farming-code 2.2.8 → 2.2.11

package/backend/main-page-session.js

@@ -14,9 +14,12 @@ function isSafeSessionId(sessionId) {
 }
 
 function mainPageAgentSessionKey(provider, sessionId, providerHomeId = '') {
+  const normalizedProvider = normalizeMainPageSessionProvider(provider);
+  const normalizedSessionId = String(sessionId || '').trim();
+  if (!normalizedProvider || !normalizedSessionId) return '';
   const homeId = String(providerHomeId || '').trim();
-  if (homeId && homeId !== 'default') return `agent-session:${provider}:home:${homeId}:${sessionId}`;
-  return `agent-session:${provider}:${sessionId}`;
+  if (homeId && homeId !== 'default') return `agent-session:${normalizedProvider}:home:${homeId}:${normalizedSessionId}`;
+  return `agent-session:${normalizedProvider}:${normalizedSessionId}`;
 }
 
 function mainPageAgentSessionFromKey(key) {

package/backend/native-pty-controller-generation.js

@@ -0,0 +1,106 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const storageLayout = require('./storage-layout');
+
+const LOCK_RETRY_MS = 10;
+const LOCK_TIMEOUT_MS = 5000;
+const STALE_LOCK_MS = 30000;
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function positiveGeneration(value) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+async function acquireGenerationLock(lockDir) {
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      await fs.promises.mkdir(lockDir);
+      return;
+    } catch (error) {
+      if (!error || error.code !== 'EEXIST') throw error;
+      try {
+        const stat = await fs.promises.stat(lockDir);
+        if (Date.now() - stat.mtimeMs > STALE_LOCK_MS) {
+          await fs.promises.rm(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch (statError) {
+        if (!statError || statError.code !== 'ENOENT') throw statError;
+      }
+      await delay(LOCK_RETRY_MS);
+    }
+  }
+  throw new Error('Timed out allocating native PTY controller generation');
+}
+
+async function allocateGeneration(generationFile, lockDir) {
+  const root = path.dirname(generationFile);
+  await fs.promises.mkdir(root, { recursive: true });
+  await acquireGenerationLock(lockDir);
+  try {
+    let current = 0;
+    try {
+      current = positiveGeneration(await fs.promises.readFile(generationFile, 'utf8'));
+    } catch (error) {
+      if (!error || error.code !== 'ENOENT') throw error;
+    }
+    const generation = current + 1;
+    const temporary = `${generationFile}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    await fs.promises.writeFile(temporary, `${generation}\n`, { mode: 0o600 });
+    await fs.promises.rename(temporary, generationFile);
+    return generation;
+  } finally {
+    await fs.promises.rm(lockDir, { recursive: true, force: true });
+  }
+}
+
+async function allocateNativePtyControllerGeneration(configDir) {
+  const root = path.resolve(configDir);
+  const generationFile = storageLayout.nativePtyControllerGenerationFile(root);
+  const lockDir = storageLayout.nativePtyControllerGenerationLockDir(root);
+  return allocateGeneration(generationFile, lockDir);
+}
+
+async function allocateNativePtyRuntimeGeneration(configDir) {
+  const root = path.resolve(configDir);
+  return allocateGeneration(
+    storageLayout.nativePtyRuntimeGenerationFile(root),
+    storageLayout.nativePtyRuntimeGenerationLockDir(root),
+  );
+}
+
+function formatNativePtyRuntimeEpoch(generation, id = crypto.randomUUID()) {
+  const normalized = positiveGeneration(generation);
+  if (!normalized) throw new Error('Native PTY runtime generation must be positive');
+  return `farming-runtime-v1:${String(normalized).padStart(20, '0')}:${id}`;
+}
+
+function nativePtyRuntimeEpochGeneration(runtimeEpoch) {
+  const match = /^farming-runtime-v1:(\d{20}):/.exec(String(runtimeEpoch || ''));
+  if (!match) return null;
+  const generation = Number(match[1]);
+  return Number.isSafeInteger(generation) && generation > 0 ? generation : null;
+}
+
+function compareNativePtyRuntimeEpochs(left, right) {
+  if (left === right) return 0;
+  const leftGeneration = nativePtyRuntimeEpochGeneration(left);
+  const rightGeneration = nativePtyRuntimeEpochGeneration(right);
+  if (leftGeneration === null || rightGeneration === null || leftGeneration === rightGeneration) return null;
+  return leftGeneration < rightGeneration ? -1 : 1;
+}
+
+module.exports = {
+  allocateNativePtyControllerGeneration,
+  allocateNativePtyRuntimeGeneration,
+  compareNativePtyRuntimeEpochs,
+  formatNativePtyRuntimeEpoch,
+  nativePtyRuntimeEpochGeneration,
+  positiveGeneration,
+};

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

@@ -1,24 +1,38 @@
 const EventEmitter = require('events');
 const { spawn } = require('child_process');
+const crypto = require('crypto');
 const fs = require('fs');
 const net = require('net');
 const path = require('path');
 const { nativePtyHostSocketPath } = require('./native-pty-host-path');
+const {
+  nativePtyHostRuntimeIdentity,
+  nativePtyHostRuntimeIdentityMatches,
+  normalizeNativePtyHostRuntimeIdentity,
+} = require('./native-pty-host-identity');
+const {
+  allocateNativePtyControllerGeneration,
+  positiveGeneration,
+} = require('./native-pty-controller-generation');
 const storageLayout = require('./storage-layout');
 
 const DEFAULT_CONNECT_RETRIES = 300;
 const DEFAULT_CONNECT_RETRY_MS = 50;
 const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+const DEFAULT_HOST_ROTATION_TIMEOUT_MS = 10000;
 const PACKAGED_NATIVE_PTY_HOST_ENV = 'FARMING_RUN_NATIVE_PTY_HOST';
 const RECONNECT_RETRYABLE_METHODS = new Set([
   'ping',
   'createSession',
+  'claimSessionController',
+  'renewSessionController',
   'resizeSession',
-  'clearBuffer',
   'killSession',
+  'getSessionAttachCheckpoint',
   'getSessionState',
   'getSessionPreview',
   'recoverSessions',
+  'serializeTerminalState',
   'updateSessionMetadata',
 ]);
 const PACKAGED_NATIVE_HOST_ENV_KEYS = new Set([
@@ -111,6 +125,13 @@ function hostConnectErrorMessage(error, spawned, logPath) {
   return `Native PTY host is not reachable${code}.${logHint}`;
 }
 
+function runtimeIdentityLabel(value) {
+  const identity = normalizeNativePtyHostRuntimeIdentity(value);
+  if (!identity) return 'legacy/unknown';
+  const version = identity.version ? `v${identity.version} ` : '';
+  return `${version}protocol ${identity.protocolVersion} build ${identity.buildId.slice(0, 12)}`;
+}
+
 function nativeHostSpawnCommand(hostScript, env) {
   const nodeBin = env.FARMING_NODE_BIN || process.execPath;
   const ldPath = env.FARMING_NODE_LD || '';
@@ -148,7 +169,22 @@ class NativePtyHostClient extends EventEmitter {
     this.connectRetryMs = options.connectRetryMs || DEFAULT_CONNECT_RETRY_MS;
     this.requestTimeoutMs = options.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
     this.hostLogPath = options.hostLogPath || this.defaultHostLogPath();
+    this.expectedRuntimeIdentity = options.expectedRuntimeIdentity || nativePtyHostRuntimeIdentity();
+    this.controllerIdentity = options.controllerIdentity
+      ? {
+        id: String(options.controllerIdentity.id || ''),
+        generation: positiveGeneration(options.controllerIdentity.generation),
+      }
+      : {
+        id: crypto.randomUUID(),
+        generation: 0,
+      };
+    this.controllerIdentityReady = null;
+    this.hostRotationTimeoutMs = options.hostRotationTimeoutMs || DEFAULT_HOST_ROTATION_TIMEOUT_MS;
+    this.connectedHostInfo = null;
+    this.runtimeRotationInfo = null;
     this.socket = null;
+    this.socketGeneration = 0;
     this.buffer = '';
     this.nextRequestId = 1;
     this.pending = new Map();
@@ -281,8 +317,11 @@ class NativePtyHostClient extends EventEmitter {
   }
 
   async connectWithRetries(options = {}) {
+    await this.ensureControllerIdentity();
     const allowHostStart = options.startHost !== false;
     let spawned = false;
+    let rotatedMismatchedHost = false;
+    let pendingRotationInfo = null;
     let lastError = null;
 
     for (let attempt = 0; attempt < this.connectRetries; attempt += 1) {
@@ -291,14 +330,51 @@ class NativePtyHostClient extends EventEmitter {
       }
       try {
         await this.connectOnce();
-        await this.request('ping', {}, { ensureConnected: false, timeoutMs: 3000 });
+        const hostInfo = await this.request('ping', {}, { ensureConnected: false, timeoutMs: 3000 });
+        if (!nativePtyHostRuntimeIdentityMatches(this.expectedRuntimeIdentity, hostInfo?.runtimeIdentity)) {
+          if (rotatedMismatchedHost) {
+            const error = new Error(
+              `Native PTY host runtime still mismatches after rotation: expected ` +
+              `${runtimeIdentityLabel(this.expectedRuntimeIdentity)}, got ${runtimeIdentityLabel(hostInfo?.runtimeIdentity)}`
+            );
+            error.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+            throw error;
+          }
+          const serializedTerminalState = await this.rotateMismatchedHost(hostInfo);
+          pendingRotationInfo = {
+            rotatedAt: Date.now(),
+            previous: normalizeNativePtyHostRuntimeIdentity(hostInfo?.runtimeIdentity),
+            current: normalizeNativePtyHostRuntimeIdentity(this.expectedRuntimeIdentity),
+            previousPid: Number(hostInfo?.pid) || null,
+            serializedTerminalState: typeof serializedTerminalState === 'string'
+              ? serializedTerminalState
+              : '',
+          };
+          rotatedMismatchedHost = true;
+          spawned = true;
+          continue;
+        }
+        await this.requestOnce('registerController', {
+          identity: this.controllerIdentity,
+        }, {
+          ensureConnected: false,
+          retryOnDisconnect: false,
+          timeoutMs: 3000,
+        });
+        this.connectedHostInfo = hostInfo || null;
+        if (pendingRotationInfo) {
+          this.runtimeRotationInfo = pendingRotationInfo;
+        }
         return;
       } catch (error) {
         lastError = error;
+        if (error && error.code === 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH') {
+          throw error;
+        }
         if (this.hostStartError) {
           lastError = this.hostStartError;
         }
-        if (!allowHostStart && isConnectRetryable(error)) {
+        if (!allowHostStart && !rotatedMismatchedHost && isConnectRetryable(error)) {
           throw error;
         }
         if (allowHostStart && !spawned && isConnectRetryable(error)) {
@@ -330,26 +406,217 @@ class NativePtyHostClient extends EventEmitter {
     throw lastError || new Error('Failed to connect to native pty host');
   }
 
+  async ensureControllerIdentity() {
+    if (this.controllerIdentity.generation > 0) {
+      return this.controllerIdentity;
+    }
+    if (!this.controllerIdentityReady) {
+      const configRoot = this.configDir || path.dirname(this.socketPath);
+      this.controllerIdentityReady = allocateNativePtyControllerGeneration(configRoot)
+        .then((generation) => {
+          this.controllerIdentity.generation = generation;
+          return this.controllerIdentity;
+        })
+        .catch((error) => {
+          this.controllerIdentityReady = null;
+          throw error;
+        });
+    }
+    return this.controllerIdentityReady;
+  }
+
+  async waitForHostRelease() {
+    const deadline = Date.now() + this.hostRotationTimeoutMs;
+    if (process.platform === 'win32') {
+      await delay(Math.min(250, this.hostRotationTimeoutMs));
+      return;
+    }
+    while (Date.now() < deadline) {
+      const childReleased = !this.hostChild ||
+        this.hostChild.exitCode !== null ||
+        this.hostChild.signalCode !== null;
+      if (!fs.existsSync(this.socketPath) && childReleased) return;
+      await delay(50);
+    }
+    const error = new Error('Timed out waiting for the previous native PTY host to stop');
+    error.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+    throw error;
+  }
+
+  async resumePreparedHostRotation(preparationToken = '') {
+    if (!this.socket || this.socket.destroyed) {
+      await this.connectOnce();
+      await this.requestOnce('registerController', {
+        identity: this.controllerIdentity,
+      }, {
+        ensureConnected: false,
+        retryOnDisconnect: false,
+        timeoutMs: 1000,
+      });
+    }
+    return this.requestOnce('resumeTerminalState', {
+      preparationToken,
+    }, {
+      ensureConnected: false,
+      retryOnDisconnect: false,
+      timeoutMs: 1000,
+    });
+  }
+
+  async rotateMismatchedHost(hostInfo) {
+    const expected = runtimeIdentityLabel(this.expectedRuntimeIdentity);
+    const actual = runtimeIdentityLabel(hostInfo && hostInfo.runtimeIdentity);
+    console.warn(`Rotating native PTY host runtime: expected ${expected}, connected to ${actual}`);
+    this.emit('host-runtime-mismatch', {
+      expected: this.expectedRuntimeIdentity,
+      actual: hostInfo && hostInfo.runtimeIdentity || null,
+      pid: Number(hostInfo && hostInfo.pid) || null,
+    });
+
+    await this.requestOnce('registerController', {
+      identity: this.controllerIdentity,
+    }, {
+      ensureConnected: false,
+      retryOnDisconnect: false,
+      timeoutMs: 3000,
+    });
+
+    let serializedTerminalState = '';
+    let preparationToken = '';
+    try {
+      const preparation = await this.requestOnce('serializeTerminalState', {}, {
+        ensureConnected: false,
+        retryOnDisconnect: false,
+        timeoutMs: Math.min(5000, this.hostRotationTimeoutMs),
+      });
+      if (
+        preparation &&
+        typeof preparation === 'object' &&
+        typeof preparation.preparationToken === 'string' &&
+        preparation.preparationToken &&
+        typeof preparation.serializedTerminalState === 'string'
+      ) {
+        preparationToken = preparation.preparationToken;
+        serializedTerminalState = preparation.serializedTerminalState;
+      } else if (typeof preparation === 'string') {
+        const recovered = await this.requestOnce('recoverSessions', {}, {
+          ensureConnected: false,
+          retryOnDisconnect: false,
+          timeoutMs: Math.min(3000, this.hostRotationTimeoutMs),
+        });
+        if (Array.isArray(recovered) && recovered.length === 0) {
+          serializedTerminalState = preparation;
+        } else {
+          throw new Error('The old native PTY host cannot commit a transactional terminal checkpoint');
+        }
+      } else {
+        throw new Error('The native PTY host returned an invalid rotation checkpoint');
+      }
+    } catch (error) {
+      await this.resumePreparedHostRotation(preparationToken).catch(() => {});
+      const recovered = await this.requestOnce('recoverSessions', {}, {
+        ensureConnected: false,
+        retryOnDisconnect: false,
+        timeoutMs: Math.min(3000, this.hostRotationTimeoutMs),
+      }).catch(() => null);
+      if (Array.isArray(recovered) && recovered.length === 0) {
+        serializedTerminalState = '';
+        preparationToken = '';
+      } else {
+        const mismatchError = new Error(
+          `Cannot rotate incompatible native PTY host (${actual}) without a committed terminal checkpoint`
+        );
+        mismatchError.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+        mismatchError.cause = error;
+        throw mismatchError;
+      }
+    }
+
+    const socket = this.socket;
+    if (socket) this.suppressedDisconnectSockets.add(socket);
+    let shutdownUncertain = false;
+    try {
+      await this.requestOnce('shutdownHost', {
+        controller: this.controllerIdentity,
+        preparationToken,
+      }, {
+        ensureConnected: false,
+        retryOnDisconnect: false,
+        timeoutMs: Math.min(5000, this.hostRotationTimeoutMs),
+      });
+    } catch (error) {
+      if (!isConnectRetryable(error)) {
+        await this.resumePreparedHostRotation(preparationToken).catch(() => {});
+        const mismatchError = new Error(
+          `Cannot rotate incompatible native PTY host (${actual}); stop the old host and restart Farming`
+        );
+        mismatchError.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+        mismatchError.cause = error;
+        throw mismatchError;
+      }
+      shutdownUncertain = true;
+    } finally {
+      if (this.socket === socket) {
+        this.socket = null;
+        this.buffer = '';
+      }
+      if (socket && !socket.destroyed) socket.destroy();
+      this.connectedHostInfo = null;
+    }
+
+    try {
+      await this.waitForHostRelease();
+    } catch (error) {
+      if (shutdownUncertain) {
+        try {
+          await this.resumePreparedHostRotation(preparationToken);
+        } catch {
+          // The old host may have exited after the release timeout. Do not
+          // start a second host until the socket and child are actually gone.
+        }
+      }
+      const mismatchError = new Error(
+        `Cannot confirm shutdown of incompatible native PTY host (${actual}); restart Farming after the old host exits`
+      );
+      mismatchError.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+      mismatchError.cause = error;
+      throw mismatchError;
+    }
+    this.spawnHost();
+    return serializedTerminalState;
+  }
+
+  consumeRuntimeRotation() {
+    const rotation = this.runtimeRotationInfo;
+    this.runtimeRotationInfo = null;
+    return rotation;
+  }
+
   attachSocket(socket) {
     if (this.socket && this.socket !== socket) {
       this.socket.destroy();
     }
+    const generation = this.socketGeneration + 1;
+    this.socketGeneration = generation;
     this.socket = socket;
     this.buffer = '';
 
-    socket.on('data', chunk => this.handleData(chunk));
-    socket.on('close', () => this.handleDisconnect(socket));
+    socket.on('data', chunk => this.handleData(chunk, socket, generation));
+    socket.on('close', () => this.handleDisconnect(socket, generation));
     socket.on('error', error => {
+      if (this.socket !== socket || this.socketGeneration !== generation) return;
       this.emit('host-error', error);
     });
   }
 
-  handleDisconnect(socket) {
+  handleDisconnect(socket, generation = this.socketGeneration) {
     if (socket && this.socket && this.socket !== socket) {
       return;
     }
+    if (generation !== this.socketGeneration) return;
     this.socket = null;
     this.buffer = '';
+    this.connectedHostInfo = null;
     if (this.disposed) return;
     const error = new Error('Native pty host disconnected');
     error.code = 'ECONNRESET';
@@ -374,7 +641,8 @@ class NativePtyHostClient extends EventEmitter {
     }
   }
 
-  handleData(chunk) {
+  handleData(chunk, socket = this.socket, generation = this.socketGeneration) {
+    if (!socket || socket !== this.socket || generation !== this.socketGeneration) return;
     this.buffer += chunk.toString('utf8');
     let newline = this.buffer.indexOf('\n');
     while (newline >= 0) {

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

@@ -0,0 +1,86 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const NATIVE_PTY_HOST_PROTOCOL_VERSION = 8;
+const NATIVE_PTY_HOST_RUNTIME_FILES = Object.freeze([
+  'agent-env.js',
+  'input-parts.js',
+  'local-session-engine.js',
+  'native-pty-host.js',
+  'shell-busy-integration.js',
+  'terminal-screen-worker-pool.js',
+  'terminal-screen-worker-thread.js',
+  'terminal-screen-worker.js',
+  'terminal-reducer-flow-control.js',
+  'terminal-state-serialization.js',
+  'native-pty-controller-generation.js',
+  'terminal-status.js',
+]);
+
+function readFileForIdentity(filePath) {
+  try {
+    return fs.readFileSync(filePath);
+  } catch (error) {
+    return Buffer.from(`missing:${error && error.code ? error.code : 'unknown'}`, 'utf8');
+  }
+}
+
+function packageVersion(backendDir) {
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(backendDir, '..', 'package.json'), 'utf8'));
+    return typeof packageJson.version === 'string' ? packageJson.version : '';
+  } catch {
+    return '';
+  }
+}
+
+function nativePtyHostRuntimeIdentity(backendDir = __dirname) {
+  const hash = crypto.createHash('sha256');
+  const version = packageVersion(backendDir);
+  hash.update(`protocol:${NATIVE_PTY_HOST_PROTOCOL_VERSION}\n`);
+  hash.update(`version:${version}\n`);
+  for (const filename of NATIVE_PTY_HOST_RUNTIME_FILES) {
+    hash.update(`file:${filename}\n`);
+    hash.update(readFileForIdentity(path.join(backendDir, filename)));
+    hash.update('\n');
+  }
+  return Object.freeze({
+    protocolVersion: NATIVE_PTY_HOST_PROTOCOL_VERSION,
+    buildId: hash.digest('hex'),
+    version,
+  });
+}
+
+function normalizeNativePtyHostRuntimeIdentity(value) {
+  if (!value || typeof value !== 'object') return null;
+  const protocolVersion = Number(value.protocolVersion);
+  const buildId = typeof value.buildId === 'string' ? value.buildId.trim() : '';
+  if (!Number.isInteger(protocolVersion) || protocolVersion <= 0 || !/^[a-f0-9]{64}$/i.test(buildId)) {
+    return null;
+  }
+  return {
+    protocolVersion,
+    buildId: buildId.toLowerCase(),
+    version: typeof value.version === 'string' ? value.version : '',
+  };
+}
+
+function nativePtyHostRuntimeIdentityMatches(expected, actual) {
+  const normalizedExpected = normalizeNativePtyHostRuntimeIdentity(expected);
+  const normalizedActual = normalizeNativePtyHostRuntimeIdentity(actual);
+  return Boolean(
+    normalizedExpected &&
+    normalizedActual &&
+    normalizedExpected.protocolVersion === normalizedActual.protocolVersion &&
+    normalizedExpected.buildId === normalizedActual.buildId
+  );
+}
+
+module.exports = {
+  NATIVE_PTY_HOST_PROTOCOL_VERSION,
+  NATIVE_PTY_HOST_RUNTIME_FILES,
+  nativePtyHostRuntimeIdentity,
+  nativePtyHostRuntimeIdentityMatches,
+  normalizeNativePtyHostRuntimeIdentity,
+};