@logicseek/hello-cc 1.0.1 → 1.0.2

package/lib/web/http-routes.mjs

@@ -14,6 +14,9 @@ import { normalizeStateResources } from '../ui/state-render.mjs';
 import { requestUrl, runtimeBaseUrl } from '../web/runtime.mjs';
 import { authOk, readJsonRequest, requestMatchesProxyOrigin, requestOriginMatches, sendFile, sendJson, tokenMatches } from '../web/http.mjs';
 import { API_VERSION, apiVersionUnsupportedBody, readHttpApiVersion } from '../web/api-version.mjs';
+import { isDshHookBinding } from '../core/peers/bindings.mjs';
+import { writeAdoptionState } from './adoption-state.mjs';
+import { CodexAppServerError } from './codex-app-server.mjs';
 
 export function createHttpRoutes(deps) {
   const {
@@ -27,6 +30,9 @@ export function createHttpRoutes(deps) {
     prepareRuntimeBufferGc, applyPreparedRuntimeBufferGc,
     detachTmuxSession, safeTmuxKillPlan, executeTmuxKillPlan,
     killDbProvenTmuxSession, attachTmuxSession, writeSessionInput, startSession,
+    startCodexSession, codexAction, stopCodexSession, assertWebWrite,
+    listCodexThreads, readCodexThread, forkCodexThread, readSessionResults, writeSessionResult,
+    discoverNativeSessions, nativeAction,
     webStatusSnapshot, webPeerActionForProject,
     now, addEvent, auditPayload, sendMessage,
     getProcessIdentity, getActualPort,
@@ -35,6 +41,12 @@ export function createHttpRoutes(deps) {
     ACTIVE_PEER_TTL, DETECTED_PEER_MAX_AGE, PRODUCT_NAME, VERSION
   } = deps;
 
+  function ownsExecutor(session) {
+    return session.status === 'running' || (session.type === 'app-server' &&
+      !session.executorReleased && !session.adapter.snapshot().processExited) ||
+      (session.type === 'native' && !session.nativeRetired && session.status !== 'exited');
+  }
+
   const handleWebRequest = async (req, res) => {
     const url = requestUrl(req);
     try {
@@ -54,7 +66,7 @@ export function createHttpRoutes(deps) {
           }
           const sid = issueSession();
           const params = new URLSearchParams();
-          for (const key of ['project', 'root']) {
+          for (const key of ['project', 'root', 'session']) {
             const value = url.searchParams.get(key);
             if (value) params.set(key, value);
           }
@@ -80,6 +92,14 @@ export function createHttpRoutes(deps) {
         sendFile(res, path.join(packageRoot(), 'node_modules', '@xterm', 'xterm', 'css', 'xterm.css'), 'text/css; charset=utf-8');
         return;
       }
+      if (req.method === 'GET' && url.pathname === '/assets/addon-fit.js') {
+        sendFile(res, path.join(packageRoot(), 'node_modules', '@xterm', 'addon-fit', 'lib', 'addon-fit.js'), 'application/javascript; charset=utf-8');
+        return;
+      }
+      if (req.method === 'GET' && url.pathname === '/assets/addon-search.js') {
+        sendFile(res, path.join(packageRoot(), 'node_modules', '@xterm', 'addon-search', 'lib', 'addon-search.js'), 'application/javascript; charset=utf-8');
+        return;
+      }
       if (req.method === 'POST' && url.pathname === '/login') {
         const input = await readJsonRequest(req);
         const loginToken = String(input.token || '');
@@ -105,6 +125,16 @@ export function createHttpRoutes(deps) {
         sendJson(res, 401, { ok: false, error: { code: 'UNAUTHORIZED', message: 'Missing or invalid token' } });
         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.
+        if (!cookieSessionOk(req)) {
+          sendJson(res, 401, { ok: false, error: { code: 'UNAUTHORIZED', message: 'A browser session is required for a workspace pane' } });
+          return;
+        }
+        sendWebHtml(res, renderWebIndex, { pane: true });
+        return;
+      }
       const safeMethod = ['GET', 'HEAD', 'OPTIONS'].includes(req.method || '');
       // Cookie-authenticated writes require affirmative same-origin evidence;
       // a missing Origin is not sufficient. Token-authenticated CLI requests
@@ -190,6 +220,10 @@ export function createHttpRoutes(deps) {
               resource: url.searchParams.getAll('resource')
             }
           : await readJsonRequest(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');
+        }
         const actionInput = readOnly
           ? input
           : { ...input, actorPeer: resolveWebActionSession(reqCtx, peer, input, req) };
@@ -198,17 +232,20 @@ export function createHttpRoutes(deps) {
       }
       // Detected sessions: peers registered via hooks/watcher but without PTY
       if (req.method === 'GET' && url.pathname === '/api/detected') {
+        await discoverNativeSessions?.(reqCtx);
         const db = connectWebProject(reqCtx);
         let detected = [];
         const managedIds = new Set();
         const t = now();
         try {
           detected = db.prepare(`
-            SELECT id, kind, role, status, worktree, branch, pid, capabilities,
-                   created_at, last_seen_at, (? - last_seen_at) AS age_sec
-            FROM peers
-            WHERE status != 'exited' AND last_seen_at >= ?
-            ORDER BY last_seen_at DESC, id ASC
+            SELECT p.id, p.kind, p.role, p.status, p.worktree, p.branch, p.pid, p.capabilities,
+                   p.created_at, p.last_seen_at, (? - p.last_seen_at) AS age_sec,
+                   b.provider, b.transport, b.provider_session_id, b.provider_session_name
+            FROM peers p
+            LEFT JOIN peer_bindings b ON b.peer = p.id
+            WHERE p.status != 'exited' AND p.last_seen_at >= ?
+            ORDER BY p.last_seen_at DESC, p.id ASC
             LIMIT 100
           `).all(t, t - DETECTED_PEER_MAX_AGE);
           for (const session of sessionsForProject(reqCtx)) {
@@ -312,11 +349,13 @@ export function createHttpRoutes(deps) {
         throw new CliError('BAD_REQUEST', 'buffer GC phase must be prepare or apply');
       }
       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');
         sendJson(res, 200, { ok: true, pid: process.pid });
         setTimeout(shutdown, 10);
         return;
       }
       if (req.method === 'GET' && url.pathname === '/api/sessions') {
+        await discoverNativeSessions?.(reqCtx);
         const db = connectWebProject(reqCtx);
         try {
           sendJson(res, 200, {
@@ -329,23 +368,131 @@ export function createHttpRoutes(deps) {
       }
       if (req.method === 'POST' && url.pathname === '/api/sessions') {
         const input = await readJsonRequest(req);
-        const session = startSession({ ...input, projectCtx: reqCtx, auditActorPeer: 'web', auditSource: 'web' });
+        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;
+        const session = await start({ ...input, projectCtx: reqCtx, auditActorPeer: 'web', auditSource: 'web',
+          authorizeMutation: existing => assertWebWrite?.(existing, input, authMode, req) });
         sendJson(res, 200, { session: serializeSession(session) });
         return;
       }
       if (req.method === 'POST' && url.pathname === '/api/sessions/attach') {
         const input = await readJsonRequest(req);
-        const session = attachTmuxSession({ ...input, projectCtx: reqCtx, auditActorPeer: 'web', auditSource: 'web' });
+        const bindingDb = connectWebProject(reqCtx);
+        let binding;
+        try {
+          binding = input.id ? bindingDb.prepare('SELECT provider, transport FROM peer_bindings WHERE peer = ?').get(input.id) : null;
+        } finally {
+          bindingDb.close();
+        }
+        if (binding?.transport === 'native') throw new CliError('NATIVE_MANAGED_SESSION', 'Open the existing native worker instead of attaching a terminal');
+        if (isDshHookBinding(binding) || input.kind === 'dsh' || input.binding?.provider === 'dsh') {
+          sendJson(res, 409, { ok: false, error: { code: 'DSH_SESSION_CONTROL_UNSUPPORTED', message: 'Control this agent in the dsh Web UI. A dsh service pane cannot represent an individual agent session.' } });
+          return;
+        }
+        for (const existing of sessionsForProject(reqCtx)) {
+          if ((input.id && [existing.id, existing.peerId].includes(input.id)) ||
+            (input.pane && existing.pane === input.pane)) assertWebWrite?.(existing, input, authMode, req);
+        }
+        const session = attachTmuxSession({ ...input, projectCtx: reqCtx, auditActorPeer: 'web', auditSource: 'web',
+          authorizeMutation: existing => assertWebWrite?.(existing, input, authMode, req) });
+        const adoptionDb = connectWebProject(reqCtx);
+        try { writeAdoptionState(adoptionDb, session, false, now()); } finally { adoptionDb.close(); }
         sendJson(res, 200, { session: serializeSession(session) });
         return;
       }
+      const nativeMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/native\/([^/]+)$/);
+      if (nativeMatch) {
+        await discoverNativeSessions?.(reqCtx);
+        const db = connectWebProject(reqCtx);
+        let session;
+        try { session = getSession(reqCtx, decodeURIComponent(nativeMatch[1]), db); } finally { db.close(); }
+        if (!session || session.type !== 'native') throw new CliError('NOT_FOUND', 'Native worker not found');
+        const action = decodeURIComponent(nativeMatch[2]);
+        if (req.method === 'GET' && action === 'state') {
+          sendJson(res, 200, { state: await nativeAction(session, 'read') }); 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 authorizeMutation = () => assertWebWrite(session, input, 'cookie', req);
+        authorizeMutation();
+        const receipt = await nativeAction(session, action, { ...input, authorizeMutation });
+        sendJson(res, 200, { receipt, state: session.nativeSnapshot() }); return;
+      }
+      if (req.method === 'GET' && url.pathname === '/api/codex/threads') {
+        const limit = url.searchParams.has('limit') ? Number(url.searchParams.get('limit')) : 30;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new CliError('BAD_REQUEST', 'limit must be from 1 to 100');
+        sendJson(res, 200, await listCodexThreads(reqCtx, { cursor: url.searchParams.get('cursor') || null, limit }));
+        return;
+      }
+      const historyMatch = url.pathname.match(/^\/api\/codex\/threads\/([^/]+)(\/fork)?$/);
+      if (historyMatch) {
+        const threadId = decodeURIComponent(historyMatch[1]);
+        if (req.method === 'GET' && !historyMatch[2]) {
+          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);
+        // 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)) {
+          if (source.binding?.provider === 'codex' && source.binding.provider_session_id === threadId && ownsExecutor(source)) {
+            assertWebWrite(source, input, 'cookie', req);
+          }
+        }
+        const authorizeMutation = () => {
+          for (const source of sessionsForProject(reqCtx)) {
+            if (source.binding?.provider === 'codex' && source.binding.provider_session_id === threadId && ownsExecutor(source)) {
+              assertWebWrite(source, input, 'cookie', req);
+            }
+          }
+        };
+        const forked = await forkCodexThread(reqCtx, threadId, { ...input, authorizeMutation });
+        sendJson(res, 200, { session: serializeSession(forked.session), thread: forked.thread, source_thread_id: threadId }); return;
+      }
+      const resultsMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/results$/);
+      if (resultsMatch) {
+        const db = connectWebProject(reqCtx);
+        let session;
+        try { session = getSession(reqCtx, decodeURIComponent(resultsMatch[1]), db); } finally { db.close(); }
+        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);
+        assertWebWrite(session, input, 'cookie', req);
+        if (session.type === 'native') {
+          await nativeAction(session, 'read');
+          assertWebWrite(session, input, 'cookie', req);
+        }
+        sendJson(res, 200, writeSessionResult(session, input)); return;
+      }
+      const codexMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/codex\/([^/]+)$/);
+      if (codexMatch && ['GET', 'POST'].includes(req.method)) {
+        const id = decodeURIComponent(codexMatch[1]);
+        const action = decodeURIComponent(codexMatch[2]);
+        const db = connectWebProject(reqCtx);
+        let session;
+        try { session = getSession(reqCtx, id, db); } finally { db.close(); }
+        if (!session || session.type !== 'app-server') throw new CliError('NOT_FOUND', 'Codex App Server session not found');
+        if (req.method === 'GET' && action === 'state') {
+          sendJson(res, 200, { state: session.adapter.snapshot() }); return;
+        }
+        if (req.method === 'GET' && action === 'read') {
+          sendJson(res, 200, await codexAction(session, 'read', {})); return;
+        }
+        if (req.method !== 'POST' || !['turn', 'steer', 'interrupt', 'approve'].includes(action)) {
+          throw new CliError('BAD_REQUEST', 'Unsupported Codex action');
+        }
+        const input = await readJsonRequest(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);
+        sendJson(res, 200, await codexAction(session, action, input)); return;
+      }
       const inputMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/input$/);
       if (req.method === 'POST' && inputMatch) {
-        // This HTTP input route is the admin injection path used by the CLI
-        // (hcc inject / ask / broadcast). It is gated by the runtime token
-        // (authOk above) and intentionally does NOT require the per-session
-        // action token — the browser types via the WebSocket input frame
-        // (which DOES require it), and the CLI cannot obtain the action token.
+        // CLI injection remains available without a browser controller. While
+        // Web owns a lease, all injection paths require that controller's epoch.
         const id = decodeURIComponent(inputMatch[1]);
         const lookupDb = connectWebProject(reqCtx);
         let session;
@@ -363,6 +510,8 @@ export function createHttpRoutes(deps) {
           return;
         }
         const input = await readJsonRequest(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 ?? '');
         const data = input.data !== undefined ? String(input.data) : `${text}${input.enter === false ? '' : '\r'}`;
         writeSessionInput(session, data);
@@ -400,7 +549,13 @@ export function createHttpRoutes(deps) {
           sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: 'Session not found' } });
           return;
         }
-        if (session.status === 'running') {
+        assertWebWrite?.(session, stopInput, authMode, req);
+        if (session.type === 'native') {
+          await nativeAction(session, 'close', { ...stopInput,
+            authorizeMutation: () => assertWebWrite(session, stopInput, 'cookie', req) });
+        } else if (session.type === 'app-server') {
+          await stopCodexSession(session);
+        } else if (session.status === 'running') {
           if (session.type === 'external') {
             // Stop the hcc run wrapper first so it can kill the PTY and clean
             // buffer files; fall back to the child pid for older metadata.
@@ -414,6 +569,7 @@ export function createHttpRoutes(deps) {
               if (stopInput.kill_tmux) {
                 killPlan = safeTmuxKillPlan(reqCtx, stopDb, peerId, session.pane || null);
               }
+              if (!stopInput.kill_tmux) writeAdoptionState(stopDb, session, true, now());
             } finally {
               stopDb.close();
             }
@@ -446,6 +602,10 @@ export function createHttpRoutes(deps) {
       if (req.method === 'POST' && detectedMsgMatch) {
         const peerId = decodeURIComponent(detectedMsgMatch[1]);
         const input = await readJsonRequest(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');
+        }
         const body = String(input.body || '');
         const sender = 'web';
         const taskId = input.task ? Number(input.task) : null;
@@ -453,6 +613,8 @@ export function createHttpRoutes(deps) {
         const db = connectWebProject(reqCtx);
         let msgId;
         try {
+          const binding = db.prepare('SELECT transport FROM peer_bindings WHERE peer = ?').get(peerId);
+          if (['native', 'app-server'].includes(binding?.transport)) throw new CliError('STRUCTURED_SESSION_NO_TERMINAL', 'Use the structured worker control endpoint for messages');
           msgId = sendMessage(db, sender, peerId, taskId, 'note', body);
         } finally {
           db.close();
@@ -463,10 +625,19 @@ export function createHttpRoutes(deps) {
       const detectedStopMatch = url.pathname.match(/^\/api\/detected\/([^/]+)\/stop$/);
       if (req.method === 'POST' && detectedStopMatch) {
         const peerId = decodeURIComponent(detectedStopMatch[1]);
+        if (sessionsForProject(reqCtx).some(s => [s.id, s.peerId].includes(peerId))) {
+          throw new CliError('CONTROL_REQUIRED', 'Use the managed session stop endpoint and its control lease');
+        }
         let input = {};
         try { input = await readJsonRequest(req); } catch {}
         const db = connectWebProject(reqCtx);
         try {
+          const binding = db.prepare('SELECT provider, transport FROM peer_bindings WHERE peer = ?').get(peerId);
+          if (binding?.transport === 'native') throw new CliError('NATIVE_MANAGED_SESSION', 'Use the existing native worker control endpoint');
+          if (isDshHookBinding(binding)) {
+            sendJson(res, 409, { ok: false, error: { code: 'DSH_SESSION_CONTROL_UNSUPPORTED', message: 'Control this agent in the dsh Web UI. hello-cc hooks support coordination only.' } });
+            return;
+          }
           const now_ = now();
           let killPlan = null;
           if (input.kill_tmux) {
@@ -495,8 +666,17 @@ export function createHttpRoutes(deps) {
       const detectedRestartMatch = url.pathname.match(/^\/api\/detected\/([^/]+)\/restart$/);
       if (req.method === 'POST' && detectedRestartMatch) {
         const peerId = decodeURIComponent(detectedRestartMatch[1]);
+        if (sessionsForProject(reqCtx).some(s => [s.id, s.peerId].includes(peerId))) {
+          throw new CliError('CONTROL_REQUIRED', 'Open the existing managed session');
+        }
         const db = connectWebProject(reqCtx);
         try {
+          const binding = db.prepare('SELECT provider, transport FROM peer_bindings WHERE peer = ?').get(peerId);
+          if (binding?.transport === 'native') throw new CliError('NATIVE_MANAGED_SESSION', 'Use the existing native worker control endpoint');
+          if (isDshHookBinding(binding)) {
+            sendJson(res, 409, { ok: false, error: { code: 'DSH_SESSION_CONTROL_UNSUPPORTED', message: 'Resume this agent in the dsh Web UI. hello-cc hooks support coordination only.' } });
+            return;
+          }
           // v1-detected-restart: only flip a real detected peer that has a live
           // process or is not explicitly exited. Do not bump last_seen_at
           // (the peer did not actually heartbeat) so the reaper's age filter
@@ -522,12 +702,14 @@ export function createHttpRoutes(deps) {
       }
       sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: 'Route not found' } });
     } catch (err) {
+      if (err instanceof CodexAppServerError) err = new CliError(err.code, err.message);
       const publicFailure = publicCliFailure(err);
       const publicError = publicFailure?.error || err;
       const detail = publicFailure || process.env.HCC_DEBUG
         ? publicError.message
         : 'internal server error';
-      sendJson(res, webErrorStatus(publicError), {
+      const status = publicError.code === 'DSH_SESSION_CONTROL_UNSUPPORTED' ? 409 : webErrorStatus(publicError);
+      sendJson(res, status, {
         ok: false,
         error: {
           code: publicError.code || 'SERVER_ERROR',

package/lib/web/http.mjs

@@ -30,7 +30,7 @@ export async function readJsonRequest(req) {
   }
 }
 
-export function contentSecurityPolicy(nonce) {
+export function contentSecurityPolicy(nonce, { pane = false } = {}) {
   const value = String(nonce || '');
   if (!/^[A-Za-z0-9_-]{16,}$/.test(value)) {
     throw new CliError('BAD_ARGS', 'A valid CSP nonce is required');
@@ -40,7 +40,8 @@ export function contentSecurityPolicy(nonce) {
     "style-src 'self' 'unsafe-inline'; " +
     "img-src 'self' data:; " +
     "connect-src 'self' ws: wss:; " +
-    "object-src 'none'; base-uri 'none'; frame-ancestors 'none'";
+    "object-src 'none'; base-uri 'none'; " +
+    (pane === true ? "frame-ancestors 'self'; frame-src 'none'" : "frame-ancestors 'none'");
 }
 
 export function sendHttp(res, status, contentType, body, options = {}) {
@@ -49,9 +50,9 @@ export function sendHttp(res, status, contentType, body, options = {}) {
     'Cache-Control': 'no-store',
     'Referrer-Policy': 'no-referrer',
     'X-Content-Type-Options': 'nosniff',
-    'X-Frame-Options': 'DENY',
+    'X-Frame-Options': options.pane === true && options.nonce ? 'SAMEORIGIN' : 'DENY',
     'Content-Security-Policy': options.nonce
-      ? contentSecurityPolicy(options.nonce)
+      ? contentSecurityPolicy(options.nonce, options)
       : "frame-ancestors 'none'"
   });
   res.end(body);