Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.3 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { connect } from "node:net";

import { clearEnginePoolForConfig, computeEngineConfigFingerprint, type EngineSpawnTemplate } from "./engine-pool.js";
import type { ManagedOpencodeServer } from "./managed-opencode.js";
import { createEnginePoolForConfig, registerTrustedOpencodeProcess, startServer } from "./server.js";
import type { ServerConfig } from "./types.js";

/**
 * The merged engine event stream must keep quiet-but-healthy connections
 * attestable: SSE comments are invisible to SSE parsers (they only yield
 * frames with data lines), so the keepalive has to be a data-bearing
 * heartbeat event. Otherwise the renderer's stale-stream watchdog cannot
 * tell a healthy silent stream from a dead socket and churns reconnects.
 */

type Served = { port: number; stop: (closeActiveConnections?: boolean) => void | Promise<void> };

const stops: Array<() => void | Promise<void>> = [];
const roots: string[] = [];
const savedEnv = new Map<string, string | undefined>();

afterEach(async () => {
  while (stops.length) await stops.pop()?.();
  while (roots.length) await rm(roots.pop()!, { recursive: true, force: true });
  for (const [name, value] of savedEnv) {
    if (value === undefined) delete process.env[name];
    else process.env[name] = value;
  }
  savedEnv.clear();
});

function setEnv(name: string, value: string): void {
  if (!savedEnv.has(name)) savedEnv.set(name, process.env[name]);
  process.env[name] = value;
}

function startMockEngine(eventBody?: () => ReadableStream<Uint8Array>) {
  const server = Bun.serve({
    hostname: "127.0.0.1",
    port: 0,
    fetch(request) {
      const url = new URL(request.url);
      if (url.pathname === "/event" && eventBody) {
        return new Response(eventBody(), { headers: { "content-type": "text/event-stream" } });
      }
      if (url.pathname === "/event") {
        // Held open and silent like a real engine between task events; ends
        // when the proxy aborts it after its client disconnects.
        const body = new ReadableStream({
          start(controller) {
            controller.enqueue(new TextEncoder().encode("data: {}\n\n"));
          },
        });
        return new Response(body, { headers: { "content-type": "text/event-stream" } });
      }
      if (url.pathname === "/session/status") return Response.json({});
      if (url.pathname === "/session") return Response.json([]);
      if (url.pathname === "/mcp") return Response.json({});
      if (url.pathname === "/instance/dispose") return Response.json({ disposed: true });
      return Response.json({ code: "not_found", message: "Not found" }, { status: 404 });
    },
  }) as Served & { port: number };
  stops.push(() => server.stop(true));
  return { url: `http://127.0.0.1:${server.port}` };
}

function syntheticManagedHandle(url: string): ManagedOpencodeServer {
  return {
    url,
    username: "event-heartbeat-user",
    password: "event-heartbeat-pass",
    pid: null,
    execution: { command: "opencode", args: [], cwd: "/", env: [] },
    isAlive: () => true,
    close: async () => undefined,
  };
}

async function startPooledOmniRushServer(input: { root: string; engineUrl: string }) {
  const config: ServerConfig = {
    host: "127.0.0.1",
    port: 0,
    token: "owt_test_token",
    hostToken: "owt_host_token",
    approval: { mode: "auto", timeoutMs: 1000 },
    corsOrigins: ["*"],
    workspaces: [{
      id: "ws_heartbeat",
      name: "Heartbeat",
      path: input.root,
      preset: "starter",
      workspaceType: "local",
      baseUrl: input.engineUrl,
    }],
    authorizedRoots: [input.root],
    readOnly: false,
    startedAt: Date.now(),
    tokenSource: "cli",
    hostTokenSource: "cli",
    logFormat: "pretty",
    logRequests: false,
  };
  registerTrustedOpencodeProcess(config, {
    baseUrl: input.engineUrl,
    identity: "test-event-heartbeat",
    isAlive: () => true,
  });
  const runtimeConfigPath = join(input.root, ".opencode", "runtime-config.json");
  await writeFile(runtimeConfigPath, "{}\n", "utf8");
  const template: EngineSpawnTemplate = {
    cwd: input.root,
    runtimeConfigPath,
    env: {},
    reservedPorts: () => [],
  };
  const pool = createEnginePoolForConfig({
    config,
    template,
    handle: syntheticManagedHandle(input.engineUrl),
    fingerprint: await computeEngineConfigFingerprint(template),
    registryId: null,
    trustedIdentity: null,
  });
  stops.push(async () => {
    clearEnginePoolForConfig(config);
    await pool.disposeAll();
  });
  const server = await startServer(config) as Served;
  stops.push(() => server.stop(true));
  return { base: `http://127.0.0.1:${server.port}`, token: config.token };
}

describe("engine event stream heartbeat", () => {
  test("emits data-bearing heartbeats on a quiet stream instead of SSE comments", async () => {
    setEnv("OMNIRUSH_ENGINE_EVENT_HEARTBEAT_MS", "50");
    const root = await mkdtemp(join(tmpdir(), "omnirush-event-heartbeat-"));
    roots.push(root);
    await mkdir(join(root, ".opencode"), { recursive: true });
    const engine = startMockEngine();
    const omnirush = await startPooledOmniRushServer({ root, engineUrl: engine.url });

    const controller = new AbortController();
    const response = await fetch(`${omnirush.base}/workspace/ws_heartbeat/opencode/event`, {
      headers: { Authorization: `Bearer ${omnirush.token}`, Accept: "text/event-stream" },
      signal: controller.signal,
    });
    expect(response.status).toBe(200);
    expect(response.headers.get("content-type")).toContain("text/event-stream");

    const reader = response.body!.getReader();
    const decoder = new TextDecoder();
    let buffered = "";
    const deadline = Date.now() + 3_000;
    let heartbeats = 0;
    while (Date.now() < deadline && heartbeats < 2) {
      const chunk = await Promise.race([
        reader.read(),
        new Promise<null>((resolve) => setTimeout(() => resolve(null), 250)),
      ]);
      if (chunk === null) continue;
      if (chunk.done) break;
      buffered += decoder.decode(chunk.value, { stream: true });
      heartbeats = (buffered.match(/data: \{"type":"server\.heartbeat"\}/g) ?? []).length;
    }
    controller.abort();
    await reader.cancel().catch(() => undefined);

    // Two heartbeats prove a periodic signal, not a one-shot frame. Comment
    // keepalives would be dropped by SSE parsers before any liveness
    // tracking, so none may remain.
    expect(heartbeats).toBeGreaterThanOrEqual(2);
    expect(buffered).not.toContain(": ping");
  }, 20_000);

  test("closes the stream of a client that stopped reading instead of queueing every event", async () => {
    const root = await mkdtemp(join(tmpdir(), "omnirush-event-backlog-"));
    roots.push(root);
    await mkdir(join(root, ".opencode"), { recursive: true });
    const frame = new TextEncoder().encode(`data: ${JSON.stringify({ type: "message.part.updated", properties: { text: "x".repeat(1024 * 1024) } })}\n\n`);
    let sent = 0;
    const engine = startMockEngine(() => new ReadableStream<Uint8Array>({
      pull(controller) {
        if (sent < 200) { sent += 1; controller.enqueue(frame); }
      },
    }));
    const omnirush = await startPooledOmniRushServer({ root, engineUrl: engine.url });
    const warnings: string[] = [];
    const warn = console.warn;
    console.warn = (...args: unknown[]) => { warnings.push(args.map(String).join(" ")); };
    // A window that never reads (frozen): its socket is paused after the request.
    const port = Number(new URL(omnirush.base).port);
    const socket = connect(port, "127.0.0.1", () => {
      socket.write(`GET /workspace/ws_heartbeat/opencode/event HTTP/1.1\r\nhost: x\r\nauthorization: Bearer ${omnirush.token}\r\naccept: text/event-stream\r\n\r\n`);
      socket.pause();
    });
    socket.on("error", () => undefined);
    try {
      const deadline = Date.now() + 15_000;
      while (Date.now() < deadline && !warnings.some((line) => line.includes("client stopped reading"))) await Bun.sleep(50);
      expect(warnings.some((line) => line.includes("client stopped reading"))).toBe(true);
      // Cut near the cap, not after the whole turn's events were queued.
      expect(sent).toBeLessThan(200);
    } finally {
      console.warn = warn;
      socket.destroy();
    }
  }, 30_000);
});