@desplega.ai/agent-swarm 1.166.0 → 1.168.0

package/src/tests/acp-adapter.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, spyOn, test } from "bun:test";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Usage } from "@agentclientprotocol/sdk";
@@ -64,20 +64,29 @@ function baseConfig(overrides: Partial<ProviderSessionConfig> = {}): ProviderSes
 
 /**
  * Start a minimal swarm API stub that handles POST /api/sessions/tokens and
- * DELETE /api/sessions/tokens/:id. Returns the server and its base URL.
- * The caller is responsible for closing the server.
+ * DELETE /api/sessions/tokens/:id. Returns its base URL and `close()`, which
+ * the caller must await. The adapter revokes a minted token fire-and-forget,
+ * so closing before that DELETE lands fails it and leaks a revoke warning
+ * into a later test.
  */
 async function startTokenStubServer(
   tokenId: string,
   plaintext: string,
-): Promise<{ server: Server; apiUrl: string }> {
+): Promise<{ apiUrl: string; close: () => Promise<void> }> {
+  let minted = false;
+  let resolveRevoked!: () => void;
+  const revoked = new Promise<void>((resolve) => {
+    resolveRevoked = resolve;
+  });
   const stub = createServer(async (req: IncomingMessage, res: ServerResponse) => {
     if (req.method === "POST" && req.url === "/api/sessions/tokens") {
+      minted = true;
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ tokenId, plaintext }));
     } else if (req.method === "DELETE" && req.url?.startsWith("/api/sessions/tokens/")) {
       res.writeHead(204);
       res.end();
+      resolveRevoked();
     } else {
       res.writeHead(404);
       res.end();
@@ -85,7 +94,13 @@ async function startTokenStubServer(
   });
   await new Promise<void>((resolve) => stub.listen(0, "127.0.0.1", resolve));
   const addr = stub.address() as import("net").AddressInfo;
-  return { server: stub, apiUrl: `http://127.0.0.1:${addr.port}` };
+  const close = async () => {
+    // A minted token is always revoked; wait for it, bounded so a failed test
+    // still tears down.
+    if (minted) await Promise.race([revoked, Bun.sleep(5_000)]);
+    await new Promise<void>((resolve) => stub.close(() => resolve()));
+  };
+  return { apiUrl: `http://127.0.0.1:${addr.port}`, close };
 }
 
 describe("ACPAdapter", () => {
@@ -305,7 +320,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
 `,
     );
 
-    const { server: tokenStub, apiUrl } = await startTokenStubServer(
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
       "stub-token-id",
       "aseph_stubtokenfortest1234567890",
     );
@@ -503,7 +518,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
         closeDb();
       }
     } finally {
-      await new Promise<void>((resolve) => tokenStub.close(() => resolve()));
+      await closeTokenStub();
     }
   });
 
@@ -537,10 +552,132 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
       ),
     ).toMatchObject({
       OPENAI_API_KEY: "example-test-key",
-      OPENCODE_CONFIG_CONTENT: JSON.stringify({ theme: "dark", model: "opencode/model" }),
+      OPENCODE_CONFIG_CONTENT: JSON.stringify({
+        theme: "dark",
+        model: "opencode/model",
+        provider: {
+          openrouter: {
+            options: {
+              headers: {
+                "HTTP-Referer": "https://agent-swarm.dev",
+                "X-OpenRouter-Title": "Agent Swarm",
+                "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+                "X-Title": "Agent Swarm",
+              },
+            },
+          },
+        },
+      }),
     });
   });
 
+  test("OpenCode preset merges the OpenRouter gateway with model and provider config", () => {
+    const config = baseConfig({
+      model: " openrouter/openai/gpt-4o-mini ",
+      env: {
+        ACP_TARGET: "opencode",
+        OPENROUTER_BASE_URL: " http://127.0.0.1:8080/api/v1/ ",
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          theme: "dark",
+          provider: { openrouter: { options: { apiKey: "dummy" } } },
+        }),
+      },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!)).toEqual({
+      theme: "dark",
+      model: "openrouter/openai/gpt-4o-mini",
+      provider: {
+        openrouter: { options: { apiKey: "dummy", baseURL: "http://127.0.0.1:8080/api/v1" } },
+      },
+    });
+  });
+
+  test("OpenCode preset omits gateway override for unset, blank, or default URL", () => {
+    for (const url of [undefined, "", "https://openrouter.ai/api/v1/"]) {
+      const config = baseConfig({
+        env: { ACP_TARGET: "opencode", OPENROUTER_BASE_URL: url },
+      });
+      const env = resolveAcpTarget(config).env(config);
+      const content = JSON.parse(env.OPENCODE_CONFIG_CONTENT!);
+      expect(content).toEqual({
+        model: config.model,
+        provider: {
+          openrouter: {
+            options: {
+              headers: {
+                "HTTP-Referer": "https://agent-swarm.dev",
+                "X-OpenRouter-Title": "Agent Swarm",
+                "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+                "X-Title": "Agent Swarm",
+              },
+            },
+          },
+        },
+      });
+      expect(content.provider.openrouter.options.baseURL).toBeUndefined();
+    }
+  });
+
+  test("OpenCode preset adds attribution headers to OPENCODE_CONFIG_CONTENT for an OpenRouter host", () => {
+    const config = baseConfig({
+      model: "",
+      env: {
+        ACP_TARGET: "opencode",
+        OPENROUTER_BASE_URL: "https://openrouter.ai/api/v1",
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          theme: "dark",
+          provider: { openrouter: { options: { headers: { "X-Custom": "preserved" } } } },
+        }),
+      },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!)).toEqual({
+      theme: "dark",
+      provider: {
+        openrouter: {
+          options: {
+            headers: {
+              "X-Custom": "preserved",
+              "HTTP-Referer": "https://agent-swarm.dev",
+              "X-OpenRouter-Title": "Agent Swarm",
+              "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+              "X-Title": "Agent Swarm",
+            },
+          },
+        },
+      },
+    });
+  });
+
+  test("OpenCode preset leaves OPENCODE_CONFIG_CONTENT unchanged when attribution is disabled", () => {
+    const content = JSON.stringify({
+      theme: "dark",
+      provider: { openrouter: { options: { headers: { "X-Custom": "preserved" } } } },
+    });
+    const config = baseConfig({
+      model: "",
+      env: {
+        ACP_TARGET: "opencode",
+        OPENROUTER_BASE_URL: "https://openrouter.ai/api/v1",
+        OPENROUTER_APP_ATTRIBUTION: "false",
+        OPENCODE_CONFIG_CONTENT: content,
+      },
+    });
+    expect(resolveAcpTarget(config).env(config).OPENCODE_CONFIG_CONTENT).toBe(content);
+  });
+
+  test("OpenCode preset injects gateway even without a model fallback", () => {
+    const config = baseConfig({
+      model: "",
+      env: { ACP_TARGET: "opencode", OPENROUTER_BASE_URL: "http://127.0.0.1:8080/api/v1" },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider.openrouter.options.baseURL).toBe(
+      "http://127.0.0.1:8080/api/v1",
+    );
+  });
+
   test("Gemini preset supplies command, credentials, trust, and a model environment fallback", () => {
     const config = baseConfig({
       model: "gemini-3-flash-preview",
@@ -687,7 +824,10 @@ new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
     chmodSync(copilotStub, 0o755);
     mkdirSync(join(binDir, "home"));
 
-    const { server, apiUrl } = await startTokenStubServer("copilot-token-id", "example-aseph_x");
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
+      "copilot-token-id",
+      "example-aseph_x",
+    );
     try {
       const config = baseConfig({
         cwd,
@@ -721,7 +861,7 @@ new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
       while (existsSync(captured.dir) && Date.now() < deadline) await Bun.sleep(10);
       expect(existsSync(captured.dir)).toBe(false);
     } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()));
+      await closeTokenStub();
     }
   });
 
@@ -1077,7 +1217,7 @@ const stream = ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(proce
 new AgentSideConnection((connection) => new FakeAgent(connection), stream);
 `,
     );
-    const { server: tokenStub, apiUrl } = await startTokenStubServer(
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
       "stub-token-id",
       "aseph_stubtokenfortest1234567890",
     );
@@ -1140,7 +1280,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
         closeDb();
       }
     } finally {
-      await new Promise<void>((resolve) => tokenStub.close(() => resolve()));
+      await closeTokenStub();
     }
   });
 });

package/src/tests/ci-unit-test-report.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { buildPayload, parseJunit } from "../../scripts/ci-unit-test-report";
+
+// Shape emitted by `bun test --reporter=junit` (bun 1.4): one testsuite per file,
+// nested testsuites per describe, and attribute values XML-escaped.
+const JUNIT = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="bun test" tests="6" assertions="5" failures="1" skipped="2" time="0.3">
+  <testsuite name="src/a.test.ts" file="src/a.test.ts" tests="4" failures="1" skipped="1" time="0.2">
+    <testsuite name="outer" file="src/a.test.ts" line="3" tests="4" time="0">
+      <testsuite name="inner &amp; &quot;nested&quot;" file="src/a.test.ts" line="4" tests="2" time="0">
+        <testcase name="slow one" classname="inner" time="0.120" file="src/a.test.ts" line="5" assertions="1" />
+        <testcase name="breaks &lt;sometimes&gt;" classname="inner" time="0.004" file="src/a.test.ts" line="6" assertions="1">
+          <failure type="AssertionError" message="expect(received).toBe(expected)&#10;">AssertionError&#10;</failure>
+        </testcase>
+      </testsuite>
+      <testcase name="fast" classname="outer" time="0.000010" file="src/a.test.ts" line="8" assertions="1" />
+      <testcase name="later" classname="outer" time="0" file="src/a.test.ts" line="9" assertions="0">
+        <skipped message="TODO" />
+      </testcase>
+    </testsuite>
+  </testsuite>
+  <testsuite name="src/b.test.ts" file="src/b.test.ts" tests="2" failures="0" skipped="1" time="0.1">
+    <testcase name="top level" classname="" time="0.06" file="src/b.test.ts" line="2" assertions="2" />
+    <testcase name="skipped" classname="" time="0" file="src/b.test.ts" line="3" assertions="0">
+      <skipped />
+    </testcase>
+  </testsuite>
+</testsuites>`;
+
+describe("ci-unit-test-report", () => {
+  test("parses describe chains, statuses, durations and XML entities", () => {
+    expect(parseJunit(JUNIT)).toEqual([
+      {
+        file: "src/a.test.ts",
+        name: 'outer > inner & "nested" > slow one',
+        ms: 120,
+        status: "pass",
+      },
+      {
+        file: "src/a.test.ts",
+        name: 'outer > inner & "nested" > breaks <sometimes>',
+        ms: 4,
+        status: "fail",
+      },
+      { file: "src/a.test.ts", name: "outer > fast", ms: 0, status: "pass" },
+      { file: "src/a.test.ts", name: "outer > later", ms: 0, status: "skip" },
+      { file: "src/b.test.ts", name: "top level", ms: 60, status: "pass" },
+      { file: "src/b.test.ts", name: "skipped", ms: 0, status: "skip" },
+    ]);
+  });
+
+  test("keeps every non-pass and every test at or above minMs, with per-file totals", () => {
+    const payload = buildPayload(parseJunit(JUNIT), new Map([["src/a.test.ts", "abc123"]]), 50);
+    expect(payload.totals).toEqual({ tests: 6, pass: 3, fail: 1, skip: 2, testMs: 184 });
+    expect(payload.files).toEqual([
+      ["src/a.test.ts", "abc123", 4, 1, 124],
+      ["src/b.test.ts", null, 2, 0, 60],
+    ]);
+    expect(payload.tests).toEqual([
+      [0, 'outer > inner & "nested" > slow one', 120, "p"],
+      [0, 'outer > inner & "nested" > breaks <sometimes>', 4, "f"],
+      [0, "outer > later", 0, "s"],
+      [1, "top level", 60, "p"],
+      [1, "skipped", 0, "s"],
+    ]);
+  });
+
+  test("an empty report parses to no tests", () => {
+    expect(
+      parseJunit('<?xml version="1.0"?><testsuites name="bun test" tests="0"></testsuites>'),
+    ).toEqual([]);
+  });
+});

package/src/tests/claude-background-keepalive-wiring.test.ts

@@ -0,0 +1,220 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { appendFile, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ClaudeAdapter } from "../providers/claude-adapter";
+import { BACKGROUND_KEEPALIVE_INTERVAL_MS } from "../providers/claude-background-keepalive";
+import type { ProviderResult, ProviderSession, ProviderSessionConfig } from "../providers/types";
+import { CHILD_PROCESS_TEST_BUDGET_MS } from "./test-proc";
+
+// These tests go through ClaudeAdapter.createSession, so they cover the wiring
+// in each transport: observe() on every parsed message and stop() at teardown.
+// A fake Claude binary ends its turn and goes silent; a local server records the
+// session heartbeats the keepalive sends while it waits.
+
+const fixturePath = join(import.meta.dir, "claude-background-keepalive.fixture.ts");
+const TICK_MS = 20;
+
+// The keepalive pings every 60s. Run its interval at TICK_MS instead; every
+// other timer keeps its real period.
+const realSetInterval = globalThis.setInterval;
+beforeAll(() => {
+  globalThis.setInterval = ((handler: TimerHandler, timeout?: number, ...rest: unknown[]) =>
+    realSetInterval(
+      handler,
+      timeout === BACKGROUND_KEEPALIVE_INTERVAL_MS ? TICK_MS : timeout,
+      ...rest,
+    )) as typeof setInterval;
+});
+afterAll(() => {
+  globalThis.setInterval = realSetInterval;
+});
+
+const heartbeats = new Map<string, number>();
+const server = Bun.serve({
+  port: 0,
+  fetch(req) {
+    const match = new URL(req.url).pathname.match(/^\/api\/active-sessions\/heartbeat\/(.+)$/);
+    if (req.method === "PUT" && match?.[1]) {
+      const taskId = decodeURIComponent(match[1]);
+      heartbeats.set(taskId, (heartbeats.get(taskId) ?? 0) + 1);
+    }
+    return Response.json({ updated: true });
+  },
+});
+afterAll(() => server.stop(true));
+
+const temporaryDirectories: string[] = [];
+let originalHome: string | undefined;
+
+beforeEach(async () => {
+  // Every session seeds Claude trust into `$HOME/.claude.json`; keep that off the real home.
+  originalHome = process.env.HOME;
+  const home = await mkdtemp(join(tmpdir(), "claude-bg-keepalive-home-"));
+  temporaryDirectories.push(home);
+  process.env.HOME = home;
+});
+
+afterEach(async () => {
+  if (originalHome === undefined) delete process.env.HOME;
+  else process.env.HOME = originalHome;
+  await Promise.all(
+    temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+});
+
+type Transport = "cli" | "sdk";
+
+interface Harness {
+  session: ProviderSession;
+  taskId: string;
+  send(command: "empty" | "exit" | "fail"): Promise<void>;
+  count(): number;
+  completed(): boolean;
+  turnEnded(): Promise<void>;
+}
+
+async function startSession(transport: Transport, withBackgroundTask: boolean): Promise<Harness> {
+  const directory = await mkdtemp(join(tmpdir(), "claude-bg-keepalive-"));
+  temporaryDirectories.push(directory);
+  const controlFile = join(directory, "control");
+  const logFile = join(directory, "session.jsonl");
+  const taskId = crypto.randomUUID();
+  const config: ProviderSessionConfig = {
+    prompt: "wait on the background job",
+    systemPrompt: "",
+    model: "claude-haiku-4-5",
+    role: "worker",
+    agentId: crypto.randomUUID(),
+    taskId,
+    apiUrl: `http://127.0.0.1:${server.port}`,
+    apiKey: "test-key",
+    cwd: directory,
+    logFile,
+    env: {
+      PATH: process.env.PATH ?? "/usr/bin:/bin",
+      CLAUDE_CODE_OAUTH_TOKEN: "example-fixture-oauth-token",
+      CLAUDE_TRANSPORT: transport,
+      CLAUDE_BINARY: `${process.execPath} ${fixturePath}`,
+      BG_FIXTURE_TRANSPORT: transport,
+      BG_FIXTURE_CONTROL: controlFile,
+      BG_FIXTURE_BACKGROUND: withBackgroundTask ? "1" : "0",
+    },
+  };
+  const session = await new ClaudeAdapter(async () => {}).createSession(config);
+  let completed = false;
+  void session.waitForCompletion().finally(() => {
+    completed = true;
+  });
+  return {
+    session,
+    taskId,
+    completed: () => completed,
+    send: (command) => appendFile(controlFile, `${command}\n`),
+    count: () => heartbeats.get(taskId) ?? 0,
+    // Both transports log every protocol line; the result line marks the end of the turn.
+    turnEnded: () =>
+      waitFor(async () => {
+        const file = Bun.file(logFile);
+        return (await file.exists()) && (await file.text()).includes('"type":"result"');
+      }, "the fixture's result message"),
+  };
+}
+
+async function waitFor(
+  condition: () => boolean | Promise<boolean>,
+  what: string,
+  timeoutMs = 5_000,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!(await condition())) {
+    if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${what}`);
+    await Bun.sleep(TICK_MS / 2);
+  }
+}
+
+/** Waits out in-flight requests, then asserts no further heartbeat arrives. */
+async function expectHeartbeatsStopped(harness: Harness): Promise<void> {
+  await Bun.sleep(TICK_MS * 3);
+  const settled = harness.count();
+  await Bun.sleep(TICK_MS * 8);
+  expect(harness.count()).toBe(settled);
+}
+
+async function liveSessionWithHeartbeats(transport: Transport): Promise<Harness> {
+  const harness = await startSession(transport, true);
+  await harness.turnEnded();
+  // The turn is over and the process is silent; only the keepalive is sending.
+  await waitFor(() => harness.count() >= 3, "keepalive heartbeats after the turn ended");
+  return harness;
+}
+
+describe.each(["cli", "sdk"] as const)("Claude %s transport background keepalive", (transport) => {
+  test(
+    "heartbeats while a background task stays live after the turn ends, and stops when the set empties",
+    async () => {
+      const harness = await liveSessionWithHeartbeats(transport);
+      try {
+        await harness.send("empty");
+        await expectHeartbeatsStopped(harness);
+        // The session is still running: the empty set stopped the pings, not teardown.
+        expect(harness.completed()).toBe(false);
+      } finally {
+        await harness.send("exit");
+        await harness.session.waitForCompletion();
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "normal end stops the keepalive",
+    async () => {
+      const harness = await liveSessionWithHeartbeats(transport);
+      await harness.send("exit");
+      const result = await harness.session.waitForCompletion();
+      expect(result.isError).toBe(false);
+      await expectHeartbeatsStopped(harness);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "error end stops the keepalive",
+    async () => {
+      const harness = await liveSessionWithHeartbeats(transport);
+      await harness.send("fail");
+      const result: ProviderResult = await harness.session.waitForCompletion();
+      expect(result.exitCode).not.toBe(0);
+      await expectHeartbeatsStopped(harness);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "abort stops the keepalive",
+    async () => {
+      const harness = await liveSessionWithHeartbeats(transport);
+      await harness.session.abort();
+      await harness.session.waitForCompletion();
+      await expectHeartbeatsStopped(harness);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "a session with no background work sends no keepalive heartbeats",
+    async () => {
+      const harness = await startSession(transport, false);
+      try {
+        await harness.turnEnded();
+        await Bun.sleep(TICK_MS * 10);
+        expect(harness.count()).toBe(0);
+      } finally {
+        await harness.send("exit");
+        await harness.session.waitForCompletion();
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});