@desplega.ai/agent-swarm 1.165.0 → 1.166.0

package/src/tests/codex-oauth-device.test.ts

@@ -1,15 +1,8 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { createServer, type Server } from "node:http";
 import { decryptSecret, encryptSecret, getEncryptionKey } from "../be/crypto";
-import {
-  closeDb,
-  getDbClient,
-  getKv,
-  getSwarmConfigs,
-  initDb,
-  upsertKv,
-  upsertSwarmConfig,
-} from "../be/db";
+import { closeDb, getDbClient, getSwarmConfigs, initDb, upsertSwarmConfig } from "../be/db";
+import { getCodexDeviceFlow, upsertCodexDeviceFlow } from "../be/db/codex-oauth-device-flows";
 import type { OnboardingState } from "../be/onboarding";
 import { handleCodexOAuthDevice } from "../http/codex-oauth-device";
 import { handleCore } from "../http/core";
@@ -97,7 +90,7 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await getDbClient().run("DELETE FROM kv_entries");
+  await getDbClient().run("DELETE FROM codex_oauth_device_flows");
   await getDbClient().run("DELETE FROM swarm_config");
   fetchImpl = async () => {
     throw new Error("Unexpected fetch");
@@ -221,8 +214,8 @@ describe("Codex device HTTP routes", () => {
 
     const started = await startFlow();
     expect(Number.isNaN(Date.parse(started.expiresAt))).toBe(false);
-    const encrypted = await getKv("codex-oauth-device", started.flowId);
-    expect(encrypted?.value).not.toContain("device-auth-full");
+    const encrypted = await getCodexDeviceFlow(started.flowId);
+    expect(encrypted?.state).not.toContain("device-auth-full");
 
     const poll = await request(`/api/codex-oauth/device/${started.flowId}/poll`);
     expect(await poll.json()).toEqual({ status: "complete", slot: 1 });
@@ -318,17 +311,15 @@ describe("Codex device HTTP routes", () => {
     const secondResponse = await request(path);
     const secondBody = await secondResponse.json();
     const callsBeforeRelease = { pollCalls, exchangeCalls };
-    const entry = await getKv("codex-oauth-device", started.flowId);
-    const state = JSON.parse(decryptSecret(String(entry!.value), getEncryptionKey())) as Record<
+    const entry = await getCodexDeviceFlow(started.flowId);
+    const state = JSON.parse(decryptSecret(entry!.state, getEncryptionKey())) as Record<
       string,
       unknown
     >;
     state.pollLeaseExpiresAt = Date.now() - 1;
-    await upsertKv({
-      namespace: "codex-oauth-device",
-      key: started.flowId,
-      value: encryptSecret(JSON.stringify(state), getEncryptionKey()),
-      valueType: "string",
+    await upsertCodexDeviceFlow({
+      flowId: started.flowId,
+      state: encryptSecret(JSON.stringify(state), getEncryptionKey()),
       expiresAt: Number(state.expiresAt),
     });
     releaseExchange();
@@ -359,19 +350,17 @@ describe("Codex device HTTP routes", () => {
     }) as typeof fetch;
 
     const started = await startFlow();
-    const entry = await getKv("codex-oauth-device", started.flowId);
-    const state = JSON.parse(decryptSecret(String(entry!.value), getEncryptionKey())) as Record<
+    const entry = await getCodexDeviceFlow(started.flowId);
+    const state = JSON.parse(decryptSecret(entry!.state, getEncryptionKey())) as Record<
       string,
       unknown
     >;
     state.lastPolledAt = Date.now() - 10_000;
     state.pollLeaseId = crypto.randomUUID();
     state.pollLeaseExpiresAt = Date.now() - 1;
-    await upsertKv({
-      namespace: "codex-oauth-device",
-      key: started.flowId,
-      value: encryptSecret(JSON.stringify(state), getEncryptionKey()),
-      valueType: "string",
+    await upsertCodexDeviceFlow({
+      flowId: started.flowId,
+      state: encryptSecret(JSON.stringify(state), getEncryptionKey()),
       expiresAt: Number(state.expiresAt),
     });
 
@@ -380,9 +369,9 @@ describe("Codex device HTTP routes", () => {
     });
     expect(pollCalls).toBe(1);
 
-    const recovered = await getKv("codex-oauth-device", started.flowId);
+    const recovered = await getCodexDeviceFlow(started.flowId);
     const recoveredState = JSON.parse(
-      decryptSecret(String(recovered!.value), getEncryptionKey()),
+      decryptSecret(recovered!.state, getEncryptionKey()),
     ) as Record<string, unknown>;
     expect(recoveredState.pollLeaseId).toBeNull();
     expect(recoveredState.pollLeaseExpiresAt).toBeNull();
@@ -403,17 +392,15 @@ describe("Codex device HTTP routes", () => {
     }) as typeof fetch;
 
     const started = await startFlow();
-    const entry = await getKv("codex-oauth-device", started.flowId);
-    const state = JSON.parse(decryptSecret(String(entry!.value), getEncryptionKey())) as Record<
+    const entry = await getCodexDeviceFlow(started.flowId);
+    const state = JSON.parse(decryptSecret(entry!.state, getEncryptionKey())) as Record<
       string,
       unknown
     >;
     state.expiresAt = Date.now() - 1;
-    await upsertKv({
-      namespace: "codex-oauth-device",
-      key: started.flowId,
-      value: encryptSecret(JSON.stringify(state), getEncryptionKey()),
-      valueType: "string",
+    await upsertCodexDeviceFlow({
+      flowId: started.flowId,
+      state: encryptSecret(JSON.stringify(state), getEncryptionKey()),
       expiresAt: Number(state.expiresAt),
     });
 
@@ -482,8 +469,7 @@ describe("Codex device HTTP routes", () => {
     }) as typeof fetch;
     await getDbClient().run(
       `CREATE TRIGGER fail_device_flow_write
-       BEFORE INSERT ON kv_entries
-       WHEN NEW.namespace = 'codex-oauth-device'
+       BEFORE INSERT ON codex_oauth_device_flows
        BEGIN
          SELECT RAISE(ABORT, 'forced local write failure');
        END`,

package/src/tests/db-query-denylist.test.ts

@@ -0,0 +1,202 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer as createHttpServer, type Server } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { closeDb, getDb, initDb, upsertKv } from "../be/db";
+import { upsertCodexDeviceFlow } from "../be/db/codex-oauth-device-flows";
+import {
+  DbQueryDeniedTableError,
+  executeReadOnlyQueryGated,
+  handleDbQuery,
+} from "../http/db-query";
+import { executeReadOnlyQuery } from "../http/db-query-shared";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+// A real on-disk database: the bounded path spawns a child process that opens
+// its own connection, so an in-memory test template would be invisible to it.
+const DB_PATH = join(tmpdir(), `db-query-denylist-${process.pid}-${Date.now()}.sqlite`);
+
+const testGlobals = globalThis as typeof globalThis & {
+  __testMigrationTemplate?: Uint8Array;
+};
+let savedTemplate: Uint8Array | undefined;
+
+// Built at runtime so no secret-shaped literal lands in the repo.
+const syntheticToken = () => `gh${"p"}_${"K".repeat(36)}`;
+
+async function removeDb(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await Bun.file(`${DB_PATH}${suffix}`).delete();
+    } catch {}
+  }
+}
+
+beforeAll(async () => {
+  savedTemplate = testGlobals.__testMigrationTemplate;
+  testGlobals.__testMigrationTemplate = undefined;
+  closeDb();
+  await removeDb();
+  initDb(DB_PATH);
+  const db = getDb();
+  db.run("CREATE VIEW denylist_test_view AS SELECT * FROM oauth_authorizations");
+  db.run("CREATE TABLE denylist_test_notes (id INTEGER PRIMARY KEY, body TEXT)");
+  db.run("INSERT INTO denylist_test_notes (body) VALUES (?)", [
+    `deploy used ${syntheticToken()} from the env dump`,
+  ]);
+});
+
+afterAll(async () => {
+  closeDb();
+  testGlobals.__testMigrationTemplate = savedTemplate;
+  await removeDb();
+});
+
+const DENIED_QUERIES: Array<[string, string, string]> = [
+  ["direct read", "SELECT * FROM oauth_authorizations", "oauth_authorizations"],
+  ["alias", "SELECT a.accessToken FROM oauth_authorizations AS a", "oauth_authorizations"],
+  ["CTE", "WITH t AS (SELECT * FROM oauth_authorizations) SELECT * FROM t", "oauth_authorizations"],
+  [
+    "join",
+    "SELECT n.body, p.codeVerifier FROM denylist_test_notes n JOIN oauth_pending p ON 1 = 1",
+    "oauth_pending",
+  ],
+  ["subquery", "SELECT * FROM (SELECT * FROM user_tokens)", "user_tokens"],
+  ["view", "SELECT * FROM denylist_test_view", "oauth_authorizations"],
+  ["scalar subquery", "SELECT (SELECT clientSecret FROM oauth_apps LIMIT 1) AS s", "oauth_apps"],
+  ["count only", "SELECT COUNT(*) FROM session_tokens", "session_tokens"],
+  ["mixed case", "select * from Script_Apis", "script_apis"],
+];
+
+describe("db-query credential-table denylist", () => {
+  for (const [label, sql, table] of DENIED_QUERIES) {
+    test(`in-process path rejects a ${label}`, () => {
+      expect(() => executeReadOnlyQuery(sql)).toThrow(DbQueryDeniedTableError);
+      expect(() => executeReadOnlyQuery(sql)).toThrow(table);
+    });
+  }
+
+  test("bounded path rejects before spawning a child", async () => {
+    for (const [, sql, table] of DENIED_QUERIES) {
+      await expect(executeReadOnlyQueryGated(sql, [], 5_000, 10)).rejects.toThrow(table);
+    }
+  });
+
+  test("allows swarm_config, EXPLAIN and a table name in a string literal", async () => {
+    const config = await executeReadOnlyQueryGated("SELECT key FROM swarm_config", [], 5_000, 10);
+    expect(config.columns).toEqual(["key"]);
+
+    const explained = executeReadOnlyQuery("EXPLAIN QUERY PLAN SELECT * FROM oauth_authorizations");
+    expect(explained.columns.length).toBeGreaterThan(0);
+
+    const literal = executeReadOnlyQuery("SELECT 'oauth_authorizations' AS name");
+    expect(literal.rows).toEqual([["oauth_authorizations"]]);
+  });
+});
+
+describe("POST /api/db-query", () => {
+  let server: Server;
+  let baseUrl = "";
+
+  beforeAll(async () => {
+    server = createHttpServer(async (req, res) => {
+      const handled = await handleDbQuery(
+        req,
+        res,
+        getPathSegments(req.url || ""),
+        parseQueryParams(req.url || ""),
+      );
+      if (!handled) {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    baseUrl = `http://localhost:${await listenOnFreePort(server)}`;
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  });
+
+  async function post(sql: string) {
+    const res = await fetch(`${baseUrl}/api/db-query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sql }),
+    });
+    return { status: res.status, body: (await res.json()) as Record<string, unknown> };
+  }
+
+  test("rejects a credential table with a clear 400", async () => {
+    const { status, body } = await post("SELECT * FROM oauth_authorizations");
+    expect(status).toBe(400);
+    expect(String(body.error)).toContain("oauth_authorizations");
+    expect(String(body.error)).toContain("credentials");
+  });
+
+  test("redacts a secret stored in an allowed table and keeps the context", async () => {
+    const { status, body } = await post("SELECT body FROM denylist_test_notes");
+    expect(status).toBe(200);
+    const serialized = JSON.stringify(body.rows);
+    expect(serialized).not.toContain(syntheticToken());
+    expect(serialized).toContain("[REDACTED:");
+    expect(serialized).toContain("from the env dump");
+  });
+
+  test("denies Codex device-login state and keeps general KV readable", async () => {
+    const marker = `device-state-${crypto.randomUUID()}`;
+    await upsertCodexDeviceFlow({
+      flowId: crypto.randomUUID(),
+      state: marker,
+      expiresAt: Date.now() + 60_000,
+    });
+    await upsertKv({
+      namespace: "denylist-test",
+      key: "note",
+      value: "plain kv value",
+      valueType: "string",
+    });
+
+    for (const sql of [
+      "SELECT * FROM codex_oauth_device_flows",
+      "SELECT f.state FROM codex_oauth_device_flows f JOIN kv_entries k ON 1",
+    ]) {
+      const { status, body } = await post(sql);
+      expect(status).toBe(400);
+      expect(String(body.error)).toContain("codex_oauth_device_flows");
+      expect(JSON.stringify(body)).not.toContain(marker);
+    }
+
+    const kv = await post("SELECT namespace, value FROM kv_entries");
+    expect(kv.status).toBe(200);
+    const rows = JSON.stringify(kv.body.rows);
+    expect(rows).toContain("plain kv value");
+    expect(rows).not.toContain("codex-oauth-device");
+    expect(rows).not.toContain(marker);
+  });
+
+  test("migration 202 moves legacy kv device flows out of kv_entries", async () => {
+    const flowId = crypto.randomUUID();
+    const marker = `legacy-state-${crypto.randomUUID()}`;
+    await upsertKv({
+      namespace: "codex-oauth-device",
+      key: flowId,
+      value: marker,
+      valueType: "string",
+      expiresAt: Date.now() + 60_000,
+    });
+    const migration = await Bun.file(
+      join(import.meta.dir, "../be/migrations/202_codex_oauth_device_flows.sql"),
+    ).text();
+    getDb().exec(migration);
+
+    const kv = await post("SELECT key FROM kv_entries WHERE namespace = 'codex-oauth-device'");
+    expect(kv.status).toBe(200);
+    expect(kv.body.rows).toEqual([]);
+    const moved = getDb()
+      .query("SELECT state FROM codex_oauth_device_flows WHERE flow_id = ?")
+      .get(flowId) as { state: string } | null;
+    expect(moved?.state).toBe(marker);
+  });
+});

package/src/tests/db-task-read-contract.test.ts

@@ -357,6 +357,7 @@ value:getScheduledTaskByName
 value:getScheduledTasks
 value:getScriptRun
 value:getScriptRunByIdempotencyKey
+value:getScriptRunExecutionArgs
 value:getScriptRunJournalStep
 value:getServiceByAgentAndName
 value:getServiceById

package/src/tests/db-task-write-contract.test.ts

@@ -380,6 +380,7 @@ value:getScheduledTaskByName
 value:getScheduledTasks
 value:getScriptRun
 value:getScriptRunByIdempotencyKey
+value:getScriptRunExecutionArgs
 value:getScriptRunJournalStep
 value:getServiceByAgentAndName
 value:getServiceById

package/src/tests/entrypoint-acp-target-binary.test.ts

@@ -44,6 +44,7 @@ const STUB_BINARIES = [
   "codex",
   "opencode",
   "gemini",
+  "copilot",
   "dsh",
   "acp-target-stub",
   "acp target stub",
@@ -142,6 +143,35 @@ describe("docker-entrypoint.sh: acp target binary verification", () => {
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
 
+  test(
+    "resolves the copilot catalog target to the copilot binary",
+    async () => {
+      const result = await runChain({ HARNESS_PROVIDER: "acp", ACP_TARGET: "copilot" });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain("ACP target: ");
+      expect(result.stdout).toContain("ACP_TARGET='copilot'");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "fails boot with an install hint when the copilot binary is missing",
+    async () => {
+      // No stub dir on PATH, so `copilot` cannot resolve.
+      const result = await runChain({
+        HARNESS_PROVIDER: "acp",
+        ACP_TARGET: "copilot",
+        PATH: "/usr/bin:/bin",
+      });
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stdout).toContain("FATAL: ACP target binary not found: 'copilot'");
+      expect(result.stdout).toContain("npm install -g @github/copilot");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
   test(
     "resolves a custom target supplied as a command string with argv",
     async () => {
@@ -191,7 +221,7 @@ describe("docker-entrypoint.sh: acp target binary verification", () => {
 
       expect(result.exitCode).not.toBe(0);
       expect(result.stdout).toContain(
-        "FATAL: unsupported ACP target 'gemini-cli'. Supported targets: opencode, gemini, custom.",
+        "FATAL: unsupported ACP target 'gemini-cli'. Supported targets: opencode, gemini, copilot, custom.",
       );
     },
     CHILD_PROCESS_TEST_BUDGET_MS,

package/src/tests/events-scrub.test.ts

@@ -0,0 +1,88 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDbClient, initDb } from "../be/db";
+import { createEvent, createEventsBatch } from "../be/events";
+import { randomToken, syntheticSecret } from "./synthetic-secret-helpers";
+
+const TEST_DB_PATH = "./test-events-scrub.sqlite";
+
+beforeAll(async () => {
+  try {
+    await unlink(TEST_DB_PATH);
+  } catch {}
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+async function readData(sessionId: string): Promise<string[]> {
+  const rows = await getDbClient().query<{ data: string | null }>(
+    "SELECT data FROM events WHERE sessionId = ? ORDER BY rowid",
+    [sessionId],
+  );
+  return rows.map((r) => r.data ?? "");
+}
+
+describe("events.data scrub at write", () => {
+  test("createEvent redacts a secret in the payload and keeps valid JSON", async () => {
+    const pat = ["ghp", randomToken(36)].join("_");
+    const sessionId = crypto.randomUUID();
+    await createEvent({
+      category: "session",
+      event: "session.start",
+      source: "api",
+      sessionId,
+      data: { note: "cloned repo with token", output: `remote: ${pat} ok`, count: 3 },
+    });
+
+    const [raw] = await readData(sessionId);
+    expect(raw).toBeDefined();
+    expect(raw).not.toContain(pat);
+    expect(raw).toContain("[REDACTED:");
+    const parsed = JSON.parse(raw as string);
+    expect(parsed.note).toBe("cloned repo with token");
+    expect(parsed.output).toStartWith("remote: ");
+    expect(parsed.output).toEndWith(" ok");
+    expect(parsed.count).toBe(3);
+  });
+
+  test("createEventsBatch redacts every row and keeps valid JSON", async () => {
+    // Registered per test: the preload clears volatile secrets after each one.
+    const known = syntheticSecret("evscrub");
+    const sessionId = crypto.randomUUID();
+    const count = await createEventsBatch([
+      {
+        category: "tool",
+        event: "tool.start",
+        source: "worker",
+        sessionId,
+        data: { tool: "Bash", input: `echo ${known.value}` },
+      },
+      {
+        category: "tool",
+        event: "tool.end",
+        source: "worker",
+        sessionId,
+        data: { tool: "Bash", nested: { lines: ["first", `leaked ${known.value} here`] } },
+      },
+    ]);
+    expect(count).toBe(2);
+
+    const rows = await readData(sessionId);
+    expect(rows).toHaveLength(2);
+    for (const raw of rows) {
+      expect(raw).not.toContain(known.value);
+      expect(raw).toContain(`[REDACTED:${known.name}]`);
+      expect(JSON.parse(raw).tool).toBe("Bash");
+    }
+    expect(JSON.parse(rows[0] as string).input).toStartWith("echo ");
+    expect(JSON.parse(rows[1] as string).nested.lines[0]).toBe("first");
+  });
+});