@logicseek/hello-cc 1.0.5 → 1.1.0-rc.3

package/lib/web/http-routes.mjs

@@ -2,13 +2,19 @@
 // The single handleWebRequest dispatcher: auth/cookie exchange, static UI,
 // projects, sessions, peers, tmux/buffer-GC endpoints, and the status APIs.
 
-import path from 'node:path';
 import process from 'node:process';
 import { URL } from 'node:url';
 import { publicCliFailure, CliError } from '../shared/errors.mjs';
 import { required } from '../cli-args.mjs';
 import { terminalAssetPath } from './terminal-assets.mjs';
+import { browserAssetPath } from './browser-assets.mjs';
+import { listContextFiles } from './context-files.mjs';
+import { createAgentDefaults } from './agent-defaults.mjs';
+import { listProjectFiles, previewProjectFile, inspectProjectFileStatus, projectFileErrorStatus } from './project-files.mjs';
+import { saveProjectFile, uploadProjectFile } from './project-file-write.mjs';
 import { projectRecord } from '../runtime/projects.mjs';
+import { projectDbPath } from '../runtime/paths.mjs';
+import { resolveProjectDatabase } from '../runtime/project-path.mjs';
 import { writeRuntime } from '../runtime/state.mjs';
 import { normalizeStateResources } from '../ui/state-render.mjs';
 import { requestUrl, runtimeBaseUrl } from '../web/runtime.mjs';
@@ -17,6 +23,60 @@ import { API_VERSION, apiVersionUnsupportedBody, readHttpApiVersion } from '../w
 import { isDshHookBinding } from '../core/peers/bindings.mjs';
 import { writeAdoptionState } from './adoption-state.mjs';
 import { CodexAppServerError } from './codex-app-server.mjs';
+import { sameSelectedCwdIdentity } from '../process/selected-cwd-identity.mjs';
+import { scheduleResponseShutdown } from './shutdown-response.mjs';
+
+// Keep unknown API requests out of project resolution: resolving an arbitrary
+// root can create its managed state directory and refresh the project registry
+// even when the dispatcher ultimately returns 404. Null means the matching
+// dispatcher branch handles its own method error.
+const projectApiPaths = new Map([
+  ['/api/agent-defaults', null],
+  ['/api/files/tree', ['GET']], ['/api/files/preview', ['GET']],
+  ['/api/files/status', ['GET']], ['/api/files/content', ['PUT']], ['/api/files/upload', ['POST']],
+  ['/api/context/files', ['GET']],
+  ['/api/projects/select', ['POST']], ['/api/projects', ['GET', 'POST']],
+  ['/api/state', ['GET']], ['/api/detected', ['GET']], ['/api/resumable', ['GET']],
+  ['/api/runtime', ['GET']], ['/api/runtime/gc-buffers', ['POST']], ['/api/runtime/stop', ['POST']],
+  ['/api/sessions', ['GET', 'POST']], ['/api/sessions/attach', ['POST']],
+  ['/api/native/history', ['GET']], ['/api/codex/threads', ['GET']]
+]);
+const projectApiPatterns = [
+  [/^\/api\/peers\/[^/]+\/actions\/[^/]+$/, null],
+  [/^\/api\/native\/history\/[^/]+(?:\/resume)?$/, null],
+  [/^\/api\/sessions\/[^/]+\/native\/([^/]+)$/, null, {
+    GET: ['state', 'account'], POST: ['send', 'interrupt', 'close', 'respond']
+  }],
+  [/^\/api\/codex\/threads\/[^/]+(?:\/fork)?$/, null],
+  [/^\/api\/sessions\/[^/]+\/results$/, ['GET', 'POST']],
+  [/^\/api\/sessions\/[^/]+\/codex\/([^/]+)$/, null, {
+    GET: ['state', 'read', 'account'], POST: ['turn', 'steer', 'interrupt', 'approve']
+  }],
+  [/^\/api\/sessions\/[^/]+\/(?:input|stop)$/, ['POST']],
+  [/^\/api\/detected\/[^/]+\/(?:msg|stop|restart)$/, ['POST']]
+];
+
+function projectApiRouteExists(method, pathname) {
+  if (projectApiPaths.has(pathname)) {
+    const methods = projectApiPaths.get(pathname);
+    return methods === null || methods.includes(method);
+  }
+  return projectApiPatterns.some(([pattern, methods, actions]) => {
+    const match = pathname.match(pattern);
+    if (!match || methods !== null && !methods.includes(method)) return false;
+    if (!actions) return true;
+    try { return Array.isArray(actions[method]) && actions[method].includes(decodeURIComponent(match[1])); }
+    catch { return false; }
+  });
+}
+
+function legacyForbiddenCodexAction(method, pathname) {
+  if (method !== 'POST') return false;
+  const match = pathname.match(/^\/api\/sessions\/[^/]+\/codex\/([^/]+)$/);
+  if (!match) return false;
+  try { return ['account', 'login', 'logout', 'refreshToken'].includes(decodeURIComponent(match[1])); }
+  catch { return false; }
+}
 
 export function createHttpRoutes(deps) {
   const {
@@ -25,21 +85,32 @@ export function createHttpRoutes(deps) {
     broadcast, serializeSession, sessionsForProject, resolveSessionPeerId,
     parseCookieSid, closeWebSession, issueSession, sessionCookieHeader,
     expiredSessionCookieHeader, cookieSessionOk, webAuthMode,
-    rememberProject, knownProjects, resolveWebProjectContext,
+    rememberProject, knownProjects, selectedProjectIdentity, resolveWebProjectContext,
     connectWebProject, projectFromRequest, getSession, resolveWebActionSession,
     prepareRuntimeBufferGc, applyPreparedRuntimeBufferGc,
     detachTmuxSession, safeTmuxKillPlan, executeTmuxKillPlan,
     killDbProvenTmuxSession, attachTmuxSession, writeSessionInput, startSession,
     startCodexSession, codexAction, stopCodexSession, assertWebWrite,
     listCodexThreads, readCodexThread, forkCodexThread, readSessionResults, writeSessionResult,
-    discoverNativeSessions, nativeAction,
+    startNativeSession, listNativeHistory, nativeWorkerHistory, resumeNativeSession, discoverNativeSessions, nativeAction,
     webStatusSnapshot, webPeerActionForProject,
     now, addEvent, auditPayload, sendMessage,
     getProcessIdentity, getActualPort,
-    shutdown, tlsCredentials,
+    shutdown, prepareShutdown = () => {}, isStopping = () => false,
+    shutdownDiagnostic = () => {}, tlsCredentials,
     renderWebIndex, renderWebLogin, sendWebHtml, webErrorStatus,
     ACTIVE_PEER_TTL, DETECTED_PEER_MAX_AGE, PRODUCT_NAME, VERSION
   } = deps;
+  const { readAgentDefaults, saveAgentDefaults } = createAgentDefaults({ connectWebProject });
+
+  function assertRunning() {
+    if (isStopping()) throw new CliError('RUNTIME_STOPPING', 'Web runtime is stopping');
+  }
+  async function readActiveJsonRequest(req, options) {
+    const input = await readJsonRequest(req, options);
+    assertRunning();
+    return input;
+  }
 
   function ownsExecutor(session) {
     return session.status === 'running' || (session.type === 'app-server' &&
@@ -129,6 +200,10 @@ export function createHttpRoutes(deps) {
         sendJson(res, 401, { ok: false, error: { code: 'UNAUTHORIZED', message: 'Missing or invalid token' } });
         return;
       }
+      if (req.method === 'GET' && browserAssetPath(url.pathname)) {
+        sendFile(res, browserAssetPath(url.pathname), 'application/javascript; charset=utf-8');
+        return;
+      }
       if (req.method === 'GET' && url.pathname === '/pane') {
         // Only an existing browser session may create a workspace pane. Never
         // exchange a query token here or make the login page embeddable.
@@ -157,18 +232,112 @@ export function createHttpRoutes(deps) {
         res.end();
         return;
       }
-      const reqCtx = projectFromRequest(req, url);
+      // All remaining routes are versioned API routes. An unknown top-level
+      // navigation carries a SameSite=Lax cookie but cannot supply the API
+      // version header; do not resolve (and possibly create) a project before
+      // returning its 404.
+      if (!url.pathname.startsWith('/api/')) {
+        sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: 'Route not found' } });
+        return;
+      }
+      if (!projectApiRouteExists(req.method, url.pathname)) {
+        // The legacy Codex account-control POSTs have a stable BAD_REQUEST
+        // contract. Reject them here without resolving an arbitrary project.
+        if (legacyForbiddenCodexAction(req.method, url.pathname)) {
+          throw new CliError('BAD_REQUEST', 'Unsupported Codex action');
+        }
+        sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: 'Route not found' } });
+        return;
+      }
+      if (url.pathname !== '/api/runtime/stop' && url.pathname !== '/api/runtime') assertRunning();
+      // Project registration may explicitly name a replacement root in the
+      // JSON body. Read it after auth/origin checks, then resolve that root
+      // directly; falling through the stale startup root would reject B
+      // before its explicit selection is even examined.
+      const projectInput = req.method === 'POST' && url.pathname === '/api/projects'
+        ? await readActiveJsonRequest(req) : null;
+      // Reject an outside DB before resolving the body-selected root, which
+      // can create its managed state directory and record registry activity.
+      if (projectInput?.db) {
+        resolveProjectDatabase({
+          root: projectInput.root || url.searchParams.get('root') ||
+            url.searchParams.get('project') || req.headers['x-hcc-root'] || ctx.root,
+          db: projectInput.db,
+          createStateDir: false
+        });
+      }
+      const projectUrl = projectInput?.root && !url.searchParams.has('root') &&
+        !url.searchParams.has('project') && !req.headers['x-hcc-root']
+        ? new URL(url) : url;
+      if (projectUrl !== url) projectUrl.searchParams.set('root', projectInput.root);
+      const reqCtx = projectFromRequest(req, projectUrl, { requireIdentity: cookieAuthenticated });
+      if (url.pathname === '/api/agent-defaults') {
+        if (req.method === 'GET') { sendJson(res, 200, readAgentDefaults(reqCtx)); return; }
+        if (req.method === 'PUT') { sendJson(res, 200, saveAgentDefaults(reqCtx, await readActiveJsonRequest(req))); return; }
+        throw new CliError('BAD_REQUEST', 'Agent defaults support GET and PUT only');
+      }
+
+      if (req.method === 'GET' && url.pathname === '/api/files/tree') {
+        sendJson(res, 200, await listProjectFiles(reqCtx.root, url.searchParams.get('path') || '',
+          { rootIdentity: reqCtx.rootIdentity }));
+        return;
+      }
+      if (req.method === 'GET' && url.pathname === '/api/files/preview') {
+        sendJson(res, 200, await previewProjectFile(reqCtx.root, url.searchParams.get('path'),
+          { rootIdentity: reqCtx.rootIdentity }));
+        return;
+      }
+      if (req.method === 'GET' && url.pathname === '/api/files/status') {
+        sendJson(res, 200, await inspectProjectFileStatus(reqCtx.root, url.searchParams.get('path'),
+          { rootIdentity: reqCtx.rootIdentity })); return;
+      }
+      if (req.method === 'PUT' && url.pathname === '/api/files/content') {
+        const input = await readActiveJsonRequest(req, { maxBytes: 6 * 1024 * 1024 + 65536 });
+        sendJson(res, 200, await saveProjectFile(reqCtx.root, input, { rootIdentity: reqCtx.rootIdentity })); return;
+      }
+      if (req.method === 'POST' && url.pathname === '/api/files/upload') {
+        const input = await readActiveJsonRequest(req, { maxBytes: 14 * 1024 * 1024 + 65536 });
+        sendJson(res, 201, await uploadProjectFile(reqCtx.root, input, { rootIdentity: reqCtx.rootIdentity })); return;
+      }
+      if (req.method === 'GET' && url.pathname === '/api/context/files') {
+        sendJson(res, 200, await listContextFiles(reqCtx.root, url.searchParams.get('query') || '',
+          { rootIdentity: reqCtx.rootIdentity }));
+        return;
+      }
+      if (req.method === 'POST' && url.pathname === '/api/projects/select') {
+        // Selection is deliberate and may name any accessible server directory.
+        // It is not constrained to the registry, and does not inherit a stale
+        // identity from the previously selected browser project.
+        const selected = rememberProject(reqCtx, { register: true, nonblocking: true });
+        sendJson(res, 200, { projects: knownProjects(), current: projectRecord(selected),
+          project_identity: selectedProjectIdentity(selected) });
+        return;
+      }
       if (req.method === 'GET' && url.pathname === '/api/projects') {
-        sendJson(res, 200, { projects: knownProjects(), current: projectRecord(reqCtx) });
+        sendJson(res, 200, { projects: knownProjects(), current: projectRecord(reqCtx), project_identity: selectedProjectIdentity(reqCtx) });
         return;
       }
       if (req.method === 'POST' && url.pathname === '/api/projects') {
-        const input = await readJsonRequest(req);
+        const input = projectInput;
+        if (!input || typeof input !== 'object' || Array.isArray(input)) {
+          throw new CliError('BAD_REQUEST', 'Project registration requires a JSON object');
+        }
         const requestedRoot = input.root || reqCtx.root;
-        const projectCtx = rememberProject(resolveWebProjectContext(
+        const selected = resolveWebProjectContext(
           requestedRoot,
-          input.db || path.join(requestedRoot, '.hello-cc', 'mesh.db')
-        ), { register: true, nonblocking: true });
+          input.db || projectDbPath(requestedRoot)
+        );
+        let projectCtx;
+        try {
+          if ((req.headers['x-hcc-root-identity'] !== undefined || url.searchParams.has('root_identity')) &&
+              !sameSelectedCwdIdentity(reqCtx.rootIdentity, selected.rootIdentity)) {
+            throw new CliError('PROJECT_PATH_CHANGED', 'Selected project directory changed during request');
+          }
+          projectCtx = rememberProject(selected, { register: true, nonblocking: true });
+        } catch (error) {
+          selected.rootIdentity?.release();
+          throw error;
+        }
         const db = connectWebProject(projectCtx);
         db.close();
         writeRuntime(projectCtx, {
@@ -190,7 +359,7 @@ export function createHttpRoutes(deps) {
           global_runtime: true,
           started_at: now()
         });
-        sendJson(res, 200, { project: projectRecord(projectCtx), projects: knownProjects() });
+        sendJson(res, 200, { project: projectRecord(projectCtx), projects: knownProjects(), project_identity: selectedProjectIdentity(projectCtx) });
         return;
       }
       if (req.method === 'GET' && url.pathname === '/api/state') {
@@ -223,7 +392,7 @@ export function createHttpRoutes(deps) {
               ...Object.fromEntries(url.searchParams.entries()),
               resource: url.searchParams.getAll('resource')
             }
-          : await readJsonRequest(req);
+          : await readActiveJsonRequest(req);
         if (!readOnly && nativeAction) {
           const nativeSession = sessionsForProject(reqCtx).find(s => s.type === 'native' && [s.id, s.peerId].includes(peer));
           if (nativeSession) await nativeAction(nativeSession, 'read');
@@ -321,7 +490,7 @@ export function createHttpRoutes(deps) {
         return;
       }
       if (req.method === 'POST' && url.pathname === '/api/runtime/gc-buffers') {
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         if (!input || typeof input !== 'object' || Array.isArray(input)) {
           throw new CliError('BAD_REQUEST', 'buffer GC request must be an object');
         }
@@ -354,8 +523,10 @@ export function createHttpRoutes(deps) {
       }
       if (req.method === 'POST' && url.pathname === '/api/runtime/stop') {
         if (cookieAuthenticated) throw new CliError('RUNTIME_ADMIN_REQUIRED', 'Stop the runtime with the local administrator CLI');
+        shutdownDiagnostic('stop_accepted');
+        prepareShutdown();
+        scheduleResponseShutdown(res, shutdown);
         sendJson(res, 200, { ok: true, pid: process.pid });
-        setTimeout(shutdown, 10);
         return;
       }
       if (req.method === 'GET' && url.pathname === '/api/sessions') {
@@ -370,8 +541,34 @@ export function createHttpRoutes(deps) {
         }
         return;
       }
+      if (req.method === 'GET' && url.pathname === '/api/native/history') {
+        sendJson(res, 200, await listNativeHistory(reqCtx)); return;
+      }
+      const nativeHistoryMatch = url.pathname.match(/^\/api\/native\/history\/([^/]+)(\/resume)?$/);
+      if (nativeHistoryMatch) {
+        const peer = decodeURIComponent(nativeHistoryMatch[1]);
+        if (req.method === 'GET' && !nativeHistoryMatch[2]) {
+          const afterText = url.searchParams.get('after') || '0';
+          if (!/^(?:0|[1-9][0-9]*)$/.test(afterText) || !Number.isSafeInteger(Number(afterText))) throw new CliError('BAD_REQUEST', 'History cursor must be a nonnegative safe integer');
+          sendJson(res, 200, await nativeWorkerHistory(reqCtx, peer, { after: Number(afterText) })); return;
+        }
+        if (req.method === 'POST' && nativeHistoryMatch[2]) {
+          const session = await resumeNativeSession(reqCtx, peer, await readActiveJsonRequest(req));
+          sendJson(res, 200, { session: serializeSession(session) }); return;
+        }
+        throw new CliError('BAD_REQUEST', 'Unsupported native history action');
+      }
       if (req.method === 'POST' && url.pathname === '/api/sessions') {
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
+        if (!input || typeof input !== 'object' || Array.isArray(input)) throw new CliError('BAD_REQUEST', 'Session creation requires a JSON object');
+        if (input.transport === 'native' || input.backend === 'native') {
+          if (Object.keys(input).some(key => !['transport', 'kind', 'id', 'cwd', 'model'].includes(key))) {
+            throw new CliError('BAD_REQUEST', 'Native creation accepts only transport, kind, id, cwd and model');
+          }
+          const session = await startNativeSession({ ...input, projectCtx: reqCtx });
+          sendJson(res, 200, { session: serializeSession(session) });
+          return;
+        }
         const existing = input.id && sessionsForProject(reqCtx).find(s => s.id === input.id || s.peerId === input.id);
         if (existing) assertWebWrite?.(existing, input, authMode, req);
         const start = input.transport === 'app-server' || input.backend === 'app-server' ? startCodexSession : startSession;
@@ -381,7 +578,7 @@ export function createHttpRoutes(deps) {
         return;
       }
       if (req.method === 'POST' && url.pathname === '/api/sessions/attach') {
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         const bindingDb = connectWebProject(reqCtx);
         let binding;
         try {
@@ -416,8 +613,12 @@ export function createHttpRoutes(deps) {
         if (req.method === 'GET' && action === 'state') {
           sendJson(res, 200, { state: await nativeAction(session, 'read') }); return;
         }
+        if (req.method === 'GET' && action === 'account') {
+          sendJson(res, 200, { state: await nativeAction(session, 'account', {
+            generation: url.searchParams.get('generation'), owner: url.searchParams.get('owner'), sessionId: url.searchParams.get('sessionId') }) }); return;
+        }
         if (req.method !== 'POST' || !['send', 'interrupt', 'close', 'respond'].includes(action)) throw new CliError('BAD_REQUEST', 'Unsupported native action');
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         const authorizeMutation = () => assertWebWrite(session, input, 'cookie', req);
         authorizeMutation();
         const receipt = await nativeAction(session, action, { ...input, authorizeMutation });
@@ -436,7 +637,7 @@ export function createHttpRoutes(deps) {
           sendJson(res, 200, await readCodexThread(reqCtx, threadId)); return;
         }
         if (req.method !== 'POST' || !historyMatch[2]) throw new CliError('BAD_REQUEST', 'Unsupported history action');
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         // Fork keeps the source task owner; it is still a mutation of history
         // and must respect a source session's browser control when present.
         for (const source of sessionsForProject(reqCtx)) {
@@ -462,7 +663,7 @@ export function createHttpRoutes(deps) {
         if (!session) throw new CliError('NOT_FOUND', 'Session not found');
         if (req.method === 'GET') { sendJson(res, 200, readSessionResults(session)); return; }
         if (req.method !== 'POST') throw new CliError('BAD_REQUEST', 'Unsupported result action');
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         assertWebWrite(session, input, 'cookie', req);
         if (session.type === 'native') {
           await nativeAction(session, 'read');
@@ -484,10 +685,14 @@ export function createHttpRoutes(deps) {
         if (req.method === 'GET' && action === 'read') {
           sendJson(res, 200, await codexAction(session, 'read', {})); return;
         }
+        if (req.method === 'GET' && action === 'account') {
+          const account = await codexAction(session, 'account', { executorId: url.searchParams.get('executorId') });
+          sendJson(res, 200, { executorId: session.adapter.snapshot().executorId, account }); return;
+        }
         if (req.method !== 'POST' || !['turn', 'steer', 'interrupt', 'approve'].includes(action)) {
           throw new CliError('BAD_REQUEST', 'Unsupported Codex action');
         }
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         // Structured turns and approvals always need a live browser controller,
         // even when the caller also possesses the runtime administrator token.
         assertWebWrite(session, input, 'cookie', req);
@@ -513,7 +718,7 @@ export function createHttpRoutes(deps) {
           sendJson(res, 409, { ok: false, error: { code: 'SESSION_NOT_RUNNING', message: 'Session is not running' } });
           return;
         }
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         assertWebWrite?.(session, input, authMode, req);
         if (['app-server', 'native'].includes(session.type)) throw new CliError('BAD_REQUEST', 'Use structured worker actions');
         const text = String(input.text ?? input.data ?? '');
@@ -541,7 +746,8 @@ export function createHttpRoutes(deps) {
       if (req.method === 'POST' && stopMatch) {
         const id = decodeURIComponent(stopMatch[1]);
         let stopInput = {};
-        try { stopInput = await readJsonRequest(req); } catch {}
+        try { stopInput = await readActiveJsonRequest(req); } catch {}
+        assertRunning();
         const lookupDb = connectWebProject(reqCtx);
         let session;
         try {
@@ -605,7 +811,7 @@ export function createHttpRoutes(deps) {
       const detectedMsgMatch = url.pathname.match(/^\/api\/detected\/([^/]+)\/msg$/);
       if (req.method === 'POST' && detectedMsgMatch) {
         const peerId = decodeURIComponent(detectedMsgMatch[1]);
-        const input = await readJsonRequest(req);
+        const input = await readActiveJsonRequest(req);
         if (['all', '*'].includes(peerId)) throw new CliError('CONTROL_REQUIRED', 'Detected inbox messaging requires an individual peer; use a controlled coordination action for broadcast');
         if (sessionsForProject(reqCtx).some(s => [s.id, s.peerId].includes(peerId))) {
           throw new CliError('CONTROL_REQUIRED', 'Use the managed session message endpoint and its control lease');
@@ -633,7 +839,8 @@ export function createHttpRoutes(deps) {
           throw new CliError('CONTROL_REQUIRED', 'Use the managed session stop endpoint and its control lease');
         }
         let input = {};
-        try { input = await readJsonRequest(req); } catch {}
+        try { input = await readActiveJsonRequest(req); } catch {}
+        assertRunning();
         const db = connectWebProject(reqCtx);
         try {
           const binding = db.prepare('SELECT provider, transport FROM peer_bindings WHERE peer = ?').get(peerId);
@@ -712,12 +919,18 @@ export function createHttpRoutes(deps) {
       const detail = publicFailure || process.env.HCC_DEBUG
         ? publicError.message
         : 'internal server error';
-      const status = publicError.code === 'DSH_SESSION_CONTROL_UNSUPPORTED' ? 409 : webErrorStatus(publicError);
+      const status = publicError.code === 'RUNTIME_STOPPING' ? 503 : projectFileErrorStatus(publicError) || (['DSH_SESSION_CONTROL_UNSUPPORTED', 'AGENT_DEFAULTS_CONFLICT', 'AGENT_DEFAULTS_INVALID'].includes(publicError.code) ? 409
+        : publicError.code === 'INVALID_CONTEXT_QUERY' ? 400 : webErrorStatus(publicError));
       sendJson(res, status, {
         ok: false,
         error: {
           code: publicError.code || 'SERVER_ERROR',
           message: detail,
+          ...(['NATIVE_WORKER_DISCOVERY_FAILED', 'NATIVE_CREATE_UNCONFIRMED', 'NATIVE_RESUME_UNCONFIRMED'].includes(publicError.code) ? {
+            extra: { peer: publicError.extra.peer, provider: publicError.extra.provider,
+              ...(publicError.extra.executorId ? { executorId: publicError.extra.executorId } : {}),
+              created: publicError.extra.created === true, uncertain: publicError.extra.uncertain === true }
+          } : {}),
           ...(publicFailure?.cleanupFailed ? { cleanup_failed: true } : {})
         }
       });

package/lib/web/http.mjs

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import { timingSafeEqual } from 'node:crypto';
+import { TextDecoder } from 'node:util';
 import { CliError } from '../shared/errors.mjs';
 
 function readRequestBody(req, limit = 1024 * 1024) {
@@ -17,8 +18,8 @@ function readRequestBody(req, limit = 1024 * 1024) {
   });
 }
 
-export async function readJsonRequest(req) {
-  const body = await readRequestBody(req);
+export async function readJsonRequest(req, { maxBytes } = {}) {
+  const body = maxBytes === undefined ? await readRequestBody(req) : await readBoundedUtf8Body(req, maxBytes);
   if (!body.trim()) return {};
   try {
     return JSON.parse(body);
@@ -30,6 +31,51 @@ export async function readJsonRequest(req) {
   }
 }
 
+// File writes need a decoded-byte budget and enough JSON space for escaped
+// text or base64. Keep legacy callers' default limits unchanged.
+function readBoundedUtf8Body(req, maxBytes) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new TypeError('Invalid request byte limit');
+  return new Promise((resolve, reject) => {
+    const chunks = []; let length = 0, settled = false;
+    const tooLarge = () => new CliError('PROJECT_FILE_TOO_LARGE', 'The file request exceeds its byte limit');
+    const interrupted = () => new CliError('BAD_REQUEST', 'JSON request body was interrupted');
+    function cleanup() {
+      req.removeListener('data', onData); req.removeListener('end', onEnd);
+      req.removeListener('error', onError); req.removeListener('aborted', onAborted); req.removeListener('close', onClose);
+    }
+    function fail(error) {
+      if (settled) return;
+      settled = true; chunks.length = 0; reject(error);
+    }
+    function onData(chunk) {
+      if (settled) return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      length += buffer.length;
+      // Exiting IncomingMessage's async iterator destroys the request and may
+      // close its socket before the route can send JSON. Discard the remainder
+      // in flowing mode so an over-limit request still gets its 413 response.
+      if (length > maxBytes) { fail(tooLarge()); req.resume(); return; }
+      chunks.push(buffer);
+    }
+    function onEnd() {
+      cleanup();
+      if (settled) return;
+      let body;
+      try { body = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks, length)); }
+      catch { fail(new CliError('BAD_REQUEST', 'JSON request body must use valid UTF-8')); return; }
+      settled = true; chunks.length = 0; resolve(body);
+    }
+    function onError(error) { cleanup(); fail(error); }
+    function onAborted() { fail(interrupted()); }
+    function onClose() { cleanup(); if (!req.readableEnded) fail(interrupted()); }
+    req.on('data', onData); req.once('end', onEnd); req.once('error', onError);
+    req.once('aborted', onAborted); req.once('close', onClose);
+    if (req.destroyed || req.aborted) { cleanup(); fail(interrupted()); return; }
+    const declared = req.headers?.['content-length'];
+    if (declared && /^[0-9]+$/.test(declared) && Number(declared) > maxBytes) { fail(tooLarge()); req.resume(); }
+  });
+}
+
 export function contentSecurityPolicy(nonce, { pane = false } = {}) {
   const value = String(nonce || '');
   if (!/^[A-Za-z0-9_-]{16,}$/.test(value)) {
@@ -38,10 +84,10 @@ export function contentSecurityPolicy(nonce, { pane = false } = {}) {
   return "default-src 'self'; " +
     `script-src 'self' 'nonce-${value}'; ` +
     "style-src 'self' 'unsafe-inline'; " +
-    "img-src 'self' data:; " +
+    "img-src 'self' data: blob:; " +
     "connect-src 'self' ws: wss:; " +
     "object-src 'none'; base-uri 'none'; " +
-    (pane === true ? "frame-ancestors 'self'; frame-src 'none'" : "frame-ancestors 'none'");
+    (pane === true ? "frame-ancestors 'self'; frame-src 'none'" : "frame-ancestors 'none'; frame-src 'self' blob:");
 }
 
 export function sendHttp(res, status, contentType, body, options = {}) {

package/lib/web/liveness-reaper.mjs

@@ -11,7 +11,7 @@ import { peerEvidenceAllowsReap } from '../core/peers/evidence.mjs';
 
 export function createLivenessReaper(deps) {
   const {
-    ctx, projectContexts, sessions,
+    ctx, projectContexts, sessions, isStopping = () => false,
     sessionsForProject, connectWebProject,
     now, addEvent,
     peerEvidenceFromDb, mutatePeerWithEvidence, observeClockSafetyOrThrow,
@@ -57,7 +57,7 @@ export function createLivenessReaper(deps) {
   }
 
   function runClockAwareReaper() {
-    if (reaperInFlight) return;
+    if (isStopping() || reaperInFlight) return;
     reaperInFlight = true;
     try {
       // Probe exactly once per scheduler tick. A clock jump is machine-wide;