@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/tests/swarm-diff.test.ts

@@ -32,7 +32,11 @@ type StubInstance = {
   innerHTML: string;
   textContent: string;
   isConnected: boolean;
+  style: { cssText: string; transform: string };
+  children: StubInstance[];
+  hasAttribute?: (name: string) => boolean;
   connectedCallback?: () => void;
+  disconnectedCallback?: () => void;
   dispatchEvent: (evt: unknown) => boolean;
 };
 
@@ -44,24 +48,52 @@ type StubInstance = {
  * callers can simulate the real-browser parse-order race
  * (`connectedCallback` fires → children get appended → microtask drains).
  */
-function makeRig(): {
+function makeRig(
+  swarmSdk?: unknown,
+  readyState = "complete",
+  sdkConstructor?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> },
+): {
   Ctor: new () => StubInstance;
+  CursorsCtor: new () => StubInstance;
+  SdkCtor?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> };
+  body: StubInstance;
   setText: (el: StubInstance, attrs: Record<string, string>, text: string) => void;
+  fireDocumentEvent: (name: string, event: unknown) => void;
+  fireNextFrame: () => void;
   flushMicrotasks: () => Promise<void>;
 } {
   const registry = new Map<string, new () => StubInstance>();
+  const documentListeners = new Map<string, ((event: unknown) => void)[]>();
+  const animationFrames = new Map<number, (time: number) => void>();
+  let nextAnimationFrame = 1;
 
   class StubHTMLElement {
     innerHTML = "";
     textContent = "";
     isConnected = true;
+    style = { cssText: "", transform: "" };
+    parentNode: StubHTMLElement | null = null;
+    children: StubHTMLElement[] = [];
     _attrs: Record<string, string> = {};
     getAttribute(name: string): string | null {
       return this._attrs[name] ?? null;
     }
+    hasAttribute(name: string): boolean {
+      return Object.hasOwn(this._attrs, name);
+    }
     setAttribute(name: string, value: string): void {
       this._attrs[name] = value;
     }
+    appendChild(child: StubHTMLElement): StubHTMLElement {
+      child.parentNode = this;
+      this.children.push(child);
+      return child;
+    }
+    removeChild(child: StubHTMLElement): StubHTMLElement {
+      this.children = this.children.filter((item) => item !== child);
+      child.parentNode = null;
+      return child;
+    }
     connectedCallback?(): void;
     closest(_selector: string): null {
       return null;
@@ -85,6 +117,20 @@ function makeRig(): {
 
   const win = {
     customElements,
+    swarmSdk: swarmSdk as
+      | { room?: (name: string, options?: unknown) => Promise<unknown> }
+      | undefined,
+    SwarmSDK: sdkConstructor,
+    innerWidth: 1000,
+    innerHeight: 500,
+    scrollX: 0,
+    scrollY: 0,
+    requestAnimationFrame: (callback: (time: number) => void) => {
+      const id = nextAnimationFrame++;
+      animationFrames.set(id, callback);
+      return id;
+    },
+    cancelAnimationFrame: (id: number) => animationFrames.delete(id),
     swarmUi: undefined as { renderDiff?: (rootEl: unknown, data: unknown) => void } | undefined,
     HTMLElement: StubHTMLElement,
     CustomEvent: class {
@@ -96,10 +142,27 @@ function makeRig(): {
   };
 
   // Provide `document` stubs the jump-list path uses.
+  const body = new StubHTMLElement();
   const doc = {
+    readyState,
+    documentElement: { scrollWidth: 1000, scrollHeight: 500, clientWidth: 1000, clientHeight: 500 },
+    body,
+    createElement: () => new StubHTMLElement(),
     querySelectorAll: () => [],
-    addEventListener: () => {},
-    removeEventListener: () => {},
+    addEventListener: (name: string, handler: (event: unknown) => void) => {
+      const handlers = documentListeners.get(name) ?? [];
+      handlers.push(handler);
+      documentListeners.set(name, handlers);
+    },
+    removeEventListener: (name: string, handler: (event: unknown) => void) => {
+      documentListeners.set(
+        name,
+        (documentListeners.get(name) ?? []).filter((item) => item !== handler),
+      );
+    },
+    fireEvent: (name: string, event: unknown) => {
+      for (const handler of documentListeners.get(name) ?? []) handler(event);
+    },
   };
 
   // Evaluate SWARM_UI_JS with our stubs in scope. The IIFE inside the
@@ -113,9 +176,9 @@ function makeRig(): {
     "CustomEvent",
     "queueMicrotask",
     "console",
-    `${SWARM_UI_JS}\nreturn window.customElements.get('swarm-diff');`,
+    `${SWARM_UI_JS}\nreturn { diff: window.customElements.get('swarm-diff'), cursors: window.customElements.get('swarm-cursors'), sdk: window.SwarmSDK };`,
   );
-  const Ctor = factory(
+  const constructors = factory(
     win,
     customElements,
     doc,
@@ -123,20 +186,39 @@ function makeRig(): {
     win.CustomEvent,
     queueMicrotask,
     console,
-  ) as (new () => StubInstance) | undefined;
+  ) as {
+    diff?: new () => StubInstance;
+    cursors?: new () => StubInstance;
+    sdk?: new () => { room: (name?: string, options?: unknown) => Promise<unknown> };
+  };
+  const Ctor = constructors.diff;
   if (!Ctor) throw new Error("custom element did not register");
+  const CursorsCtor = constructors.cursors;
+  if (!CursorsCtor) throw new Error("swarm-cursors custom element did not register");
 
   return {
     Ctor,
+    CursorsCtor,
+    SdkCtor: constructors.sdk,
+    body,
     setText(el, attrs, text) {
       (el as unknown as { _attrs: Record<string, string> })._attrs = attrs;
       el.textContent = text;
     },
+    fireDocumentEvent(name, event) {
+      doc.fireEvent(name, event);
+    },
+    fireNextFrame() {
+      const next = animationFrames.entries().next().value as
+        | [number, (time: number) => void]
+        | undefined;
+      if (!next) return;
+      animationFrames.delete(next[0]);
+      next[1](0);
+    },
     async flushMicrotasks() {
-      // Two yields: one drains the connectedCallback microtask, the next one
-      // drains anything queued by the render path itself.
-      await Promise.resolve();
-      await Promise.resolve();
+      // Drain the chained async room-open and render callbacks.
+      for (let i = 0; i < 5; i++) await Promise.resolve();
     },
   };
 }
@@ -164,6 +246,7 @@ describe("SWARM_UI_JS", () => {
   test("defines swarm-diff + swarm-diff-jumps custom elements", () => {
     expect(SWARM_UI_JS).toContain("customElements.define('swarm-diff'");
     expect(SWARM_UI_JS).toContain("customElements.define('swarm-diff-jumps'");
+    expect(SWARM_UI_JS).toContain("customElements.define('swarm-cursors'");
   });
 
   test("exposes window.swarmUi.renderDiff as a programmatic entry point", () => {
@@ -172,6 +255,229 @@ describe("SWARM_UI_JS", () => {
   });
 });
 
+describe("<swarm-cursors> presence merge", () => {
+  test("reuses a page room's schema and preserves page presence fields", async () => {
+    const sent: unknown[] = [];
+    const roomOptions: unknown[] = [];
+    const roomHandlers = new Map<string, (value: unknown) => void>();
+    let closeCount = 0;
+    const room = {
+      me: { userId: "self" },
+      presence: {
+        peers: [] as unknown[],
+        set(data: unknown) {
+          sent.push(structuredClone(data));
+        },
+      },
+      on(name: string, handler: (value: unknown) => void) {
+        roomHandlers.set(name, handler);
+        return () => roomHandlers.delete(name);
+      },
+      async close() {
+        closeCount++;
+      },
+    };
+    let pageRoomSchema: number | undefined;
+    class PageSdk {
+      async room(_name?: string, options?: unknown) {
+        const requestedSchema =
+          (options as { schemaVersion?: number } | undefined)?.schemaVersion ?? 1;
+        if (pageRoomSchema !== undefined && requestedSchema !== pageRoomSchema)
+          throw new Error("Room already opened with a different schema version");
+        pageRoomSchema = requestedSchema;
+        roomOptions.push(options);
+        return room;
+      }
+    }
+    const swarmSdk = new PageSdk();
+    const rig = makeRig(swarmSdk, "loading", PageSdk);
+    if (!rig.SdkCtor) throw new Error("SDK constructor was not wrapped");
+    expect(swarmSdk).toBeInstanceOf(rig.SdkCtor);
+    const pageSdk = new rig.SdkCtor();
+
+    // Page code may set its data before the cursor element connects.
+    const board = (await pageSdk.room(undefined, { schemaVersion: 2 })) as typeof room;
+    const mismatchedOpens = await Promise.allSettled([
+      pageSdk.room(undefined, { schemaVersion: 3 }),
+      pageSdk.room(undefined, { schemaVersion: 4 }),
+    ]);
+    expect(mismatchedOpens.map(({ status }) => status)).toEqual(["rejected", "rejected"]);
+    board.presence.set({ selectedCard: "card-1" });
+
+    const cursors = new rig.CursorsCtor();
+    rig.setText(cursors, { room: "default" }, "");
+    cursors.connectedCallback?.();
+    rig.fireDocumentEvent("DOMContentLoaded", undefined);
+    await rig.flushMicrotasks();
+    rig.fireDocumentEvent("pointermove", { pageX: 250, pageY: 125, clientX: 250, clientY: 125 });
+
+    expect(sent.at(-1)).toEqual({ selectedCard: "card-1", __cursor: { x: 0.25, y: 0.25 } });
+
+    // Later page updates also keep the active cursor in the replacement payload.
+    board.presence.set({ selectedCard: "card-2", tool: "pen" });
+    expect(sent.at(-1)).toEqual({
+      selectedCard: "card-2",
+      tool: "pen",
+      __cursor: { x: 0.25, y: 0.25 },
+    });
+    rig.fireDocumentEvent("pointerleave", undefined);
+    expect(sent.at(-1)).toEqual({ selectedCard: "card-2", tool: "pen" });
+    cursors.disconnectedCallback?.();
+    await rig.flushMicrotasks();
+    expect(roomOptions).toEqual([{ schemaVersion: 2 }]);
+    expect(closeCount).toBe(0);
+  });
+
+  test("closes a cursor-only room when the element disconnects", async () => {
+    let closeCount = 0;
+    const room = {
+      me: { userId: "self" },
+      presence: { peers: [], set: () => {} },
+      on: () => () => {},
+      async close() {
+        closeCount++;
+      },
+    };
+    const rig = makeRig({ room: async () => room });
+    const cursors = new rig.CursorsCtor();
+    rig.setText(cursors, { room: "cursor-only" }, "");
+    cursors.connectedCallback?.();
+    await rig.flushMicrotasks();
+
+    cursors.disconnectedCallback?.();
+    await rig.flushMicrotasks();
+    expect(closeCount).toBe(1);
+  });
+
+  test("keeps a shared cursor active while another cursor element remains", async () => {
+    const sent: unknown[] = [];
+    let closeCount = 0;
+    const room = {
+      me: { userId: "self" },
+      presence: {
+        peers: [],
+        set(data: unknown) {
+          sent.push(structuredClone(data));
+        },
+      },
+      on: () => () => {},
+      async close() {
+        closeCount++;
+      },
+    };
+    const rig = makeRig({ room: async () => room });
+    const first = new rig.CursorsCtor();
+    const second = new rig.CursorsCtor();
+    rig.setText(first, { room: "shared" }, "");
+    rig.setText(second, { room: "shared" }, "");
+    first.connectedCallback?.();
+    await rig.flushMicrotasks();
+
+    rig.fireDocumentEvent("pointermove", { pageX: 100, pageY: 100, clientX: 100, clientY: 100 });
+    second.connectedCallback?.();
+    await rig.flushMicrotasks();
+    first.disconnectedCallback?.();
+    expect(sent.at(-1)).toEqual({ __cursor: { x: 0.1, y: 0.2 } });
+    expect(closeCount).toBe(0);
+
+    second.disconnectedCallback?.();
+    await rig.flushMicrotasks();
+    expect(sent.at(-1)).toEqual({});
+    expect(closeCount).toBe(1);
+  });
+
+  test("uses a page room reopened after close", async () => {
+    const firstSent: unknown[] = [];
+    const reopenedSent: unknown[] = [];
+    let firstCloseCount = 0;
+    let reopenedCloseCount = 0;
+    const makeRoom = (sent: unknown[], onClose: () => void) => ({
+      me: { userId: "self" },
+      presence: {
+        peers: [],
+        set(data: unknown) {
+          sent.push(structuredClone(data));
+        },
+      },
+      on: () => () => {},
+      async close() {
+        onClose();
+      },
+    });
+    const firstRoom = makeRoom(firstSent, () => firstCloseCount++);
+    const reopenedRoom = makeRoom(reopenedSent, () => reopenedCloseCount++);
+    let roomOpens = 0;
+    const swarmSdk = {
+      room: async (_name?: string) => (roomOpens++ === 0 ? firstRoom : reopenedRoom),
+    };
+    const rig = makeRig(swarmSdk);
+    const board = await swarmSdk.room("board");
+    await board.close();
+    await swarmSdk.room("board");
+
+    const cursors = new rig.CursorsCtor();
+    rig.setText(cursors, { room: "board" }, "");
+    cursors.connectedCallback?.();
+    await rig.flushMicrotasks();
+    rig.fireDocumentEvent("pointermove", { pageX: 300, pageY: 100, clientX: 300, clientY: 100 });
+
+    expect(roomOpens).toBe(2);
+    expect(firstSent).toHaveLength(0);
+    expect(reopenedSent.at(-1)).toEqual({ __cursor: { x: 0.3, y: 0.2 } });
+    cursors.disconnectedCallback?.();
+    expect(reopenedCloseCount).toBe(0);
+  });
+
+  test("renders remote people and removes an unchanged cursor after idle", async () => {
+    const roomHandlers = new Map<string, (value: unknown) => void>();
+    const room = {
+      me: { userId: "self" },
+      presence: { peers: [], set: () => {} },
+      on(name: string, handler: (value: unknown) => void) {
+        roomHandlers.set(name, handler);
+        return () => roomHandlers.delete(name);
+      },
+      async close() {},
+    };
+    const rig = makeRig({ room: async () => room });
+    const cursors = new rig.CursorsCtor();
+    rig.setText(cursors, { room: "board" }, "");
+    cursors.connectedCallback?.();
+
+    const realNow = Date.now;
+    let now = 1000;
+    Date.now = () => now;
+    try {
+      await rig.flushMicrotasks();
+      const peers = [
+        { userId: "self", name: "Self", kind: "human", data: { __cursor: { x: 0.1, y: 0.1 } } },
+        { userId: "agent-1", name: "Agent", kind: "agent", data: { __cursor: { x: 0.9, y: 0.9 } } },
+        {
+          userId: "person-1",
+          name: "Avery",
+          kind: "human",
+          data: { __cursor: { x: 0.25, y: 0.5 } },
+        },
+      ];
+      roomHandlers.get("presence")?.(peers);
+
+      const overlay = rig.body.children[0] as StubInstance;
+      expect(overlay.children).toHaveLength(1);
+      expect(overlay.children[0]?.innerHTML).toContain("Avery");
+      expect(overlay.children[0]?.innerHTML).toContain("<svg");
+      rig.fireNextFrame();
+      expect(overlay.children[0]?.style.transform).toBe("translate3d(250px,250px,0)");
+
+      now = 5000;
+      roomHandlers.get("presence")?.(peers);
+      expect(overlay.children).toHaveLength(0);
+    } finally {
+      Date.now = realNow;
+      cursors.disconnectedCallback?.();
+    }
+  });
+});
+
 describe("<swarm-diff> render", () => {
   test("constructs and renders without throwing on the example input", async () => {
     const html = await renderViaStub(JSON.stringify(EXAMPLE_HUNK), {

package/src/tests/task-completion-idempotency.test.ts

@@ -831,7 +831,7 @@ describe("worker task follow-up creation", () => {
     expect(rows[0]!.task).not.toContain("post the URL");
   });
 
-  test("inherits followUpConfig from parent task when child has no override", async () => {
+  test("a continuation inherits followUpConfig from its parent when it has no override", async () => {
     await createAgent({
       name: "follow-up-lead-inheritance",
       isLead: true,
@@ -851,6 +851,7 @@ describe("worker task follow-up creation", () => {
     const child = await createTaskExtended("Child task", {
       agentId: worker.id,
       parentTaskId: parent.id,
+      inheritParentFollowUpConfig: true,
     });
     await startTask(child.id);
 

package/src/tests/tasks-requested-by-filter.test.ts

@@ -206,7 +206,9 @@ describe("GET /api/tasks — requestedByUserId route wiring", () => {
       requestedByUserId: routeUserId,
     });
 
-    const res = await listTasks("&requestedByUserId=00000000-0000-4000-8000-000000000000");
+    const res = await listTasks(
+      "&requestedByUserId=00000000-0000-4000-8000-000000000000&includeTotal=true",
+    );
     expect(res.status).toBe(200);
     const body = (await res.json()) as { tasks: unknown[]; total: number };
     expect(body.tasks).toEqual([]);

package/src/tests/tool-annotations.test.ts

@@ -378,7 +378,7 @@ describe("Tool Annotations & Classification", () => {
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(148);
+    expect(count).toBeLessThanOrEqual(149);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/ui-list-slim-projections.test.ts

@@ -0,0 +1,158 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import {
+  closeDb,
+  createApprovalRequest,
+  createScheduledTask,
+  initDb,
+  listApprovalRequestSummaries,
+  listApprovalRequests,
+  resolveApprovalRequest,
+} from "../be/db";
+import { handleApprovalRequests } from "../http/approval-requests";
+import { handleStats } from "../http/stats";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-ui-list-slim-projections.sqlite";
+
+/**
+ * `/api/scheduled-tasks` and `/api/approval-requests` serve the UI list pages.
+ * `fields=slim` is opt-in: callers that don't pass it keep the full rows.
+ */
+describe("UI list slim projections", () => {
+  let server: Server;
+  let baseUrl = "";
+  let approvalId = "";
+  const template = `T${"x".repeat(5000)}`;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+
+    server = createHttpServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const segments = url.pathname.split("/").filter(Boolean);
+      if (await handleStats(req, res, segments, url.searchParams)) return;
+      if (await handleApprovalRequests(req, res, segments, url.searchParams)) return;
+      res.writeHead(404);
+      res.end();
+    });
+    baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+
+    await createScheduledTask({
+      name: "slim-list-schedule",
+      taskTemplate: template,
+      cronExpression: "0 9 * * *",
+      description: "daily report",
+    });
+
+    approvalId = crypto.randomUUID();
+    await createApprovalRequest({
+      id: approvalId,
+      title: "Ship it?",
+      questions: [
+        { id: "q1", type: "approval", label: "Approve?", description: "D".repeat(2000) },
+        { id: "q2", type: "text", label: "Why?" },
+      ],
+      approvers: { policy: "any" },
+      sourceTaskId: "source-task-1",
+      timeoutSeconds: 3600,
+      notificationChannels: [{ channel: "slack", target: "C123" }],
+    });
+    await resolveApprovalRequest(approvalId, {
+      status: "approved",
+      responses: { q1: { approved: true }, q2: "because" },
+      resolvedBy: "user-1",
+    });
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  async function get(path: string) {
+    const res = await fetch(`${baseUrl}${path}`);
+    expect(res.status).toBe(200);
+    return (await res.json()) as Record<string, Array<Record<string, unknown>>>;
+  }
+
+  test("/api/scheduled-tasks keeps full rows by default", async () => {
+    const { scheduledTasks } = await get("/api/scheduled-tasks");
+    const row = scheduledTasks.find((s) => s.name === "slim-list-schedule");
+    expect(row?.taskTemplate).toBe(template);
+    expect(row && "taskTemplatePreview" in row).toBe(false);
+  });
+
+  test("/api/scheduled-tasks?fields=slim swaps taskTemplate for a preview", async () => {
+    const { scheduledTasks } = await get("/api/scheduled-tasks?fields=slim");
+    const row = scheduledTasks.find((s) => s.name === "slim-list-schedule");
+    expect(row).toBeDefined();
+    expect(row && "taskTemplate" in row).toBe(false);
+    expect(String(row?.taskTemplatePreview).length).toBeLessThan(template.length);
+    // Every other field the schedules list page reads is identical to the full row.
+    const full = (await get("/api/scheduled-tasks")).scheduledTasks.find(
+      (s) => s.name === "slim-list-schedule",
+    );
+    const { taskTemplate: _omitted, ...fullWithoutTemplate } = full ?? {};
+    const { taskTemplatePreview: _preview, ...slimWithoutPreview } = row ?? {};
+    expect(slimWithoutPreview).toEqual(fullWithoutTemplate);
+  });
+
+  test("/api/approval-requests keeps full rows by default", async () => {
+    const { approvalRequests } = await get("/api/approval-requests");
+    const row = approvalRequests.find((r) => r.id === approvalId);
+    expect(row?.questions).toHaveLength(2);
+    expect(row?.responses).toEqual({ q1: { approved: true }, q2: "because" });
+    expect(row && "questionCount" in row).toBe(false);
+  });
+
+  test("/api/approval-requests?fields=slim drops bodies and counts questions", async () => {
+    const { approvalRequests } = await get("/api/approval-requests?fields=slim&status=approved");
+    const row = approvalRequests.find((r) => r.id === approvalId);
+    expect(row).toBeDefined();
+    for (const dropped of [
+      "questions",
+      "approvers",
+      "responses",
+      "resolutionReason",
+      "notificationChannels",
+    ]) {
+      expect(row && dropped in row).toBe(false);
+    }
+    expect(row?.questionCount).toBe(2);
+    expect(row?.title).toBe("Ship it?");
+    expect(row?.status).toBe("approved");
+    expect(row?.resolvedBy).toBe("user-1");
+    expect(row?.sourceTaskId).toBe("source-task-1");
+    expect(row?.workflowRunId).toBeNull();
+    expect(typeof row?.createdAt).toBe("string");
+    expect(typeof row?.expiresAt).toBe("string");
+  });
+
+  test("slim and full DB reads agree on filters, order and limit", async () => {
+    for (let i = 0; i < 3; i++) {
+      await createApprovalRequest({
+        id: crypto.randomUUID(),
+        title: `pending ${i}`,
+        questions: [{ id: "q1", type: "boolean", label: "Ok?" }],
+        approvers: { policy: "any" },
+      });
+    }
+    const filters = { status: "pending", limit: 2 };
+    const full = await listApprovalRequests(filters);
+    const slim = await listApprovalRequestSummaries(filters);
+    expect(slim.map((r) => r.id)).toEqual(full.map((r) => r.id));
+    expect(slim.map((r) => r.questionCount)).toEqual(full.map((r) => r.questions.length));
+  });
+});