@desplega.ai/agent-swarm 1.78.1 → 1.79.1

package/src/http/utils.ts

@@ -1,11 +1,37 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getActiveTaskCount } from "../be/db";
 
-export function setCorsHeaders(res: ServerResponse) {
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
-  res.setHeader("Access-Control-Allow-Headers", "*");
-  res.setHeader("Access-Control-Expose-Headers", "*");
+export function setCorsHeaders(req: IncomingMessage, res: ServerResponse) {
+  // Echo the request Origin (rather than emitting `*`) so credentialed fetches
+  // — e.g. the SPA's `credentials: 'include'` calls to `/p/:id.json` and the
+  // page-session cookie endpoints — pass the browser's CORS check. A wildcard
+  // would force the browser to reject any credentialed cross-origin response.
+  const rawOrigin = req.headers.origin;
+  const origin = Array.isArray(rawOrigin) ? rawOrigin[0] : rawOrigin;
+  if (origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Credentials", "true");
+    // When credentials are involved the spec disallows wildcards in
+    // Allow-Headers / Allow-Methods / Expose-Headers — they must be
+    // explicit. Echo whatever the preflight asked for (defensive default
+    // covers Authorization + the common app headers).
+    const reqHeaders = req.headers["access-control-request-headers"];
+    const askedHeaders = Array.isArray(reqHeaders) ? reqHeaders.join(", ") : reqHeaders;
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      askedHeaders ?? "Authorization, Content-Type, X-Agent-ID, X-Requested-With",
+    );
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Expose-Headers", "Content-Type, Content-Length, ETag, Location");
+  } else {
+    // No Origin (curl / direct browser nav) — wildcards are fine and avoid
+    // breaking non-browser callers.
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "*");
+    res.setHeader("Access-Control-Expose-Headers", "*");
+  }
 }
 
 export function parseQueryParams(url: string): URLSearchParams {
@@ -45,6 +71,43 @@ export async function parseBody<T = unknown>(req: IncomingMessage): Promise<T> {
   return JSON.parse(Buffer.concat(chunks).toString()) as T;
 }
 
+/**
+ * Sentinel returned by `enforceContentLengthCap` when the request exceeds the
+ * provided byte cap. The caller has already received a `413` response — it
+ * should stop processing the request immediately.
+ */
+export const BODY_TOO_LARGE = Symbol("body-too-large");
+
+/**
+ * Reject the request with `413 Payload Too Large` when its `Content-Length`
+ * header exceeds `maxBytes`. Returns `BODY_TOO_LARGE` after writing the
+ * response (caller short-circuits); otherwise returns `null` and processing
+ * continues.
+ *
+ * This is a cheap pre-flight; downstream `parseBody`/streamed parsers can be
+ * a second defence if a malicious client lies about Content-Length.
+ *
+ * Used by `/api/pages` POST/PUT to bound the per-row body size — page bodies
+ * land in SQLite as a TEXT column and there is no per-instance quota yet.
+ */
+export function enforceContentLengthCap(
+  req: IncomingMessage,
+  res: ServerResponse,
+  maxBytes: number,
+): typeof BODY_TOO_LARGE | null {
+  const raw = req.headers["content-length"];
+  const val = Array.isArray(raw) ? raw[0] : raw;
+  if (!val) return null; // No header — best-effort; parseBody will still buffer.
+  const n = Number(val);
+  if (!Number.isFinite(n) || n < 0) return null;
+  if (n > maxBytes) {
+    res.writeHead(413, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: `Payload too large (max ${maxBytes} bytes)` }));
+    return BODY_TOO_LARGE;
+  }
+  return null;
+}
+
 /** Send JSON response */
 export function json(res: ServerResponse, data: unknown, status = 200) {
   res.writeHead(status, { "Content-Type": "application/json" });

package/src/pages/version.ts

@@ -0,0 +1,44 @@
+import { createPageVersion, getPage, getPageVersions } from "../be/db";
+import type { PageSnapshot, PageVersion } from "../types";
+
+/**
+ * Create a version snapshot of a page's current state.
+ *
+ * Call this BEFORE applying an update to preserve the pre-update state.
+ * Mirrors `snapshotWorkflow` (src/workflows/version.ts:13-44).
+ *
+ * 1. Load current page state
+ * 2. Get max version number for this page (page_versions ORDER BY version DESC)
+ * 3. Insert page_versions row with version+1 and the pre-update snapshot
+ *
+ * Throws on missing parent. Callers in HTTP handlers wrap this in a try/catch
+ * with an empty catch — snapshot failure should not block the update (matches
+ * the workflow pattern at src/http/workflows.ts:483-486).
+ */
+export function snapshotPage(pageId: string, changedByAgentId?: string): PageVersion {
+  const page = getPage(pageId);
+  if (!page) {
+    throw new Error(`Page ${pageId} not found — cannot create snapshot`);
+  }
+
+  const existingVersions = getPageVersions(pageId);
+  const maxVersion = existingVersions.length > 0 ? existingVersions[0]!.version : 0;
+  const nextVersion = maxVersion + 1;
+
+  const snapshot: PageSnapshot = {
+    title: page.title,
+    description: page.description,
+    contentType: page.contentType,
+    authMode: page.authMode,
+    passwordHash: page.passwordHash,
+    body: page.body,
+    needsCredentials: page.needsCredentials,
+  };
+
+  return createPageVersion({
+    pageId,
+    version: nextVersion,
+    snapshot,
+    changedByAgentId,
+  });
+}

package/src/prompts/session-templates.ts

@@ -297,6 +297,20 @@ agent-fs comment add docs/spec.md --body "Needs clarification on auth flow"
 agent-fs comment list docs/spec.md
 \`\`\`
 
+### Sharing agent-fs files with humans
+
+To give a human a direct link to a file, build the URL from the live host
+(env-var driven, never hardcode):
+
+\`\`\`
+\${AGENT_FS_LIVE_URL}/file/~/<org_id>/<drive_id>/<file_path>
+\`\`\`
+
+\`AGENT_FS_LIVE_URL\` defaults to \`https://live.agent-fs.dev\` if not set.
+\`<org_id>\` and \`<drive_id>\` come from the file's \`agent-fs stat <path> --json\`
+output (or the agent-fs CLI returns them on write). Use the **shared** drive
+id for files humans should review.
+
 Key conventions:
 - **Personal drive**: thoughts/{type}/YYYY-MM-DD-topic.md (plans, research, brainstorms)
 - **Shared drive**: thoughts/{{agentId}}/{type}/YYYY-MM-DD-topic.md (same structure, namespaced by your ID)
@@ -442,6 +456,41 @@ registerTemplate({
 Agents can serve interactive web content (HTML pages, dashboards, approval flows) via public URLs using localtunnel.
 Use the \`/artifacts\` skill for detailed instructions, examples, and API reference.
 Artifact content should be stored in \`/workspace/personal/artifacts/\` (persisted across sessions).
+
+For lightweight static reports / dashboards (HTML or JSON), prefer the
+\`create_page\` MCP tool (\`pages\` skill) — it stores in SQLite and serves at
+\`/p/:id\` without a PM2 process or tunnel.
+`,
+  variables: [],
+  category: "system",
+});
+
+registerTemplate({
+  eventType: "system.agent.share_urls",
+  header: "",
+  defaultBody: `
+### Share URLs (read from env, never hardcode)
+
+When you emit a link meant for a human or another agent — a page, artifact,
+agent-fs file, or any external URL — read the host from env. Hardcoded hosts
+break across deployments.
+
+| Env var | Purpose | Prod example |
+|---|---|---|
+| \`MCP_BASE_URL\` | API origin. Use for \`/p/:id\` direct page links and any \`/api/*\` curl examples. | \`https://api.example-swarm.dev\` |
+| \`APP_URL\` | SPA origin. Default share target for pages: \`\${APP_URL}/pages/:id\`. Append \`?mode=full\` for a maximized view (slim header + body fills viewport). | \`https://app.example-swarm.dev\` |
+| \`SWARM_URL\` | Bare host (no scheme). Use in copy / Slack messages that need just the domain. | \`app.example-swarm.dev\` |
+| \`AGENT_FS_LIVE_URL\` | agent-fs live origin. Share files via \`\${AGENT_FS_LIVE_URL}/file/~/<org_id>/<drive_id>/<file_path>\`. Defaults to \`https://live.agent-fs.dev\` if unset. | \`https://live.agent-fs.dev\` |
+
+**Page share patterns** (most common):
+- Default: \`\${APP_URL}/pages/:id\` — opens the SPA with chrome.
+- Full / standalone: \`\${APP_URL}/pages/:id?mode=full\` — hides sidebar/header; slim row with title + Exit-Full.
+- Direct API (no SPA): \`\${MCP_BASE_URL}/p/:id\` — HTML inlines; JSON 302→SPA.
+
+**agent-fs share pattern**: \`\${AGENT_FS_LIVE_URL}/file/~/<org_id>/<drive_id>/<file_path>\`.
+
+If a required env var is missing, **surface that to the user** — never fall
+back to a localhost value or invent a host when shipping a share link.
 `,
   variables: [],
   category: "system",
@@ -493,6 +542,7 @@ registerTemplate({
 {{@template[system.agent.context_mode]}}
 
 {{@template[system.agent.system]}}
+{{@template[system.agent.share_urls]}}
 {{@template[system.agent.code_quality]}}`,
   variables: [
     { name: "role", description: "The agent's role" },
@@ -513,6 +563,7 @@ registerTemplate({
 {{@template[system.agent.context_mode]}}
 
 {{@template[system.agent.system]}}
+{{@template[system.agent.share_urls]}}
 {{@template[system.agent.code_quality]}}`,
   variables: [
     { name: "role", description: "The agent's role" },

package/src/providers/pi-mono-adapter.ts

@@ -8,20 +8,20 @@
 
 import { existsSync, lstatSync, symlinkSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { getModel } from "@mariozechner/pi-ai";
+import { getModel } from "@earendil-works/pi-ai";
 import type {
   AgentSessionEvent,
   CreateAgentSessionOptions,
   SessionStats,
   ToolDefinition,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import {
   type AgentSession,
   createAgentSession,
   DefaultResourceLoader,
   getAgentDir,
   SessionManager,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import { type TSchema, Type } from "typebox";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { createSwarmHooksExtension } from "./pi-mono-extension";

package/src/providers/pi-mono-extension.ts

@@ -6,7 +6,7 @@
  * with full behavioral parity.
  */
 
-import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
 import { checkToolLoop, clearToolHistory } from "../hooks/tool-loop-detection";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";

package/src/server.ts

@@ -5,6 +5,7 @@ import { registerCancelTaskTool } from "./tools/cancel-task";
 import { registerContextDiffTool } from "./tools/context-diff";
 import { registerContextHistoryTool } from "./tools/context-history";
 import { registerCreateChannelTool } from "./tools/create-channel";
+import { registerCreatePageTool } from "./tools/create-page";
 import { registerDbQueryTool } from "./tools/db-query";
 import { registerDeleteChannelTool } from "./tools/delete-channel";
 import { registerGetSwarmTool } from "./tools/get-swarm";
@@ -12,6 +13,14 @@ import { registerGetTaskDetailsTool } from "./tools/get-task-details";
 import { registerGetTasksTool } from "./tools/get-tasks";
 import { registerInjectLearningTool } from "./tools/inject-learning";
 import { registerJoinSwarmTool } from "./tools/join-swarm";
+// KV capability
+import {
+  registerKvDeleteTool,
+  registerKvGetTool,
+  registerKvIncrTool,
+  registerKvListTool,
+  registerKvSetTool,
+} from "./tools/kv";
 // Messaging capability
 import { registerListChannelsTool } from "./tools/list-channels";
 import { registerListServicesTool } from "./tools/list-services";
@@ -120,7 +129,8 @@ import {
 
 // Capability-based feature flags
 // Default: all capabilities enabled
-const DEFAULT_CAPABILITIES = "core,task-pool,profiles,services,scheduling,memory,workflows";
+const DEFAULT_CAPABILITIES =
+  "core,task-pool,profiles,services,scheduling,memory,workflows,pages,kv";
 const CAPABILITIES = new Set(
   (process.env.CAPABILITIES || DEFAULT_CAPABILITIES).split(",").map((s) => s.trim()),
 );
@@ -284,6 +294,24 @@ export function createServer() {
   registerSkillSyncRemoteTool(server);
   registerSkillPublishTool(server);
 
+  // Pages capability - DB-backed lightweight artifacts (HTML / JSON specs).
+  // Enabled by default (added to DEFAULT_CAPABILITIES in step-9 of the
+  // db-backed-pages plan). Operators can disable via explicit
+  // `CAPABILITIES=...` env without `pages`.
+  if (hasCapability("pages")) {
+    registerCreatePageTool(server);
+  }
+
+  // KV capability — namespaced Redis-like key/value (see src/be/migrations/061_kv_store.sql).
+  // Enabled by default; opt out via `CAPABILITIES=...` without `kv`.
+  if (hasCapability("kv")) {
+    registerKvGetTool(server);
+    registerKvSetTool(server);
+    registerKvDeleteTool(server);
+    registerKvIncrTool(server);
+    registerKvListTool(server);
+  }
+
   // MCP Servers - always registered
   registerMcpServerCreateTool(server);
   registerMcpServerUpdateTool(server);

package/src/tasks/context-key.ts

@@ -6,6 +6,11 @@
  * a task belongs to. We persist the key on `agent_tasks.contextKey` so that a
  * single indexed lookup can return all sibling tasks for a given entity.
  *
+ * The same vocabulary is reused by the KV store (`kv_entries.namespace`) so a
+ * caller can read/write state scoped to the entity that triggered the call
+ * (Slack thread, PR, Linear issue, agent, page, ...) without inventing a
+ * separate namespace scheme.
+ *
  * Key schema:
  *   task:slack:{channelId}:{threadTs}
  *   task:agentmail:{threadId}
@@ -15,6 +20,8 @@
  *   task:trackers:jira:{issueIdentifier}          (e.g. PROJ-123 — case preserved)
  *   task:schedule:{scheduleId}
  *   task:workflow:{workflowRunId}
+ *   task:agent:{agentId}                          (KV-only: per-agent scratchpad)
+ *   task:page:{pageId}                            (KV-only: per-page state, proxy-enforced)
  *
  * Rules:
  *   - Fixed prefix tokens (`task`, family, sub-family, kind) are always lowercase.
@@ -157,6 +164,27 @@ export function workflowContextKey(input: { workflowRunId: string }): string {
   return ["task", "workflow", workflowRunId].join(SEPARATOR);
 }
 
+/**
+ * Per-agent KV scratchpad namespace. Not used as a task `contextKey` (tasks
+ * always derive their context from an ingress entity), but reused here so the
+ * KV layer can resolve "the caller has no task header, just an agent id" into
+ * a stable namespace string with the same shape as everything else.
+ */
+export function agentContextKey(input: { agentId: string }): string {
+  const agentId = assertSafePart(input.agentId, "agentId");
+  return ["task", "agent", agentId].join(SEPARATOR);
+}
+
+/**
+ * Per-page KV namespace. Enforced at the page-proxy boundary
+ * (src/http/page-proxy.ts) — pages can never write outside their own
+ * `task:page:<id>` namespace regardless of what the request body or URL says.
+ */
+export function pageContextKey(input: { pageId: string }): string {
+  const pageId = assertSafePart(input.pageId, "pageId");
+  return ["task", "page", pageId].join(SEPARATOR);
+}
+
 /**
  * Parse a context key back into a structured form. Throws on malformed input.
  * Useful for diagnostics and downstream routing; not used on the hot insert path.

package/src/telemetry.ts

@@ -14,11 +14,60 @@ const TIMEOUT_MS = 5_000;
 
 let installationId: string | null = null;
 let source = "unknown";
+let cachedIsCloud = false;
 
 function isEnabled(): boolean {
   return process.env.ANONYMIZED_TELEMETRY !== "false";
 }
 
+/**
+ * Hosts we own that indicate a cloud-pointed install. Exact-match for known
+ * hostnames + suffix-match for the cloud apexes so future cloud subdomains
+ * (`mcp.agent-swarm.dev`, `api.agent-swarm.cloud`, etc.) are automatically
+ * classified as cloud. Substring match is intentionally avoided —
+ * `agent-swarm.dev.attacker.com` must NOT be treated as cloud.
+ */
+const CLOUD_HOST_EXACT = new Set<string>([
+  "agent-swarm-mcp.desplega.sh",
+  "agent-swarm.dev",
+  "agent-swarm.cloud",
+]);
+const CLOUD_HOST_SUFFIXES = [".agent-swarm.dev", ".agent-swarm.cloud"];
+
+function isCloudHostname(hostname: string): boolean {
+  if (!hostname) return false;
+  const normalized = hostname.toLowerCase();
+  if (CLOUD_HOST_EXACT.has(normalized)) return true;
+  return CLOUD_HOST_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
+}
+
+/**
+ * Parse `MCP_BASE_URL` (or any candidate URL) into the cloud flag we ship on
+ * every telemetry event. URL parsing — not substring match — so we never
+ * confuse an attacker-controlled `agent-swarm.dev.bad` for cloud. On any
+ * parse failure returns a safe `false` so callers never need to defend
+ * against this throwing.
+ *
+ * The hostname itself is intentionally NOT emitted — telemetry is anonymous,
+ * and leaking the deployment host would defeat that. Only the boolean
+ * cloud-cohort flag ships.
+ *
+ * Exported for tests; not part of the public API.
+ */
+export function _resolveCloudMode(mcpBaseUrl: string | undefined | null): {
+  isCloud: boolean;
+} {
+  if (!mcpBaseUrl) return { isCloud: false };
+  let hostname: string;
+  try {
+    hostname = new URL(mcpBaseUrl).hostname;
+  } catch {
+    return { isCloud: false };
+  }
+  if (!hostname) return { isCloud: false };
+  return { isCloud: isCloudHostname(hostname) };
+}
+
 interface InitTelemetryOptions {
   /**
    * Whether to mint and persist a new install ID when the config read returns
@@ -48,6 +97,11 @@ export async function initTelemetry(
   if (!isEnabled()) return;
   source = sourceId;
   const generateIfMissing = options.generateIfMissing === true;
+
+  const resolved = _resolveCloudMode(process.env.MCP_BASE_URL);
+  cachedIsCloud = resolved.isCloud;
+  console.log(`telemetry: cloud=${cachedIsCloud}`);
+
   try {
     const existing = await getConfig("telemetry_installation_id");
     if (existing) {
@@ -110,7 +164,16 @@ export function track(options: TrackOptions): void {
       source,
       actor_mode: "anonymous" as const,
       actor_anonymous_id: installationId,
-      properties: options.properties ?? {},
+      properties: {
+        ...(options.properties ?? {}),
+        // Cloud-cohort signal derived from MCP_BASE_URL at init time.
+        // Placed at the top level of `properties_json` so ClickHouse can
+        // GROUP BY without descending into nested objects. Spread LAST so
+        // caller-supplied keys can never spoof the cohort classification.
+        // The hostname is intentionally NOT included — telemetry must stay
+        // anonymous, and the boolean is sufficient to split cloud vs self-host.
+        is_cloud: cachedIsCloud,
+      },
       metadata: {
         transport: "https",
         schema_version: 1,
@@ -138,6 +201,7 @@ export function track(options: TrackOptions): void {
 export function _resetTelemetryStateForTests(): void {
   installationId = null;
   source = "unknown";
+  cachedIsCloud = false;
 }
 
 /** Test-only: read the resolved install ID. */

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

@@ -0,0 +1,92 @@
+/**
+ * Regression test for the `/api/services` response-shape bug in
+ * `src/commands/artifact.ts` (artifactList / artifactStop).
+ *
+ * The endpoint returns `{ services: [...] }`, but earlier the code
+ * cast the JSON as a bare `Array<...>` and crashed with
+ * `services.filter is not a function`.
+ */
+
+import { afterAll, afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
+import { runArtifact } from "../commands/artifact";
+
+const originalFetch = globalThis.fetch;
+const originalLog = console.log;
+const originalError = console.error;
+
+let capturedOut: string[] = [];
+let capturedErr: string[] = [];
+
+beforeAll(() => {
+  console.log = (...args: unknown[]) => {
+    capturedOut.push(args.map(String).join(" "));
+  };
+  console.error = (...args: unknown[]) => {
+    capturedErr.push(args.map(String).join(" "));
+  };
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  capturedOut = [];
+  capturedErr = [];
+});
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+  console.log = originalLog;
+  console.error = originalError;
+});
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+describe("runArtifact('list')", () => {
+  test("handles wrapped { services: [] } without throwing", async () => {
+    globalThis.fetch = mock(() => Promise.resolve(jsonResponse({ services: [] })));
+
+    await expect(runArtifact("list", { additionalArgs: [] })).resolves.toBeUndefined();
+    expect(capturedOut.join("\n")).toContain("No active artifacts");
+    expect(capturedErr.join("\n")).not.toContain("services.filter");
+  });
+
+  test("renders artifact rows from { services: [...] }", async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        jsonResponse({
+          services: [
+            {
+              name: "artifact-testart",
+              agentId: "agent-xyz",
+              status: "healthy",
+              metadata: {
+                type: "artifact",
+                artifactName: "testart",
+                port: 4242,
+                publicUrl: "https://testart.loca.lt",
+              },
+            },
+          ],
+        }),
+      ),
+    );
+
+    await expect(runArtifact("list", { additionalArgs: [] })).resolves.toBeUndefined();
+    const out = capturedOut.join("\n");
+    expect(out).toContain("testart");
+    expect(out).toContain("4242");
+    expect(out).toContain("https://testart.loca.lt");
+    expect(out).toContain("healthy");
+  });
+
+  test("falls back to [] when response omits services key", async () => {
+    globalThis.fetch = mock(() => Promise.resolve(jsonResponse({})));
+
+    await expect(runArtifact("list", { additionalArgs: [] })).resolves.toBeUndefined();
+    expect(capturedOut.join("\n")).toContain("No active artifacts");
+  });
+});