Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
13.6 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { mkdtemp, rm, writeFile } from "node:fs/promises";
import { createServer, type Server, type ServerResponse } from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { clearEnginePoolForConfig, EnginePool, setEnginePoolForConfig } from "./engine-pool.js";
import type { ManagedOpencodeServer } from "./managed-opencode.js";
import { startServer } from "./server.js";
import type { ServerConfig, WorkspaceInfo } from "./types.js";

const ENV = {
  OMNIRUSH_ENGINE_RELOAD_RETRY_MS: "50",
  OMNIRUSH_ENGINE_DRAIN_TIMEOUT_MS: "5000",
  OMNIRUSH_ENGINE_DRAIN_POLL_MS: "100",
  OMNIRUSH_ENGINE_MIN_SPAWN_INTERVAL_MS: "0",
};

type FakeEngine = {
  handle: ManagedOpencodeServer;
  aborted: string[];
  setBusy: (sessionIds: string[]) => void;
  emit: (sessionId: string) => void;
  isClosed: () => boolean;
  stop: () => Promise<void>;
};

type Fixture = {
  engineA: FakeEngine;
  pool: EnginePool;
  serverBaseUrl: string;
  spawnCount: () => number;
  releaseDrain: () => void;
  releaseProviderList: () => void;
};

const savedEnv = new Map<string, string | undefined>();
const engines: FakeEngine[] = [];
let root: string | null = null;
let poolToDispose: EnginePool | null = null;
let configToClear: ServerConfig | null = null;
let serverToStop: (() => void | Promise<void>) | null = null;
let denToStop: (() => void | Promise<void>) | null = null;
let heartbeat: ReturnType<typeof setInterval> | null = null;
let fixture: Fixture | null = null;

async function startFakeEngine(): Promise<FakeEngine> {
  const busy = new Set<string>();
  const aborted: string[] = [];
  const eventClients = new Set<ServerResponse>();
  let closed = false;

  const server: Server = createServer((request, response) => {
    const url = new URL(request.url ?? "/", "http://127.0.0.1");
    if (url.pathname === "/session/status") {
      response.setHeader("content-type", "application/json");
      response.end(JSON.stringify(Object.fromEntries([...busy].map((id) => [id, { type: "busy" }]))));
      return;
    }
    if (url.pathname === "/global/event") {
      response.writeHead(200, { "content-type": "text/event-stream" });
      eventClients.add(response);
      request.on("close", () => eventClients.delete(response));
      return;
    }
    if (url.pathname === "/event") {
      response.writeHead(200, { "content-type": "text/event-stream" });
      return;
    }
    const abortMatch = url.pathname.match(/^\/session\/([^/]+)\/abort$/);
    if (abortMatch && request.method === "POST") {
      aborted.push(decodeURIComponent(abortMatch[1] ?? ""));
      response.setHeader("content-type", "application/json");
      response.end("{}");
      return;
    }
    response.setHeader("content-type", "application/json");
    response.end("{}");
  });

  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
  const address = server.address();
  if (address === null || typeof address === "string") throw new Error("fake engine failed to bind a port");
  const url = `http://127.0.0.1:${address.port}`;

  const stop = async (): Promise<void> => {
    if (closed) return;
    closed = true;
    for (const client of eventClients) client.end();
    eventClients.clear();
    server.closeAllConnections();
    await new Promise<void>((resolve) => server.close(() => resolve()));
  };

  return {
    handle: {
      url,
      username: "engine",
      password: "engine-password",
      pid: null,
      execution: { command: "fake-engine", args: [], cwd: "/", env: [] },
      isAlive: () => !closed,
      close: stop,
    },
    aborted,
    setBusy: (sessionIds) => {
      busy.clear();
      for (const id of sessionIds) busy.add(id);
    },
    emit: (sessionId) => {
      const frame = `data: ${JSON.stringify({
        directory: "/workspace",
        payload: { type: "session.updated", properties: { sessionID: sessionId } },
      })}\n\n`;
      for (const client of eventClients) client.write(frame);
    },
    isClosed: () => closed,
    stop,
  };
}

function sleep(durationMs: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, durationMs));
}

async function waitUntil(predicate: () => boolean | Promise<boolean>, timeoutMs: number): Promise<boolean> {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    if (await predicate()) return true;
    await sleep(25);
  }
  return await predicate();
}

function timeout(durationMs: number): Promise<{ status: "timeout" }> {
  return new Promise((resolve) => setTimeout(() => resolve({ status: "timeout" }), durationMs));
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function hostHeaders() {
  return { "x-omnirush-host-token": "host-token", "content-type": "application/json" };
}

function clientHeaders() {
  return { authorization: "Bearer token", "content-type": "application/json" };
}

async function readJsonObject(response: Response): Promise<Record<string, unknown>> {
  const payload: unknown = await response.json();
  if (!isRecord(payload)) throw new Error("Expected JSON object");
  return payload;
}

async function runSync(serverBaseUrl: string): Promise<Record<string, unknown>> {
  return readJsonObject(await fetch(`${serverBaseUrl}/cloud-provider-sync/run`, {
    method: "POST",
    headers: hostHeaders(),
    body: JSON.stringify({ reason: "settings_cloud_opened" }),
  }));
}

async function syncStatus(serverBaseUrl: string): Promise<Record<string, unknown>> {
  return readJsonObject(await fetch(`${serverBaseUrl}/cloud-provider-sync/status`, {
    headers: clientHeaders(),
  }));
}

function currentFixture(): Fixture {
  if (!fixture) throw new Error("fixture not initialized");
  return fixture;
}

beforeEach(async () => {
  for (const [name, value] of Object.entries(ENV)) {
    savedEnv.set(name, process.env[name]);
    process.env[name] = value;
  }

  const fixtureRoot = await mkdtemp(join(tmpdir(), "omnirush-cloud-sync-drain-"));
  root = fixtureRoot;
  savedEnv.set("OMNIRUSH_RUNTIME_DB", process.env.OMNIRUSH_RUNTIME_DB);
  savedEnv.set("OMNIRUSH_ENV_STORE", process.env.OMNIRUSH_ENV_STORE);
  process.env.OMNIRUSH_RUNTIME_DB = join(fixtureRoot, "runtime.sqlite");
  process.env.OMNIRUSH_ENV_STORE = join(fixtureRoot, "env.json");

  const engineA = await startFakeEngine();
  engines.push(engineA);
  const runtimeConfigPath = join(fixtureRoot, "runtime-opencode-config.json");
  await writeFile(runtimeConfigPath, JSON.stringify({ scenario: "initial" }));
  const workspace: WorkspaceInfo = {
    id: "ws_cloud_sync_drain",
    name: "Cloud sync drain",
    path: fixtureRoot,
    preset: "starter",
    workspaceType: "local",
    baseUrl: engineA.handle.url,
  };
  const config = {
    host: "127.0.0.1",
    port: 0,
    token: "token",
    hostToken: "host-token",
    configPath: join(fixtureRoot, "server.json"),
    approval: { mode: "auto", timeoutMs: 1_000 },
    corsOrigins: ["*"],
    workspaces: [workspace],
    authorizedRoots: [fixtureRoot],
    readOnly: false,
    startedAt: Date.now(),
    tokenSource: "cli",
    hostTokenSource: "cli",
    logFormat: "pretty",
    logRequests: false,
    opencodeBaseUrl: engineA.handle.url,
  } as ServerConfig;

  let spawnCount = 0;
  const pool = new EnginePool({
    config,
    template: {
      cwd: fixtureRoot,
      runtimeConfigPath,
      env: {},
      reservedPorts: () => [],
    },
    hooks: {
      reloadInPlace: async () => undefined,
      engineBusy: async () => true,
      postRefreshSync: async () => undefined,
      writeRuntimeConfigFile: async () => ({ path: runtimeConfigPath }),
      registerTrusted: () => undefined,
      clearTrusted: () => undefined,
      spawn: async () => {
        const engine = await startFakeEngine();
        engines.push(engine);
        spawnCount += 1;
        return engine.handle;
      },
      waitForHealthy: async () => undefined,
    },
  });
  pool.adoptPrimary({
    handle: engineA.handle,
    fingerprint: "initial-config",
    registryId: null,
    trustedIdentity: null,
  });
  poolToDispose = pool;

  engineA.setBusy(["ses_live"]);
  await writeFile(runtimeConfigPath, JSON.stringify({ scenario: "config_changed" }));
  const rollover = await pool.requestRollover({ reason: "config_changed", workspace });
  if (rollover.action !== "rolled_over" || !pool.hasDrainingGeneration() || spawnCount !== 1) {
    throw new Error(`failed to establish drain: action=${rollover.action} draining=${pool.hasDrainingGeneration()} spawns=${spawnCount}`);
  }
  heartbeat = setInterval(() => engineA.emit("ses_live"), 50);

  const provider = {
    id: "lpr_test",
    providerId: "openai-compatible",
    name: "Test provider",
    source: "custom",
    updatedAt: "2026-08-04T10:00:00.000Z",
    providerConfig: {
      env: ["TEST_PROVIDER_API_KEY"],
      npm: "@ai-sdk/openai-compatible",
      api: "https://models.example.test/api/v1",
      options: { baseURL: "https://models.example.test/api/v1" },
      whitelist: ["allowed-model"],
      blacklist: ["blocked-model"],
    },
    apiKey: "sk-test-provider",
    apiKeys: null,
    models: [{ id: "model-a", name: "Model A", config: {} }],
  };
  let markProviderListReached: () => void = () => undefined;
  const providerListReached = new Promise<void>((resolve) => {
    markProviderListReached = resolve;
  });
  let releaseProviderList: () => void = () => undefined;
  const providerListReleased = new Promise<void>((resolve) => {
    releaseProviderList = resolve;
  });
  const den = Bun.serve({
    hostname: "127.0.0.1",
    port: 0,
    async fetch(request) {
      const url = new URL(request.url);
      if (url.pathname === "/v1/llm-providers") {
        markProviderListReached();
        await providerListReleased;
        return Response.json({ llmProviders: [provider] });
      }
      if (url.pathname === `/v1/llm-providers/${provider.id}/connect`) {
        return Response.json({ llmProvider: provider });
      }
      return Response.json({ error: "not_found" }, { status: 404 });
    },
  });
  denToStop = () => den.stop(true);

  setEnginePoolForConfig(config, pool);
  configToClear = config;
  const server = await startServer(config);
  serverToStop = () => server.stop();
  const serverBaseUrl = `http://127.0.0.1:${server.port}`;
  const sessionResponse = await fetch(`${serverBaseUrl}/den-session`, {
    method: "PUT",
    headers: hostHeaders(),
    body: JSON.stringify({
      baseUrl: `http://127.0.0.1:${den.port}`,
      token: "token-a",
      orgId: "org_a",
    }),
  });
  if (sessionResponse.status !== 204) throw new Error(`failed to set Den session: ${sessionResponse.status}`);
  await providerListReached;

  fixture = {
    engineA,
    pool,
    serverBaseUrl,
    spawnCount: () => spawnCount,
    releaseDrain: () => {
      if (heartbeat) clearInterval(heartbeat);
      heartbeat = null;
      engineA.setBusy([]);
    },
    releaseProviderList,
  };
});

afterEach(async () => {
  if (heartbeat) clearInterval(heartbeat);
  heartbeat = null;
  await poolToDispose?.disposeAll().catch(() => undefined);
  poolToDispose = null;
  await serverToStop?.();
  serverToStop = null;
  await denToStop?.();
  denToStop = null;
  if (configToClear) clearEnginePoolForConfig(configToClear);
  configToClear = null;
  for (const engine of engines) await engine.stop();
  engines.length = 0;
  if (root) await rm(root, { recursive: true, force: true });
  root = null;
  fixture = null;
  for (const [name, value] of savedEnv) {
    if (value === undefined) delete process.env[name];
    else process.env[name] = value;
  }
  savedEnv.clear();
});

describe("cloud provider sync drain defer", () => {
  test("boundedRun: applies provider sync and returns with a pending deferred reload", async () => {
    const { releaseProviderList, serverBaseUrl } = currentFixture();
    const run = runSync(serverBaseUrl);
    await sleep(25);
    releaseProviderList();
    const result = await Promise.race([run, timeout(5_000)]);
    const deferredStatus = await syncStatus(serverBaseUrl);
    const lastRun = isRecord(deferredStatus.lastRun) ? deferredStatus.lastRun : {};
    const detail = isRecord(lastRun.detail) ? lastRun.detail : {};

    expect(result.status).toBe("applied");
    expect(detail.reloadDeferred).toBe(true);
    expect(deferredStatus.reloadPending).toBe(true);
  }, 10_000);

  test("drainUntouched: leaves the draining engine and its live session untouched", async () => {
    const { engineA, pool, releaseProviderList, serverBaseUrl, spawnCount } = currentFixture();
    const run = runSync(serverBaseUrl);
    await sleep(25);
    releaseProviderList();
    await Promise.race([run, timeout(5_000)]);

    expect(engineA.isClosed()).toBe(false);
    expect(engineA.aborted).toHaveLength(0);
    expect(spawnCount()).toBe(1);
    expect(pool.hasDrainingGeneration()).toBe(true);
  }, 10_000);

  test("retryLands: retries after the drain and rolls over exactly once", async () => {
    const { pool, releaseDrain, releaseProviderList, serverBaseUrl, spawnCount } = currentFixture();
    const run = runSync(serverBaseUrl);
    await sleep(25);
    releaseProviderList();
    await Promise.race([run, timeout(5_000)]);

    releaseDrain();
    const drainRetired = await waitUntil(() => !pool.hasDrainingGeneration(), 5_000);
    const retryFinished = await waitUntil(async () => (await syncStatus(serverBaseUrl)).reloadPending === false, 5_000);
    await sleep(300);
    const settledSpawnCount: number = spawnCount();
    const settledStatus = await syncStatus(serverBaseUrl);

    expect(drainRetired).toBe(true);
    expect(retryFinished).toBe(true);
    expect(settledStatus.reloadPending).toBe(false);
    expect(settledSpawnCount).toBe(2);
  }, 10_000);
});