@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/heartbeat/heartbeat.ts

@@ -248,14 +248,15 @@ function isBootTriageAlways(): boolean {
 const HEARTBEAT_CHECKLIST_GATE_TIMEOUT_MS = 60_000;
 let checklistGateTimeoutMs = HEARTBEAT_CHECKLIST_GATE_TIMEOUT_MS;
 
-/** Seeded gate used when `HEARTBEAT_CHECKLIST_GATE_SCRIPT` is unset and Jev has a key. */
+/** Seeded gate used when `HEARTBEAT_CHECKLIST_GATE_SCRIPT` is unset and a gate provider has a key. */
 const DEFAULT_CHECKLIST_GATE_SCRIPT = "heartbeat-jev-gate";
 
 /**
  * Name of a global-scope script that decides whether a checklist tick needs
  * the Lead. An empty value or `off` turns the gate off. Unset falls back to
- * the seeded Jev gate, but only when Jev has a usable global key: without
- * one the script would open a setup approval request on the first tick.
+ * the seeded gate, but only when one of its providers has a usable global
+ * key: without one the script would open a setup approval request on the
+ * first tick.
  */
 async function heartbeatChecklistGateScript(): Promise<string | null> {
   const raw = process.env.HEARTBEAT_CHECKLIST_GATE_SCRIPT;
@@ -268,22 +269,41 @@ async function heartbeatChecklistGateScript(): Promise<string | null> {
 
 /**
  * Mirrors the provider pick in `heartbeat-jev-gate`: a global TypeSafe or
- * OpenRouter key, honoring `HEARTBEAT_JEV_GATE_PROVIDER`. An OpenRouter key
- * behind an `OPENROUTER_BASE_URL` gateway does not count, because the
- * decisions call refuses it and every tick would be an `error` verdict.
+ * OpenRouter key, or a Cloudflare token plus account id, honoring
+ * `HEARTBEAT_JEV_GATE_PROVIDER`. An OpenRouter key behind an
+ * `OPENROUTER_BASE_URL` gateway does not count, because the decisions call
+ * refuses it and every tick would be an `error` verdict.
  */
 async function hasJevGateKey(): Promise<boolean> {
   const pref = process.env.HEARTBEAT_JEV_GATE_PROVIDER?.trim().toLowerCase() || "auto";
-  const keys: string[] = [];
-  if (pref !== "openrouter") keys.push("TYPESAFE_API_KEY");
-  if (pref !== "typesafe" && getOpenRouterBaseUrl() === DEFAULT_OPENROUTER_BASE_URL) {
-    keys.push("OPENROUTER_API_KEY");
+  const auto = pref !== "typesafe" && pref !== "openrouter" && pref !== "cloudflare";
+  // Each entry is one provider: every key group must have a set value.
+  const providers: string[][][] = [];
+  if (auto || pref === "typesafe") providers.push([["TYPESAFE_API_KEY"]]);
+  if ((auto || pref === "openrouter") && getOpenRouterBaseUrl() === DEFAULT_OPENROUTER_BASE_URL) {
+    providers.push([["OPENROUTER_API_KEY"]]);
   }
-  try {
+  if (auto || pref === "cloudflare") {
+    providers.push([["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_API_KEY"], ["CLOUDFLARE_ACCOUNT_ID"]]);
+  }
+  const anySet = async (keys: string[]) => {
     for (const key of keys) {
       const rows = await getSwarmConfigs({ scope: "global", key });
       if (rows.some((row) => row.value.trim() !== "")) return true;
     }
+    return false;
+  };
+  try {
+    for (const groups of providers) {
+      let usable = true;
+      for (const group of groups) {
+        if (!(await anySet(group))) {
+          usable = false;
+          break;
+        }
+      }
+      if (usable) return true;
+    }
   } catch {
     // An unreadable secret row leaves the gate off; the checklist still runs.
   }

package/src/http/assets.ts

@@ -5,6 +5,7 @@ import { auditAssetKeys } from "../be/asset-key-audit";
 import { AssetKeyAuthorizationError, authorizeAssetKeyWrite } from "../be/asset-key-auth";
 import { resolveHttpAuditUserId } from "../be/audit-user";
 import {
+  AssetKeyMovesBlockedError,
   getDb,
   getDbClient,
   getRootTaskChain,
@@ -25,6 +26,7 @@ import {
 import { getRequestAuth } from "../utils/request-auth-context";
 import { requestPrincipal } from "./request-principal";
 import { route } from "./route-def";
+import { canReadSession, hasSessionWrite, SESSION_READ_DENIED } from "./session-access";
 import { jsonError } from "./utils";
 
 const AssetKeyAuditIssueSchema = z.object({
@@ -184,7 +186,7 @@ const moveAssetRoute = route({
   },
 });
 
-async function canMutateTaskNamespace(
+export async function canMutateTaskNamespace(
   task: { id: string; agentId: string | null; creatorAgentId?: string },
   myAgentId: string | undefined,
   req: IncomingMessage,
@@ -322,6 +324,16 @@ export async function handleAssets(
         jsonError(res, "Asset not found", 404);
         return true;
       }
+      if (!(await hasSessionWrite(req, myAgentId, task.id))) {
+        jsonError(
+          res,
+          (await canReadSession(req, myAgentId, task.id))
+            ? "You can view this session but not move it."
+            : SESSION_READ_DENIED,
+          403,
+        );
+        return true;
+      }
       // Only the tasks checked here move: a subtask created after this read stays put.
       const tasks = parsed.body.cascade ? await getRootTaskChain(task.id) : [task];
       for (const target of tasks) {
@@ -382,7 +394,7 @@ export async function handleAssets(
         return true;
       }
       const message = error instanceof Error ? error.message : String(error);
-      jsonError(res, message, message.includes("blocked until") ? 409 : 400);
+      jsonError(res, message, error instanceof AssetKeyMovesBlockedError ? 409 : 400);
     }
     return true;
   }

package/src/http/core.ts

@@ -29,6 +29,12 @@ import {
 import { enqueueAdmissionRow } from "../be/rbac-audit";
 import { getUserGrant } from "../be/rbac-roles";
 import { syncTelemetryEnabled } from "../be/telemetry-enable";
+import {
+  initBitbucket,
+  isBitbucketEnabled,
+  resetBitbucket,
+  resetBitbucketBotCache,
+} from "../bitbucket";
 import { initGitHub, resetGitHub } from "../github";
 import { initGitLab, isGitLabEnabled, resetGitLab } from "../gitlab";
 import { restartChatSdkIfConfigChanged } from "../integrations/chat-sdk/runtime";
@@ -248,6 +254,12 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
   teardownAzureDevOpsOutbound();
   if (isAzureDevOpsEnabled()) initAzureDevOpsOutbound();
 
+  // Same reset-then-init: the webhook secret and bot account id are cached.
+  resetBitbucket();
+  resetBitbucketBotCache();
+  initBitbucket();
+  if (isBitbucketEnabled()) integrations.push("bitbucket");
+
   resetLinear();
   if (await initLinear()) integrations.push("linear");
 

package/src/http/fs.ts

@@ -1,18 +1,25 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import { deleteTaskAttachment, getTaskAttachments, getTaskById } from "../be/db";
+import { appendDraftTaskText } from "../be/db/tasks/draft-text";
 import {
   ensureAgentFsCredentialsForAgent,
   inviteEmailToSharedOrg,
 } from "../be/seed/agent-fs-provision";
-import { MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload } from "../be/task-attachment-store";
-import { type FileObject, type FileScope, FilesError, normalizeFilesError } from "../fs/provider";
+import {
+  backingProviderId,
+  MAX_TASK_ATTACHMENT_BYTES,
+  recordTaskAttachmentUpload,
+  scopeFromAttachment,
+} from "../be/task-attachment-store";
+import { type FileObject, FilesError, normalizeFilesError } from "../fs/provider";
 import { getFileStorageProvider } from "../fs/registry";
 import { can, type RbacResource } from "../rbac";
 import { type TaskAttachment, TaskAttachmentSchema } from "../types";
 import { attachmentContentDisposition } from "../utils/content-disposition";
 import { getCurrentRequestAuth } from "../utils/request-auth-context";
 import { scrubSecrets } from "../utils/secret-scrubber";
+import { transcribeAudioNotes } from "../utils/transcription";
 import { requestPrincipal } from "./request-principal";
 import { route } from "./route-def";
 import { canReadSession, SESSION_READ_DENIED } from "./session-access";
@@ -147,7 +154,7 @@ const uploadTaskFileRoute = route({
   session: { taskParam: "taskId" },
   summary: "Upload a binary task file attachment",
   description:
-    "Accepts a raw binary request body. Pass the display/path name as the `name` query parameter.",
+    "Accepts a raw binary request body. Pass the display/path name as the `name` query parameter. An `audio/*` file uploaded to a `draft` task gets a `[File: …]` line and its transcript (or why there is none) appended to the task text before the response; a failed transcription never fails the upload.",
   tags: ["FS"],
   params: taskParams,
   query: uploadQuery,
@@ -331,7 +338,14 @@ export async function handleFs(
     const task = await getTaskById(parsed.params.taskId);
     if (!task) return notFound(res, "Task not found");
     if (!(await canMutateTask(task, myAgentId, req))) return forbidden(res);
-    return sendUpload(req, res, parsed.params.taskId, parsed.query, myAgentId ?? null);
+    return sendUpload(
+      req,
+      res,
+      parsed.params.taskId,
+      parsed.query,
+      myAgentId ?? null,
+      task.status === "draft",
+    );
   }
 
   if (listTaskFilesRoute.match(req.method, pathSegments)) {
@@ -366,6 +380,7 @@ async function sendUpload(
   taskId: string,
   query: z.infer<typeof uploadQuery>,
   agentId: string | null,
+  isDraft: boolean,
 ): Promise<boolean> {
   const body = await readRawBody(req, MAX_TASK_ATTACHMENT_BYTES);
   if (body === BODY_TOO_LARGE) {
@@ -417,10 +432,45 @@ async function sendUpload(
     isPrimary: query.isPrimary === "true",
     createdBy: auth?.kind === "user" ? auth.userId : undefined,
   });
+  const mimeType = contentType.split(";")[0]!.trim().toLowerCase();
+  if (isDraft && mimeType.startsWith("audio/")) {
+    await appendAudioTranscript(taskId, query.name, mimeType, body);
+  }
   uploadTaskFileRoute.respond(res, 201, attachment);
   return true;
 }
 
+/**
+ * A voice note uploaded to a draft (the composer's pre-dispatch window) gets
+ * its transcript in the task text, as one sent over Slack or a chat app does.
+ * Runs before the upload responds, so the composer promotes the draft only
+ * after the text is final. Never throws: the attachment has already landed.
+ */
+async function appendAudioTranscript(
+  taskId: string,
+  name: string,
+  mimeType: string,
+  body: Buffer,
+): Promise<void> {
+  try {
+    const notes = await transcribeAudioNotes(
+      [{ key: name, name, data: new Blob([body], { type: mimeType }), mimeType }],
+      "[fs]",
+    );
+    const note = notes.get(name);
+    if (!note) return;
+    if (!(await appendDraftTaskText(taskId, `[File: ${name} (${mimeType})]\n${note}`))) {
+      console.warn(`[fs] task ${taskId} left draft before the transcript of ${name} was added`);
+    }
+  } catch (error) {
+    console.warn(
+      scrubSecrets(
+        `[fs] could not add the transcript of ${name} to task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
 async function sendDownload(res: ServerResponse, attachment: TaskAttachment): Promise<boolean> {
   const provider = getFileStorageProvider();
   if (backingProviderId(attachment) !== provider.id) {
@@ -491,36 +541,6 @@ async function sendDelete(res: ServerResponse, attachment: TaskAttachment): Prom
   return true;
 }
 
-// Resolve against the row's ACTUAL stored key + its own org/drive, rather than
-// reconstructing `tasks/<taskId>/<name>`. Attachments written to agent-fs via the
-// CLI live at arbitrary paths (`misc/…`, `smoke/…`); reconstruction mis-resolves
-// them, which previously caused downloads to 404 and deletes to orphan the real
-// file. New uploads have no stored key yet at scope-build time and keep the
-// forward-looking layout.
-function scopeFromAttachment(attachment: TaskAttachment): FileScope {
-  const storedKey = attachment.providerKey ?? attachment.path ?? "";
-  return {
-    taskId: attachment.taskId,
-    name: attachment.name,
-    key: storedKey.trim() ? storedKey : undefined,
-    orgId: attachment.orgId,
-    driveId: attachment.driveId,
-  };
-}
-
-// Which file-storage provider (if any) actually holds this attachment's bytes.
-// Only agent-fs objects and local-fs uploads are provider-backed; `shared-fs`
-// worker-volume pointers, `url`, and `page` attachments have no provider object,
-// so they must never be fetched or deleted through a provider (doing so would
-// mis-resolve and, on delete, orphan the real target). Note local-fs uploads are
-// recorded with kind "shared-fs" but an explicit local-fs providerId, so key off
-// both signals rather than kind alone.
-function backingProviderId(attachment: TaskAttachment): string | null {
-  if (attachment.kind === "agent-fs") return attachment.providerId ?? "agent-fs";
-  if (attachment.providerId === "local-fs") return "local-fs";
-  return null;
-}
-
 async function findAttachment(
   req: IncomingMessage,
   myAgentId: string | undefined,

package/src/http/index.ts

@@ -33,6 +33,7 @@ import { loadSecretRegistry } from "../be/secret-registry";
 import { seedLegacyCapabilitiesConfig } from "../be/seed-capabilities";
 import { initApiTelemetry } from "../be/telemetry-enable";
 import { startWorkerNudgeListener } from "../be/worker-nudge-listener";
+import { initBitbucket } from "../bitbucket";
 import {
   loadEnabledExtensions,
   setExtensionLoopbackBaseUrl,
@@ -798,6 +799,9 @@ httpServer
     initAzureDevOps();
     initAzureDevOpsOutbound();
 
+    // Initialize Bitbucket Cloud webhook handler (if configured)
+    initBitbucket();
+
     // Initialize AgentMail webhook handler (if configured)
     initAgentMail();
 

package/src/http/mcp-body.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { MCP_MAX_REQUEST_BODY_BYTES } from "@/mcp-limits";
+import { parseBody, RequestBodyTooLargeError } from "./utils";
+
+/** Returned by `readMcpBody` after it has answered the request with 413. */
+export const MCP_BODY_TOO_LARGE = Symbol("mcp-body-too-large");
+
+/**
+ * Read and parse a JSON-RPC request body for an MCP HTTP handler, capped at
+ * `MCP_MAX_REQUEST_BODY_BYTES`. A declared Content-Length over the cap is
+ * refused before reading; otherwise the read stops once the cap is crossed.
+ * Either way the caller gets `MCP_BODY_TOO_LARGE` after a 413 with a JSON-RPC
+ * error body (the SDK transport's shape), and the body never reaches
+ * `JSON.parse`.
+ */
+export async function readMcpBody(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<unknown | typeof MCP_BODY_TOO_LARGE> {
+  try {
+    return await parseBody(req, MCP_MAX_REQUEST_BODY_BYTES);
+  } catch (error) {
+    if (!(error instanceof RequestBodyTooLargeError)) throw error;
+    res.writeHead(413, { "Content-Type": "application/json", Connection: "close" });
+    res.end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+          code: -32000,
+          message: `Payload Too Large: Request body must not exceed ${MCP_MAX_REQUEST_BODY_BYTES} bytes`,
+        },
+        id: null,
+      }),
+    );
+    return MCP_BODY_TOO_LARGE;
+  }
+}

package/src/http/mcp-user.ts

@@ -12,6 +12,7 @@ import {
   markMcpTransportActivity,
   respondNoMcpSession,
 } from "./mcp";
+import { MCP_BODY_TOO_LARGE, readMcpBody } from "./mcp-body";
 
 function unauthorized(res: ServerResponse): true {
   res.writeHead(401, { "Content-Type": "application/json" });
@@ -59,11 +60,8 @@ export async function handleMcpUser(
   }
 
   if (req.method === "POST") {
-    const chunks: Buffer[] = [];
-    for await (const chunk of req) {
-      chunks.push(chunk);
-    }
-    const body = JSON.parse(Buffer.concat(chunks).toString());
+    const body = await readMcpBody(req, res);
+    if (body === MCP_BODY_TOO_LARGE) return true;
 
     let transport: StreamableHTTPServerTransport;
 

package/src/http/mcp.ts

@@ -13,6 +13,7 @@ import {
   parseTaskToolManifest,
   selectTaskTools,
 } from "@/utils/task-tool-manifest";
+import { MCP_BODY_TOO_LARGE, readMcpBody } from "./mcp-body";
 
 export type McpTransportActivity = Record<string, number>;
 export type McpSessionAgents = Record<string, string>;
@@ -166,19 +167,17 @@ export async function handleMcp(
   if (agentMismatch) return true;
 
   if (req.method === "POST") {
-    const chunks: Buffer[] = [];
-    for await (const chunk of req) {
-      chunks.push(chunk);
-    }
-    const body = JSON.parse(Buffer.concat(chunks).toString());
+    const body = await readMcpBody(req, res);
+    if (body === MCP_BODY_TOO_LARGE) return true;
+    const rpc = body as { method?: unknown; id?: unknown } | null;
 
-    if (!sessionId && body.method === "server/discover") {
+    if (!sessionId && rpc?.method === "server/discover") {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(
         JSON.stringify({
           jsonrpc: "2.0",
           error: { code: -32601, message: "Method not found" },
-          id: body.id ?? null,
+          id: rpc.id ?? null,
         }),
       );
       return true;

package/src/http/memory.ts

@@ -35,6 +35,7 @@ import {
 } from "../be/memory/raters/types";
 import { rerank } from "../be/memory/reranker";
 import { getRetrievalsForAgent, hasRetrievalForTask } from "../be/memory/retrieval-store";
+import { searchMemoryCandidates } from "../be/memory/search-candidates";
 import { getUsefulnessStats } from "../be/memory/usefulness-stats";
 import { shouldPersistAutomaticTaskMemory } from "../memory/automatic-task-gate";
 import { buildRecallQuery } from "../memory/recall-query";
@@ -916,14 +917,19 @@ export async function handleMemory(
       const queryEmbedding = await provider.embed(query);
 
       const candidateLimit = Math.min(limit, 20) * CANDIDATE_SET_MULTIPLIER;
-      const candidates = await store.search(queryEmbedding ?? new Float32Array(0), myAgentId, {
-        scope,
-        limit: candidateLimit,
-        source,
-        isLead: false,
-        queryText: query,
-        keyPrefix,
-      });
+      const candidates = await searchMemoryCandidates(
+        store,
+        queryEmbedding ?? new Float32Array(0),
+        myAgentId,
+        {
+          scope,
+          limit: candidateLimit,
+          source,
+          isLead: false,
+          queryText: query,
+          keyPrefix,
+        },
+      );
       // Default-on 1-hop memory_link neighbor expansion (disable with
       // MEMORY_GRAPH_EXPANSION=0|false).
       const expanded = await expandCandidatesWithGraph(candidates, myAgentId, {
@@ -1039,13 +1045,18 @@ export async function handleMemory(
           4096,
           Math.max(offset + pageLimit, pageLimit) * CANDIDATE_SET_MULTIPLIER,
         );
-        let candidates = await store.search(queryEmbedding ?? new Float32Array(0), viewer.agentId, {
-          scope,
-          limit: candidateLimit,
-          isLead: viewer.seesAll,
-          source,
-          queryText: query.trim(),
-        });
+        let candidates = await searchMemoryCandidates(
+          store,
+          queryEmbedding ?? new Float32Array(0),
+          viewer.agentId,
+          {
+            scope,
+            limit: candidateLimit,
+            isLead: viewer.seesAll,
+            source,
+            queryText: query.trim(),
+          },
+        );
         if (agentId) {
           candidates = candidates.filter((c) => c.agentId === agentId);
         }

package/src/http/onboarding.ts

@@ -58,6 +58,7 @@ async function buildSignals(state: OnboardingState): Promise<OnboardingSignals>
       slack: integrations.slack === "configured",
       github: Boolean(process.env.GITHUB_TOKEN?.trim()) || integrations.github === "verified",
       gitlab: Boolean(process.env.GITLAB_TOKEN?.trim()),
+      bitbucket: Boolean(process.env.BITBUCKET_TOKEN?.trim()),
       linear: integrations.linear === "verified",
       jira: integrations.jira === "verified",
     },

package/src/http/page-proxy.ts

@@ -1,7 +1,11 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getPage } from "../be/db";
 import { getApiKey } from "../utils/api-key";
-import { extractAndVerifyCookie, parseCookieHeader } from "../utils/page-session";
+import {
+  extractLegacyPageSession,
+  extractPageSession,
+  isCookieSafePageId,
+} from "../utils/page-session";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
 
@@ -11,7 +15,10 @@ import { jsonError } from "./utils";
  *
  * Flow:
  *   1. Browser hits `/@swarm/api/<rest>` from inside an iframe of `/p/:id`.
- *   2. We parse the `page_session` cookie, verify HMAC + expiry.
+ *   2. The browser SDK names its page in `X-Swarm-Page-Id` (else we read the
+ *      same-host `/p/<id>` Referer). We read that page's `page_session_<id>`
+ *      cookie (or the legacy `page_session`), verify HMAC + expiry, and
+ *      require the signed payload to name the same page.
  *   3. Look up the page and recover the signed viewer identity.
  *   4. Re-issue the request to the same API server's `/api/<rest>` with
  *      the operator bearer plus the original signed session token. The bearer NEVER
@@ -119,6 +126,48 @@ route({
 
 const PROXY_PREFIX = "/@swarm/api/";
 
+/** Request header the browser SDK uses to say which page's session to use. */
+export const PAGE_ID_REQUEST_HEADER = "x-swarm-page-id";
+
+const PAGE_PATH_RE = /^\/p\/([^/.]+)/;
+
+/**
+ * Which page the caller claims to be: the `X-Swarm-Page-Id` header, else the
+ * `/p/<id>` path of a same-host Referer (pages that call `fetch` directly
+ * instead of the SDK). This only selects which cookie to read. It grants
+ * nothing: the cookie's signed payload must still name this page, and the
+ * forwarded `X-Page-Id` comes from that payload. `undefined` means the caller
+ * named no page (a client predating per-page cookies). `null` means it named
+ * one that cannot be a page id.
+ * Exported for tests.
+ */
+export function requestedPageId(req: IncomingMessage): string | null | undefined {
+  const raw = req.headers[PAGE_ID_REQUEST_HEADER];
+  const fromHeader = Array.isArray(raw) ? raw[0] : raw;
+  if (fromHeader !== undefined) return isCookieSafePageId(fromHeader) ? fromHeader : null;
+
+  const referer = req.headers.referer;
+  if (!referer) return undefined;
+  let refererUrl: URL;
+  try {
+    refererUrl = new URL(referer);
+  } catch {
+    return undefined;
+  }
+  // A cross-site Referer must not pick a cookie: a custom header would force a
+  // CORS preflight, a Referer does not.
+  if (refererUrl.host !== req.headers.host) return undefined;
+  const match = PAGE_PATH_RE.exec(refererUrl.pathname);
+  if (!match) return undefined;
+  let fromReferer: string;
+  try {
+    fromReferer = decodeURIComponent(match[1]!);
+  } catch {
+    return undefined;
+  }
+  return isCookieSafePageId(fromReferer) ? fromReferer : undefined;
+}
+
 /**
  * Reject a proxied suffix that smells like path traversal or an attempt to
  * smuggle an extra path segment via percent-encoding (e.g. `%2e%2e`, `%2f`).
@@ -194,11 +243,18 @@ export async function handlePageProxy(req: IncomingMessage, res: ServerResponse)
   }
 
   // ─── Cookie validation ────────────────────────────────────────────────────
-  const payload = await extractAndVerifyCookie(req);
-  if (!payload) {
+  const claimedPageId = requestedPageId(req);
+  const session =
+    claimedPageId === undefined
+      ? await extractLegacyPageSession(req)
+      : claimedPageId === null
+        ? null
+        : await extractPageSession(req, claimedPageId);
+  if (!session) {
     jsonError(res, "no page session", 401);
     return true;
   }
+  const { payload } = session;
 
   const page = await getPage(payload.pageId);
   if (!page) {
@@ -236,7 +292,7 @@ export async function handlePageProxy(req: IncomingMessage, res: ServerResponse)
   const headers: Record<string, string> = {
     Authorization: `Bearer ${apiKey}`,
     "X-Page-Id": page.id,
-    "X-Page-Session": parseCookieHeader(req.headers.cookie, "page_session") ?? "",
+    "X-Page-Session": session.token,
   };
   // The page owner is not the browser viewer. The receiving auth layer
   // verifies this original signed token before resolving any user identity.