farming-code 2.2.29 → 2.2.32

package/backend/control-api.js

@@ -1,455 +0,0 @@
-const express = require('express');
-const crypto = require('crypto');
-const { runtimeKind } = require('./agent-runtime-binding');
-const { terminalInputReady } = require('./terminal-status');
-
-const DEFAULT_INITIAL_INPUT_TIMEOUT_MS = 30000;
-
-function ensureTrailingNewline(value) {
-  const text = String(value || '');
-  return text.endsWith('\r') || text.endsWith('\n') ? text : `${text}\r`;
-}
-
-function findAgent(state, agentId) {
-  return state.agents.find((agent) => agent.id === agentId) || null;
-}
-
-function normalizeTail(value, fallback = 4000) {
-  const tail = Number(value);
-  if (!Number.isFinite(tail)) return fallback;
-  return Math.max(0, Math.min(100000, Math.floor(tail)));
-}
-
-function stableJsonValue(value) {
-  if (Array.isArray(value)) return value.map(stableJsonValue);
-  if (!value || typeof value !== 'object') return value;
-  return Object.keys(value).sort().reduce((result, key) => {
-    result[key] = stableJsonValue(value[key]);
-    return result;
-  }, {});
-}
-
-function requestSignature(value) {
-  return crypto.createHash('sha256')
-    .update(JSON.stringify(stableJsonValue(value)))
-    .digest('hex');
-}
-
-function terminalReadinessOptions(agent) {
-  return {
-    command: agent.command,
-    cwd: agent.terminalStatus?.cwd || agent.cwd,
-    status: agent.status === 'running' ? 'running' : agent.status,
-    title: agent.terminalStatus?.title || agent.sessionTitle || '',
-    previewText: agent.previewText || '',
-    terminalBusy: typeof agent.terminalBusy === 'boolean' ? agent.terminalBusy : null,
-    shellLastEvent: agent.terminalStatus?.source === 'shell-status-marker' ? 'finish' : '',
-    shellLastExitCode: agent.terminalStatus?.lastExitCode,
-    shellCommand: agent.terminalStatus?.runningCommand || '',
-  };
-}
-
-function waitForTerminalInputReadiness(agentManager, agentId, options = {}) {
-  const expectedStartedAt = Number(options.expectedStartedAt);
-  const initialRuntimeEpoch = typeof options.expectedRuntimeEpoch === 'string'
-    ? options.expectedRuntimeEpoch
-    : '';
-  const timeoutMs = Number.isFinite(options.timeoutMs)
-    ? Math.max(1, options.timeoutMs)
-    : DEFAULT_INITIAL_INPUT_TIMEOUT_MS;
-
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let expectedRuntimeEpoch = initialRuntimeEpoch;
-    const removeUpdateListener = () => {
-      if (typeof agentManager.off === 'function') agentManager.off('update', inspect);
-      else if (typeof agentManager.removeListener === 'function') agentManager.removeListener('update', inspect);
-    };
-    const finish = (error, value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      removeUpdateListener();
-      if (error) reject(error);
-      else resolve(value);
-    };
-    const fail = (code, message) => {
-      const error = new Error(message);
-      error.code = code;
-      finish(error);
-    };
-    const inspect = () => {
-      const agent = findAgent(agentManager.getState(), agentId);
-      if (!agent) {
-        fail('agent-removed', 'Agent disappeared before its initial Terminal task was delivered');
-        return;
-      }
-      if (Number(agent.startedAt) !== expectedStartedAt) {
-        fail('runtime-replaced', 'Agent runtime was replaced before its initial Terminal task was delivered');
-        return;
-      }
-      if (agent.terminalInputReceived === true) {
-        fail('terminal-already-used', 'Terminal received user input before its initial task was delivered');
-        return;
-      }
-      if (agent.status === 'dead' || agent.status === 'stopped') {
-        fail('runtime-exited', 'Agent exited before its initial Terminal task was delivered');
-        return;
-      }
-      const runtimeEpoch = typeof agent.runtimeEpoch === 'string' ? agent.runtimeEpoch : '';
-      if (!runtimeEpoch) return;
-      if (expectedRuntimeEpoch && runtimeEpoch !== expectedRuntimeEpoch) {
-        fail('runtime-replaced', 'Agent runtime changed before its initial Terminal task was delivered');
-        return;
-      }
-      expectedRuntimeEpoch = runtimeEpoch;
-      if (agent.status !== 'running' || !terminalInputReady(terminalReadinessOptions(agent))) return;
-      finish(null, {
-        expectedStartedAt,
-        expectedRuntimeEpoch,
-      });
-    };
-    const timeout = setTimeout(() => {
-      fail('initial-input-timeout', 'Terminal did not become ready for its initial task before the timeout');
-    }, timeoutMs);
-    timeout.unref?.();
-    if (typeof agentManager.on === 'function') agentManager.on('update', inspect);
-    Promise.resolve().then(inspect);
-  });
-}
-
-function createControlRouter(agentManager, options = {}) {
-  const router = express.Router();
-  const createRequestAdmissions = new Map();
-  const notifyUpdate = typeof options.notifyUpdate === 'function' ? options.notifyUpdate : () => {};
-  const initialInputTimeoutMs = Number.isFinite(options.initialInputTimeoutMs)
-    ? Math.max(1, options.initialInputTimeoutMs)
-    : DEFAULT_INITIAL_INPUT_TIMEOUT_MS;
-
-  async function runTerminalMutation(agentId, expectedRuntimeEpoch, operation) {
-    const current = findAgent(agentManager.getState(), agentId);
-    if (!current || current.runtimeEpoch !== expectedRuntimeEpoch) {
-      return { status: 'rejected', reason: 'runtime-epoch-mismatch' };
-    }
-    return operation({ expectedRuntimeEpoch });
-  }
-
-  router.use(express.json({ limit: '1mb' }));
-
-  router.get('/agents', (req, res) => {
-    const state = agentManager.getState();
-    const parent = typeof req.query.parent === 'string' ? req.query.parent : '';
-    const agents = parent
-      ? state.agents.filter((agent) => agent.parentAgentId === parent)
-      : state.agents;
-
-    res.json({
-      mainAgentId: state.mainAgentId,
-      agents,
-    });
-  });
-
-  router.post('/agents', (req, res) => {
-    const body = req.body || {};
-    const command = typeof body.command === 'string' ? body.command.trim() : '';
-    const workspace = typeof body.workspace === 'string' ? body.workspace : null;
-    const task = typeof body.task === 'string' ? body.task.trim() : '';
-    const initialInput = typeof body.initialInput === 'string' ? body.initialInput : task;
-    const createRequestId = typeof body.requestId === 'string' && body.requestId.trim()
-      ? body.requestId
-      : req.get('Idempotency-Key') || '';
-    const controlRequestSignature = requestSignature(body);
-
-    if (!command) {
-      res.status(400).json({ error: 'command is required' });
-      return;
-    }
-
-    const pendingRequest = createRequestId
-      ? createRequestAdmissions.get(createRequestId)
-      : null;
-    if (pendingRequest) {
-      if (pendingRequest.signature !== controlRequestSignature) {
-        res.status(409).json({
-          error: `Create request ${createRequestId} is already in progress with different parameters`,
-        });
-        return;
-      }
-      void pendingRequest.promise.then(outcome => {
-        res.status(outcome.status).json(outcome.body);
-      });
-      return;
-    }
-
-    agentManager.startAgent(command, workspace, (agentId, error, metadata = {}) => {
-      if (error) {
-        res.status(400).json({ error });
-        return;
-      }
-
-      if (!agentId) {
-        res.status(500).json({ error: 'failed to start agent' });
-        return;
-      }
-
-      if (metadata.deduplicated === true) {
-        const recorded = metadata.createResult?.controlApi;
-        if (recorded && Number.isInteger(recorded.status) && recorded.body) {
-          res.status(recorded.status).json(recorded.body);
-          return;
-        }
-        const admitted = createRequestId
-          ? createRequestAdmissions.get(createRequestId)
-          : null;
-        if (admitted) {
-          void admitted.promise.then(outcome => {
-            res.status(outcome.status).json(outcome.body);
-          });
-          return;
-        }
-        res.status(409).json({
-          error: 'Create succeeded, but the initial-input outcome is unknown; input was not replayed',
-          code: 'create-result-unknown',
-          agentId,
-        });
-        return;
-      }
-
-      const deliveryPromise = (async () => {
-        if (!initialInput) {
-          notifyUpdate();
-          return {
-            status: 201,
-            body: { agentId, initialInputDelivered: false },
-          };
-        }
-
-        const started = findAgent(agentManager.getState(), agentId);
-        if (!started) throw Object.assign(new Error('Agent disappeared before initial input delivery'), {
-          code: 'agent-removed',
-        });
-        const structuredRuntime = runtimeKind(started) !== 'terminal';
-        if (structuredRuntime) {
-          await agentManager.sendComposerMessage(agentId, initialInput);
-          notifyUpdate();
-          return {
-            status: 201,
-            body: { agentId, initialInputDelivered: true, inputMode: 'structured' },
-          };
-        }
-
-        const readiness = await waitForTerminalInputReadiness(agentManager, agentId, {
-          expectedStartedAt: started.startedAt,
-          expectedRuntimeEpoch: started.runtimeEpoch,
-          timeoutMs: initialInputTimeoutMs,
-        });
-        const result = await runTerminalMutation(
-          agentId,
-          readiness.expectedRuntimeEpoch,
-          async ({ expectedRuntimeEpoch }) => {
-            const current = findAgent(agentManager.getState(), agentId);
-            if (
-              !current ||
-              Number(current.startedAt) !== readiness.expectedStartedAt ||
-              current.runtimeEpoch !== readiness.expectedRuntimeEpoch ||
-              current.terminalInputReceived === true ||
-              current.status !== 'running' ||
-              !terminalInputReady(terminalReadinessOptions(current))
-            ) {
-              return { status: 'rejected', reason: 'startup-state-changed' };
-            }
-            return agentManager.sendInput(agentId, ensureTrailingNewline(initialInput), {
-              expectedRuntimeEpoch,
-            });
-          },
-        );
-        if (!result || result.status === 'rejected' || result.status === 'input-rejected') {
-          const reason = result?.reason || 'initial-input-rejected';
-          throw Object.assign(new Error(`Initial Terminal task was not delivered: ${reason}`), { code: reason });
-        }
-        notifyUpdate();
-        return {
-          status: 201,
-          body: { agentId, initialInputDelivered: true, inputMode: 'terminal' },
-        };
-      })().catch(deliveryError => {
-        const status = deliveryError?.code === 'initial-input-timeout' ? 504 : 409;
-        return {
-          status,
-          body: {
-            error: deliveryError?.message || 'Initial input delivery failed',
-            code: deliveryError?.code || 'initial-input-failed',
-            agentId,
-            initialInputDelivered: false,
-          },
-        };
-      });
-      const durableDeliveryPromise = deliveryPromise.then(outcome => {
-        if (!createRequestId) return outcome;
-        let persisted;
-        try {
-          persisted = agentManager.recordCreateRequestResult(
-            agentId,
-            createRequestId,
-            { controlApi: outcome },
-          );
-        } catch (error) {
-          persisted = { error: error?.message || 'Create result persistence failed' };
-        }
-        if (persisted?.error) {
-          return {
-            status: 409,
-            body: {
-              error: `${persisted.error}; Create outcome was not persisted and initial input was not replayed`,
-              code: 'create-result-not-durable',
-              agentId,
-              initialInputDelivered: outcome.body?.initialInputDelivered === true,
-              createResultDurable: false,
-            },
-          };
-        }
-        return outcome;
-      });
-      if (createRequestId) {
-        const admission = {
-          signature: controlRequestSignature,
-          promise: durableDeliveryPromise,
-        };
-        createRequestAdmissions.set(createRequestId, admission);
-        void durableDeliveryPromise.finally(() => {
-          if (createRequestAdmissions.get(createRequestId) === admission) {
-            createRequestAdmissions.delete(createRequestId);
-          }
-        }).catch(() => {});
-      }
-      void durableDeliveryPromise.then(outcome => {
-        res.status(outcome.status).json(outcome.body);
-      });
-    }, {
-      wantsMain: false,
-      parentAgentId: typeof body.parentAgentId === 'string' ? body.parentAgentId : '',
-      task,
-      source: 'control-cli',
-      createRequestId,
-      createInitialInputSignature: requestSignature(initialInput),
-      agentRuntimeMode: ['json', 'acp', 'chat'].includes(body.agentRuntimeMode) ? body.agentRuntimeMode : 'terminal',
-      acpHistoryMode: body.acpHistoryMode === 'resume' ? 'resume' : 'load',
-      providerSessionTitle: typeof body.providerSessionTitle === 'string' ? body.providerSessionTitle : '',
-      ...(Array.isArray(body.additionalDirectories) ? { additionalDirectories: body.additionalDirectories } : {}),
-      ...(Array.isArray(body.mcpServers) ? { mcpServers: body.mcpServers } : {}),
-      dangerouslySkipPermissions: body.dangerouslySkipPermissions === true,
-    });
-  });
-
-  router.post('/agents/:agentId/input', async (req, res) => {
-    const agentId = req.params.agentId;
-    const state = agentManager.getState();
-    if (!findAgent(state, agentId)) {
-      res.status(404).json({ error: 'agent not found' });
-      return;
-    }
-
-    if (agentManager.agentSupportsTerminalInput?.(agentId) === false) {
-      res.status(409).json({ error: 'raw input is only available for Terminal Agents' });
-      return;
-    }
-    const expectedRuntimeEpoch = typeof findAgent(agentManager.getState(), agentId)?.runtimeEpoch === 'string'
-      ? findAgent(agentManager.getState(), agentId).runtimeEpoch
-      : '';
-    if (!expectedRuntimeEpoch) {
-      res.status(409).json({ error: 'terminal runtime is not ready' });
-      return;
-    }
-    const input = typeof req.body.input === 'string' ? req.body.input : '';
-    const result = await runTerminalMutation(agentId, expectedRuntimeEpoch, ({ expectedRuntimeEpoch: epoch }) => (
-      agentManager.sendInput(agentId, input, { expectedRuntimeEpoch: epoch })
-    ));
-    if (!result || result.status === 'rejected' || result.status === 'input-rejected') {
-      res.status(409).json({ error: result?.reason || 'terminal input rejected' });
-      return;
-    }
-    res.json({ success: true });
-  });
-
-  router.post('/agents/:agentId/clear', async (req, res) => {
-    const agentId = req.params.agentId;
-    const state = agentManager.getState();
-    if (!findAgent(state, agentId)) {
-      res.status(404).json({ error: 'agent not found' });
-      return;
-    }
-
-    if (agentManager.agentSupportsTerminalInput?.(agentId) === false) {
-      res.status(409).json({ error: 'clear is only available for Terminal Agents' });
-      return;
-    }
-    const expectedRuntimeEpoch = typeof findAgent(agentManager.getState(), agentId)?.runtimeEpoch === 'string'
-      ? findAgent(agentManager.getState(), agentId).runtimeEpoch
-      : '';
-    if (!expectedRuntimeEpoch) {
-      res.status(409).json({ error: 'terminal runtime is not ready' });
-      return;
-    }
-    const result = await runTerminalMutation(agentId, expectedRuntimeEpoch, ({ expectedRuntimeEpoch: epoch }) => (
-      agentManager.clearAgentSessionBuffer(agentId, { expectedRuntimeEpoch: epoch })
-    ));
-    if (!result || result.status === 'rejected' || result.cleared === false) {
-      res.status(409).json({ error: result?.reason || result?.error || 'terminal clear rejected' });
-      return;
-    }
-    notifyUpdate();
-    res.json({ success: Boolean(result && result.cleared), ...result });
-  });
-
-  router.get('/agents/:agentId/output', async (req, res) => {
-    const agentId = req.params.agentId;
-    const state = agentManager.getState();
-    if (!findAgent(state, agentId)) {
-      res.status(404).json({ error: 'agent not found' });
-      return;
-    }
-
-    const output = await agentManager.getAgentSessionText(agentId);
-    const tail = normalizeTail(req.query.tail);
-    const text = tail > 0 ? String(output || '').slice(-tail) : String(output || '');
-
-    res.type('text/plain');
-    res.send(text);
-  });
-
-  router.delete('/agents/:agentId', async (req, res) => {
-    const agentId = req.params.agentId;
-    const recordHistory = req.query?.recordHistory !== '0';
-    let requested;
-    try {
-      requested = await agentManager.requestKillAgent(agentId, { recordHistory });
-    } catch (error) {
-      res.status(503).json({
-        error: error?.message || 'Agent lifecycle recovery is unavailable',
-        retryable: true,
-      });
-      return;
-    }
-    const result = requested.result;
-    if (result?.error) {
-      res.status(409).json({ error: result.error });
-      return;
-    }
-    if (result?.accepted) {
-      void requested.completion.finally(() => notifyUpdate()).catch(() => {});
-      res.status(202).json(result);
-      return;
-    }
-    notifyUpdate();
-    res.json({ success: true, agentId, ...result });
-  });
-
-  return router;
-}
-
-module.exports = {
-  DEFAULT_INITIAL_INPUT_TIMEOUT_MS,
-  createControlRouter,
-  ensureTrailingNewline,
-  waitForTerminalInputReadiness,
-};

package/backend/executable-discovery.js

@@ -1,216 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { execFileSync } = require('child_process');
-const { getUserLaunchAgents } = require('./cli-agents');
-
-const DEFAULT_CODEX_APP_BIN = '/Applications/Codex.app/Contents/Resources/codex';
-const DEFAULT_CHATGPT_APP_CODEX_BIN = '/Applications/ChatGPT.app/Contents/Resources/codex';
-const executableVersionCache = new Map();
-
-function getPathDirectories(pathEnv = process.env.PATH || '') {
-  return String(pathEnv)
-    .split(path.delimiter)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-function isExecutable(filePath) {
-  try {
-    fs.accessSync(filePath, fs.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function parseCliVersion(value) {
-  const match = String(value || '').match(/(\d+\.\d+\.\d+)/);
-  return match ? match[1] : '';
-}
-
-function compareCliVersions(left, right) {
-  const leftParts = parseCliVersion(left).split('.').map(part => Number(part));
-  const rightParts = parseCliVersion(right).split('.').map(part => Number(part));
-  if (leftParts.length !== 3 || rightParts.length !== 3) return 0;
-
-  for (let index = 0; index < 3; index += 1) {
-    const delta = leftParts[index] - rightParts[index];
-    if (delta !== 0) return delta;
-  }
-  return 0;
-}
-
-function readExecutableCliVersion(filePath, runner = execFileSync) {
-  try {
-    return parseCliVersion(runner(filePath, ['--version'], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: 2000,
-    }));
-  } catch {
-    return '';
-  }
-}
-
-function getExecutableVersionCacheKey(filePath) {
-  try {
-    const stats = fs.statSync(filePath);
-    return `${filePath}:${stats.size}:${stats.mtimeMs}`;
-  } catch {
-    return `${filePath}:missing`;
-  }
-}
-
-function readCachedExecutableCliVersion(filePath, readVersion, options = {}) {
-  if (options.cacheVersions === false) {
-    return readVersion(filePath);
-  }
-
-  const cacheToken = getExecutableVersionCacheKey(filePath);
-  if (executableVersionCache.has(cacheToken)) {
-    return executableVersionCache.get(cacheToken);
-  }
-
-  const version = readVersion(filePath);
-  const prefix = `${filePath}:`;
-  Array.from(executableVersionCache.keys())
-    .filter(key => key.startsWith(prefix) && key !== cacheToken)
-    .forEach(key => executableVersionCache.delete(key));
-  executableVersionCache.set(cacheToken, version);
-  return version;
-}
-
-function clearExecutableVersionCache() {
-  executableVersionCache.clear();
-}
-
-function getPreferredExecutableCandidates(agentName, pathEnv = process.env.PATH || '') {
-  const pathCandidates = getPathDirectories(pathEnv).map((dir) => path.join(dir, agentName));
-  if (agentName === 'claude') {
-    return [
-      process.env.FARMING_CLAUDE_BIN || '',
-      process.env.CLAUDE_CODE_EXECUTABLE || '',
-      ...pathCandidates,
-    ].filter(Boolean);
-  }
-  if (agentName !== 'codex') return pathCandidates;
-
-  return [
-    process.env.FARMING_CODEX_BIN || '',
-    DEFAULT_CODEX_APP_BIN,
-    DEFAULT_CHATGPT_APP_CODEX_BIN,
-    ...pathCandidates,
-  ].filter(Boolean);
-}
-
-function resolveAgentExecutable(agentName, pathEnv = process.env.PATH || '') {
-  return getPreferredExecutableCandidates(agentName, pathEnv).find(isExecutable) || '';
-}
-
-function resolveCompatibleCodexExecutable(requiredVersion = '', pathEnv = process.env.PATH || '', options = {}) {
-  const normalizedRequired = parseCliVersion(requiredVersion);
-  const readVersion = typeof options.readVersion === 'function'
-    ? options.readVersion
-    : readExecutableCliVersion;
-  const rawCandidates = Array.isArray(options.candidates)
-    ? options.candidates
-    : getPreferredExecutableCandidates('codex', pathEnv);
-  const seen = new Set();
-  const inspected = rawCandidates
-    .filter(Boolean)
-    .filter(candidate => {
-      if (seen.has(candidate)) return false;
-      seen.add(candidate);
-      return true;
-    })
-    .filter(isExecutable)
-    .map(candidate => ({
-      path: candidate,
-      version: readCachedExecutableCliVersion(candidate, readVersion, options),
-    }));
-
-  if (inspected.length === 0) {
-    return {
-      path: '',
-      version: '',
-      requiredVersion: normalizedRequired,
-      compatible: false,
-      error: 'Codex executable not found',
-    };
-  }
-
-  if (!normalizedRequired) {
-    const selected = inspected[0];
-    return {
-      path: selected.path,
-      version: selected.version,
-      requiredVersion: '',
-      compatible: true,
-      error: '',
-    };
-  }
-
-  const compatibleKnown = inspected.find(candidate => (
-    candidate.version && compareCliVersions(candidate.version, normalizedRequired) >= 0
-  ));
-  if (compatibleKnown) {
-    return {
-      path: compatibleKnown.path,
-      version: compatibleKnown.version,
-      requiredVersion: normalizedRequired,
-      compatible: true,
-      error: '',
-    };
-  }
-
-  const unknownVersion = inspected.find(candidate => !candidate.version);
-  if (unknownVersion) {
-    return {
-      path: unknownVersion.path,
-      version: '',
-      requiredVersion: normalizedRequired,
-      compatible: true,
-      error: '',
-    };
-  }
-
-  const newestKnown = inspected
-    .filter(candidate => candidate.version)
-    .sort((left, right) => compareCliVersions(right.version, left.version))[0];
-  const newestVersion = newestKnown ? newestKnown.version : '';
-  return {
-    path: newestKnown ? newestKnown.path : inspected[0].path,
-    version: newestVersion,
-    requiredVersion: normalizedRequired,
-    compatible: false,
-    error: newestVersion
-      ? `Codex CLI ${newestVersion} is older than this session (${normalizedRequired}). Update Codex or set FARMING_CODEX_BIN to a newer Codex executable.`
-      : `Codex CLI version could not be verified for session ${normalizedRequired}. Update Codex or set FARMING_CODEX_BIN to a newer Codex executable.`,
-  };
-}
-
-function listAvailableAgents(pathEnv = process.env.PATH || '') {
-  return getUserLaunchAgents()
-    .map((agent) => ({
-      ...agent,
-      resolvedPath: resolveAgentExecutable(agent.command || agent.name, pathEnv),
-    }))
-    .filter((agent) => Boolean(agent.resolvedPath))
-    .map((agent) => ({
-      ...agent,
-      available: true
-    }));
-}
-
-module.exports = {
-  getPathDirectories,
-  getPreferredExecutableCandidates,
-  compareCliVersions,
-  clearExecutableVersionCache,
-  isExecutable,
-  listAvailableAgents,
-  parseCliVersion,
-  readExecutableCliVersion,
-  resolveAgentExecutable,
-  resolveCompatibleCodexExecutable
-};