@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/tests/user-token-rest-auth.test.ts

@@ -6,7 +6,7 @@ import {
   type Server,
   type ServerResponse,
 } from "node:http";
-import { closeDb, createAgent, createUser, getDb, initDb } from "../be/db";
+import { closeDb, createAgent, createTaskExtended, createUser, getDb, initDb } from "../be/db";
 import { type IdentityActor, mintToken, revokeToken } from "../be/users";
 import { handleCore } from "../http/core";
 import { handleTasks } from "../http/tasks";
@@ -110,6 +110,145 @@ describe("normal REST API user-bound token auth", () => {
     expect(body.requestedByUserId).toBeUndefined();
   });
 
+  test("global API key caller cannot spoof requestedByUserId via body — falls back to owned task context", async () => {
+    const legitRequester = createUser({ name: "Legit Requester" });
+    const attacker = createUser({ name: "Attacker" });
+    const agent = createAgent({ name: "spoof-test-agent", isLead: false, status: "idle" });
+    const ownedTask = createTaskExtended("owned task for spoof test", {
+      agentId: agent.id,
+      requestedByUserId: legitRequester.id,
+    });
+
+    const res = await fetch(`http://localhost:${port}/api/tasks`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${API_KEY}`,
+        "Content-Type": "application/json",
+        "x-agent-id": agent.id,
+        "x-source-task-id": ownedTask.id,
+      },
+      body: JSON.stringify({
+        task: "created through global key with spoofed requestedByUserId",
+        requestedByUserId: attacker.id,
+      }),
+    });
+
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as { id: string; requestedByUserId?: string };
+    expect(body.requestedByUserId).toBe(legitRequester.id);
+    expect(body.requestedByUserId).not.toBe(attacker.id);
+  });
+
+  test("global API key caller + body requestedByUserId, flag OFF (default) → stays unattributed, body ignored", async () => {
+    // Default posture: the body fallback is off, so an operator/global-key
+    // caller cannot spoof attribution via the request body. This is the
+    // anti-spoofing behavior upstream #939 introduced.
+    expect(process.env.TRUST_BODY_REQUESTED_BY_USER_ID).toBeUndefined();
+    const someUser = createUser({ name: "Some User (flag off)" });
+
+    const res = await fetch(`http://localhost:${port}/api/tasks`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        task: "created from the UI session view, flag off",
+        requestedByUserId: someUser.id,
+      }),
+    });
+
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as { id: string; requestedByUserId?: string };
+    expect(body.requestedByUserId).toBeUndefined();
+  });
+
+  describe("TRUST_BODY_REQUESTED_BY_USER_ID=true (opt-in for shared-key deployments)", () => {
+    beforeAll(() => {
+      process.env.TRUST_BODY_REQUESTED_BY_USER_ID = "true";
+    });
+
+    afterAll(() => {
+      delete process.env.TRUST_BODY_REQUESTED_BY_USER_ID;
+    });
+
+    test("global API key caller + valid body requestedByUserId (no owned task context) → attributed to that user", async () => {
+      // Fork-specific opt-in: this org's UI shares one operator key across
+      // all users, so there is no ownership-gated task context to fall back
+      // to — the body-supplied id is the only signal available, and it is
+      // trusted once validated against a real user row, but only when the
+      // deployment has explicitly opted into this flag.
+      const uiUser = createUser({ name: "UI Picker User" });
+
+      const res = await fetch(`http://localhost:${port}/api/tasks`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${API_KEY}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          task: "created from the UI session view",
+          requestedByUserId: uiUser.id,
+        }),
+      });
+
+      expect(res.status).toBe(201);
+      const body = (await res.json()) as { id: string; requestedByUserId?: string };
+      expect(body.requestedByUserId).toBe(uiUser.id);
+    });
+
+    test("global API key caller + bogus body requestedByUserId → stays unattributed (NULL), not a crash", async () => {
+      const res = await fetch(`http://localhost:${port}/api/tasks`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${API_KEY}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          task: "created with a nonexistent requestedByUserId",
+          requestedByUserId: "does-not-exist",
+        }),
+      });
+
+      expect(res.status).toBe(201);
+      const body = (await res.json()) as { id: string; requestedByUserId?: string };
+      expect(body.requestedByUserId).toBeUndefined();
+    });
+
+    test("owned task context still takes precedence over body even when flag is on", async () => {
+      const legitRequester = createUser({ name: "Legit Requester (flag on)" });
+      const attacker = createUser({ name: "Attacker (flag on)" });
+      const agent = createAgent({
+        name: "spoof-test-agent-flag-on",
+        isLead: false,
+        status: "idle",
+      });
+      const ownedTask = createTaskExtended("owned task for spoof test, flag on", {
+        agentId: agent.id,
+        requestedByUserId: legitRequester.id,
+      });
+
+      const res = await fetch(`http://localhost:${port}/api/tasks`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${API_KEY}`,
+          "Content-Type": "application/json",
+          "x-agent-id": agent.id,
+          "x-source-task-id": ownedTask.id,
+        },
+        body: JSON.stringify({
+          task: "created through global key with spoofed requestedByUserId, flag on",
+          requestedByUserId: attacker.id,
+        }),
+      });
+
+      expect(res.status).toBe(201);
+      const body = (await res.json()) as { id: string; requestedByUserId?: string };
+      expect(body.requestedByUserId).toBe(legitRequester.id);
+      expect(body.requestedByUserId).not.toBe(attacker.id);
+    });
+  });
+
   test("revoked user token is unauthorized for normal API", async () => {
     const user = createUser({ name: "Revoked REST User" });
     const { tokenId, plaintext } = mintToken(user.id, "revoked", ACTOR);

package/src/tests/workflow-swarm-script.test.ts

@@ -10,6 +10,7 @@ import {
   getWorkflowRunStepsByRunId,
   initDb,
 } from "../be/db";
+import { upsertScriptConnection } from "../be/script-connections";
 import { upsertScriptByName } from "../be/scripts/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import type { Workflow, WorkflowDefinition } from "../types";
@@ -143,6 +144,7 @@ beforeEach(() => {
   getDb().run("DELETE FROM workflow_run_steps");
   getDb().run("DELETE FROM workflow_runs");
   getDb().run("DELETE FROM scripts");
+  getDb().run("DELETE FROM script_connections");
   getDb().run("DELETE FROM workflows");
 });
 
@@ -204,6 +206,48 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output?.scriptName).toBe("add-one");
   });
 
+  test("swarm-script executor includes API connection descriptors in ctx.api", async () => {
+    await upsertScriptConnection({
+      slug: "workflowVendor",
+      kind: "openapi",
+      scope: "global",
+      baseUrl: "https://api.workflow-vendor.test",
+      openapiSpecJson: JSON.stringify({
+        openapi: "3.0.0",
+        info: { title: "WorkflowVendor", version: "1.0.0" },
+        paths: {
+          "/items": {
+            get: {
+              operationId: "listItems",
+              responses: { "200": { description: "ok" } },
+            },
+          },
+        },
+      }),
+    });
+    await saveScript(
+      "ctx-api-keys",
+      `export default async (_args, ctx) => ({ apiKeys: Object.keys(ctx.api).sort() });`,
+    );
+
+    const executor = new SwarmScriptExecutor(deps);
+    const wf = makeWorkflow({ nodes: [] });
+    const result = await executor.run({
+      config: { scriptName: "ctx-api-keys" },
+      context: {},
+      meta: {
+        runId: crypto.randomUUID(),
+        stepId: crypto.randomUUID(),
+        nodeId: "script",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("success");
+    expect(result.output?.result).toEqual({ apiKeys: ["workflowVendor"] });
+  });
+
   test("pinHash correctly resolves to a historic script_versions row", async () => {
     const first = await saveScript("versioned", `export default async () => ({ version: "old" });`);
     await saveScript("versioned", `export default async () => ({ version: "new" });`);

package/src/tests/workflow-triggers-v2.test.ts

@@ -11,10 +11,17 @@ import {
   upsertSwarmConfig,
 } from "../be/db";
 import type { Workflow } from "../types";
+import { TriggerConfigSchema } from "../types";
 import { startWorkflowExecution } from "../workflows/engine";
 import { BaseExecutor, type ExecutorResult } from "../workflows/executors/base";
 import { ExecutorRegistry } from "../workflows/executors/registry";
-import { handleWebhookTrigger, verifyHmacSignature, WebhookError } from "../workflows/triggers";
+import {
+  handleWebhookTrigger,
+  verifyHmacSignature,
+  verifyTimestampedHmacSignature,
+  verifyTokenEquality,
+  WebhookError,
+} from "../workflows/triggers";
 
 const TEST_DB_PATH = "./test-workflow-triggers-v2.sqlite";
 
@@ -111,6 +118,93 @@ describe("verifyHmacSignature", () => {
   });
 });
 
+describe("verifyTimestampedHmacSignature", () => {
+  const secret = "timestamped-secret";
+  const body = '{"event":"finding.triage_completed"}';
+  const timestamp = 1_700_000_000;
+  const nowMs = timestamp * 1000;
+
+  function sign(ts: number, signingSecret = secret): string {
+    return crypto.createHmac("sha256", signingSecret).update(`${ts}.${body}`).digest("hex");
+  }
+
+  test("valid timestamped signature passes", () => {
+    const header = `t=${timestamp},v1=${sign(timestamp)}`;
+
+    expect(verifyTimestampedHmacSignature(secret, body, header, {}, nowMs)).toBe(true);
+  });
+
+  test("wrong secret fails", () => {
+    const header = `t=${timestamp},v1=${sign(timestamp, "wrong-secret")}`;
+
+    expect(verifyTimestampedHmacSignature(secret, body, header, {}, nowMs)).toBe(false);
+  });
+
+  test("expired timestamp fails", () => {
+    const oldTimestamp = timestamp - 301;
+    const header = `t=${oldTimestamp},v1=${sign(oldTimestamp)}`;
+
+    expect(verifyTimestampedHmacSignature(secret, body, header, {}, nowMs)).toBe(false);
+  });
+
+  test("future timestamp beyond tolerance fails", () => {
+    const futureTimestamp = timestamp + 301;
+    const header = `t=${futureTimestamp},v1=${sign(futureTimestamp)}`;
+
+    expect(verifyTimestampedHmacSignature(secret, body, header, {}, nowMs)).toBe(false);
+  });
+
+  test("missing or garbled timestamp fails", () => {
+    expect(verifyTimestampedHmacSignature(secret, body, `v1=${sign(timestamp)}`, {}, nowMs)).toBe(
+      false,
+    );
+    expect(
+      verifyTimestampedHmacSignature(
+        secret,
+        body,
+        `t=not-a-number,v1=${sign(timestamp)}`,
+        {},
+        nowMs,
+      ),
+    ).toBe(false);
+  });
+
+  test("multiple signature entries pass when any one matches", () => {
+    const header = `t=${timestamp},v1=deadbeef,v1=${sign(timestamp)}`;
+
+    expect(verifyTimestampedHmacSignature(secret, body, header, {}, nowMs)).toBe(true);
+  });
+
+  test("custom timestamp and signature keys are supported", () => {
+    const header = `ts=${timestamp},sig=${sign(timestamp)}`;
+
+    expect(
+      verifyTimestampedHmacSignature(
+        secret,
+        body,
+        header,
+        { timestampKey: "ts", signatureKey: "sig", toleranceSeconds: 300 },
+        nowMs,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("verifyTokenEquality", () => {
+  test("matching token passes", () => {
+    expect(verifyTokenEquality("shared-token", "shared-token")).toBe(true);
+  });
+
+  test("same-length non-matching token fails", () => {
+    expect(verifyTokenEquality("shared-token", "shared-tokem")).toBe(false);
+  });
+
+  test("wrong-length non-matching token fails without throwing", () => {
+    expect(() => verifyTokenEquality("shared-token", "short")).not.toThrow();
+    expect(verifyTokenEquality("shared-token", "short")).toBe(false);
+  });
+});
+
 // ─── Webhook Trigger ────────────────────────────────────────
 
 describe("handleWebhookTrigger", () => {
@@ -312,6 +406,179 @@ describe("handleWebhookTrigger — custom hmacHeader", () => {
 
     expect(result.runId).toBeDefined();
   });
+
+  test("explicit hmac-sha256 verification does not use fallback headers", async () => {
+    const secret = "explicit-hmac-secret";
+    const workflow = makeWorkflow({
+      triggers: [
+        {
+          type: "webhook",
+          hmacSecret: secret,
+          verification: { format: "hmac-sha256", header: "X-Primary-Signature" },
+        },
+      ],
+    });
+
+    const body = '{"event":"explicit"}';
+    try {
+      await handleWebhookTrigger(
+        workflow.id,
+        body,
+        { "x-signature": signRaw(secret, body) },
+        registry,
+      );
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(401);
+    }
+  });
+});
+
+describe("handleWebhookTrigger — verification formats", () => {
+  function signTimestamped(secret: string, body: string, timestamp: number): string {
+    return crypto.createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("hex");
+  }
+
+  test("timestamped-hmac-sha256 starts workflow for Superagent-shaped request", async () => {
+    const secret = "superagent-secret";
+    const timestamp = Math.floor(Date.now() / 1000);
+    const workflow = makeWorkflow({
+      triggers: [
+        {
+          type: "webhook",
+          hmacSecret: secret,
+          verification: {
+            format: "timestamped-hmac-sha256",
+            header: "X-Superagent-Signature",
+            toleranceSeconds: 300,
+          },
+        },
+      ],
+    });
+
+    const body = '{"type":"finding.triage_completed","finding":{"id":"finding-123"}}';
+    const result = await handleWebhookTrigger(
+      workflow.id,
+      body,
+      {
+        "x-superagent-signature": `t=${timestamp},v1=${signTimestamped(secret, body, timestamp)}`,
+      },
+      registry,
+    );
+
+    expect(result.runId).toBeDefined();
+    const run = getWorkflowRun(result.runId);
+    expect(run).not.toBeNull();
+    expect(run!.triggerData).toEqual({
+      type: "finding.triage_completed",
+      finding: { id: "finding-123" },
+    });
+  });
+
+  test("timestamped-hmac-sha256 rejects signatures on fallback headers", async () => {
+    const secret = "timestamped-no-fallback-secret";
+    const timestamp = Math.floor(Date.now() / 1000);
+    const workflow = makeWorkflow({
+      triggers: [
+        {
+          type: "webhook",
+          hmacSecret: secret,
+          verification: {
+            format: "timestamped-hmac-sha256",
+            header: "X-Superagent-Signature",
+          },
+        },
+      ],
+    });
+
+    const body = '{"event":"fallback-blocked"}';
+    try {
+      await handleWebhookTrigger(
+        workflow.id,
+        body,
+        { "x-signature": `t=${timestamp},v1=${signTimestamped(secret, body, timestamp)}` },
+        registry,
+      );
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(401);
+    }
+  });
+
+  test("token-equality starts workflow when shared token matches", async () => {
+    const workflow = makeWorkflow({
+      triggers: [
+        {
+          type: "webhook",
+          hmacSecret: "gitlab-token",
+          verification: { format: "token-equality", header: "X-Gitlab-Token" },
+        },
+      ],
+    });
+
+    const result = await handleWebhookTrigger(
+      workflow.id,
+      '{"event":"push"}',
+      { "x-gitlab-token": "gitlab-token" },
+      registry,
+    );
+
+    expect(result.runId).toBeDefined();
+  });
+
+  test("token-equality rejects a wrong token", async () => {
+    const workflow = makeWorkflow({
+      triggers: [
+        {
+          type: "webhook",
+          hmacSecret: "gitlab-token",
+          verification: { format: "token-equality", header: "X-Gitlab-Token" },
+        },
+      ],
+    });
+
+    try {
+      await handleWebhookTrigger(
+        workflow.id,
+        '{"event":"push"}',
+        { "x-gitlab-token": "wrong-token" },
+        registry,
+      );
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(401);
+    }
+  });
+
+  test("verification configured without hmacSecret fails closed instead of accepting the request", async () => {
+    // Bypasses the create/update Zod schema (which now also rejects this shape) to
+    // exercise the runtime guard directly — e.g. for data written before this fix,
+    // or any future write path that skips schema validation.
+    const workflow = makeWorkflow({
+      triggers: [
+        {
+          type: "webhook",
+          verification: { format: "token-equality", header: "X-Gitlab-Token" },
+        },
+      ],
+    });
+
+    try {
+      await handleWebhookTrigger(
+        workflow.id,
+        '{"event":"push"}',
+        { "x-gitlab-token": "anything" },
+        registry,
+      );
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(WebhookError);
+      expect((err as WebhookError).statusCode).toBe(500);
+    }
+  });
 });
 
 describe("handleWebhookTrigger — hmacSecret references", () => {
@@ -503,3 +770,35 @@ describe("cooldown", () => {
     expect(run2!.status).toBe("completed");
   });
 });
+
+// ─── TriggerConfigSchema validation ──────────────────────────
+
+describe("TriggerConfigSchema", () => {
+  test("rejects verification configured without hmacSecret", () => {
+    const result = TriggerConfigSchema.safeParse({
+      type: "webhook",
+      verification: { format: "token-equality", header: "X-Gitlab-Token" },
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues.some((issue) => issue.path.includes("hmacSecret"))).toBe(true);
+    }
+  });
+
+  test("accepts verification configured with hmacSecret", () => {
+    const result = TriggerConfigSchema.safeParse({
+      type: "webhook",
+      hmacSecret: "gitlab-token",
+      verification: { format: "token-equality", header: "X-Gitlab-Token" },
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  test("accepts a webhook trigger with neither hmacSecret nor verification (intentionally unauthenticated)", () => {
+    const result = TriggerConfigSchema.safeParse({ type: "webhook" });
+
+    expect(result.success).toBe(true);
+  });
+});