farming-code 2.2.29 → 2.2.32

package/backend/codex-context-window.cjs

@@ -0,0 +1,196 @@
+// 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 codex_context_window_exports = {};
+__export(codex_context_window_exports, {
+  CodexContextWindowReader: () => CodexContextWindowReader,
+  contextWindowFromRecord: () => contextWindowFromRecord,
+  readLatestCodexContextWindow: () => readLatestCodexContextWindow
+});
+module.exports = __toCommonJS(codex_context_window_exports);
+var import_codex_session_history = require("./codex-session-history.cjs");
+var import_provider_session_id = require("./provider-session-id.cjs");
+const fsp = require("fs/promises");
+const os = require("os");
+const path = require("path");
+const CACHE_TTL_MS = 5e3;
+const CONTEXT_TAIL_BYTES = 512 * 1024;
+const DEFAULT_SCAN_LIMIT = 800;
+function recordValue(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function numberOrNull(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function unavailable(agentId, reason) {
+  return {
+    agentId,
+    available: false,
+    reason
+  };
+}
+function contextWindowFromRecord(agentId, sessionId, record) {
+  const source = recordValue(record);
+  const payload = recordValue(source.payload);
+  if (source.type !== "event_msg" || payload.type !== "token_count") return null;
+  const info = recordValue(payload.info);
+  const usage = recordValue(info.last_token_usage);
+  const usedTokens = numberOrNull(usage.input_tokens);
+  const limitTokens = numberOrNull(payload.model_context_window ?? info.model_context_window);
+  if (usedTokens === null || limitTokens === null || usedTokens < 0 || limitTokens <= 0) return null;
+  const percentUsed = Math.max(0, Math.min(100, Math.round(usedTokens / limitTokens * 100)));
+  return {
+    agentId,
+    available: true,
+    provider: "codex",
+    sessionId,
+    usedTokens,
+    limitTokens,
+    percentUsed,
+    percentLeft: Math.max(0, 100 - percentUsed),
+    cachedInputTokens: Math.max(0, numberOrNull(usage?.cached_input_tokens) ?? 0),
+    outputTokens: Math.max(0, numberOrNull(usage?.output_tokens) ?? 0),
+    reasoningOutputTokens: Math.max(0, numberOrNull(usage?.reasoning_output_tokens) ?? 0),
+    updatedAt: typeof source.timestamp === "string" ? source.timestamp : "",
+    source: "codex token_count events",
+    confidence: "exact"
+  };
+}
+async function readJsonlTail(filePath, maxBytes = CONTEXT_TAIL_BYTES) {
+  const stat = await fsp.stat(filePath);
+  if (stat.size <= 0) return "";
+  const bytesToRead = Math.min(stat.size, maxBytes);
+  const start = stat.size - bytesToRead;
+  const buffer = Buffer.alloc(bytesToRead);
+  const handle = await fsp.open(filePath, "r");
+  try {
+    await handle.read(buffer, 0, bytesToRead, start);
+  } finally {
+    await handle.close();
+  }
+  let text = buffer.toString("utf8");
+  if (start > 0) {
+    const newlineIndex = text.indexOf("\n");
+    text = newlineIndex >= 0 ? text.slice(newlineIndex + 1) : "";
+  }
+  return text;
+}
+async function readLatestCodexContextWindow({
+  agentId,
+  sessionId,
+  filePath
+}) {
+  const lines = (await readJsonlTail(filePath)).split(/\r?\n/).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    let record = null;
+    try {
+      record = JSON.parse(lines[index]);
+    } catch {
+      continue;
+    }
+    const contextWindow = contextWindowFromRecord(agentId, sessionId, record);
+    if (contextWindow) return contextWindow;
+  }
+  return unavailable(agentId, "No Codex token_count event with context window was found.");
+}
+class CodexContextWindowReader {
+  cacheTtlMs;
+  codexHome;
+  fileCache = /* @__PURE__ */ new Map();
+  now;
+  scanLimit;
+  constructor(options = {}) {
+    this.codexHome = options.codexHome || path.join(os.homedir(), ".codex");
+    this.cacheTtlMs = options.cacheTtlMs ?? CACHE_TTL_MS;
+    this.scanLimit = options.scanLimit ?? DEFAULT_SCAN_LIMIT;
+    this.now = options.now || (() => Date.now());
+  }
+  codexRoots() {
+    return [
+      path.join(this.codexHome, "sessions"),
+      path.join(this.codexHome, "archived_sessions")
+    ];
+  }
+  async cachedFilePath(sessionId) {
+    const cached = this.fileCache.get(sessionId);
+    if (!cached || this.now() - cached.checkedAt > this.cacheTtlMs) return "";
+    if ((0, import_codex_session_history.sessionIdFromFilePath)(cached.filePath) !== sessionId) return "";
+    try {
+      const stat = await fsp.stat(cached.filePath);
+      if (stat.isFile()) return cached.filePath;
+    } catch {
+    }
+    return "";
+  }
+  collectCandidates() {
+    return this.codexRoots().flatMap((root) => (0, import_codex_session_history.collectRecentJsonlFiles)(root, this.scanLimit)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, this.scanLimit);
+  }
+  async findSessionFile(sessionId) {
+    const cached = await this.cachedFilePath(sessionId);
+    if (cached) return cached;
+    const candidates = this.collectCandidates();
+    const direct = candidates.find((candidate) => (0, import_codex_session_history.sessionIdFromFilePath)(candidate.filePath) === sessionId);
+    if (direct) {
+      this.fileCache.set(sessionId, { filePath: direct.filePath, checkedAt: this.now() });
+      return direct.filePath;
+    }
+    for (const candidate of candidates) {
+      const metadata = await (0, import_codex_session_history.readSessionMetadata)(candidate.filePath, 40).catch(() => null);
+      if (metadata?.id !== sessionId) continue;
+      this.fileCache.set(sessionId, { filePath: candidate.filePath, checkedAt: this.now() });
+      return candidate.filePath;
+    }
+    this.fileCache.delete(sessionId);
+    return "";
+  }
+  async readForAgent(agent) {
+    const requestedCodexHome = String(agent?.providerHomePath || "").trim();
+    if (requestedCodexHome && requestedCodexHome !== this.codexHome) {
+      const reader = new CodexContextWindowReader({
+        codexHome: requestedCodexHome,
+        cacheTtlMs: this.cacheTtlMs,
+        scanLimit: this.scanLimit,
+        now: this.now
+      });
+      return reader.readForAgent({ ...agent, providerHomePath: "" });
+    }
+    const agentId = String(agent?.id || "");
+    if (!agentId) return unavailable("", "Agent id is empty.");
+    if (agent?.providerSessionProvider !== "codex") return unavailable(agentId, "Agent is not a Codex session.");
+    const sessionId = String(agent.providerSessionId || "").trim();
+    if (!sessionId || (0, import_provider_session_id.isTemporaryProviderSessionId)(sessionId)) {
+      return unavailable(agentId, "Codex session has not been resolved yet.");
+    }
+    if (!(0, import_provider_session_id.isSafeProviderSessionId)(sessionId)) return unavailable(agentId, "Codex session id is not safe.");
+    const filePath = await this.findSessionFile(sessionId);
+    if (!filePath) return unavailable(agentId, "Codex session log was not found.");
+    return readLatestCodexContextWindow({ agentId, sessionId, filePath }).catch(() => unavailable(agentId, "Failed to read Codex context window."));
+  }
+  async readForAgents(agents) {
+    const list = Array.isArray(agents) ? agents : [];
+    return Promise.all(list.map((agent) => this.readForAgent(agent)));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodexContextWindowReader,
+  contextWindowFromRecord,
+  readLatestCodexContextWindow
+});

package/backend/codex-models.cjs

@@ -0,0 +1,228 @@
+// 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 codex_models_exports = {};
+__export(codex_models_exports, {
+  CodexModelCatalogError: () => CodexModelCatalogError,
+  DEFAULT_CODEX_MODELS_TIMEOUT_MS: () => DEFAULT_CODEX_MODELS_TIMEOUT_MS,
+  buildModelCatalog: () => buildModelCatalog,
+  buildModelOptions: () => buildModelOptions,
+  catalogModelsFromJson: () => catalogModelsFromJson,
+  listCodexModelOptions: () => listCodexModelOptions
+});
+module.exports = __toCommonJS(codex_models_exports);
+const { execFile } = require("child_process");
+const DEFAULT_CODEX_MODELS_TIMEOUT_MS = 15e3;
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+class CodexModelCatalogError extends Error {
+  code;
+  cause;
+  constructor(code, message, cause = null) {
+    super(message);
+    this.name = "CodexModelCatalogError";
+    this.code = code;
+    if (cause) this.cause = cause;
+  }
+}
+const EFFORT_LABELS = {
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra High",
+  max: "Max",
+  ultra: "Ultra"
+};
+const DEFAULT_SERVICE_TIER = {
+  value: "default",
+  label: "Standard",
+  description: "Default speed"
+};
+function compactModelLabel(model) {
+  const displayName = String(model.display_name || model.slug || "").trim();
+  if (!displayName) return String(model.slug || "").trim();
+  return displayName.replace(/^GPT-/i, "");
+}
+function normalizeReasoningLevels(model) {
+  const levels = Array.isArray(model.supported_reasoning_levels) ? model.supported_reasoning_levels : [];
+  if (levels.length > 0) {
+    return levels.map((level) => ({
+      effort: String(level && level.effort || "").trim(),
+      description: String(level && level.description || "").trim()
+    })).filter((level) => level.effort);
+  }
+  const fallbackEffort = String(model.default_reasoning_level || "").trim();
+  return fallbackEffort ? [{ effort: fallbackEffort, description: "" }] : [];
+}
+function normalizeServiceTiers(model) {
+  const tiers = Array.isArray(model.service_tiers) ? model.service_tiers : [];
+  const normalized = tiers.map((tier) => {
+    const candidate = isObject(tier) ? tier : {};
+    return {
+      value: String(candidate.id || candidate.value || "").trim(),
+      label: String(candidate.name || candidate.label || "").trim(),
+      description: String(candidate.description || "").trim()
+    };
+  }).filter((tier) => tier.value);
+  return [
+    DEFAULT_SERVICE_TIER,
+    ...normalized.map((tier) => ({
+      ...tier,
+      label: tier.label || tier.value
+    }))
+  ];
+}
+function catalogModelsFromJson(rawJson) {
+  const parsed = JSON.parse(String(rawJson));
+  const models = Array.isArray(parsed) ? parsed : isObject(parsed) ? parsed.models : [];
+  return Array.isArray(models) ? models : [];
+}
+function visibleModels(models) {
+  return models.filter((model) => isObject(model) && typeof model.slug === "string" && Boolean(model.slug.trim())).filter((model) => !model.visibility || model.visibility === "list").sort((a, b) => {
+    const priorityA = typeof a.priority === "number" && Number.isFinite(a.priority) ? a.priority : Number.MAX_SAFE_INTEGER;
+    const priorityB = typeof b.priority === "number" && Number.isFinite(b.priority) ? b.priority : Number.MAX_SAFE_INTEGER;
+    return priorityA - priorityB;
+  });
+}
+function buildModelCatalog(models, source = "codex") {
+  return visibleModels(models).map((model) => {
+    const modelId = model.slug.trim();
+    const levels = normalizeReasoningLevels(model);
+    return {
+      value: modelId,
+      model: modelId,
+      label: compactModelLabel(model),
+      displayName: String(model.display_name || model.slug || "").trim(),
+      description: String(model.description || "").trim(),
+      defaultEffort: String(model.default_reasoning_level || levels[0]?.effort || "").trim(),
+      reasoningLevels: levels.map((level) => ({
+        value: level.effort,
+        effort: level.effort,
+        label: EFFORT_LABELS[level.effort] || level.effort,
+        description: level.description
+      })),
+      serviceTiers: normalizeServiceTiers(model),
+      source
+    };
+  });
+}
+function buildModelOptions(models, source = "codex") {
+  return buildModelCatalog(models, source).flatMap((model) => {
+    if (model.reasoningLevels.length === 0) {
+      return [{
+        value: model.value,
+        model: model.value,
+        effort: "",
+        label: model.label,
+        description: model.description,
+        source
+      }];
+    }
+    return model.reasoningLevels.map((level) => ({
+      value: `${model.value}:${level.value}`,
+      model: model.value,
+      effort: level.value,
+      label: `${model.label} ${level.label}`,
+      description: level.description || model.description,
+      source
+    }));
+  });
+}
+function listCodexModelOptions(options = {}) {
+  const codexBin = options.codexBin || process.env.FARMING_CODEX_BIN || "codex";
+  const timeout = typeof options.timeout === "number" && Number.isFinite(options.timeout) ? Math.max(1, options.timeout) : DEFAULT_CODEX_MODELS_TIMEOUT_MS;
+  const runExecFile = options.execFile || execFile;
+  return new Promise((resolve, reject) => {
+    try {
+      runExecFile(codexBin, ["debug", "models"], {
+        ...options.env ? { env: options.env } : {},
+        timeout,
+        maxBuffer: 20 * 1024 * 1024
+      }, (error, stdout, stderr) => {
+        if (error) {
+          const timedOut = error.code === "ETIMEDOUT" || error.killed === true;
+          if (timedOut) {
+            reject(new CodexModelCatalogError(
+              "CODEX_MODELS_TIMEOUT",
+              `Codex model catalog timed out after ${timeout}ms`,
+              error
+            ));
+            return;
+          }
+          const detail = String(stderr || error.message || "").trim().split(/\r?\n/, 1)[0];
+          reject(new CodexModelCatalogError(
+            "CODEX_MODELS_COMMAND_FAILED",
+            detail ? `Codex model catalog command failed: ${detail}` : "Codex model catalog command failed",
+            error
+          ));
+          return;
+        }
+        if (!String(stdout || "").trim()) {
+          reject(new CodexModelCatalogError(
+            "CODEX_MODELS_EMPTY_OUTPUT",
+            "Codex model catalog command returned no output"
+          ));
+          return;
+        }
+        let models;
+        try {
+          models = catalogModelsFromJson(stdout);
+        } catch (error2) {
+          reject(new CodexModelCatalogError(
+            "CODEX_MODELS_INVALID_JSON",
+            "Codex model catalog returned invalid JSON",
+            error2
+          ));
+          return;
+        }
+        const modelOptions = buildModelOptions(models, "codex");
+        const catalog = buildModelCatalog(models, "codex");
+        if (modelOptions.length === 0 || catalog.length === 0) {
+          reject(new CodexModelCatalogError(
+            "CODEX_MODELS_EMPTY_CATALOG",
+            "Codex model catalog did not contain any visible models"
+          ));
+          return;
+        }
+        resolve({
+          models: modelOptions,
+          catalog,
+          source: "codex"
+        });
+      });
+    } catch (error) {
+      reject(new CodexModelCatalogError(
+        "CODEX_MODELS_COMMAND_FAILED",
+        `Failed to start Codex model catalog command: ${error instanceof Error ? error.message : error}`,
+        error
+      ));
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodexModelCatalogError,
+  DEFAULT_CODEX_MODELS_TIMEOUT_MS,
+  buildModelCatalog,
+  buildModelOptions,
+  catalogModelsFromJson,
+  listCodexModelOptions
+});

package/backend/codex-session-archive.cjs

@@ -0,0 +1,82 @@
+// 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 codex_session_archive_exports = {};
+__export(codex_session_archive_exports, {
+  archiveCodexSession: () => archiveCodexSession,
+  unarchiveCodexSession: () => unarchiveCodexSession
+});
+module.exports = __toCommonJS(codex_session_archive_exports);
+var import_executable_discovery = require("./executable-discovery.cjs");
+const { execFile } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const { promisify } = require("util");
+const execFileAsync = promisify(execFile);
+async function runCodexSessionArchiveCommand(action, sessionId, session = {}, options = {}) {
+  const resolveExecutable = options.resolveCompatibleCodexExecutable || import_executable_discovery.resolveCompatibleCodexExecutable;
+  const runExecFile = options.execFileAsync || execFileAsync;
+  const processEnv = options.processEnv || process.env;
+  const directoryExists = options.directoryExists || ((directory) => {
+    try {
+      return fs.statSync(directory).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const codexResolution = resolveExecutable(session.cliVersion || "", processEnv.PATH || "");
+  if (!codexResolution.compatible) {
+    return {
+      error: codexResolution.error || "Codex CLI is not compatible with this session",
+      status: 400
+    };
+  }
+  try {
+    const sessionCwd = session.cwd || session.workspace || "";
+    await runExecFile(codexResolution.path || "codex", [action, sessionId], {
+      cwd: sessionCwd && directoryExists(sessionCwd) ? sessionCwd : processEnv.HOME || os.homedir(),
+      env: session.providerHomePath ? { ...processEnv, CODEX_HOME: session.providerHomePath } : processEnv,
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024
+    });
+    return { [action === "archive" ? "archived" : "unarchived"]: true };
+  } catch (error) {
+    const details = error && typeof error === "object" ? error : {};
+    const message = [
+      details.stdout ? String(details.stdout).trim() : "",
+      details.stderr ? String(details.stderr).trim() : "",
+      details.message ? String(details.message).trim() : ""
+    ].filter(Boolean).join("\n") || `failed to ${action} Codex session`;
+    return {
+      error: message,
+      status: 409
+    };
+  }
+}
+async function archiveCodexSession(sessionId, session = {}, options = {}) {
+  return runCodexSessionArchiveCommand("archive", sessionId, session, options);
+}
+async function unarchiveCodexSession(sessionId, session = {}, options = {}) {
+  return runCodexSessionArchiveCommand("unarchive", sessionId, session, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  archiveCodexSession,
+  unarchiveCodexSession
+});