@desplega.ai/agent-swarm 2.7.6 → 2.7.7

package/src/tests/internal-ai/task-title.test.ts

@@ -0,0 +1,283 @@
+import { describe, expect, test } from "bun:test";
+import type { completeStructuredWithModel } from "../../utils/internal-ai/complete-structured.js";
+import type {
+  CredentialKind,
+  ResolvedCredential,
+  resolveCredentials,
+} from "../../utils/internal-ai/credentials.js";
+import {
+  buildTaskTitlePlan,
+  generateTaskTitle,
+  kindForModelString,
+  normalizeTaskTitle,
+  prepareTaskTextForTitle,
+  TASK_TITLE_MAX_CHARS,
+  TASK_TITLE_MAX_TASK_CHARS,
+  TASK_TITLE_MODEL_CANDIDATES,
+  TASK_TITLE_MODEL_ENV,
+} from "../../utils/internal-ai/task-title.js";
+
+const LONG_TASK =
+  "Investigate why the nightly Playwright suite times out on the sessions page after the sidebar redesign and fix the flake.";
+
+function credential(kind: CredentialKind): ResolvedCredential {
+  return kind === "claude-cli"
+    ? { kind, modelDefault: "haiku" }
+    : { kind, apiKey: `key-${kind}`, modelDefault: `${kind}/default` };
+}
+
+/** `resolveCredentials` stub that offers exactly `kinds` and records every lookup. */
+function resolver(kinds: CredentialKind[], calls: CredentialKind[][] = []) {
+  const resolve: typeof resolveCredentials = async (opts) => {
+    const wanted = [...(opts?.kinds ?? [])];
+    calls.push(wanted);
+    return wanted.filter((kind) => kinds.includes(kind)).map(credential);
+  };
+  return { resolve, calls };
+}
+
+type CompleteFn = typeof completeStructuredWithModel;
+
+/** `completeStructuredWithModel` stub keyed by model string; absent = failure (null). */
+function completer(answers: Record<string, string | Error>, models: string[] = []) {
+  const complete: CompleteFn = async (opts) => {
+    const model = opts._credentialOverride?.modelDefault ?? "<none>";
+    models.push(model);
+    const answer = answers[model];
+    if (answer instanceof Error) throw answer;
+    if (answer === undefined) return null;
+    return { data: { title: answer }, model };
+  };
+  return { complete, models };
+}
+
+describe("normalizeTaskTitle", () => {
+  test("collapses whitespace, strips quotes, prefix, markdown and trailing punctuation", () => {
+    expect(normalizeTaskTitle('  "Fix   sessions sidebar flake."  ')).toBe(
+      "Fix sessions sidebar flake",
+    );
+    expect(normalizeTaskTitle("Title: **Rotate Slack token**")).toBe("Rotate Slack token");
+    expect(normalizeTaskTitle("“Add retry to poller”…")).toBe("Add retry to poller");
+    expect(normalizeTaskTitle("`Bump bun to 1.4`")).toBe("Bump bun to 1.4");
+  });
+
+  test("keeps question marks and inner punctuation", () => {
+    expect(normalizeTaskTitle("Why does the poller stall?")).toBe("Why does the poller stall?");
+    expect(normalizeTaskTitle("Migrate agent-fs 0.16.3 pins")).toBe("Migrate agent-fs 0.16.3 pins");
+  });
+
+  test("cuts long titles at a word boundary under the limit", () => {
+    const words = Array.from({ length: 40 }, (_, i) => `word${i}`).join(" ");
+    const title = normalizeTaskTitle(words);
+    expect(title.length).toBeLessThanOrEqual(TASK_TITLE_MAX_CHARS);
+    expect(title.endsWith("word")).toBe(false);
+    expect(words.startsWith(title)).toBe(true);
+  });
+
+  test("returns an empty string when nothing usable remains", () => {
+    expect(normalizeTaskTitle('""')).toBe("");
+    expect(normalizeTaskTitle(" ... ")).toBe("");
+  });
+});
+
+describe("prepareTaskTextForTitle", () => {
+  test("drops the sibling-awareness block and collapses blank lines", () => {
+    const task = `<sibling_tasks_in_progress>\n- other\n</sibling_tasks_in_progress>\n\n\n\nFix the login bug\n\n\n\nin the auth module`;
+    expect(prepareTaskTextForTitle(task)).toBe("Fix the login bug\n\nin the auth module");
+  });
+
+  test("keeps a prompt without the block and truncates long prompts", () => {
+    expect(prepareTaskTextForTitle("  hello\r\nworld ")).toBe("hello\nworld");
+    const long = "x".repeat(TASK_TITLE_MAX_TASK_CHARS + 500);
+    const prepared = prepareTaskTextForTitle(long);
+    expect(prepared.length).toBe(TASK_TITLE_MAX_TASK_CHARS + 2);
+    expect(prepared.endsWith(" …")).toBe(true);
+  });
+});
+
+describe("buildTaskTitlePlan", () => {
+  test("default plan is the candidate table", () => {
+    expect(buildTaskTitlePlan({})).toBe(TASK_TITLE_MODEL_CANDIDATES);
+  });
+
+  test("a pinned model moves its provider first and the model to the front", () => {
+    const plan = buildTaskTitlePlan({ [TASK_TITLE_MODEL_ENV]: "openai/gpt-5-nano" });
+    expect(plan[0]).toEqual({ kind: "openai", models: ["openai/gpt-5-nano", "openai/gpt-6-luna"] });
+    expect(plan.slice(1).map((group) => group.kind)).toEqual([
+      "openrouter",
+      "anthropic",
+      "openai-codex",
+      "claude-cli",
+    ]);
+  });
+
+  test("a pinned model outside the table is still tried first", () => {
+    const plan = buildTaskTitlePlan({ [TASK_TITLE_MODEL_ENV]: "anthropic/claude-haiku-4-5" });
+    expect(plan[0]?.models).toEqual(["anthropic/claude-haiku-4-5", "anthropic/claude-haiku-5-5"]);
+  });
+
+  test("a bare alias pins the claude CLI; an unsupported provider is ignored", () => {
+    expect(buildTaskTitlePlan({ [TASK_TITLE_MODEL_ENV]: "sonnet" })[0]).toEqual({
+      kind: "claude-cli",
+      models: ["sonnet", "haiku"],
+    });
+    expect(buildTaskTitlePlan({ [TASK_TITLE_MODEL_ENV]: "google/gemini-2.5-flash-lite" })).toBe(
+      TASK_TITLE_MODEL_CANDIDATES,
+    );
+  });
+
+  test("kindForModelString maps provider prefixes", () => {
+    expect(kindForModelString("openrouter/deepseek/deepseek-v4.1-flash")).toBe("openrouter");
+    expect(kindForModelString("openai-codex/gpt-6-luna")).toBe("openai-codex");
+    expect(kindForModelString("haiku")).toBe("claude-cli");
+    expect(kindForModelString("mistral/ministral-3b")).toBeNull();
+  });
+});
+
+describe("generateTaskTitle", () => {
+  test("short prompts are skipped before any credential lookup", async () => {
+    const { resolve, calls } = resolver(["openrouter"]);
+    const { complete, models } = completer({});
+    const result = await generateTaskTitle({
+      task: "fix the login bug",
+      env: {},
+      _resolveCredentials: resolve,
+      _completeStructured: complete,
+    });
+    expect(result).toEqual({ ok: false, reason: "short-task" });
+    expect(calls).toEqual([]);
+    expect(models).toEqual([]);
+  });
+
+  test("uses the first provider with a credential and its cheapest model", async () => {
+    const { resolve } = resolver(["anthropic", "openai"]);
+    const { complete, models } = completer({
+      "anthropic/claude-haiku-5-5": "Fix nightly Playwright timeout on sessions page",
+    });
+    const result = await generateTaskTitle({
+      task: LONG_TASK,
+      env: {},
+      _resolveCredentials: resolve,
+      _completeStructured: complete,
+    });
+    expect(result).toEqual({
+      ok: true,
+      title: "Fix nightly Playwright timeout on sessions page",
+      model: "anthropic/claude-haiku-5-5",
+      kind: "anthropic",
+    });
+    expect(models).toEqual(["anthropic/claude-haiku-5-5"]);
+  });
+
+  test("falls through models, then providers, on null results and thrown errors", async () => {
+    const { resolve } = resolver(["openrouter", "openai"]);
+    const { complete, models } = completer({
+      "openrouter/deepseek/deepseek-v4.1-flash": new Error("429 rate limited"),
+      // claude-haiku-5.5 absent → null
+      "openrouter/openai/gpt-6-luna": "   ",
+      "openai/gpt-6-luna": "Sessions page Playwright flake",
+    });
+    const result = await generateTaskTitle({
+      task: LONG_TASK,
+      env: {},
+      _resolveCredentials: resolve,
+      _completeStructured: complete,
+    });
+    expect(result).toEqual({
+      ok: true,
+      title: "Sessions page Playwright flake",
+      model: "openai/gpt-6-luna",
+      kind: "openai",
+    });
+    expect(models).toEqual([
+      "openrouter/deepseek/deepseek-v4.1-flash",
+      "openrouter/anthropic/claude-haiku-5.5",
+      "openrouter/openai/gpt-6-luna",
+      "openai/gpt-6-luna",
+    ]);
+  });
+
+  test("resolves one credential kind at a time and stops before the codex probe when an earlier provider answers", async () => {
+    const { resolve, calls } = resolver(["openrouter", "openai-codex"]);
+    const { complete } = completer({ "openrouter/deepseek/deepseek-v4.1-flash": "A title" });
+    await generateTaskTitle({
+      task: LONG_TASK,
+      env: {},
+      apiUrl: "http://127.0.0.1:1",
+      apiKey: "k",
+      _resolveCredentials: resolve,
+      _completeStructured: complete,
+    });
+    expect(calls).toEqual([["openrouter"]]);
+  });
+
+  test("reports no-credentials when nothing resolves and all-models-failed otherwise", async () => {
+    const none = resolver([]);
+    const silent = completer({});
+    expect(
+      await generateTaskTitle({
+        task: LONG_TASK,
+        env: {},
+        _resolveCredentials: none.resolve,
+        _completeStructured: silent.complete,
+      }),
+    ).toEqual({ ok: false, reason: "no-credentials" });
+    // Every kind was asked exactly once, in precedence order.
+    expect(none.calls.map((call) => call[0])).toEqual(
+      TASK_TITLE_MODEL_CANDIDATES.map((group) => group.kind),
+    );
+
+    const some = resolver(["claude-cli"]);
+    expect(
+      await generateTaskTitle({
+        task: LONG_TASK,
+        env: {},
+        _resolveCredentials: some.resolve,
+        _completeStructured: silent.complete,
+      }),
+    ).toEqual({ ok: false, reason: "all-models-failed" });
+    expect(silent.models).toEqual(["haiku"]);
+  });
+
+  test("the pinned model runs first and the credential override carries it", async () => {
+    const { resolve } = resolver(["openrouter", "openai"]);
+    let seenOverride: ResolvedCredential | undefined;
+    const complete: CompleteFn = async (opts) => {
+      seenOverride = opts._credentialOverride;
+      return { data: { title: "Pinned" }, model: "openai/gpt-5-nano" };
+    };
+    const result = await generateTaskTitle({
+      task: LONG_TASK,
+      env: { [TASK_TITLE_MODEL_ENV]: "openai/gpt-5-nano" },
+      _resolveCredentials: resolve,
+      _completeStructured: complete,
+    });
+    expect(result).toEqual({
+      ok: true,
+      title: "Pinned",
+      model: "openai/gpt-5-nano",
+      kind: "openai",
+    });
+    expect(seenOverride).toEqual({
+      kind: "openai",
+      apiKey: "key-openai",
+      modelDefault: "openai/gpt-5-nano",
+    });
+  });
+
+  test("an aborted signal stops the walk", async () => {
+    const { resolve } = resolver(["openrouter"]);
+    const { complete, models } = completer({ "openrouter/deepseek/deepseek-v4.1-flash": "T" });
+    const controller = new AbortController();
+    controller.abort();
+    const result = await generateTaskTitle({
+      task: LONG_TASK,
+      env: {},
+      signal: controller.signal,
+      _resolveCredentials: resolve,
+      _completeStructured: complete,
+    });
+    expect(result).toEqual({ ok: false, reason: "no-credentials" });
+    expect(models).toEqual([]);
+  });
+});

package/src/tests/merge-gate-detect-changes.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Runs the merge gate's "Compute per-domain change flags" step, verbatim from
+ * .github/workflows/merge-gate.yml, against throwaway git repos.
+ *
+ * Regression: a rename from a covered path to an excluded one (src/x.ts ->
+ * docs/x.ts) used to list only the destination, so the E2E Contract job (and
+ * every other src/-keyed flag) skipped a PR that removed a server input.
+ */
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
+
+type Workflow = {
+  jobs: Record<string, { steps: Array<{ id?: string; run?: string }> }>;
+};
+
+// The GitHub expression the step uses for the diff base; the test substitutes a local branch.
+const BASE_REF_EXPR = ["$", "{{ steps.base.outputs.ref }}"].join("");
+const WORKFLOW_PATH = join(import.meta.dir, "../../.github/workflows/merge-gate.yml");
+
+async function loadFlagStep(): Promise<string> {
+  const wf = Bun.YAML.parse(await Bun.file(WORKFLOW_PATH).text()) as Workflow;
+  const step = wf.jobs["detect-changes"]?.steps.find((s) => s.id === "check");
+  if (!step?.run) throw new Error("detect-changes step `check` not found in merge-gate.yml");
+  return step.run.replaceAll(BASE_REF_EXPR, "base");
+}
+
+// Isolate from the host's git config (a global diff.renames=false would make
+// the positive control pass for the wrong reason).
+const GIT_ENV = {
+  PATH: process.env.PATH,
+  HOME: tmpdir(),
+  GIT_CONFIG_NOSYSTEM: "1",
+  GIT_CONFIG_GLOBAL: "/dev/null",
+  GIT_AUTHOR_NAME: "t",
+  GIT_AUTHOR_EMAIL: "t@example.com",
+  GIT_COMMITTER_NAME: "t",
+  GIT_COMMITTER_EMAIL: "t@example.com",
+};
+
+const dirs: string[] = [];
+afterAll(async () => {
+  await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })));
+});
+
+async function git(cwd: string, ...args: string[]) {
+  return expectChildOk(await runChild(["git", ...args], { cwd, env: GIT_ENV }), `git ${args[0]}`);
+}
+
+// Large enough that git's default rename detection pairs the two sides.
+const BODY = Array.from({ length: 40 }, (_, i) => `export const v${i} = ${i};`).join("\n");
+
+/** Builds a repo whose `base` branch holds `files`, applies `change` on HEAD, and returns the step's flags. */
+async function flagsFor(
+  files: string[],
+  change: (repo: string) => Promise<void>,
+  script?: string,
+): Promise<Record<string, string>> {
+  const repo = await mkdtemp(join(tmpdir(), "merge-gate-flags-"));
+  dirs.push(repo);
+  await git(repo, "init", "-q", "-b", "base");
+  for (const f of files) {
+    await mkdir(dirname(join(repo, f)), { recursive: true });
+    await writeFile(join(repo, f), `${BODY}\n// ${f}\n`);
+  }
+  await git(repo, "add", "-A");
+  await git(repo, "commit", "-qm", "base");
+  await git(repo, "checkout", "-qb", "pr");
+  await change(repo);
+  await git(repo, "add", "-A");
+  await git(repo, "commit", "-qm", "pr");
+
+  const out = join(repo, ".gh-output");
+  const res = expectChildOk(
+    await runChild(["bash", "-c", script ?? (await loadFlagStep())], {
+      cwd: repo,
+      env: { ...GIT_ENV, GITHUB_OUTPUT: out },
+    }),
+    "flag step",
+  );
+  expect(res.stdout).toContain("Changed files:");
+  const flags: Record<string, string> = {};
+  for (const line of (await Bun.file(out).text()).split("\n")) {
+    const [k, v] = line.split("=");
+    if (k && v) flags[k] = v;
+  }
+  return flags;
+}
+
+const mv = (from: string, to: string) => async (repo: string) => {
+  await mkdir(dirname(join(repo, to)), { recursive: true });
+  await git(repo, "mv", from, to);
+};
+
+describe("merge-gate detect-changes flags", () => {
+  test(
+    "renaming a server file out of src/ still runs E2E",
+    async () => {
+      const flags = await flagsFor(["src/critical.ts"], mv("src/critical.ts", "docs/critical.ts"));
+      expect(flags.e2e).toBe("true");
+      expect(flags.test).toBe("true");
+      expect(flags.lint).toBe("true");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "renaming a docs file into src/ runs E2E",
+    async () => {
+      const flags = await flagsFor(["docs/notes.ts"], mv("docs/notes.ts", "src/notes.ts"));
+      expect(flags.e2e).toBe("true");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "a docs-only change skips E2E, tests, and lint",
+    async () => {
+      const flags = await flagsFor(["src/critical.ts", "docs/readme.md"], async (repo) => {
+        await writeFile(join(repo, "docs/readme.md"), "edited\n");
+      });
+      expect(flags.e2e).toBe("false");
+      expect(flags.test).toBe("false");
+      expect(flags.lint).toBe("false");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "control: with rename detection on, the outbound move hides from E2E",
+    async () => {
+      const step = await loadFlagStep();
+      expect(step).toContain("git diff --no-renames --name-only");
+      const flags = await flagsFor(
+        ["src/critical.ts"],
+        mv("src/critical.ts", "docs/critical.ts"),
+        step.replace("git diff --no-renames --name-only", "git diff --name-only"),
+      );
+      expect(flags.e2e).toBe("false");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});

package/src/tests/page-proxy.test.ts

@@ -252,7 +252,7 @@ describe("/api/pages/:id/launch", () => {
     expect(cookie!).toContain("HttpOnly");
     expect(cookie!).toContain("Path=/");
     expect(cookie!).toContain("Max-Age=3600");
-    // In dev (NODE_ENV != production) the cookie should be SameSite=Lax sans Secure.
+    // Under bun test (NODE_ENV=test) from http://localhost the cookie should be SameSite=Lax sans Secure.
     expect(cookie!).toContain("SameSite=Lax");
     expect(cookie!).not.toMatch(/\bSecure\b/);
     const cookieValue = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(cookie!)?.[1];

package/src/tests/page-session-dev-cookie.test.ts

@@ -0,0 +1,188 @@
+/**
+ * The page-session cookie may only drop `Secure` (SameSite=Lax) for an explicit
+ * development or test NODE_ENV and a request from http://localhost or
+ * http://127.0.0.1. Deployed images leave NODE_ENV unset, so unset must issue
+ * `SameSite=None; Secure`, and the localhost check must parse the origin
+ * instead of matching a string prefix.
+ *
+ * Covers both issuers: the launch endpoint (`src/http/pages.ts`) and the
+ * password flow on `/p/:id` (`src/http/pages-public.ts`).
+ */
+import { afterAll, afterEach, 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";
+import { isLocalDevPageRequest } from "../utils/page-session";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-page-session-dev-cookie.sqlite";
+const PASSWORD = "example-swordfish";
+const ORIGINAL_NODE_ENV = process.env.NODE_ENV;
+
+function setNodeEnv(value: string | undefined): void {
+  if (value === undefined) delete process.env.NODE_ENV;
+  else process.env.NODE_ENV = value;
+}
+
+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");
+  });
+}
+
+type Case = { name: string; nodeEnv: string | undefined; origin?: string; secure: boolean };
+
+const CASES: Case[] = [
+  { name: "NODE_ENV unset, no Origin", nodeEnv: undefined, secure: true },
+  {
+    name: "NODE_ENV unset, spoofed localhost prefix",
+    nodeEnv: undefined,
+    origin: "http://localhost.evil.example",
+    secure: true,
+  },
+  {
+    name: "NODE_ENV unset, real localhost origin",
+    nodeEnv: undefined,
+    origin: "http://localhost:5274",
+    secure: true,
+  },
+  {
+    name: "NODE_ENV=development, spoofed localhost prefix",
+    nodeEnv: "development",
+    origin: "http://localhost.evil.example",
+    secure: true,
+  },
+  {
+    name: "NODE_ENV=development, portless https origin",
+    nodeEnv: "development",
+    origin: "https://ui.swarm.localhost",
+    secure: true,
+  },
+  {
+    name: "NODE_ENV=development, localhost UI origin",
+    nodeEnv: "development",
+    origin: "http://localhost:5274",
+    secure: false,
+  },
+  {
+    name: "NODE_ENV=development, 127.0.0.1 UI origin",
+    nodeEnv: "development",
+    origin: "http://127.0.0.1:5274",
+    secure: false,
+  },
+];
+
+function expectCookieShape(cookie: string | null, secure: boolean): void {
+  expect(cookie).toContain("page_session_");
+  if (secure) {
+    expect(cookie!).toContain("SameSite=None");
+    expect(cookie!).toMatch(/\bSecure\b/);
+  } else {
+    expect(cookie!).toContain("SameSite=Lax");
+    expect(cookie!).not.toMatch(/\bSecure\b/);
+  }
+}
+
+describe("page-session cookie dev softening fails closed", () => {
+  let server: Server;
+  let base = "";
+  let authedId = "";
+  let passwordId = "";
+  const agentId = crypto.randomUUID();
+
+  async function createPage(body: Record<string, unknown>): Promise<string> {
+    const post = await fetch(`${base}/api/pages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ contentType: "text/html", body: "<h1>x</h1>", ...body }),
+    });
+    expect(post.status).toBe(201);
+    return ((await post.json()) as { id: string }).id;
+  }
+
+  beforeAll(async () => {
+    process.env.PAGE_SESSION_SECRET = "example-test-page-session-dev-cookie-secret";
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    server = createTestServer();
+    const port = await listenOnFreePort(server);
+    base = `http://localhost:${port}`;
+    authedId = await createPage({ slug: "dev-cookie-authed", title: "A", authMode: "authed" });
+    passwordId = await createPage({
+      slug: "dev-cookie-password",
+      title: "P",
+      authMode: "password",
+      password: PASSWORD,
+    });
+  });
+
+  afterEach(() => setNodeEnv(ORIGINAL_NODE_ENV));
+
+  afterAll(async () => {
+    setNodeEnv(ORIGINAL_NODE_ENV);
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test.each(CASES)("launch endpoint: $name", async ({ nodeEnv, origin, secure }) => {
+    setNodeEnv(nodeEnv);
+    const res = await fetch(`${base}/api/pages/${authedId}/launch`, {
+      method: "POST",
+      headers: { "X-Agent-ID": agentId, ...(origin ? { Origin: origin } : {}) },
+    });
+    expect(res.status).toBe(204);
+    expectCookieShape(res.headers.get("set-cookie"), secure);
+  });
+
+  test.each(CASES)("/p/:id password flow: $name", async ({ nodeEnv, origin, secure }) => {
+    setNodeEnv(nodeEnv);
+    const res = await fetch(`${base}/p/${passwordId}?key=${PASSWORD}`, {
+      redirect: "manual",
+      headers: origin ? { Origin: origin } : {},
+    });
+    expect(res.status).toBeLessThan(400);
+    expectCookieShape(res.headers.get("set-cookie"), secure);
+  });
+});
+
+describe("isLocalDevPageRequest Host fallback", () => {
+  afterEach(() => setNodeEnv(ORIGINAL_NODE_ENV));
+
+  test.each([
+    [undefined, "localhost:3013", false],
+    ["production", "localhost:3013", false],
+    ["development", "localhost:3013", true],
+    ["development", "127.0.0.1:3013", true],
+    ["development", undefined, true],
+    ["development", "localhost.evil.example", false],
+    ["development", "localhost@evil.example", false],
+    ["development", "api.swarm.localhost", false],
+  ] as const)("NODE_ENV=%p Host=%p → %p", (nodeEnv, host, expected) => {
+    setNodeEnv(nodeEnv);
+    expect(isLocalDevPageRequest({ headers: host === undefined ? {} : { host } })).toBe(expected);
+  });
+});

package/src/tests/pages-frame-ancestors.test.ts

@@ -50,6 +50,7 @@ describe("PAGES_FRAME_ANCESTORS on /p/:id", () => {
     APP_URL: process.env.APP_URL,
     DASHBOARD_URL: process.env.DASHBOARD_URL,
     PAGE_SESSION_SECRET: process.env.PAGE_SESSION_SECRET,
+    NODE_ENV: process.env.NODE_ENV,
   };
 
   function restore(key: keyof typeof ORIG): void {
@@ -93,7 +94,10 @@ describe("PAGES_FRAME_ANCESTORS on /p/:id", () => {
     BASE = `http://localhost:${port}`;
   });
 
-  afterEach(() => restore("PAGES_FRAME_ANCESTORS"));
+  afterEach(() => {
+    restore("PAGES_FRAME_ANCESTORS");
+    restore("NODE_ENV");
+  });
 
   afterAll(async () => {
     await new Promise<void>((resolve) => server.close(() => resolve()));
@@ -150,6 +154,29 @@ describe("PAGES_FRAME_ANCESTORS on /p/:id", () => {
     expect(blank).toBe(unset);
   });
 
+  // Deployed images leave NODE_ENV unset. Localhost dev origins must only be
+  // allowed to frame pages under an explicit development or test NODE_ENV.
+  for (const nodeEnv of [undefined, "production", "staging"]) {
+    test(`NODE_ENV=${nodeEnv ?? "<unset>"} emits no localhost ancestors`, async () => {
+      if (nodeEnv === undefined) delete process.env.NODE_ENV;
+      else process.env.NODE_ENV = nodeEnv;
+      const id = await createPage(`public-env-${nodeEnv ?? "unset"}`, "public");
+      const fa = frameAncestors(await fetch(`${BASE}/p/${id}`));
+      expect(fa.trim()).toBe("frame-ancestors 'self' https://app.example.test");
+    });
+  }
+
+  for (const nodeEnv of ["development", "test"]) {
+    test(`NODE_ENV=${nodeEnv} keeps the local dashboard origins`, async () => {
+      process.env.NODE_ENV = nodeEnv;
+      const id = await createPage(`public-env-${nodeEnv}`, "public");
+      const fa = frameAncestors(await fetch(`${BASE}/p/${id}`));
+      expect(fa).toContain("https://app.example.test");
+      expect(fa).toContain("http://localhost:5274");
+      expect(fa).toContain("https://*.localhost");
+    });
+  }
+
   test("parser accepts comma or space lists and drops invalid entries", () => {
     process.env.PAGES_FRAME_ANCESTORS =
       "https://www.agent-swarm.dev/, https://*.example.com:8443 blog.example.org,* 'none' https://evil.test;script-src javascript:alert(1) https://x.test/path";