@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/src/tests/status.test.ts

@@ -864,30 +864,30 @@ describe("validateProviderCredentials — error scrubbing", () => {
     expect(result.error).toContain("ANTHROPIC_API_KEY");
   });
 
-  test("claude with CLAUDE_CODE_OAUTH_TOKEN passes via presence check (no upstream call)", async () => {
+  test("claude with CLAUDE_CODE_OAUTH_TOKEN checks the token against the OAuth profile", async () => {
     delete process.env.ANTHROPIC_API_KEY;
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "sk-ant-oat01-fake-oauth-token";
-    let fetchCalled = false;
-    globalThis.fetch = (async () => {
-      fetchCalled = true;
+    const urls: string[] = [];
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      urls.push(String(url));
       return new Response("{}", { status: 200 });
     }) as typeof fetch;
     const result = await validateProviderCredentials("claude");
     expect(result.ok).toBe(true);
-    expect(fetchCalled).toBe(false);
+    expect(urls).toEqual(["https://api.anthropic.com/api/oauth/profile"]);
   });
 
-  test("claude prefers OAuth presence check over API-key live call when both are set", async () => {
+  test("claude prefers the OAuth check over the API-key check when both are set", async () => {
     process.env.ANTHROPIC_API_KEY = "sk-ant-api-fake-1234";
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "sk-ant-oat01-fake-oauth";
-    let fetchCalled = false;
-    globalThis.fetch = (async () => {
-      fetchCalled = true;
+    const urls: string[] = [];
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      urls.push(String(url));
       return new Response("{}", { status: 200 });
     }) as typeof fetch;
     const result = await validateProviderCredentials("claude");
     expect(result.ok).toBe(true);
-    expect(fetchCalled).toBe(false);
+    expect(urls).toEqual(["https://api.anthropic.com/api/oauth/profile"]);
   });
 
   test("codex with valid CODEX_OAUTH JSON passes via presence check (no upstream call)", async () => {
@@ -1212,10 +1212,10 @@ describe("computeHealth (Phase 2)", () => {
     expect((harness.providers ?? []).map((p) => p.provider)).toEqual(["claude"]);
   });
 
-  test("`ok` when workers are `configured` (heartbeat drift is a runtime concern, not setup health)", async () => {
+  test("`ok` when workers are `configured` and the seeded lead is `idle`", async () => {
     // Workers in `configured` state means agents exist but haven't posted a
-    // heartbeat in the last 5 minutes. This is surfaced on /agents and the
-    // dashboard canvas — it should NOT degrade the header health dot.
+    // heartbeat in the last 5 minutes. Health reads the lead's status, not
+    // its heartbeat: this lead is `idle`, so it can take work.
     const lead = await createAgent({
       name: "lead-d",
       isLead: true,
@@ -1229,9 +1229,92 @@ describe("computeHealth (Phase 2)", () => {
     });
     const payload = await buildStatusPayload();
     expect(getMilestone(payload, "workers").state).toBe("configured");
+    expect(payload.activity.leads_ready).toBe(1);
+    expect(payload.health).toBe("ok");
+  });
+
+  test("`ok` for an idle lead with a stale heartbeat and no worker heartbeat", async () => {
+    const lead = await createAgent({
+      name: "lead-idle",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = await createAgent({
+      name: "worker-quiet",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    // The lead last ran a session an hour ago. The worker never heartbeated.
+    const hourAgo = new Date(Date.now() - 3_600_000).toISOString();
+    await getDbClient().run(`UPDATE agents SET lastActivityAt = ? WHERE id = ?`, [
+      hourAgo,
+      lead.id,
+    ]);
+    const pass = { ok: true, error: null, latency_ms: 12, testedAt: Date.now() };
+    await seedCredStatus(lead.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+    await seedCredStatus(worker.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+
+    const payload = await buildStatusPayload();
+    expect(payload.activity.leads_online).toBe(0);
+    expect(payload.activity.leads_ready).toBe(1);
     expect(payload.health).toBe("ok");
   });
 
+  test("`degraded` when no lead row exists", async () => {
+    const worker = await createAgent({
+      name: "worker-alone",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    await updateAgentActivity(worker.id);
+    await seedCredStatus(worker.id, "claude", {
+      ready: true,
+      satisfiedBy: "env",
+      liveTest: { ok: true, error: null, latency_ms: 12, testedAt: Date.now() },
+    });
+
+    const payload = await buildStatusPayload();
+    expect(getMilestone(payload, "harness").state).toBe("verified");
+    expect(payload.activity.leads_ready).toBe(0);
+    expect(payload.health).toBe("degraded");
+  });
+
+  test("`degraded` when the only lead is offline", async () => {
+    const lead = await createAgent({
+      name: "lead-gone",
+      isLead: true,
+      status: "offline",
+      capabilities: [],
+    });
+    const worker = await createAgent({
+      name: "worker-left",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    await updateAgentActivity(worker.id);
+    const pass = { ok: true, error: null, latency_ms: 12, testedAt: Date.now() };
+    await seedCredStatus(lead.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+    await seedCredStatus(worker.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+
+    const payload = await buildStatusPayload();
+    expect(getMilestone(payload, "harness").state).toBe("verified");
+    expect(payload.activity.leads_ready).toBe(0);
+    expect(payload.health).toBe("degraded");
+  });
+
+  test("no ready lead degrades an otherwise `ok` rollup", () => {
+    const synthetic: SetupMilestone[] = [
+      { id: "harness", label: "Harness", state: "verified" },
+      { id: "workers", label: "Workers", state: "verified" },
+    ];
+    expect(computeHealth(synthetic, 1)).toBe("ok");
+    expect(computeHealth(synthetic, 0)).toBe("degraded");
+  });
+
   test("`ok` when harness verified and workers verified (no other integration is `configured`)", () => {
     // We can't reach the in-memory cache from here, so simulate by directly
     // checking the helper: build a synthetic milestone array.
@@ -1245,7 +1328,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 
   test("`degraded` when an integration is `configured`", () => {
@@ -1258,7 +1341,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("degraded");
+    expect(computeHealth(synthetic, 1)).toBe("degraded");
   });
 
   test("`ok` when a connected Slack reports `verified` next to other connected integrations", () => {
@@ -1271,7 +1354,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 
   test("integrations in `unverified` alone do NOT degrade health", () => {
@@ -1286,7 +1369,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "unverified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 
   test("an unverified embedding key never blocks boot or degrades health", () => {
@@ -1295,7 +1378,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "embeddings", label: "Memory search", state: "unverified" },
       { id: "workers", label: "Workers", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 });
 

package/src/tests/tasks-workflow-run-filter.test.ts

@@ -0,0 +1,146 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createWorkflow,
+  createWorkflowRun,
+  getAllTasks,
+  getTasksCount,
+  initDb,
+} from "../be/db";
+import { handleCore } from "../http/core";
+import { handleTasks } from "../http/tasks";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-tasks-workflow-run-filter.sqlite";
+const API_KEY = "test-tasks-workflow-run-filter";
+
+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;
+    }
+  }
+}
+
+function createTestServer(apiKey: string): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleCore(req, res, myAgentId, apiKey);
+    if (handled) return;
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const ok = await handleTasks(req, res, pathSegments, queryParams, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+}
+
+describe("workflowRunId task filter", () => {
+  let server: Server;
+  let port: number;
+  let agentId: string;
+  let runAId: string;
+  let runATaskIds: string[];
+  let runBTaskId: string;
+  let noRunTaskId: string;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+    agentId = (
+      await createAgent({ name: "workflow-run-filter-agent", isLead: false, status: "idle" })
+    ).id;
+    const workflow = await createWorkflow({
+      name: `workflow-run-filter-${crypto.randomUUID()}`,
+      definition: { nodes: [] },
+    });
+    const runA = await createWorkflowRun({ id: crypto.randomUUID(), workflowId: workflow.id });
+    const runB = await createWorkflowRun({ id: crypto.randomUUID(), workflowId: workflow.id });
+    runAId = runA.id;
+    runATaskIds = [
+      (
+        await createTaskExtended("run A — step 1", {
+          agentId,
+          source: "workflow",
+          workflowRunId: runA.id,
+        })
+      ).id,
+      (
+        await createTaskExtended("run A — step 2", {
+          agentId,
+          source: "workflow",
+          workflowRunId: runA.id,
+        })
+      ).id,
+    ];
+    runBTaskId = (
+      await createTaskExtended("run B — step 1", {
+        agentId,
+        source: "workflow",
+        workflowRunId: runB.id,
+      })
+    ).id;
+    noRunTaskId = (await createTaskExtended("task outside any run", { agentId })).id;
+
+    server = createTestServer(API_KEY);
+    port = await listenOnFreePort(server);
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  function listTasks(query: string): Promise<Response> {
+    return fetch(`http://localhost:${port}/api/tasks?${query}`, {
+      headers: { Authorization: `Bearer ${API_KEY}`, "X-Agent-ID": agentId },
+    });
+  }
+
+  test("getAllTasks and getTasksCount return only the run's tasks", async () => {
+    const tasks = await getAllTasks({ workflowRunId: runAId });
+    expect(tasks.map((t) => t.id).sort()).toEqual([...runATaskIds].sort());
+    expect(await getTasksCount({ workflowRunId: runAId })).toBe(2);
+  });
+
+  for (const fields of ["slim", "full", "timeline"] as const) {
+    test(`GET /api/tasks?workflowRunId with fields=${fields} returns only the run's tasks`, async () => {
+      const res = await listTasks(`workflowRunId=${runAId}&fields=${fields}&includeTotal=true`);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { tasks: { id: string }[]; total: number };
+      const ids = body.tasks.map((t) => t.id);
+      expect(ids.sort()).toEqual([...runATaskIds].sort());
+      expect(ids).not.toContain(runBTaskId);
+      expect(ids).not.toContain(noRunTaskId);
+      expect(body.total).toBe(2);
+    });
+  }
+
+  test("an unknown run returns an empty list and zero total", async () => {
+    const res = await listTasks(`workflowRunId=${crypto.randomUUID()}&includeTotal=true`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { tasks: unknown[]; total: number };
+    expect(body.tasks).toEqual([]);
+    expect(body.total).toBe(0);
+  });
+
+  test("a non-UUID workflowRunId is rejected", async () => {
+    const res = await listTasks("workflowRunId=not-a-uuid");
+    expect(res.status).toBe(400);
+  });
+});

package/src/tests/test-net.ts

@@ -6,6 +6,8 @@
  * Always bind an OS-assigned port: `listenOnFreePort(server)` for an
  * in-process `node:http` server, `getFreePort()` for a port that must be known
  * before the server exists (spawned `src/http.ts` children take it via `PORT`).
+ * A spawned child can lose that port before it binds; `startOnFreePort` retries
+ * it on a new one.
  */
 import { createServer, type Server } from "node:net";
 
@@ -27,6 +29,35 @@ export function getFreePort(): Promise<number> {
   });
 }
 
+/** Matches the boot error a server prints when its port is already bound. */
+export const PORT_IN_USE_LOG = /EADDRINUSE|Is port \d+ in use\?/;
+
+/** Thrown by a `startOnFreePort` callback when the server lost its port to another process. */
+export class PortInUseError extends Error {}
+
+/**
+ * Start a server on a getFreePort() port, and on a new port when `start`
+ * throws PortInUseError. getFreePort() releases the port before the spawned
+ * server binds it, and under `bun test --parallel` another process can take
+ * it during the server's boot. Any other error, or the last attempt's
+ * PortInUseError, propagates unchanged.
+ */
+export async function startOnFreePort<T>(
+  start: (port: number) => Promise<T>,
+  opts: { attempts?: number; getPort?: () => Promise<number> } = {},
+): Promise<T> {
+  const attempts = opts.attempts ?? 3;
+  const getPort = opts.getPort ?? getFreePort;
+  for (let attempt = 1; ; attempt++) {
+    const port = await getPort();
+    try {
+      return await start(port);
+    } catch (error) {
+      if (!(error instanceof PortInUseError) || attempt >= attempts) throw error;
+    }
+  }
+}
+
 /**
  * Bind `server` to port 0 and return the assigned port. Binds all interfaces
  * unless `host` is given, matching a bare `server.listen(0)`, so

package/src/tests/transcription.test.ts

@@ -207,6 +207,14 @@ describe("provider key fallback", () => {
     });
   });
 
+  test("a pooled OPENAI_API_KEY sends one member", async () => {
+    process.env.OPENAI_API_KEY = `${OPENAI_FAKE}-a,${OPENAI_FAKE}-b`;
+    const apiKey = resolveTranscriptionConfig()?.apiKey;
+    expect([`${OPENAI_FAKE}-a`, `${OPENAI_FAKE}-b`]).toContain(apiKey);
+    await transcribeAudio(audio);
+    expect(captured[0]?.authorization).toMatch(new RegExp(`^Bearer ${OPENAI_FAKE}-[ab]$`));
+  });
+
   test("GROQ_API_KEY alone uses Groq's OpenAI-compatible endpoint and whisper model", async () => {
     process.env.GROQ_API_KEY = GROQ_FAKE;
     expect(resolveTranscriptionConfig()).toMatchObject({

package/src/tests/used-by-route.test.ts

@@ -183,6 +183,17 @@ describe("POST /api/used-by", () => {
     expect(proxied[1]?.body).not.toHaveProperty("quote");
   });
 
+  test("a job function the catalog does not list yet is stored but not sent", async () => {
+    const grant = await post(
+      { granted: true, contactEmail: "admin@acme.com", contactFunction: "marketing" },
+      OPERATOR,
+    );
+    expect(grant.statusCode).toBe(200);
+    expect(proxied[0]?.body).toMatchObject({ granted: true, contact_email: "admin@acme.com" });
+    expect(proxied[0]?.body).not.toHaveProperty("contact_function");
+    expect(await configValue("SWARM_USED_BY_CONTACT_FUNCTION")).toBe("marketing");
+  });
+
   test("a grant requires valid contact details and a quote of at most 280 characters", async () => {
     for (const details of [
       {},