farming-code 2.2.30 → 2.2.32

package/THIRD_PARTY_NOTICES.md

@@ -25,8 +25,10 @@ preserved in bundled `node_modules` when bundled dependencies are enabled.
 | `@xterm/xterm` | 6.0.0 | MIT | Browser terminal renderer |
 | `ansi-to-html` | 0.7.2 | MIT | ANSI text rendering support |
 | `chokidar` | 5.0.0 | MIT | Filesystem watching |
+| `compression` | 1.8.1 | MIT | HTTP response compression |
 | `diff` | 9.0.0 | BSD-3-Clause | Character-level diff ranges for code review |
 | `express` | 4.22.2 | MIT | HTTP API server |
+| `extract-zip` | 2.0.1 | BSD-2-Clause | Managed Chromium archive extraction |
 | `ghostty-web` | 0.4.0 | MIT | Optional/debug terminal renderer assets |
 | `highlight.js` | 11.11.1 | BSD-3-Clause | Syntax highlighting |
 | `html2canvas` | 1.4.1 | MIT | Pet rest-scene snapshot capture |
@@ -71,6 +73,11 @@ Farming accepts only the version-locked sources and integrity values declared
 by its release manifest. The `agent-browser` license text is included at
 `backend/data/LICENSE.agent-browser`.
 
+The optional Computer plugin interoperates with the version-pinned Cua Driver
+0.12.4 and `trycua/xfce-cua` container image. Farming does not bundle that
+container image in its release package. Cua is licensed under MIT; its license
+text is included at `backend/data/LICENSE.cua`.
+
 Farming vendors `ghostty-web` distribution files under
 `frontend/vendor/ghostty-web` for the optional Ghostty debug renderer. The
 source package is `ghostty-web` 0.4.0, licensed under MIT. Its license is kept

package/backend/acp/{client-services.js → client-services.cjs}

@@ -1,101 +1,116 @@
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-const nodePty = require('../packaged-node-pty');
-
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_services_exports = {};
+__export(client_services_exports, {
+  AcpClientFileSystem: () => AcpClientFileSystem,
+  AcpClientTerminalManager: () => AcpClientTerminalManager,
+  resolveWorkspacePath: () => resolveWorkspacePath
+});
+module.exports = __toCommonJS(client_services_exports);
+var import_packaged_node_pty = require("../packaged-node-pty.cjs");
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
 const fsp = fs.promises;
 const DEFAULT_MAX_FILE_BYTES = 8 * 1024 * 1024;
 const DEFAULT_TERMINAL_OUTPUT_BYTES = 1024 * 1024;
 const MAX_TERMINAL_OUTPUT_BYTES = 16 * 1024 * 1024;
 const MAX_ACTIVE_TERMINALS_PER_AGENT = 32;
-
 function isInside(root, target) {
   const relative = path.relative(root, target);
-  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
 }
-
 function requireMatchingSession(binding, params) {
-  if (!binding?.sessionId || String(params?.sessionId || '') !== binding.sessionId) {
-    throw new Error('ACP client request does not match the active session');
+  if (!binding?.sessionId || String(params?.sessionId || "") !== binding.sessionId) {
+    throw new Error("ACP client request does not match the active session");
   }
 }
-
 function requireOpenBinding(binding) {
-  if (binding?.exited === true) throw new Error('ACP Agent connection is closed');
+  if (binding?.exited === true) throw new Error("ACP Agent connection is closed");
 }
-
 async function resolveWorkspacePath(binding, requestedPath, options = {}) {
-  const value = String(requestedPath || '');
-  if (!path.isAbsolute(value)) throw new Error('ACP file and terminal paths must be absolute');
+  const value = String(requestedPath || "");
+  if (!path.isAbsolute(value)) throw new Error("ACP file and terminal paths must be absolute");
   const logicalRoot = path.resolve(binding.cwd);
   const root = await fsp.realpath(binding.cwd);
   const logicalTarget = path.resolve(value);
-  const target = isInside(logicalRoot, logicalTarget)
-    ? path.resolve(root, path.relative(logicalRoot, logicalTarget))
-    : isInside(root, logicalTarget)
-      ? logicalTarget
-      : null;
-  if (!target) throw new Error('ACP path is outside the Agent workspace');
-
+  const target = isInside(logicalRoot, logicalTarget) ? path.resolve(root, path.relative(logicalRoot, logicalTarget)) : isInside(root, logicalTarget) ? logicalTarget : null;
+  if (!target) throw new Error("ACP path is outside the Agent workspace");
   if (options.allowMissing === true) {
     const parent = await fsp.realpath(path.dirname(target));
-    if (!isInside(root, parent)) throw new Error('ACP path resolves outside the Agent workspace');
+    if (!isInside(root, parent)) throw new Error("ACP path resolves outside the Agent workspace");
     return target;
   }
-
   const realTarget = await fsp.realpath(target);
-  if (!isInside(root, realTarget)) throw new Error('ACP path resolves outside the Agent workspace');
+  if (!isInside(root, realTarget)) throw new Error("ACP path resolves outside the Agent workspace");
   return realTarget;
 }
-
 class AcpClientFileSystem {
+  maxFileBytes;
   constructor(options = {}) {
     this.maxFileBytes = options.maxFileBytes || DEFAULT_MAX_FILE_BYTES;
   }
-
   async readTextFile(binding, params) {
     requireMatchingSession(binding, params);
     const target = await resolveWorkspacePath(binding, params.path);
     const stat = await fsp.stat(target);
-    if (!stat.isFile()) throw new Error('ACP read path must be a file');
-    if (stat.size > this.maxFileBytes) throw new Error('ACP text file is too large to read');
-    const content = await fsp.readFile(target, 'utf8');
+    if (!stat.isFile()) throw new Error("ACP read path must be a file");
+    if (stat.size > this.maxFileBytes) throw new Error("ACP text file is too large to read");
+    const content = await fsp.readFile(target, "utf8");
     const requestedLine = params.line == null ? 1 : Number(params.line);
     const requestedLimit = params.limit == null ? null : Number(params.limit);
-    if (!Number.isInteger(requestedLine) || requestedLine < 1) throw new Error('ACP read line must be a positive integer');
+    if (!Number.isInteger(requestedLine) || requestedLine < 1) throw new Error("ACP read line must be a positive integer");
     if (requestedLimit !== null && (!Number.isInteger(requestedLimit) || requestedLimit < 0)) {
-      throw new Error('ACP read limit must be a non-negative integer');
+      throw new Error("ACP read limit must be a non-negative integer");
     }
     if (requestedLine === 1 && requestedLimit === null) return { content };
-    const lines = content.split('\n');
+    const lines = content.split("\n");
     const start = requestedLine - 1;
     const end = requestedLimit === null ? lines.length : start + requestedLimit;
-    return { content: lines.slice(start, end).join('\n') };
+    return { content: lines.slice(start, end).join("\n") };
   }
-
   async writeTextFile(binding, params) {
     requireMatchingSession(binding, params);
-    const content = String(params.content ?? '');
-    if (Buffer.byteLength(content, 'utf8') > this.maxFileBytes) {
-      throw new Error('ACP text file is too large to write');
+    const content = String(params.content ?? "");
+    if (Buffer.byteLength(content, "utf8") > this.maxFileBytes) {
+      throw new Error("ACP text file is too large to write");
     }
     const target = await resolveWorkspacePath(binding, params.path, { allowMissing: true });
     requireOpenBinding(binding);
-    let mode = 0o666;
+    let mode = 438;
     try {
       const existing = await fsp.realpath(target);
       const root = await fsp.realpath(binding.cwd);
-      if (!isInside(root, existing)) throw new Error('ACP path resolves outside the Agent workspace');
+      if (!isInside(root, existing)) throw new Error("ACP path resolves outside the Agent workspace");
       const stat = await fsp.stat(existing);
-      if (!stat.isFile()) throw new Error('ACP write path must be a file');
+      if (!stat.isFile()) throw new Error("ACP write path must be a file");
       mode = stat.mode;
     } catch (error) {
-      if (error?.code !== 'ENOENT') throw error;
+      if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
+        throw error;
+      }
     }
     const temporary = path.join(
       path.dirname(target),
-      `.${path.basename(target)}.farming-acp-${process.pid}-${crypto.randomUUID()}.tmp`,
+      `.${path.basename(target)}.farming-acp-${process.pid}-${crypto.randomUUID()}.tmp`
     );
     try {
       requireOpenBinding(binding);
@@ -103,38 +118,35 @@ class AcpClientFileSystem {
       requireOpenBinding(binding);
       await fsp.rename(temporary, target);
     } catch (error) {
-      await fsp.rm(temporary, { force: true }).catch(() => {});
+      await fsp.rm(temporary, { force: true }).catch(() => {
+      });
       throw error;
     }
     return {};
   }
 }
-
 function boundedOutputLimit(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_TERMINAL_OUTPUT_BYTES;
   return Math.min(MAX_TERMINAL_OUTPUT_BYTES, Math.max(1, Math.floor(parsed)));
 }
-
 function trimUtf8Start(buffer, limit) {
   if (buffer.length <= limit) return { buffer, truncated: false };
   let start = buffer.length - limit;
-  while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start += 1;
+  while (start < buffer.length && (buffer[start] & 192) === 128) start += 1;
   return { buffer: buffer.subarray(start), truncated: true };
 }
-
 class AcpClientTerminalManager {
+  spawn;
+  ptySpawn;
+  terminals;
+  pendingCreates;
   constructor(options = {}) {
-    this.spawn = options.spawn || spawn;
-    this.ptySpawn = typeof options.ptySpawn === 'function'
-      ? options.ptySpawn
-      : typeof options.spawn === 'function'
-        ? null
-        : nodePty.spawn;
-    this.terminals = new Map();
-    this.pendingCreates = new Map();
+    this.spawn = options.spawn || ((command, args, spawnOptions) => spawn(command, args, spawnOptions));
+    this.ptySpawn = typeof options.ptySpawn === "function" ? options.ptySpawn : typeof options.spawn === "function" ? null : import_packaged_node_pty.nodePty.spawn;
+    this.terminals = /* @__PURE__ */ new Map();
+    this.pendingCreates = /* @__PURE__ */ new Map();
   }
-
   activeCount(agentId) {
     let count = 0;
     for (const record of this.terminals.values()) {
@@ -142,21 +154,18 @@ class AcpClientTerminalManager {
     }
     return count;
   }
-
   reserveCreate(agentId) {
     const pending = this.pendingCreates.get(agentId) || 0;
     if (this.activeCount(agentId) + pending >= MAX_ACTIVE_TERMINALS_PER_AGENT) {
-      throw new Error('ACP terminal limit reached for this Agent');
+      throw new Error("ACP terminal limit reached for this Agent");
     }
     this.pendingCreates.set(agentId, pending + 1);
   }
-
   releaseCreate(agentId) {
     const pending = this.pendingCreates.get(agentId) || 0;
     if (pending <= 1) this.pendingCreates.delete(agentId);
     else this.pendingCreates.set(agentId, pending - 1);
   }
-
   async create(binding, params) {
     requireMatchingSession(binding, params);
     this.reserveCreate(binding.agentId);
@@ -166,36 +175,20 @@ class AcpClientTerminalManager {
       this.releaseCreate(binding.agentId);
     }
   }
-
   async createReserved(binding, params) {
-    const command = String(params.command || '').trim();
-    if (!command) throw new Error('ACP terminal command is required');
-    const cwd = params.cwd
-      ? await resolveWorkspacePath(binding, params.cwd)
-      : await fsp.realpath(binding.cwd);
+    const command = String(params.command || "").trim();
+    if (!command) throw new Error("ACP terminal command is required");
+    const cwd = params.cwd ? await resolveWorkspacePath(binding, params.cwd) : await fsp.realpath(binding.cwd);
     requireOpenBinding(binding);
     const env = { ...binding.env };
     for (const item of Array.isArray(params.env) ? params.env : []) {
-      const name = String(item?.name || '');
-      if (!name || name.includes('=') || name.includes('\0')) throw new Error('Invalid ACP terminal environment variable');
-      env[name] = String(item?.value ?? '');
+      const name = String(item?.name || "");
+      if (!name || name.includes("=") || name.includes("\0")) throw new Error("Invalid ACP terminal environment variable");
+      env[name] = String(item?.value ?? "");
     }
     const terminalId = `acp-terminal-${crypto.randomUUID()}`;
     const args = Array.isArray(params.args) ? params.args.map(String) : [];
-    const child = this.ptySpawn
-      ? this.ptySpawn(command, args, {
-          cwd,
-          env,
-          name: 'xterm-256color',
-          cols: 80,
-          rows: 24,
-        })
-      : this.spawn(command, args, {
-          cwd,
-          env,
-          stdio: ['ignore', 'pipe', 'pipe'],
-        });
-    const record = {
+    const baseRecord = {
       terminalId,
       agentId: binding.agentId,
       sessionId: binding.sessionId,
@@ -204,141 +197,146 @@ class AcpClientTerminalManager {
       cwd,
       startedAt: Date.now(),
       endedAt: null,
-      child,
       output: Buffer.alloc(0),
       outputLimit: boundedOutputLimit(params.outputByteLimit),
       truncated: false,
       exitStatus: null,
       released: false,
-      waiters: [],
-      interactive: Boolean(this.ptySpawn),
+      waiters: []
     };
-    this.terminals.set(terminalId, record);
-    const append = chunk => {
+    let record;
+    const append = (chunk) => {
       const next = Buffer.concat([record.output, Buffer.from(chunk)]);
       const bounded = trimUtf8Start(next, record.outputLimit);
       record.output = bounded.buffer;
       record.truncated = record.truncated || bounded.truncated;
     };
-    if (record.interactive) {
+    if (this.ptySpawn) {
+      const child = this.ptySpawn(command, args, {
+        cwd,
+        env,
+        name: "xterm-256color",
+        cols: 80,
+        rows: 24
+      });
+      record = { ...baseRecord, child, interactive: true };
+      this.terminals.set(terminalId, record);
       child.onData(append);
-      child.onExit(event => this.finish(record, {
+      child.onExit((event) => this.finish(record, {
         exitCode: Number.isInteger(event?.exitCode) ? event.exitCode : null,
-        signal: Number.isInteger(event?.signal) && event.signal > 0 ? String(event.signal) : null,
+        signal: typeof event?.signal === "number" && Number.isInteger(event.signal) && event.signal > 0 ? String(event.signal) : null
       }));
     } else {
-      child.stdout?.on('data', append);
-      child.stderr?.on('data', append);
-      child.on('error', error => {
-        append(`${error.message || error}\n`);
-        this.finish(record, { exitCode: null, signal: 'spawn-error' });
+      const child = this.spawn(command, args, {
+        cwd,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      record = { ...baseRecord, child, interactive: false };
+      this.terminals.set(terminalId, record);
+      child.stdout?.on("data", append);
+      child.stderr?.on("data", append);
+      child.on("error", (error) => {
+        append(`${error.message || error}
+`);
+        this.finish(record, { exitCode: null, signal: "spawn-error" });
       });
-      child.on('close', (code, signal) => this.finish(record, {
+      child.on("close", (code, signal) => this.finish(record, {
         exitCode: Number.isInteger(code) ? code : null,
-        signal: signal ? String(signal) : null,
+        signal: signal ? String(signal) : null
       }));
     }
     return { terminalId };
   }
-
   require(binding, params, options = {}) {
     requireMatchingSession(binding, params);
-    const record = this.terminals.get(String(params.terminalId || ''));
+    const record = this.terminals.get(String(params.terminalId || ""));
     if (!record || record.agentId !== binding.agentId || record.sessionId !== binding.sessionId) {
-      throw new Error('Unknown ACP terminal');
+      throw new Error("Unknown ACP terminal");
     }
-    if (record.released && options.allowReleased !== true) throw new Error('ACP terminal has been released');
+    if (record.released && options.allowReleased !== true) throw new Error("ACP terminal has been released");
     return record;
   }
-
   finish(record, exitStatus) {
     if (record.exitStatus) return;
     record.exitStatus = exitStatus;
     record.endedAt = Date.now();
     const waiters = record.waiters.splice(0);
-    waiters.forEach(resolve => resolve({ ...exitStatus }));
+    waiters.forEach((resolve) => resolve({ ...exitStatus }));
   }
-
   output(binding, params) {
     const record = this.require(binding, params);
     return {
-      output: record.output.toString('utf8'),
+      output: record.output.toString("utf8"),
       truncated: record.truncated,
-      ...(record.exitStatus ? { exitStatus: { ...record.exitStatus } } : {}),
+      ...record.exitStatus ? { exitStatus: { ...record.exitStatus } } : {}
     };
   }
-
   waitForExit(binding, params) {
     const record = this.require(binding, params);
     if (record.exitStatus) return { ...record.exitStatus };
-    return new Promise(resolve => record.waiters.push(resolve));
+    return new Promise((resolve) => record.waiters.push(resolve));
   }
-
   input(binding, params) {
     const record = this.require(binding, params);
-    if (!record.interactive) throw new Error('ACP terminal does not accept interactive input');
-    if (record.exitStatus) throw new Error('ACP terminal has already exited');
-    const input = String(params.input ?? '');
-    if (Buffer.byteLength(input, 'utf8') > 64 * 1024) throw new Error('ACP terminal input is too large');
+    if (!record.interactive) throw new Error("ACP terminal does not accept interactive input");
+    if (record.exitStatus) throw new Error("ACP terminal has already exited");
+    const input = String(params.input ?? "");
+    if (Buffer.byteLength(input, "utf8") > 64 * 1024) throw new Error("ACP terminal input is too large");
     record.child.write(input);
     return {};
   }
-
   resize(binding, params) {
     const record = this.require(binding, params);
     if (!record.interactive) return {};
     const cols = Number(params.cols);
     const rows = Number(params.rows);
-    if (!Number.isInteger(cols) || cols < 2 || cols > 1000 || !Number.isInteger(rows) || rows < 1 || rows > 1000) {
-      throw new Error('ACP terminal size is invalid');
+    if (!Number.isInteger(cols) || cols < 2 || cols > 1e3 || !Number.isInteger(rows) || rows < 1 || rows > 1e3) {
+      throw new Error("ACP terminal size is invalid");
     }
     if (!record.exitStatus) record.child.resize(cols, rows);
     return {};
   }
-
   kill(binding, params) {
     const record = this.require(binding, params);
-    if (!record.exitStatus && !record.child.killed) record.child.kill('SIGTERM');
+    if (!record.exitStatus && !record.child.killed) record.child.kill("SIGTERM");
     return {};
   }
-
   release(binding, params) {
     const record = this.require(binding, params);
-    if (!record.exitStatus && !record.child.killed) record.child.kill('SIGTERM');
+    if (!record.exitStatus && !record.child.killed) record.child.kill("SIGTERM");
     record.released = true;
     return {};
   }
-
   display(terminalId) {
-    const record = this.terminals.get(String(terminalId || ''));
+    const record = this.terminals.get(String(terminalId || ""));
     if (!record) return null;
     return {
       command: record.command,
       args: [...record.args],
       cwd: record.cwd,
-      output: record.output.toString('utf8'),
+      output: record.output.toString("utf8"),
       truncated: record.truncated,
       exitStatus: record.exitStatus ? { ...record.exitStatus } : null,
       released: record.released,
       startedAt: record.startedAt,
       endedAt: record.endedAt,
       durationMs: Math.max(0, (record.endedAt || Date.now()) - record.startedAt),
-      interactive: record.interactive,
+      interactive: record.interactive
     };
   }
-
   cleanupAgent(agentId) {
     for (const [terminalId, record] of this.terminals) {
       if (record.agentId !== agentId) continue;
-      if (!record.exitStatus && !record.child.killed) record.child.kill('SIGTERM');
+      if (!record.exitStatus && !record.child.killed) record.child.kill("SIGTERM");
       this.terminals.delete(terminalId);
-      this.finish(record, { exitCode: null, signal: 'SIGTERM' });
+      this.finish(record, { exitCode: null, signal: "SIGTERM" });
     }
   }
 }
-
-module.exports = {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   AcpClientFileSystem,
   AcpClientTerminalManager,
-  resolveWorkspacePath,
-};
+  resolveWorkspacePath
+});

package/backend/acp/packaged-claude-acp.cjs

@@ -0,0 +1,37 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var packaged_claude_acp_exports = {};
+__export(packaged_claude_acp_exports, {
+  PACKAGED_CLAUDE_ACP_ARG: () => PACKAGED_CLAUDE_ACP_ARG,
+  runPackagedClaudeAcp: () => runPackagedClaudeAcp
+});
+module.exports = __toCommonJS(packaged_claude_acp_exports);
+const PACKAGED_CLAUDE_ACP_ARG = "--farming-claude-acp";
+async function runPackagedClaudeAcp() {
+  if (!process.pkg) {
+    throw new Error("The packaged Claude ACP entry is available only in a standalone Farming CLI");
+  }
+  throw new Error("The standalone Farming CLI omitted its embedded Claude ACP runtime");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PACKAGED_CLAUDE_ACP_ARG,
+  runPackagedClaudeAcp
+});

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

@@ -0,0 +1,37 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var packaged_codex_acp_exports = {};
+__export(packaged_codex_acp_exports, {
+  PACKAGED_CODEX_ACP_ARG: () => PACKAGED_CODEX_ACP_ARG,
+  runPackagedCodexAcp: () => runPackagedCodexAcp
+});
+module.exports = __toCommonJS(packaged_codex_acp_exports);
+const PACKAGED_CODEX_ACP_ARG = "--farming-codex-acp";
+async function runPackagedCodexAcp() {
+  if (!process.pkg) {
+    throw new Error("The packaged Codex ACP entry is available only in a standalone Farming CLI");
+  }
+  throw new Error("The standalone Farming CLI omitted its embedded Codex ACP runtime");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PACKAGED_CODEX_ACP_ARG,
+  runPackagedCodexAcp
+});