farming-code 2.2.30 → 2.2.32

package/backend/packaged-node-pty.js

@@ -1,99 +0,0 @@
-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 });
-  let unchanged = false;
-  try {
-    const sourceStat = fs.statSync(source);
-    const targetStat = fs.statSync(target);
-    unchanged = sourceStat.size === targetStat.size
-      && fs.readFileSync(source).equals(fs.readFileSync(target));
-  } catch {
-    unchanged = false;
-  }
-  if (!unchanged) {
-    const temporary = `${target}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
-    try {
-      fs.copyFileSync(source, temporary, fs.constants.COPYFILE_EXCL);
-      if (mode !== undefined) fs.chmodSync(temporary, mode);
-      fs.renameSync(temporary, target);
-    } finally {
-      fs.rmSync(temporary, { force: true });
-    }
-  } else 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.copyIfExists = copyIfExists;
-module.exports.preparePackagedNodePtyRuntime = preparePackagedNodePtyRuntime;
-module.exports.isPackagedRuntime = isPackagedRuntime;

package/backend/preview-session-manager.js

@@ -1,68 +0,0 @@
-const crypto = require('crypto');
-
-const DEFAULT_PREVIEW_SESSION_TTL_MS = 30 * 60 * 1000;
-const DEFAULT_MAX_PREVIEW_SESSIONS = 128;
-
-class PreviewSessionManager {
-  constructor(options = {}) {
-    this.ttlMs = Math.max(1_000, Number(options.ttlMs) || DEFAULT_PREVIEW_SESSION_TTL_MS);
-    this.maxSessions = Math.max(1, Number(options.maxSessions) || DEFAULT_MAX_PREVIEW_SESSIONS);
-    this.now = options.now || (() => Date.now());
-    this.randomUUID = options.randomUUID || (() => crypto.randomUUID());
-    this.sessions = new Map();
-  }
-
-  createStatic(input) {
-    this.cleanupExpired();
-    while (this.sessions.size >= this.maxSessions) {
-      const oldestId = this.sessions.keys().next().value;
-      if (!oldestId) break;
-      this.sessions.delete(oldestId);
-    }
-
-    const now = this.now();
-    const session = Object.freeze({
-      id: this.randomUUID(),
-      kind: 'static',
-      rootId: input.rootId,
-      workspaceRoot: input.workspaceRoot,
-      authorizedRoot: input.authorizedRoot,
-      entryPath: input.entryPath,
-      baseDirectory: input.baseDirectory,
-      createdAt: now,
-      expiresAt: now + this.ttlMs,
-    });
-    this.sessions.set(session.id, session);
-    return session;
-  }
-
-  get(sessionId) {
-    const session = this.sessions.get(String(sessionId || ''));
-    if (!session) return null;
-    if (session.expiresAt <= this.now()) {
-      this.sessions.delete(session.id);
-      return null;
-    }
-    return session;
-  }
-
-  delete(sessionId) {
-    return this.sessions.delete(String(sessionId || ''));
-  }
-
-  cleanupExpired() {
-    const now = this.now();
-    for (const [sessionId, session] of this.sessions) {
-      if (session.expiresAt <= now) this.sessions.delete(sessionId);
-    }
-  }
-
-  dispose() {
-    this.sessions.clear();
-  }
-}
-
-module.exports = {
-  DEFAULT_PREVIEW_SESSION_TTL_MS,
-  PreviewSessionManager,
-};

package/backend/provider-adapters.js

@@ -1,399 +0,0 @@
-const path = require('path');
-const { chatCapabilitiesForProvider } = require('./chat-runtime');
-const {
-  createProviderSessionId,
-  createTemporaryProviderSessionId,
-  isSafeProviderSessionId,
-} = require('./provider-session-id');
-
-const CODEX_VALUE_OPTIONS = new Set([
-  '-a', '-c', '-C', '-m', '-p', '-s', '--ask-for-approval', '--cd', '--config',
-  '--config-profile', '--model', '--profile', '--sandbox', '--add-dir',
-  '--enable', '--disable', '--remote', '--remote-auth-token-env',
-  '--local-provider', '-i', '--image',
-]);
-const OPENCODE_VALUE_OPTIONS = new Set([
-  '-m', '-s', '--agent', '--hostname', '--log-level', '--mdns-domain',
-  '--model', '--port', '--prompt', '--replay-limit', '--session',
-]);
-const CODEX_SUBCOMMANDS = new Set([
-  'exec', 'e', 'review', 'login', 'logout', 'mcp', 'plugin', 'mcp-server',
-  'app-server', 'remote-control', 'app', 'completion', 'update', 'doctor',
-  'sandbox', 'debug', 'apply', 'a', 'resume', 'archive', 'delete', 'unarchive',
-  'fork', 'cloud', 'exec-server', 'features', 'help',
-]);
-const OPENCODE_SUBCOMMANDS = new Set([
-  'completion', 'acp', 'mcp', 'attach', 'run', 'debug', 'providers', 'auth',
-  'agent', 'upgrade', 'uninstall', 'serve', 'web', 'models', 'stats', 'export',
-  'import', 'github', 'pr', 'session', 'plugin', 'plug', 'db',
-]);
-const CODEX_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-function optionTakesValue(option, valueOptions) {
-  return Boolean(option && !option.includes('=') && valueOptions.has(option));
-}
-
-function scanPositionals(args, valueOptions, options = {}) {
-  const positionals = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = String(args[index] || '');
-    if (!arg) continue;
-    if (arg === '--') {
-      for (let positionalIndex = index + 1; positionalIndex < args.length; positionalIndex += 1) {
-        const value = String(args[positionalIndex] || '');
-        if (value) positionals.push({ value, index: positionalIndex, afterDelimiter: true });
-      }
-      break;
-    }
-    if (arg.startsWith('-')) {
-      if (
-        options.multiValueOptions?.has(arg)
-        && !arg.includes('=')
-      ) {
-        while (index + 1 < args.length && !String(args[index + 1] || '').startsWith('-')) index += 1;
-        continue;
-      }
-      if (optionTakesValue(arg, valueOptions)) index += 1;
-      continue;
-    }
-    positionals.push({ value: arg, index, afterDelimiter: false });
-  }
-  return positionals;
-}
-
-function codexSessionIdAfterSubcommand(args, subcommandIndex) {
-  const sessionId = scanPositionals(
-    args.slice(subcommandIndex + 1),
-    CODEX_VALUE_OPTIONS,
-    { multiValueOptions: new Set(['-i', '--image']) },
-  )[0]?.value || '';
-  return CODEX_SESSION_ID_RE.test(sessionId) ? sessionId.toLowerCase() : '';
-}
-
-function argValue(args, names) {
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === '--') break;
-    for (const name of names) {
-      if (arg === name) return args[index + 1] || '';
-      if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
-    }
-  }
-  return '';
-}
-
-function hasArg(args, names) {
-  for (const arg of args) {
-    if (arg === '--') break;
-    if (names.includes(arg) || names.some(name => arg.startsWith(`${name}=`))) return true;
-  }
-  return false;
-}
-
-function codexSessionPlan(rawArgs, _launchArgs) {
-  const positional = scanPositionals(rawArgs, CODEX_VALUE_OPTIONS, {
-    multiValueOptions: new Set(['-i', '--image']),
-  });
-  const subcommand = positional[0]
-    && positional[0].afterDelimiter !== true
-    && CODEX_SUBCOMMANDS.has(positional[0].value)
-    ? positional[0]
-    : null;
-  if (subcommand?.value === 'resume') {
-    const id = hasArg(rawArgs.slice(subcommand.index + 1), ['--last'])
-      ? ''
-      : codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
-    if (id) return { id, temporary: false, source: 'resume' };
-  }
-  if (subcommand?.value === 'fork') {
-    return {
-      id: createTemporaryProviderSessionId(),
-      temporary: true,
-      source: 'codex-fork-temporary',
-      forkedFromProviderSessionId: hasArg(rawArgs.slice(subcommand.index + 1), ['--last'])
-        ? ''
-        : codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
-    };
-  }
-  if (subcommand) return null;
-  if (hasArg(rawArgs, ['--remote'])) {
-    return {
-      error: 'A fresh Codex --remote Terminal cannot be correlated with a local resumable session id; resume an explicit remote session id instead',
-    };
-  }
-  return {
-    id: createTemporaryProviderSessionId(),
-    temporary: true,
-    source: 'codex-temporary',
-  };
-}
-
-function explicitSessionPlan(provider, rawArgs, launchArgs) {
-  const explicitSessionId = argValue(rawArgs, ['--session-id']);
-  const resumeSessionId = argValue(rawArgs, ['--resume']);
-  const isFork = hasArg(rawArgs, ['--fork-session']);
-  const isContinue = hasArg(rawArgs, provider === 'claude' ? ['--continue', '-c'] : ['--continue']);
-  if (explicitSessionId && isSafeProviderSessionId(explicitSessionId)) {
-    return {
-      id: explicitSessionId,
-      temporary: false,
-      source: 'launch-session-id',
-      forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
-    };
-  }
-  if (resumeSessionId && isSafeProviderSessionId(resumeSessionId) && !isFork) {
-    return { id: resumeSessionId, temporary: false, source: 'resume' };
-  }
-  if (isContinue) return null;
-  const id = createProviderSessionId();
-  return {
-    id,
-    temporary: false,
-    source: isFork ? `${provider}-fork-session-id` : `${provider}-session-id`,
-    forkedFromProviderSessionId: isFork && isSafeProviderSessionId(resumeSessionId) ? resumeSessionId : '',
-    args: ['--session-id', id, ...launchArgs],
-  };
-}
-
-function openCodeSessionPlan(rawArgs, launchArgs) {
-  const id = argValue(rawArgs, ['--session', '-s']);
-  if (id && isSafeProviderSessionId(id)) {
-    return hasArg(rawArgs, ['--fork'])
-      ? {
-        id: createTemporaryProviderSessionId(),
-        temporary: true,
-        source: 'opencode-fork-temporary',
-        forkedFromProviderSessionId: id,
-      }
-      : { id, temporary: false, source: 'resume' };
-  }
-  if (hasArg(rawArgs, ['--session', '-s', '--continue', '-c', '--fork'])) return null;
-  const positional = scanPositionals(rawArgs, OPENCODE_VALUE_OPTIONS, {
-    multiValueOptions: new Set(['--cors']),
-  });
-  if (
-    positional[0]
-    && positional[0].afterDelimiter !== true
-    && OPENCODE_SUBCOMMANDS.has(positional[0].value)
-  ) return null;
-  return {
-    id: '',
-    precreate: true,
-    temporary: false,
-    source: 'opencode-precreate',
-    identityWorkspace: positional[0]?.value || '',
-    resumeInsertIndex: launchArgs.length,
-  };
-}
-
-function codexAcpEnvironment(options = {}) {
-  const env = { ...(options.env || process.env) };
-  if (options.executable && !env.CODEX_PATH) env.CODEX_PATH = options.executable;
-  let config = {};
-  if (env.CODEX_CONFIG) {
-    try {
-      const parsed = JSON.parse(env.CODEX_CONFIG);
-      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) config = parsed;
-    } catch {
-      // A selected Farming profile below replaces an invalid adapter config.
-    }
-  }
-  if (options.model && options.model !== 'config') config.model = options.model;
-  if (options.reasoningEffort && options.reasoningEffort !== 'config') config.model_reasoning_effort = options.reasoningEffort;
-  if (options.serviceTier && !['config', 'default'].includes(options.serviceTier)) config.service_tier = options.serviceTier;
-  if (typeof options.farmingSystemPrompt === 'string' && options.farmingSystemPrompt.trim()) {
-    config.developer_instructions = [
-      typeof config.developer_instructions === 'string' ? config.developer_instructions.trim() : '',
-      options.farmingSystemPrompt.trim(),
-    ].filter(Boolean).join('\n\n');
-  }
-  if (Object.keys(config).length > 0) env.CODEX_CONFIG = JSON.stringify(config);
-  const initialMode = { ask: 'read-only', approve: 'agent', full: 'agent-full-access' }[options.approvalMode];
-  if (initialMode) env.INITIAL_AGENT_MODE = initialMode;
-  return env;
-}
-
-function claudeAcpEnvironment(options = {}) {
-  const env = { ...(options.env || process.env) };
-  if (options.executable && !env.CLAUDE_CODE_EXECUTABLE) {
-    env.CLAUDE_CODE_EXECUTABLE = options.executable;
-  }
-  return env;
-}
-
-const PROVIDER_ADAPTERS = Object.freeze([
-  {
-    id: 'codex',
-    displayName: 'codex',
-    executable: 'codex',
-    homeEnvKey: 'CODEX_HOME',
-    interruptInput: '\x1b',
-    freshAcpSessionSources: ['codex-temporary'],
-    commands: ['codex'],
-    supportedRuntimes: ['terminal', 'acp', 'json'],
-    planSession: codexSessionPlan,
-    terminalResumeArgs: (args, sessionId) => ['resume', sessionId, ...args],
-    acp: { packageName: '@agentclientprotocol/codex-acp', version: '1.1.4' },
-    prepareAcpEnvironment: codexAcpEnvironment,
-    capabilities: {
-      runtimeSwitch: true,
-      terminalProfile: true,
-      goals: false,
-      goalSubmission: { terminal: { kind: 'prompt' }, acp: { kind: 'prompt' } },
-      sessionFork: true,
-    },
-  },
-  {
-    id: 'claude',
-    displayName: 'claude code',
-    executable: 'claude',
-    homeEnvKey: 'CLAUDE_CONFIG_DIR',
-    interruptInput: '\x1b',
-    freshAcpSessionSources: ['claude-session-id'],
-    commands: ['claude'],
-    supportedRuntimes: ['terminal', 'acp'],
-    planSession: (rawArgs, launchArgs) => explicitSessionPlan('claude', rawArgs, launchArgs),
-    acp: {
-      packageName: '@agentclientprotocol/claude-agent-acp',
-      version: '0.59.0',
-      forkMode: 'target-process',
-    },
-    prepareAcpEnvironment: claudeAcpEnvironment,
-    capabilities: {
-      runtimeSwitch: true,
-      terminalProfile: false,
-      goals: false,
-      goalSubmission: { terminal: { kind: 'command', prefix: '/goal' }, acp: { kind: 'prompt' } },
-      sessionFork: true,
-    },
-  },
-  {
-    id: 'opencode',
-    displayName: 'opencode',
-    executable: 'opencode',
-    homeEnvKey: 'OPENCODE_CONFIG_DIR',
-    interruptInput: '\x03',
-    freshAcpSessionSources: [],
-    commands: ['opencode'],
-    supportedRuntimes: ['terminal', 'acp', 'json'],
-    planSession: openCodeSessionPlan,
-    terminalResumeArgs: (args, sessionId) => {
-      const delimiterIndex = args.indexOf('--');
-      const insertIndex = delimiterIndex >= 0 ? delimiterIndex : args.length;
-      return [
-        ...args.slice(0, insertIndex),
-        '--session',
-        sessionId,
-        ...args.slice(insertIndex),
-      ];
-    },
-    acp: {
-      version: 'native',
-      launch: options => ({
-        command: options.executable || 'opencode',
-        args: ['acp', '--cwd', path.resolve(options.cwd || process.cwd())],
-      }),
-    },
-    capabilities: {
-      runtimeSwitch: true,
-      terminalProfile: false,
-      goals: false,
-      goalSubmission: { terminal: { kind: 'prompt' }, acp: { kind: 'prompt' } },
-      sessionFork: true,
-    },
-  },
-  {
-    id: 'qoder',
-    displayName: 'qoder',
-    executable: 'qodercli',
-    homeEnvKey: 'QODER_CONFIG_DIR',
-    interruptInput: '\x1b',
-    freshAcpSessionSources: ['qoder-session-id'],
-    commands: ['qoder', 'qodercli'],
-    supportedRuntimes: ['terminal', 'acp'],
-    planSession: (rawArgs, launchArgs) => explicitSessionPlan('qoder', rawArgs, launchArgs),
-    acp: {
-      version: 'native',
-      launch: options => ({
-        command: options.executable || 'qodercli',
-        args: [
-          ...(typeof options.farmingSystemPrompt === 'string' && options.farmingSystemPrompt.trim()
-            ? ['--append-system-prompt', options.farmingSystemPrompt.trim()]
-            : []),
-          '--acp',
-        ],
-      }),
-    },
-    capabilities: {
-      runtimeSwitch: true,
-      terminalProfile: false,
-      goals: false,
-      goalSubmission: { terminal: { kind: 'command', prefix: '/goal set' }, acp: { kind: 'prompt' } },
-      sessionFork: true,
-    },
-  },
-]);
-
-const ADAPTER_BY_ID = new Map(PROVIDER_ADAPTERS.map(adapter => [adapter.id, Object.freeze(adapter)]));
-const ADAPTER_BY_COMMAND = new Map(PROVIDER_ADAPTERS.flatMap(adapter => (
-  adapter.commands.map(command => [command, adapter])
-)));
-
-function getProviderAdapter(provider) {
-  return ADAPTER_BY_ID.get(String(provider || '').trim().toLowerCase()) || null;
-}
-
-function providerForProgram(program) {
-  return ADAPTER_BY_COMMAND.get(path.basename(String(program || '').trim()))?.id || '';
-}
-
-function listProviderAdapters() {
-  return [...PROVIDER_ADAPTERS];
-}
-
-function providerCapabilities(provider) {
-  const adapter = getProviderAdapter(provider);
-  return {
-    supportedRuntimes: adapter
-      ? adapter.supportedRuntimes.filter(runtime => runtime !== 'json')
-      : ['terminal'],
-    runtimeSwitch: adapter?.capabilities?.runtimeSwitch === true,
-    terminalProfile: adapter?.capabilities?.terminalProfile === true,
-    goals: adapter?.capabilities?.goals === true,
-    goalSubmission: adapter?.capabilities?.goalSubmission || null,
-    sessionFork: adapter?.capabilities?.sessionFork === true,
-    ...(adapter
-      ? chatCapabilitiesForProvider(provider)
-      : { chatRuntime: '', supportsChat: false, supportsSteer: false }),
-  };
-}
-
-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;
-  return env;
-}
-
-function isFreshAcpSessionSource(provider, source) {
-  return getProviderAdapter(provider)?.freshAcpSessionSources.includes(source) === true;
-}
-
-module.exports = {
-  claudeAcpEnvironment,
-  getProviderAdapter,
-  applyProviderHomeEnvironment,
-  isFreshAcpSessionSource,
-  listProviderAdapters,
-  providerAcpForkMode,
-  providerCapabilities,
-  providerForProgram,
-  providerSupportsRuntime,
-};

package/backend/provider-session-id.js

@@ -1,47 +0,0 @@
-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,
-};