farming-code 2.2.14 → 2.2.16

package/README.md

@@ -119,7 +119,7 @@ farming logs
 farming stop
 ```
 
-The startup token is stored in `~/.farming/.session-token` and reused across restarts and upgrades. **Settings → Updates** can upgrade npm installations in place. GitHub Releases also provide standalone CLI and directory bundles; see [GitHub Releases](https://github.com/zhuwenzhuang/farming/releases) for current artifacts.
+The startup token is stored in `~/.farming/.session-token` and reused across restarts and upgrades. **Settings → Updates** can upgrade npm installations in place. npm updates first use the machine's configured registry and retry the registry shown in Settings only when that registry lacks the selected version. Before installing, Farming verifies that npm will update the same package root that launched the server. GitHub Releases also provide standalone CLI and directory bundles; see [GitHub Releases](https://github.com/zhuwenzhuang/farming/releases) for current artifacts.
 
 To run from source with the same port and base path:
 

package/README.zh_cn.md

@@ -119,7 +119,7 @@ farming logs
 farming stop
 ```
 
-启动 Token 存放在 `~/.farming/.session-token`，重启和升级会继续复用。**Settings → Updates** 可以原地升级 npm 安装。GitHub Releases 也提供独立 CLI 和目录 Bundle；当前产物见 [GitHub Releases](https://github.com/zhuwenzhuang/farming/releases)。
+启动 Token 存放在 `~/.farming/.session-token`，重启和升级会继续复用。**Settings → Updates** 可以原地升级 npm 安装。npm 升级会先使用机器配置的 registry；只有该 registry 缺少所选版本时，才会回退到 Settings 展示版本所用的 registry。安装前 Farming 会校验 npm 将更新的包根目录与启动当前服务的包根目录一致。GitHub Releases 也提供独立 CLI 和目录 Bundle；当前产物见 [GitHub Releases](https://github.com/zhuwenzhuang/farming/releases)。
 
 从源码运行，并使用相同的端口与 Base Path：
 

package/THIRD_PARTY_NOTICES.md

@@ -27,7 +27,7 @@ preserved in bundled `node_modules` when bundled dependencies are enabled.
 | `ansi-to-html` | 0.7.2 | MIT | ANSI text rendering support |
 | `chokidar` | 5.0.0 | MIT | Filesystem watching |
 | `diff` | 9.0.0 | BSD-3-Clause | Character-level diff ranges for code review |
-| `express` | 4.22.1 | MIT | HTTP API server |
+| `express` | 4.22.2 | MIT | HTTP API server |
 | `ghostty-web` | 0.4.0 | MIT | Optional/debug terminal renderer assets |
 | `highlight.js` | 11.11.1 | BSD-3-Clause | Syntax highlighting |
 | `katex` | 0.17.0 | MIT | Mathematical notation rendering |

package/backend/acp/packaged-codex-acp.js

@@ -0,0 +1,13 @@
+const PACKAGED_CODEX_ACP_ARG = '--farming-codex-acp';
+
+function runPackagedCodexAcp() {
+  if (!process.pkg) {
+    throw new Error('The packaged Codex ACP entry is available only in a standalone Farming CLI');
+  }
+  require('../../dist/acp/codex-acp-1.1.4.js');
+}
+
+module.exports = {
+  PACKAGED_CODEX_ACP_ARG,
+  runPackagedCodexAcp,
+};

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,
 };