farming-code 2.2.29 → 2.2.32

package/backend/control-api.cjs

@@ -0,0 +1,439 @@
+// 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 control_api_exports = {};
+__export(control_api_exports, {
+  DEFAULT_INITIAL_INPUT_TIMEOUT_MS: () => DEFAULT_INITIAL_INPUT_TIMEOUT_MS,
+  createControlRouter: () => createControlRouter,
+  ensureTrailingNewline: () => ensureTrailingNewline,
+  waitForTerminalInputReadiness: () => waitForTerminalInputReadiness
+});
+module.exports = __toCommonJS(control_api_exports);
+var import_terminal_status = require("./terminal-status.cjs");
+var import_agent_runtime_binding = require("./agent-runtime-binding.cjs");
+const express = require("express");
+const crypto = require("crypto");
+const DEFAULT_INITIAL_INPUT_TIMEOUT_MS = 3e4;
+const expressFactory = express;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function errorMessage(error, fallback) {
+  return isRecord(error) && typeof error.message === "string" ? error.message : fallback;
+}
+function errorCode(error, fallback) {
+  return isRecord(error) && error.code ? String(error.code) : fallback;
+}
+function controlError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+function isRequestedRuntimeMode(value) {
+  return value === "acp" || value === "chat";
+}
+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 = 4e3) {
+  const tail = Number(value);
+  if (!Number.isFinite(tail)) return fallback;
+  return Math.max(0, Math.min(1e5, 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 = typeof options.timeoutMs === "number" && 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 if (value) resolve(value);
+    };
+    const fail = (code, message) => {
+      finish(controlError(code, message));
+    };
+    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" || !(0, import_terminal_status.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 = expressFactory.Router();
+  const createRequestAdmissions = /* @__PURE__ */ new Map();
+  const notifyUpdate = typeof options.notifyUpdate === "function" ? options.notifyUpdate : () => {
+  };
+  const initialInputTimeoutMs = typeof options.initialInputTimeoutMs === "number" && 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(expressFactory.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 = (0, import_agent_runtime_binding.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" || !(0, import_terminal_status.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 code = errorCode(deliveryError, "initial-input-failed");
+        const status = code === "initial-input-timeout" ? 504 : 409;
+        return {
+          status,
+          body: {
+            error: errorMessage(deliveryError, "Initial input delivery failed"),
+            code,
+            agentId,
+            initialInputDelivered: false
+          }
+        };
+      });
+      const durableDeliveryPromise = deliveryPromise.then((outcome) => {
+        if (!createRequestId) return outcome;
+        let persisted;
+        try {
+          persisted = agentManager.recordCreateRequestResult(
+            agentId,
+            createRequestId,
+            { controlApi: outcome }
+          );
+        } catch (error2) {
+          persisted = { error: errorMessage(error2, "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: isRequestedRuntimeMode(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 currentAgent = findAgent(agentManager.getState(), agentId);
+    const expectedRuntimeEpoch = typeof currentAgent?.runtimeEpoch === "string" ? currentAgent.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 currentAgent = findAgent(agentManager.getState(), agentId);
+    const expectedRuntimeEpoch = typeof currentAgent?.runtimeEpoch === "string" ? currentAgent.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: errorMessage(error, "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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_INITIAL_INPUT_TIMEOUT_MS,
+  createControlRouter,
+  ensureTrailingNewline,
+  waitForTerminalInputReadiness
+});

package/backend/data/LICENSE.cua

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cua AI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/backend/executable-discovery.cjs

@@ -0,0 +1,204 @@
+// 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 executable_discovery_exports = {};
+__export(executable_discovery_exports, {
+  clearExecutableVersionCache: () => clearExecutableVersionCache,
+  compareCliVersions: () => compareCliVersions,
+  getPathDirectories: () => getPathDirectories,
+  getPreferredExecutableCandidates: () => getPreferredExecutableCandidates,
+  isExecutable: () => isExecutable,
+  listAvailableAgents: () => listAvailableAgents,
+  parseCliVersion: () => parseCliVersion,
+  readExecutableCliVersion: () => readExecutableCliVersion,
+  resolveAgentExecutable: () => resolveAgentExecutable,
+  resolveCompatibleCodexExecutable: () => resolveCompatibleCodexExecutable
+});
+module.exports = __toCommonJS(executable_discovery_exports);
+var import_cli_agents = require("./cli-agents.cjs");
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+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 = /* @__PURE__ */ 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: 2e3
+    }));
+  } 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);
+  const cachedVersion = executableVersionCache.get(cacheToken);
+  if (cachedVersion !== void 0) return cachedVersion;
+  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 = /* @__PURE__ */ 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 (0, import_cli_agents.getUserLaunchAgents)().map((agent) => ({
+    ...agent,
+    resolvedPath: resolveAgentExecutable(agent.command || agent.name, pathEnv)
+  })).filter((agent) => Boolean(agent.resolvedPath)).map((agent) => ({
+    ...agent,
+    available: true
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearExecutableVersionCache,
+  compareCliVersions,
+  getPathDirectories,
+  getPreferredExecutableCandidates,
+  isExecutable,
+  listAvailableAgents,
+  parseCliVersion,
+  readExecutableCliVersion,
+  resolveAgentExecutable,
+  resolveCompatibleCodexExecutable
+});