npm - @desplega.ai/agent-swarm - Versions diffs - 1.78.0 → 1.79.0 - Mend

@desplega.ai/agent-swarm 1.78.0 → 1.79.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/openapi.json +542 -1
package/package.json +1 -1
package/plugin/skills/artifacts/SKILL.md +151 -0
package/plugin/skills/artifacts/examples/static-report.sh +1 -1
package/plugin/skills/pages/SKILL.md +274 -0
package/src/artifact-sdk/browser-sdk.ts +105 -20
package/src/be/db.ts +239 -0
package/src/be/migrations/059_pages.sql +34 -0
package/src/be/migrations/060_page_versions.sql +19 -0
package/src/commands/artifact.ts +17 -11
package/src/http/index.ts +7 -1
package/src/http/page-proxy.ts +208 -0
package/src/http/pages-public.ts +466 -0
package/src/http/pages.ts +608 -0
package/src/http/utils.ts +68 -5
package/src/pages/version.ts +44 -0
package/src/prompts/session-templates.ts +51 -0
package/src/server.ts +10 -1
package/src/tests/artifact-commands.test.ts +92 -0
package/src/tests/artifact-sdk.test.ts +80 -74
package/src/tests/create-page-tool.test.ts +197 -0
package/src/tests/error-tracker.test.ts +30 -0
package/src/tests/fixtures/sample-json-page.json +52 -0
package/src/tests/launch-password-rejection.test.ts +139 -0
package/src/tests/page-proxy-authed.test.ts +146 -0
package/src/tests/page-proxy.test.ts +266 -0
package/src/tests/page-session.test.ts +164 -0
package/src/tests/pages-actions-endpoint.test.ts +102 -0
package/src/tests/pages-authed-mode.test.ts +207 -0
package/src/tests/pages-http.test.ts +193 -0
package/src/tests/pages-list-endpoint.test.ts +149 -0
package/src/tests/pages-password-hash.test.ts +57 -0
package/src/tests/pages-password-mode.test.ts +265 -0
package/src/tests/pages-public-authed-401.test.ts +102 -0
package/src/tests/pages-public-html.test.ts +151 -0
package/src/tests/pages-public-json-redirect.test.ts +86 -0
package/src/tests/pages-storage.test.ts +196 -0
package/src/tests/pages-versioning.test.ts +231 -0
package/src/tests/prompt-template-session.test.ts +3 -2
package/src/tests/skill-update-scope.test.ts +165 -0
package/src/tests/workflow-wait-event.test.ts +4 -7
package/src/tools/create-page.ts +263 -0
package/src/tools/skills/skill-update.ts +26 -0
package/src/tools/tool-config.ts +3 -0
package/src/types.ts +54 -0
package/src/utils/error-tracker.ts +55 -1
package/src/utils/page-session.ts +254 -0
package/plugin/skills/artifacts/skill.md +0 -70

package/src/tests/pages-public-html.test.ts ADDED Viewed

@@ -0,0 +1,151 @@
+/**
+ * Public `/p/:id` for HTML content. Verifies that:
+ *   - the response body contains the original HTML verbatim
+ *   - the `BROWSER_SDK_JS` is injected as an inline `<script>` (we look for
+ *     `class SwarmSDK` which is unique to the constant)
+ *   - the response `Content-Type` is `text/html`
+ *   - a `Content-Security-Policy` header is set
+ */
+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-public-html.sqlite";
+const TEST_PORT = 13042;
+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;
+    // Try public first, then bearer REST.
+    if (await handlePagesPublic(req, res, pathSegments, queryParams)) return;
+    if (await handlePages(req, res, pathSegments, queryParams, myAgentId)) return;
+    res.writeHead(404);
+    res.end("not found");
+  });
+}
+describe("GET /p/:id — HTML public path", () => {
+  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 renders with SDK injection + CSP", async () => {
+    const html =
+      "<!doctype html><html><head><title>X</title></head><body><h1>Hello</h1></body></html>";
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "public-html",
+        title: "Public HTML",
+        contentType: "text/html",
+        authMode: "public",
+        body: html,
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+    const res = await fetch(`${BASE}/p/${id}`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")?.toLowerCase()).toContain("text/html");
+    expect(res.headers.get("content-security-policy")).toBeTruthy();
+    const text = await res.text();
+    expect(text).toContain("<h1>Hello</h1>");
+    expect(text).toContain("class SwarmSDK"); // BROWSER_SDK_JS sentinel
+  });
+  test("public JSON page 302-redirects to SPA artifact route", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "public-json",
+        title: "Public JSON",
+        contentType: "application/json",
+        authMode: "public",
+        body: JSON.stringify({ kind: "spec" }),
+      }),
+    });
+    const { id } = (await post.json()) as { id: string };
+    const res = await fetch(`${BASE}/p/${id}`, { redirect: "manual" });
+    expect(res.status).toBe(302);
+    const loc = res.headers.get("location");
+    expect(loc).toContain(`/pages/${id}`);
+  });
+  test("/p/:id.json returns page metadata + body as JSON", async () => {
+    const html = "<h1>jsonable</h1>";
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "public-json-renderer",
+        title: "JSON Endpoint",
+        description: "for the SPA renderer",
+        contentType: "text/html",
+        authMode: "public",
+        body: html,
+      }),
+    });
+    const { id } = (await post.json()) as { id: string };
+    const res = await fetch(`${BASE}/p/${id}.json`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")?.toLowerCase()).toContain("application/json");
+    const json = (await res.json()) as {
+      id: string;
+      title: string;
+      contentType: string;
+      authMode: string;
+      body: string;
+      description?: string;
+    };
+    expect(json.id).toBe(id);
+    expect(json.title).toBe("JSON Endpoint");
+    expect(json.description).toBe("for the SPA renderer");
+    expect(json.contentType).toBe("text/html");
+    expect(json.authMode).toBe("public");
+    expect(json.body).toBe(html);
+  });
+  test("404 for unknown page id", async () => {
+    const res = await fetch(`${BASE}/p/${"0".repeat(32)}`);
+    expect(res.status).toBe(404);
+  });
+});

package/src/tests/pages-public-json-redirect.test.ts ADDED Viewed

@@ -0,0 +1,86 @@
+/**
+ * Public `/p/:id` for JSON content. JSON pages do NOT render at the API —
+ * the renderer lives in the SPA at `/pages/:id` (step-6/7). The API
+ * responds with a 302 to `${APP_URL}/pages/:id`.
+ */
+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-public-json.sqlite";
+const TEST_PORT = 13043;
+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");
+  });
+}
+describe("GET /p/:id — JSON page redirect", () => {
+  let server: Server;
+  const agentId = crypto.randomUUID();
+  const headers = { "Content-Type": "application/json", "X-Agent-ID": agentId };
+  const ORIG_APP = process.env.APP_URL;
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    // Pin APP_URL so the redirect is deterministic across hosts.
+    process.env.APP_URL = "http://localhost:5274";
+    server = createTestServer();
+    await new Promise<void>((resolve) => server.listen(TEST_PORT, () => resolve()));
+  });
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    if (ORIG_APP === undefined) delete process.env.APP_URL;
+    else process.env.APP_URL = ORIG_APP;
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+  test("JSON content redirects to ${APP_URL}/pages/:id", async () => {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "redir",
+        title: "Redirect Me",
+        contentType: "application/json",
+        authMode: "public",
+        body: JSON.stringify({ kind: "spec", nodes: [] }),
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+    const res = await fetch(`${BASE}/p/${id}`, { redirect: "manual" });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("location")).toBe(`http://localhost:5274/pages/${id}`);
+  });
+});

package/src/tests/pages-storage.test.ts ADDED Viewed

@@ -0,0 +1,196 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import { unlinkSync } from "node:fs";
+import {
+  closeDb,
+  createPage,
+  deletePage,
+  getPage,
+  getPageBySlug,
+  getPageVersion,
+  getPageVersions,
+  initDb,
+  listAllPages,
+  listPagesByAgent,
+  updatePage,
+} from "../be/db";
+import { snapshotPage } from "../pages/version";
+const TEST_DB_PATH = "./test-pages-storage.sqlite";
+function makeAgentId() {
+  return `agent-${crypto.randomUUID().slice(0, 8)}`;
+}
+beforeAll(() => {
+  try {
+    unlinkSync(TEST_DB_PATH);
+  } catch {}
+  initDb(TEST_DB_PATH);
+});
+afterAll(() => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+describe("pages storage CRUD", () => {
+  test("create → get → list → delete cascades to versions", () => {
+    const agentId = makeAgentId();
+    const created = createPage({
+      agentId,
+      slug: "hello",
+      title: "Hello",
+      contentType: "text/html",
+      authMode: "public",
+      body: "<h1>hi</h1>",
+    });
+    expect(created.id).toMatch(/^[0-9a-f]{32}$/); // 32-char random hex from migration default
+    expect(created.agentId).toBe(agentId);
+    expect(created.slug).toBe("hello");
+    expect(created.contentType).toBe("text/html");
+    expect(created.authMode).toBe("public");
+    const fetched = getPage(created.id);
+    expect(fetched).not.toBeNull();
+    expect(fetched?.title).toBe("Hello");
+    const bySlug = getPageBySlug(agentId, "hello");
+    expect(bySlug?.id).toBe(created.id);
+    const byAgent = listPagesByAgent(agentId);
+    expect(byAgent.map((p) => p.id)).toContain(created.id);
+    const all = listAllPages();
+    expect(all.map((p) => p.id)).toContain(created.id);
+    // Create a version so we can verify cascade
+    const snap = snapshotPage(created.id, agentId);
+    expect(snap.version).toBe(1);
+    expect(getPageVersions(created.id)).toHaveLength(1);
+    const deleted = deletePage(created.id);
+    expect(deleted).toBe(true);
+    expect(getPage(created.id)).toBeNull();
+    // Cascade: version rows gone
+    expect(getPageVersions(created.id)).toHaveLength(0);
+  });
+  test("snapshotPage captures PRE-update content; post-update lives on parent", () => {
+    const agentId = makeAgentId();
+    const page = createPage({
+      agentId,
+      slug: "pre-update",
+      title: "Original Title",
+      contentType: "text/html",
+      authMode: "public",
+      body: "<h1>v1 body</h1>",
+    });
+    // 1. Snapshot first — captures v1 (pre-update) content
+    snapshotPage(page.id, agentId);
+    // 2. Then update — new content goes on parent
+    const updated = updatePage(page.id, {
+      title: "Updated Title",
+      body: "<h1>v2 body</h1>",
+    });
+    expect(updated?.title).toBe("Updated Title");
+    expect(updated?.body).toBe("<h1>v2 body</h1>");
+    const v1 = getPageVersion(page.id, 1);
+    expect(v1).not.toBeNull();
+    expect(v1?.snapshot.title).toBe("Original Title");
+    expect(v1?.snapshot.body).toBe("<h1>v1 body</h1>");
+    // Repeat — snapshot then update should produce v2 with the latest
+    // pre-update state (i.e. "Updated Title").
+    snapshotPage(page.id, agentId);
+    updatePage(page.id, { title: "Third Title", body: "<h1>v3 body</h1>" });
+    const v2 = getPageVersion(page.id, 2);
+    expect(v2?.snapshot.title).toBe("Updated Title");
+    expect(v2?.snapshot.body).toBe("<h1>v2 body</h1>");
+    // Versions list ordered DESC
+    const all = getPageVersions(page.id);
+    expect(all.map((v) => v.version)).toEqual([2, 1]);
+  });
+  test("UNIQUE(agentId, slug) is enforced", () => {
+    const agentId = makeAgentId();
+    createPage({
+      agentId,
+      slug: "dup",
+      title: "First",
+      contentType: "text/html",
+      authMode: "public",
+      body: "<h1>1</h1>",
+    });
+    expect(() =>
+      createPage({
+        agentId,
+        slug: "dup",
+        title: "Second",
+        contentType: "text/html",
+        authMode: "public",
+        body: "<h1>2</h1>",
+      }),
+    ).toThrow(/UNIQUE/);
+    // Different agent — same slug is fine
+    const otherAgent = makeAgentId();
+    const ok = createPage({
+      agentId: otherAgent,
+      slug: "dup",
+      title: "Other agent",
+      contentType: "text/html",
+      authMode: "public",
+      body: "<h1>x</h1>",
+    });
+    expect(ok.id).toBeTruthy();
+  });
+  test("password hash is not equal to plaintext", async () => {
+    const plaintext = "hunter2-secret";
+    const hash = await Bun.password.hash(plaintext, "bcrypt");
+    expect(hash).not.toBe(plaintext);
+    expect(hash.length).toBeGreaterThan(20);
+    const page = createPage({
+      agentId: makeAgentId(),
+      slug: "secret",
+      title: "Secret",
+      contentType: "text/html",
+      authMode: "password",
+      passwordHash: hash,
+      body: "<h1>secret</h1>",
+    });
+    expect(page.passwordHash).toBe(hash);
+    expect(page.passwordHash).not.toBe(plaintext);
+    expect(await Bun.password.verify(plaintext, page.passwordHash!)).toBe(true);
+  });
+  test("needsCredentials roundtrips as JSON array", () => {
+    const page = createPage({
+      agentId: makeAgentId(),
+      slug: "needs-creds",
+      title: "Needs",
+      contentType: "application/json",
+      authMode: "public",
+      body: "{}",
+      needsCredentials: ["GITHUB_TOKEN", "OPENAI_API_KEY"],
+    });
+    const fetched = getPage(page.id);
+    expect(fetched?.needsCredentials).toEqual(["GITHUB_TOKEN", "OPENAI_API_KEY"]);
+  });
+  test("snapshotPage throws on missing parent", () => {
+    expect(() => snapshotPage("0".repeat(32), "agent-x")).toThrow(/not found/);
+  });
+});

package/src/tests/pages-versioning.test.ts ADDED Viewed

@@ -0,0 +1,231 @@
+/**
+ * PUT /api/pages/:id versioning behavior.
+ *
+ * Per the plan (step-3 §1): each PUT calls `snapshotPage(id)` BEFORE
+ * `updatePage(id, …)`, so each row in `page_versions` holds the parent
+ * state as it stood IMMEDIATELY BEFORE that PUT. After three PUTs of a
+ * page created with body "v0", the version table should hold:
+ *   v1: snapshot.body = "v0" (state before PUT #1)
+ *   v2: snapshot.body = "v1" (state before PUT #2)
+ *   v3: snapshot.body = "v2" (state before PUT #3)
+ * And the parent (final state) holds "v3".
+ *
+ * Edit-counter returned to the caller is `MAX(version) + 1`.
+ */
+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 { getPathSegments, parseQueryParams } from "../http/utils";
+import type { PageVersion } from "../types";
+const TEST_DB_PATH = "./test-pages-versioning.sqlite";
+const TEST_PORT = 13041;
+const BASE = `http://localhost:${TEST_PORT}`;
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    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 handlePages(req, res, pathSegments, queryParams, myAgentId);
+    if (!handled) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "not found" }));
+    }
+  });
+}
+describe("Pages versioning (PUT /api/pages/:id)", () => {
+  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("three PUTs produce three version snapshots holding pre-update content", async () => {
+    // Create with body v0.
+    const created = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "vers",
+        title: "Versioning",
+        contentType: "text/html",
+        authMode: "public",
+        body: "v0",
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string; version: number };
+    // PUT v1, v2, v3.
+    for (const body of ["v1", "v2", "v3"]) {
+      const res = await fetch(`${BASE}/api/pages/${id}`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ body }),
+      });
+      expect(res.status).toBe(200);
+    }
+    // Final state is "v3".
+    const head = await fetch(`${BASE}/api/pages/${id}`, { headers });
+    expect(head.status).toBe(200);
+    const headPage = (await head.json()) as { body: string };
+    expect(headPage.body).toBe("v3");
+    // Versions: newest-first, so v3..v1 holding v2, v1, v0 respectively.
+    const versionsRes = await fetch(`${BASE}/api/pages/${id}/versions`, { headers });
+    expect(versionsRes.status).toBe(200);
+    const { versions } = (await versionsRes.json()) as { versions: PageVersion[] };
+    expect(versions).toHaveLength(3);
+    expect(versions[0]!.version).toBe(3);
+    expect(versions[0]!.snapshot.body).toBe("v2");
+    expect(versions[1]!.version).toBe(2);
+    expect(versions[1]!.snapshot.body).toBe("v1");
+    expect(versions[2]!.version).toBe(1);
+    expect(versions[2]!.snapshot.body).toBe("v0");
+  });
+  test("PUT response includes monotonically-increasing edit-counter version", async () => {
+    const created = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "counter",
+        title: "Counter",
+        contentType: "text/html",
+        authMode: "public",
+        body: "x0",
+      }),
+    });
+    const { id, version: createdVersion } = (await created.json()) as {
+      id: string;
+      version: number;
+    };
+    expect(createdVersion).toBe(1);
+    const observed: number[] = [];
+    for (const body of ["x1", "x2", "x3"]) {
+      const res = await fetch(`${BASE}/api/pages/${id}`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ body }),
+      });
+      const json = (await res.json()) as { version: number };
+      observed.push(json.version);
+    }
+    expect(observed).toEqual([2, 3, 4]);
+  });
+  test("PUT 404 for unknown id", async () => {
+    const res = await fetch(`${BASE}/api/pages/${"0".repeat(32)}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({ body: "noop" }),
+    });
+    expect(res.status).toBe(404);
+  });
+  test("GET /api/pages/:id/versions/:version returns single snapshot", async () => {
+    const created = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "byversion",
+        title: "ByVersion",
+        contentType: "text/html",
+        authMode: "public",
+        body: "alpha",
+      }),
+    });
+    const { id } = (await created.json()) as { id: string };
+    await fetch(`${BASE}/api/pages/${id}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({ body: "beta" }),
+    });
+    const single = await fetch(`${BASE}/api/pages/${id}/versions/1`, { headers });
+    expect(single.status).toBe(200);
+    const row = (await single.json()) as PageVersion;
+    expect(row.version).toBe(1);
+    expect(row.snapshot.body).toBe("alpha");
+    const missing = await fetch(`${BASE}/api/pages/${id}/versions/999`, { headers });
+    expect(missing.status).toBe(404);
+  });
+  test("DELETE /api/pages/:id removes parent + cascades version rows", async () => {
+    const created = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "doomed",
+        title: "Doomed",
+        contentType: "text/html",
+        authMode: "public",
+        body: "x",
+      }),
+    });
+    const { id } = (await created.json()) as { id: string };
+    // Force a version snapshot via a PUT.
+    await fetch(`${BASE}/api/pages/${id}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({ body: "y" }),
+    });
+    const del = await fetch(`${BASE}/api/pages/${id}`, { method: "DELETE", headers });
+    expect(del.status).toBe(204);
+    const after = await fetch(`${BASE}/api/pages/${id}`, { headers });
+    expect(after.status).toBe(404);
+    const afterVersions = await fetch(`${BASE}/api/pages/${id}/versions`, { headers });
+    expect(afterVersions.status).toBe(404);
+  });
+  test("GET /api/pages lists with share-URL pointers + total", async () => {
+    const listRes = await fetch(`${BASE}/api/pages?limit=10&offset=0`, { headers });
+    expect(listRes.status).toBe(200);
+    const json = (await listRes.json()) as {
+      pages: Array<{ id: string; api_url: string; app_url: string }>;
+      total: number;
+    };
+    expect(Array.isArray(json.pages)).toBe(true);
+    expect(typeof json.total).toBe("number");
+    for (const p of json.pages) {
+      expect(p.api_url).toContain(`/p/${p.id}`);
+      expect(p.app_url).toContain(`/pages/${p.id}`);
+    }
+  });
+});

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

@@ -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);
   });
 });