farming-code 2.2.27 → 2.2.29

package/backend/server.js

@@ -42,14 +42,17 @@ const { createControlRouter } = require('./control-api');
 const { WorkspaceFileService, WorkspaceFileError } = require('./workspace-file-service');
 const { createWorkspaceFileRouter, resolveWorkspaceRoot } = require('./workspace-file-router');
 const { WorkspaceRootRegistry, rootIdForPath } = require('./workspace-root-registry');
+const {
+  BrowserResourceManager,
+  createBrowserRouter,
+} = require('../extensions/browser/backend');
 const { UsageMonitor } = require('./usage-monitor');
 const { CodexContextWindowReader } = require('./codex-context-window');
 const { DEFAULT_MAX_TURNS: DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS, readCodexTranscript } = require('./codex-transcript');
 const { AsyncCache } = require('./async-cache');
 const { getMainAgentSkillsCatalog } = require('./main-agent-skills');
-const { discoverSlashCommands } = require('./slash-command-discovery');
+const { discoverAgentExtensions, discoverSlashCommands } = require('./slash-command-discovery');
 const { FarmingUpdateService } = require('./update-service');
-const { isRestartBlockingAgent } = require('./agent-activity');
 const { inputPartsFromMessage } = require('./input-parts');
 const { cleanupTerminalRuntime } = require('./terminal-runtime-cleanup');
 const { QrShareTicketStore, SHARE_TICKET_TTL_MS } = require('./qr-share-tickets');
@@ -61,11 +64,13 @@ const { ReviewSessionStore } = require('./review-session-store');
 const { ReviewSessionService } = require('./review-session-service');
 const { createReviewSessionRouter } = require('./review-session-router');
 const {
+  applyIndexHtmlAppearance,
   normalizeBasePath,
   routePath,
   rewriteIndexHtmlForBasePath,
   appendIndexHtmlAssetToken,
 } = require('./index-html');
+const { decodeAcpTranscriptMedia } = require('./acp-transcript');
 const {
   coalesceSessionStream,
   deliverSessionStreamToClients,
@@ -129,6 +134,15 @@ async function requireAgentRecoveryForHttp(res) {
 const themeManager = new ThemeManager({ configDir: configManager.farmingDir });
 const workspaceFileService = new WorkspaceFileService();
 const workspaceRootRegistry = new WorkspaceRootRegistry(agentManager);
+const browserResourceManager = new BrowserResourceManager({
+  configDir: configManager.farmingDir,
+  isEnabled: () => configManager.getSettings().browserExtensionEnabled === true,
+  getBrowserSettings: () => configManager.getSettings(),
+});
+const browserRuntimeRecoveryPromise = browserResourceManager.init().catch(error => {
+  console.warn('Failed to recover Browser runtimes:', error?.message || error);
+  return null;
+});
 const updateService = new FarmingUpdateService({
   rootDir: path.join(__dirname, '..'),
   configDir: configManager.farmingDir,
@@ -246,6 +260,22 @@ function getAvailableAgentsForRequest() {
         supported: true,
         interactive: true,
       },
+      {
+        name: 'opencode',
+        command: 'opencode',
+        description: 'OpenCode - AI coding assistant',
+        category: 'coding',
+        supported: true,
+        interactive: true,
+      },
+      {
+        name: 'qoder',
+        command: 'qodercli',
+        description: 'Qoder - AI coding assistant',
+        category: 'coding',
+        supported: true,
+        interactive: true,
+      },
       {
         name: 'bash',
         command: 'bash',
@@ -527,6 +557,7 @@ app.use(BASE_PATH || '/', express.static(staticAppDir, { index: false }));
 app.use(routePath(BASE_PATH, '/api/files'), createWorkspaceFileRouter(agentManager, workspaceFileService, {
   rootRegistry: workspaceRootRegistry,
 }));
+app.use(routePath(BASE_PATH, '/api/browsers'), createBrowserRouter(browserResourceManager, workspaceRootRegistry));
 
 app.use(routePath(BASE_PATH, '/api/review-sessions'), createReviewSessionRouter(reviewSessionService));
 app.use(routePath(BASE_PATH, '/api/reviews'), createReviewDiffRouter(reviewDiffService, reviewSessionService));
@@ -564,7 +595,10 @@ app.get([
     }
     res.setHeader('Content-Type', 'text/html; charset=utf-8');
     res.setHeader('Cache-Control', 'no-cache');
-    const rewrittenHtml = rewriteIndexHtmlForBasePath(html, BASE_PATH);
+    const rewrittenHtml = applyIndexHtmlAppearance(
+      rewriteIndexHtmlForBasePath(html, BASE_PATH),
+      configManager.getSettings().appearance
+    );
     const requestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
     const requestToken = requestUrl.searchParams.has('token') ? tokenAuth.extractToken(req) : '';
     const htmlWithAssetToken = authEnabled && requestToken && tokenAuth.verify(requestToken)
@@ -603,6 +637,40 @@ app.get(routePath(BASE_PATH, '/api/skills'), (_req, res) => {
   res.json({ skills: getMainAgentSkillsCatalog() });
 });
 
+app.get(routePath(BASE_PATH, '/api/agent-extensions'), (_req, res) => {
+  const agents = getAvailableAgentsForRequest()
+    .filter(agent => agent.category === 'coding')
+    .map(agent => {
+      const provider = String(agent.name || agent.command || '').trim().toLowerCase();
+      const configuredHomes = configManager.getAgentHomes(provider);
+      const homes = configuredHomes.length > 0
+        ? configuredHomes
+        : [{ id: 'default', path: '' }];
+      return {
+        id: provider,
+        name: agent.name,
+        description: agent.description || '',
+        discoverySupported: provider === 'codex' || provider === 'claude',
+        homes: homes.map(home => ({
+          id: home.id,
+          extensions: discoverAgentExtensions({
+            provider,
+            providerHomePath: home.path,
+          }).map(extension => ({
+            id: extension.command,
+            command: extension.command,
+            name: extension.label,
+            description: extension.description,
+            kind: extension.source === 'custom' ? 'command' : extension.source || 'command',
+            scope: extension.scope || '',
+          })),
+        })),
+      };
+    });
+  res.setHeader('Cache-Control', 'no-store');
+  res.json({ agents });
+});
+
 app.get(routePath(BASE_PATH, '/api/slash-commands'), (req, res) => {
   const provider = typeof req.query.provider === 'string' ? req.query.provider : '';
   const workspace = typeof req.query.workspace === 'string' ? req.query.workspace : '';
@@ -805,26 +873,10 @@ app.post(routePath(BASE_PATH, '/api/codex/context-windows'), express.json(), asy
   }
 });
 
-function blockingUpdateAgents() {
-  return agentManager.getState().agents
-    .filter(isRestartBlockingAgent)
-    .map(agent => ({
-      id: agent.id,
-      command: agent.command,
-      task: agent.task || agent.customTitle || agent.sessionTitle || '',
-      cwd: agent.cwd,
-    }));
-}
-
 app.get(routePath(BASE_PATH, '/api/update'), async (req, res) => {
   try {
     const update = await updateService.check({ force: req.query.force === '1' });
-    res.json({
-      update: {
-        ...update,
-        blockingAgents: blockingUpdateAgents(),
-      },
-    });
+    res.json({ update });
   } catch (error) {
     res.status(502).json({ error: error.message || 'Failed to check for updates' });
   }
@@ -835,31 +887,16 @@ app.post(routePath(BASE_PATH, '/api/update/install'), express.json(), async (req
     const state = await updateService.startInstall({
       assetName: req.body && typeof req.body.assetName === 'string' ? req.body.assetName : '',
     });
-    res.status(202).json({
-      update: {
-        state,
-        blockingAgents: blockingUpdateAgents(),
-      },
-    });
+    res.status(202).json({ update: { state } });
   } catch (error) {
     res.status(500).json({ error: error.message || 'Failed to start update' });
   }
 });
 
 app.post(routePath(BASE_PATH, '/api/update/restart'), express.json(), async (req, res) => {
-  const blockers = blockingUpdateAgents();
-  const force = req.body && req.body.force === true;
-  if (blockers.length > 0 && !force) {
-    res.status(409).json({
-      error: 'Cannot restart for update while non-recoverable project agents are running',
-      blockingAgents: blockers,
-    });
-    return;
-  }
-
   try {
     const state = await updateService.applyPreparedUpdate();
-    res.status(202).json({ update: { state, blockingAgents: blockers } });
+    res.status(202).json({ update: { state } });
   } catch (error) {
     res.status(500).json({ error: error.message || 'Failed to restart for update' });
   }
@@ -1142,8 +1179,17 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-transcript'), async (req,
       ? Math.min(MAX_CODEX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
       : DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS;
     const requestedRevision = Number.parseInt(String(req.query.sinceRevision || ''), 10);
+    const externalMedia = req.query.media === 'external-v1';
     res.json({ transcript: agentManager.getAcpTranscript(req.params.agentId, {
       maxTurns,
+      ...(externalMedia
+        ? {
+            mediaPathPrefix: routePath(
+              BASE_PATH,
+              `/api/agents/${encodeURIComponent(req.params.agentId)}/acp-media`
+            ),
+          }
+        : {}),
       ...(Number.isFinite(requestedRevision) && requestedRevision >= 0
         ? { sinceRevision: requestedRevision }
         : {}),
@@ -1154,6 +1200,32 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-transcript'), async (req,
   }
 });
 
+app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-media/:entryId/:mediaId'), (req, res) => {
+  try {
+    const media = agentManager.getAcpTranscriptMedia(
+      req.params.agentId,
+      req.params.entryId,
+      req.params.mediaId
+    );
+    const decoded = decodeAcpTranscriptMedia(media);
+    if (!decoded) {
+      res.status(415).json({ error: 'unsupported ACP transcript media' });
+      return;
+    }
+    res.setHeader('Cache-Control', 'private, max-age=31536000, immutable');
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.type(decoded.mimeType).send(decoded.content);
+  } catch (error) {
+    const message = error && error.message ? error.message : 'Failed to read ACP transcript media';
+    const status = message === 'Agent not found'
+      || message === 'ACP transcript entry not found'
+      || message === 'ACP transcript media not found'
+      ? 404
+      : 409;
+    res.status(status).json({ error: message });
+  }
+});
+
 app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-tool-details/:toolCallId'), async (req, res) => {
   try {
     res.json(agentManager.getAcpToolDetail(req.params.agentId, req.params.toolCallId));
@@ -1554,7 +1626,13 @@ app.post(routePath(BASE_PATH, '/api/agents/:agentId/fork'), express.json(), asyn
     res.status(400).json({ error: 'Unsupported Fork target runtime' });
     return;
   }
+  const requestId = typeof req.body?.requestId === 'string' ? req.body.requestId.trim() : '';
+  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
+    res.status(400).json({ error: 'Fork requires a valid requestId' });
+    return;
+  }
   const result = await agentManager.forkAgent(req.params.agentId, mode, {
+    requestId,
     ...(targetRuntime ? { targetRuntime } : {}),
     ...(Number.isSafeInteger(req.body?.expectedRevision)
       ? { expectedRevision: req.body.expectedRevision }
@@ -1562,7 +1640,7 @@ app.post(routePath(BASE_PATH, '/api/agents/:agentId/fork'), express.json(), asyn
   });
   if (result.error) {
     const status = result.error === 'Agent not found' ? 404 : 400;
-    res.status(status).json({ error: result.error });
+    res.status(status).json(result);
     return;
   }
 
@@ -1571,32 +1649,12 @@ app.post(routePath(BASE_PATH, '/api/agents/:agentId/fork'), express.json(), asyn
     result.projectWorkspaces = membership.projectWorkspaces;
     result.pinnedProjectWorkspaces = membership.pinnedProjectWorkspaces;
   } catch (error) {
-    let rollbackError = '';
-    try {
-      if (mode === 'new-worktree') {
-        const rollback = await agentManager.deleteForkWorktreeProject(result.workspace, { force: true });
-        if (!rollback?.deleted || rollback.cleanupError) {
-          rollbackError = rollback?.error || rollback?.cleanupError || 'Failed to delete the fork worktree';
-        }
-      } else {
-        const rollback = await agentManager.archiveAgent(result.agentId, {
-          reason: 'project-mount-failed',
-          recordHistory: false,
-          requireEngineExit: true,
-          scheduleProviderArchive: false,
-        });
-        if (rollback?.error) rollbackError = rollback.error;
-      }
-    } catch (cleanupError) {
-      rollbackError = cleanupError?.message || String(cleanupError);
-    }
     broadcastState();
     const mountError = error.message || 'Failed to create Project';
     res.status(500).json({
-      error: rollbackError
-        ? `${mountError}. Rollback failed: ${rollbackError}`
-        : mountError,
-      ...(rollbackError ? { rollbackError } : {}),
+      ...result,
+      error: `${mountError}. Retry the same Fork request to reconcile Project membership.`,
+      retryable: true,
     });
     return;
   }
@@ -1676,31 +1734,26 @@ app.patch(routePath(BASE_PATH, '/api/projects/name'), express.json(), (req, res)
 });
 
 app.post(routePath(BASE_PATH, '/api/projects/create-worktree'), express.json(), async (req, res) => {
-  let created = null;
+  const requestId = typeof req.body?.requestId === 'string' ? req.body.requestId.trim() : '';
+  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
+    res.status(400).json({ error: 'Project worktree creation requires a valid requestId' });
+    return;
+  }
   try {
     const root = resolveProjectActionRoot(req.body?.rootId);
-    created = await agentManager.createPermanentWorktree(root.canonicalPath);
-    const membership = configManager.mountProjectWorkspace(created.workspace);
+    const created = await agentManager.createPermanentWorktree(root.canonicalPath, { requestId });
     broadcastState();
     res.status(201).json({
-      workspace: created.workspace,
-      branch: created.branch,
-      projectWorkspaces: membership.projectWorkspaces,
-      pinnedProjectWorkspaces: membership.pinnedProjectWorkspaces,
+      ...created,
     });
   } catch (error) {
-    let rollbackError = '';
-    if (created) {
-      const rollback = await agentManager.rollbackPermanentWorktree(created);
-      if (rollback?.rolledBack === false) rollbackError = rollback.error || 'Unknown rollback failure';
-    }
     const status = error instanceof WorkspaceFileError ? error.statusCode : 400;
-    const createError = error.message || 'Failed to create permanent worktree';
+    const operation = configManager.getProjectOperation?.(requestId);
     res.status(status).json({
-      error: rollbackError
-        ? `${createError}. Rollback failed: ${rollbackError}`
-        : createError,
-      ...(rollbackError ? { rollbackError } : {}),
+      error: error.message || 'Failed to create permanent worktree',
+      requestId,
+      ...(operation?.state === 'pending' ? { retryable: true } : {}),
+      ...(['unknown', 'blocked'].includes(operation?.state) ? { uncertain: true } : {}),
     });
   }
 });
@@ -1709,45 +1762,26 @@ app.post(routePath(BASE_PATH, '/api/projects/delete-worktree'), express.json(),
   if (!await requireAgentRecoveryForHttp(res)) return;
   const body = req.body || {};
   const workspace = typeof body.workspace === 'string' ? body.workspace : '';
-  const inspected = await agentManager.inspectForkWorktreeProject(workspace);
-  if (inspected.error || (inspected.requiresForce && body.force !== true)) {
-    if (inspected.requiresForce) {
-      res.status(409).json({
-        ...inspected,
-        error: 'Worktree has uncommitted or untracked files',
-      });
-      return;
-    }
-    const status = inspected.error === 'Workspace not found' || inspected.error === 'Workspace is required' ? 404 : 400;
-    res.status(status).json(inspected);
+  const requestId = typeof body.requestId === 'string' ? body.requestId.trim() : '';
+  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
+    res.status(400).json({ error: 'Project worktree deletion requires a valid requestId' });
     return;
   }
 
-  const result = await agentManager.deleteForkWorktreeProject(inspected.workspace, { force: body.force === true });
+  const result = await agentManager.deleteForkWorktreeProject(workspace, {
+    force: body.force === true,
+    requestId,
+  });
   if (result.error) {
     broadcastState();
-    const status = result.requiresForce ? 409 : 400;
+    const status = result.requiresForce
+      ? 409
+      : (result.error === 'Workspace not found' || result.error === 'Workspace is required' ? 404 : 400);
     res.status(status).json(result);
     return;
   }
-
-  let membership;
-  try {
-    membership = configManager.removeProjectWorkspace(inspected.workspace);
-  } catch (error) {
-    broadcastState();
-    res.status(500).json({
-      ...result,
-      error: `Worktree was deleted, but Project membership cleanup failed: ${error.message || error}`,
-    });
-    return;
-  }
   broadcastState();
-  res.json({
-    ...result,
-    projectWorkspaces: membership.projectWorkspaces,
-    pinnedProjectWorkspaces: membership.pinnedProjectWorkspaces,
-  });
+  res.json(result);
 });
 
 app.post(routePath(BASE_PATH, '/api/codex/sessions/:sessionId/resume'), express.json(), async (req, res) => {
@@ -2232,12 +2266,64 @@ async function autoResumeMainPageAgentSessions() {
   }
 }
 
-app.post(routePath(BASE_PATH, '/api/settings'), express.json(), (req, res) => {
+app.post(routePath(BASE_PATH, '/api/settings'), express.json(), async (req, res) => {
   const settingsPatch = { ...(req.body || {}) };
   delete settingsPatch.mainPageSessionKeys;
   delete settingsPatch.projectWorkspaces;
   delete settingsPatch.pinnedProjectWorkspaces;
+  const browserConfigurationKeys = [
+    'browserSource',
+    'browserExecutablePath',
+    'browserExternalCdpUrl',
+  ];
+  const changesBrowserExtension = Object.prototype.hasOwnProperty.call(settingsPatch, 'browserExtensionEnabled');
+  const changesBrowserConfiguration = browserConfigurationKeys.some(key =>
+    Object.prototype.hasOwnProperty.call(settingsPatch, key)
+  );
+  const currentSettings = configManager.getSettings();
+  const browserExtensionEnabled = settingsPatch.browserExtensionEnabled === true;
+  const desiredBrowserEnabled = changesBrowserExtension
+    ? browserExtensionEnabled
+    : currentSettings.browserExtensionEnabled === true;
+  if ((changesBrowserExtension && browserExtensionEnabled) || changesBrowserConfiguration) {
+    const desiredSelection = browserResourceManager.browserSelection({
+      ...currentSettings,
+      ...settingsPatch,
+    });
+    const probe = await browserResourceManager.probeCapability(desiredSelection);
+    if (
+      (changesBrowserConfiguration || desiredBrowserEnabled)
+      && (!probe.runtimeCapability || probe.runtimeCapability.error)
+    ) {
+      res.status(400).json({
+        error: probe.runtimeCapability?.error
+          || 'Install a Chromium-based browser or configure a loopback external CDP endpoint',
+        code: 'BROWSER_EXECUTABLE_NOT_FOUND',
+      });
+      return;
+    }
+  }
+  if (
+    currentSettings.browserExtensionEnabled === true
+    && (
+      (changesBrowserExtension && !browserExtensionEnabled)
+      || changesBrowserConfiguration
+    )
+  ) {
+    try {
+      await browserResourceManager.stopAll();
+    } catch (error) {
+      res.status(Number(error?.status) || 500).json({
+        error: error?.message || 'Browser extension could not be disabled',
+        code: error?.code || 'BROWSER_DISABLE_FAILED',
+      });
+      return;
+    }
+  }
   configManager.updateSettings(settingsPatch);
+  if (changesBrowserExtension || changesBrowserConfiguration) {
+    await browserResourceManager.refreshCapability();
+  }
   agentSessionsCache.invalidate();
   res.json({
     success: true,
@@ -2299,6 +2385,20 @@ app.get(routePath(BASE_PATH, '/api/themes/:themeId'), (req, res) => {
 
 wss.on('connection', (ws, req) => {
   const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+  const viewerPrefix = routePath(BASE_PATH, '/api/browsers/');
+  if (url.pathname.startsWith(viewerPrefix) && url.pathname.endsWith('/viewer')) {
+    if (authEnabled && !tokenAuth.verifyWebSocket(req)) {
+      ws.close(4001, 'Authentication required');
+      return;
+    }
+    const encodedId = url.pathname.slice(viewerPrefix.length, -'/viewer'.length);
+    try {
+      browserResourceManager.attachViewer(decodeURIComponent(encodedId), ws);
+    } catch (error) {
+      ws.close(4004, error?.message || 'Browser resource not found');
+    }
+    return;
+  }
   if (url.pathname !== WS_PATH) {
     ws.close(1008, 'Invalid path');
     return;
@@ -2442,9 +2542,9 @@ async function sendInputMessage(ws, data) {
 
 async function sendComposerInputMessage(ws, data) {
   const targetAgentId = resolveInputTargetAgentId(ws, data);
-  const requestId = typeof data.requestId === 'string' ? data.requestId : '';
+  const requestId = typeof data.requestId === 'string' ? data.requestId.trim() : '';
   const responseAgentId = targetAgentId || (typeof data.agentId === 'string' ? data.agentId : '');
-  const respond = (accepted, message = '') => {
+  const respond = (accepted, message = '', uncertain = false) => {
     if (!requestId || !responseAgentId) return;
     ws.send(JSON.stringify({
       type: 'composer-input-result',
@@ -2452,9 +2552,22 @@ async function sendComposerInputMessage(ws, data) {
       agentId: responseAgentId,
       accepted,
       ...(message ? { message } : {}),
+      ...(uncertain ? { uncertain: true } : {}),
     }));
   };
   const message = typeof data.message === 'string' ? data.message : '';
+  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
+    if (responseAgentId) {
+      ws.send(JSON.stringify({
+        type: 'composer-input-result',
+        requestId: requestId || 'invalid-request',
+        agentId: responseAgentId,
+        accepted: false,
+        message: 'Structured Composer input requires a valid requestId',
+      }));
+    }
+    return;
+  }
   const content = [];
   if (message.trim()) content.push({ type: 'text', text: message });
   const attachmentsRoot = path.resolve(imageAttachmentsDir());
@@ -2496,11 +2609,11 @@ async function sendComposerInputMessage(ws, data) {
     return;
   }
   try {
-    await agentManager.sendComposerMessage(targetAgentId, content);
+    await agentManager.sendComposerMessage(targetAgentId, content, { requestId });
     respond(true);
   } catch (error) {
     const message = error && error.message ? error.message : 'Failed to send Composer message';
-    if (requestId) respond(false, message);
+    if (requestId) respond(false, message, error?.uncertain === true);
     else ws.send(JSON.stringify({ type: 'error', message }));
   }
 }
@@ -2834,7 +2947,6 @@ const pendingAgentUpdates = new Map();
 const pendingSessionStreams = new Map();
 let sessionStreamBroadcastTimer = null;
 let lastSessionStreamBroadcastAt = 0;
-let shutdownStarted = false;
 
 function broadcastState() {
   lastStateBroadcastAt = Date.now();
@@ -3049,105 +3161,6 @@ function scheduleSessionStreamBroadcast(stream) {
   }
 }
 
-function clearBroadcastTimers() {
-  if (stateBroadcastTimer) {
-    clearTimeout(stateBroadcastTimer);
-    stateBroadcastTimer = null;
-  }
-  for (const entry of pendingPreviewBroadcasts.values()) {
-    if (entry && entry.timer) {
-      clearTimeout(entry.timer);
-    }
-  }
-  pendingPreviewBroadcasts.clear();
-  for (const entry of pendingAgentActivityBroadcasts.values()) {
-    if (entry && entry.timer) clearTimeout(entry.timer);
-  }
-  pendingAgentActivityBroadcasts.clear();
-  for (const entry of pendingAgentUpdates.values()) {
-    if (entry && entry.timer) clearTimeout(entry.timer);
-  }
-  pendingAgentUpdates.clear();
-  if (sessionStreamBroadcastTimer) {
-    clearTimeout(sessionStreamBroadcastTimer);
-    sessionStreamBroadcastTimer = null;
-  }
-  pendingSessionStreams.clear();
-}
-
-function closeHttpServer() {
-  return new Promise(resolve => {
-    if (!server.listening) {
-      resolve();
-      return;
-    }
-    server.close(error => {
-      if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') {
-        console.warn('Failed to close HTTP server:', error.message || error);
-      }
-      resolve();
-    });
-  });
-}
-
-function closeWebSocketServer() {
-  for (const client of wss.clients) {
-    clearWorkspaceFileWatch(client);
-    try {
-      client.close(1001, 'Farming server shutting down');
-    } catch {
-      // ignore shutdown races
-    }
-  }
-  return new Promise(resolve => {
-    wss.close(() => resolve());
-    setTimeout(resolve, 250).unref?.();
-  });
-}
-
-async function shutdownServer(options = {}) {
-  if (shutdownStarted) return;
-  shutdownStarted = true;
-  const preserveTerminalHost = options.preserveTerminalHost !== undefined
-    ? options.preserveTerminalHost === true
-    : process.env.FARMING_NATIVE_PTY_HOST_PERSIST !== '0';
-
-  try {
-    await agentManager.dispose({ preserveTerminalHost });
-  } catch (error) {
-    const teardownFrozen = agentManager.disposing === true;
-    shutdownStarted = false;
-    console.error('Farming shutdown blocked because Agent runtime cleanup could not be verified:', error);
-    if (teardownFrozen) {
-      clearBroadcastTimers();
-      tokenAuth.cleanup();
-      await Promise.allSettled([
-        closeWebSocketServer(),
-        workspaceFileService.dispose(),
-        closeHttpServer(),
-      ]);
-    }
-    if (options.exit === true) process.exitCode = 1;
-    return {
-      error: error?.message || 'Agent runtime cleanup could not be verified',
-      ...(teardownFrozen ? { frozen: true } : {}),
-    };
-  }
-
-  clearBroadcastTimers();
-  tokenAuth.cleanup();
-  await Promise.allSettled([
-    closeWebSocketServer(),
-    workspaceFileService.dispose(),
-    closeHttpServer(),
-  ]);
-
-  if (options.exit === true) {
-    process.exit(options.exitCode || 0);
-  }
-  return { stopped: true };
-}
-
 agentManager.onSessionStream((stream) => {
   scheduleSessionStreamBroadcast(stream);
 });
@@ -3197,8 +3210,10 @@ function startServer() {
   if (serverStarted) return server;
   serverStarted = true;
 
-  void runTerminalRuntimeStartupCleanup().finally(() => {
-    if (shutdownStarted) return;
+  void Promise.all([
+    runTerminalRuntimeStartupCleanup(),
+    browserRuntimeRecoveryPromise,
+  ]).finally(() => {
     server.listen(PORT, () => {
       const token = tokenAuth.getToken();
       const localIPs = getLocalIPs();
@@ -3228,13 +3243,6 @@ function startServer() {
     });
   });
 
-  process.on('SIGINT', () => {
-    void shutdownServer({ exit: true });
-  });
-  process.on('SIGTERM', () => {
-    void shutdownServer({ exit: true });
-  });
-
   return server;
 }
 
@@ -3247,6 +3255,7 @@ module.exports = {
   server,
   wss,
   agentManager,
+  browserResourceManager,
   workspaceFileService,
   handleMessage,
   resolveCliBinDir,
@@ -3254,6 +3263,5 @@ module.exports = {
   rewriteIndexHtmlForBasePath,
   appendIndexHtmlAssetToken,
   startServer,
-  shutdownServer,
   runTerminalRuntimeStartupCleanup,
 };