farming-code 2.2.22 → 2.2.27

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

@@ -4,7 +4,10 @@ const crypto = require('crypto');
 const fs = require('fs');
 const net = require('net');
 const path = require('path');
-const { nativePtyHostSocketPath } = require('./native-pty-host-path');
+const {
+  nativePtyHostPrivateSocketNamePattern,
+  nativePtyHostSocketPath,
+} = require('./native-pty-host-path');
 const {
   nativePtyHostRuntimeIdentity,
   nativePtyHostRuntimeIdentityMatches,
@@ -17,6 +20,7 @@ const {
 const { isTemporaryProviderSessionId } = require('./provider-session-id');
 const storageLayout = require('./storage-layout');
 const { deserializeTerminalState } = require('./terminal-state-serialization');
+const { probeUnixSocket } = require('./terminal-runtime-cleanup');
 
 const DEFAULT_CONNECT_RETRIES = 300;
 const DEFAULT_CONNECT_RETRY_MS = 50;
@@ -184,6 +188,7 @@ class NativePtyHostClient extends EventEmitter {
     this.controllerIdentityReady = null;
     this.hostRotationTimeoutMs = options.hostRotationTimeoutMs || DEFAULT_HOST_ROTATION_TIMEOUT_MS;
     this.connectedHostInfo = null;
+    this.connectedSocketPath = '';
     this.runtimeRotationInfo = null;
     this.socket = null;
     this.socketGeneration = 0;
@@ -235,7 +240,85 @@ class NativePtyHostClient extends EventEmitter {
 
   canConnectWithoutStartingHost() {
     if (process.platform === 'win32') return true;
-    return fs.existsSync(this.socketPath);
+    return fs.existsSync(this.socketPath) || this.privateSocketCandidates().length > 0;
+  }
+
+  privateSocketCandidates() {
+    if (process.platform === 'win32') return [];
+    const directory = path.dirname(this.socketPath);
+    const pattern = nativePtyHostPrivateSocketNamePattern(this.socketPath);
+    try {
+      return fs.readdirSync(directory)
+        .filter(name => pattern.test(name))
+        .map(name => path.join(directory, name));
+    } catch (error) {
+      if (error?.code === 'ENOENT') return [];
+      throw error;
+    }
+  }
+
+  connectedPrivateSocketPath(hostInfo = {}) {
+    if (process.platform === 'win32') return '';
+    if (typeof hostInfo.privateSocketPath === 'string' && hostInfo.privateSocketPath) {
+      return hostInfo.privateSocketPath;
+    }
+    if (!this.connectedSocketPath || this.connectedSocketPath !== this.socketPath) {
+      return this.connectedSocketPath;
+    }
+
+    let publicIdentity;
+    try {
+      const stat = fs.statSync(this.socketPath, { bigint: true });
+      publicIdentity = { dev: stat.dev, ino: stat.ino };
+    } catch (error) {
+      if (error?.code === 'ENOENT') return '';
+      throw error;
+    }
+
+    const matching = this.privateSocketCandidates().filter((candidate) => {
+      try {
+        const stat = fs.statSync(candidate, { bigint: true });
+        return stat.dev === publicIdentity.dev && stat.ino === publicIdentity.ino;
+      } catch (error) {
+        if (error?.code === 'ENOENT') return false;
+        throw error;
+      }
+    });
+    return matching.length === 1 ? matching[0] : '';
+  }
+
+  async resolveConnectSocketPath() {
+    if (process.platform === 'win32' || fs.existsSync(this.socketPath)) {
+      return this.socketPath;
+    }
+    const active = [];
+    for (const candidate of this.privateSocketCandidates()) {
+      const probe = await probeUnixSocket(candidate);
+      if (probe.active) active.push(candidate);
+    }
+    if (active.length > 1) {
+      const error = new Error('Multiple live native PTY hosts were found for this Farming config');
+      error.code = 'FARMING_NATIVE_HOST_AMBIGUOUS';
+      error.socketPaths = active;
+      throw error;
+    }
+    return active[0] || this.socketPath;
+  }
+
+  restorePublicSocketPath(connectedPath) {
+    if (
+      process.platform === 'win32'
+      || !connectedPath
+      || connectedPath === this.socketPath
+      || fs.existsSync(this.socketPath)
+    ) {
+      return;
+    }
+    try {
+      fs.linkSync(connectedPath, this.socketPath);
+    } catch (error) {
+      if (!error || error.code !== 'EEXIST') throw error;
+    }
   }
 
   spawnHost() {
@@ -288,9 +371,10 @@ class NativePtyHostClient extends EventEmitter {
     });
   }
 
-  connectOnce() {
+  async connectOnce() {
+    const connectedPath = await this.resolveConnectSocketPath();
     return new Promise((resolve, reject) => {
-      const socket = net.createConnection(this.socketPath);
+      const socket = net.createConnection(connectedPath);
       const onError = (error) => {
         socket.destroy();
         reject(error);
@@ -298,6 +382,8 @@ class NativePtyHostClient extends EventEmitter {
       socket.once('error', onError);
       socket.once('connect', () => {
         socket.off('error', onError);
+        this.restorePublicSocketPath(connectedPath);
+        this.connectedSocketPath = connectedPath;
         this.attachSocket(socket);
         resolve();
       });
@@ -373,6 +459,9 @@ class NativePtyHostClient extends EventEmitter {
         if (error && error.code === 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH') {
           throw error;
         }
+        if (error && error.code === 'FARMING_NATIVE_HOST_AMBIGUOUS') {
+          throw error;
+        }
         if (this.hostStartError) {
           lastError = this.hostStartError;
         }
@@ -427,7 +516,7 @@ class NativePtyHostClient extends EventEmitter {
     return this.controllerIdentityReady;
   }
 
-  async waitForHostRelease() {
+  async waitForHostRelease(privateSocketPath = '') {
     const deadline = Date.now() + this.hostRotationTimeoutMs;
     if (process.platform === 'win32') {
       await delay(Math.min(250, this.hostRotationTimeoutMs));
@@ -437,7 +526,8 @@ class NativePtyHostClient extends EventEmitter {
       const childReleased = !this.hostChild ||
         this.hostChild.exitCode !== null ||
         this.hostChild.signalCode !== null;
-      if (!fs.existsSync(this.socketPath) && childReleased) return;
+      const privateReleased = !privateSocketPath || !fs.existsSync(privateSocketPath);
+      if (!fs.existsSync(this.socketPath) && privateReleased && childReleased) return;
       await delay(50);
     }
     const error = new Error('Timed out waiting for the previous native PTY host to stop');
@@ -589,6 +679,7 @@ class NativePtyHostClient extends EventEmitter {
       throw mismatchError;
     }
 
+    const privateSocketPath = this.connectedPrivateSocketPath(hostInfo);
     const socket = this.socket;
     if (socket) this.suppressedDisconnectSockets.add(socket);
     let shutdownUncertain = false;
@@ -622,7 +713,7 @@ class NativePtyHostClient extends EventEmitter {
     }
 
     try {
-      await this.waitForHostRelease();
+      await this.waitForHostRelease(privateSocketPath || this.connectedSocketPath);
     } catch (error) {
       if (shutdownUncertain) {
         try {
@@ -674,6 +765,7 @@ class NativePtyHostClient extends EventEmitter {
     this.socket = null;
     this.buffer = '';
     this.connectedHostInfo = null;
+    this.connectedSocketPath = '';
     if (this.disposed) return;
     const error = new Error('Native pty host disconnected');
     error.code = 'ECONNRESET';

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

@@ -17,6 +17,26 @@ function nativePtyHostSocketPath(configDir) {
   return path.join(os.tmpdir(), `farming-native-pty-${process.getuid ? process.getuid() : 'user'}-${hash}.sock`);
 }
 
+function nativePtyHostPrivateSocketHash(socketPath) {
+  return crypto.createHash('sha256').update(socketPath).digest('hex').slice(0, 8);
+}
+
+function nativePtyHostPrivateSocketPath(socketPath, options = {}) {
+  const pid = Number(options.pid || process.pid);
+  const nonce = String(options.nonce || crypto.randomBytes(4).toString('hex'));
+  return path.join(
+    path.dirname(socketPath),
+    `.fpty-${pid}-${nativePtyHostPrivateSocketHash(socketPath)}-${nonce}.sock`,
+  );
+}
+
+function nativePtyHostPrivateSocketNamePattern(socketPath) {
+  const hash = nativePtyHostPrivateSocketHash(socketPath);
+  return new RegExp(`^\\.fpty-\\d+-${hash}-[a-f0-9]+\\.sock$`);
+}
+
 module.exports = {
+  nativePtyHostPrivateSocketNamePattern,
+  nativePtyHostPrivateSocketPath,
   nativePtyHostSocketPath,
 };

package/backend/native-pty-host.js

@@ -7,7 +7,10 @@ const os = require('os');
 const path = require('path');
 
 const TerminalScreenWorkerPool = require('./terminal-screen-worker-pool');
-const { nativePtyHostSocketPath } = require('./native-pty-host-path');
+const {
+  nativePtyHostPrivateSocketPath,
+  nativePtyHostSocketPath,
+} = require('./native-pty-host-path');
 const { terminalInputToPtyString } = require('./input-parts');
 const { normalizeInteractiveTerminalEnv } = require('./agent-env');
 const {
@@ -77,6 +80,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 +96,10 @@ 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
+      : nativePtyHostPrivateSocketPath(this.socketPath);
+    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) {
@@ -317,6 +347,7 @@ class NativePtyHost {
         return {
           ok: true,
           pid: process.pid,
+          privateSocketPath: process.platform === 'win32' ? '' : this.boundSocketPath,
           runtimeIdentity: this.runtimeIdentity,
         };
       case 'registerController':
@@ -1476,16 +1507,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/workspace-file-router.js

@@ -136,6 +136,23 @@ function assertGlobalWorkspacePathAllowed(agentManager, userPath, options = {})
   return { target: requestedTarget, allowedRoots };
 }
 
+function assertExactExternalFileReadable(userPath) {
+  const requestedTarget = globalUserPathToAbsolute(userPath);
+  let target;
+  let stat;
+  try {
+    target = fs.realpathSync(requestedTarget);
+    stat = fs.statSync(target);
+    fs.accessSync(target, fs.constants.R_OK);
+  } catch {
+    throw new WorkspaceFileError('external file is not readable', 403);
+  }
+  if (!stat.isFile()) {
+    throw new WorkspaceFileError('external path must be a file', 400);
+  }
+  return relativeGlobalPath(target);
+}
+
 function globalSyntheticTree(agentManager, userPath = '') {
   const { target, allowedRoots } = assertGlobalWorkspacePathAllowed(agentManager, userPath, {
     allowAllowedRootAncestor: true,
@@ -233,11 +250,14 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
   router.get('/file', async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
-      if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '');
+      const requestPath = isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact === '1'
+        ? assertExactExternalFileReadable(req.query.path || '')
+        : req.query.path || '';
+      if (isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact !== '1') {
+        assertGlobalWorkspacePathAllowed(agentManager, requestPath);
       }
       const { root, rootId } = resolveRequestRoot(req.query);
-      const file = await fileService.readFile(root, req.query.path || '', readOptionsForAgent(agentManager, rootRef));
+      const file = await fileService.readFile(root, requestPath, readOptionsForAgent(agentManager, rootRef));
       res.json({ rootId, root, file });
     } catch (error) {
       sendWorkspaceFileError(res, error);
@@ -247,11 +267,14 @@ function createWorkspaceFileRouter(agentManager, fileService, options = {}) {
   router.get('/raw', async (req, res) => {
     try {
       const rootRef = workspaceRef(req.query);
-      if (isGlobalWorkspaceFilesAgentId(rootRef)) {
-        assertGlobalWorkspacePathAllowed(agentManager, req.query.path || '');
+      const requestPath = isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact === '1'
+        ? assertExactExternalFileReadable(req.query.path || '')
+        : req.query.path || '';
+      if (isGlobalWorkspaceFilesAgentId(rootRef) && req.query.exact !== '1') {
+        assertGlobalWorkspacePathAllowed(agentManager, requestPath);
       }
       const { root } = resolveRequestRoot(req.query);
-      const file = await fileService.readPreviewFile(root, req.query.path || '', readOptionsForAgent(agentManager, rootRef));
+      const file = await fileService.readPreviewFile(root, requestPath, readOptionsForAgent(agentManager, rootRef));
       res
         .status(200)
         .type(file.preview.mediaType)
@@ -533,6 +556,7 @@ module.exports = {
   PROJECT_FILES_WORKSPACE_PREFIX,
   PROJECT_FILES_AGENT_PREFIX: PROJECT_FILES_WORKSPACE_PREFIX,
   assertGlobalWorkspacePathAllowed,
+  assertExactExternalFileReadable,
   createWorkspaceFileRouter,
   globalWorkspaceAllowedRoots,
   isGlobalWorkspaceFilesAgentId,