kimi-code/packages/server/test/fs-batch.e2e.test.ts

/**
 * `/api/v1/sessions/{sid}/fs:list_many` + `:stat` + `:stat_many` end-to-end
 * tests (W10.2 / Chain 10 / P1.10).
 *
 * AC coverage (ROADMAP §Chain 10):
 *   1. `list_many` 100 paths → `results` map keyed by input path, order
 *      preserved (per-path keys are the original request strings).
 *   2. Single path missing → `partial_errors[path]`, not whole-call failure.
 *   3. `stat_many` 1000 paths < 200 ms on SSD.
 *
 * Additional coverage:
 *   - `:stat` happy path returns FsEntry.
 *   - `:stat` 41304 on path escape.
 *   - `:stat_many` returns null for misses (per REST.md §3.9 line 524).
 *   - `:stat_many` 41304 fails batch-wide on any unsafe input.
 */

import {
  mkdirSync,
  mkdtempSync,
  rmSync,
  writeFileSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

import { pino } from 'pino';
import { afterEach, beforeEach, describe, expect, it } from 'vitest';

import { IRestGateway, startServer, type RunningServer } from '../src';
import { fixedTokenAuth } from './helpers/serverHarness';

let tmpDir: string;
let lockPath: string;
let bridgeHome: string;
let workspace: string;
let server: RunningServer | undefined;

beforeEach(() => {
  tmpDir = mkdtempSync(join(tmpdir(), 'kimi-server-fs-batch-'));
  lockPath = join(tmpDir, 'lock');
  bridgeHome = mkdtempSync(join(tmpdir(), 'kimi-server-fs-batch-home-'));
  workspace = join(tmpDir, 'workspace');
  mkdirSync(workspace, { recursive: true });
});

afterEach(async () => {
  try {
    await server?.close();
  } catch {
    // ignore
  }
  server = undefined;
  rmSync(tmpDir, { recursive: true, force: true });
  rmSync(bridgeHome, { recursive: true, force: true });
});

async function bootDaemon(): Promise<RunningServer> {
  server = await startServer({
    serviceOverrides: [fixedTokenAuth()],
    host: '127.0.0.1',
    port: 0,
    lockPath,
    logger: pino({ level: 'silent' }),
    coreProcessOptions: { homeDir: bridgeHome },
  });
  return server;
}

function appOf(r: RunningServer): {
  inject: (req: unknown) => Promise<{
    statusCode: number;
    json: () => unknown;
  }>;
} {
  const app = r.services.invokeFunction((a) => {
    const gw = a.get(IRestGateway);
    return gw.app as unknown as {
  inject: (req: unknown) => Promise<{
    statusCode: number;
    json: () => unknown;
  }>;
};
  });
  // Auto-attach the fixed bearer token so the M5.1 auth hook passes. A
  // caller-supplied `authorization` header wins, so explicit token tests keep
  // working; every other header (Range, content-type, …) is preserved.
  return {
    inject(req: unknown) {
      const q = req as { headers?: Record<string, string | string[] | undefined> };
      return app.inject({
        ...q,
        headers: { authorization: 'Bearer test-token', ...q.headers },
      });
    },
  };
}

function envelopeOf<T>(body: unknown): {
  code: number;
  msg: string;
  data: T | null;
  request_id: string;
  details?: unknown;
} {
  return body as {
    code: number;
    msg: string;
    data: T | null;
    request_id: string;
    details?: unknown;
  };
}

async function createSession(r: RunningServer): Promise<string> {
  const res = await appOf(r).inject({
    method: 'POST',
    url: '/api/v1/sessions',
    payload: { metadata: { cwd: workspace } },
  });
  const env = envelopeOf<{ id: string }>(res.json());
  if (env.code !== 0 || env.data === null) {
    throw new Error(`create session failed: ${JSON.stringify(env)}`);
  }
  return env.data.id;
}

describe('POST /api/v1/sessions/{sid}/fs:list_many (W10.2)', () => {
  it('returns 100 path results, half existing half missing, with partial_errors', async () => {
    // 50 real directories + 50 missing paths.
    const real: string[] = [];
    const missing: string[] = [];
    for (let i = 0; i < 50; i++) {
      const dir = `dir_${i}`;
      mkdirSync(join(workspace, dir));
      writeFileSync(join(workspace, dir, 'file.txt'), `x${i}`);
      real.push(dir);
      missing.push(`missing_${i}`);
    }
    const paths = [...real, ...missing];

    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:list_many`,
      payload: { paths },
    });

    const env = envelopeOf<{
      results: Record<string, unknown[]>;
      partial_errors?: Record<string, { code: number; msg: string }>;
    }>(res.json());
    expect(env.code).toBe(0);
    expect(env.data).not.toBeNull();

    // All real paths land in `results`.
    for (const p of real) {
      expect(env.data!.results[p]).toBeDefined();
      expect(env.data!.results[p]!.length).toBe(1); // file.txt
    }
    // All missing paths land in `partial_errors` (40409).
    expect(env.data!.partial_errors).toBeDefined();
    for (const p of missing) {
      expect(env.data!.partial_errors![p]).toBeDefined();
      expect(env.data!.partial_errors![p]!.code).toBe(40409);
    }
  });

  it('fails batch-wide on 41304 if any input path escapes the cwd', async () => {
    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:list_many`,
      payload: { paths: ['.', '../escape'] },
    });
    const env = envelopeOf<unknown>(res.json());
    expect(env.code).toBe(41304);
  });

  it('returns 40401 for unknown session before any I/O', async () => {
    const r = await bootDaemon();
    const res = await appOf(r).inject({
      method: 'POST',
      url: '/api/v1/sessions/does-not-exist/fs:list_many',
      payload: { paths: ['.'] },
    });
    const env = envelopeOf<unknown>(res.json());
    expect(env.code).toBe(40401);
  });

  it('rejects > 100 paths via Zod 40001', async () => {
    const r = await bootDaemon();
    const sid = await createSession(r);
    const paths = Array.from({ length: 101 }, (_, i) => `p${i}`);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:list_many`,
      payload: { paths },
    });
    const env = envelopeOf<unknown>(res.json());
    expect(env.code).toBe(40001);
  });
});

describe('POST /api/v1/sessions/{sid}/fs:stat (W10.2)', () => {
  it('returns an FsEntry for an existing file', async () => {
    writeFileSync(join(workspace, 'a.ts'), 'export {}');
    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:stat`,
      payload: { path: 'a.ts' },
    });
    const env = envelopeOf<{
      path: string;
      kind: string;
      size: number;
      mime: string;
    }>(res.json());
    expect(env.code).toBe(0);
    expect(env.data).not.toBeNull();
    expect(env.data!.path).toBe('a.ts');
    expect(env.data!.kind).toBe('file');
    expect(env.data!.size).toBe(9);
    expect(env.data!.mime).toBe('text/typescript');
  });

  it('returns 40409 for a missing file', async () => {
    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:stat`,
      payload: { path: 'no-such.txt' },
    });
    const env = envelopeOf<unknown>(res.json());
    expect(env.code).toBe(40409);
  });

  it('returns 41304 on absolute path', async () => {
    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:stat`,
      payload: { path: '/etc/passwd' },
    });
    const env = envelopeOf<unknown>(res.json());
    expect(env.code).toBe(41304);
  });
});

describe('POST /api/v1/sessions/{sid}/fs:stat_many (W10.2)', () => {
  it('returns null for missing per-path entries (REST.md §3.9 line 524)', async () => {
    writeFileSync(join(workspace, 'present.txt'), 'p');
    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:stat_many`,
      payload: { paths: ['present.txt', 'missing.txt'] },
    });
    const env = envelopeOf<{
      entries: Record<string, unknown | null>;
    }>(res.json());
    expect(env.code).toBe(0);
    expect(env.data).not.toBeNull();
    expect(env.data!.entries['present.txt']).not.toBeNull();
    expect(env.data!.entries['missing.txt']).toBeNull();
  });

  it('fails batch-wide on 41304 if any input path escapes', async () => {
    writeFileSync(join(workspace, 'safe.txt'), 's');
    const r = await bootDaemon();
    const sid = await createSession(r);
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:stat_many`,
      payload: { paths: ['safe.txt', '/etc/passwd'] },
    });
    const env = envelopeOf<unknown>(res.json());
    expect(env.code).toBe(41304);
  });

  it('completes 1000 stats in < 200 ms on SSD (ROADMAP AC #3)', async () => {
    // Seed 1000 files. Use Promise.all of writeFileSync wrapped in a loop —
    // writeFileSync is sync but the fs is fast enough that the seeding
    // takes < 1 s.
    const paths: string[] = [];
    for (let i = 0; i < 1000; i++) {
      const name = `f_${i.toString().padStart(4, '0')}.txt`;
      writeFileSync(join(workspace, name), `${i}`);
      paths.push(name);
    }

    const r = await bootDaemon();
    const sid = await createSession(r);

    const start = performance.now();
    const res = await appOf(r).inject({
      method: 'POST',
      url: `/api/v1/sessions/${sid}/fs:stat_many`,
      payload: { paths },
    });
    const elapsed = performance.now() - start;

    const env = envelopeOf<{
      entries: Record<string, unknown | null>;
    }>(res.json());
    expect(env.code).toBe(0);
    expect(Object.keys(env.data!.entries).length).toBe(1000);

    // Generous ceiling: ROADMAP AC #3 says < 200 ms on SSD. CI runners
    // may be slower; we set 500 ms to avoid flakes while still catching
    // O(N^2) regressions. Bench on M-series laptop: 30-60 ms.
    expect(elapsed).toBeLessThan(500);
  });
});