farming-code 2.2.17 → 2.2.19

package/backend/agent-manager.js

@@ -79,6 +79,9 @@ const AGENT_DISCOVERY_CACHE_MAX_AGE_MS = 3_000;
 const UNCERTAIN_TERMINAL_STOP_TIMEOUT_MS = 5_000;
 const TERMINAL_STOP_STATE_READ_TIMEOUT_MS = 1_000;
 const TERMINAL_STOP_POLL_MS = 50;
+const CODEX_TERMINAL_START_READY_TIMEOUT_MS = 30_000;
+const CODEX_TERMINAL_START_READY_POLL_MS = 50;
+const CODEX_TERMINAL_START_OUTPUT_LIMIT = 64 * 1024;
 const SHELL_PROMPT_ENV_KEYS = [
   'PS1',
   'PS2',
@@ -100,6 +103,15 @@ function withBoundedWait(promise, timeoutMs, label) {
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
+function canonicalProviderHomePath(value) {
+  const resolved = path.resolve(String(value || '').trim() || '.');
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
 async function deletePrecreatedProviderSession(options = {}) {
   const provider = String(options.provider || '').trim().toLowerCase();
   const sessionId = String(options.sessionId || '').trim();
@@ -591,6 +603,8 @@ class AgentManager extends EventEmitter {
     this.resizeDrains = new Map();
     this.inputQueues = new Map();
     this.codexTerminalProfileQueues = new Map();
+    this.codexTerminalStartQueues = new Map();
+    this.codexTerminalStartOutput = new Map();
     this.agentWorktreeResolveGeneration = new Map();
     this.permissionRestartInFlight = new Map();
     this.runtimeRestartInFlight = new Map();
@@ -757,6 +771,13 @@ class AgentManager extends EventEmitter {
 
         this.reviveAgentRuntime(agent);
         agent.output = trimSessionOutput(agent.output + data);
+        if (this.codexTerminalStartOutput.has(sessionId)) {
+          const startupOutput = `${this.codexTerminalStartOutput.get(sessionId) || ''}${data}`;
+          this.codexTerminalStartOutput.set(
+            sessionId,
+            startupOutput.slice(-CODEX_TERMINAL_START_OUTPUT_LIMIT),
+          );
+        }
         if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
           void this.providerSessionService.resolveTemporaryCodex(sessionId);
         }
@@ -1393,6 +1414,16 @@ class AgentManager extends EventEmitter {
         projectOrder: finiteOrder(record.projectOrder),
         pinnedOrder: finiteOrder(record.pinnedOrder),
         customTitle: record.customTitle || '',
+        pinned: record.pinned === true,
+        attentionSeq: finiteNonNegativeInteger(record.attentionSeq),
+        readAttentionSeq: finiteNonNegativeInteger(record.readAttentionSeq),
+        attentionUpdatedAt: finiteNumberOrNull(record.attentionUpdatedAt),
+        readAttentionAt: finiteNumberOrNull(record.readAttentionAt),
+        attentionReason: record.attentionReason || '',
+        attentionOutputEpoch: record.attentionOutputEpoch || '',
+        attentionOutputSeq: finiteNumberOrNull(record.attentionOutputSeq),
+        readOutputEpoch: record.readOutputEpoch || '',
+        readOutputSeq: finiteNumberOrNull(record.readOutputSeq),
         persistentSessionId: record.id || '',
         runtimeAgentId: record.runtimeAgentId || '',
         reviveTerminalState: record.serializedState || null,
@@ -1440,7 +1471,10 @@ class AgentManager extends EventEmitter {
       replacement.attentionUpdatedAt = finiteNumberOrNull(record.attentionUpdatedAt);
       replacement.readAttentionAt = finiteNumberOrNull(record.readAttentionAt);
       replacement.attentionReason = record.attentionReason || '';
+      replacement.attentionOutputEpoch = record.attentionOutputEpoch || '';
       replacement.attentionOutputSeq = finiteNumberOrNull(record.attentionOutputSeq);
+      replacement.readOutputEpoch = record.readOutputEpoch || '';
+      replacement.readOutputSeq = finiteNumberOrNull(record.readOutputSeq);
       replacement.unread = agentAttentionUnread(replacement);
       this.ensurePersistentAgentSession(replacement);
       if (sessionKey) liveProviderSessions.add(sessionKey);
@@ -1716,6 +1750,7 @@ class AgentManager extends EventEmitter {
     if (!agent || !this.configManager || typeof this.configManager.ensureAgentSessionRecord !== 'function') {
       return '';
     }
+    const previousPersistentSessionId = agent.persistentSessionId || '';
     const sessionOptions = agent.providerSessionKey
       ? this.acpSessionOptionsByKey.get(agent.providerSessionKey)
       : null;
@@ -1726,9 +1761,39 @@ class AgentManager extends EventEmitter {
       } : {}),
       ...patch,
     });
-    if (persistentSessionId && !agent.persistentSessionId) {
+    if (persistentSessionId) {
       agent.persistentSessionId = persistentSessionId;
     }
+    if (
+      persistentSessionId
+      && previousPersistentSessionId
+      && persistentSessionId !== previousPersistentSessionId
+      && agent.providerSessionKey
+      && typeof this.configManager.getAgentSessionRecordForProviderSessionKey === 'function'
+    ) {
+      const record = this.configManager.getAgentSessionRecordForProviderSessionKey(agent.providerSessionKey);
+      if (record) {
+        agent.projectWorkspace = record.projectWorkspace || agent.projectWorkspace || '';
+        agent.task = typeof record.task === 'string' ? record.task : (agent.task || '');
+        agent.workflowTemplate = typeof record.workflowTemplate === 'string'
+          ? record.workflowTemplate
+          : (agent.workflowTemplate || '');
+        agent.customTitle = typeof record.customTitle === 'string' ? record.customTitle : '';
+        agent.pinned = record.pinned === true;
+        agent.projectOrder = finiteOrder(record.projectOrder);
+        agent.pinnedOrder = finiteOrder(record.pinnedOrder);
+        agent.attentionSeq = finiteNonNegativeInteger(record.attentionSeq);
+        agent.readAttentionSeq = finiteNonNegativeInteger(record.readAttentionSeq);
+        agent.attentionUpdatedAt = finiteNumberOrNull(record.attentionUpdatedAt);
+        agent.readAttentionAt = finiteNumberOrNull(record.readAttentionAt);
+        agent.attentionReason = record.attentionReason || '';
+        agent.attentionOutputEpoch = record.attentionOutputEpoch || '';
+        agent.attentionOutputSeq = finiteNumberOrNull(record.attentionOutputSeq);
+        agent.readOutputEpoch = record.readOutputEpoch || '';
+        agent.readOutputSeq = finiteNumberOrNull(record.readOutputSeq);
+        agent.unread = agentAttentionUnread(agent);
+      }
+    }
     return persistentSessionId;
   }
 
@@ -2264,6 +2329,8 @@ class AgentManager extends EventEmitter {
     this.resizeDrains.clear();
     this.inputQueues.clear();
     this.codexTerminalProfileQueues.clear();
+    this.codexTerminalStartQueues.clear();
+    this.codexTerminalStartOutput.clear();
     this.acpSessionOptionsByKey.clear();
     if (this.jsonCliRuntime) {
       for (const agentId of this.agents.keys()) this.jsonCliRuntime.unregisterAgent(agentId);
@@ -2373,6 +2440,37 @@ class AgentManager extends EventEmitter {
     throw new Error(`Terminal ${agentId} did not reach an exited state after kill`);
   }
 
+  async waitForCodexTerminalStart(agentId) {
+    const deadline = Date.now() + CODEX_TERMINAL_START_READY_TIMEOUT_MS;
+    while (Date.now() <= deadline) {
+      const agent = this.agents.get(agentId);
+      if (!agent) throw new Error(`Codex Terminal ${agentId} disappeared during startup`);
+      if (['dead', 'stopped'].includes(agent.status) || agent.engineStatus === 'exited') {
+        const detail = trimSessionOutput(agent.previewText || agent.output || '').trim();
+        throw new Error(detail || `Codex Terminal ${agentId} exited during startup`);
+      }
+      if ((this.codexTerminalStartOutput.get(agentId) || '').includes('\u001b')) {
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, CODEX_TERMINAL_START_READY_POLL_MS));
+    }
+    throw new Error(`Codex Terminal ${agentId} did not become ready within ${CODEX_TERMINAL_START_READY_TIMEOUT_MS}ms`);
+  }
+
+  async enqueueCodexTerminalStart(providerHomeKey, operation) {
+    const key = canonicalProviderHomePath(providerHomeKey || '.');
+    const previous = this.codexTerminalStartQueues.get(key) || Promise.resolve();
+    const next = previous.catch(() => {}).then(operation);
+    this.codexTerminalStartQueues.set(key, next);
+    try {
+      return await next;
+    } finally {
+      if (this.codexTerminalStartQueues.get(key) === next) {
+        this.codexTerminalStartQueues.delete(key);
+      }
+    }
+  }
+
   async startAgent(command, customWorkspace, callback, options = {}) {
     if (options.wantsMain !== false && options.skipRecoveryWait !== true) {
       await this.whenRecovered();
@@ -2774,19 +2872,19 @@ class AgentManager extends EventEmitter {
       shellLastCommandStartedAt: null,
       shellLastCommandFinishedAt: null,
       shellLastCommandDurationMs: null,
-      pinned: false,
+      pinned: options.pinned === true,
       projectOrder: finiteOrder(options.projectOrder),
       pinnedOrder: finiteOrder(options.pinnedOrder),
-      attentionSeq: 0,
-      readAttentionSeq: 0,
-      attentionUpdatedAt: null,
-      readAttentionAt: null,
-      attentionReason: '',
-      attentionOutputEpoch: '',
-      attentionOutputSeq: null,
-      readOutputEpoch: '',
-      readOutputSeq: null,
-      unread: false,
+      attentionSeq: finiteNonNegativeInteger(options.attentionSeq),
+      readAttentionSeq: finiteNonNegativeInteger(options.readAttentionSeq),
+      attentionUpdatedAt: finiteNumberOrNull(options.attentionUpdatedAt),
+      readAttentionAt: finiteNumberOrNull(options.readAttentionAt),
+      attentionReason: typeof options.attentionReason === 'string' ? options.attentionReason : '',
+      attentionOutputEpoch: typeof options.attentionOutputEpoch === 'string' ? options.attentionOutputEpoch : '',
+      attentionOutputSeq: finiteNumberOrNull(options.attentionOutputSeq),
+      readOutputEpoch: typeof options.readOutputEpoch === 'string' ? options.readOutputEpoch : '',
+      readOutputSeq: finiteNumberOrNull(options.readOutputSeq),
+      unread: finiteNonNegativeInteger(options.attentionSeq) > finiteNonNegativeInteger(options.readAttentionSeq),
       archived: false,
       archivedAt: null,
       canForkNewWorktree: this.canCreateForkWorktree(projectWorkspace || workspace),
@@ -3016,18 +3114,41 @@ class AgentManager extends EventEmitter {
       }
 
       if (!useJsonCli && !useAcp) {
-        const engineLaunch = {
-          command: spawnProgram,
-          args,
-          cwd: workspace,
-          category: resolution.spec ? resolution.spec.category : 'shell',
-          reviveState: options.reviveTerminalState || null,
+        const serializeCodexStartup = agentRecord.providerSessionProvider === 'codex'
+          && resolution.engineName === 'native';
+        const startTerminal = async () => {
+          const engineLaunch = {
+            command: spawnProgram,
+            args,
+            cwd: workspace,
+            category: resolution.spec ? resolution.spec.category : 'shell',
+            reviveState: options.reviveTerminalState || null,
+          };
+          if (serializeCodexStartup) this.codexTerminalStartOutput.set(agentId, '');
+          try {
+            await this.createAgentEngineSession(agentRecord, resolution.engine, engineLaunch);
+            if (serializeCodexStartup) {
+              await this.waitForCodexTerminalStart(agentId);
+            }
+          } finally {
+            if (serializeCodexStartup) this.codexTerminalStartOutput.delete(agentId);
+          }
         };
-        await this.createAgentEngineSession(agentRecord, resolution.engine, engineLaunch);
+        if (serializeCodexStartup) {
+          await this.enqueueCodexTerminalStart(
+            providerHomePath || resolvedProviderHomeId || 'default',
+            startTerminal
+          );
+        } else {
+          await startTerminal();
+        }
       }
       agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord, {
         visibleOnMainPage: true,
         archived: false,
+        ...(options.customTitleExplicit === true
+          ? { customTitle: agentRecord.customTitle }
+          : {}),
       });
 
       const agent = this.agents.get(agentId);
@@ -3643,7 +3764,7 @@ class AgentManager extends EventEmitter {
 
     const customTitle = String(title || '').trim().slice(0, 80);
     agent.customTitle = customTitle;
-    this.ensurePersistentAgentSession(agent);
+    this.ensurePersistentAgentSession(agent, { customTitle });
     this.updateEngineProviderSessionMetadata(agent);
     this.emit('update');
     return { agentId, customTitle };
@@ -4305,24 +4426,33 @@ class AgentManager extends EventEmitter {
   }
 
   async rollbackPermanentWorktree(created) {
-    if (!created?.workspace || !created?.sourceWorkspace) return;
+    if (!created?.workspace || !created?.sourceWorkspace) {
+      return { rolledBack: true };
+    }
+    const errors = [];
     try {
       await execFileAsync('git', ['-C', created.sourceWorkspace, 'worktree', 'remove', '--force', created.workspace], {
         timeout: 60000,
         maxBuffer: 1024 * 1024 * 4,
       });
-    } catch {
-      // Rollback is best-effort so the original create/persist failure remains visible.
+    } catch (error) {
+      const message = error && error.stderr ? String(error.stderr).trim() : '';
+      errors.push(message || 'Failed to remove the created worktree');
     }
-    if (!created.branch) return;
-    try {
-      await execFileAsync('git', ['-C', created.sourceWorkspace, 'branch', '-D', created.branch], {
-        timeout: 30000,
-        maxBuffer: 1024 * 1024 * 4,
-      });
-    } catch {
-      // The worktree removal may already have pruned the newly created branch.
+    if (created.branch) {
+      try {
+        await execFileAsync('git', ['-C', created.sourceWorkspace, 'branch', '-D', created.branch], {
+          timeout: 30000,
+          maxBuffer: 1024 * 1024 * 4,
+        });
+      } catch (error) {
+        const message = error && error.stderr ? String(error.stderr).trim() : '';
+        errors.push(message || 'Failed to delete the created worktree branch');
+      }
     }
+    return errors.length > 0
+      ? { rolledBack: false, error: errors.join('; ') }
+      : { rolledBack: true };
   }
 
   async inspectForkWorktreeProject(workspace) {
@@ -4424,13 +4554,6 @@ class AgentManager extends EventEmitter {
     }
 
     const projectAgents = this.agentsForProjectWorkspace(inspected.workspace);
-    const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents(projectAgents);
-    const archivedAgentIds = [];
-    for (const agent of projectAgents) {
-      const result = await this.archiveAgent(agent.id);
-      if (result && !result.error) archivedAgentIds.push(agent.id);
-    }
-
     const args = ['-C', inspected.workspace, 'worktree', 'remove'];
     if (options.force === true) args.push('--force');
     args.push(inspected.workspace);
@@ -4444,18 +4567,31 @@ class AgentManager extends EventEmitter {
       const message = error && error.stderr ? String(error.stderr).trim() : '';
       return {
         ...inspected,
-        archivedAgentIds,
-        removedMainPageSessionKeys,
         error: message || 'Failed to delete git worktree',
       };
     }
 
+    const archivedAgentIds = [];
+    const removedMainPageSessionKeys = [];
+    const cleanupErrors = [];
+    for (const agent of projectAgents) {
+      const result = await this.archiveAgent(agent.id, { requireEngineExit: true });
+      if (result && !result.error) {
+        archivedAgentIds.push(agent.id);
+        removedMainPageSessionKeys.push(...(result.removedMainPageSessionKeys || []));
+      } else {
+        cleanupErrors.push(`${agent.id}: ${result?.error || 'Failed to archive Agent'}`);
+      }
+    }
     return {
       workspace: inspected.workspace,
       deleted: true,
       forced: options.force === true,
       archivedAgentIds,
-      removedMainPageSessionKeys,
+      removedMainPageSessionKeys: Array.from(new Set(removedMainPageSessionKeys)),
+      ...(cleanupErrors.length > 0 ? {
+        cleanupError: cleanupErrors.join('; '),
+      } : {}),
     };
   }
 
@@ -4612,7 +4748,7 @@ class AgentManager extends EventEmitter {
     }
   }
 
-  async archiveAgent(agentId) {
+  async archiveAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) {
       return { error: 'Agent not found' };
@@ -4621,13 +4757,26 @@ class AgentManager extends EventEmitter {
       return { error: 'Main Agent cannot be archived' };
     }
 
+    if (options.requireEngineExit !== true) {
+      const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents([agent]);
+      this.ensurePersistentAgentSession(agent, { visibleOnMainPage: false });
+      await this.killAgent(agentId, {
+        reason: options.reason || 'manual-archive',
+        recordHistory: options.recordHistory !== false && !isEphemeralShellAgent(agent),
+      });
+      if (options.scheduleProviderArchive !== false) this.scheduleCodexSessionArchive(agent);
+      return { agentId, archived: true, removed: true, removedMainPageSessionKeys };
+    }
+
+    const killResult = await this.killAgent(agentId, {
+      reason: options.reason || 'manual-archive',
+      recordHistory: options.recordHistory !== false && !isEphemeralShellAgent(agent),
+      requireEngineExit: true,
+    });
+    if (killResult?.error) return killResult;
     const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents([agent]);
     this.ensurePersistentAgentSession(agent, { visibleOnMainPage: false });
-    await this.killAgent(agentId, {
-      reason: 'manual-archive',
-      recordHistory: !isEphemeralShellAgent(agent),
-    });
-    this.scheduleCodexSessionArchive(agent);
+    if (options.scheduleProviderArchive !== false) this.scheduleCodexSessionArchive(agent);
     return { agentId, archived: true, removed: true, removedMainPageSessionKeys };
   }
 
@@ -4662,15 +4811,42 @@ class AgentManager extends EventEmitter {
   
   async killAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
-    if (!agent) return;
+    if (!agent) return { agentId, killed: true, missing: true };
 
+    const engine = this.engineBridge.getEngine(agent.engineName);
+    if (options.requireEngineExit === true && !engine) {
+      return { agentId, error: 'Agent runtime is unavailable; process exit cannot be verified' };
+    }
     try {
-      const engine = this.engineBridge.getEngine(agent.engineName);
       if (engine) {
         await engine.killSession(agentId);
       }
     } catch (error) {
       console.error('Failed to kill agent:', error);
+      if (options.requireEngineExit === true) {
+        return { agentId, error: error.message || 'Failed to stop Agent runtime' };
+      }
+    }
+
+    if (options.requireEngineExit === true && engine) {
+      const deadline = Date.now() + 3000;
+      let lastState = null;
+      while (Date.now() < deadline) {
+        try {
+          lastState = await engine.getSessionState(agentId);
+        } catch (error) {
+          if (isSessionNotAvailableError(error)) {
+            lastState = null;
+            break;
+          }
+          return { agentId, error: error.message || 'Failed to verify Agent process exit' };
+        }
+        if (!isLiveEngineSessionState(lastState)) break;
+        await new Promise(resolve => setTimeout(resolve, 50));
+      }
+      if (isLiveEngineSessionState(lastState)) {
+        return { agentId, error: 'Agent process did not exit within 3 seconds' };
+      }
     }
 
     if (options.recordHistory !== false && !isEphemeralShellAgent(agent)) {
@@ -4697,6 +4873,7 @@ class AgentManager extends EventEmitter {
     if (options.emitUpdate !== false) {
       this.emit('update');
     }
+    return { agentId, killed: true };
   }
 
   async getAgentSessionText(agentId) {

package/backend/bundle-update-helper.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+function writeJsonAtomic(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.tmp`;
+  fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporaryPath, filePath);
+}
+
+function appendLog(logPath, message) {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, `[${new Date().toISOString()}] ${message}\n`);
+}
+
+function validatePayload(payload) {
+  if (!payload || typeof payload !== 'object') throw new Error('Missing bundle update payload');
+  for (const key of ['stateFile', 'logPath', 'releaseDir', 'installer']) {
+    if (!path.isAbsolute(String(payload[key] || ''))) throw new Error(`Invalid bundle update ${key}`);
+  }
+  if (!/^[0-9A-Za-z.+-]+$/.test(String(payload.version || ''))) {
+    throw new Error('Invalid bundle update version');
+  }
+  return payload;
+}
+
+function stateFor(payload, phase, extra = {}) {
+  return {
+    method: payload.method,
+    targetMethod: payload.targetMethod,
+    phase,
+    version: payload.version,
+    previousVersion: payload.previousVersion,
+    startedAt: payload.startedAt,
+    logPath: payload.logPath,
+    ...extra,
+  };
+}
+
+function commandEnvironment() {
+  const env = { ...process.env };
+  delete env.FARMING_BUNDLE_UPDATE_PAYLOAD;
+  delete env.FARMING_RUN_SERVER;
+  delete env.FARMING_RUN_NATIVE_PTY_HOST;
+  return env;
+}
+
+function runInstaller(payload) {
+  return new Promise((resolve, reject) => {
+    const logFd = fs.openSync(payload.logPath, 'a');
+    const child = spawn('bash', [payload.installer, 'install'], {
+      cwd: payload.releaseDir,
+      env: commandEnvironment(),
+      stdio: ['ignore', logFd, logFd],
+    });
+    child.once('error', error => {
+      fs.closeSync(logFd);
+      reject(error);
+    });
+    child.once('exit', (code, signal) => {
+      fs.closeSync(logFd);
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`bundle installer exited with ${signal || code}`));
+    });
+  });
+}
+
+async function runBundleUpdate(rawPayload) {
+  const payload = validatePayload(rawPayload);
+  writeJsonAtomic(payload.stateFile, stateFor(payload, 'installing'));
+  await new Promise(resolve => setTimeout(resolve, 1_000));
+  try {
+    await runInstaller(payload);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'succeeded', {
+      completedAt: new Date().toISOString(),
+    }));
+    appendLog(payload.logPath, `Farming updated to ${payload.version}`);
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'failed', {
+      error: message,
+      completedAt: new Date().toISOString(),
+    }));
+    appendLog(payload.logPath, `Update failed: ${message}`);
+  }
+}
+
+if (require.main === module) {
+  let payload;
+  try {
+    payload = JSON.parse(process.env.FARMING_BUNDLE_UPDATE_PAYLOAD || '');
+  } catch {
+    console.error('Invalid FARMING_BUNDLE_UPDATE_PAYLOAD');
+    process.exit(1);
+  }
+  runBundleUpdate(payload).catch(error => {
+    console.error(error.message || error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  runBundleUpdate,
+  validatePayload,
+};