farming-code 2.2.28 → 2.2.30

package/backend/runtime-executable-invocation.js

@@ -0,0 +1,20 @@
+function runtimeExecutableInvocation(
+  executablePath,
+  args = [],
+  env = process.env,
+  platform = process.platform,
+) {
+  if (
+    platform === 'linux'
+    && env.FARMING_NODE_LD
+    && env.FARMING_NODE_LIBRARY_PATH
+  ) {
+    return {
+      command: env.FARMING_NODE_LD,
+      args: ['--library-path', env.FARMING_NODE_LIBRARY_PATH, executablePath, ...args],
+    };
+  }
+  return { command: executablePath, args };
+}
+
+module.exports = { runtimeExecutableInvocation };

package/backend/server-process-identity.js

@@ -0,0 +1,47 @@
+const { execFileSync } = require('child_process');
+
+const SERVER_PROCESS_IDENTITY_FORMAT = 'ps-lstart-c-utc-v1';
+
+function readServerProcessIdentity(pid) {
+  const processId = Number(pid);
+  if (!Number.isSafeInteger(processId) || processId <= 0 || process.platform === 'win32') return null;
+  let stdout;
+  try {
+    stdout = execFileSync(
+      '/bin/ps',
+      ['-p', String(processId), '-o', 'pid=', '-o', 'pgid=', '-o', 'lstart='],
+      {
+        encoding: 'utf8',
+        timeout: 1_000,
+        maxBuffer: 16_384,
+        env: { ...process.env, LANG: 'C', LC_ALL: 'C', TZ: 'UTC' },
+      },
+    );
+  } catch (error) {
+    if (error?.status === 1 || error?.code === 'ESRCH') return null;
+    throw error;
+  }
+  const match = String(stdout || '').trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+  if (!match || Number(match[1]) !== processId) return null;
+  return {
+    pid: processId,
+    processGroupId: Number(match[2]),
+    startedAt: match[3].trim(),
+    format: SERVER_PROCESS_IDENTITY_FORMAT,
+  };
+}
+
+function matchingProcessIdentity(expected, current) {
+  return Boolean(
+    current
+    && current.pid === Number(expected?.pid)
+    && current.processGroupId === Number(expected?.processGroupId)
+    && current.startedAt === String(expected?.startedAt || '')
+  );
+}
+
+module.exports = {
+  SERVER_PROCESS_IDENTITY_FORMAT,
+  matchingProcessIdentity,
+  readServerProcessIdentity,
+};

package/backend/server.js

@@ -48,12 +48,10 @@ const {
 } = 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');
@@ -65,11 +63,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,
@@ -89,7 +89,8 @@ const tokenAuth = new TokenAuth({ basePath: BASE_PATH || '/' });
 const authEnabled = tokenAuth.isEnabled();
 const WS_PATH = routePath(BASE_PATH, '/ws');
 const encodeCookieToken = TokenAuth.encodeCookieToken;
-const MAX_CODEX_TRANSCRIPT_TURNS = 1000;
+const DEFAULT_TRANSCRIPT_MAX_TURNS = 240;
+const MAX_TRANSCRIPT_TURNS = 1000;
 const INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS = 3_000;
 const execFileAsync = promisify(execFile);
 
@@ -136,15 +137,18 @@ 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;
 });
-browserResourceManager.init();
 const updateService = new FarmingUpdateService({
   rootDir: path.join(__dirname, '..'),
   configDir: configManager.farmingDir,
   platform: process.platform,
   arch: process.arch,
   packagedRuntime: Boolean(process.pkg || process.env.FARMING_PACKAGED_RUNTIME === '1'),
-  getUpdateUrl: () => configManager.getSettings().updateUrl || '',
 });
 const usageMonitor = new UsageMonitor({
   agentManager,
@@ -255,6 +259,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',
@@ -574,7 +594,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)
@@ -613,6 +636,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 : '';
@@ -815,26 +872,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' });
   }
@@ -845,31 +886,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' });
   }
@@ -1078,51 +1104,10 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/session-view'), async (req, r
   res.json({ session: sessionView });
 });
 
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/codex-transcript'), async (req, res) => {
-  // Legacy JSONL transcript reader. ACP Chat uses the dedicated ACP endpoint;
-  // Terminal Agents stay in their terminal UI.
-  const providerSession = agentManager.getAgentProviderSession(req.params.agentId);
-  if (!providerSession) {
-    res.status(404).json({ error: 'Agent not found' });
-    return;
-  }
-  if (
-    providerSession.provider !== 'codex'
-    || providerSession.temporary
-    || !providerSession.sessionId
-    || providerSession.sessionId.startsWith('tmp_uuid')
-  ) {
-    res.json({
-      transcript: {
-        available: false,
-        reason: 'not-codex-provider-session',
-        sessionId: providerSession.sessionId || '',
-        turns: [],
-      },
-    });
-    return;
-  }
-
-  try {
-    const requestedMaxTurns = Number.parseInt(String(req.query.maxTurns || ''), 10);
-    const maxTurns = Number.isFinite(requestedMaxTurns)
-      ? Math.min(MAX_CODEX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
-      : DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS;
-    const transcript = await readCodexTranscript(providerSession.sessionId, {
-      maxTurns,
-      codexHome: providerSession.providerHomePath || '',
-    });
-    res.json({ transcript });
-  } catch (error) {
-    console.error('Failed to read Codex transcript:', error);
-    res.status(500).json({ error: error.message || 'Failed to read Codex transcript' });
-  }
-});
-
 app.get(routePath(BASE_PATH, '/api/agents/:agentId/json-cli-transcript'), async (req, res) => {
   try {
     const transcript = agentManager.getJsonCliTranscript(req.params.agentId, {
-      maxTurns: DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS,
+      maxTurns: DEFAULT_TRANSCRIPT_MAX_TURNS,
     });
     res.json({ transcript });
   } catch (error) {
@@ -1149,11 +1134,20 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-transcript'), async (req,
   try {
     const requestedMaxTurns = Number.parseInt(String(req.query.maxTurns || ''), 10);
     const maxTurns = Number.isFinite(requestedMaxTurns)
-      ? Math.min(MAX_CODEX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
-      : DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS;
+      ? Math.min(MAX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
+      : DEFAULT_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 }
         : {}),
@@ -1164,6 +1158,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));
@@ -2209,19 +2229,44 @@ app.post(routePath(BASE_PATH, '/api/settings'), express.json(), async (req, res)
   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;
-  if (changesBrowserExtension && browserExtensionEnabled && !browserResourceManager.capability().browser) {
-    res.status(400).json({
-      error: 'Install a Chromium-based browser to use the system Browser in Farming',
-      code: 'BROWSER_EXECUTABLE_NOT_FOUND',
+  const desiredBrowserEnabled = changesBrowserExtension
+    ? browserExtensionEnabled
+    : currentSettings.browserExtensionEnabled === true;
+  if ((changesBrowserExtension && browserExtensionEnabled) || changesBrowserConfiguration) {
+    const desiredSelection = browserResourceManager.browserSelection({
+      ...currentSettings,
+      ...settingsPatch,
     });
-    return;
+    const probe = await browserResourceManager.probeCapability(desiredSelection);
+    if (
+      (changesBrowserConfiguration || desiredBrowserEnabled)
+      && (!probe.runtimeCapability || probe.runtimeCapability.error)
+    ) {
+      res.status(400).json({
+        error: probe.runtimeCapability?.error
+          || 'Install Farming-managed Chromium, choose a system Chromium browser, or configure a loopback external CDP endpoint',
+        code: 'BROWSER_EXECUTABLE_NOT_FOUND',
+      });
+      return;
+    }
   }
   if (
-    changesBrowserExtension
-    && !browserExtensionEnabled
-    && configManager.getSettings().browserExtensionEnabled === true
+    currentSettings.browserExtensionEnabled === true
+    && (
+      (changesBrowserExtension && !browserExtensionEnabled)
+      || changesBrowserConfiguration
+    )
   ) {
     try {
       await browserResourceManager.stopAll();
@@ -2234,6 +2279,9 @@ app.post(routePath(BASE_PATH, '/api/settings'), express.json(), async (req, res)
     }
   }
   configManager.updateSettings(settingsPatch);
+  if (changesBrowserExtension || changesBrowserConfiguration) {
+    await browserResourceManager.refreshCapability();
+  }
   agentSessionsCache.invalidate();
   res.json({
     success: true,
@@ -2857,7 +2905,6 @@ const pendingAgentUpdates = new Map();
 const pendingSessionStreams = new Map();
 let sessionStreamBroadcastTimer = null;
 let lastSessionStreamBroadcastAt = 0;
-let shutdownStarted = false;
 
 function broadcastState() {
   lastStateBroadcastAt = Date.now();
@@ -3072,106 +3119,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 browserResourceManager.dispose();
-    await agentManager.dispose({ preserveTerminalHost });
-  } catch (error) {
-    const teardownFrozen = agentManager.disposing === true;
-    shutdownStarted = false;
-    console.error('Farming shutdown blocked because 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 || '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);
 });
@@ -3221,8 +3168,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();
@@ -3252,13 +3201,6 @@ function startServer() {
     });
   });
 
-  process.on('SIGINT', () => {
-    void shutdownServer({ exit: true });
-  });
-  process.on('SIGTERM', () => {
-    void shutdownServer({ exit: true });
-  });
-
   return server;
 }
 
@@ -3279,6 +3221,5 @@ module.exports = {
   rewriteIndexHtmlForBasePath,
   appendIndexHtmlAssetToken,
   startServer,
-  shutdownServer,
   runTerminalRuntimeStartupCleanup,
 };