@desplega.ai/agent-swarm 1.165.0 → 1.167.0

package/src/tests/enabled-tools.test.ts

@@ -0,0 +1,269 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { closeDb, createAgent, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
+import { validateConfigValue } from "../be/swarm-config-guard";
+import {
+  _resetAutoReloadForTests,
+  flushPendingIntegrationsReload,
+  loadGlobalConfigsIntoEnv,
+} from "../http/core";
+import { handleMcp } from "../http/mcp";
+import { createServer } from "../server";
+import { parseEnabledTools } from "../utils/enabled-tools";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-enabled-tools.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+async function toolNames(opts: Parameters<typeof createServer>[0]): Promise<string[]> {
+  const server = (await createServer(opts)) as unknown as {
+    _registeredTools: Record<string, unknown>;
+  };
+  return Object.keys(server._registeredTools).sort();
+}
+
+function parseMcpPayload(text: string): unknown {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("event:") || trimmed.startsWith("data:")) {
+    return JSON.parse(
+      trimmed
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trim())
+        .join("\n"),
+    );
+  }
+  return JSON.parse(trimmed);
+}
+
+let httpServer: Server;
+let baseUrl: string;
+let savedEnv: string | undefined;
+let savedCapabilities: string | undefined;
+
+async function mcpPost(agentId: string, body: Record<string, unknown>, sessionId?: string) {
+  const headers: Record<string, string> = {
+    Accept: "application/json, text/event-stream",
+    "Content-Type": "application/json",
+    "X-Agent-ID": agentId,
+  };
+  if (sessionId) headers["mcp-session-id"] = sessionId;
+  const response = await fetch(`${baseUrl}/mcp`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  return { response, payload: text ? parseMcpPayload(text) : null };
+}
+
+async function listSessionTools(agentId: string): Promise<string[]> {
+  const init = await mcpPost(agentId, {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: "2024-11-05",
+      clientInfo: { name: "enabled-tools", version: "1" },
+      capabilities: {},
+    },
+  });
+  const sessionId = init.response.headers.get("mcp-session-id");
+  if (!sessionId) throw new Error("missing MCP session ID");
+  await mcpPost(agentId, { jsonrpc: "2.0", method: "notifications/initialized" }, sessionId);
+  const listed = await mcpPost(
+    agentId,
+    { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} },
+    sessionId,
+  );
+  return (listed.payload as { result: { tools: Array<{ name: string }> } }).result.tools
+    .map((tool) => tool.name)
+    .sort();
+}
+
+beforeAll(async () => {
+  // Drain any config reload a previous suite left queued (see
+  // scripts-only-gating.test.ts) before touching the global config rows.
+  const originalSlackDisable = process.env.SLACK_DISABLE;
+  process.env.SLACK_DISABLE = "true";
+  await flushPendingIntegrationsReload();
+  _resetAutoReloadForTests();
+  if (originalSlackDisable === undefined) delete process.env.SLACK_DISABLE;
+  else process.env.SLACK_DISABLE = originalSlackDisable;
+
+  await removeDbFiles(TEST_DB_PATH);
+  closeDb();
+  initDb(TEST_DB_PATH);
+
+  const transports: Record<string, StreamableHTTPServerTransport> = {};
+  const sessionAgents: Record<string, string> = {};
+  httpServer = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    if (await handleMcp(req, res, transports, {}, sessionAgents)) return;
+    res.writeHead(404);
+    res.end("Not Found");
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(httpServer, "127.0.0.1")}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => httpServer.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(() => {
+  savedEnv = process.env.SWARM_ENABLED_TOOLS;
+  delete process.env.SWARM_ENABLED_TOOLS;
+  // Pin the default capability set; worker containers export their own.
+  savedCapabilities = process.env.CAPABILITIES;
+  delete process.env.CAPABILITIES;
+});
+
+afterEach(async () => {
+  await getDbClient().run("DELETE FROM swarm_config WHERE key = 'SWARM_ENABLED_TOOLS'");
+  // Un-inject the global row so it cannot leak into later suites.
+  await loadGlobalConfigsIntoEnv(true);
+  if (savedEnv === undefined) delete process.env.SWARM_ENABLED_TOOLS;
+  else process.env.SWARM_ENABLED_TOOLS = savedEnv;
+  if (savedCapabilities === undefined) delete process.env.CAPABILITIES;
+  else process.env.CAPABILITIES = savedCapabilities;
+});
+
+describe("parseEnabledTools", () => {
+  test.each([
+    [undefined, undefined],
+    ["", undefined],
+    ["  ", undefined],
+    [" , ,", undefined],
+    ["[]", undefined],
+    ["get-tasks, store-progress", ["get-tasks", "store-progress"]],
+    ["get-tasks,get-tasks,", ["get-tasks"]],
+    ['["get-tasks", " store-progress "]', ["get-tasks", "store-progress"]],
+  ] as Array<[string | undefined, string[] | undefined]>)("parses %#", (value, expected) => {
+    expect(parseEnabledTools(value)).toEqual(expected);
+  });
+
+  test("rejects a JSON value that is not an array of strings", () => {
+    expect(() => parseEnabledTools("[1, 2]")).toThrow();
+    expect(() => parseEnabledTools("[not json")).toThrow();
+    expect(validateConfigValue("SWARM_ENABLED_TOOLS", "[1]")).toContain("SWARM_ENABLED_TOOLS");
+    expect(validateConfigValue("SWARM_ENABLED_TOOLS", "get-tasks,nope")).toBeNull();
+  });
+});
+
+describe("SWARM_ENABLED_TOOLS on the MCP server", () => {
+  test("unset keeps the capability-driven surface", async () => {
+    const unset = await toolNames({});
+    expect(unset).toContain("send-task");
+    // messaging is a default-disabled capability
+    expect(unset).not.toContain("post-message");
+    expect(await toolNames({ enabledTools: undefined })).toEqual(unset);
+  });
+
+  test("set registers exactly the listed tools, ignoring capabilities", async () => {
+    expect(await toolNames({ enabledTools: "get-tasks, post-message" })).toEqual([
+      "get-tasks",
+      "post-message",
+    ]);
+  });
+
+  test("reads the deployment env when no session value is passed", async () => {
+    process.env.SWARM_ENABLED_TOOLS = "store-progress";
+    expect(await toolNames({})).toEqual(["store-progress"]);
+  });
+
+  test("overrides scripts-only mode", async () => {
+    expect(await toolNames({ scriptsOnly: true, enabledTools: "get-tasks" })).toEqual([
+      "get-tasks",
+    ]);
+  });
+
+  test("does not affect the full-surface bridge server", async () => {
+    const tools = await toolNames({ fullSurface: true, enabledTools: "get-tasks" });
+    expect(tools).toContain("post-message");
+    expect(tools.length).toBeGreaterThan(1);
+  });
+
+  test("warns once on unknown names and keeps the known ones", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const value = "get-tasks, no-such-tool-a1, no-such-tool-b2";
+      expect(await toolNames({ enabledTools: value })).toEqual(["get-tasks"]);
+      await toolNames({ enabledTools: value });
+      const messages = warn.mock.calls.map((call) => String(call[0]));
+      const unknown = messages.filter((m) => m.includes("unknown tools"));
+      expect(unknown).toEqual([
+        "[MCP] SWARM_ENABLED_TOOLS names unknown tools, ignoring them: no-such-tool-a1, no-such-tool-b2",
+      ]);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("an empty value logs and behaves as unset", async () => {
+    const unset = await toolNames({});
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      expect(await toolNames({ enabledTools: " , " })).toEqual(unset);
+      expect(await toolNames({ enabledTools: "" })).toEqual(unset);
+      expect(
+        warn.mock.calls.some((call) => String(call[0]).includes("lists no tools; ignoring it")),
+      ).toBe(true);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("an agent-scoped value beats the swarm-wide one, per session", async () => {
+    const scoped = await createAgent({ name: "allowlist-agent", isLead: false, status: "idle" });
+    const neighbor = await createAgent({
+      name: "allowlist-neighbor",
+      isLead: false,
+      status: "idle",
+    });
+    await upsertSwarmConfig({ scope: "global", key: "SWARM_ENABLED_TOOLS", value: "get-tasks" });
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: scoped.id,
+      key: "SWARM_ENABLED_TOOLS",
+      value: "store-progress,post-message",
+    });
+
+    expect(await listSessionTools(scoped.id)).toEqual(["post-message", "store-progress"]);
+    expect(await listSessionTools(neighbor.id)).toEqual(["get-tasks"]);
+
+    // Reloadable: a config change applies on the next session, no restart.
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: scoped.id,
+      key: "SWARM_ENABLED_TOOLS",
+      value: "store-progress",
+    });
+    expect(await listSessionTools(scoped.id)).toEqual(["store-progress"]);
+  });
+});

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/entrypoint-codex-oauth-seed.test.ts

@@ -119,6 +119,7 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
   test(
     "blanks refresh_token for a flat {access,refresh,accountId,expires} input",
     async () => {
+      const before = Math.floor(Date.now() / 1000) * 1000;
       const result = (await runJqFilter(filter, {
         access: "example-access-tok",
         refresh: "example-live-refresh-tok",
@@ -126,6 +127,8 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
         expires: 1_800_000_000_000,
       })) as {
         auth_mode: string;
+        last_refresh: string;
+        expires: number;
         tokens: {
           id_token: string;
           access_token: string;
@@ -139,6 +142,9 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
       expect(result.tokens.id_token).toBe("example-access-tok");
       expect(result.tokens.access_token).toBe("example-access-tok");
       expect(result.tokens.account_id).toBe("acct-456");
+      expect(Date.parse(result.last_refresh)).toBeGreaterThanOrEqual(before);
+      expect(Date.parse(result.last_refresh)).toBeLessThanOrEqual(Date.now());
+      expect(result.expires).toBe(1_800_000_000_000);
     },
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
@@ -182,6 +188,7 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
   test(
     "preserves refresh_token (from the flat `refresh` field) for a flat input on the standalone path",
     async () => {
+      const before = Math.floor(Date.now() / 1000) * 1000;
       const result = (await runJqFilter(
         filter,
         {
@@ -193,9 +200,14 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
         true,
       )) as {
         tokens: { refresh_token: string };
+        last_refresh: string;
+        expires: number;
       };
 
       expect(result.tokens.refresh_token).toBe("example-live-refresh-tok");
+      expect(Date.parse(result.last_refresh)).toBeGreaterThanOrEqual(before);
+      expect(Date.parse(result.last_refresh)).toBeLessThanOrEqual(Date.now());
+      expect(result.expires).toBe(1_800_000_000_000);
     },
     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");
+  });
+});