Function boot

packages/server/test/helpers/serverHarness.ts:135–223

(opts: BootOptions = {})

 * binds to `127.0.0.1:0` by default, and tracks the result for `closeAll()`.
 */
export async function boot(opts: BootOptions = {}): Promise<ServerHarness> {
  const token = opts.token ?? DEFAULT_TOKEN;
  const host = opts.host ?? '127.0.0.1';
  const port = opts.port ?? 0;
  // Inject a fixed-token `IAuthTokenService` by default so harness-based tests
  // stay transparent (`authedFetch` / `authedWs` already carry `test-token`).
  // The fixed impl is placed FIRST so an explicit caller-supplied
  // `IAuthTokenService` override still wins (serviceOverrides are last-wins).
  const serviceOverrides: ServerStartOptions['serviceOverrides'] = [
    fixedTokenAuth(token),
    ...(opts.serviceOverrides ?? []),
  ];

  const tmpDir = mkdtempSync(join(tmpdir(), 'kimi-server-harness-'));
  const homeDir = mkdtempSync(join(tmpdir(), 'kimi-server-harness-home-'));
  const lockPath = join(tmpDir, 'lock');

  const server = await startServer({
    host,
    port,
    lockPath,
    serviceOverrides,
    logger: pino({ level: 'silent' }),
    coreProcessOptions: { homeDir },
  });

  const httpPort = deriveHttpPort(server.address);
  const baseUrl = `http://${host}:${httpPort}`;
  const wsUrl = `ws://${host}:${httpPort}/api/v1/ws`;

  const sockets = new Set<WebSocket>();
  let closed = false;

  const harness: ServerHarness = {
    server,
    address: server.address,
    baseUrl,
    wsUrl,
    token,

    authedFetch(path: string, init: RequestInit = {}): Promise<Response> {
      const headers = new Headers(init.headers);
      // Caller-supplied Authorization wins on conflict.
      if (!headers.has('Authorization')) {
        headers.set('Authorization', `Bearer ${token}`);
      }
      return fetch(`${baseUrl}${path}`, { ...init, headers });
    },

    authedWs(): WebSocket {
      const ws = new WebSocket(wsUrl, [`${WS_BEARER_PROTOCOL_PREFIX}${token}`], {
        headers: { Authorization: `Bearer ${token}` },
      });
      sockets.add(ws);
      const drop = (): void => {
        sockets.delete(ws);
      };
      ws.once('close', drop);