farming-code 2.2.6

package/backend/native-session-engine.js

@@ -0,0 +1,196 @@
+const SessionEngine = require('./session-engine');
+const NativePtyHostClient = require('./native-pty-host-client');
+const { normalizeShellSessionOptions } = require('./local-session-engine');
+const { cleanupShellBusyIntegration } = require('./shell-busy-integration');
+
+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 || '';
+}
+
+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.reconcilingHostDisconnect = false;
+    this.bindClientEvents();
+  }
+
+  bindClientEvents() {
+    [
+      'session-started',
+      'session-output',
+      '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.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') {
+      this.activeSessionIds.add(sessionId);
+    } else if (eventName === 'session-exited') {
+      this.activeSessionIds.delete(sessionId);
+    }
+  }
+
+  async reconcileHostDisconnect() {
+    if (this.reconcilingHostDisconnect) return;
+    const expectedSessionIds = [...this.activeSessionIds];
+    if (expectedSessionIds.length === 0) return;
+
+    this.reconcilingHostDisconnect = true;
+    try {
+      const recovered = await this.recoverSessions({ startHost: true });
+      const recoveredIds = new Set((recovered || [])
+        .map(entry => nativeSessionId(entry))
+        .filter(Boolean));
+
+      for (const sessionId of expectedSessionIds) {
+        if (recoveredIds.has(sessionId)) continue;
+        this.activeSessionIds.delete(sessionId);
+        this.emit('session-error', {
+          sessionId,
+          error: 'Native pty host disconnected; terminal session is no longer recoverable',
+          fatal: true,
+        });
+      }
+    } finally {
+      this.reconcilingHostDisconnect = false;
+    }
+  }
+
+  failActiveSessions(message) {
+    for (const sessionId of [...this.activeSessionIds]) {
+      this.activeSessionIds.delete(sessionId);
+      this.emit('session-error', {
+        sessionId,
+        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) {
+    return this.client.request('sendInput', { sessionId, input });
+  }
+
+  async interruptSession(sessionId, input = '\x03') {
+    return this.sendInput(sessionId, input);
+  }
+
+  async resizeSession(sessionId, cols, rows) {
+    return this.client.request('resizeSession', { sessionId, cols, rows });
+  }
+
+  async clearBuffer(sessionId) {
+    return this.client.request('clearBuffer', { sessionId });
+  }
+
+  async killSession(sessionId) {
+    const result = await this.client.request('killSession', { sessionId });
+    this.activeSessionIds.delete(sessionId);
+    return result;
+  }
+
+  async getSessionState(sessionId) {
+    return this.client.request('getSessionState', { 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) this.activeSessionIds.add(sessionId);
+      }
+      return recovered;
+    } catch (error) {
+      if (isRecoverableConnectError(error)) return [];
+      throw error;
+    }
+  }
+
+  async updateSessionMetadata(sessionId, patch) {
+    return this.client.request('updateSessionMetadata', { sessionId, patch });
+  }
+
+  dispose(options = {}) {
+    this.client.disconnect({
+      preserveHost: options.preserveHost === true || this.preserveHostOnDispose,
+    });
+    this.activeSessionIds.clear();
+  }
+}
+
+module.exports = NativeSessionEngine;

package/backend/network.js

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,196 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+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 {
+    return false;
+  }
+}
+
+async function stopProcess(pid, timeoutMs = 15_000) {
+  if (!isProcessRunning(pid)) return;
+  process.kill(pid, 'SIGTERM');
+  const startedAt = Date.now();
+  while (isProcessRunning(pid)) {
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(`Farming server ${pid} did not stop before timeout`);
+    }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+}
+
+function validatePayload(payload) {
+  if (!payload || typeof payload !== 'object') throw new Error('Missing npm update 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']) {
+    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');
+  }
+  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,
+    ...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;
+  return env;
+}
+
+async function installPackage(payload, version) {
+  const packageSpec = `${payload.packageName}@${version}`;
+  appendLog(payload.logPath, `Installing ${packageSpec}`);
+  const args = ['install', '--global'];
+  if (payload.npmPrefix) args.push('--prefix', payload.npmPrefix);
+  args.push(packageSpec, '--no-audit', '--no-fund');
+  await runCommand(payload.npmCommand || 'npm', args, {
+    env: commandEnvironment(),
+    logPath: payload.logPath,
+  });
+}
+
+async function startServer(payload, version = payload.targetVersion) {
+  appendLog(payload.logPath, `Starting Farming ${version}`);
+  await runCommand(payload.nodePath, startArguments(payload), {
+    env: commandEnvironment(),
+    logPath: payload.logPath,
+  });
+}
+
+async function runNpmUpdate(rawPayload) {
+  const payload = validatePayload(rawPayload);
+  try {
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'installing'));
+    await installPackage(payload, payload.targetVersion);
+
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'restarting'));
+    await stopProcess(Number(payload.serverPid));
+    await startServer(payload);
+
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'succeeded', {
+      completedAt: new Date().toISOString(),
+    }));
+    appendLog(payload.logPath, `Farming updated to ${payload.targetVersion}`);
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    appendLog(payload.logPath, `Update failed: ${message}`);
+
+    if (!isProcessRunning(Number(payload.serverPid))) {
+      try {
+        writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolling-back', { error: message }));
+        await installPackage(payload, payload.previousVersion);
+        await startServer(payload, payload.previousVersion);
+        writeJsonAtomic(payload.stateFile, stateFor(payload, 'rolled-back', {
+          version: payload.previousVersion,
+          attemptedVersion: payload.targetVersion,
+          error: message,
+          completedAt: new Date().toISOString(),
+        }));
+        appendLog(payload.logPath, `Rolled back to ${payload.previousVersion}`);
+        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', {
+      error: message,
+      completedAt: new Date().toISOString(),
+    }));
+  }
+}
+
+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,
+  writeJsonAtomic,
+};

package/backend/packaged-node-pty.js

@@ -0,0 +1,79 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { createRequire } = require('module');
+
+function isPackagedRuntime() {
+  return Boolean(process.pkg) || process.env.FARMING_PACKAGED_RUNTIME === '1';
+}
+
+function packagedNodePtyTargetDir() {
+  const baseDir = process.env.FARMING_CONFIG_DIR || path.join(os.homedir(), '.farming');
+  return path.join(baseDir, 'runtime', 'node-pty', `${process.platform}-${process.arch}`);
+}
+
+function copyIfExists(source, target, mode) {
+  if (!fs.existsSync(source)) return false;
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.copyFileSync(source, target);
+  if (mode !== undefined) fs.chmodSync(target, mode);
+  return true;
+}
+
+function nodePtyPackageRoot() {
+  if (isPackagedRuntime()) {
+    return path.join(__dirname, '..', 'node_modules', 'node-pty');
+  }
+
+  return path.dirname(createRequire(__filename).resolve('node-pty/package.json'));
+}
+
+function loadNativeModule(modulePath) {
+  const runtimeRequire = module.require ? module.require.bind(module) : require;
+  return runtimeRequire(modulePath);
+}
+
+function preparePackagedNodePtyRuntime(nativeName = 'pty') {
+  if (!isPackagedRuntime()) return '';
+  const packageRoot = nodePtyPackageRoot();
+  const prebuildDir = path.join(packageRoot, 'prebuilds', `${process.platform}-${process.arch}`);
+  const targetDir = packagedNodePtyTargetDir();
+  const nativeFile = `${nativeName}.node`;
+  const nativeCopied = copyIfExists(
+    path.join(prebuildDir, nativeFile),
+    path.join(targetDir, nativeFile)
+  );
+  copyIfExists(
+    path.join(prebuildDir, 'spawn-helper'),
+    path.join(targetDir, 'spawn-helper'),
+    0o755
+  );
+  return nativeCopied ? targetDir : '';
+}
+
+function copyPackagedSpawnHelper() {
+  return preparePackagedNodePtyRuntime('pty');
+}
+
+function loadNodePty() {
+  if (isPackagedRuntime()) {
+    const utils = require('node-pty/lib/utils');
+    utils.loadNativeModule = function patchedLoadNativeModule(name) {
+      const runtimeDir = preparePackagedNodePtyRuntime(name);
+      if (runtimeDir) {
+        return {
+          dir: runtimeDir,
+          module: loadNativeModule(path.join(runtimeDir, `${name}.node`)),
+        };
+      }
+      throw new Error(`Failed to load packaged node-pty native module: ${name}.node`);
+    };
+  }
+
+  return require('node-pty');
+}
+
+module.exports = loadNodePty();
+module.exports.copyPackagedSpawnHelper = copyPackagedSpawnHelper;
+module.exports.preparePackagedNodePtyRuntime = preparePackagedNodePtyRuntime;
+module.exports.isPackagedRuntime = isPackagedRuntime;

package/backend/provider-session-id.js

@@ -0,0 +1,47 @@
+const crypto = require('crypto');
+
+const TEMPORARY_PROVIDER_SESSION_ID_PREFIX = 'tmp_uuid';
+const SAFE_PROVIDER_SESSION_ID_RE = /^[A-Za-z0-9._:-]+$/;
+
+function randomUuid() {
+  if (typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+
+  return [
+    crypto.randomBytes(4).toString('hex'),
+    crypto.randomBytes(2).toString('hex'),
+    crypto.randomBytes(2).toString('hex'),
+    crypto.randomBytes(2).toString('hex'),
+    crypto.randomBytes(6).toString('hex'),
+  ].join('-');
+}
+
+function createProviderSessionId() {
+  return randomUuid();
+}
+
+function createTemporaryProviderSessionId() {
+  return `${TEMPORARY_PROVIDER_SESSION_ID_PREFIX}_${randomUuid()}`;
+}
+
+function isTemporaryProviderSessionId(sessionId) {
+  return String(sessionId || '').trim().startsWith(TEMPORARY_PROVIDER_SESSION_ID_PREFIX);
+}
+
+function isSafeProviderSessionId(sessionId, options = {}) {
+  const value = String(sessionId || '').trim();
+  if (value.startsWith('-')) return false;
+  if (!SAFE_PROVIDER_SESSION_ID_RE.test(value)) return false;
+  if (options.allowTemporary !== true && isTemporaryProviderSessionId(value)) return false;
+  return true;
+}
+
+module.exports = {
+  SAFE_PROVIDER_SESSION_ID_RE,
+  TEMPORARY_PROVIDER_SESSION_ID_PREFIX,
+  createProviderSessionId,
+  createTemporaryProviderSessionId,
+  isSafeProviderSessionId,
+  isTemporaryProviderSessionId,
+};

package/backend/qr-share-tickets.js

@@ -0,0 +1,100 @@
+const crypto = require('crypto');
+
+const SHARE_TICKET_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_CODE_LENGTH = 10;
+const DEFAULT_MAX_TICKETS = 200;
+const SHARE_TICKET_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+
+function normalizeCode(value) {
+  return String(value || '').trim().toUpperCase();
+}
+
+function createShareTicketCode(options = {}) {
+  const length = Math.max(6, Math.min(Number(options.length) || DEFAULT_CODE_LENGTH, 32));
+  const randomBytes = typeof options.randomBytes === 'function' ? options.randomBytes : crypto.randomBytes;
+  const bytes = randomBytes(length);
+  let code = '';
+  for (let index = 0; index < length; index += 1) {
+    code += SHARE_TICKET_ALPHABET[bytes[index] % SHARE_TICKET_ALPHABET.length];
+  }
+  return code;
+}
+
+class QrShareTicketStore {
+  constructor(options = {}) {
+    this.ttlMs = Math.max(30_000, Number(options.ttlMs) || SHARE_TICKET_TTL_MS);
+    this.codeLength = Math.max(6, Math.min(Number(options.codeLength) || DEFAULT_CODE_LENGTH, 32));
+    this.maxTickets = Math.max(1, Number(options.maxTickets) || DEFAULT_MAX_TICKETS);
+    this.randomBytes = typeof options.randomBytes === 'function' ? options.randomBytes : crypto.randomBytes;
+    this.tickets = new Map();
+  }
+
+  create(token, options = {}) {
+    const now = Number(options.now) || Date.now();
+    const targetQuery = typeof options.targetQuery === 'string' ? options.targetQuery : '';
+    this.cleanup(now);
+    this.trim(now);
+
+    let code = '';
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      code = createShareTicketCode({ length: this.codeLength, randomBytes: this.randomBytes });
+      if (!this.tickets.has(code)) break;
+      code = '';
+    }
+    if (!code) {
+      throw new Error('Unable to allocate share code');
+    }
+
+    const ticket = {
+      code,
+      token: String(token || ''),
+      targetQuery,
+      createdAt: now,
+      expiresAt: now + this.ttlMs,
+    };
+    this.tickets.set(code, ticket);
+    return { ...ticket };
+  }
+
+  consume(code, options = {}) {
+    const normalizedCode = normalizeCode(code);
+    const now = Number(options.now) || Date.now();
+    const ticket = this.tickets.get(normalizedCode);
+    if (!ticket) return null;
+    this.tickets.delete(normalizedCode);
+    if (ticket.expiresAt <= now) return null;
+    return { ...ticket };
+  }
+
+  revoke(code) {
+    return this.tickets.delete(normalizeCode(code));
+  }
+
+  cleanup(now = Date.now()) {
+    for (const [code, ticket] of this.tickets) {
+      if (ticket.expiresAt <= now) {
+        this.tickets.delete(code);
+      }
+    }
+  }
+
+  trim(now = Date.now()) {
+    if (this.tickets.size < this.maxTickets) return;
+    this.cleanup(now);
+    if (this.tickets.size < this.maxTickets) return;
+    const oldest = [...this.tickets.values()]
+      .sort((a, b) => a.expiresAt - b.expiresAt)
+      .slice(0, Math.max(1, this.tickets.size - this.maxTickets + 1));
+    for (const ticket of oldest) {
+      this.tickets.delete(ticket.code);
+    }
+  }
+}
+
+module.exports = {
+  QrShareTicketStore,
+  SHARE_TICKET_ALPHABET,
+  SHARE_TICKET_TTL_MS,
+  createShareTicketCode,
+  normalizeCode,
+};