@desplega.ai/agent-swarm 1.165.0 → 1.167.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/codex-oauth.test.ts

@@ -355,6 +355,7 @@ describe("credentialsToAuthJson", () => {
       accountId: "c724a178-abc",
     };
 
+    const before = Date.now();
     const authJson = credentialsToAuthJson(creds);
     expect(authJson.auth_mode).toBe("chatgpt");
     expect(authJson.OPENAI_API_KEY).toBeNull();
@@ -362,7 +363,9 @@ describe("credentialsToAuthJson", () => {
     expect(authJson.tokens.refresh_token).toBe(creds.refresh);
     expect(authJson.tokens.account_id).toBe(creds.accountId);
     expect(authJson.tokens.id_token).toBe(creds.access);
-    expect(authJson.last_refresh).toBe(new Date(creds.expires).toISOString());
+    expect(Date.parse(authJson.last_refresh)).toBeGreaterThanOrEqual(before);
+    expect(Date.parse(authJson.last_refresh)).toBeLessThanOrEqual(Date.now());
+    expect(authJson.expires).toBe(creds.expires);
   });
 });
 

package/src/tests/context-window.test.ts

@@ -32,9 +32,9 @@ describe("getContextWindowSize", () => {
     expect(getContextWindowSize("sonnet")).toBe(1_000_000);
   });
 
-  test("returns 200K for haiku models", () => {
+  test("returns 200K for Haiku 4.5 and 1M for the haiku shortname (Haiku 5.5)", () => {
     expect(getContextWindowSize("claude-haiku-4-5")).toBe(200_000);
-    expect(getContextWindowSize("haiku")).toBe(200_000);
+    expect(getContextWindowSize("haiku")).toBe(1_000_000);
   });
 
   test("reads OpenAI windows from the catalog", () => {

package/src/tests/credential-check.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, mock, test } from "bun:test";
 import {
   buildCredStatusReport,
+  CREDENTIAL_PROVIDER_CHECKERS,
   checkProviderCredentials,
   isBedrockMode,
   isCredCheckDisabled,
@@ -8,6 +9,7 @@ import {
   shouldRefreshBedrockStatus,
   validateProviderCredentials,
 } from "../commands/provider-credentials";
+import { ACP_TARGET_IDS } from "../providers/acp-target-catalog";
 import { checkClaudeCredentials } from "../providers/claude-adapter";
 import { checkClaudeManagedCredentials } from "../providers/claude-managed-adapter";
 import { checkCodexCredentials } from "../providers/codex-adapter";
@@ -660,6 +662,54 @@ describe("checkOpencodeCredentials", () => {
   });
 });
 
+describe("ACP readiness", () => {
+  test.each(["typo", "", " \t "])("rejects unsupported target %j", async (target) => {
+    const status = await checkProviderCredentials("acp", {
+      ACP_TARGET: target,
+      ACP_TARGET_COMMAND: "custom-acp --stdio",
+    });
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["ACP_TARGET"]);
+    expect(status.hint).toContain("ACP_TARGET");
+    for (const supported of ACP_TARGET_IDS) expect(status.hint).toContain(supported);
+  });
+
+  test.each([undefined, "custom"])("requires a command for target %s", async (target) => {
+    const status = await CREDENTIAL_PROVIDER_CHECKERS.acp({ ACP_TARGET: target });
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["ACP_TARGET_COMMAND"]);
+    expect(status.hint).toContain("ACP_TARGET_COMMAND");
+    expect(status.hint).toContain("ACP_COMMAND");
+  });
+
+  test.each(["", " \t "])("rejects a blank custom command %j", async (command) => {
+    const status = await checkProviderCredentials("acp", {
+      ACP_TARGET: "custom",
+      ACP_TARGET_COMMAND: command,
+      ACP_COMMAND: "legacy-acp",
+    });
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["ACP_TARGET_COMMAND"]);
+  });
+
+  test.each(["ACP_TARGET_COMMAND", "ACP_COMMAND"])("accepts a command from %s", async (key) => {
+    for (const target of [undefined, "custom"]) {
+      const status = await checkProviderCredentials("acp", {
+        ACP_TARGET: target,
+        [key]: "custom-acp --stdio",
+      });
+      expect(status).toEqual({ ready: true, missing: [], satisfiedBy: "sdk-delegated" });
+    }
+  });
+
+  test.each(
+    ACP_TARGET_IDS.filter((target) => target !== "custom"),
+  )("keeps preset %s ready without a custom command", async (target) => {
+    const status = await checkProviderCredentials("acp", { ACP_TARGET: target });
+    expect(status).toEqual({ ready: true, missing: [], satisfiedBy: "sdk-delegated" });
+  });
+});
+
 // ─── dispatcher ──────────────────────────────────────────────────────────────
 
 describe("checkProviderCredentials dispatcher", () => {
@@ -720,7 +770,7 @@ describe("checkProviderCredentials dispatcher", () => {
       ).ready,
     ).toBe(true);
 
-    const acpStatus = await checkProviderCredentials("acp", {});
+    const acpStatus = await checkProviderCredentials("acp", { ACP_TARGET: "opencode" });
     expect(acpStatus.ready).toBe(true);
     expect(acpStatus.satisfiedBy).toBe("sdk-delegated");
   });

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/dsh-adapter.test.ts

@@ -9,7 +9,10 @@ import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
 import { DEFAULT_MODEL_TIER_MAP } from "../types";
 import { getModelAwareCredentialVars } from "../utils/credentials";
 import { resolveHarnessProvider } from "../utils/harness-provider";
-import { DEFAULT_OPENROUTER_BASE_URL } from "../utils/openrouter-base-url";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  OPENROUTER_APP_ATTRIBUTION_HEADERS,
+} from "../utils/openrouter-base-url";
 
 const directories: string[] = [];
 afterEach(async () => {
@@ -166,6 +169,7 @@ describe("dsh harness", () => {
             openrouter: {
               apiKeyEnv: "OPENROUTER_API_KEY",
               baseURL: DEFAULT_OPENROUTER_BASE_URL,
+              headers: OPENROUTER_APP_ATTRIBUTION_HEADERS,
               api: "openai-completions",
               models: [{ id: modelId }],
             },
@@ -316,6 +320,24 @@ describe("dsh harness", () => {
       model: "deepseek/deepseek-v4.1-flash",
     });
     expect(patch[2].config.providers.openrouter.baseURL).toBe("https://gateway.example/proxy/v1");
+    // A gateway gets no OpenRouter app attribution.
+    expect(patch[2].config.providers.openrouter).not.toHaveProperty("headers");
+  });
+
+  test("OPENROUTER_APP_ATTRIBUTION=false drops the attribution headers", async () => {
+    const config = await fixture();
+    config.model = "openrouter/vendor/new-model";
+    config.env = {
+      ...config.env,
+      DEEPSEEK_API_KEY: "",
+      OPENROUTER_API_KEY: "openrouter-test-key",
+      OPENROUTER_APP_ATTRIBUTION: "false",
+    };
+    const session = await new DshAdapter().createSession(config);
+    expect((await session.waitForCompletion()).isError).toBe(false);
+    const { patch } = await Bun.file(join(config.cwd, "invocation.json")).json();
+    expect(patch[2].config.providers.openrouter.baseURL).toBe(DEFAULT_OPENROUTER_BASE_URL);
+    expect(patch[2].config.providers.openrouter).not.toHaveProperty("headers");
   });
 
   test("bare models keep direct DeepSeek when both keys exist", async () => {