farming-code 2.2.13 → 2.2.16

package/backend/acp-runtime.js

@@ -1,4 +1,5 @@
 const EventEmitter = require('events');
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
@@ -9,6 +10,7 @@ const { AcpCheckpointStore } = require('./acp-checkpoint-store');
 const { AcpSessionState } = require('./acp-session-state');
 const { readCodexHistoryImageData } = require('./codex-transcript');
 const { AcpClientFileSystem, AcpClientTerminalManager } = require('./acp/client-services');
+const { PACKAGED_CODEX_ACP_ARG } = require('./acp/packaged-codex-acp');
 const { permissionSecurityWarnings } = require('./acp/permission-security');
 const { rejectPatch } = require('./acp/patch-decisions');
 const { getProviderAdapter, listProviderAdapters } = require('./provider-adapters');
@@ -25,6 +27,17 @@ const DEFAULT_HISTORY_REPLAY_MIN_WAIT_MS = 350;
 const DEFAULT_HISTORY_REPLAY_QUIET_MS = 150;
 const DEFAULT_HISTORY_REPLAY_MAX_WAIT_MS = 5_000;
 const CODEX_SET_SESSION_MODEL_METHOD = 'session/set_model';
+const CODEX_STEER_METHOD = '_codex/session/steer';
+const CODEX_ACP_PACKAGE = '@agentclientprotocol/codex-acp';
+const CODEX_ACP_VERSION = '1.1.4';
+const CODEX_ACP_SHA256 = '39cbae01e336c2ca185d624358e03280d1f6fef6d73bbe42dd9eb77e2b1efb32';
+const CODEX_ACP_VENDOR_ENTRY = path.join(
+  __dirname,
+  '..',
+  'dist',
+  'acp',
+  `codex-acp-${CODEX_ACP_VERSION}.js`,
+);
 
 let sdkPromise;
 const runtimeRequire = createRequire(__filename);
@@ -33,7 +46,24 @@ function loadAcpSdk() {
   return sdkPromise;
 }
 
+function fileSha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function verifiedCodexAcpEntry(entry) {
+  const actualSha256 = fileSha256(entry);
+  if (actualSha256 !== CODEX_ACP_SHA256) {
+    throw new Error(
+      `Codex ACP runtime failed integrity verification: expected ${CODEX_ACP_SHA256}, found ${actualSha256}`,
+    );
+  }
+  return entry;
+}
+
 function adapterEntry(packageName) {
+  if (packageName === CODEX_ACP_PACKAGE && fs.existsSync(CODEX_ACP_VENDOR_ENTRY)) {
+    return verifiedCodexAcpEntry(CODEX_ACP_VENDOR_ENTRY);
+  }
   let sdkDirectory;
   try {
     sdkDirectory = path.dirname(runtimeRequire.resolve('@agentclientprotocol/sdk'));
@@ -42,11 +72,15 @@ function adapterEntry(packageName) {
   }
   const entry = path.resolve(sdkDirectory, '..', '..', packageName.split('/').pop(), 'dist', 'index.js');
   if (!fs.existsSync(entry)) throw new Error(`ACP adapter is not installed: ${packageName}`);
+  if (packageName === CODEX_ACP_PACKAGE) return verifiedCodexAcpEntry(entry);
   return entry;
 }
 
-function nodeAdapterLaunch(entry, env = process.env) {
+function nodeAdapterLaunch(entry, env = process.env, packagedArg = '') {
   const runtimeEnv = env && typeof env === 'object' ? env : process.env;
+  if (process.pkg && packagedArg) {
+    return { command: process.execPath, args: [packagedArg] };
+  }
   const nodeBin = runtimeEnv.FARMING_NODE_BIN || process.execPath;
   const ldPath = runtimeEnv.FARMING_NODE_LD || '';
   const libraryPath = runtimeEnv.FARMING_NODE_LIBRARY_PATH || '';
@@ -69,6 +103,7 @@ function resolveAcpLaunch(provider, options = {}) {
     const launch = nodeAdapterLaunch(
       adapterEntry(adapter.acp.packageName),
       options.runtimeEnv || process.env,
+      adapter.acp.packageName === CODEX_ACP_PACKAGE ? PACKAGED_CODEX_ACP_ARG : '',
     );
     return { ...launch, version: adapter.acp.version };
   }
@@ -202,6 +237,59 @@ function clone(value) {
   return value == null ? value : JSON.parse(JSON.stringify(value));
 }
 
+function acpSessionRequestOptions(options = {}, cwd = process.cwd()) {
+  const root = path.resolve(cwd || process.cwd());
+  const additionalDirectories = Array.isArray(options.additionalDirectories)
+    ? [...new Set(options.additionalDirectories
+      .filter(directory => typeof directory === 'string' && directory.trim())
+      .map(directory => path.resolve(root, directory)))]
+    : [];
+  const mcpServers = Array.isArray(options.mcpServers)
+    ? clone(options.mcpServers.filter(server => server && typeof server === 'object' && !Array.isArray(server)))
+    : [];
+  return { cwd: root, additionalDirectories, mcpServers };
+}
+
+function promptContentForCapabilities(content, capabilities = {}) {
+  const promptCapabilities = capabilities?.promptCapabilities || {};
+  return (Array.isArray(content) ? content : []).flatMap(block => {
+    if (!block || typeof block !== 'object') return [];
+    if (!['image', 'audio'].includes(block.type)) return [clone(block)];
+    if (promptCapabilities[block.type] === true) return [clone(block)];
+
+    const label = block.type === 'audio' ? 'audio' : 'image';
+    const attachmentPath = typeof block.path === 'string' && block.path.trim()
+      ? path.resolve(block.path)
+      : '';
+    const name = attachmentPath ? path.basename(attachmentPath) : `attached ${label}`;
+    const detail = attachmentPath
+      ? `${label[0].toUpperCase()}${label.slice(1)} path: ${attachmentPath}`
+      : `[The ACP Agent does not accept native ${label} content]`;
+    return [{ type: 'text', text: `Attached ${label}: ${name}\n\n${detail}` }];
+  });
+}
+
+function supportsCodexSteer(capabilities = {}) {
+  const capability = capabilities?._meta?.codex?.steer;
+  return capability?.method === CODEX_STEER_METHOD
+    && Number.isFinite(Number(capability.version))
+    && Number(capability.version) >= 1;
+}
+
+function isCodexSteerUnavailableError(error) {
+  const text = [
+    error?.message,
+    error?.data?.details,
+    error?.cause?.message,
+    error?.cause?.data?.details,
+  ].filter(Boolean).join(' ').toLowerCase();
+  return text.includes('no active codex turn to steer')
+    || text.includes('no active turn to steer')
+    || /expected active turn id .* but found/.test(text)
+    || text.includes('cannot steer a review turn')
+    || text.includes('cannot steer a compact turn');
+}
+
 class AcpRuntime extends EventEmitter {
   constructor(options = {}) {
     super();
@@ -231,11 +319,14 @@ class AcpRuntime extends EventEmitter {
     if (this.bindings.has(agentId)) throw new Error('ACP Agent is already registered');
     const provider = String(options.provider || '').trim().toLowerCase();
     const launch = this.resolveLaunch(provider, options);
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const sessionRequestOptions = acpSessionRequestOptions(options, cwd);
     const binding = {
       agentId,
       provider,
       providerHomeId: String(options.providerHomeId || 'default'),
-      cwd: path.resolve(options.cwd || process.cwd()),
+      cwd,
+      sessionRequestOptions,
       env: (getProviderAdapter(provider)?.prepareAcpEnvironment || (value => value.env || process.env))(options),
       launch,
       restartOptions: { ...options, agentId, provider },
@@ -257,6 +348,8 @@ class AcpRuntime extends EventEmitter {
       subagentStates: new Map(),
       interactionOrigins: new Map(),
       promptActive: false,
+      supportsSteer: false,
+      steerTail: null,
       historyReplayActive: false,
       sessionState: null,
       authTerminal: null,
@@ -308,12 +401,14 @@ class AcpRuntime extends EventEmitter {
       if (binding.initializeResponse.protocolVersion !== sdk.PROTOCOL_VERSION) {
         throw new Error(`ACP protocol version mismatch: Agent selected ${binding.initializeResponse.protocolVersion}, Farming supports ${sdk.PROTOCOL_VERSION}`);
       }
+      binding.supportsSteer = binding.provider === 'codex'
+        && supportsCodexSteer(binding.initializeResponse.agentCapabilities);
 
       const requestedSessionId = String(options.sessionId || '').trim();
       const revisionBase = Number.isFinite(Number(options.revisionBase))
         ? Math.max(0, Math.floor(Number(options.revisionBase)))
         : 0;
-      const sessionRequest = { sessionId: requestedSessionId, cwd: binding.cwd, mcpServers: [] };
+      const sessionRequest = { sessionId: requestedSessionId, ...binding.sessionRequestOptions };
       let sessionResponse;
       let historyMode = 'new';
       if (requestedSessionId) {
@@ -413,7 +508,7 @@ class AcpRuntime extends EventEmitter {
         }
       } else {
         sessionResponse = await withTimeout(
-          connection.newSession({ cwd: binding.cwd, mcpServers: [] }),
+          connection.newSession(binding.sessionRequestOptions),
           this.sessionSetupTimeoutMs,
           'ACP session/new'
         );
@@ -697,9 +792,11 @@ class AcpRuntime extends EventEmitter {
   }
 
   requestElicitation(binding, request) {
-    const requestSessionId = String(request?.sessionId || binding.sessionId);
-    const isPrimarySession = requestSessionId === binding.sessionId;
-    if (!isPrimarySession && !binding.subagentStates.has(requestSessionId)) {
+    const hasSessionScope = typeof request?.sessionId === 'string' && request.sessionId.length > 0;
+    const requestSessionId = hasSessionScope ? String(request.sessionId) : '';
+    const isPrimarySession = hasSessionScope && requestSessionId === binding.sessionId;
+    const isRequestScoped = !hasSessionScope;
+    if (!isRequestScoped && !isPrimarySession && !binding.subagentStates.has(requestSessionId)) {
       throw new Error('ACP elicitation does not match an active session');
     }
     if (!['form', 'url'].includes(String(request?.mode || ''))) {
@@ -715,7 +812,7 @@ class AcpRuntime extends EventEmitter {
       ...cloned,
       ...(protocolRequestId !== undefined ? { protocolRequestId } : {}),
       requestId,
-      origin: isPrimarySession ? 'agent' : 'subagent',
+      origin: isRequestScoped ? 'request' : isPrimarySession ? 'agent' : 'subagent',
     };
     binding.interactionOrigins.set(requestId, binding.state);
     binding.pendingElicitations.set(requestId, pending);
@@ -757,7 +854,11 @@ class AcpRuntime extends EventEmitter {
   async prompt(agentId, prompt) {
     const binding = this.requireBinding(agentId);
     if (!['idle', 'error'].includes(binding.state)) throw new Error(`ACP Agent is not ready (${binding.state})`);
-    const content = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
+    const rawContent = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
+    const content = promptContentForCapabilities(
+      rawContent,
+      binding.initializeResponse?.agentCapabilities || {},
+    );
     await this.markCheckpointDirty(binding);
     binding.sessionState.beginPrompt(content);
     binding.promptActive = true;
@@ -795,6 +896,54 @@ class AcpRuntime extends EventEmitter {
     }
   }
 
+  canSteer(agentId) {
+    const binding = this.bindings.get(agentId);
+    return binding?.provider === 'codex'
+      && binding.supportsSteer === true
+      && binding.promptActive === true
+      && Boolean(binding.sessionId)
+      && Boolean(binding.connection);
+  }
+
+  async steer(agentId, prompt) {
+    const binding = this.requireBinding(agentId);
+    if (binding.provider !== 'codex' || binding.supportsSteer !== true) {
+      throw new Error(`${binding.provider} ACP Agent does not support steer`);
+    }
+    const rawContent = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
+    const content = promptContentForCapabilities(
+      rawContent,
+      binding.initializeResponse?.agentCapabilities || {},
+    );
+    const clientMessageId = `farming-steer-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    const operation = async () => {
+      if (!binding.promptActive) throw new Error('No active Codex turn to steer');
+      await this.markCheckpointDirty(binding);
+      const response = await withTimeout(
+        binding.connection.request(CODEX_STEER_METHOD, {
+          sessionId: binding.sessionId,
+          prompt: content,
+          clientMessageId,
+        }),
+        this.requestTimeoutMs,
+        'Codex ACP steer',
+      );
+      return {
+        sessionId: binding.sessionId,
+        turnId: String(response?.turnId || ''),
+        clientMessageId,
+      };
+    };
+    const previous = binding.steerTail || Promise.resolve();
+    const pending = previous.catch(() => {}).then(operation);
+    binding.steerTail = pending;
+    try {
+      return await pending;
+    } finally {
+      if (binding.steerTail === pending) binding.steerTail = null;
+    }
+  }
+
   async cancel(agentId) {
     const binding = this.requireBinding(agentId);
     if (!binding.sessionId) return false;
@@ -871,10 +1020,18 @@ class AcpRuntime extends EventEmitter {
     if (!capabilities?.list) throw new Error(`${binding.provider} ACP Agent does not support session/list`);
     return withTimeout(binding.connection.listSessions({
       ...(options.cwd ? { cwd: path.resolve(options.cwd) } : {}),
+      ...(Array.isArray(options.additionalDirectories)
+        ? { additionalDirectories: acpSessionRequestOptions(options, options.cwd || binding.cwd).additionalDirectories }
+        : {}),
       ...(options.cursor ? { cursor: String(options.cursor) } : {}),
     }), this.requestTimeoutMs, 'ACP session/list');
   }
 
+  getSessionRequestOptions(agentId) {
+    const binding = this.requireBinding(agentId);
+    return clone(binding.sessionRequestOptions);
+  }
+
   async authenticate(agentId, methodId) {
     const binding = this.requireBinding(agentId);
     const method = binding.initializeResponse?.authMethods?.find(item => item.id === methodId);
@@ -896,6 +1053,20 @@ class AcpRuntime extends EventEmitter {
     return { authenticated: true, methodId };
   }
 
+  async logout(agentId) {
+    const binding = this.requireBinding(agentId);
+    if (binding.initializeResponse?.agentCapabilities?.auth?.logout == null) {
+      throw new Error(`${binding.provider} ACP Agent does not support logout`);
+    }
+    await withTimeout(binding.connection.logout({}), this.requestTimeoutMs, 'ACP logout');
+    binding.error = '';
+    binding.stopReason = '';
+    binding.updatedAt = new Date().toISOString();
+    this.emitRuntime(binding);
+    this.emitSession(binding);
+    return { loggedOut: true };
+  }
+
   terminalAuthenticationLaunch(binding, method) {
     const legacy = method?._meta?.['terminal-auth'];
     if (legacy && typeof legacy === 'object' && legacy.command) {
@@ -994,13 +1165,13 @@ class AcpRuntime extends EventEmitter {
     const binding = this.requireBinding(agentId);
     const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
     if (!capabilities?.fork) throw new Error(`${binding.provider} ACP Agent does not support session/fork`);
+    const sessionOptions = acpSessionRequestOptions({
+      additionalDirectories: options.additionalDirectories ?? binding.sessionRequestOptions.additionalDirectories,
+      mcpServers: options.mcpServers ?? binding.sessionRequestOptions.mcpServers,
+    }, options.cwd || binding.cwd);
     return withTimeout(binding.connection.unstable_forkSession({
       sessionId: options.sessionId || binding.sessionId,
-      cwd: path.resolve(options.cwd || binding.cwd),
-      additionalDirectories: Array.isArray(options.additionalDirectories)
-        ? options.additionalDirectories.map(directory => path.resolve(directory))
-        : [],
-      mcpServers: [],
+      ...sessionOptions,
     }), this.sessionSetupTimeoutMs, 'ACP session/fork');
   }
 
@@ -1186,6 +1357,7 @@ class AcpRuntime extends EventEmitter {
       error: binding.error,
       errorKind: binding.error ? acpErrorKind(binding.error) : '',
       stopReason: binding.stopReason,
+      supportsSteer: binding.supportsSteer === true,
       protocolVersion: binding.initializeResponse?.protocolVersion || null,
       agentInfo: binding.initializeResponse?.agentInfo || null,
       capabilities: binding.initializeResponse?.agentCapabilities || {},
@@ -1376,6 +1548,7 @@ class AcpRuntime extends EventEmitter {
       error: binding.error,
       errorKind: binding.error ? acpErrorKind(binding.error) : '',
       stopReason: binding.stopReason,
+      supportsSteer: binding.supportsSteer === true,
       pendingPermission: binding.pendingPermissions.values().next().value || null,
       pendingPermissions: [...binding.pendingPermissions.values()],
       pendingElicitation: binding.pendingElicitations.values().next().value || null,
@@ -1452,8 +1625,13 @@ class AcpRuntime extends EventEmitter {
 module.exports = {
   AcpRuntime,
   ADAPTER_VERSIONS,
+  acpSessionRequestOptions,
   acpErrorKind,
   autoPermissionResponse,
   codexAcpEnvironment,
+  promptContentForCapabilities,
   resolveAcpLaunch,
+  supportsCodexSteer,
+  isCodexSteerUnavailableError,
+  CODEX_STEER_METHOD,
 };