@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/tests/pages-browser-sdk.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, mock, test } from "bun:test";
+import { BROWSER_SDK_JS } from "../pages/browser-sdk";
+
+// ─── Browser SDK tests ─────────────────────────────────────────────────
+
+describe("BROWSER_SDK_JS", () => {
+  test("is a non-empty string", () => {
+    expect(typeof BROWSER_SDK_JS).toBe("string");
+    expect(BROWSER_SDK_JS.length).toBeGreaterThan(100);
+  });
+
+  test("contains SwarmSDK class", () => {
+    expect(BROWSER_SDK_JS).toContain("class SwarmSDK");
+  });
+
+  test("is syntactically valid JavaScript", () => {
+    expect(() => new Function(BROWSER_SDK_JS)).not.toThrow();
+  });
+
+  test("exposes the eight canonical domains", () => {
+    const expectedDomains = [
+      "this.tasks",
+      "this.agents",
+      "this.events",
+      "this.memory",
+      "this.repos",
+      "this.schedules",
+      "this.approvalRequests",
+      "this.assets",
+    ];
+    for (const domain of expectedDomains) {
+      expect(BROWSER_SDK_JS).toContain(domain);
+    }
+  });
+
+  test("removed domains are NOT exposed (messages, services, slack)", () => {
+    const removed = ["this.messages", "this.services", "this.slack", "postMessage", "readMessages"];
+    for (const r of removed) {
+      expect(BROWSER_SDK_JS).not.toContain(r);
+    }
+  });
+
+  test("assigns SwarmSDK class + swarmSdk singleton to window", () => {
+    expect(BROWSER_SDK_JS).toContain("window.SwarmSDK = SwarmSDK");
+    expect(BROWSER_SDK_JS).toContain("window.swarmSdk = new SwarmSDK()");
+  });
+
+  test("routes calls through the /@swarm/api/* proxy", () => {
+    expect(BROWSER_SDK_JS).toContain("const base = '/@swarm/api'");
+    // Sentinel endpoints — one per domain.
+    expect(BROWSER_SDK_JS).toContain("'/tasks'");
+    expect(BROWSER_SDK_JS).toContain("'/agents'");
+    expect(BROWSER_SDK_JS).toContain("'/events'");
+    expect(BROWSER_SDK_JS).toContain("'/memory/search'");
+    expect(BROWSER_SDK_JS).toContain("'/repos'");
+    expect(BROWSER_SDK_JS).toContain("'/schedules'");
+    expect(BROWSER_SDK_JS).toContain("'/approval-requests'");
+    expect(BROWSER_SDK_JS).toContain("'/assets'");
+    expect(BROWSER_SDK_JS).toContain("'/assets/key-audit'");
+    expect(BROWSER_SDK_JS).toContain("'/assets/mappings'");
+  });
+
+  test("does not fetch on SDK load or construction", () => {
+    const fetchMock = mock(() => Promise.resolve(Response.json({})));
+    const window = {};
+    const loadSdk = new Function("window", "fetch", `${BROWSER_SDK_JS}\nreturn window.SwarmSDK;`);
+
+    const SwarmSDK = loadSdk(window, fetchMock);
+    expect(window).toHaveProperty("swarmSdk");
+    expect(fetchMock).not.toHaveBeenCalled();
+
+    new SwarmSDK();
+    new SwarmSDK();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/src/tests/pages-feedback-keys.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Typing in the page feedback overlay must not reach the page's own key
+ * handlers. The overlay lives in a shadow root, so outside it the event target
+ * is the shadow host and a page's "ignore keys from a textarea" guard misses:
+ * Space and arrows typed into a comment used to change slides in a deck page.
+ * Page capture listeners on window/document run before anything the overlay
+ * registers later, so a key guard is served first in <head>.
+ */
+import { describe, expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { feedbackKeyGuardScript, feedbackOverlayScripts } from "../pages/feedback-overlay";
+
+type Target = { dispatchEvent(e: unknown): boolean };
+
+function scriptSources(html: string): string[] {
+  return [...html.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1]!);
+}
+
+// Served order: key guard (top of <head>), page scripts, overlay (end of body).
+function overlayPage() {
+  const window = new Window({ url: "https://api.example.test/p/abc" });
+  const document = window.document;
+  document.body.innerHTML = "<h2>Slide title</h2>";
+  for (const source of scriptSources(feedbackKeyGuardScript())) window.eval(source);
+  // A page's key handlers (e.g. a deck's slide navigation), registered before
+  // the overlay, in every phase. They record every key event they see.
+  const pageKeys: string[] = [];
+  for (const type of ["keydown", "keyup", "keypress"]) {
+    const record = (where: string) => (e: Event) =>
+      pageKeys.push(`${where}:${type}:${(e as unknown as KeyboardEvent).key}`);
+    window.addEventListener(type, record("window-capture"), true);
+    document.addEventListener(type, record("document-capture"), true);
+    window.addEventListener(type, record("window-bubble"));
+  }
+  for (const source of scriptSources(feedbackOverlayScripts("abc"))) window.eval(source);
+  const root = document.querySelector("swarm-feedback-root")!.shadowRoot!;
+  return { window, document, root, pageKeys };
+}
+
+function key(window: Window, target: Target, type: string, key: string, init = {}) {
+  target.dispatchEvent(
+    new window.KeyboardEvent(type, { key, bubbles: true, composed: true, ...init }),
+  );
+}
+
+function press(window: Window, target: Target, k: string) {
+  key(window, target, "keydown", k);
+  key(window, target, "keypress", k);
+  key(window, target, "keyup", k);
+}
+
+function openComposer(window: Window, document: Window["document"], root: ShadowRoot) {
+  // Select mode stays on after a comment, so the button is only there the first time.
+  const select = [...root.querySelectorAll("button")].find(
+    (b) => b.textContent === "Select an element",
+  );
+  select?.click();
+  document.querySelector("h2")!.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
+  const comment = root.querySelector("textarea") as unknown as HTMLTextAreaElement | null;
+  expect(comment).not.toBeNull();
+  return comment!;
+}
+
+function savedComments(window: Window): unknown[] {
+  return JSON.parse(window.sessionStorage.getItem("swarm-feedback:abc") || "[]");
+}
+
+describe("page feedback overlay keys", () => {
+  test("keys typed in a comment box never reach page capture or bubble handlers", () => {
+    const { window, document, root, pageKeys } = overlayPage();
+    const comment = openComposer(window, document, root);
+
+    for (const k of [" ", "ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown", "Enter", "PageDown"]) {
+      press(window, comment, k);
+    }
+    expect(pageKeys).toEqual([]);
+    // Escape still closes the composer, and the page never sees it.
+    key(window, comment, "keydown", "Escape");
+    expect(comment.isConnected).toBe(false);
+    expect(pageKeys).toEqual([]);
+  });
+
+  test("the release of an overlay key stays in the overlay after the composer closes", () => {
+    const { window, document, root, pageKeys } = overlayPage();
+
+    // Escape: keydown closes the composer, keyup lands on the page body.
+    let comment = openComposer(window, document, root);
+    key(window, comment, "keydown", "Escape");
+    expect(comment.isConnected).toBe(false);
+    key(window, document.body, "keyup", "Escape");
+
+    // Ctrl+Enter: keydown commits and removes the textarea, both keyups land on the body.
+    comment = openComposer(window, document, root);
+    comment.value = "Bigger title";
+    key(window, comment, "keydown", "Control", { ctrlKey: true });
+    key(window, comment, "keydown", "Enter", { ctrlKey: true });
+    expect(comment.isConnected).toBe(false);
+    expect(savedComments(window)).toHaveLength(1);
+    key(window, document.body, "keyup", "Enter", { ctrlKey: true });
+    key(window, document.body, "keyup", "Control");
+    expect(pageKeys).toEqual([]);
+
+    // The next press that starts on the page is the page's again.
+    key(window, document.body, "keydown", "Escape");
+    key(window, document.body, "keyup", "Escape");
+    expect(pageKeys).toContain("window-bubble:keydown:Escape");
+    expect(pageKeys).toContain("window-bubble:keyup:Escape");
+  });
+
+  test("keys outside the overlay still reach the page", () => {
+    const { window, document, pageKeys } = overlayPage();
+    press(window, document.body, "ArrowRight");
+    expect(pageKeys).toEqual(
+      ["keydown", "keypress", "keyup"].flatMap((type) => [
+        `window-capture:${type}:ArrowRight`,
+        `document-capture:${type}:ArrowRight`,
+        `window-bubble:${type}:ArrowRight`,
+      ]),
+    );
+  });
+});

package/src/tests/pages-feedback.test.ts

@@ -12,11 +12,11 @@ import {
   type Server,
   type ServerResponse,
 } from "node:http";
-import { feedbackOverlayScripts, isPageFeedbackRequested } from "../artifact-sdk/feedback-overlay";
 import { closeDb, createAgent, getTaskById, initDb } from "../be/db";
 import { handlePages } from "../http/pages";
 import { handlePagesPublic } from "../http/pages-public";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { feedbackOverlayScripts, isPageFeedbackRequested } from "../pages/feedback-overlay";
 import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-pages-feedback.sqlite";
@@ -127,6 +127,9 @@ describe("page feedback", () => {
     const html = await res.text();
     expect(html).toContain(`window.__swarmFeedback = {"pageId":"${pageId}"};`);
     expect(html).toContain("swarm-feedback-root");
+    // The key guard is served before the page's own markup and scripts.
+    expect(html.indexOf("__swarmFeedbackKeys")).toBeGreaterThan(-1);
+    expect(html.indexOf("__swarmFeedbackKeys")).toBeLessThan(html.indexOf("<h1>Hello</h1>"));
     // The agent-authored body and the SDK are still served.
     expect(html).toContain("<h1>Hello</h1>");
     expect(html).toContain("class SwarmSDK");

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

@@ -0,0 +1,102 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  initDb,
+  pauseTask,
+  startTask,
+} from "../be/db";
+import { handleTasks } from "../http/tasks";
+
+const TEST_DB_PATH = "./test-paused-tasks-requested-by.sqlite";
+const AGENT_ID = "50000000-0000-4000-8000-000000000001";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+async function getPausedTasks(): Promise<{
+  status: number;
+  body: { tasks: Array<{ id: string; requestedBy?: Record<string, unknown> }> };
+}> {
+  let status = 200;
+  let bodyStr = "";
+  const req = {
+    method: "GET",
+    url: "/api/paused-tasks",
+    headers: { "x-agent-id": AGENT_ID },
+  } as unknown as Parameters<typeof handleTasks>[0];
+  const res = {
+    setHeader() {},
+    writeHead(code: number) {
+      status = code;
+    },
+    end(body?: string) {
+      bodyStr = body ?? "";
+    },
+  } as unknown as Parameters<typeof handleTasks>[1];
+  const handled = await handleTasks(
+    req,
+    res,
+    ["api", "paused-tasks"],
+    new URLSearchParams(),
+    AGENT_ID,
+  );
+  if (!handled) throw new Error("handleTasks did not handle the request");
+  return { status, body: JSON.parse(bodyStr) };
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  await createAgent({ id: AGENT_ID, name: "Paused Worker", isLead: false, status: "idle" });
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+describe("GET /api/paused-tasks requester projection", () => {
+  test("carries the same requestedBy a task_assigned trigger carries", async () => {
+    const user = await createUser({
+      name: "Paused Requester",
+      email: "paused@example.com",
+      role: "CTO",
+      notes: "Paused requester notes",
+    });
+    const withUser = await createTaskExtended("Paused task with requester", {
+      agentId: AGENT_ID,
+      requestedByUserId: user.id,
+    });
+    const withoutUser = await createTaskExtended("Paused task without requester", {
+      agentId: AGENT_ID,
+    });
+    for (const task of [withUser, withoutUser]) {
+      await startTask(task.id);
+      expect(await pauseTask(task.id)).not.toBeNull();
+    }
+
+    const { status, body } = await getPausedTasks();
+    expect(status).toBe(200);
+    const byId = new Map(body.tasks.map((task) => [task.id, task]));
+    expect(byId.get(withUser.id)?.requestedBy).toMatchObject({
+      id: user.id,
+      name: "Paused Requester",
+      email: "paused@example.com",
+      role: "CTO",
+      notes: "Paused requester notes",
+    });
+    expect(byId.get(withoutUser.id)).toBeDefined();
+    expect(byId.get(withoutUser.id)?.requestedBy).toBeUndefined();
+  });
+});

package/src/tests/pi-context-compaction.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Pi's `context` hook fires before every LLM call. It must report usage as a
+ * `progress` snapshot; only `session_compact` reports a compaction. Migration
+ * 219 relabels the trigger-less pi compaction rows written before the fix.
+ */
+
+import type { Database } from "bun:sqlite";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type {
+  ContextEvent,
+  ExtensionFactory,
+  SessionCompactEvent,
+} from "@earendil-works/pi-coding-agent";
+import type { CreateContextSnapshotInput } from "../be/db";
+import {
+  closeDb,
+  createAgent,
+  createContextSnapshot,
+  createTaskExtended,
+  getContextSnapshotsByTaskId,
+  getContextSummaryByTaskId,
+  initDb,
+} from "../be/db";
+import { createSwarmHooksExtension } from "../providers/pi-mono-extension";
+
+const TEST_DB_PATH = "./test-pi-context-compaction.sqlite";
+const agentId = "aaaa0000-0000-4000-8000-0000000000a1";
+
+type Handler = (event: unknown, ctx: unknown) => Promise<unknown> | unknown;
+
+let db: Database;
+const origFetch = globalThis.fetch;
+
+async function removeDbFiles() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {
+      // File doesn't exist
+    }
+  }
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  db = initDb(TEST_DB_PATH);
+  await createAgent({ id: agentId, name: "Pi Worker", isLead: false, status: "idle" });
+});
+
+afterEach(() => {
+  globalThis.fetch = origFetch;
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+});
+
+async function createTask(provider: string): Promise<string> {
+  const task = await createTaskExtended(`context compaction ${provider}`, {
+    agentId,
+    source: "mcp",
+  });
+  db.run("UPDATE agent_tasks SET provider = ? WHERE id = ?", [provider, task.id]);
+  return task.id;
+}
+
+/**
+ * Load the extension and route its `/context` POSTs into the real snapshot
+ * writer, the same path `POST /api/tasks/:id/context` takes.
+ */
+function loadExtension(taskId: string) {
+  const handlers = new Map<string, Handler>();
+  const pending: Promise<unknown>[] = [];
+  globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+    const urlStr = typeof url === "string" ? url : url.toString();
+    if (urlStr.endsWith(`/api/tasks/${taskId}/context`) && init?.method === "POST") {
+      const body = JSON.parse(String(init.body)) as Omit<
+        CreateContextSnapshotInput,
+        "taskId" | "agentId"
+      >;
+      const write = createContextSnapshot({ ...body, taskId, agentId });
+      pending.push(write);
+      await write;
+    }
+    return new Response("{}", { status: 200 });
+  }) as typeof fetch;
+
+  const pi = {
+    on: (event: string, handler: Handler) => {
+      handlers.set(event, handler);
+    },
+    sendMessage: () => {},
+    registerMcpServer: () => {},
+  };
+  createSwarmHooksExtension({
+    apiUrl: "http://localhost:3013",
+    apiKey: "example-test-key",
+    agentId,
+    taskId,
+    isLead: false,
+  })(pi as unknown as Parameters<ExtensionFactory>[0]);
+
+  let tokens = 0;
+  const ctx = {
+    getContextUsage: () => ({ tokens, contextWindow: 1_000_000, percent: tokens / 10_000 }),
+  };
+  const fire = async (event: ContextEvent | SessionCompactEvent, usedTokens: number) => {
+    tokens = usedTokens;
+    await handlers.get(event.type)?.(event, ctx);
+    await Promise.all(pending);
+  };
+  return { fire };
+}
+
+describe("pi context hook", () => {
+  test("per-call context usage is progress; only session_compact counts", async () => {
+    const taskId = await createTask("pi");
+    const { fire } = loadExtension(taskId);
+
+    for (const used of [82_000, 94_000, 94_400]) {
+      await fire({ type: "context", messages: [] }, used);
+    }
+
+    let snapshots = await getContextSnapshotsByTaskId(taskId);
+    expect(snapshots.length).toBe(3);
+    expect(snapshots.filter((s) => s.eventType === "compaction")).toEqual([]);
+    let summary = await getContextSummaryByTaskId(taskId);
+    expect(summary.compactionCount).toBe(0);
+    expect(summary.peakContextTokens).toBe(94_400);
+
+    await fire(
+      {
+        type: "session_compact",
+        reason: "threshold",
+        willRetry: false,
+        fromExtension: false,
+        compactionEntry: {
+          type: "compaction",
+          id: "c1",
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          summary: "s",
+          firstKeptEntryId: "e1",
+          tokensBefore: 120_000,
+        },
+      },
+      30_000,
+    );
+
+    snapshots = await getContextSnapshotsByTaskId(taskId);
+    const compactions = snapshots.filter((s) => s.eventType === "compaction");
+    expect(compactions.length).toBe(1);
+    expect(compactions[0]?.compactTrigger).toBe("auto");
+    expect(compactions[0]?.preCompactTokens).toBe(120_000);
+    summary = await getContextSummaryByTaskId(taskId);
+    expect(summary.compactionCount).toBe(1);
+  });
+});
+
+describe("migration 219", () => {
+  test("relabels trigger-less pi compactions and leaves other rows alone", async () => {
+    const piTask = await createTask("pi");
+    const claudeTask = await createTask("claude");
+    const snapshot = (taskId: string, sessionId: string, extra = {}) =>
+      createContextSnapshot({
+        taskId,
+        agentId,
+        sessionId,
+        eventType: "compaction",
+        contextPercent: 9,
+        ...extra,
+      });
+
+    await snapshot(piTask, `pi-${piTask}`);
+    await snapshot(piTask, `pi-${piTask}`);
+    await snapshot(piTask, `pi-${piTask}`, { compactTrigger: "auto", preCompactTokens: 150_000 });
+    await snapshot(claudeTask, "claude-session");
+    expect((await getContextSummaryByTaskId(piTask)).compactionCount).toBe(3);
+
+    db.exec(await Bun.file("src/be/migrations/219_relabel_pi_context_compactions.sql").text());
+
+    const piRows = await getContextSnapshotsByTaskId(piTask);
+    expect(piRows.map((s) => s.eventType).sort()).toEqual(["compaction", "progress", "progress"]);
+    expect(piRows.find((s) => s.eventType === "compaction")?.preCompactTokens).toBe(150_000);
+    expect((await getContextSummaryByTaskId(piTask)).compactionCount).toBe(1);
+
+    const claudeRows = await getContextSnapshotsByTaskId(claudeTask);
+    expect(claudeRows.map((s) => s.eventType)).toEqual(["compaction"]);
+    expect((await getContextSummaryByTaskId(claudeTask)).compactionCount).toBe(1);
+  });
+});