@desplega.ai/agent-swarm 1.78.1 → 1.79.1

package/src/tests/pages-view-count.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Verifies the per-page view counter:
+ *   - `view_count` bumps on every 200 from `GET /p/:id` and `GET /p/:id.json`
+ *   - 401/403/404 responses do NOT bump
+ *   - Bumps survive across requests (writes are committed)
+ *   - Counter surfaces on `GET /api/pages` listing and `GET /api/pages/:id`
+ *
+ * No dedup by viewer — that's the explicit design (per Taras: "super simple
+ * counter field, that's it"). If someone wants unique views later, that's a
+ * follow-up.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { closeDb, initDb } from "../be/db";
+import { handlePages } from "../http/pages";
+import { handlePagesPublic } from "../http/pages-public";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const TEST_DB_PATH = "./test-pages-view-count.sqlite";
+const TEST_PORT = 13095;
+const BASE = `http://localhost:${TEST_PORT}`;
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    if (await handlePagesPublic(req, res, pathSegments, queryParams)) return;
+    if (await handlePages(req, res, pathSegments, queryParams, myAgentId)) return;
+    res.writeHead(404);
+    res.end("not found");
+  });
+}
+
+async function getViewCount(id: string, agentId: string): Promise<number> {
+  const res = await fetch(`${BASE}/api/pages/${id}`, {
+    headers: { "X-Agent-ID": agentId },
+  });
+  expect(res.status).toBe(200);
+  const json = (await res.json()) as { viewCount?: number };
+  return typeof json.viewCount === "number" ? json.viewCount : 0;
+}
+
+describe("Pages — view_count counter", () => {
+  let server: Server;
+  const agentId = crypto.randomUUID();
+  const headers = { "Content-Type": "application/json", "X-Agent-ID": agentId };
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    server = createTestServer();
+    await new Promise<void>((resolve) => server.listen(TEST_PORT, () => resolve()));
+  });
+
+  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 {}
+    }
+  });
+
+  test("public HTML page: 3 fetches → view_count = 3", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "view-count-html",
+        title: "View Count HTML",
+        contentType: "text/html",
+        authMode: "public",
+        body: "<h1>hi</h1>",
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+
+    expect(await getViewCount(id, agentId)).toBe(0);
+
+    for (let i = 0; i < 3; i++) {
+      const r = await fetch(`${BASE}/p/${id}`);
+      expect(r.status).toBe(200);
+    }
+
+    expect(await getViewCount(id, agentId)).toBe(3);
+  });
+
+  test("/p/:id.json fetches also bump the counter", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "view-count-json-path",
+        title: "View Count JSON Path",
+        contentType: "text/html",
+        authMode: "public",
+        body: "<h1>hi</h1>",
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+
+    for (let i = 0; i < 2; i++) {
+      const r = await fetch(`${BASE}/p/${id}.json`);
+      expect(r.status).toBe(200);
+    }
+    // One additional HTML fetch — both paths bump the same counter.
+    expect((await fetch(`${BASE}/p/${id}`)).status).toBe(200);
+    expect(await getViewCount(id, agentId)).toBe(3);
+  });
+
+  test("404 on unknown page id does NOT crash and does not touch any counter", async () => {
+    const bogus = "0".repeat(32);
+    const r = await fetch(`${BASE}/p/${bogus}`);
+    expect(r.status).toBe(404);
+  });
+
+  test("password-protected page: 401 without unlock does NOT bump", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "view-count-pw",
+        title: "View Count Password",
+        contentType: "text/html",
+        authMode: "password",
+        password: "letmein",
+        body: "<h1>secret</h1>",
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+
+    // No `?key=`, no Basic header → 401, no counter bump.
+    const r1 = await fetch(`${BASE}/p/${id}`);
+    expect(r1.status).toBe(401);
+    const r2 = await fetch(`${BASE}/p/${id}.json`);
+    expect(r2.status).toBe(401);
+
+    expect(await getViewCount(id, agentId)).toBe(0);
+
+    // After unlocking via ?key= → counter bumps.
+    const ok = await fetch(`${BASE}/p/${id}?key=letmein`);
+    expect(ok.status).toBe(200);
+    expect(await getViewCount(id, agentId)).toBe(1);
+  });
+
+  test("authed page: 401 without cookie does NOT bump", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "view-count-authed",
+        title: "View Count Authed",
+        contentType: "text/html",
+        authMode: "authed",
+        body: "<h1>members only</h1>",
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+
+    // No cookie → 401.
+    const r = await fetch(`${BASE}/p/${id}`);
+    expect(r.status).toBe(401);
+    expect(await getViewCount(id, agentId)).toBe(0);
+  });
+
+  test("JSON content-type page: 302→SPA does NOT double-count (only .json bumps)", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "view-count-jsonct",
+        title: "JSON Content Page",
+        contentType: "application/json",
+        authMode: "public",
+        body: JSON.stringify({ kind: "spec" }),
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+
+    // /p/:id 302s — should NOT bump.
+    const redir = await fetch(`${BASE}/p/${id}`, { redirect: "manual" });
+    expect(redir.status).toBe(302);
+    expect(await getViewCount(id, agentId)).toBe(0);
+
+    // /p/:id.json bumps.
+    const j = await fetch(`${BASE}/p/${id}.json`);
+    expect(j.status).toBe(200);
+    expect(await getViewCount(id, agentId)).toBe(1);
+  });
+
+  test("listing endpoint exposes viewCount", async () => {
+    const res = await fetch(`${BASE}/api/pages`, {
+      headers: { "X-Agent-ID": agentId },
+    });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { pages: Array<{ id: string; viewCount?: number }> };
+    expect(body.pages.length).toBeGreaterThan(0);
+    for (const p of body.pages) {
+      expect(typeof p.viewCount).toBe("number");
+    }
+  });
+});

package/src/tests/prompt-template-session.test.ts

@@ -69,6 +69,7 @@ describe("Session templates — registration", () => {
       "system.agent.system",
       "system.agent.services",
       "system.agent.artifacts",
+      "system.agent.share_urls",
     ];
 
     for (const eventType of systemTemplates) {
@@ -88,10 +89,10 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 17 session/system templates registered", () => {
+  test("total of 18 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    expect(sessionSystem.length).toBe(17);
+    expect(sessionSystem.length).toBe(18);
   });
 });
 

package/src/tests/skill-update-scope.test.ts

@@ -0,0 +1,165 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createAgent, createSkill, getSkillById, initDb } from "../be/db";
+import { registerSkillUpdateTool } from "../tools/skills/skill-update";
+
+const TEST_DB_PATH = "./test-skill-update-scope.sqlite";
+
+const LEAD_ID = "aaaa0000-0000-4000-8000-000000000010";
+const WORKER_ID = "bbbb0000-0000-4000-8000-000000000020";
+
+type StructuredContent = {
+  yourAgentId?: string;
+  success: boolean;
+  message: string;
+  skill?: { id: string; scope: string; ownerAgentId: string | null };
+};
+
+async function callSkillUpdate(
+  server: McpServer,
+  callerAgentId: string | undefined,
+  args: Record<string, unknown>,
+): Promise<{ structuredContent: StructuredContent }> {
+  // biome-ignore lint/complexity/noBannedTypes: accessing internal MCP SDK type for test
+  const tools = (server as unknown as { _registeredTools: Record<string, { handler: Function }> })
+    ._registeredTools;
+  const handler = tools["skill-update"].handler;
+
+  const extra = {
+    sessionId: "test-session",
+    requestInfo: {
+      headers: {
+        "x-agent-id": callerAgentId ?? "",
+      },
+    },
+  };
+
+  const result = await handler(args, extra);
+  return result as { structuredContent: StructuredContent };
+}
+
+describe("skill-update scope promotion", () => {
+  let server: McpServer;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // File doesn't exist
+      }
+    }
+
+    closeDb();
+    initDb(TEST_DB_PATH);
+
+    createAgent({ id: LEAD_ID, name: "Test Lead", isLead: true, status: "idle" });
+    createAgent({ id: WORKER_ID, name: "Test Worker", isLead: false, status: "idle" });
+
+    server = new McpServer({ name: "test-skill-update-scope", version: "1.0.0" });
+    registerSkillUpdateTool(server);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  test("worker cannot promote their own skill to swarm scope", async () => {
+    const skill = createSkill({
+      name: "worker-skill-self-promote",
+      description: "Worker tries to promote",
+      content:
+        "---\nname: worker-skill-self-promote\ndescription: Worker tries to promote\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      ownerAgentId: WORKER_ID,
+    });
+
+    const result = await callSkillUpdate(server, WORKER_ID, {
+      skillId: skill.id,
+      scope: "swarm",
+    });
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("lead");
+
+    const stored = getSkillById(skill.id);
+    expect(stored?.scope).toBe("agent");
+    expect(stored?.ownerAgentId).toBe(WORKER_ID);
+  });
+
+  test("lead can promote a worker's agent-scope skill to swarm without changing ownerAgentId", async () => {
+    const skill = createSkill({
+      name: "worker-skill-lead-promote",
+      description: "Lead promotes",
+      content: "---\nname: worker-skill-lead-promote\ndescription: Lead promotes\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      ownerAgentId: WORKER_ID,
+    });
+
+    const result = await callSkillUpdate(server, LEAD_ID, {
+      skillId: skill.id,
+      scope: "swarm",
+    });
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(result.structuredContent.skill?.scope).toBe("swarm");
+    expect(result.structuredContent.skill?.ownerAgentId).toBe(WORKER_ID);
+
+    const stored = getSkillById(skill.id);
+    expect(stored?.scope).toBe("swarm");
+    expect(stored?.ownerAgentId).toBe(WORKER_ID);
+  });
+
+  test("lead demoting a swarm skill back to agent scope is allowed", async () => {
+    const skill = createSkill({
+      name: "swarm-skill-demote",
+      description: "Demote test",
+      content: "---\nname: swarm-skill-demote\ndescription: Demote test\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+    });
+
+    const result = await callSkillUpdate(server, LEAD_ID, {
+      skillId: skill.id,
+      scope: "agent",
+    });
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(result.structuredContent.skill?.scope).toBe("agent");
+
+    const stored = getSkillById(skill.id);
+    expect(stored?.scope).toBe("agent");
+  });
+
+  test("omitting scope leaves it unchanged", async () => {
+    const skill = createSkill({
+      name: "scope-untouched",
+      description: "No scope change",
+      content: "---\nname: scope-untouched\ndescription: No scope change\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      ownerAgentId: WORKER_ID,
+    });
+
+    const result = await callSkillUpdate(server, WORKER_ID, {
+      skillId: skill.id,
+      isEnabled: false,
+    });
+
+    expect(result.structuredContent.success).toBe(true);
+    const stored = getSkillById(skill.id);
+    expect(stored?.scope).toBe("agent");
+    expect(stored?.isEnabled).toBe(false);
+  });
+});