@desplega.ai/agent-swarm 1.147.0 → 1.149.0

package/src/slack/handlers.ts

@@ -624,6 +624,7 @@ export function registerMessageHandler(app: App): void {
         fullTaskDescription,
         {
           agentId: lead?.id,
+          routingReason: lead ? "skill" : undefined,
           source: "slack",
           slackChannelId: msg.channel,
           slackThreadTs: threadTs,
@@ -739,6 +740,7 @@ export function registerMessageHandler(app: App): void {
             fullTaskDescription,
             {
               agentId: agent.id,
+              routingReason: "human_pinned",
               source: "slack",
               slackChannelId: msg.channel,
               slackThreadTs: threadTs,
@@ -762,6 +764,7 @@ export function registerMessageHandler(app: App): void {
           fullTaskDescription,
           {
             agentId: agent.id,
+            routingReason: "human_pinned",
             source: "slack",
             slackChannelId: msg.channel,
             slackThreadTs: threadTs,

package/src/slack/thread-buffer.ts

@@ -209,6 +209,8 @@ async function slackFlush(
   const mostRecentTask = await getMostRecentTaskInThread(channelId, threadTs);
   const task = await createTaskWithSiblingAwareness(fullDescription, {
     agentId: lead?.id,
+    routingReason:
+      lead && mostRecentTask?.agentId === lead.id ? "continuity" : lead ? "skill" : undefined,
     source: "slack",
     slackChannelId: channelId,
     slackThreadTs: threadTs,

package/src/tasks/worker-follow-up.ts

@@ -219,6 +219,7 @@ export async function createWorkerTaskFollowUp(args: {
 
   return await createTaskExtended(followUpDescription, {
     agentId: leadAgent.id,
+    routingReason: "skill",
     source: "system",
     taskType: "follow-up",
     parentTaskId: task.id,
@@ -424,6 +425,12 @@ export async function createResumeFollowUp(args: {
     : sourceAffinity;
   const created = await createTaskExtended(followUpDescription, {
     agentId: preferredAgentId,
+    routingReason:
+      preferredAgentId === undefined
+        ? undefined
+        : preferredAgentId === parent.agentId
+          ? "continuity"
+          : "reroute_fault",
     creatorAgentId: parent.creatorAgentId,
     source: "system",
     taskType: "resume",
@@ -542,6 +549,7 @@ export async function createRerouteDecisionTask(args: {
   // via parentTaskId. taskType is the distinct "reroute-decision" marker.
   const created = await createTaskExtended(decision.text, {
     agentId: leadAgent.id,
+    routingReason: "reroute_fault",
     creatorAgentId: original.creatorAgentId,
     source: "system",
     taskType: "reroute-decision",
@@ -621,6 +629,7 @@ export async function createPoolStarvationDecisionTask(args: {
 
   const created = await createTaskExtended(decision.text, {
     agentId: leadAgent.id,
+    routingReason: "overflow",
     creatorAgentId: original.creatorAgentId,
     source: "system",
     taskType: "reroute-decision",

package/src/tests/acp-adapter.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { tmpdir } from "node:os";
@@ -688,7 +688,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
     expect(toAcpMcpServers(null)).toEqual([]);
   });
 
-  test("mints an ephemeral token and revokes it when the session ends", async () => {
+  test("completes before the revoke response and logs a failed revocation", async () => {
     const cwd = makeTempDir();
     const agentPath = join(cwd, "fake-acp-ephem-agent.ts");
     const sdkPath = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
@@ -734,6 +734,22 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
     let mintCalled = false;
     let revokeCalled = false;
     let mintBody: Record<string, unknown> = {};
+    let revokeResponse: ServerResponse | undefined;
+    let resolveRevokeRequested!: () => void;
+    const revokeRequested = new Promise<void>((resolve) => {
+      resolveRevokeRequested = resolve;
+    });
+    let resolveWarning!: () => void;
+    const warned = new Promise<void>((resolve) => {
+      resolveWarning = resolve;
+    });
+    const revokeWarnings: string[] = [];
+    const warning = spyOn(console, "warn").mockImplementation((message) => {
+      if (String(message).includes("Session token revoke failed")) {
+        revokeWarnings.push(String(message));
+        resolveWarning();
+      }
+    });
 
     const swarmServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
       if (req.method === "POST" && req.url === "/api/sessions/tokens") {
@@ -749,8 +765,8 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
         res.end(JSON.stringify({ tokenId: FAKE_TOKEN_ID, plaintext: FAKE_TOKEN }));
       } else if (req.method === "DELETE" && req.url === `/api/sessions/tokens/${FAKE_TOKEN_ID}`) {
         revokeCalled = true;
-        res.writeHead(204);
-        res.end();
+        revokeResponse = res;
+        resolveRevokeRequested();
       } else {
         res.writeHead(404);
         res.end();
@@ -778,8 +794,19 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
       const events: ProviderEvent[] = [];
       session.onEvent((e) => events.push(e));
       const result = await session.waitForCompletion();
-      // Give the revoke call (fire-and-forget) a moment to complete.
-      await Bun.sleep(100);
+      // Withhold the HTTP response until completion: cleanup must never block it.
+      await revokeRequested;
+      expect(revokeWarnings).toEqual([]);
+      expect(revokeResponse!.destroyed).toBe(false);
+      expect(revokeResponse!.writableEnded).toBe(false);
+      revokeResponse!.writeHead(503).end();
+      const observed = await Promise.race([
+        warned.then(() => true),
+        Bun.sleep(1000).then(() => false),
+      ]);
+      expect(observed).toBe(true);
+      expect(revokeWarnings).toHaveLength(1);
+      expect(revokeWarnings[0]).toContain("HTTP 503");
 
       expect(result.exitCode).toBe(0);
 
@@ -799,6 +826,8 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
       const captured = await Bun.file(captureFile).text();
       expect(captured).toBe(`Bearer ${FAKE_TOKEN}`);
     } finally {
+      warning.mockRestore();
+      revokeResponse?.end();
       await new Promise<void>((resolve) => swarmServer.close(() => resolve()));
     }
   });

package/src/tests/acp-session-token.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, spyOn, test } from "bun:test";
+import { revokeAcpSessionToken } from "../utils/acp-session-token";
+
+describe("ACP session token revocation", () => {
+  test("logs HTTP 503 without rejecting or disclosing credentials", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: () => new Response("sensitive body", { status: 503 }),
+    });
+    const warning = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await expect(
+        revokeAcpSessionToken(server.url.origin, "test-operator-key", "test-token-id"),
+      ).resolves.toBeUndefined();
+      expect(warning).toHaveBeenCalled();
+      const log = JSON.stringify(warning.mock.calls);
+      expect(log).toContain("Session token revoke failed");
+      expect(log).toContain("503");
+      expect(log).not.toContain("test-operator-key");
+      expect(log).not.toContain("sensitive body");
+    } finally {
+      warning.mockRestore();
+      server.stop(true);
+    }
+  });
+
+  test("logs connection failure against a stopped server without rejecting", async () => {
+    const server = Bun.serve({ port: 0, fetch: () => new Response(null, { status: 204 }) });
+    const url = server.url.origin;
+    await server.stop(true);
+    const warning = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await expect(
+        revokeAcpSessionToken(url, "test-operator-key", "test-token-id"),
+      ).resolves.toBeUndefined();
+      expect(warning).toHaveBeenCalled();
+      expect(JSON.stringify(warning.mock.calls)).toContain("Session token revoke failed");
+    } finally {
+      warning.mockRestore();
+    }
+  });
+
+  test("aborts a stalled revoke request within its timeout and logs the failure", async () => {
+    const server = Bun.serve({ port: 0, fetch: () => new Promise<Response>(() => {}) });
+    const warning = spyOn(console, "warn").mockImplementation(() => {});
+    // Exercise the real fetch cancellation with a short test-only clock budget.
+    const realTimeout = AbortSignal.timeout.bind(AbortSignal);
+    const timeout = spyOn(AbortSignal, "timeout").mockImplementation(() => realTimeout(25));
+    try {
+      const pending = revokeAcpSessionToken(
+        server.url.origin,
+        "test-operator-key",
+        "test-token-id",
+      );
+      expect(timeout).toHaveBeenCalled();
+      expect(timeout.mock.calls[0]![0]).toBeGreaterThan(0);
+      expect(timeout.mock.calls[0]![0]).toBeLessThanOrEqual(5000);
+      await expect(pending).resolves.toBeUndefined();
+      expect(warning).toHaveBeenCalled();
+      expect(JSON.stringify(warning.mock.calls)).toContain("Session token revoke failed");
+    } finally {
+      server.stop(true);
+      timeout.mockRestore();
+      warning.mockRestore();
+    }
+  });
+});

package/src/tests/asset-key-api.test.ts

@@ -108,7 +108,12 @@ describe("asset namespace REST contract", () => {
     const task = await api(
       "POST",
       "/api/tasks",
-      { task: "namespaced task", agentId, key: "Shared/Team" },
+      {
+        task: "namespaced task",
+        agentId,
+        routingReason: "human_pinned",
+        key: "Shared/Team",
+      },
       { agentId },
     );
     expect(task.status).toBe(201);
@@ -245,6 +250,7 @@ describe("asset namespace REST contract", () => {
       {
         task: "personal task",
         agentId,
+        routingReason: "human_pinned",
         key: `personal/${userId}/drafts/`,
       },
       { agentId, sourceTaskId },
@@ -258,6 +264,7 @@ describe("asset namespace REST contract", () => {
       {
         task: "wrong personal task",
         agentId,
+        routingReason: "human_pinned",
         key: `personal/${secondUserId}/drafts/`,
       },
       { agentId, sourceTaskId },
@@ -270,6 +277,7 @@ describe("asset namespace REST contract", () => {
       {
         task: "unattributed personal task",
         agentId: secondAgentId,
+        routingReason: "human_pinned",
         key: `personal/${secondUserId}/drafts/`,
       },
       { agentId: secondAgentId },
@@ -281,7 +289,12 @@ describe("asset namespace REST contract", () => {
     const task = await api(
       "POST",
       "/api/tasks",
-      { task: "move target", agentId, key: "shared/inbox/" },
+      {
+        task: "move target",
+        agentId,
+        routingReason: "human_pinned",
+        key: "shared/inbox/",
+      },
       { agentId },
     );
     const move = await api(

package/src/tests/asset-key-mcp.test.ts

@@ -76,6 +76,7 @@ describe("asset namespace MCP exposure", () => {
       "send-task",
       {
         agentId: targetAgentId,
+        routingReason: "human_pinned",
         task: `inherited namespace ${Date.now()}`,
         allowDuplicate: true,
       },
@@ -90,6 +91,7 @@ describe("asset namespace MCP exposure", () => {
       "send-task",
       {
         agentId: targetAgentId,
+        routingReason: "human_pinned",
         task: `wrong namespace ${Date.now()}`,
         key: `personal/${otherUserId}/drafts/`,
         allowDuplicate: true,

package/src/tests/automation-preflight-alert.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { notifyAutomationPreflightFailure } from "../automation-preflight-alert";
+import type { AutomationPreflightResult } from "../be/automation-preflight";
+import * as slack from "../slack/app";
+import { registerVolatileSecret } from "../utils/secret-scrubber";
+
+const savedEnv = { ...process.env };
+const preflight: AutomationPreflightResult = {
+  id: "test-schedule",
+  kind: "schedule",
+  name: "daily-report",
+  state: "needs_setup",
+  missing: { params: ["REPORT_NAME", "REPO_URL"], integrations: ["github", "slack"] },
+  fixes: [],
+  fixUrl: "/schedules/test-schedule?param=REPORT_NAME",
+};
+const postMessage = mock(async (_message: unknown) => ({ ok: true }));
+
+beforeEach(() => {
+  process.env.SLACK_ALERTS_CHANNEL = "C_TEST_ALERTS";
+  process.env.APP_URL = "https://dashboard.example.com/";
+  postMessage.mockReset();
+  postMessage.mockResolvedValue({ ok: true });
+  spyOn(slack, "getSlackApp").mockReturnValue({
+    client: { chat: { postMessage } },
+  } as unknown as NonNullable<ReturnType<typeof slack.getSlackApp>>);
+});
+
+afterEach(() => {
+  mock.restore();
+  process.env = { ...savedEnv };
+});
+
+describe("Automation preflight alerts", () => {
+  test("skips Slack notification when alerts channel env is unset", async () => {
+    delete process.env.SLACK_ALERTS_CHANNEL;
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+
+    await expect(notifyAutomationPreflightFailure(preflight)).resolves.toBeUndefined();
+
+    expect(warn).toHaveBeenCalledWith(
+      "[Automation Preflight] SLACK_ALERTS_CHANNEL not set; skipping alert",
+    );
+    expect(slack.getSlackApp).not.toHaveBeenCalled();
+    expect(postMessage).not.toHaveBeenCalled();
+  });
+
+  test("posts the skipped automation, missing setup, and dashboard fix link", async () => {
+    await notifyAutomationPreflightFailure(preflight);
+
+    expect(postMessage).toHaveBeenCalledWith({
+      channel: "C_TEST_ALERTS",
+      text:
+        '⚠️ Automation needs setup\nAutomation: schedule "daily-report"\n' +
+        "Missing params: REPORT_NAME, REPO_URL\nMissing integrations: github, slack\n" +
+        "Fire SKIPPED. It was not retried or queued.\n" +
+        "Fix setup: https://dashboard.example.com/schedules/test-schedule?param=REPORT_NAME",
+      unfurl_links: false,
+      unfurl_media: false,
+    });
+  });
+
+  test("skips Slack notification when the app is unavailable", async () => {
+    spyOn(slack, "getSlackApp").mockReturnValue(null);
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+
+    await expect(notifyAutomationPreflightFailure(preflight)).resolves.toBeUndefined();
+
+    expect(warn).toHaveBeenCalledWith(
+      "[Automation Preflight] Slack not available, cannot send notification",
+    );
+    expect(postMessage).not.toHaveBeenCalled();
+  });
+
+  test("scrubs alert text and logs Slack failures without throwing", async () => {
+    const secret = "preflight-alert-sensitive-fixture";
+    registerVolatileSecret(secret, "PREFLIGHT_TEST_SECRET");
+    postMessage.mockRejectedValueOnce(new Error(`Slack failed: ${secret}`));
+    const error = spyOn(console, "error").mockImplementation(() => {});
+
+    await expect(
+      notifyAutomationPreflightFailure({ ...preflight, name: secret }),
+    ).resolves.toBeUndefined();
+
+    expect(postMessage).toHaveBeenCalledTimes(1);
+    expect(JSON.stringify(postMessage.mock.calls)).not.toContain(secret);
+    expect(error).toHaveBeenCalledTimes(1);
+    expect(JSON.stringify(error.mock.calls)).toContain("Slack failed:");
+    expect(JSON.stringify(error.mock.calls)).not.toContain(secret);
+  });
+});

package/src/tests/claude-worker-parity.test.ts

@@ -235,6 +235,7 @@ async function runTransport(transport: "cli" | "sdk", agentId: string): Promise<
   const created = await api("POST", "/api/tasks", {
     body: {
       task: `Run the deterministic Claude ${transport} transport parity fixture and report completion.`,
+      routingReason: "human_pinned",
       agentId,
       source: "api",
     },
@@ -373,6 +374,7 @@ async function runCredentialRotation(): Promise<void> {
   const firstCreated = await api("POST", "/api/tasks", {
     body: {
       task: "Run the first deterministic credential rotation fixture task.",
+      routingReason: "human_pinned",
       agentId: ROTATION_AGENT_ID,
       source: "api",
     },
@@ -483,6 +485,7 @@ async function runCredentialRotation(): Promise<void> {
     const secondCreated = await api("POST", "/api/tasks", {
       body: {
         task: "Run the second deterministic credential rotation fixture task.",
+        routingReason: "human_pinned",
         agentId: ROTATION_AGENT_ID,
         source: "api",
       },

package/src/tests/config-session-auth.test.ts

@@ -0,0 +1,143 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import { closeDb, createAgent, initDb, upsertSwarmConfig } from "../be/db";
+import { handleConfig } from "../http/config";
+import { handleCore } from "../http/core";
+import { handleSessions } from "../http/sessions";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+const API_KEY = "config-session-test-operator";
+const SECRET = "config-session-test-secret-value";
+let server: Server;
+let baseUrl: string;
+let workerId: string;
+let leadId: string;
+let configId: string;
+
+function headers(bearer: string, agentId?: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${bearer}`,
+    "Content-Type": "application/json",
+    ...(agentId ? { "X-Agent-ID": agentId } : {}),
+  };
+}
+
+async function mint(agentId: string) {
+  const res = await fetch(`${baseUrl}/api/sessions/tokens`, {
+    method: "POST",
+    headers: headers(API_KEY),
+    body: JSON.stringify({ agentId, taskId: crypto.randomUUID(), ttlMs: 60_000 }),
+  });
+  expect(res.status).toBe(200);
+  return (await res.json()) as { tokenId: string; plaintext: string };
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  workerId = (await createAgent({ name: "config-worker", isLead: false, status: "idle" })).id;
+  leadId = (await createAgent({ name: "config-lead", isLead: true, status: "idle" })).id;
+  configId = (
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: workerId,
+      key: "ACP_AUTH_TEST_SECRET",
+      value: SECRET,
+      isSecret: true,
+    })
+  ).id;
+  server = createServer(async (req, res) => {
+    if (await handleCore(req, res, req.headers["x-agent-id"] as string | undefined, API_KEY))
+      return;
+    const segments = getPathSegments(req.url || "");
+    const query = parseQueryParams(req.url || "");
+    if (await handleSessions(req, res, segments, query)) return;
+    if (await handleConfig(req, res, segments, query)) return;
+    res.writeHead(404).end();
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+});
+
+describe("config HTTP session-token authorization", () => {
+  for (const route of ["list", "resolved", "by-id"] as const) {
+    test(`${route} masks secrets for a non-lead session even with a spoofed lead header`, async () => {
+      const token = await mint(workerId);
+      const lead = await mint(leadId);
+      const path =
+        route === "by-id"
+          ? `/api/config/${configId}`
+          : route === "resolved"
+            ? "/api/config/resolved"
+            : "/api/config";
+      const url = `${baseUrl}${path}?includeSecrets=true&agentId=${workerId}`;
+      // Positive controls: operator and a token bound to the actual lead may read.
+      for (const bearer of [API_KEY, lead.plaintext]) {
+        const res = await fetch(url, { headers: headers(bearer) });
+        expect(res.status).toBe(200);
+        expect(await res.text()).toContain(SECRET);
+      }
+      const responses: string[] = [];
+      for (const agentId of [undefined, workerId, leadId]) {
+        const res = await fetch(url, { headers: headers(token.plaintext, agentId) });
+        expect(res.status).toBe(200);
+        responses.push(await res.text());
+      }
+      const revoked = await fetch(`${baseUrl}/api/sessions/tokens/${token.tokenId}`, {
+        method: "DELETE",
+        headers: headers(API_KEY),
+      });
+      expect(revoked.status).toBe(204);
+      expect((await fetch(url, { headers: headers(token.plaintext, leadId) })).status).toBe(401);
+      for (const body of responses) {
+        expect(body).not.toContain(SECRET);
+        expect(body).toContain("secret values masked");
+      }
+    });
+  }
+
+  for (const method of ["PUT", "DELETE"] as const) {
+    test(`${method} cannot escalate a non-lead session by changing only X-Agent-ID`, async () => {
+      const token = await mint(workerId);
+      const key = `ACP_AUTH_TEST_${method}`;
+      const config = await upsertSwarmConfig({
+        scope: "agent",
+        scopeId: workerId,
+        key,
+        value: "original",
+      });
+      const url = `${baseUrl}/api/config${method === "DELETE" ? `/${config.id}` : ""}`;
+      const request = (bearer: string, agentId?: string) =>
+        fetch(url, {
+          method,
+          headers: headers(bearer, agentId),
+          ...(method === "PUT"
+            ? { body: JSON.stringify({ scope: "agent", scopeId: workerId, key, value: "changed" }) }
+            : {}),
+        });
+      const own = await request(token.plaintext, workerId);
+      expect(own.status).toBe(403);
+      await own.text();
+      const spoofed = await request(token.plaintext, leadId);
+      await spoofed.text();
+      const stored = await fetch(`${baseUrl}/api/config/${config.id}`, {
+        headers: headers(API_KEY),
+      });
+      const storedBody = await stored.text();
+      // Confirm both the response and persisted state; an error after writing is insufficient.
+      expect({
+        status: spoofed.status,
+        storedStatus: stored.status,
+        unchanged: storedBody.includes("original"),
+      }).toEqual({ status: 403, storedStatus: 200, unchanged: true });
+      const lead = await mint(leadId);
+      const allowed = await request(lead.plaintext);
+      expect(allowed.ok).toBe(true);
+      await allowed.text();
+    });
+  }
+});