farming-code 2.2.14 → 2.2.17

package/backend/native-pty-host-client.js

@@ -14,7 +14,9 @@ const {
   allocateNativePtyControllerGeneration,
   positiveGeneration,
 } = require('./native-pty-controller-generation');
+const { isTemporaryProviderSessionId } = require('./provider-session-id');
 const storageLayout = require('./storage-layout');
+const { deserializeTerminalState } = require('./terminal-state-serialization');
 
 const DEFAULT_CONNECT_RETRIES = 300;
 const DEFAULT_CONNECT_RETRY_MS = 50;
@@ -463,6 +465,23 @@ class NativePtyHostClient extends EventEmitter {
     });
   }
 
+  async requirePreparedHostRotationResume(preparationToken, actual, primaryError) {
+    if (!preparationToken) return;
+    try {
+      await this.resumePreparedHostRotation(preparationToken);
+    } catch (resumeError) {
+      const recoveryError = new Error(
+        `Cannot confirm recovery of incompatible native PTY host (${actual}) after aborting rotation`
+      );
+      recoveryError.code = 'FARMING_NATIVE_HOST_ROTATION_RECOVERY_FAILED';
+      recoveryError.cause = new AggregateError(
+        [primaryError, resumeError].filter(Boolean),
+        'Native PTY rotation failed and the prepared host could not be resumed'
+      );
+      throw recoveryError;
+    }
+  }
+
   async rotateMismatchedHost(hostInfo) {
     const expected = runtimeIdentityLabel(this.expectedRuntimeIdentity);
     const actual = runtimeIdentityLabel(hostInfo && hostInfo.runtimeIdentity);
@@ -513,7 +532,11 @@ class NativePtyHostClient extends EventEmitter {
         throw new Error('The native PTY host returned an invalid rotation checkpoint');
       }
     } catch (error) {
-      await this.resumePreparedHostRotation(preparationToken).catch(() => {});
+      if (preparationToken) {
+        await this.requirePreparedHostRotationResume(preparationToken, actual, error);
+      } else {
+        await this.resumePreparedHostRotation('').catch(() => {});
+      }
       const recovered = await this.requestOnce('recoverSessions', {}, {
         ensureConnected: false,
         retryOnDisconnect: false,
@@ -532,6 +555,40 @@ class NativePtyHostClient extends EventEmitter {
       }
     }
 
+    let unresumableCodex;
+    try {
+      unresumableCodex = deserializeTerminalState(serializedTerminalState).find(entry => {
+        const metadata = entry.metadata || {};
+        const provider = String(metadata.providerSessionProvider || metadata.provider || '').trim();
+        return provider === 'codex'
+          && metadata.terminalInputReceived === true
+          && (
+            metadata.providerSessionTemporary === true
+            || isTemporaryProviderSessionId(metadata.providerSessionId)
+          );
+      });
+    } catch (error) {
+      await this.requirePreparedHostRotationResume(preparationToken, actual, error);
+      const mismatchError = new Error(
+        `Cannot rotate incompatible native PTY host (${actual}) with an invalid terminal checkpoint`
+      );
+      mismatchError.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+      mismatchError.cause = error;
+      throw mismatchError;
+    }
+    if (unresumableCodex) {
+      const unresumableError = new Error(
+        `Codex session ${unresumableCodex.id} has user input but no exact resume id`
+      );
+      await this.requirePreparedHostRotationResume(preparationToken, actual, unresumableError);
+      const mismatchError = new Error(
+        `Cannot rotate incompatible native PTY host (${actual}) while Codex session ${unresumableCodex.id} has user input but no exact resume id`
+      );
+      mismatchError.code = 'FARMING_NATIVE_HOST_UNRESUMABLE_SESSION';
+      mismatchError.cause = unresumableError;
+      throw mismatchError;
+    }
+
     const socket = this.socket;
     if (socket) this.suppressedDisconnectSockets.add(socket);
     let shutdownUncertain = false;
@@ -546,7 +603,7 @@ class NativePtyHostClient extends EventEmitter {
       });
     } catch (error) {
       if (!isConnectRetryable(error)) {
-        await this.resumePreparedHostRotation(preparationToken).catch(() => {});
+        await this.requirePreparedHostRotationResume(preparationToken, actual, error);
         const mismatchError = new Error(
           `Cannot rotate incompatible native PTY host (${actual}); stop the old host and restart Farming`
         );

package/backend/npm-update-helper.js

@@ -64,12 +64,23 @@ function validatePayload(payload) {
   if (!/^[A-Za-z0-9@/._-]+$/.test(String(payload.packageName || ''))) throw new Error('Invalid npm package name');
   if (!/^[0-9A-Za-z.+-]+$/.test(String(payload.targetVersion || ''))) throw new Error('Invalid npm target version');
   if (!/^[0-9A-Za-z.+-]+$/.test(String(payload.previousVersion || ''))) throw new Error('Invalid npm previous version');
-  for (const key of ['stateFile', 'logPath', 'cliPath', 'configDir']) {
+  for (const key of ['stateFile', 'logPath', 'cliPath', 'packageRoot', 'configDir']) {
     if (!path.isAbsolute(String(payload[key] || ''))) throw new Error(`Invalid npm update ${key}`);
   }
   if (payload.npmPrefix && !path.isAbsolute(String(payload.npmPrefix))) {
     throw new Error('Invalid npm update npmPrefix');
   }
+  if (payload.npmFallbackRegistryUrl) {
+    let registry;
+    try {
+      registry = new URL(String(payload.npmFallbackRegistryUrl));
+    } catch {
+      throw new Error('Invalid npm update registry');
+    }
+    if (!['http:', 'https:'].includes(registry.protocol)) {
+      throw new Error('Invalid npm update registry');
+    }
+  }
   return payload;
 }
 
@@ -109,15 +120,59 @@ function commandEnvironment() {
 
 async function installPackage(payload, version) {
   const packageSpec = `${payload.packageName}@${version}`;
-  appendLog(payload.logPath, `Installing ${packageSpec}`);
+  return installPackageFromRegistry(payload, packageSpec);
+}
+
+function verifyInstalledVersion(payload, expectedVersion) {
+  const packageJsonPath = path.join(payload.packageRoot, 'package.json');
+  let metadata;
+  try {
+    metadata = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Installed ${payload.packageName} package metadata is unreadable: ${error.message || String(error)}`, { cause: error });
+  }
+  const actualVersion = String(metadata && metadata.version || '');
+  if (actualVersion !== expectedVersion) {
+    throw new Error(`Installed ${payload.packageName} version mismatch: expected ${expectedVersion}, found ${actualVersion || 'missing'}`);
+  }
+}
+
+function logSize(filePath) {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+
+function logSince(filePath, offset) {
+  try {
+    return fs.readFileSync(filePath, 'utf8').slice(offset);
+  } catch {
+    return '';
+  }
+}
+
+async function installPackageFromRegistry(payload, packageSpec, registryUrl = '') {
+  appendLog(payload.logPath, `Installing ${packageSpec}${registryUrl ? ' from the update-status registry' : ''}`);
   const args = ['install', '--global'];
   if (payload.npmPrefix) args.push('--prefix', payload.npmPrefix);
+  if (registryUrl) args.push('--registry', registryUrl);
   args.push(packageSpec, '--no-audit', '--no-fund');
-  await runCommand(payload.npmCommand || 'npm', args, {
-    cwd: payload.configDir,
-    env: commandEnvironment(),
-    logPath: payload.logPath,
-  });
+  const offset = logSize(payload.logPath);
+  try {
+    await runCommand(payload.npmCommand || 'npm', args, {
+      cwd: payload.configDir,
+      env: commandEnvironment(),
+      logPath: payload.logPath,
+    });
+  } catch (error) {
+    if (!registryUrl && payload.npmFallbackRegistryUrl && /(?:ETARGET|No matching version found)/.test(logSince(payload.logPath, offset))) {
+      appendLog(payload.logPath, `Configured npm registry has no ${packageSpec}; retrying from the update-status registry`);
+      return installPackageFromRegistry(payload, packageSpec, payload.npmFallbackRegistryUrl);
+    }
+    throw error;
+  }
 }
 
 async function startServer(payload, version = payload.targetVersion) {
@@ -134,6 +189,7 @@ async function runNpmUpdate(rawPayload) {
   try {
     writeJsonAtomic(payload.stateFile, stateFor(payload, 'installing'));
     await installPackage(payload, payload.targetVersion);
+    verifyInstalledVersion(payload, payload.targetVersion);
 
     writeJsonAtomic(payload.stateFile, stateFor(payload, 'restarting'));
     await stopProcess(Number(payload.serverPid));
@@ -151,6 +207,7 @@ async function runNpmUpdate(rawPayload) {
       try {
         writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolling-back', { error: message }));
         await installPackage(payload, payload.previousVersion);
+        verifyInstalledVersion(payload, payload.previousVersion);
         await startServer(payload, payload.previousVersion);
         writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolled-back', {
           version: payload.previousVersion,
@@ -196,5 +253,6 @@ module.exports = {
   runNpmUpdate,
   stopProcess,
   validatePayload,
+  verifyInstalledVersion,
   writeJsonAtomic,
 };

package/backend/provider-adapters.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const { chatCapabilitiesForProvider } = require('./chat-runtime');
 const {
   createProviderSessionId,
   createTemporaryProviderSessionId,
@@ -6,45 +7,73 @@ const {
 } = 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',
+  '-a', '-c', '-C', '-m', '-p', '-s', '--ask-for-approval', '--cd', '--config',
+  '--config-profile', '--model', '--profile', '--sandbox', '--add-dir',
+  '--enable', '--disable', '--remote', '--remote-auth-token-env',
+  '--local-provider', '-i', '--image',
 ]);
+const OPENCODE_VALUE_OPTIONS = new Set([
+  '-m', '-s', '--agent', '--hostname', '--log-level', '--mdns-domain',
+  '--model', '--port', '--prompt', '--replay-limit', '--session',
+]);
+const CODEX_SUBCOMMANDS = new Set([
+  'exec', 'e', 'review', 'login', 'logout', 'mcp', 'plugin', 'mcp-server',
+  'app-server', 'remote-control', 'app', 'completion', 'update', 'doctor',
+  'sandbox', 'debug', 'apply', 'a', 'resume', 'archive', 'delete', 'unarchive',
+  'fork', 'cloud', 'exec-server', 'features', 'help',
+]);
+const OPENCODE_SUBCOMMANDS = new Set([
+  'completion', 'acp', 'mcp', 'attach', 'run', 'debug', 'providers', 'auth',
+  'agent', 'upgrade', 'uninstall', 'serve', 'web', 'models', 'stats', 'export',
+  'import', 'github', 'pr', 'session', 'plugin', 'plug', 'db',
+]);
+const CODEX_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 function optionTakesValue(option, valueOptions) {
   return Boolean(option && !option.includes('=') && valueOptions.has(option));
 }
 
-function firstCodexSubcommand(args) {
+function scanPositionals(args, valueOptions, options = {}) {
+  const positionals = [];
   for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
+    const arg = String(args[index] || '');
     if (!arg) continue;
+    if (arg === '--') {
+      for (let positionalIndex = index + 1; positionalIndex < args.length; positionalIndex += 1) {
+        const value = String(args[positionalIndex] || '');
+        if (value) positionals.push({ value, index: positionalIndex, afterDelimiter: true });
+      }
+      break;
+    }
     if (arg.startsWith('-')) {
-      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
+      if (
+        options.multiValueOptions?.has(arg)
+        && !arg.includes('=')
+      ) {
+        while (index + 1 < args.length && !String(args[index + 1] || '').startsWith('-')) index += 1;
+        continue;
+      }
+      if (optionTakesValue(arg, valueOptions)) index += 1;
       continue;
     }
-    return { value: arg, index };
+    positionals.push({ value: arg, index, afterDelimiter: false });
   }
-  return null;
+  return positionals;
 }
 
 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 : '';
+  const sessionId = scanPositionals(
+    args.slice(subcommandIndex + 1),
+    CODEX_VALUE_OPTIONS,
+    { multiValueOptions: new Set(['-i', '--image']) },
+  )[0]?.value || '';
+  return CODEX_SESSION_ID_RE.test(sessionId) ? sessionId.toLowerCase() : '';
 }
 
 function argValue(args, names) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
+    if (arg === '--') break;
     for (const name of names) {
       if (arg === name) return args[index + 1] || '';
       if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
@@ -54,13 +83,26 @@ function argValue(args, names) {
 }
 
 function hasArg(args, names) {
-  return args.some(arg => names.includes(arg) || names.some(name => arg.startsWith(`${name}=`)));
+  for (const arg of args) {
+    if (arg === '--') break;
+    if (names.includes(arg) || names.some(name => arg.startsWith(`${name}=`))) return true;
+  }
+  return false;
 }
 
-function codexSessionPlan(rawArgs) {
-  const subcommand = firstCodexSubcommand(rawArgs);
+function codexSessionPlan(rawArgs, _launchArgs) {
+  const positional = scanPositionals(rawArgs, CODEX_VALUE_OPTIONS, {
+    multiValueOptions: new Set(['-i', '--image']),
+  });
+  const subcommand = positional[0]
+    && positional[0].afterDelimiter !== true
+    && CODEX_SUBCOMMANDS.has(positional[0].value)
+    ? positional[0]
+    : null;
   if (subcommand?.value === 'resume') {
-    const id = codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
+    const id = hasArg(rawArgs.slice(subcommand.index + 1), ['--last'])
+      ? ''
+      : codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
     if (id) return { id, temporary: false, source: 'resume' };
   }
   if (subcommand?.value === 'fork') {
@@ -68,11 +110,22 @@ function codexSessionPlan(rawArgs) {
       id: createTemporaryProviderSessionId(),
       temporary: true,
       source: 'codex-fork-temporary',
-      forkedFromProviderSessionId: codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
+      forkedFromProviderSessionId: hasArg(rawArgs.slice(subcommand.index + 1), ['--last'])
+        ? ''
+        : codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
+    };
+  }
+  if (subcommand) return null;
+  if (hasArg(rawArgs, ['--remote'])) {
+    return {
+      error: 'A fresh Codex --remote Terminal cannot be correlated with a local resumable session id; resume an explicit remote session id instead',
     };
   }
-  if (subcommand?.value) return null;
-  return { id: createTemporaryProviderSessionId(), temporary: true, source: 'codex-temporary' };
+  return {
+    id: createTemporaryProviderSessionId(),
+    temporary: true,
+    source: 'codex-temporary',
+  };
 }
 
 function explicitSessionPlan(provider, rawArgs, launchArgs) {
@@ -102,17 +155,35 @@ function explicitSessionPlan(provider, rawArgs, launchArgs) {
   };
 }
 
-function openCodeSessionPlan(rawArgs) {
+function openCodeSessionPlan(rawArgs, launchArgs) {
   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' };
+  if (id && isSafeProviderSessionId(id)) {
+    return hasArg(rawArgs, ['--fork'])
+      ? {
+        id: createTemporaryProviderSessionId(),
+        temporary: true,
+        source: 'opencode-fork-temporary',
+        forkedFromProviderSessionId: id,
+      }
+      : { id, temporary: false, source: 'resume' };
+  }
+  if (hasArg(rawArgs, ['--session', '-s', '--continue', '-c', '--fork'])) return null;
+  const positional = scanPositionals(rawArgs, OPENCODE_VALUE_OPTIONS, {
+    multiValueOptions: new Set(['--cors']),
+  });
+  if (
+    positional[0]
+    && positional[0].afterDelimiter !== true
+    && OPENCODE_SUBCOMMANDS.has(positional[0].value)
+  ) return null;
+  return {
+    id: '',
+    precreate: true,
+    temporary: false,
+    source: 'opencode-precreate',
+    identityWorkspace: positional[0]?.value || '',
+    resumeInsertIndex: launchArgs.length,
+  };
 }
 
 function codexAcpEnvironment(options = {}) {
@@ -145,11 +216,12 @@ const PROVIDER_ADAPTERS = Object.freeze([
     interruptInput: '\x1b',
     freshAcpSessionSources: ['codex-temporary'],
     commands: ['codex'],
-    supportedRuntimes: ['terminal', 'acp', 'json', 'app-server'],
+    supportedRuntimes: ['terminal', 'acp', 'json'],
     planSession: codexSessionPlan,
+    terminalResumeArgs: (args, sessionId) => ['resume', sessionId, ...args],
     acp: { packageName: '@agentclientprotocol/codex-acp', version: '1.1.4' },
     prepareAcpEnvironment: codexAcpEnvironment,
-    capabilities: { runtimeSwitch: true, terminalProfile: true, goals: true },
+    capabilities: { runtimeSwitch: true, terminalProfile: true, goals: false },
   },
   {
     id: 'claude',
@@ -174,6 +246,16 @@ const PROVIDER_ADAPTERS = Object.freeze([
     commands: ['opencode'],
     supportedRuntimes: ['terminal', 'acp', 'json'],
     planSession: openCodeSessionPlan,
+    terminalResumeArgs: (args, sessionId) => {
+      const delimiterIndex = args.indexOf('--');
+      const insertIndex = delimiterIndex >= 0 ? delimiterIndex : args.length;
+      return [
+        ...args.slice(0, insertIndex),
+        '--session',
+        sessionId,
+        ...args.slice(insertIndex),
+      ];
+    },
     acp: {
       version: 'native',
       launch: options => ({
@@ -225,6 +307,9 @@ function providerCapabilities(provider) {
     runtimeSwitch: adapter?.capabilities?.runtimeSwitch === true,
     terminalProfile: adapter?.capabilities?.terminalProfile === true,
     goals: adapter?.capabilities?.goals === true,
+    ...(adapter
+      ? chatCapabilitiesForProvider(provider)
+      : { chatRuntime: '', supportsChat: false, supportsSteer: false }),
   };
 }