@desplega.ai/agent-swarm 1.129.0 → 1.131.0

package/src/tests/rbac-admission-e2e.test.ts

@@ -26,6 +26,7 @@ setDefaultTimeout(120_000);
 
 const REQUESTER_ROLE_ID = "rbac-role-requester";
 const CONFIG_SECRET_READER_ROLE_ID = "rbac-test-config-secret-reader";
+const APP_MANAGER_ROLE_ID = "rbac-test-app-manager";
 const CONFIG_SECRET_KEY = "RBAC_ADMISSION_SECRET";
 const CONFIG_SECRET_VALUE = "rbac-admission-secret-value";
 
@@ -81,6 +82,29 @@ function grantUserConfigSecretRead(dbPath: string, userId: string): void {
   }
 }
 
+function grantUserAppManage(dbPath: string, userId: string): void {
+  const db = new Database(dbPath);
+  try {
+    db.run("PRAGMA busy_timeout = 5000");
+    db.transaction(() => {
+      db.prepare(
+        `INSERT OR IGNORE INTO roles (id, name, description, isBuiltin, grantsAll)
+         VALUES (?, ?, ?, 0, 0)`,
+      ).run(APP_MANAGER_ROLE_ID, "app-manager", "Test app manager");
+      db.prepare("INSERT OR IGNORE INTO role_permissions (roleId, verb) VALUES (?, ?)").run(
+        APP_MANAGER_ROLE_ID,
+        "app.manage",
+      );
+      db.prepare(
+        `INSERT OR IGNORE INTO principal_roles (principalType, principalId, roleId)
+         VALUES ('user', ?, ?)`,
+      ).run(userId, APP_MANAGER_ROLE_ID);
+    })();
+  } finally {
+    db.close();
+  }
+}
+
 describe("RBAC admission over real HTTP", () => {
   afterAll(async () => {
     if (server) {
@@ -205,6 +229,21 @@ describe("RBAC admission over real HTTP", () => {
     expect(defaultCreate.status).toBe(201);
     const taskId = defaultCreate.body.id as string;
 
+    const appCreate = await api(server.base, "POST", "/api/apps", {
+      body: {
+        name: "RBAC admission app",
+        definition: {
+          models: { note: { columns: { title: { kind: "string" } } } },
+          pages: {
+            main: { root: "root", elements: { root: { type: "Container", props: {} } } },
+          },
+          defaultPage: "main",
+        },
+      },
+    });
+    expect(appCreate.status).toBe(201);
+    const appId = appCreate.body.app.id as string;
+
     rewriteUserToRequester(dbPath, userId);
 
     const deniedTaskCreate = await api(server.base, "POST", "/api/tasks", {
@@ -214,6 +253,26 @@ describe("RBAC admission over real HTTP", () => {
     expect(deniedTaskCreate.status).toBe(403);
     expect(deniedTaskCreate.body.error).toContain("admission: route has no permission verb");
 
+    const deniedAppMove = await api(server.base, "PATCH", `/api/assets/app/${appId}/key`, {
+      bearer: userToken,
+      body: { key: "shared/rbac-denied/" },
+    });
+    expect(deniedAppMove.status).toBe(403);
+    expect(deniedAppMove.body.error).toContain("missing permission 'app.manage'");
+
+    grantUserAppManage(dbPath, userId);
+
+    const allowedAppMove = await api(server.base, "PATCH", `/api/assets/app/${appId}/key`, {
+      bearer: userToken,
+      body: { key: "shared/rbac-allowed/" },
+    });
+    expect(allowedAppMove.status).toBe(200);
+    expect(allowedAppMove.body).toEqual({
+      entityType: "app",
+      id: appId,
+      key: "shared/rbac-allowed/",
+    });
+
     const allowedFavorite = await api(server.base, "PUT", "/api/favorites", {
       bearer: userToken,
       body: { itemType: "workflow", itemId: "wf-rbac-admission", favorite: true },
@@ -311,6 +370,7 @@ describe("RBAC admission over real HTTP", () => {
     expect(denyRows.map((row) => row.resourceId).sort()).toEqual([
       "GET /api/agents/{id}/mcp-servers",
       "GET /api/scripts/{id}/apis/{endpointId}/secret",
+      "PATCH /api/assets/app/{id}/key",
       "POST /api/scripts/{id}/apis",
       "POST /api/tasks",
     ]);
@@ -336,6 +396,14 @@ describe("RBAC admission over real HTTP", () => {
           row.decision === "allow",
       ),
     ).toBe(true);
+    expect(
+      userHttpRows.some(
+        (row) =>
+          row.resourceId === "PATCH /api/assets/app/{id}/key" &&
+          row.verb === "app.manage" &&
+          row.decision === "allow",
+      ),
+    ).toBe(true);
 
     rewriteUserToRequester(dbPath, userId);
 

package/src/tests/script-connections.test.ts

@@ -535,6 +535,9 @@ describe("script connections", () => {
       markMigrationApplied(database, "127_backfill_user_attribution.sql");
       // 128 alters session_costs, which this partial fixture does not create.
       markMigrationApplied(database, "128_session_costs_accuracy.sql");
+      // 129 alters scripts and rebuilds asset_key_history, neither of which this
+      // migration-112-only fixture creates.
+      markMigrationApplied(database, "129_asset_keys_apps_scripts.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/scripts-runtime-fetch.test.ts

@@ -0,0 +1,121 @@
+// DES-770: runtimeFetch must honor already-aborted / mid-flight caller aborts
+// instead of running (and retrying) attempts for a cancelled request. All tests
+// count real attempts against a Bun.serve fixture — no mock.module (leaks
+// process-wide across the test run).
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { runtimeFetch } from "../scripts-runtime/stdlib/fetch";
+
+describe("runtimeFetch abort handling", () => {
+  let fixture: ReturnType<typeof Bun.serve>;
+  let origin = "";
+  const hits: Record<string, number> = {};
+  // Stalled handlers park their resolvers here; afterAll releases them so the
+  // fixture can shut down cleanly.
+  const stallReleases: Array<() => void> = [];
+  let onStallHit: (() => void) | undefined;
+
+  beforeAll(() => {
+    fixture = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      fetch: async (req: Request) => {
+        const path = new URL(req.url).pathname;
+        hits[path] = (hits[path] ?? 0) + 1;
+        if (path.startsWith("/stall")) {
+          onStallHit?.();
+          await new Promise<void>((resolve) => stallReleases.push(resolve));
+        }
+        if (path === "/flaky" && hits[path] === 1) {
+          return new Response("boom", { status: 500 });
+        }
+        return new Response("ok");
+      },
+    });
+    origin = `http://127.0.0.1:${fixture.port}`;
+  });
+
+  afterAll(() => {
+    for (const release of stallReleases) release();
+    fixture.stop(true);
+  });
+
+  async function rejectionOf(promise: Promise<unknown>): Promise<unknown> {
+    return promise.then(
+      () => {
+        throw new Error("expected runtimeFetch to reject");
+      },
+      (error: unknown) => error,
+    );
+  }
+
+  test("already-aborted signal rejects immediately with zero fetch attempts", async () => {
+    const error = await rejectionOf(
+      runtimeFetch(`${origin}/pre-aborted`, {
+        signal: AbortSignal.abort(),
+        retries: 3,
+        timeoutMs: 30_000,
+      }),
+    );
+    expect((error as DOMException).name).toBe("AbortError");
+    expect(hits["/pre-aborted"]).toBeUndefined();
+  });
+
+  test("already-aborted signal propagates the caller's abort reason", async () => {
+    const reason = new Error("caller cancelled");
+    const error = await rejectionOf(
+      runtimeFetch(`${origin}/pre-aborted-reason`, {
+        signal: AbortSignal.abort(reason),
+        retries: 3,
+        timeoutMs: 30_000,
+      }),
+    );
+    expect(error).toBe(reason);
+    expect(hits["/pre-aborted-reason"]).toBeUndefined();
+  });
+
+  test("mid-flight abort rejects after exactly one attempt, no retry", async () => {
+    const arrived = new Promise<void>((resolve) => {
+      onStallHit = resolve;
+    });
+    const controller = new AbortController();
+    const pending = runtimeFetch(`${origin}/stall-abort`, {
+      signal: controller.signal,
+      retries: 3,
+      timeoutMs: 5_000,
+    });
+    await arrived;
+    onStallHit = undefined;
+    controller.abort();
+    const error = await rejectionOf(pending);
+    expect((error as DOMException).name).toBe("AbortError");
+    // Give a would-be retry time to land before asserting the attempt count.
+    await Bun.sleep(50);
+    expect(hits["/stall-abort"]).toBe(1);
+  });
+
+  test("timeout abort still retries up to the retry budget", async () => {
+    // Live, never-aborted caller signal: proves signal presence doesn't turn
+    // the controller's own timeout abort into a terminal error.
+    const controller = new AbortController();
+    const error = await rejectionOf(
+      runtimeFetch(`${origin}/stall-timeout`, {
+        signal: controller.signal,
+        retries: 2,
+        timeoutMs: 100,
+      }),
+    );
+    expect(error).toBeInstanceOf(Error);
+    expect(hits["/stall-timeout"]).toBe(2);
+  });
+
+  test("5xx responses still retry and succeed on a later attempt", async () => {
+    const controller = new AbortController();
+    const res = await runtimeFetch(`${origin}/flaky`, {
+      signal: controller.signal,
+      retries: 3,
+      timeoutMs: 5_000,
+    });
+    expect(res.status).toBe(200);
+    expect(hits["/flaky"]).toBe(2);
+  });
+});

package/src/tests/scripts-runtime-secret-egress.test.ts

@@ -111,7 +111,7 @@ describe("egress-substitution", () => {
       expect(capturedHeaders?.get("authorization")).toBe("Bearer ghp_real_secret_value_123");
     });
 
-    test("does NOT substitute for non-allowlisted host", async () => {
+    test("drops the placeholder header for a non-allowlisted host", async () => {
       let capturedHeaders: Headers | undefined;
       globalThis.fetch = async (_input: any, init?: any) => {
         capturedHeaders = new Headers(init?.headers);
@@ -134,7 +134,9 @@ describe("egress-substitution", () => {
         headers: { Authorization: "Bearer [REDACTED:GITHUB_TOKEN]" },
       });
 
-      expect(capturedHeaders?.get("authorization")).toBe("Bearer [REDACTED:GITHUB_TOKEN]");
+      // The placeholder header is DROPPED for non-allowlisted hosts: the
+      // literal marker is useless to the destination and must never egress.
+      expect(capturedHeaders?.get("authorization")).toBeNull();
     });
 
     test("passes through requests with no redacted placeholders", async () => {

package/src/tests/seed-scripts.test.ts

@@ -55,8 +55,8 @@ afterAll(async () => {
 });
 
 describe("seed-scripts catalog", () => {
-  test("manifest holds 24 unique, well-described scripts", () => {
-    expect(SEED_SCRIPTS.length).toBe(24);
+  test("manifest holds 26 unique, well-described scripts", () => {
+    expect(SEED_SCRIPTS.length).toBe(26);
     const names = SEED_SCRIPTS.map((s) => s.name);
     expect(new Set(names).size).toBe(names.length);
     for (const s of SEED_SCRIPTS) {

package/src/tests/swarm-tool-result-gate.test.ts

@@ -267,6 +267,38 @@ describe("finalizeSwarmToolResult", () => {
     expect((nonEmpty.structuredContent as { nudge?: string }).nudge).toBeUndefined();
   });
 
+  test("NUDGES map: app-get steers to the callable surface only when one exists", () => {
+    const withSurface = finalizeSwarmToolResult("app-get", {
+      ok: true,
+      message: 'App "PM Inbox" (a1).',
+      data: {
+        app: {
+          definition: {
+            models: {},
+            queries: { open: { model: "issue" } },
+            actions: { refresh: { kind: "sync" } },
+          },
+        },
+      },
+    });
+    expect((withSurface.structuredContent as { nudge?: string }).nudge).toContain(
+      "callable surface",
+    );
+
+    const bare = finalizeSwarmToolResult("app-get", {
+      ok: true,
+      message: 'App "Bare" (a2).',
+      data: { app: { definition: { models: {} } } },
+    });
+    expect((bare.structuredContent as { nudge?: string }).nudge).toBeUndefined();
+
+    const failed = finalizeSwarmToolResult("app-get", {
+      ok: false,
+      message: "App a3 not found.",
+    });
+    expect((failed.structuredContent as { nudge?: string }).nudge).toBeUndefined();
+  });
+
   test("NUDGES map: memory-search rating steer fires only when a result carries a rateHint", () => {
     const withHint = finalizeSwarmToolResult("memory-search", {
       ok: true,

package/src/tests/task-working-dir.test.ts

@@ -55,10 +55,14 @@ describe("Task Working Directory", () => {
       expect(() => dirSchema.parse("")).toThrow();
     });
 
-    test("rejects relative paths", () => {
-      expect(() => dirSchema.parse("relative/path")).toThrow();
-      expect(() => dirSchema.parse("./local")).toThrow();
-      expect(() => dirSchema.parse("../parent")).toThrow();
+    test("accepts relative paths (row contract mirrors what the create body stores verbatim)", () => {
+      // The create-task body validates dir as z.string() and the DB stores it
+      // as-is, so rows CAN hold relative paths — the entity schema must not
+      // pin .startsWith("/") or response validation would reject honest rows
+      // after the write already landed (PR #1141 review). Absolute paths stay
+      // the documented expectation; enforcement would belong on the INPUT side.
+      expect(dirSchema.parse("relative/path")).toBe("relative/path");
+      expect(dirSchema.parse("./local")).toBe("./local");
     });
   });
 

package/src/tests/whoami-route.test.ts

@@ -0,0 +1,127 @@
+/**
+ * GET /api/whoami — bearer → principal resolution (DES-771).
+ *
+ * The embedded dashboard authenticates with a per-user `aswt_` token and asks
+ * this endpoint which user it is acting as (the server forces requester/audit
+ * attribution from the token, see user-token-rest-auth.test.ts). The operator
+ * key resolves to `kind: "operator"` with no bound user; inactive tokens are
+ * rejected by the transport-level auth (401), never mapped to a user.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { closeDb, createUser, initDb, updateUser } from "../be/db";
+import { type IdentityActor, mintToken, revokeToken } from "../be/users";
+import { handleCore } from "../http/core";
+import { handleUsers } from "../http/users";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const TEST_DB_PATH = "./test-whoami-route.sqlite";
+const API_KEY = "test-api-key";
+const ACTOR: IdentityActor = { kind: "operator", id: "op:test" };
+
+interface WhoamiBody {
+  kind: "operator" | "user";
+  user: { id: string; name: string; status: string } | null;
+}
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+
+    if (await handleCore(req, res, myAgentId, API_KEY)) return;
+    if (await handleUsers(req, res, pathSegments, queryParams)) return;
+
+    res.writeHead(404);
+    res.end("Not Found");
+  });
+}
+
+async function listen(server: Server): Promise<number> {
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  return addr.port;
+}
+
+function cleanupDb() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+}
+
+describe("GET /api/whoami", () => {
+  let server: Server;
+  let port: number;
+
+  beforeAll(async () => {
+    cleanupDb();
+    initDb(TEST_DB_PATH);
+    server = createTestServer();
+    port = await listen(server);
+  });
+
+  afterAll(() => {
+    server.close();
+    closeDb();
+    cleanupDb();
+  });
+
+  const whoami = (bearer?: string) =>
+    fetch(`http://localhost:${port}/api/whoami`, {
+      headers: bearer ? { Authorization: `Bearer ${bearer}` } : {},
+    });
+
+  test("operator key resolves to kind=operator with no user", async () => {
+    const res = await whoami(API_KEY);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as WhoamiBody;
+    expect(body.kind).toBe("operator");
+    expect(body.user).toBeNull();
+  });
+
+  test("active user token resolves to its bound user", async () => {
+    const user = createUser({ name: "Whoami User", email: "whoami@example.com" });
+    const { plaintext } = mintToken(user.id, "rest", ACTOR);
+
+    const res = await whoami(plaintext);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as WhoamiBody;
+    expect(body.kind).toBe("user");
+    expect(body.user?.id).toBe(user.id);
+    expect(body.user?.name).toBe("Whoami User");
+  });
+
+  test("revoked token is rejected at auth (401)", async () => {
+    const user = createUser({ name: "Revoked User" });
+    const { plaintext, tokenId } = mintToken(user.id, "rest", ACTOR);
+    revokeToken(tokenId, ACTOR);
+
+    const res = await whoami(plaintext);
+    expect(res.status).toBe(401);
+  });
+
+  test("suspended user's token is rejected at auth (401)", async () => {
+    const user = createUser({ name: "Suspended User" });
+    const { plaintext } = mintToken(user.id, "rest", ACTOR);
+    updateUser(user.id, { status: "suspended" });
+
+    const res = await whoami(plaintext);
+    expect(res.status).toBe(401);
+  });
+
+  test("missing bearer is rejected (401)", async () => {
+    const res = await whoami();
+    expect(res.status).toBe(401);
+  });
+});

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

@@ -786,6 +786,81 @@ describe("Workflow Engine v2 (Phase 3)", () => {
       const nodeIds = steps.map((s) => s.nodeId);
       expect(nodeIds).not.toContain("after");
     });
+
+    test("unresolved inline script-body tokens fail with the node and token named", async () => {
+      const registry = createTestRegistry();
+      registry.register(new ScriptExecutor(mockDeps));
+      const workflow = makeWorkflow({
+        nodes: [
+          {
+            id: "unsafe-script",
+            type: "script",
+            config: { runtime: "bash", script: "echo {{trigger.payload}}" },
+          },
+        ],
+      });
+
+      const runId = await startWorkflowExecution(workflow, { payload: "attacker-data" }, registry);
+      const run = getWorkflowRun(runId);
+      const [step] = getWorkflowRunStepsByRunId(runId);
+
+      expect(run?.status).toBe("failed");
+      expect(run?.error).toContain('node "unsafe-script"');
+      expect(run?.error).toContain("{{trigger.payload}}");
+      expect(run?.error).toContain("config.args");
+      expect(step?.status).toBe("failed");
+      expect(step?.error).toContain("{{trigger.payload}}");
+      expect(step?.retryCount).toBe(0);
+      expect(step?.output).toBeUndefined();
+    });
+
+    test("bundled ralph-loop scripts execute with trigger and upstream values passed as args", async () => {
+      const receipt = (await Bun.file(
+        new URL("../../docs-site/public/receipts/workflows/ralph-loop.json", import.meta.url),
+      ).json()) as { definition: WorkflowDefinition };
+      const receiptNode = (id: string) => {
+        const node = receipt.definition.nodes.find((candidate) => candidate.id === id);
+        if (!node) throw new Error(`Missing ${id} in bundled ralph-loop receipt`);
+        return node;
+      };
+
+      const registry = createTestRegistry();
+      registry.register(new ScriptExecutor(mockDeps));
+      const workflow = makeWorkflow({
+        nodes: [
+          { ...receiptNode("validate-trigger"), next: "ralph-iteration" },
+          {
+            id: "ralph-iteration",
+            type: "script",
+            config: {
+              runtime: "bash",
+              script: `jq -n '{taskOutput:{iteration:1}}'`,
+            },
+            next: "max-check",
+          },
+          { ...receiptNode("max-check"), next: undefined },
+        ],
+      });
+
+      const runId = await startWorkflowExecution(
+        workflow,
+        { goal: "ship safely", maxIterations: 3 },
+        registry,
+      );
+      const run = getWorkflowRun(runId);
+      const steps = getWorkflowRunStepsByRunId(runId);
+
+      expect(run?.status).toBe("completed");
+      expect(steps.map((step) => [step.nodeId, step.status])).toEqual([
+        ["validate-trigger", "completed"],
+        ["ralph-iteration", "completed"],
+        ["max-check", "completed"],
+      ]);
+      expect(run?.context).toMatchObject({
+        "validate-trigger": { ok: true, goal: "ship safely", maxIterations: 3 },
+        "max-check": { atMax: false, iteration: 1, max: 3 },
+      });
+    });
   });
 
   // ─── Context Interpolation ────────────────────────────────
@@ -836,9 +911,7 @@ describe("interpolateNodeConfig — script node", () => {
 
     const script = (value as { script: string }).script;
     expect(script).not.toContain("curl attacker.example");
-    // Blanked to empty (existing deepInterpolate behavior for an unresolved
-    // token), not substituted with the attacker-controlled value.
-    expect(script).toBe("echo ");
+    expect(script).toBe("echo {{trigger.payload}}");
     expect(unresolved).toContain("trigger.payload");
   });
 
@@ -900,7 +973,7 @@ describe("interpolateNodeConfig — script node", () => {
 
     const script = (value as { script: string }).script;
     expect(script).not.toContain("curl attacker.example");
-    expect(script).toBe("echo ");
+    expect(script).toBe("echo {{payload}}");
     expect(unresolved).toContain("payload");
   });
 
@@ -914,7 +987,7 @@ describe("interpolateNodeConfig — script node", () => {
 
     const { value } = interpolateNodeConfig(node, ctx);
 
-    expect((value as { script: string }).script).toBe("echo ");
+    expect((value as { script: string }).script).toBe("echo {{input}}");
   });
 
   test("an inputs alias pointing at workflow input is still interpolated into the script", () => {
@@ -940,7 +1013,7 @@ describe("interpolateNodeConfig — script node", () => {
 
     const { value, unresolved } = interpolateNodeConfig(node, ctx);
 
-    expect((value as { script: string }).script).toBe("echo ");
+    expect((value as { script: string }).script).toBe("echo {{fetchStep.stdout}}");
     expect(unresolved).toContain("fetchStep.stdout");
   });
 
@@ -954,6 +1027,6 @@ describe("interpolateNodeConfig — script node", () => {
 
     const { value } = interpolateNodeConfig(node, ctx);
 
-    expect((value as { script: string }).script).toBe("echo ");
+    expect((value as { script: string }).script).toBe("echo {{prev}}");
   });
 });