@desplega.ai/agent-swarm 1.78.1 → 1.79.1

package/src/tests/artifact-sdk.test.ts

@@ -64,48 +64,48 @@ describe("BROWSER_SDK_JS", () => {
     expect(BROWSER_SDK_JS).toContain("class SwarmSDK");
   });
 
-  test("contains all expected API methods", () => {
-    const expectedMethods = [
-      "createTask",
-      "getTasks",
-      "getTaskDetails",
-      "storeProgress",
-      "postMessage",
-      "readMessages",
-      "getSwarm",
-      "listServices",
-      "slackReply",
+  test("exposes the seven canonical domains", () => {
+    const expectedDomains = [
+      "this.tasks",
+      "this.agents",
+      "this.events",
+      "this.memory",
+      "this.repos",
+      "this.schedules",
+      "this.approvalRequests",
     ];
-    for (const method of expectedMethods) {
-      expect(BROWSER_SDK_JS).toContain(method);
+    for (const domain of expectedDomains) {
+      expect(BROWSER_SDK_JS).toContain(domain);
     }
   });
 
-  test("assigns SwarmSDK to window", () => {
+  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("uses correct proxy API paths", () => {
-    expect(BROWSER_SDK_JS).toContain("/@swarm/api/tasks");
-    expect(BROWSER_SDK_JS).toContain("/@swarm/api/agents");
-    expect(BROWSER_SDK_JS).toContain("/@swarm/api/messages");
-    expect(BROWSER_SDK_JS).toContain("/@swarm/api/services");
-    expect(BROWSER_SDK_JS).toContain("/@swarm/api/slack/reply");
+  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'");
   });
 
   test("fetches config on construction", () => {
     expect(BROWSER_SDK_JS).toContain("fetch('/@swarm/config')");
   });
-
-  test("has _post helper with JSON content-type", () => {
-    expect(BROWSER_SDK_JS).toContain("_post(url, body)");
-    expect(BROWSER_SDK_JS).toContain("'Content-Type': 'application/json'");
-    expect(BROWSER_SDK_JS).toContain("JSON.stringify(body)");
-  });
-
-  test("has _get helper", () => {
-    expect(BROWSER_SDK_JS).toContain("_get(url)");
-  });
 });
 
 // ─── createArtifactServer factory tests ──────────────────────────────────
@@ -536,27 +536,29 @@ describe("artifact CLI command", () => {
           const url = new URL(req.url);
           if (url.pathname === "/api/services") {
             return new Response(
-              JSON.stringify([
-                {
-                  id: "svc-1",
-                  name: "artifact-dashboard",
-                  agentId: "agent-123",
-                  status: "healthy",
-                  metadata: {
-                    type: "artifact",
-                    artifactName: "dashboard",
-                    port: 3001,
-                    publicUrl: "https://test.lt.example.com",
+              JSON.stringify({
+                services: [
+                  {
+                    id: "svc-1",
+                    name: "artifact-dashboard",
+                    agentId: "agent-123",
+                    status: "healthy",
+                    metadata: {
+                      type: "artifact",
+                      artifactName: "dashboard",
+                      port: 3001,
+                      publicUrl: "https://test.lt.example.com",
+                    },
                   },
-                },
-                {
-                  id: "svc-2",
-                  name: "some-other-service",
-                  agentId: "agent-456",
-                  status: "healthy",
-                  metadata: { type: "web" },
-                },
-              ]),
+                  {
+                    id: "svc-2",
+                    name: "some-other-service",
+                    agentId: "agent-456",
+                    status: "healthy",
+                    metadata: { type: "web" },
+                  },
+                ],
+              }),
             );
           }
           return new Response("Not found", { status: 404 });
@@ -593,7 +595,7 @@ describe("artifact CLI command", () => {
       const mockPort = await getAvailablePort();
       const mockServer = Bun.serve({
         port: mockPort,
-        fetch: () => new Response(JSON.stringify([])),
+        fetch: () => new Response(JSON.stringify({ services: [] })),
       });
 
       const origEnv = { ...process.env };
@@ -626,22 +628,24 @@ describe("artifact CLI command", () => {
         port: mockPort,
         fetch: () =>
           new Response(
-            JSON.stringify([
-              {
-                id: "s1",
-                name: "web-server",
-                agentId: "a1",
-                status: "healthy",
-                metadata: { type: "web" },
-              },
-              {
-                id: "s2",
-                name: "api-server",
-                agentId: "a2",
-                status: "healthy",
-                metadata: {},
-              },
-            ]),
+            JSON.stringify({
+              services: [
+                {
+                  id: "s1",
+                  name: "web-server",
+                  agentId: "a1",
+                  status: "healthy",
+                  metadata: { type: "web" },
+                },
+                {
+                  id: "s2",
+                  name: "api-server",
+                  agentId: "a2",
+                  status: "healthy",
+                  metadata: {},
+                },
+              ],
+            }),
           ),
       });
 
@@ -682,13 +686,15 @@ describe("artifact CLI command", () => {
           const url = new URL(req.url);
           if (req.method === "GET" && url.pathname === "/api/services") {
             return new Response(
-              JSON.stringify([
-                {
-                  id: "svc-to-delete",
-                  name: "artifact-my-report",
-                  metadata: { type: "artifact", artifactName: "my-report" },
-                },
-              ]),
+              JSON.stringify({
+                services: [
+                  {
+                    id: "svc-to-delete",
+                    name: "artifact-my-report",
+                    metadata: { type: "artifact", artifactName: "my-report" },
+                  },
+                ],
+              }),
             );
           }
           if (req.method === "DELETE" && url.pathname.startsWith("/api/services/")) {

package/src/tests/context-key.test.ts

@@ -1,10 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import {
+  agentContextKey,
   agentmailContextKey,
   buildJiraContextKey,
   githubContextKey,
   gitlabContextKey,
   linearContextKey,
+  pageContextKey,
   parseContextKey,
   scheduleContextKey,
   slackContextKey,
@@ -49,6 +51,21 @@ describe("context-key builders", () => {
   test("workflowContextKey builds expected format", () => {
     expect(workflowContextKey({ workflowRunId: "run-uuid" })).toBe("task:workflow:run-uuid");
   });
+
+  test("agentContextKey builds expected format", () => {
+    expect(agentContextKey({ agentId: "agent-uuid" })).toBe("task:agent:agent-uuid");
+  });
+
+  test("pageContextKey builds expected format", () => {
+    expect(pageContextKey({ pageId: "page-uuid" })).toBe("task:page:page-uuid");
+  });
+
+  test("agentContextKey and pageContextKey reject empty / colon-bearing inputs", () => {
+    expect(() => agentContextKey({ agentId: "" })).toThrow(/non-empty/);
+    expect(() => agentContextKey({ agentId: "a:b" })).toThrow(/must not contain/);
+    expect(() => pageContextKey({ pageId: "" })).toThrow(/non-empty/);
+    expect(() => pageContextKey({ pageId: "p:q" })).toThrow(/must not contain/);
+  });
 });
 
 describe("context-key separator safety", () => {

package/src/tests/create-page-tool.test.ts

@@ -0,0 +1,197 @@
+/**
+ * `create_page` MCP tool — unit-level coverage. Registers the tool against
+ * a fresh `McpServer`, pulls the handler out of the SDK's registry, and
+ * invokes it directly with a stubbed agent-id `requestInfo`.
+ *
+ * Verifies:
+ *   - first-call path: creates a row in `pages`, returns `{id, version=1, app_url, api_url}`
+ *   - upsert path: second call with the same slug bumps the edit-counter
+ *     and writes a version row
+ *   - capability gate: tool is registered when `CAPABILITIES` contains
+ *     `pages`, NOT registered when missing (verified via `createServer`)
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, getPageBySlug, getPageVersions, initDb } from "../be/db";
+import { registerCreatePageTool } from "../tools/create-page";
+
+const TEST_DB_PATH = "./test-create-page-tool.sqlite";
+
+type RegisteredTool = {
+  handler: (args: unknown, extra: unknown) => Promise<unknown>;
+};
+
+function buildServer() {
+  const server = new McpServer({ name: "create-page-test", version: "1.0.0" });
+  registerCreatePageTool(server);
+  const registered = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+  const tool = registered.create_page;
+  if (!tool) throw new Error("create_page tool not registered");
+  return tool;
+}
+
+describe("create_page MCP tool", () => {
+  const agentId = crypto.randomUUID();
+  const fakeMeta = {
+    sessionId: "session-1",
+    requestInfo: { headers: { "x-agent-id": agentId } },
+  };
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    // The tool reads MCP_BASE_URL / APP_URL when building share URLs.
+    process.env.MCP_BASE_URL = "http://test-api:9999";
+    process.env.APP_URL = "http://test-app:5274";
+  });
+
+  afterAll(async () => {
+    closeDb();
+    delete process.env.MCP_BASE_URL;
+    delete process.env.APP_URL;
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test("first call creates a row + returns shareable URLs", async () => {
+    const tool = buildServer();
+    const result = (await tool.handler(
+      {
+        title: "Hello Page",
+        body: "<h1>hello</h1>",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      fakeMeta,
+    )) as {
+      structuredContent: {
+        id: string;
+        version: number;
+        app_url: string;
+        api_url: string;
+        yourAgentId: string;
+      };
+    };
+
+    expect(result.structuredContent.id).toMatch(/^[0-9a-f]{32}$/);
+    expect(result.structuredContent.version).toBe(1);
+    expect(result.structuredContent.api_url).toBe(
+      `http://test-api:9999/p/${result.structuredContent.id}`,
+    );
+    expect(result.structuredContent.app_url).toBe(
+      `http://test-app:5274/pages/${result.structuredContent.id}`,
+    );
+    expect(result.structuredContent.yourAgentId).toBe(agentId);
+
+    // DB row exists with the auto-slug from the title.
+    const row = getPageBySlug(agentId, "hello-page");
+    expect(row).not.toBeNull();
+    expect(row!.body).toBe("<h1>hello</h1>");
+  });
+
+  test("re-running with the same slug upserts + bumps edit-counter", async () => {
+    const tool = buildServer();
+
+    const first = (await tool.handler(
+      {
+        title: "Upsert Page",
+        slug: "upsert",
+        body: "v0",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      fakeMeta,
+    )) as { structuredContent: { id: string; version: number } };
+    expect(first.structuredContent.version).toBe(1);
+
+    const second = (await tool.handler(
+      {
+        title: "Upsert Page",
+        slug: "upsert",
+        body: "v1",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      fakeMeta,
+    )) as { structuredContent: { id: string; version: number } };
+    expect(second.structuredContent.id).toBe(first.structuredContent.id);
+    expect(second.structuredContent.version).toBe(2);
+
+    // Version row holds the PRE-update body.
+    const versions = getPageVersions(first.structuredContent.id);
+    expect(versions).toHaveLength(1);
+    expect(versions[0]!.snapshot.body).toBe("v0");
+
+    // Parent now holds the new body.
+    const row = getPageBySlug(agentId, "upsert");
+    expect(row?.body).toBe("v1");
+  });
+
+  test("missing X-Agent-ID returns an error result", async () => {
+    const tool = buildServer();
+    const result = (await tool.handler(
+      {
+        title: "Anon",
+        body: "x",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      { sessionId: "s", requestInfo: { headers: {} } },
+    )) as { isError?: boolean };
+    expect(result.isError).toBe(true);
+  });
+
+  test("password is hashed (not stored verbatim)", async () => {
+    const tool = buildServer();
+    await tool.handler(
+      {
+        title: "Pw",
+        slug: "pw-tool",
+        body: "secret",
+        contentType: "text/html",
+        authMode: "password",
+        password: "open-sesame",
+      },
+      fakeMeta,
+    );
+    const row = getPageBySlug(agentId, "pw-tool");
+    expect(row?.passwordHash).toBeDefined();
+    expect(row?.passwordHash).not.toBe("open-sesame");
+    expect(await Bun.password.verify("open-sesame", row!.passwordHash!)).toBe(true);
+  });
+});
+
+describe("create_page MCP tool capability gating", () => {
+  test("not registered without 'pages' capability; registered with it", async () => {
+    // Save + clear env then load the server module fresh.
+    const orig = process.env.CAPABILITIES;
+    try {
+      // Default capabilities don't include 'pages' (step-3 enforced).
+      process.env.CAPABILITIES = "core,task-pool,profiles,services,scheduling,memory,workflows";
+      // Force a fresh module evaluation so the capability check re-runs.
+      delete require.cache[require.resolve("../server")];
+      const without = await import("../server");
+      expect(without.hasCapability("pages")).toBe(false);
+
+      process.env.CAPABILITIES =
+        "core,task-pool,profiles,services,scheduling,memory,workflows,pages";
+      delete require.cache[require.resolve("../server")];
+      const withPages = await import("../server");
+      expect(withPages.hasCapability("pages")).toBe(true);
+    } finally {
+      if (orig === undefined) delete process.env.CAPABILITIES;
+      else process.env.CAPABILITIES = orig;
+      delete require.cache[require.resolve("../server")];
+    }
+  });
+});

package/src/tests/fixtures/sample-json-page.json

@@ -0,0 +1,52 @@
+{
+  "root": "root",
+  "elements": {
+    "root": {
+      "type": "Container",
+      "props": { "direction": "column", "gap": "md" },
+      "children": ["heading", "intro", "sdkBtn", "callBtn"]
+    },
+    "heading": {
+      "type": "Heading",
+      "props": { "text": "Sample JSON page", "level": "h1" },
+      "children": []
+    },
+    "intro": {
+      "type": "Text",
+      "props": {
+        "content": "Two buttons below dispatch swarm.sdk and swarm.call actions. Click each to exercise the renderer's action wiring.",
+        "tone": "muted"
+      },
+      "children": []
+    },
+    "sdkBtn": {
+      "type": "Button",
+      "props": { "label": "Create task via SDK" },
+      "children": [],
+      "on": {
+        "press": {
+          "action": "swarm.sdk",
+          "params": {
+            "sdk": "createTask",
+            "args": { "description": "from-json-page" }
+          }
+        }
+      }
+    },
+    "callBtn": {
+      "type": "Button",
+      "props": { "label": "Create channel via raw call", "variant": "secondary" },
+      "children": [],
+      "on": {
+        "press": {
+          "action": "swarm.call",
+          "params": {
+            "method": "POST",
+            "endpoint": "/api/channels",
+            "body": { "name": "from-json-page" }
+          }
+        }
+      }
+    }
+  }
+}