farming-code 2.2.30 → 2.2.32

package/backend/native-session-engine.js

@@ -1,268 +0,0 @@
-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;
-  return code === 'ENOENT' || code === 'ECONNREFUSED' || code === 'ECONNRESET' || code === 'EPIPE' || code === 'ETIMEDOUT';
-}
-
-function nativeSessionId(entry, fallback = '') {
-  if (!entry || typeof entry !== 'object') return 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();
-    this.client = options.client || new NativePtyHostClient({
-      configDir: options.configDir,
-      socketPath: options.socketPath,
-      preserveHostOnDisconnect: options.preserveHostOnDispose === true,
-    });
-    this.preserveHostOnDispose = options.preserveHostOnDispose === true;
-    this.activeSessionIds = new Set();
-    this.activeSessionEpochs = new Map();
-    this.hostDisconnectGeneration = 0;
-    this.reconciledHostDisconnectGeneration = 0;
-    this.hostDisconnectReconcilePromise = null;
-    this.bindClientEvents();
-  }
-
-  bindClientEvents() {
-    [
-      'session-started',
-      'session-output',
-      'session-transition',
-      'session-sync',
-      'session-preview',
-      'session-title',
-      'session-activity',
-      'session-busy-state',
-      'session-exited',
-      'session-error',
-    ].forEach(eventName => {
-      this.client.on(eventName, payload => {
-        this.observeSessionLifecycleEvent(eventName, payload || {});
-        this.emit(eventName, payload);
-      });
-    });
-    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);
-      });
-    });
-    this.client.on('host-exit', ({ code, signal } = {}) => {
-      const suffix = [
-        code == null ? '' : `code ${code}`,
-        signal ? `signal ${signal}` : '',
-      ].filter(Boolean).join(', ');
-      this.failActiveSessions(`Native pty host exited${suffix ? ` (${suffix})` : ''}`);
-    });
-  }
-
-  observeSessionLifecycleEvent(eventName, payload) {
-    const sessionId = nativeSessionId(payload);
-    if (!sessionId) return;
-    if (eventName === 'session-started') {
-      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.hostDisconnectReconcilePromise) return this.hostDisconnectReconcilePromise;
-    this.hostDisconnectReconcilePromise = (async () => {
-      while (this.reconciledHostDisconnectGeneration < this.hostDisconnectGeneration) {
-        const generation = this.hostDisconnectGeneration;
-        const expectedSessions = [...this.activeSessionIds].map(sessionId => ({
-          sessionId,
-          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.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,
-      });
-    }
-  }
-
-  getSessionSource() {
-    return 'buffer';
-  }
-
-  async createSession(options) {
-    // Prepare the startup plan in the server process. A native PTY host may
-    // deliberately survive a server restart, so it must not retain authority
-    // over how newly created shells source rc files or choose a prompt.
-    const preparedOptions = normalizeShellSessionOptions(options);
-    preparedOptions.shellIntegrationPrepared = true;
-    let result;
-    try {
-      result = await this.client.request('createSession', { options: preparedOptions });
-    } catch (error) {
-      cleanupShellBusyIntegration(preparedOptions.shellBusyIntegration);
-      throw error;
-    }
-    const sessionId = nativeSessionId(result, preparedOptions.agentId);
-    if (sessionId) this.activeSessionIds.add(sessionId);
-    return result;
-  }
-
-  async sendInput(sessionId, input, options = {}) {
-    return this.client.request('sendInput', {
-      sessionId,
-      input,
-      expectedRuntimeEpoch: options.expectedRuntimeEpoch || '',
-    }, {
-      retryOnDisconnect: false,
-    });
-  }
-
-  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, 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;
-  }
-
-  async getSessionState(sessionId) {
-    return this.client.request('getSessionState', { sessionId });
-  }
-
-  async getSessionAttachCheckpoint(sessionId) {
-    return this.client.request('getSessionAttachCheckpoint', { sessionId });
-  }
-
-  async getSessionPreview(sessionId) {
-    return this.client.request('getSessionPreview', { sessionId });
-  }
-
-  async recoverSessions(options = {}) {
-    const startHost = options.startHost === true;
-    if (
-      !startHost &&
-      this.client &&
-      typeof this.client.canConnectWithoutStartingHost === 'function' &&
-      !this.client.canConnectWithoutStartingHost()
-    ) {
-      return [];
-    }
-    try {
-      const recovered = await this.client.request('recoverSessions', {}, { startHost });
-      for (const entry of recovered || []) {
-        const sessionId = nativeSessionId(entry);
-        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) {
-      if (isRecoverableConnectError(error)) return [];
-      throw error;
-    }
-  }
-
-  async updateSessionMetadata(sessionId, patch) {
-    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();
-  }
-}
-
-module.exports = NativeSessionEngine;

package/backend/network.js

@@ -1,23 +0,0 @@
-const os = require('os');
-
-function getLocalIPs() {
-  const interfaces = os.networkInterfaces();
-  const ips = [];
-
-  for (const [, addrs] of Object.entries(interfaces)) {
-    if (!addrs) continue;
-    for (const addr of addrs) {
-      if (addr.internal) continue;
-      if (addr.family !== 'IPv4') continue;
-      ips.push(addr.address);
-    }
-  }
-
-  return ips;
-}
-
-function getPrimaryLocalIP() {
-  return getLocalIPs()[0] || '127.0.0.1';
-}
-
-module.exports = { getLocalIPs, getPrimaryLocalIP };

package/backend/npm-update-helper.js

@@ -1,374 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-const {
-  matchingProcessIdentity,
-  readServerProcessIdentity,
-} = require('./server-process-identity');
-
-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 runCommand(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const logFd = fs.openSync(options.logPath, 'a');
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      env: options.env,
-      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(`${command} exited with ${signal || code}`));
-    });
-  });
-}
-
-function isProcessRunning(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    if (error?.code === 'EPERM' || error?.code === 'EACCES') return true;
-    return false;
-  }
-}
-
-async function stopProcess(pid, expectedIdentity, timeoutMs = 15_000) {
-  if (!isProcessRunning(pid)) return;
-  const currentIdentity = await readServerProcessIdentity(pid);
-  if (!matchingProcessIdentity(expectedIdentity, currentIdentity)) {
-    throw new Error(`Refusing to stop Farming server ${pid}: process identity changed`);
-  }
-  try {
-    process.kill(pid, 'SIGKILL');
-  } catch (error) {
-    if (error?.code === 'EPERM' || error?.code === 'EACCES') {
-      throw new Error(
-        `Farming cannot stop server ${pid} because the update helper lacks permission. `
-        + 'Use the operating-system user that owns this process (or an administrator) to stop and restart Farming, then retry the update.',
-        { cause: error },
-      );
-    }
-    if (error?.code !== 'ESRCH') throw error;
-  }
-  const startedAt = Date.now();
-  while (matchingProcessIdentity(expectedIdentity, await readServerProcessIdentity(pid))) {
-    if (Date.now() - startedAt >= timeoutMs) {
-      throw new Error(
-        `Farming server ${pid} did not exit after SIGKILL. `
-        + 'Stop and restart Farming manually, then retry the update.',
-      );
-    }
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-}
-
-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', 'stagingPrefix', 'stagingPackageRoot']) {
-    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');
-    }
-  }
-  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;
-}
-
-function stateFor(payload, phase, extra = {}) {
-  return {
-    method: 'npm',
-    phase,
-    version: payload.targetVersion,
-    previousVersion: payload.previousVersion,
-    packageName: payload.packageName,
-    startedAt: payload.startedAt,
-    logPath: payload.logPath,
-    stagingPrefix: payload.stagingPrefix,
-    stagingPackageRoot: payload.stagingPackageRoot,
-    ...extra,
-  };
-}
-
-function startArguments(payload) {
-  const args = [
-    payload.cliPath,
-    'daemon',
-    '--port', String(payload.port),
-    '--base-path', payload.basePath,
-    '--config-dir', payload.configDir,
-  ];
-  if (payload.serverHome) args.push('--home', payload.serverHome);
-  if (payload.disableAuth) args.push('--no-auth');
-  return args;
-}
-
-function commandEnvironment() {
-  const env = { ...process.env };
-  delete env.FARMING_NPM_UPDATE_PAYLOAD;
-  delete env.FARMING_RUN_SERVER;
-  delete env.FARMING_RUN_NATIVE_PTY_HOST;
-  return env;
-}
-
-async function installPackage(payload, version, npmPrefix = payload.npmPrefix) {
-  const packageSpec = `${payload.packageName}@${version}`;
-  return installPackageFromRegistry(payload, packageSpec, '', npmPrefix);
-}
-
-function verifyInstalledVersion(payload, expectedVersion, packageRoot = payload.packageRoot) {
-  const packageJsonPath = path.join(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 = '', npmPrefix = payload.npmPrefix) {
-  appendLog(payload.logPath, `Installing ${packageSpec}${registryUrl ? ' from the update-status registry' : ''}`);
-  const args = ['install', '--global'];
-  if (npmPrefix) args.push('--prefix', npmPrefix);
-  if (registryUrl) args.push('--registry', registryUrl);
-  args.push(packageSpec, '--no-audit', '--no-fund');
-  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, npmPrefix);
-    }
-    throw error;
-  }
-}
-
-async function startServer(payload, version = payload.targetVersion) {
-  appendLog(payload.logPath, `Starting Farming ${version}`);
-  await runCommand(payload.nodePath, startArguments(payload), {
-    cwd: payload.configDir,
-    env: commandEnvironment(),
-    logPath: payload.logPath,
-  });
-}
-
-async function prepareNpmUpdate(payload) {
-  try {
-    writeJsonAtomic(payload.stateFile, stateFor(payload, 'installing'));
-    fs.mkdirSync(payload.stagingPrefix, { recursive: true });
-    await installPackage(payload, payload.targetVersion, payload.stagingPrefix);
-    verifyInstalledVersion(payload, payload.targetVersion, payload.stagingPackageRoot);
-    writeJsonAtomic(payload.stateFile, stateFor(payload, 'preparing-runtimes'));
-    appendLog(payload.logPath, `Preparing Farming ${payload.targetVersion} startup dependencies`);
-    await runCommand(payload.nodePath, [
-      path.join(payload.stagingPackageRoot, 'bin', 'farming'),
-      'runtime',
-      'prepare',
-      '--config-dir',
-      payload.configDir,
-    ], {
-      cwd: payload.configDir,
-      env: commandEnvironment(),
-      logPath: payload.logPath,
-    });
-    const preparedAt = new Date().toISOString();
-    writeJsonAtomic(payload.stateFile, stateFor(payload, 'ready-to-restart', {
-      preparedAt,
-      runtimePreparedAt: 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', {
-      preparedAt: payload.preparedAt,
-    }));
-    await new Promise(resolve => setTimeout(resolve, 1_000));
-    await stopProcess(Number(payload.serverPid), payload.serverProcessIdentity);
-    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 apply failed: ${message}`);
-
-    if (stoppedOldServer || !isProcessRunning(Number(payload.serverPid))) {
-      try {
-        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);
-        writeJsonAtomic(payload.stateFile, stateFor(payload, 'failed', {
-          error: `${message}; rollback failed: ${rollbackMessage}`,
-          completedAt: new Date().toISOString(),
-        }));
-        return;
-      }
-    }
-
-    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 {
-    payload = JSON.parse(process.env.FARMING_NPM_UPDATE_PAYLOAD || '');
-  } catch {
-    console.error('Invalid FARMING_NPM_UPDATE_PAYLOAD');
-    process.exit(1);
-  }
-  runNpmUpdate(payload).catch(error => {
-    console.error(error.message || error);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  isProcessRunning,
-  runNpmUpdate,
-  stopProcess,
-  validatePayload,
-  verifyInstalledVersion,
-  writeJsonAtomic,
-};