@desplega.ai/agent-swarm 2.4.3 → 2.4.5

package/src/tests/apps-action-parent-task.test.ts

@@ -0,0 +1,295 @@
+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 { parseAppDefinition } from "../apps/definition";
+import { createApp } from "../apps/store";
+import {
+  closeDb,
+  createAgent,
+  createTask,
+  createTaskExtended,
+  createUser,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { type IdentityActor, mintToken } from "../be/users";
+import { handleApps } from "../http/apps";
+import { resolveHttpRequestAuth } from "../http/auth";
+import { SESSION_WRITE_DENIED } from "../http/session-access";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { setRequestAuth } from "../utils/request-auth-context";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = `/private/tmp/test-apps-action-parent-task-${process.pid}.sqlite`;
+const API_KEY = "example-apps-action-parent-task-key";
+const OPERATOR_ACTOR: IdentityActor = { kind: "operator", id: "apps-action-parent-task-test" };
+/** Non-lead worker: the default caller. */
+const AGENT_ID = crypto.randomUUID();
+const LEAD_ID = crypto.randomUUID();
+/** Owns the parent task the worker has no context for. */
+const OTHER_AGENT_ID = crypto.randomUUID();
+const TASK_ACTION = "generateScreen";
+const SYNC_ACTION = "syncNotes";
+const CHAIN_ISSUE = "$row, $rowIndex, $form, and $chain bindings are only allowed in action params";
+
+let server: Server;
+let base = "";
+/** A user with no share on anyone else's session. */
+let userToken = "";
+let previousApiKey: string | undefined;
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    setRequestAuth(req, await resolveHttpRequestAuth(req, API_KEY));
+    res.setHeader("Content-Type", "application/json");
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleApps(req, res, pathSegments, queryParams, myAgentId);
+    if (!handled) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "not found" }));
+    }
+  });
+}
+
+/** Runs an action as an agent (default: the worker) or, with `bearer`, as a token holder. */
+async function runAction<T>(
+  appId: string,
+  body: Record<string, unknown>,
+  options: { agentId?: string; bearer?: string; action?: string } = {},
+): Promise<{ status: number; body: T }> {
+  const action = options.action ?? TASK_ACTION;
+  const response = await fetch(`${base}/api/apps/${appId}/actions/${action}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(options.bearer
+        ? { Authorization: `Bearer ${options.bearer}` }
+        : { "X-Agent-ID": options.agentId ?? AGENT_ID }),
+    },
+    body: JSON.stringify(body),
+  });
+  return { status: response.status, body: (await response.json()) as T };
+}
+
+/** A page whose Button chains a task-kind action under the chain scope's leaf task. */
+function chainedButtonPage() {
+  return {
+    root: "root",
+    elements: {
+      root: { type: "Container", props: {}, children: ["send"] },
+      send: {
+        type: "Button",
+        props: { label: "Send" },
+        on: {
+          press: [
+            {
+              action: "app.action",
+              params: {
+                name: TASK_ACTION,
+                input: { prompt: "next step" },
+                parentTaskId: { $chain: "leafTaskId" },
+              },
+            },
+          ],
+        },
+      },
+    },
+  };
+}
+
+function definitionWith(page: Record<string, unknown>) {
+  return {
+    models: {
+      note: {
+        columns: { title: { kind: "string" } },
+        // The sync action needs one (model x source) pair to be valid.
+        sources: { tracker: { connector: "swarm-tasks", joinKey: "title" } },
+      },
+    },
+    queries: { allNotes: { model: "note" } },
+    actions: {
+      [TASK_ACTION]: { kind: "task", prompt: "Generate the next screen" },
+      // A non-task action, to show parentTaskId is rejected rather than dropped.
+      [SYNC_ACTION]: { kind: "sync" },
+    },
+    pages: { main: page },
+    defaultPage: "main",
+  };
+}
+
+/** Stores the chained-Button app the way the API does: validated first. */
+async function createChainedApp(): Promise<string> {
+  const parsed = await parseAppDefinition(definitionWith(chainedButtonPage()));
+  if (!parsed.success) throw new Error(JSON.stringify(parsed.issues));
+  const app = await createApp({
+    name: `Chained ${crypto.randomUUID()}`,
+    definition: parsed.definition,
+  });
+  return app.id;
+}
+
+beforeAll(async () => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+  // Safe to mutate: CI runs one process per test file (`bun test --parallel=4`)
+  // and afterAll restores the previous value.
+  previousApiKey = process.env.AGENT_SWARM_API_KEY;
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  initDb(TEST_DB_PATH);
+  const user = await createUser({ name: "Parent Task User" });
+  userToken = (await mintToken(user.id, "apps-action-parent-task", OPERATOR_ACTOR)).plaintext;
+  await createAgent({ id: AGENT_ID, name: "parent-task-worker", isLead: false, status: "idle" });
+  await createAgent({ id: LEAD_ID, name: "parent-task-lead", isLead: true, status: "idle" });
+  await createAgent({
+    id: OTHER_AGENT_ID,
+    name: "parent-task-other",
+    isLead: false,
+    status: "idle",
+  });
+  server = createTestServer();
+  const port = await listenOnFreePort(server, "127.0.0.1");
+  base = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  if (previousApiKey === undefined) delete process.env.AGENT_SWARM_API_KEY;
+  else process.env.AGENT_SWARM_API_KEY = previousApiKey;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("$chain sentinel in the page validator", () => {
+  test("accepts parentTaskId: { $chain } inside an app.action step's params", async () => {
+    const parsed = await parseAppDefinition(definitionWith(chainedButtonPage()));
+    expect(parsed.success).toBe(true);
+  });
+
+  test("accepts a $chain sentinel nested deeper inside app.action params", async () => {
+    const page = chainedButtonPage();
+    page.elements.send.on.press[0]!.params = {
+      name: TASK_ACTION,
+      input: { context: { parentTaskId: { $chain: "leafTaskId" } } },
+    };
+    const parsed = await parseAppDefinition(definitionWith(page));
+    expect(parsed.success).toBe(true);
+  });
+
+  test("rejects a $chain sentinel used as a plain prop value", async () => {
+    const page = chainedButtonPage();
+    page.elements = {
+      ...page.elements,
+      echo: { type: "Text", props: { content: { $chain: "leafTaskId" } } },
+    } as typeof page.elements;
+    page.elements.root.children = ["send", "echo"];
+    const parsed = await parseAppDefinition(definitionWith(page));
+    expect(parsed.success).toBe(false);
+    if (parsed.success) return;
+    expect(parsed.issues.some((entry) => entry.message === CHAIN_ISSUE)).toBe(true);
+  });
+});
+
+describe("POST /api/apps/:id/actions/:name with parentTaskId", () => {
+  test("chains the created task under the given parent", async () => {
+    const appId = await createChainedApp();
+    const parent = await createTask(AGENT_ID, "Previous turn of the chain");
+
+    const started = await runAction<{ ok: boolean; taskId: string; status: string }>(appId, {
+      input: { prompt: "next step" },
+      parentTaskId: parent.id,
+    });
+    expect(started.status).toBe(200);
+    expect(started.body).toMatchObject({ ok: true, status: "pending" });
+
+    const created = await getTaskById(started.body.taskId);
+    expect(created?.parentTaskId).toBe(parent.id);
+  });
+
+  test("answers 404 for an unknown parent instead of storing a dangling id", async () => {
+    const appId = await createChainedApp();
+    const missing = await runAction<{ error: string }>(appId, {
+      input: {},
+      parentTaskId: crypto.randomUUID(),
+    });
+    expect(missing.status).toBe(404);
+    expect(missing.body.error).toBe("parent task not found");
+  });
+
+  test("denies an agent caller without context for the parent, as POST /api/tasks does", async () => {
+    const appId = await createChainedApp();
+    const foreign = await createTask(OTHER_AGENT_ID, "Someone else's thread");
+
+    const denied = await runAction<{ error: string }>(appId, {
+      input: {},
+      parentTaskId: foreign.id,
+    });
+    expect(denied.status).toBe(403);
+    expect(denied.body.error).toBe(`You don't have context for parent task ${foreign.id}.`);
+
+    // A lead keeps its `task.parent.attach` grant: the gate is about identity, not the route.
+    const asLead = await runAction<{ taskId: string }>(
+      appId,
+      { input: {}, parentTaskId: foreign.id },
+      { agentId: LEAD_ID },
+    );
+    expect(asLead.status).toBe(200);
+    expect((await getTaskById(asLead.body.taskId))?.parentTaskId).toBe(foreign.id);
+  });
+
+  test("denies a user caller without a write share on the parent's session", async () => {
+    const appId = await createChainedApp();
+    const owner = await createUser({ name: "Session Owner" });
+    const theirs = await createTaskExtended("Someone else's session", {
+      agentId: OTHER_AGENT_ID,
+      requestedByUserId: owner.id,
+    });
+
+    const denied = await runAction<{ error: string }>(
+      appId,
+      { input: {}, parentTaskId: theirs.id },
+      { bearer: userToken },
+    );
+    expect(denied.status).toBe(403);
+    expect(denied.body.error).toBe(SESSION_WRITE_DENIED);
+  });
+
+  test("rejects parentTaskId on a non-task action instead of dropping it", async () => {
+    const appId = await createChainedApp();
+    const parent = await createTask(AGENT_ID, "Previous turn of the chain");
+
+    const rejected = await runAction<{ error: string }>(
+      appId,
+      { input: {}, parentTaskId: parent.id },
+      { action: SYNC_ACTION },
+    );
+    expect(rejected.status).toBe(400);
+    expect(rejected.body.error).toBe("parentTaskId is only supported for task-kind actions");
+  });
+
+  test("rejects an empty parentTaskId", async () => {
+    const appId = await createChainedApp();
+    const rejected = await runAction<{ error: string }>(appId, { input: {}, parentTaskId: "" });
+    expect(rejected.status).toBe(400);
+  });
+
+  test("still creates a parentless task when parentTaskId is omitted", async () => {
+    const appId = await createChainedApp();
+    const started = await runAction<{ ok: boolean; taskId: string }>(appId, { input: {} });
+    expect(started.status).toBe(200);
+    expect((await getTaskById(started.body.taskId))?.parentTaskId ?? null).toBeNull();
+  });
+});

package/src/tests/apps-card-grid.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for `CardGrid` and the Table column `format` template.
+ * Pure `parseAppDefinition` calls — no DB, no HTTP — mirroring
+ * `apps-catalog-additions.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+function appWith(elements: Record<string, Element>) {
+  return {
+    models: {
+      doc: {
+        columns: {
+          title: { kind: "string", required: true },
+          author: { kind: "string" },
+          cover: { kind: "string" },
+          status: { kind: "enum", enum: ["draft", "published"], default: "draft" },
+        },
+      },
+    },
+    queries: {
+      docs: { model: "doc" },
+      docById: { model: "doc", filter: { id: { $param: "doc" } } },
+    },
+    pages: {
+      main: { title: "Main", root: "root", elements },
+      detail: {
+        title: "Detail",
+        params: { doc: { kind: "string" }, position: { kind: "number" } },
+        root: "detailRoot",
+        elements: { detailRoot: { type: "Text", props: { content: "Detail" } } },
+      },
+    },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+function cardGrid(props: Record<string, unknown>) {
+  return appWith({
+    root: { type: "Stack", props: {}, children: ["cards"] },
+    cards: {
+      type: "CardGrid",
+      props: {
+        data: { $state: "/queries/docs/data" },
+        loading: { $state: "/queries/docs/loading" },
+        error: { $state: "/queries/docs/error" },
+        titleKey: "title",
+        ...props,
+      },
+    },
+  });
+}
+
+const navigateToDetail = [
+  { action: "app.navigate", params: { page: "detail", params: { doc: { $row: "id" } } } },
+];
+
+describe("CardGrid", () => {
+  test("onClick running app.navigate to a declared page with $row params passes", async () => {
+    const issues = await issuesFor(
+      cardGrid({
+        imageKey: "cover",
+        fields: [
+          { key: "author" },
+          { key: "createdAt", kind: "date" },
+          { key: "status", kind: "badge", tones: { published: "success" } },
+        ],
+        columns: { base: 1, md: 2, lg: 4 },
+        emptyMessage: "No documents yet",
+        onClick: navigateToDetail,
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("$row and $rowIndex are accepted inside the onClick chain", async () => {
+    const issues = await issuesFor(
+      cardGrid({
+        onClick: [
+          { action: "app.refresh", params: { query: "docs" } },
+          {
+            action: "app.navigate",
+            params: {
+              page: "detail",
+              params: { doc: { $row: "id" }, position: { $rowIndex: true } },
+            },
+          },
+        ],
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("$row outside the onClick chain is rejected", async () => {
+    const issues = await issuesFor(cardGrid({ emptyMessage: { $row: "title" } }));
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.emptyMessage`,
+      message: "$row, $rowIndex, $form, and $chain bindings are only allowed in action params",
+    });
+  });
+
+  test("onClick naming an unknown action fails", async () => {
+    const issues = await issuesFor(cardGrid({ onClick: [{ action: "app.nope", params: {} }] }));
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.onClick.0.action`,
+      message: 'unknown action type "app.nope"',
+    });
+  });
+
+  test("onClick navigating to an undeclared page fails", async () => {
+    const issues = await issuesFor(
+      cardGrid({ onClick: [{ action: "app.navigate", params: { page: "nope" } }] }),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("cards")}.props.onClick.0.params.page`,
+      message: 'unknown page "nope"',
+    });
+  });
+
+  test("titleKey is required", async () => {
+    const copy = cardGrid({});
+    delete copy.pages.main.elements.cards!.props!.titleKey;
+    const issues = await issuesFor(copy);
+    expect(issues.some((i) => i.path.startsWith(`${el("cards")}.props`))).toBe(true);
+  });
+
+  test("data bound to a $state path passes", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["cards"] },
+        cards: {
+          type: "CardGrid",
+          props: { data: { $state: "/queries/docs/data" }, titleKey: "title" },
+        },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("an unknown field kind is rejected", async () => {
+    const issues = await issuesFor(cardGrid({ fields: [{ key: "author", kind: "status" }] }));
+    expect(issues.some((i) => i.path.startsWith(`${el("cards")}.props.fields.0.kind`))).toBe(true);
+  });
+});
+
+describe("Table column format", () => {
+  test("a column with a {{field}} format template passes", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["table"] },
+        table: {
+          type: "Table",
+          props: {
+            data: { $state: "/queries/docs/data" },
+            columns: [
+              { key: "title", label: "Document", format: "{{title}} ({{status}})" },
+              { key: "author" },
+            ],
+          },
+        },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("format must be a string", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["table"] },
+        table: {
+          type: "Table",
+          props: {
+            data: { $state: "/queries/docs/data" },
+            columns: [{ key: "title", format: 42 }],
+          },
+        },
+      }),
+    );
+    expect(issues.some((i) => i.path.startsWith(`${el("table")}.props.columns.0.format`))).toBe(
+      true,
+    );
+  });
+});

package/src/tests/apps-catalog-additions.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+import { parseAppDefinition } from "../apps/definition";
+
+/**
+ * Validator coverage for the small catalog additions: `NumberInput`, Select
+ * `defaultValue`, and `fill` on Stack / Split. Pure `parseAppDefinition`
+ * calls — no DB, no HTTP — mirroring `apps-catalog-inputs.test.ts`.
+ */
+
+type Element = { type: string; props?: Record<string, unknown>; children?: string[] };
+
+function appWith(elements: Record<string, Element>) {
+  return {
+    models: {},
+    pages: { main: { title: "Main", root: "root", elements } },
+    defaultPage: "main",
+  };
+}
+
+async function issuesFor(input: unknown) {
+  const parsed = await parseAppDefinition(input);
+  return parsed.success ? [] : parsed.issues;
+}
+
+const el = (id: string) => `pages.main.elements.${id}`;
+
+describe("NumberInput", () => {
+  test("a NumberInput's /ui/<id>/value read by a bound Text validates", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width", "echo"] },
+        width: {
+          type: "NumberInput",
+          props: { id: "x", label: "Width", placeholder: "px", min: 1, max: 4096 },
+        },
+        echo: { type: "Text", props: { content: { $state: "/ui/x/value" } } },
+      }),
+    );
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("a /ui/<id>/value read with no UI control of that id is rejected", async () => {
+    const issues = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["echo"] },
+        echo: { type: "Text", props: { content: { $state: "/ui/x/value" } } },
+      }),
+    );
+    expect(issues).toContainEqual({
+      path: `${el("echo")}.props.content`,
+      message: 'state reference targets unknown UI control "x"',
+    });
+  });
+
+  test("id is required and min/max must be numbers", async () => {
+    const missingId = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width"] },
+        width: { type: "NumberInput", props: { label: "Width" } },
+      }),
+    );
+    expect(missingId.map((issue) => issue.path)).toContain(`${el("width")}.props.id`);
+
+    const badBounds = await issuesFor(
+      appWith({
+        root: { type: "Stack", props: {}, children: ["width"] },
+        width: { type: "NumberInput", props: { id: "x", min: "1", max: "10" } },
+      }),
+    );
+    const paths = badBounds.map((issue) => issue.path);
+    expect(paths).toContain(`${el("width")}.props.min`);
+    expect(paths).toContain(`${el("width")}.props.max`);
+  });
+});
+
+describe("Select defaultValue", () => {
+  const select = (props: Record<string, unknown>) =>
+    appWith({
+      root: { type: "Stack", props: {}, children: ["device", "echo"] },
+      device: {
+        type: "Select",
+        props: { id: "device", options: ["phone", "tablet", "desktop"], ...props },
+      },
+      echo: { type: "Text", props: { content: { $state: "/ui/device/value" } } },
+    });
+
+  test("a Select with defaultValue validates", async () => {
+    const issues = await issuesFor(select({ defaultValue: "tablet" }));
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("defaultValue must be a string", async () => {
+    const paths = (await issuesFor(select({ defaultValue: 2 }))).map((issue) => issue.path);
+    expect(paths).toContain(`${el("device")}.props.defaultValue`);
+  });
+});
+
+describe("Stack and Split fill", () => {
+  const layout = (stackFill: unknown, splitFill: unknown) =>
+    appWith({
+      root: { type: "Stack", props: { fill: stackFill }, children: ["split"] },
+      split: { type: "Split", props: { fill: splitFill, ratio: "1-1" }, children: ["a", "b"] },
+      a: { type: "Text", props: { content: "left" } },
+      b: { type: "Text", props: { content: "right" } },
+    });
+
+  test("fill: true validates on both", async () => {
+    const issues = await issuesFor(layout(true, true));
+    if (issues.length > 0) console.error(issues);
+    expect(issues).toEqual([]);
+  });
+
+  test("fill must be a boolean", async () => {
+    const paths = (await issuesFor(layout("yes", 1))).map((issue) => issue.path);
+    expect(paths).toContain(`${el("root")}.props.fill`);
+    expect(paths).toContain(`${el("split")}.props.fill`);
+  });
+});