farming-code 2.2.20 → 2.2.23

package/backend/native-pty-host.js

@@ -77,6 +77,15 @@ function sanitizeAgentEnv(env) {
   });
 }
 
+function socketIdentity(socketPath) {
+  const stat = fs.statSync(socketPath, { bigint: true });
+  return { dev: stat.dev, ino: stat.ino };
+}
+
+function sameSocketIdentity(left, right) {
+  return Boolean(left && right && left.dev === right.dev && left.ino === right.ino);
+}
+
 class NativePtyHost {
   constructor(options = {}) {
     this.configDir = options.configDir || process.env.FARMING_CONFIG_DIR || path.join(os.homedir(), '.farming');
@@ -84,6 +93,13 @@ class NativePtyHost {
     this.ownerPid = Number(options.ownerPid || process.env.FARMING_NATIVE_PTY_HOST_OWNER_PID || 0);
     this.runtimeIdentity = options.runtimeIdentity || HOST_RUNTIME_IDENTITY;
     this.exitOnShutdown = options.exitOnShutdown !== false;
+    this.boundSocketPath = process.platform === 'win32'
+      ? this.socketPath
+      : path.join(
+          path.dirname(this.socketPath),
+          `.fpty-${process.pid}-${crypto.createHash('sha256').update(this.socketPath).digest('hex').slice(0, 8)}-${crypto.randomBytes(4).toString('hex')}.sock`,
+        );
+    this.boundSocketIdentity = null;
     this.sessions = new Map();
     this.clients = new Set();
     this.ownerCheckTimer = null;
@@ -130,13 +146,22 @@ class NativePtyHost {
     this.server = net.createServer(socket => this.handleConnection(socket));
     await new Promise((resolve, reject) => {
       this.server.once('error', reject);
-      this.server.listen(this.socketPath, () => {
+      this.server.listen(this.boundSocketPath, () => {
         this.server.off('error', reject);
         resolve();
       });
     });
     if (process.platform !== 'win32') {
-      fs.chmodSync(this.socketPath, 0o600);
+      this.boundSocketIdentity = socketIdentity(this.boundSocketPath);
+      fs.chmodSync(this.boundSocketPath, 0o600);
+      try {
+        fs.linkSync(this.boundSocketPath, this.socketPath);
+      } catch (error) {
+        await new Promise(resolve => this.server.close(() => resolve()));
+        this.server = null;
+        this.boundSocketIdentity = null;
+        throw error;
+      }
     }
     console.error(`[${new Date().toISOString()}] Native PTY host listening on ${this.socketPath} ownerPid=${this.ownerPid || ''}`);
     this.startOwnerWatch();
@@ -173,6 +198,11 @@ class NativePtyHost {
     } catch (error) {
       if (!error || error.code !== 'ENOENT') throw error;
     }
+    try {
+      fs.unlinkSync(this.boundSocketPath);
+    } catch (error) {
+      if (!error || error.code !== 'ENOENT') throw error;
+    }
   }
 
   handleConnection(socket) {
@@ -1476,16 +1506,22 @@ class NativePtyHost {
       }
     }
     await this.screenWorkerPool.dispose();
-    if (this.server) {
-      await new Promise(resolve => this.server.close(() => resolve()));
-      this.server = null;
-    }
-    if (process.platform !== 'win32') {
+    if (this.server && process.platform !== 'win32') {
       try {
-        fs.unlinkSync(this.socketPath);
+        const currentSocketIdentity = socketIdentity(this.socketPath);
+        if (sameSocketIdentity(currentSocketIdentity, this.boundSocketIdentity)) {
+          // Unlink while this listener is still active. A competing host cannot
+          // replace an active socket between the ownership check and unlink.
+          fs.unlinkSync(this.socketPath);
+        }
       } catch (error) {
         if (!error || error.code !== 'ENOENT') throw error;
       }
+      this.boundSocketIdentity = null;
+    }
+    if (this.server) {
+      await new Promise(resolve => this.server.close(() => resolve()));
+      this.server = null;
     }
   }
 }

package/backend/npm-update-helper.js

@@ -61,10 +61,11 @@ async function stopProcess(pid, timeoutMs = 15_000) {
 
 function validatePayload(payload) {
   if (!payload || typeof payload !== 'object') throw new Error('Missing npm update payload');
+  if (!['prepare', 'apply'].includes(payload.action)) throw new Error('Invalid npm update action');
   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', 'packageRoot', 'configDir']) {
+  for (const key of ['stateFile', 'logPath', 'cliPath', 'packageRoot', 'configDir', 'stagingPrefix', 'stagingPackageRoot']) {
     if (!path.isAbsolute(String(payload[key] || ''))) throw new Error(`Invalid npm update ${key}`);
   }
   if (payload.npmPrefix && !path.isAbsolute(String(payload.npmPrefix))) {
@@ -81,6 +82,13 @@ function validatePayload(payload) {
       throw new Error('Invalid npm update registry');
     }
   }
+  const expectedStagingRoot = path.join(payload.stagingPrefix, 'lib', 'node_modules', payload.packageName);
+  if (path.resolve(payload.stagingPackageRoot) !== path.resolve(expectedStagingRoot)) {
+    throw new Error('Invalid npm update stagingPackageRoot');
+  }
+  if (path.resolve(payload.stagingPackageRoot) === path.resolve(payload.packageRoot)) {
+    throw new Error('npm update staging root must differ from the running package root');
+  }
   return payload;
 }
 
@@ -93,6 +101,8 @@ function stateFor(payload, phase, extra = {}) {
     packageName: payload.packageName,
     startedAt: payload.startedAt,
     logPath: payload.logPath,
+    stagingPrefix: payload.stagingPrefix,
+    stagingPackageRoot: payload.stagingPackageRoot,
     ...extra,
   };
 }
@@ -118,13 +128,13 @@ function commandEnvironment() {
   return env;
 }
 
-async function installPackage(payload, version) {
+async function installPackage(payload, version, npmPrefix = payload.npmPrefix) {
   const packageSpec = `${payload.packageName}@${version}`;
-  return installPackageFromRegistry(payload, packageSpec);
+  return installPackageFromRegistry(payload, packageSpec, '', npmPrefix);
 }
 
-function verifyInstalledVersion(payload, expectedVersion) {
-  const packageJsonPath = path.join(payload.packageRoot, 'package.json');
+function verifyInstalledVersion(payload, expectedVersion, packageRoot = payload.packageRoot) {
+  const packageJsonPath = path.join(packageRoot, 'package.json');
   let metadata;
   try {
     metadata = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
@@ -153,10 +163,10 @@ function logSince(filePath, offset) {
   }
 }
 
-async function installPackageFromRegistry(payload, packageSpec, registryUrl = '') {
+async function installPackageFromRegistry(payload, packageSpec, registryUrl = '', npmPrefix = payload.npmPrefix) {
   appendLog(payload.logPath, `Installing ${packageSpec}${registryUrl ? ' from the update-status registry' : ''}`);
   const args = ['install', '--global'];
-  if (payload.npmPrefix) args.push('--prefix', payload.npmPrefix);
+  if (npmPrefix) args.push('--prefix', npmPrefix);
   if (registryUrl) args.push('--registry', registryUrl);
   args.push(packageSpec, '--no-audit', '--no-fund');
   const offset = logSize(payload.logPath);
@@ -169,7 +179,7 @@ async function installPackageFromRegistry(payload, packageSpec, registryUrl = ''
   } 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);
+      return installPackageFromRegistry(payload, packageSpec, payload.npmFallbackRegistryUrl, npmPrefix);
     }
     throw error;
   }
@@ -184,38 +194,100 @@ async function startServer(payload, version = payload.targetVersion) {
   });
 }
 
-async function runNpmUpdate(rawPayload) {
-  const payload = validatePayload(rawPayload);
+async function prepareNpmUpdate(payload) {
   try {
     writeJsonAtomic(payload.stateFile, stateFor(payload, 'installing'));
-    await installPackage(payload, payload.targetVersion);
-    verifyInstalledVersion(payload, payload.targetVersion);
+    fs.mkdirSync(payload.stagingPrefix, { recursive: true });
+    await installPackage(payload, payload.targetVersion, payload.stagingPrefix);
+    verifyInstalledVersion(payload, payload.targetVersion, payload.stagingPackageRoot);
+    const preparedAt = new Date().toISOString();
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'ready-to-restart', {
+      preparedAt,
+    }));
+    appendLog(payload.logPath, `Farming ${payload.targetVersion} is ready to restart`);
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    appendLog(payload.logPath, `Update preparation failed: ${message}`);
+    try {
+      fs.rmSync(payload.stagingPrefix, { recursive: true, force: true });
+    } catch (cleanupError) {
+      appendLog(payload.logPath, `Update preparation cleanup failed: ${cleanupError.message || cleanupError}`);
+    }
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'failed', {
+      error: message,
+      completedAt: new Date().toISOString(),
+    }));
+  }
+}
+
+async function applyNpmUpdate(payload) {
+  const backupRoot = path.join(
+    path.dirname(payload.packageRoot),
+    `.${path.basename(payload.packageRoot)}.backup-${process.pid}`,
+  );
+  let stoppedOldServer = false;
+  let movedOldPackage = false;
+  let movedNewPackage = false;
+  try {
+    verifyInstalledVersion(payload, payload.previousVersion, payload.packageRoot);
+    verifyInstalledVersion(payload, payload.targetVersion, payload.stagingPackageRoot);
+    if (fs.existsSync(backupRoot)) throw new Error(`npm update backup already exists: ${backupRoot}`);
 
-    writeJsonAtomic(payload.stateFile, stateFor(payload, 'restarting'));
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'restarting', {
+      preparedAt: payload.preparedAt,
+    }));
+    await new Promise(resolve => setTimeout(resolve, 1_000));
     await stopProcess(Number(payload.serverPid));
+    stoppedOldServer = true;
+    fs.renameSync(payload.packageRoot, backupRoot);
+    movedOldPackage = true;
+    fs.renameSync(payload.stagingPackageRoot, payload.packageRoot);
+    movedNewPackage = true;
     await startServer(payload);
 
     writeJsonAtomic(payload.stateFile, stateFor(payload, 'succeeded', {
+      preparedAt: payload.preparedAt,
       completedAt: new Date().toISOString(),
     }));
     appendLog(payload.logPath, `Farming updated to ${payload.targetVersion}`);
+    try {
+      fs.rmSync(backupRoot, { recursive: true, force: true });
+      fs.rmSync(payload.stagingPrefix, { recursive: true, force: true });
+    } catch (cleanupError) {
+      appendLog(payload.logPath, `Update cleanup failed: ${cleanupError.message || cleanupError}`);
+    }
   } catch (error) {
     const message = error && error.message ? error.message : String(error);
-    appendLog(payload.logPath, `Update failed: ${message}`);
+    appendLog(payload.logPath, `Update apply failed: ${message}`);
 
-    if (!isProcessRunning(Number(payload.serverPid))) {
+    if (stoppedOldServer || !isProcessRunning(Number(payload.serverPid))) {
       try {
-        writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolling-back', { error: message }));
-        await installPackage(payload, payload.previousVersion);
-        verifyInstalledVersion(payload, payload.previousVersion);
+        writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolling-back', {
+          preparedAt: payload.preparedAt,
+          error: message,
+        }));
+        if (movedNewPackage && fs.existsSync(payload.packageRoot)) {
+          fs.mkdirSync(path.dirname(payload.stagingPackageRoot), { recursive: true });
+          fs.renameSync(payload.packageRoot, payload.stagingPackageRoot);
+        }
+        if (movedOldPackage && fs.existsSync(backupRoot)) {
+          fs.renameSync(backupRoot, payload.packageRoot);
+        }
+        verifyInstalledVersion(payload, payload.previousVersion, payload.packageRoot);
         await startServer(payload, payload.previousVersion);
         writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolled-back', {
           version: payload.previousVersion,
           attemptedVersion: payload.targetVersion,
+          preparedAt: payload.preparedAt,
           error: message,
           completedAt: new Date().toISOString(),
         }));
         appendLog(payload.logPath, `Rolled back to ${payload.previousVersion}`);
+        try {
+          fs.rmSync(payload.stagingPrefix, { recursive: true, force: true });
+        } catch (cleanupError) {
+          appendLog(payload.logPath, `Rollback cleanup failed: ${cleanupError.message || cleanupError}`);
+        }
         return;
       } catch (rollbackError) {
         const rollbackMessage = rollbackError && rollbackError.message ? rollbackError.message : String(rollbackError);
@@ -228,12 +300,19 @@ async function runNpmUpdate(rawPayload) {
     }
 
     writeJsonAtomic(payload.stateFile, stateFor(payload, 'failed', {
+      preparedAt: payload.preparedAt,
       error: message,
       completedAt: new Date().toISOString(),
     }));
   }
 }
 
+async function runNpmUpdate(rawPayload) {
+  const payload = validatePayload(rawPayload);
+  if (payload.action === 'prepare') return prepareNpmUpdate(payload);
+  return applyNpmUpdate(payload);
+}
+
 if (require.main === module) {
   let payload;
   try {

package/backend/provider-adapters.js

@@ -221,7 +221,7 @@ const PROVIDER_ADAPTERS = Object.freeze([
     terminalResumeArgs: (args, sessionId) => ['resume', sessionId, ...args],
     acp: { packageName: '@agentclientprotocol/codex-acp', version: '1.1.4' },
     prepareAcpEnvironment: codexAcpEnvironment,
-    capabilities: { runtimeSwitch: true, terminalProfile: true, goals: false },
+    capabilities: { runtimeSwitch: true, terminalProfile: true, goals: false, sessionFork: true },
   },
   {
     id: 'claude',
@@ -233,8 +233,12 @@ const PROVIDER_ADAPTERS = Object.freeze([
     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 },
+    acp: {
+      packageName: '@agentclientprotocol/claude-agent-acp',
+      version: '0.59.0',
+      forkMode: 'target-process',
+    },
+    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false, sessionFork: true },
   },
   {
     id: 'opencode',
@@ -263,7 +267,7 @@ const PROVIDER_ADAPTERS = Object.freeze([
         args: ['acp', '--cwd', path.resolve(options.cwd || process.cwd())],
       }),
     },
-    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false },
+    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false, sessionFork: true },
   },
   {
     id: 'qoder',
@@ -279,7 +283,7 @@ const PROVIDER_ADAPTERS = Object.freeze([
       version: 'native',
       launch: options => ({ command: options.executable || 'qodercli', args: ['--acp'] }),
     },
-    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false },
+    capabilities: { runtimeSwitch: true, terminalProfile: false, goals: false, sessionFork: true },
   },
 ]);
 
@@ -303,10 +307,13 @@ function listProviderAdapters() {
 function providerCapabilities(provider) {
   const adapter = getProviderAdapter(provider);
   return {
-    supportedRuntimes: adapter ? [...adapter.supportedRuntimes] : ['terminal'],
+    supportedRuntimes: adapter
+      ? adapter.supportedRuntimes.filter(runtime => runtime !== 'json')
+      : ['terminal'],
     runtimeSwitch: adapter?.capabilities?.runtimeSwitch === true,
     terminalProfile: adapter?.capabilities?.terminalProfile === true,
     goals: adapter?.capabilities?.goals === true,
+    sessionFork: adapter?.capabilities?.sessionFork === true,
     ...(adapter
       ? chatCapabilitiesForProvider(provider)
       : { chatRuntime: '', supportsChat: false, supportsSteer: false }),
@@ -317,6 +324,10 @@ function providerSupportsRuntime(provider, runtime) {
   return getProviderAdapter(provider)?.supportedRuntimes.includes(runtime) === true;
 }
 
+function providerAcpForkMode(provider) {
+  return getProviderAdapter(provider)?.acp?.forkMode || 'source-then-load';
+}
+
 function applyProviderHomeEnvironment(env, provider, homePath) {
   const key = getProviderAdapter(provider)?.homeEnvKey;
   if (key && homePath) env[key] = homePath;
@@ -332,6 +343,7 @@ module.exports = {
   applyProviderHomeEnvironment,
   isFreshAcpSessionSource,
   listProviderAdapters,
+  providerAcpForkMode,
   providerCapabilities,
   providerForProgram,
   providerSupportsRuntime,

package/backend/review-session-service.js

@@ -178,6 +178,18 @@ class ReviewSessionService {
     this.reviewStateStore = reviewStateStore;
     this.resolveAgentRoot = options.resolveAgentRoot;
     this.resolveAcpReviewChanges = options.resolveAcpReviewChanges;
+    this.refreshQueues = new Map();
+  }
+
+  enqueueRefresh(reviewId, operation) {
+    const previous = this.refreshQueues.get(reviewId) || Promise.resolve();
+    const next = previous.catch(() => {}).then(operation);
+    this.refreshQueues.set(reviewId, next);
+    const cleanup = () => {
+      if (this.refreshQueues.get(reviewId) === next) this.refreshQueues.delete(reviewId);
+    };
+    next.then(cleanup, cleanup);
+    return next;
   }
 
   async git(root, args, options = {}) {
@@ -373,24 +385,26 @@ class ReviewSessionService {
 
   async refresh(reviewId) {
     if (!REVIEW_ID_PATTERN.test(reviewId)) throw new ReviewSessionError('review session id is invalid');
-    const current = this.sessionStore.get(reviewId);
-    if (!current) throw new ReviewSessionError('review session not found', 404);
-    const paths = await this.capturePaths(current.root, current);
-    const tree = await this.captureStableTree(current.root, paths);
-    const previous = current.revisions[current.revisions.length - 1];
-    if (previous.tree === tree) return { ...publicRevision(current, previous), changedPaths: [], unchanged: true };
-    const nextNumber = previous.number + 1;
-    const changedPaths = await this.changedPaths(current.root, previous.tree, tree);
-    await this.keepRevision(current.root, reviewId, nextNumber, tree);
-    const result = this.sessionStore.appendRevision(reviewId, tree);
-    const next = result.session.revisions[result.session.revisions.length - 1];
-    this.reviewStateStore?.inheritPatchset?.({
-      changedPaths,
-      nextPatchset: tree,
-      previousPatchset: previous.tree,
-      reviewId,
+    return this.enqueueRefresh(reviewId, async () => {
+      const current = this.sessionStore.get(reviewId);
+      if (!current) throw new ReviewSessionError('review session not found', 404);
+      const paths = await this.capturePaths(current.root, current);
+      const tree = await this.captureStableTree(current.root, paths);
+      const previous = current.revisions[current.revisions.length - 1];
+      if (previous.tree === tree) return { ...publicRevision(current, previous), changedPaths: [], unchanged: true };
+      const nextNumber = previous.number + 1;
+      const changedPaths = await this.changedPaths(current.root, previous.tree, tree);
+      await this.keepRevision(current.root, reviewId, nextNumber, tree);
+      const result = this.sessionStore.appendRevision(reviewId, tree);
+      const next = result.session.revisions[result.session.revisions.length - 1];
+      this.reviewStateStore?.inheritPatchset?.({
+        changedPaths,
+        nextPatchset: tree,
+        previousPatchset: previous.tree,
+        reviewId,
+      });
+      return { ...publicRevision(result.session, next), changedPaths, unchanged: false };
     });
-    return { ...publicRevision(result.session, next), changedPaths, unchanged: false };
   }
 
   get(reviewId) {