@desplega.ai/agent-swarm 2.2.0 → 2.4.0

package/src/telemetry.ts

@@ -630,6 +630,7 @@ function emit(
   metadata?: Record<string, unknown>,
   actor?: TelemetryActor,
   emitter: string = source,
+  identity?: { orgName: string; orgWebsite: string },
 ): void {
   if (!isTelemetryEnabled() || !installationId) return;
   maybeRefreshOrgIdentity();
@@ -639,7 +640,9 @@ function emit(
     const occurredAt = new Date().toISOString();
     const sentFor = installationId;
     const isCloud = cachedIsCloud || isCloudDeployment();
-    const orgIdentity = getOrgIdentity();
+    const orgIdentity = identity
+      ? { ...getOrgIdentity(), organization_name: identity.orgName }
+      : getOrgIdentity();
     const userId = actor?.userId?.trim() || undefined;
     const payload = {
       schema_version: 2 as const,
@@ -653,7 +656,7 @@ function emit(
         orgId,
         orgName: orgIdentity.organization_name,
         orgDomain: cachedOrgDomain,
-        orgWebsite: normalizeOrgWebsite(process.env.SWARM_ORG_WEBSITE),
+        orgWebsite: identity?.orgWebsite ?? normalizeOrgWebsite(process.env.SWARM_ORG_WEBSITE),
         installationId,
         actor: userId ? { userId, role: actor?.role ?? roleResolver?.(userId) ?? null } : undefined,
         isCloud,
@@ -820,6 +823,27 @@ export const telemetry = {
     );
   },
 
+  /**
+   * Public-ranking events. The API passes the org identity it just read from
+   * config, so a listing built right after an identity edit still matches the
+   * envelope's `org_name` / `org_website` (the proxy rejects a mismatch) before
+   * the debounced config reload updates `process.env`.
+   */
+  ranking<S extends EventSuffix<"ranking">>(
+    event: S,
+    props: FamilyProps<"ranking", S>,
+    identity?: { orgName: string; orgWebsite: string },
+  ): void {
+    emit(
+      `ranking.${event}`,
+      props as Record<string, unknown>,
+      undefined,
+      undefined,
+      source,
+      identity,
+    );
+  },
+
   org<S extends EventSuffix<"org">>(event: S, props: FamilyProps<"org", S>): void {
     emit(`org.${event}`, props as Record<string, unknown>, undefined);
   },

package/src/tests/apps-rbac.test.ts

@@ -7,9 +7,20 @@ import {
   type ServerResponse,
 } from "node:http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { closeDb, createAgent, createUser, getDbClient, getTaskById, initDb } from "../be/db";
+import type { AppActionCaller } from "../apps/action-caller";
+import {
+  closeDb,
+  createAgent,
+  createPage,
+  createUser,
+  getDbClient,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { createRuntimeController } from "../be/runtime-pools/db";
+import { mintControllerToken } from "../be/runtime-pools/tokens";
 import { upsertScriptByName } from "../be/scripts/db";
-import { type IdentityActor, mintToken } from "../be/users";
+import { type IdentityActor, mintRuntimeToken, mintToken } from "../be/users";
 import { handleApps } from "../http/apps";
 import { resolveHttpRequestAuth } from "../http/auth";
 import { getPathSegments, parseQueryParams } from "../http/utils";
@@ -19,13 +30,18 @@ import { registerAppDiffTool } from "../tools/app-diff";
 import { registerAppGetTool, registerAppQueryTool } from "../tools/app-get";
 import { registerAppHistoryTool } from "../tools/app-history";
 import { registerAppPatchTool } from "../tools/app-patch";
+import { signPageSession } from "../utils/page-session";
 import { setRequestAuth } from "../utils/request-auth-context";
+import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
+import { CHILD_PROCESS_TEST_BUDGET_MS } from "./test-proc";
 
 const TEST_DB_PATH = `/private/tmp/test-apps-rbac-${process.pid}.sqlite`;
 const API_KEY = "example-apps-rbac-test-key";
 const AGENT_ID = crypto.randomUUID();
 const LEAD_ID = crypto.randomUUID();
 const OPERATOR_ACTOR: IdentityActor = { kind: "operator", id: "apps-rbac-test" };
+const previousPageSecret = process.env.PAGE_SESSION_SECRET;
+const previousSwarmKey = process.env.AGENT_SWARM_API_KEY;
 
 const definition = {
   models: { note: { columns: { title: { kind: "string" } } } },
@@ -45,6 +61,7 @@ let server: Server;
 let base = "";
 let userId = "";
 let userToken = "";
+let agentToken = "";
 let appId = "";
 let tools: Record<string, RegisteredTool>;
 
@@ -144,12 +161,15 @@ async function callTool(name: string, args: unknown): Promise<unknown> {
 }
 
 beforeAll(async () => {
+  process.env.PAGE_SESSION_SECRET = "example-apps-rbac-page-session-secret";
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
   for (const suffix of ["", "-wal", "-shm"]) {
     await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
   }
   initDb(TEST_DB_PATH);
   await createAgent({ id: AGENT_ID, name: "apps-rbac-worker", isLead: false, status: "idle" });
   await createAgent({ id: LEAD_ID, name: "apps-rbac-lead", isLead: true, status: "idle" });
+  agentToken = (await mintRuntimeToken(AGENT_ID, crypto.randomUUID())).plaintext;
   const user = await createUser({ name: "Apps RBAC User" });
   userId = user.id;
   userToken = (await mintToken(user.id, "apps-rbac", OPERATOR_ACTOR)).plaintext;
@@ -177,6 +197,10 @@ afterEach(() => {
 afterAll(async () => {
   await new Promise<void>((resolve) => server.close(() => resolve()));
   closeDb();
+  if (previousPageSecret === undefined) delete process.env.PAGE_SESSION_SECRET;
+  else process.env.PAGE_SESSION_SECRET = previousPageSecret;
+  if (previousSwarmKey === undefined) delete process.env.AGENT_SWARM_API_KEY;
+  else process.env.AGENT_SWARM_API_KEY = previousSwarmKey;
   for (const suffix of ["", "-wal", "-shm"]) {
     await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
   }
@@ -323,6 +347,9 @@ describe("app viewer identity", () => {
     });
     expect(action.status).toBe(200);
     expect((await getTaskById(action.body.taskId))?.requestedByUserId).toBe(userId);
+    expect((await getTaskById(action.body.taskId))?.task).toContain(
+      `Caller (server-verified): ${JSON.stringify({ kind: "user", id: userId, name: "Apps RBAC User" })}`,
+    );
 
     const operatorAction = await request<{ taskId: string }>(
       `/api/apps/${appId}/actions/triage`,
@@ -342,6 +369,166 @@ describe("app viewer identity", () => {
   });
 });
 
+describe("verified app action caller", () => {
+  beforeEach(async () => {
+    const saved = await upsertScriptByName({
+      name: `apps_caller_${crypto.randomUUID().replaceAll("-", "")}`,
+      scope: "agent",
+      scopeId: AGENT_ID,
+      agentId: AGENT_ID,
+      source: "export default function run(args: Record<string, unknown>) { return args; }",
+      description: "Action caller fixture",
+      intent: "Return the arguments received by a script action",
+      signatureJson: JSON.stringify({ args: { type: "object" }, result: { type: "object" } }),
+      typeChecked: true,
+      embeddingMode: "skip",
+    });
+    const patched = await request(`/api/apps/${appId}`, "operator", {
+      method: "PATCH",
+      body: JSON.stringify({
+        definition: {
+          actions: {
+            echo: {
+              kind: "script",
+              scriptId: saved.script.id,
+              args: { caller: { kind: "guest", id: "default-forgery" }, base: 2 },
+            },
+          },
+        },
+      }),
+    });
+    expect(patched.status).toBe(200);
+  });
+
+  const scriptTest = test.skipIf(SKIP_SANDBOX_SPAWN_TESTS);
+  scriptTest.each([
+    ["user", undefined],
+    ["operator", AGENT_ID],
+    ["operator", crypto.randomUUID()],
+    ["operator", undefined],
+    ["agent", AGENT_ID],
+  ] as const)(
+    "%s caller with agent header %s preserves identity and overwrites forged input",
+    async (principal, agentId) => {
+      const caller: AppActionCaller =
+        principal === "user"
+          ? { kind: "user", id: userId, name: "Apps RBAC User" }
+          : agentId === AGENT_ID
+            ? { kind: "agent", id: AGENT_ID, name: "apps-rbac-worker" }
+            : { kind: "operator", id: null };
+      const requestHeaders = {
+        ...(agentId ? { "X-Agent-ID": agentId } : {}),
+        ...(principal === "agent" ? { Authorization: `Bearer ${agentToken}` } : {}),
+      };
+      const checks: RbacCheck[] = [];
+      setAuditSink((check) => checks.push(check));
+      const row = await request<{ row: { createdBy: string } }>(
+        `/api/apps/${appId}/models/note/rows`,
+        principal,
+        {
+          method: "POST",
+          headers: requestHeaders,
+          body: JSON.stringify({ values: { title: "caller row" } }),
+        },
+      );
+      expect(row.status).toBe(201);
+      expect(row.body.row.createdBy).toBe(caller.id ? `${caller.kind}:${caller.id}` : "operator");
+
+      const action = await request<{
+        ok: boolean;
+        result: { caller: AppActionCaller; app: { id: string }; base: number; add: number };
+      }>(`/api/apps/${appId}/actions/echo`, principal, {
+        method: "POST",
+        headers: requestHeaders,
+        body: JSON.stringify({
+          input: { caller: { kind: "operator", id: "input-forgery" }, app: { id: "fake" }, add: 3 },
+        }),
+      });
+      expect(action.status).toBe(200);
+      expect(action.body.ok).toBe(true);
+      expect(action.body.result).toEqual({ caller, app: { id: appId }, base: 2, add: 3 });
+
+      const taskAction = await request<{ taskId: string }>(
+        `/api/apps/${appId}/actions/triage`,
+        principal,
+        { method: "POST", headers: requestHeaders, body: JSON.stringify({ input: {} }) },
+      );
+      expect(taskAction.status).toBe(200);
+      expect((await getTaskById(taskAction.body.taskId))?.task).toContain(
+        `Caller (server-verified): ${JSON.stringify(caller)}`,
+      );
+      expect(checks).toHaveLength(3);
+      expect(checks.every((check) => check.principal.kind === principal)).toBe(true);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  scriptTest(
+    "a signed page session includes the verified page id and viewer identity",
+    async () => {
+      const page = await createPage({
+        agentId: AGENT_ID,
+        slug: `caller-${crypto.randomUUID()}`,
+        title: "Caller page",
+        contentType: "text/html",
+        body: "<p>Caller page</p>",
+      });
+      const session = await signPageSession({
+        pageId: page.id,
+        exp: Math.floor(Date.now() / 1000) + 3600,
+        uid: userId,
+      });
+      const action = await request<{ ok: boolean; result: { caller: AppActionCaller } }>(
+        `/api/apps/${appId}/actions/echo`,
+        "operator",
+        {
+          method: "POST",
+          headers: {
+            "X-Agent-ID": AGENT_ID,
+            "X-Page-ID": page.id,
+            "X-Page-Session": session,
+          },
+          body: JSON.stringify({ input: { caller: { pageId: "fake" } } }),
+        },
+      );
+      expect(action.status).toBe(200);
+      expect(action.body.ok).toBe(true);
+      expect(action.body.result.caller).toEqual({
+        kind: "user",
+        id: userId,
+        name: "Apps RBAC User",
+        pageId: page.id,
+      });
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test("controller tokens use the guest principal even with a registered agent header", async () => {
+    const controller = await createRuntimeController({
+      name: "apps-caller-controller",
+      kind: "docker",
+      placement: "remote",
+    });
+    const token = await mintControllerToken(controller.id);
+    const checks: RbacCheck[] = [];
+    setAuditSink((check) => checks.push(check));
+    const action = await request(`/api/apps/${appId}/actions/echo`, "operator", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token.plaintext}`, "X-Agent-ID": AGENT_ID },
+      body: JSON.stringify({ input: {} }),
+    });
+    expect(action.status).toBe(403);
+    expect(checks).toEqual([
+      {
+        principal: { kind: "guest" },
+        verb: "app.use",
+        resource: { kind: "app", appId },
+        source: "http",
+      },
+    ]);
+  });
+});
+
 describe("user writers and the script ownership gate", () => {
   async function saveScript(scope: "agent" | "global", ownerId: string | null): Promise<string> {
     const result = await upsertScriptByName({

package/src/tests/apps-script-types.test.ts

@@ -127,9 +127,16 @@ describe("renderAppTypes", () => {
     expect(rendered).toContain("params: { value: never };");
   });
 
-  test("renders a documentation-grade action union", () => {
+  test("renders action names and arguments with server-stamped caller context", () => {
     const rendered = renderAppTypes([app("PM Inbox", issueDefinition())]);
     expect(rendered).toContain('export type ActionName = "closeIssue" | "notifyOwner";');
+    expect(rendered).toContain("export interface ActionArgs");
+    expect(rendered).toContain('app: { id: "PM Inbox-id" };');
+    expect(rendered).toContain("caller: AppActionCaller;");
+    expect(rendered).toContain('kind: "user" | "agent" | "operator" | "guest";');
+    expect(rendered).toContain("id: string | null;");
+    expect(rendered).toContain("name?: string;");
+    expect(rendered).toContain("pageId?: string;");
   });
 
   test("derives and dedupes namespaces and model interface names", () => {
@@ -262,14 +269,20 @@ describe("renderAppTypes", () => {
     expect(rendered).not.toMatch(/^export const pwned2/m);
   });
 
-  test("a model named actionName does not collide with the ActionName alias", () => {
+  test("model names do not collide with generated action types", () => {
     const rendered = renderAppTypes([
       app("Collision", {
-        models: { actionName: { columns: { title: { kind: "string" } } } },
+        models: {
+          actionName: { columns: { title: { kind: "string" } } },
+          actionArgs: { columns: { title: { kind: "string" } } },
+          appActionCaller: { columns: { title: { kind: "string" } } },
+        },
         actions: { close: { kind: "task", prompt: "close" } },
       }),
     ]);
     expect(rendered).toContain("export interface ActionName_2");
+    expect(rendered).toContain("export interface ActionArgs_2");
+    expect(rendered).toContain("export interface AppActionCaller_2");
     expect(rendered).toContain('export type ActionName = "close";');
   });
 

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

@@ -11,8 +11,11 @@ import {
   createAgent,
   createTaskExtended,
   createUser,
+  getAssetKeyMappingByProvider,
   getDbClient,
+  getTaskById,
   initDb,
+  insertTaskAttachment,
 } from "../be/db";
 import { insertScript } from "../be/scripts/db";
 import { handleAssets } from "../http/assets";
@@ -343,4 +346,129 @@ describe("asset namespace REST contract", () => {
     expect(audit.body.structuralValid).toBe(true);
     expect(audit.body.warningCount).toBe(0);
   });
+
+  test("cascade moves descendants and sourced mappings without stamping task activity", async () => {
+    const root = await createTaskExtended("cascade root", { agentId, key: "shared/cascade/" });
+    const child = await createTaskExtended("cascade child", { agentId, parentTaskId: root.id });
+    const leaf = await createTaskExtended("cascade leaf", { agentId, parentTaskId: child.id });
+    const unchanged = await createTaskExtended("already moved", {
+      agentId,
+      parentTaskId: root.id,
+      key: "shared/cascade-target/",
+    });
+    const provider = { providerId: "agent-fs", providerKey: "cascade-file.md" };
+    await insertTaskAttachment({
+      taskId: leaf.id,
+      name: "cascade-file.md",
+      kind: "agent-fs",
+      ...provider,
+    });
+    const mapping = (await getAssetKeyMappingByProvider(provider))!;
+    const lastUpdatedAt = "2026-01-01T00:00:00.000Z";
+    for (const task of [root, child, leaf, unchanged]) {
+      await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+        lastUpdatedAt,
+        task.id,
+      ]);
+    }
+    const move = await api(
+      "PATCH",
+      `/api/assets/task/${root.id}/key`,
+      {
+        key: "shared/cascade-target/",
+        cascade: true,
+      },
+      { agentId },
+    );
+    expect(move.status).toBe(200);
+    expect(move.body.movedTaskIds).toEqual([root.id, child.id, leaf.id]);
+    for (const task of [root, child, leaf, unchanged]) {
+      const moved = (await getTaskById(task.id))!;
+      expect(moved.key).toBe("shared/cascade-target/");
+      expect(moved.lastUpdatedAt).toBe(lastUpdatedAt);
+    }
+    expect((await getAssetKeyMappingByProvider(provider))?.key).toBe("shared/cascade-target/");
+    const history = await getDbClient().query<{ entity_id: string }>(
+      "SELECT entity_id FROM asset_key_history WHERE entity_id IN (?, ?, ?, ?, ?) AND new_key = ?",
+      [root.id, child.id, leaf.id, unchanged.id, mapping.id, "shared/cascade-target/"],
+    );
+    expect(history.map((row) => row.entity_id).sort()).toEqual(
+      [root.id, child.id, leaf.id, mapping.id].sort(),
+    );
+    expect(
+      (
+        await api(
+          "PATCH",
+          `/api/assets/task/${root.id}/key`,
+          {
+            key: "shared/cascade-target/",
+            cascade: true,
+          },
+          { agentId },
+        )
+      ).body.movedTaskIds,
+    ).toEqual([]);
+
+    // The root can already have the destination key while descendants still need a move.
+    await getDbClient().run('UPDATE agent_tasks SET "key" = ? WHERE id = ?', [
+      "shared/other-child/",
+      child.id,
+    ]);
+    expect(
+      (
+        await api(
+          "PATCH",
+          `/api/assets/task/${root.id}/key`,
+          {
+            key: "shared/cascade-target/",
+            cascade: true,
+          },
+          { agentId },
+        )
+      ).body.movedTaskIds,
+    ).toEqual([child.id]);
+  });
+
+  test("cascade denies the whole move when a descendant is not authorized", async () => {
+    const root = await createTaskExtended("allowed root", { agentId });
+    const child = await createTaskExtended("denied child", {
+      agentId: secondAgentId,
+      creatorAgentId: secondAgentId,
+      parentTaskId: root.id,
+    });
+    const move = await api(
+      "PATCH",
+      `/api/assets/task/${root.id}/key`,
+      {
+        key: "shared/must-not-move/",
+        cascade: true,
+      },
+      { agentId },
+    );
+    expect(move.status).toBe(403);
+    expect((await getTaskById(root.id))?.key).toBe(root.key);
+    expect((await getTaskById(child.id))?.key).toBe(child.key);
+    expect(
+      await getDbClient().query("SELECT id FROM asset_key_history WHERE entity_id IN (?, ?)", [
+        root.id,
+        child.id,
+      ]),
+    ).toEqual([]);
+  });
+
+  test("cascade is rejected for non-task entities", async () => {
+    for (const entityType of ["workflow", "schedule", "page", "file", "app", "script"]) {
+      const move = await api(
+        "PATCH",
+        `/api/assets/${entityType}/${crypto.randomUUID()}/key`,
+        {
+          key: "shared/invalid-cascade/",
+          cascade: true,
+        },
+        { operator: true },
+      );
+      expect(move.status).toBe(400);
+      expect(move.body.error).toContain("only supported for task");
+    }
+  });
 });