farming-code 2.2.8 → 2.2.11

package/backend/native-session-engine.js

@@ -2,6 +2,7 @@ const SessionEngine = require('./session-engine');
 const NativePtyHostClient = require('./native-pty-host-client');
 const { normalizeShellSessionOptions } = require('./local-session-engine');
 const { cleanupShellBusyIntegration } = require('./shell-busy-integration');
+const { compareNativePtyRuntimeEpochs } = require('./native-pty-controller-generation');
 
 function isRecoverableConnectError(error) {
   const code = error && error.code;
@@ -13,6 +14,18 @@ function nativeSessionId(entry, fallback = '') {
   return entry.sessionId || entry.agentId || entry.metadata?.agentId || fallback || '';
 }
 
+function recoveredRuntimeEpoch(entry) {
+  if (!entry || typeof entry !== 'object') return '';
+  if (typeof entry.runtimeEpoch === 'string' && entry.runtimeEpoch) return entry.runtimeEpoch;
+  return typeof entry.state?.runtimeEpoch === 'string' ? entry.state.runtimeEpoch : '';
+}
+
+function shouldAdvanceRuntimeEpoch(currentEpoch, nextEpoch) {
+  if (!nextEpoch) return false;
+  if (!currentEpoch || currentEpoch === nextEpoch) return true;
+  return compareNativePtyRuntimeEpochs(nextEpoch, currentEpoch) === 1;
+}
+
 class NativeSessionEngine extends SessionEngine {
   constructor(options = {}) {
     super();
@@ -23,7 +36,10 @@ class NativeSessionEngine extends SessionEngine {
     });
     this.preserveHostOnDispose = options.preserveHostOnDispose === true;
     this.activeSessionIds = new Set();
-    this.reconcilingHostDisconnect = false;
+    this.activeSessionEpochs = new Map();
+    this.hostDisconnectGeneration = 0;
+    this.reconciledHostDisconnectGeneration = 0;
+    this.hostDisconnectReconcilePromise = null;
     this.bindClientEvents();
   }
 
@@ -31,6 +47,7 @@ class NativeSessionEngine extends SessionEngine {
     [
       'session-started',
       'session-output',
+      'session-transition',
       'session-sync',
       'session-preview',
       'session-title',
@@ -45,6 +62,7 @@ class NativeSessionEngine extends SessionEngine {
       });
     });
     this.client.on('host-disconnect', () => {
+      this.hostDisconnectGeneration += 1;
       this.reconcileHostDisconnect().catch(error => {
         const message = error && error.message ? error.message : 'Native pty host disconnected';
         this.failActiveSessions(message);
@@ -63,43 +81,68 @@ class NativeSessionEngine extends SessionEngine {
     const sessionId = nativeSessionId(payload);
     if (!sessionId) return;
     if (eventName === 'session-started') {
-      this.activeSessionIds.add(sessionId);
+      const runtimeEpoch = typeof payload.runtimeEpoch === 'string' ? payload.runtimeEpoch : '';
+      const currentEpoch = this.activeSessionEpochs.get(sessionId) || '';
+      if (shouldAdvanceRuntimeEpoch(currentEpoch, runtimeEpoch)) {
+        this.activeSessionIds.add(sessionId);
+        this.activeSessionEpochs.set(sessionId, runtimeEpoch);
+      } else if (!currentEpoch && !runtimeEpoch) {
+        this.activeSessionIds.add(sessionId);
+      }
     } else if (eventName === 'session-exited') {
+      const currentEpoch = this.activeSessionEpochs.get(sessionId) || '';
+      const exitedEpoch = typeof payload.runtimeEpoch === 'string' ? payload.runtimeEpoch : '';
+      if (currentEpoch ? exitedEpoch !== currentEpoch : Boolean(exitedEpoch)) return;
       this.activeSessionIds.delete(sessionId);
+      this.activeSessionEpochs.delete(sessionId);
     }
   }
 
   async reconcileHostDisconnect() {
-    if (this.reconcilingHostDisconnect) return;
-    const expectedSessionIds = [...this.activeSessionIds];
-    if (expectedSessionIds.length === 0) return;
-
-    this.reconcilingHostDisconnect = true;
-    try {
-      const recovered = await this.recoverSessions({ startHost: true });
-      const recoveredIds = new Set((recovered || [])
-        .map(entry => nativeSessionId(entry))
-        .filter(Boolean));
-
-      for (const sessionId of expectedSessionIds) {
-        if (recoveredIds.has(sessionId)) continue;
-        this.activeSessionIds.delete(sessionId);
-        this.emit('session-error', {
+    if (this.hostDisconnectReconcilePromise) return this.hostDisconnectReconcilePromise;
+    this.hostDisconnectReconcilePromise = (async () => {
+      while (this.reconciledHostDisconnectGeneration < this.hostDisconnectGeneration) {
+        const generation = this.hostDisconnectGeneration;
+        const expectedSessions = [...this.activeSessionIds].map(sessionId => ({
           sessionId,
-          error: 'Native pty host disconnected; terminal session is no longer recoverable',
-          fatal: true,
-        });
+          runtimeEpoch: this.activeSessionEpochs.get(sessionId) || '',
+        }));
+        if (expectedSessions.length > 0) {
+          const recovered = await this.recoverSessions({ startHost: true });
+          const recoveredIds = new Set((recovered || [])
+            .map(entry => nativeSessionId(entry))
+            .filter(Boolean));
+
+          for (const expected of expectedSessions) {
+            if (recoveredIds.has(expected.sessionId)) continue;
+            this.activeSessionIds.delete(expected.sessionId);
+            this.activeSessionEpochs.delete(expected.sessionId);
+            this.emit('session-error', {
+              sessionId: expected.sessionId,
+              runtimeEpoch: expected.runtimeEpoch,
+              error: 'Native pty host disconnected; terminal session is no longer recoverable',
+              fatal: true,
+            });
+          }
+        }
+        this.reconciledHostDisconnectGeneration = generation;
       }
+    })();
+    try {
+      await this.hostDisconnectReconcilePromise;
     } finally {
-      this.reconcilingHostDisconnect = false;
+      this.hostDisconnectReconcilePromise = null;
     }
   }
 
   failActiveSessions(message) {
     for (const sessionId of [...this.activeSessionIds]) {
       this.activeSessionIds.delete(sessionId);
+      const runtimeEpoch = this.activeSessionEpochs.get(sessionId) || '';
+      this.activeSessionEpochs.delete(sessionId);
       this.emit('session-error', {
         sessionId,
+        runtimeEpoch,
         error: message,
         fatal: true,
       });
@@ -128,25 +171,37 @@ class NativeSessionEngine extends SessionEngine {
     return result;
   }
 
-  async sendInput(sessionId, input) {
-    return this.client.request('sendInput', { sessionId, input });
+  async sendInput(sessionId, input, options = {}) {
+    return this.client.request('sendInput', {
+      sessionId,
+      input,
+      expectedRuntimeEpoch: options.expectedRuntimeEpoch || '',
+    }, {
+      retryOnDisconnect: false,
+    });
   }
 
-  async interruptSession(sessionId, input = '\x03') {
-    return this.sendInput(sessionId, input);
+  async interruptSession(sessionId, input = '\x03', options = {}) {
+    return this.sendInput(sessionId, input, options);
   }
 
   async resizeSession(sessionId, cols, rows) {
     return this.client.request('resizeSession', { sessionId, cols, rows });
   }
 
-  async clearBuffer(sessionId) {
-    return this.client.request('clearBuffer', { sessionId });
+  async clearBuffer(sessionId, options = {}) {
+    return this.client.request('clearBuffer', {
+      sessionId,
+      expectedRuntimeEpoch: options.expectedRuntimeEpoch || '',
+    }, {
+      retryOnDisconnect: false,
+    });
   }
 
   async killSession(sessionId) {
     const result = await this.client.request('killSession', { sessionId });
     this.activeSessionIds.delete(sessionId);
+    this.activeSessionEpochs.delete(sessionId);
     return result;
   }
 
@@ -154,6 +209,10 @@ class NativeSessionEngine extends SessionEngine {
     return this.client.request('getSessionState', { sessionId });
   }
 
+  async getSessionAttachCheckpoint(sessionId) {
+    return this.client.request('getSessionAttachCheckpoint', { sessionId });
+  }
+
   async getSessionPreview(sessionId) {
     return this.client.request('getSessionPreview', { sessionId });
   }
@@ -172,7 +231,13 @@ class NativeSessionEngine extends SessionEngine {
       const recovered = await this.client.request('recoverSessions', {}, { startHost });
       for (const entry of recovered || []) {
         const sessionId = nativeSessionId(entry);
-        if (sessionId) this.activeSessionIds.add(sessionId);
+        if (!sessionId) continue;
+        this.activeSessionIds.add(sessionId);
+        const runtimeEpoch = recoveredRuntimeEpoch(entry);
+        const currentEpoch = this.activeSessionEpochs.get(sessionId) || '';
+        if (shouldAdvanceRuntimeEpoch(currentEpoch, runtimeEpoch)) {
+          this.activeSessionEpochs.set(sessionId, runtimeEpoch);
+        }
       }
       return recovered;
     } catch (error) {
@@ -185,11 +250,18 @@ class NativeSessionEngine extends SessionEngine {
     return this.client.request('updateSessionMetadata', { sessionId, patch });
   }
 
+  consumeRuntimeRotation() {
+    return typeof this.client.consumeRuntimeRotation === 'function'
+      ? this.client.consumeRuntimeRotation()
+      : null;
+  }
+
   dispose(options = {}) {
     this.client.disconnect({
       preserveHost: options.preserveHost === true || this.preserveHostOnDispose,
     });
     this.activeSessionIds.clear();
+    this.activeSessionEpochs.clear();
   }
 }
 

package/backend/packaged-node-pty.js

@@ -15,8 +15,27 @@ function packagedNodePtyTargetDir() {
 function copyIfExists(source, target, mode) {
   if (!fs.existsSync(source)) return false;
   fs.mkdirSync(path.dirname(target), { recursive: true });
-  fs.copyFileSync(source, target);
-  if (mode !== undefined) fs.chmodSync(target, mode);
+  let unchanged = false;
+  try {
+    const sourceStat = fs.statSync(source);
+    const targetStat = fs.statSync(target);
+    unchanged = sourceStat.size === targetStat.size
+      && fs.readFileSync(source).equals(fs.readFileSync(target));
+  } catch {
+    unchanged = false;
+  }
+  if (!unchanged) {
+    const temporary = `${target}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+      fs.copyFileSync(source, temporary, fs.constants.COPYFILE_EXCL);
+      if (mode !== undefined) fs.chmodSync(temporary, mode);
+      fs.renameSync(temporary, target);
+    } finally {
+      fs.rmSync(temporary, { force: true });
+    }
+  } else if (mode !== undefined) {
+    fs.chmodSync(target, mode);
+  }
   return true;
 }
 
@@ -75,5 +94,6 @@ function loadNodePty() {
 
 module.exports = loadNodePty();
 module.exports.copyPackagedSpawnHelper = copyPackagedSpawnHelper;
+module.exports.copyIfExists = copyIfExists;
 module.exports.preparePackagedNodePtyRuntime = preparePackagedNodePtyRuntime;
 module.exports.isPackagedRuntime = isPackagedRuntime;

package/backend/provider-adapters.js

@@ -0,0 +1,253 @@
+const path = require('path');
+const {
+  createProviderSessionId,
+  createTemporaryProviderSessionId,
+  isSafeProviderSessionId,
+} = require('./provider-session-id');
+
+const CODEX_VALUE_OPTIONS = new Set([
+  '-a', '-c', '-C', '-m', '-s', '--ask-for-approval', '--cd', '--config',
+  '--config-profile', '--model', '--profile', '--sandbox',
+]);
+
+function optionTakesValue(option, valueOptions) {
+  return Boolean(option && !option.includes('=') && valueOptions.has(option));
+}
+
+function firstCodexSubcommand(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg.startsWith('-')) {
+      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
+      continue;
+    }
+    return { value: arg, index };
+  }
+  return null;
+}
+
+function codexSessionIdAfterSubcommand(args, subcommandIndex) {
+  const positional = [];
+  for (let index = subcommandIndex + 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg.startsWith('-')) {
+      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
+      continue;
+    }
+    positional.push(arg);
+  }
+  const sessionId = positional.at(-1) || '';
+  return isSafeProviderSessionId(sessionId) ? sessionId : '';
+}
+
+function argValue(args, names) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    for (const name of names) {
+      if (arg === name) return args[index + 1] || '';
+      if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+    }
+  }
+  return '';
+}
+
+function hasArg(args, names) {
+  return args.some(arg => names.includes(arg) || names.some(name => arg.startsWith(`${name}=`)));
+}
+
+function codexSessionPlan(rawArgs) {
+  const subcommand = firstCodexSubcommand(rawArgs);
+  if (subcommand?.value === 'resume') {
+    const id = codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
+    if (id) return { id, temporary: false, source: 'resume' };
+  }
+  if (subcommand?.value === 'fork') {
+    return {
+      id: createTemporaryProviderSessionId(),
+      temporary: true,
+      source: 'codex-fork-temporary',
+      forkedFromProviderSessionId: codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
+    };
+  }
+  if (subcommand?.value) return null;
+  return { id: createTemporaryProviderSessionId(), temporary: true, source: 'codex-temporary' };
+}
+
+function explicitSessionPlan(provider, rawArgs, launchArgs) {
+  const explicitSessionId = argValue(rawArgs, ['--session-id']);
+  const resumeSessionId = argValue(rawArgs, ['--resume']);
+  const isFork = hasArg(rawArgs, ['--fork-session']);
+  const isContinue = hasArg(rawArgs, provider === 'claude' ? ['--continue', '-c'] : ['--continue']);
+  if (explicitSessionId && isSafeProviderSessionId(explicitSessionId)) {
+    return {
+      id: explicitSessionId,
+      temporary: false,
+      source: 'launch-session-id',
+      forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
+    };
+  }
+  if (resumeSessionId && isSafeProviderSessionId(resumeSessionId) && !isFork) {
+    return { id: resumeSessionId, temporary: false, source: 'resume' };
+  }
+  if (isContinue) return null;
+  const id = createProviderSessionId();
+  return {
+    id,
+    temporary: false,
+    source: isFork ? `${provider}-fork-session-id` : `${provider}-session-id`,
+    forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
+    args: ['--session-id', id, ...launchArgs],
+  };
+}
+
+function openCodeSessionPlan(rawArgs) {
+  const id = argValue(rawArgs, ['--session', '-s']);
+  if (!id || !isSafeProviderSessionId(id)) return null;
+  return hasArg(rawArgs, ['--fork'])
+    ? {
+      id: createTemporaryProviderSessionId(),
+      temporary: true,
+      source: 'opencode-fork-temporary',
+      forkedFromProviderSessionId: id,
+    }
+    : { id, temporary: false, source: 'resume' };
+}
+
+function codexAcpEnvironment(options = {}) {
+  const env = { ...(options.env || process.env) };
+  if (options.executable && !env.CODEX_PATH) env.CODEX_PATH = options.executable;
+  let config = {};
+  if (env.CODEX_CONFIG) {
+    try {
+      const parsed = JSON.parse(env.CODEX_CONFIG);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) config = parsed;
+    } catch {
+      // A selected Farming profile below replaces an invalid adapter config.
+    }
+  }
+  if (options.model && options.model !== 'config') config.model = options.model;
+  if (options.reasoningEffort && options.reasoningEffort !== 'config') config.model_reasoning_effort = options.reasoningEffort;
+  if (options.serviceTier && !['config', 'default'].includes(options.serviceTier)) config.service_tier = options.serviceTier;
+  if (Object.keys(config).length > 0) env.CODEX_CONFIG = JSON.stringify(config);
+  const initialMode = { ask: 'read-only', approve: 'agent', full: 'agent-full-access' }[options.approvalMode];
+  if (initialMode) env.INITIAL_AGENT_MODE = initialMode;
+  return env;
+}
+
+const PROVIDER_ADAPTERS = Object.freeze([
+  {
+    id: 'codex',
+    displayName: 'codex',
+    executable: 'codex',
+    homeEnvKey: 'CODEX_HOME',
+    interruptInput: '\x1b',
+    freshAcpSessionSources: ['codex-temporary'],
+    commands: ['codex'],
+    supportedRuntimes: ['terminal', 'acp', 'json', 'app-server'],
+    planSession: codexSessionPlan,
+    acp: { packageName: '@agentclientprotocol/codex-acp', version: '1.1.4' },
+    prepareAcpEnvironment: codexAcpEnvironment,
+    capabilities: { runtimeSwitch: true, terminalProfile: true, goals: true },
+  },
+  {
+    id: 'claude',
+    displayName: 'claude code',
+    executable: 'claude',
+    homeEnvKey: 'CLAUDE_CONFIG_DIR',
+    interruptInput: '\x1b',
+    freshAcpSessionSources: ['claude-session-id'],
+    commands: ['claude'],
+    supportedRuntimes: ['terminal', 'acp'],
+    planSession: (rawArgs, launchArgs) => explicitSessionPlan('claude', rawArgs, launchArgs),
+    acp: { packageName: '@agentclientprotocol/claude-agent-acp', version: '0.59.0' },
+    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false },
+  },
+  {
+    id: 'opencode',
+    displayName: 'opencode',
+    executable: 'opencode',
+    homeEnvKey: 'OPENCODE_CONFIG_DIR',
+    interruptInput: '\x03',
+    freshAcpSessionSources: [],
+    commands: ['opencode'],
+    supportedRuntimes: ['terminal', 'acp', 'json'],
+    planSession: openCodeSessionPlan,
+    acp: {
+      version: 'native',
+      launch: options => ({
+        command: options.executable || 'opencode',
+        args: ['acp', '--cwd', path.resolve(options.cwd || process.cwd())],
+      }),
+    },
+    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false },
+  },
+  {
+    id: 'qoder',
+    displayName: 'qoder',
+    executable: 'qodercli',
+    homeEnvKey: 'QODER_CONFIG_DIR',
+    interruptInput: '\x1b',
+    freshAcpSessionSources: ['qoder-session-id'],
+    commands: ['qoder', 'qodercli'],
+    supportedRuntimes: ['terminal', 'acp'],
+    planSession: (rawArgs, launchArgs) => explicitSessionPlan('qoder', rawArgs, launchArgs),
+    acp: {
+      version: 'native',
+      launch: options => ({ command: options.executable || 'qodercli', args: ['--acp'] }),
+    },
+    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false },
+  },
+]);
+
+const ADAPTER_BY_ID = new Map(PROVIDER_ADAPTERS.map(adapter => [adapter.id, Object.freeze(adapter)]));
+const ADAPTER_BY_COMMAND = new Map(PROVIDER_ADAPTERS.flatMap(adapter => (
+  adapter.commands.map(command => [command, adapter])
+)));
+
+function getProviderAdapter(provider) {
+  return ADAPTER_BY_ID.get(String(provider || '').trim().toLowerCase()) || null;
+}
+
+function providerForProgram(program) {
+  return ADAPTER_BY_COMMAND.get(path.basename(String(program || '').trim()))?.id || '';
+}
+
+function listProviderAdapters() {
+  return [...PROVIDER_ADAPTERS];
+}
+
+function providerCapabilities(provider) {
+  const adapter = getProviderAdapter(provider);
+  return {
+    supportedRuntimes: adapter ? [...adapter.supportedRuntimes] : ['terminal'],
+    runtimeSwitch: adapter?.capabilities?.runtimeSwitch === true,
+    terminalProfile: adapter?.capabilities?.terminalProfile === true,
+    goals: adapter?.capabilities?.goals === true,
+  };
+}
+
+function providerSupportsRuntime(provider, runtime) {
+  return getProviderAdapter(provider)?.supportedRuntimes.includes(runtime) === true;
+}
+
+function applyProviderHomeEnvironment(env, provider, homePath) {
+  const key = getProviderAdapter(provider)?.homeEnvKey;
+  if (key && homePath) env[key] = homePath;
+  return env;
+}
+
+function isFreshAcpSessionSource(provider, source) {
+  return getProviderAdapter(provider)?.freshAcpSessionSources.includes(source) === true;
+}
+
+module.exports = {
+  getProviderAdapter,
+  applyProviderHomeEnvironment,
+  isFreshAcpSessionSource,
+  listProviderAdapters,
+  providerCapabilities,
+  providerForProgram,
+  providerSupportsRuntime,
+};