farming-code 2.2.29 → 2.2.32

package/backend/codex-models.js

@@ -1,226 +0,0 @@
-const { execFile } = require('child_process');
-
-const DEFAULT_CODEX_MODELS_TIMEOUT_MS = 15_000;
-
-class CodexModelCatalogError extends Error {
-  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 => ({
-      value: String(tier && (tier.id || tier.value) || '').trim(),
-      label: String(tier && (tier.name || tier.label) || '').trim(),
-      description: String(tier && tier.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(rawJson);
-  const models = Array.isArray(parsed) ? parsed : parsed.models;
-  return Array.isArray(models) ? models : [];
-}
-
-function visibleModels(models) {
-  return models
-    .filter(model => model && typeof model.slug === 'string' && model.slug.trim())
-    .filter(model => !model.visibility || model.visibility === 'list')
-    .sort((a, b) => {
-      const priorityA = Number.isFinite(a.priority) ? a.priority : Number.MAX_SAFE_INTEGER;
-      const priorityB = 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 = 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'], {
-        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 (error) {
-          reject(new CodexModelCatalogError(
-            'CODEX_MODELS_INVALID_JSON',
-            'Codex model catalog returned invalid JSON',
-            error
-          ));
-          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.message || error}`,
-        error
-      ));
-    }
-  });
-}
-
-module.exports = {
-  CodexModelCatalogError,
-  DEFAULT_CODEX_MODELS_TIMEOUT_MS,
-  buildModelCatalog,
-  buildModelOptions,
-  catalogModelsFromJson,
-  listCodexModelOptions,
-};

package/backend/codex-rollout-follower.js

@@ -1,326 +0,0 @@
-const EventEmitter = require('events');
-const fs = require('fs');
-const fsp = require('fs/promises');
-const os = require('os');
-const path = require('path');
-
-const DEFAULT_POLL_INTERVAL_MS = 1000;
-const DEFAULT_MAX_READ_BYTES = 512 * 1024;
-const USER_MESSAGE_BEGIN = '## My request for Codex:';
-
-function normalizePathValue(value) {
-  if (typeof value !== 'string') return '';
-  const trimmed = value.trim();
-  if (!trimmed || trimmed === path.sep) return trimmed;
-  return trimmed.replace(/[\\/]+$/, '');
-}
-
-function sessionIdFromFilePath(filePath) {
-  const match = path.basename(filePath).match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
-  return match ? match[1] : '';
-}
-
-function findCodexRolloutFile(sessionId, options = {}) {
-  const normalizedSessionId = String(sessionId || '').trim();
-  if (!normalizedSessionId) return '';
-
-  const codexHome = normalizePathValue(options.codexHome || path.join(os.homedir(), '.codex'));
-  const roots = [
-    path.join(codexHome, 'sessions'),
-    path.join(codexHome, 'archived_sessions'),
-  ];
-
-  for (const root of roots) {
-    const stack = [root];
-    while (stack.length > 0) {
-      const directory = stack.pop();
-      let entries = [];
-      try {
-        entries = fs.readdirSync(directory, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-
-      for (const entry of entries) {
-        const fullPath = path.join(directory, entry.name);
-        if (entry.isDirectory()) {
-          stack.push(fullPath);
-        } else if (
-          entry.isFile()
-          && entry.name.endsWith('.jsonl')
-          && sessionIdFromFilePath(fullPath) === normalizedSessionId
-        ) {
-          return fullPath;
-        }
-      }
-    }
-  }
-
-  return '';
-}
-
-function recentSessionDirectories(root, now = new Date()) {
-  const directories = [];
-  for (const offsetDays of [-1, 0, 1]) {
-    const date = new Date(now.getTime() + offsetDays * 24 * 60 * 60 * 1000);
-    directories.push(
-      path.join(
-        root,
-        String(date.getFullYear()),
-        String(date.getMonth() + 1).padStart(2, '0'),
-        String(date.getDate()).padStart(2, '0'),
-      ),
-      path.join(
-        root,
-        String(date.getUTCFullYear()),
-        String(date.getUTCMonth() + 1).padStart(2, '0'),
-        String(date.getUTCDate()).padStart(2, '0'),
-      ),
-    );
-  }
-  return [...new Set(directories)];
-}
-
-async function findCodexRolloutFileAsync(sessionId, options = {}) {
-  const normalizedSessionId = String(sessionId || '').trim();
-  if (!normalizedSessionId) return '';
-  const codexHome = normalizePathValue(options.codexHome || path.join(os.homedir(), '.codex'));
-  const maxEntries = Number.isFinite(options.maxEntries)
-    ? Math.max(1, Math.floor(options.maxEntries))
-    : 100_000;
-  const deadline = Number.isFinite(options.deadline)
-    ? Number(options.deadline)
-    : Date.now() + 5_000;
-  const sessionsRoot = path.join(codexHome, 'sessions');
-  const archivedRoot = path.join(codexHome, 'archived_sessions');
-  const preferredDirectories = [
-    ...recentSessionDirectories(sessionsRoot),
-    ...(options.recentOnly === true ? [] : [archivedRoot]),
-  ];
-  const visited = new Set();
-  let inspectedEntries = 0;
-
-  async function inspectDirectory(directory, descend) {
-    if (Date.now() > deadline || inspectedEntries >= maxEntries || visited.has(directory)) return '';
-    visited.add(directory);
-    let entries;
-    try {
-      entries = await fsp.readdir(directory, { withFileTypes: true });
-    } catch {
-      return '';
-    }
-    const subdirectories = [];
-    for (const entry of entries) {
-      inspectedEntries += 1;
-      if (Date.now() > deadline || inspectedEntries > maxEntries) return '';
-      const fullPath = path.join(directory, entry.name);
-      if (entry.isFile() && entry.name.endsWith('.jsonl') && sessionIdFromFilePath(fullPath) === normalizedSessionId) {
-        return fullPath;
-      }
-      if (descend && entry.isDirectory()) subdirectories.push(fullPath);
-    }
-    return subdirectories;
-  }
-
-  for (const directory of preferredDirectories) {
-    const found = await inspectDirectory(directory, false);
-    if (typeof found === 'string' && found) return found;
-  }
-  if (options.recentOnly === true) return '';
-
-  const stack = [sessionsRoot, archivedRoot];
-  while (stack.length > 0 && Date.now() <= deadline && inspectedEntries < maxEntries) {
-    const directory = stack.pop();
-    const result = await inspectDirectory(directory, true);
-    if (typeof result === 'string') {
-      if (result) return result;
-      continue;
-    }
-    stack.push(...result);
-  }
-  return '';
-}
-
-function normalizePreviewText(value, maxLength = 400) {
-  return String(value || '')
-    .replace(/\r\n/g, '\n')
-    .replace(/\r/g, '\n')
-    .trim()
-    .slice(0, maxLength);
-}
-
-function stripUserMessagePrefix(value) {
-  const text = String(value || '');
-  const index = text.indexOf(USER_MESSAGE_BEGIN);
-  return index >= 0 ? text.slice(index + USER_MESSAGE_BEGIN.length).trim() : text.trim();
-}
-
-function jsonFieldPreview(value, key, maxLength = 120) {
-  try {
-    const parsed = typeof value === 'string' ? JSON.parse(value) : value;
-    const field = parsed && typeof parsed === 'object' ? parsed[key] : '';
-    return normalizePreviewText(field, maxLength).replace(/\s+/g, ' ');
-  } catch {
-    return '';
-  }
-}
-
-function formatFunctionCall(payload) {
-  const name = String(payload.name || '').trim();
-  if (!name) return '';
-
-  if (name === 'exec_command') {
-    const cmd = jsonFieldPreview(payload.arguments, 'cmd');
-    return cmd ? `running command: ${cmd}` : 'running command';
-  }
-
-  if (name === 'apply_patch') return 'applying patch';
-  return `running ${name}`;
-}
-
-function formatCodexRolloutEvent(line) {
-  let event = null;
-  try {
-    event = JSON.parse(line);
-  } catch {
-    return '';
-  }
-
-  const payload = event && typeof event.payload === 'object' ? event.payload : null;
-  if (!payload) return '';
-
-  if (event.type === 'event_msg') {
-    if (payload.type === 'agent_message') {
-      const message = normalizePreviewText(payload.message);
-      return message ? `[Codex live]\r\n${message.replace(/\n/g, '\r\n')}\r\n` : '';
-    }
-
-    if (payload.type === 'user_message') {
-      const message = normalizePreviewText(stripUserMessagePrefix(payload.message), 240);
-      return message ? `[Codex live] queued user message: ${message.replace(/\n/g, ' ')}\r\n` : '';
-    }
-
-    if (payload.type === 'task_complete') {
-      return '[Codex live] task complete\r\n';
-    }
-
-    return '';
-  }
-
-  if (event.type === 'response_item') {
-    if (payload.type === 'function_call') {
-      const message = formatFunctionCall(payload);
-      return message ? `[Codex live] ${message}\r\n` : '';
-    }
-
-    return '';
-  }
-
-  return '';
-}
-
-async function readFileRange(filePath, start, end) {
-  const length = Math.max(0, end - start);
-  if (length <= 0) return '';
-
-  const handle = await fsp.open(filePath, 'r');
-  try {
-    const buffer = Buffer.alloc(length);
-    const result = await handle.read(buffer, 0, length, start);
-    return buffer.subarray(0, result.bytesRead).toString('utf8');
-  } finally {
-    await handle.close().catch(() => {});
-  }
-}
-
-class CodexRolloutFollower extends EventEmitter {
-  constructor(sessionId, options = {}) {
-    super();
-    this.sessionId = String(sessionId || '').trim();
-    this.codexHome = options.codexHome;
-    this.pollIntervalMs = Number.isFinite(options.pollIntervalMs)
-      ? Math.max(250, options.pollIntervalMs)
-      : DEFAULT_POLL_INTERVAL_MS;
-    this.maxReadBytes = Number.isFinite(options.maxReadBytes)
-      ? Math.max(4096, options.maxReadBytes)
-      : DEFAULT_MAX_READ_BYTES;
-    this.filePath = options.filePath || '';
-    this.offset = Number.isFinite(options.offset) ? Math.max(0, options.offset) : 0;
-    this.partialLine = '';
-    this.timer = null;
-    this.stopped = false;
-    this.polling = false;
-  }
-
-  async start() {
-    if (!this.sessionId || this.timer || this.stopped) return;
-    this.filePath = this.filePath || findCodexRolloutFile(this.sessionId, {
-      codexHome: this.codexHome,
-    });
-    if (!this.filePath) return;
-
-    if (!this.offset) {
-      try {
-        this.offset = (await fsp.stat(this.filePath)).size;
-      } catch {
-        this.offset = 0;
-      }
-    }
-
-    this.timer = setInterval(() => {
-      this.poll().catch(error => this.emit('error', error));
-    }, this.pollIntervalMs);
-  }
-
-  async poll() {
-    if (this.stopped || this.polling || !this.filePath) return;
-    this.polling = true;
-    try {
-      const stat = await fsp.stat(this.filePath);
-      if (stat.size < this.offset) {
-        this.offset = stat.size;
-        this.partialLine = '';
-        return;
-      }
-      if (stat.size === this.offset) return;
-
-      const oldOffset = this.offset;
-      const start = Math.max(oldOffset, stat.size - this.maxReadBytes);
-      const droppedPrefix = start > oldOffset;
-      const chunk = await readFileRange(this.filePath, start, stat.size);
-      this.offset = stat.size;
-
-      const text = droppedPrefix ? chunk : this.partialLine + chunk;
-      const lines = text.split('\n');
-      this.partialLine = lines.pop() || '';
-      if (droppedPrefix) {
-        lines.shift();
-      }
-
-      const formatted = lines
-        .map(formatCodexRolloutEvent)
-        .filter(Boolean)
-        .join('');
-      if (formatted) {
-        this.emit('data', formatted);
-      }
-    } finally {
-      this.polling = false;
-    }
-  }
-
-  stop() {
-    this.stopped = true;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-}
-
-module.exports = {
-  CodexRolloutFollower,
-  findCodexRolloutFile,
-  findCodexRolloutFileAsync,
-  formatCodexRolloutEvent,
-};

package/backend/codex-session-archive.js

@@ -1,65 +0,0 @@
-const { execFile } = require('child_process');
-const fs = require('fs');
-const os = require('os');
-const { promisify } = require('util');
-const { resolveCompatibleCodexExecutable } = require('./executable-discovery');
-
-const execFileAsync = promisify(execFile);
-
-async function runCodexSessionArchiveCommand(action, sessionId, session = {}, options = {}) {
-  const resolveExecutable = options.resolveCompatibleCodexExecutable || 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: 30_000,
-      maxBuffer: 1024 * 1024,
-    });
-    return { [action === 'archive' ? 'archived' : 'unarchived']: true };
-  } catch (error) {
-    const message = [
-      error && error.stdout ? String(error.stdout).trim() : '',
-      error && error.stderr ? String(error.stderr).trim() : '',
-      error && error.message ? String(error.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);
-}
-
-module.exports = {
-  archiveCodexSession,
-  unarchiveCodexSession,
-};