@desplega.ai/agent-swarm 2.6.0 → 2.7.1

package/src/tests/fixtures/onboard/solo.compose.yml.txt

@@ -0,0 +1,85 @@
+# Docker Compose for Agent Swarm
+# Generated by `agent-swarm onboard`
+#
+# Usage:
+#   docker compose --env-file .env up -d
+#
+# Image version: set AGENT_SWARM_VERSION in .env to a published release.
+# Blank falls back to `latest`, which moves on every commit to main and is
+# not a release. Releases: https://github.com/desplega-ai/agent-swarm/releases
+# Upgrade/rollback (migrations are forward-only, so back up first):
+# https://github.com/desplega-ai/agent-swarm/blob/main/skills/agent-swarm/references/upgrade.md
+
+services:
+  swarm-api:
+    image: "ghcr.io/desplega-ai/agent-swarm:${AGENT_SWARM_VERSION:-latest}"
+    container_name: swarm-api
+    pull_policy: always
+    stop_grace_period: 60s
+
+    environment:
+      - API_KEY=${API_KEY}
+      - INSTALL_METHOD=${INSTALL_METHOD}
+      - INSTALL_PRESET=${INSTALL_PRESET:-}
+      - MEMORY_HYBRID_SEARCH=${MEMORY_HYBRID_SEARCH-1}
+      - MEMORY_GRAPH_EXPANSION=${MEMORY_GRAPH_EXPANSION-1}
+      - MEMORY_RATERS=${MEMORY_RATERS-implicit-citation,explicit-self}
+      - MEMORY_DEMOTION_FLOOR=${MEMORY_DEMOTION_FLOOR-1.0}
+      - CLAUDE_CODE_OAUTH_TOKEN=${CLAUDE_CODE_OAUTH_TOKEN}
+      - MCP_BASE_URL=http://localhost:3013
+      - APP_URL=https://app.agent-swarm.dev
+
+    ports:
+      - "3013:3013"
+
+    volumes:
+      - swarm_data:/app/data
+
+    healthcheck:
+      test: ["CMD-SHELL", "curl -f http://localhost:3013/health || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 15s
+
+    restart: unless-stopped
+
+  worker-coder:
+    image: "ghcr.io/desplega-ai/agent-swarm-worker:${AGENT_SWARM_VERSION:-latest}"
+    container_name: swarm-worker-coder
+    pull_policy: always
+    stop_grace_period: 60s
+
+    depends_on:
+      swarm-api:
+        condition: service_healthy
+
+    environment:
+      - HARNESS_PROVIDER=${HARNESS_PROVIDER}
+      - CLAUDE_CODE_OAUTH_TOKEN=${CLAUDE_CODE_OAUTH_TOKEN}
+      - API_KEY=${API_KEY}
+      - MEMORY_RATERS=${MEMORY_RATERS-implicit-citation,explicit-self}
+      - AGENT_ID=00000000-0000-4000-8000-000000000001
+      - AGENT_NAME=Coder
+      - AGENT_ROLE=worker
+      - TEMPLATE_ID=official/coder
+      - MCP_BASE_URL=http://swarm-api:3013
+      - YOLO=true
+      - SWARM_URL=http://swarm-api:3013
+      - MAX_CONCURRENT_TASKS=1
+
+    ports:
+      - "3201:3000"
+
+    volumes:
+      - swarm_logs:/logs
+      - swarm_shared:/workspace/shared
+      - swarm_worker_coder:/workspace/personal
+
+    restart: unless-stopped
+
+volumes:
+  swarm_data:
+  swarm_logs:
+  swarm_shared:
+  swarm_worker_coder:

package/src/tests/fixtures/onboard/solo.env.txt

@@ -0,0 +1,26 @@
+# === Core ===
+API_KEY=example-test-api-key
+MCP_BASE_URL=http://localhost:3013
+APP_URL=https://app.agent-swarm.dev
+# Pin a release, e.g. AGENT_SWARM_VERSION=1.150.0. Blank tracks `latest`.
+AGENT_SWARM_VERSION=
+INSTALL_METHOD=onboard_noninteractive
+INSTALL_PRESET=solo
+
+# New-deployment memory preset: retrieval, citation ratings, self-rating hints.
+# Set MEMORY_RATERS= to disable all raters; leave SKIP_SESSION_SUMMARY unset.
+MEMORY_HYBRID_SEARCH=1
+MEMORY_GRAPH_EXPANSION=1
+MEMORY_RATERS=implicit-citation,explicit-self
+MEMORY_DEMOTION_FLOOR=1.0
+
+# === Authentication ===
+HARNESS_PROVIDER=claude
+CLAUDE_CODE_OAUTH_TOKEN=example-test-oauth
+
+# === Integrations ===
+GITHUB_DISABLE=true
+SLACK_DISABLE=true
+
+# === Agent IDs (for reference) ===
+# worker-coder = 00000000-0000-4000-8000-000000000001

package/src/tests/heartbeat-checklist.test.ts

@@ -24,6 +24,7 @@ import {
   upsertSwarmConfig,
 } from "../be/db";
 import { getScript, upsertScriptByName } from "../be/scripts/db";
+import * as savedScriptRunner from "../be/scripts/run-saved";
 import { runSavedScriptAsAgent } from "../be/scripts/run-saved";
 import {
   checkHeartbeatChecklist,
@@ -624,6 +625,66 @@ describe("Heartbeat Checklist", () => {
       });
     });
 
+    for (const quiet of [true, false]) {
+      test(`healthy probe preserves the saved gate quiet=${quiet} verdict`, async () => {
+        process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
+        await saveGlobalGateScript("quiet-gate", "export default () => ({ quiet: true });");
+        const saved = spyOn(savedScriptRunner, "runSavedScriptAsAgent").mockResolvedValue({
+          exitCode: 0,
+          result: { quiet, reason: "existing verdict" },
+          stdout: "",
+          stderr: "",
+          durationMs: 1,
+          truncated: { stdout: false, stderr: false },
+        });
+        try {
+          setChecklistGateRunnerForTests((name, agentId, signal) =>
+            defaultChecklistGateRunner(name, agentId, signal, { probe: async () => null }),
+          );
+          await seedLead();
+          await checkHeartbeatChecklist();
+          expect(saved).toHaveBeenCalledTimes(1);
+          const tasks = await checklistTasks();
+          expect(tasks).toHaveLength(quiet ? 0 : 1);
+          if (!quiet) expect(tasks[0]!.tags).toContain("heartbeat-gate:wake");
+        } finally {
+          saved.mockRestore();
+        }
+      });
+    }
+
+    for (const mode of ["shadow", "enforce"] as const) {
+      test(`${mode}: an unhealthy probe produces a wake checklist`, async () => {
+        process.env.HEARTBEAT_CHECKLIST_GATE_MODE = mode;
+        setChecklistGateRunnerForTests((name, agentId, signal) =>
+          defaultChecklistGateRunner(name, agentId, signal, {
+            probe: async () => ({ quiet: false, reason: "script-runner-unhealthy: timeout" }),
+          }),
+        );
+        await seedLead();
+        await checkHeartbeatChecklist();
+        const tasks = await checklistTasks();
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0]!.tags).toContain("heartbeat-gate:wake");
+      });
+    }
+
+    test("a bug in the probe produces wake rather than error", async () => {
+      process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
+      setChecklistGateRunnerForTests((name, agentId, signal) =>
+        defaultChecklistGateRunner(name, agentId, signal, {
+          probe: async () => {
+            throw new Error("probe bug");
+          },
+        }),
+      );
+      await seedLead();
+      await checkHeartbeatChecklist();
+      const tasks = await checklistTasks();
+      expect(tasks).toHaveLength(1);
+      expect(tasks[0]!.tags).toContain("heartbeat-gate:wake");
+    });
+
     test("shadow mode (default): a quiet verdict still creates the task, tagged quiet", async () => {
       useGate({ quiet: true, reason: "no change", summary: "nothing moved" });
       const lead = await seedLead();
@@ -703,6 +764,9 @@ describe("Heartbeat Checklist", () => {
     test("enforce mode: a missing global script fails open through the real runner", async () => {
       process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
       process.env.HEARTBEAT_CHECKLIST_GATE_SCRIPT = "no-such-gate-script";
+      setChecklistGateRunnerForTests((name, agentId, signal) =>
+        defaultChecklistGateRunner(name, agentId, signal, { probe: async () => null }),
+      );
       await seedLead();
 
       await checkHeartbeatChecklist();
@@ -739,6 +803,7 @@ describe("Heartbeat Checklist", () => {
         let run: Promise<unknown> | undefined;
         setChecklistGateRunnerForTests((scriptName, leadAgentId, signal) => {
           run = defaultChecklistGateRunner(scriptName, leadAgentId, signal, {
+            probe: async () => null,
             buildCredentials: () => {
               setupStarted.resolve();
               return new Promise((resolve) => {
@@ -798,6 +863,9 @@ describe("Heartbeat Checklist", () => {
         "export default async function run() { await new Promise((r) => setTimeout(r, 30_000)); return { quiet: true }; }",
       );
       setChecklistGateTimeoutMsForTests(1_500);
+      setChecklistGateRunnerForTests((name, agentId, signal) =>
+        defaultChecklistGateRunner(name, agentId, signal, { probe: async () => null }),
+      );
       await seedLead();
 
       const started = Date.now();
@@ -808,6 +876,27 @@ describe("Heartbeat Checklist", () => {
       expect(tasks).toHaveLength(1);
       expect(tasks[0]!.tags).toContain("heartbeat-gate:error");
     });
+
+    test("enforce mode: the real probe passes with no swarm API key, using the Lead's run token", async () => {
+      process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
+      await saveGlobalGateScript("quiet-gate", "export default () => ({ quiet: true });");
+      const savedKeys = { swarm: process.env.AGENT_SWARM_API_KEY, legacy: process.env.API_KEY };
+      process.env.AGENT_SWARM_API_KEY = "";
+      process.env.API_KEY = "";
+      try {
+        await seedLead();
+        await checkHeartbeatChecklist();
+        expect(await checklistTasks()).toHaveLength(0);
+      } finally {
+        for (const [name, value] of [
+          ["AGENT_SWARM_API_KEY", savedKeys.swarm],
+          ["API_KEY", savedKeys.legacy],
+        ] as const) {
+          if (value === undefined) delete process.env[name];
+          else process.env[name] = value;
+        }
+      }
+    });
   });
 
   // ==========================================================================

package/src/tests/heartbeat-script-runner-probe.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { probeScriptRunner } from "../heartbeat/script-runner-probe";
+import type { RunScriptOutput } from "../scripts-runtime/loader";
+
+const ok: RunScriptOutput = {
+  result: true,
+  stdout: "",
+  stderr: "",
+  truncated: { stdout: false, stderr: false },
+  durationMs: 1,
+  exitCode: 0,
+};
+
+afterEach(() => mock.restore());
+
+describe("heartbeat script runner probe", () => {
+  test("success leaves the gate verdict unchanged and clears its deadline", async () => {
+    const clear = spyOn(globalThis, "clearTimeout");
+    const runner = mock(async () => ok);
+    expect(await probeScriptRunner("lead", runner)).toBeNull();
+    expect(runner).toHaveBeenCalledWith({
+      source: "export default async function () { return true; }",
+      agentId: "lead",
+      fsMode: "none",
+      timeoutMs: 10_000,
+      signal: expect.any(AbortSignal),
+    });
+    expect(clear).toHaveBeenCalledTimes(1);
+  });
+
+  test("timeout wakes without waiting for a stalled runner and aborts it", async () => {
+    let expire: (() => void) | undefined;
+    spyOn(globalThis, "setTimeout").mockImplementation(((callback: () => void, ms: number) => {
+      expect(ms).toBe(10_000);
+      expire = callback;
+      return 1;
+    }) as typeof setTimeout);
+    const clear = spyOn(globalThis, "clearTimeout").mockImplementation(() => {});
+    let signal: AbortSignal | undefined;
+    let rejectRun: ((error: Error) => void) | undefined;
+    const result = probeScriptRunner("lead", async (input) => {
+      signal = input.signal;
+      return new Promise<RunScriptOutput>((_, reject) => {
+        rejectRun = reject;
+      });
+    });
+    expire!();
+    expect(await result).toEqual({
+      quiet: false,
+      reason: "script-runner-unhealthy: timeout after 10000ms",
+    });
+    expect(signal?.aborted).toBe(true);
+    expect(clear).toHaveBeenCalledTimes(1);
+    // A runner that rejects after the deadline remains handled by Promise.race.
+    rejectRun!(new Error("late rejection"));
+    await Promise.resolve();
+  });
+
+  test("a thrown runner error wakes", async () => {
+    expect(
+      await probeScriptRunner("lead", async () => {
+        throw new Error("ECONNRESET");
+      }),
+    ).toEqual({
+      quiet: false,
+      reason: "script-runner-unhealthy: ECONNRESET",
+    });
+  });
+
+  for (const [label, failure, reason] of [
+    ["nonzero exit", { exitCode: 1 }, "script exited with code 1"],
+    ["runner error", { error: "killed" }, "killed"],
+    ["runtime error", { runtimeError: { message: "runtime failed" } }, "runtime failed"],
+  ] as const) {
+    test(`${label} wakes`, async () => {
+      const result = await probeScriptRunner(
+        "lead",
+        async () => ({ ...ok, ...failure }) as RunScriptOutput,
+      );
+      expect(result).toEqual({ quiet: false, reason: `script-runner-unhealthy: ${reason}` });
+    });
+  }
+});

package/src/tests/http-log-scrubbing.test.ts

@@ -1,7 +1,19 @@
 import { describe, expect, test } from "bun:test";
-import { safeRequestUrlForLog } from "../http/utils";
+import { redactShareTokenInPath, safeRequestUrlForLog } from "../http/utils";
 
 describe("safeRequestUrlForLog", () => {
+  test("redacts invite codes in request logs and the OTel path attribute", () => {
+    for (const suffix of ["", "/", "/extra"]) {
+      expect(safeRequestUrlForLog(`/invite/example_invite_code${suffix}?code=secret`)).toBe(
+        `/invite/[REDACTED]${suffix}?code=[REDACTED]`,
+      );
+      expect(redactShareTokenInPath(`/invite/example_invite_code${suffix}`)).toBe(
+        `/invite/[REDACTED]${suffix}`,
+      );
+    }
+    expect(safeRequestUrlForLog("/invite")).toBe("/invite");
+    expect(safeRequestUrlForLog("/api/invites")).toBe("/api/invites");
+  });
   test("redacts OAuth callback query values", () => {
     expect(
       safeRequestUrlForLog(
@@ -21,4 +33,25 @@ describe("safeRequestUrlForLog", () => {
       "/mcp?session=[REDACTED]&session=[REDACTED]&token=[REDACTED]",
     );
   });
+
+  test("redacts the agent-fs share token after /share/ and /site/", () => {
+    expect(safeRequestUrlForLog("/share/tok_secret123/raw")).toBe("/share/[REDACTED]/raw");
+    expect(safeRequestUrlForLog("/site/tok_secret123/")).toBe("/site/[REDACTED]/");
+    expect(safeRequestUrlForLog("/site/tok_secret123/a/index.html?v=1")).toBe(
+      "/site/[REDACTED]/a/index.html?v=[REDACTED]",
+    );
+  });
+
+  test("redacts the share token behind the /agentfs proxy prefix", () => {
+    expect(safeRequestUrlForLog("/agentfs/share/tok_secret123")).toBe("/agentfs/share/[REDACTED]");
+    expect(safeRequestUrlForLog("/agentfs/site/tok_secret123/x.css")).toBe(
+      "/agentfs/site/[REDACTED]/x.css",
+    );
+  });
+
+  test("leaves other share-like paths alone", () => {
+    expect(safeRequestUrlForLog("/share")).toBe("/share");
+    expect(safeRequestUrlForLog("/api/share/abc")).toBe("/api/share/abc");
+    expect(safeRequestUrlForLog("/agentfs/orgs/o/share")).toBe("/agentfs/orgs/o/share");
+  });
 });

package/src/tests/http-task-write-ownership.test.ts

@@ -10,6 +10,7 @@ import {
   completeTask,
   createAgent,
   createTaskExtended,
+  createUser,
   getTaskById,
   initDb,
   startTask,
@@ -27,7 +28,9 @@ const ownerId = "aaaa0000-0000-4000-8000-000000000b01";
 const otherId = "bbbb0000-0000-4000-8000-000000000b02";
 const creatorId = "cccc0000-0000-4000-8000-000000000b03";
 const leadId = "dddd0000-0000-4000-8000-000000000b04";
-const userId = "eeee0000-0000-4000-8000-000000000b05";
+// A real user row: a new user gets the built-in admin role, so with RBAC on
+// it may cancel any task, ownerless ones included.
+let userId: string;
 
 type Caller =
   | { as: "operator"; agentId?: string }
@@ -85,6 +88,7 @@ beforeAll(async () => {
   await createAgent({ id: otherId, name: "Other", isLead: false, status: "idle" });
   await createAgent({ id: creatorId, name: "Creator", isLead: false, status: "idle" });
   await createAgent({ id: leadId, name: "Lead", isLead: true, status: "idle" });
+  userId = (await createUser({ name: "Dashboard User" })).id;
 
   server = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
     const caller = JSON.parse(String(req.headers["x-test-caller"])) as Caller;