farming-code 2.2.6

package/backend/codex-context-window.js

@@ -0,0 +1,189 @@
+const fsp = require('fs/promises');
+const os = require('os');
+const path = require('path');
+const {
+  collectRecentJsonlFiles,
+  readSessionMetadata,
+  sessionIdFromFilePath,
+} = require('./codex-session-history');
+const { isSafeProviderSessionId, isTemporaryProviderSessionId } = require('./provider-session-id');
+
+const CACHE_TTL_MS = 5_000;
+const CONTEXT_TAIL_BYTES = 512 * 1024;
+const DEFAULT_SCAN_LIMIT = 800;
+
+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) {
+  if (!record || record.type !== 'event_msg' || record.payload?.type !== 'token_count') return null;
+
+  const usage = record.payload.info?.last_token_usage;
+  const usedTokens = numberOrNull(usage?.input_tokens);
+  const limitTokens = numberOrNull(record.payload.model_context_window ?? record.payload.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 record.timestamp === 'string' ? record.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 {
+  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());
+    this.fileCache = new Map();
+  }
+
+  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 (sessionIdFromFilePath(cached.filePath) !== sessionId) return '';
+    try {
+      const stat = await fsp.stat(cached.filePath);
+      if (stat.isFile()) return cached.filePath;
+    } catch {
+      // Fall through to a fresh scan.
+    }
+    return '';
+  }
+
+  collectCandidates() {
+    return this.codexRoots()
+      .flatMap(root => 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 => 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 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 || isTemporaryProviderSessionId(sessionId)) {
+      return unavailable(agentId, 'Codex session has not been resolved yet.');
+    }
+    if (!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)));
+  }
+}
+
+module.exports = {
+  CodexContextWindowReader,
+  contextWindowFromRecord,
+  readLatestCodexContextWindow,
+};

package/backend/codex-models.js

@@ -0,0 +1,229 @@
+const { execFile } = require('child_process');
+
+const FALLBACK_MODELS = [
+  {
+    slug: 'gpt-5.5',
+    display_name: 'GPT-5.5',
+    description: 'Frontier model for complex coding, research, and real-world work.',
+    default_reasoning_level: 'medium',
+    supported_reasoning_levels: [
+      { effort: 'low', description: 'Fast responses with lighter reasoning' },
+      { effort: 'medium', description: 'Balances speed and reasoning depth for everyday tasks' },
+      { effort: 'high', description: 'Greater reasoning depth for complex problems' },
+      { effort: 'xhigh', description: 'Extra high reasoning depth for complex problems' },
+    ],
+    service_tiers: [
+      { id: 'priority', name: 'Fast', description: '1.5x speed, increased usage' },
+    ],
+    visibility: 'list',
+  },
+  {
+    slug: 'gpt-5.4',
+    display_name: 'GPT-5.4',
+    description: 'Strong model for everyday coding.',
+    default_reasoning_level: 'medium',
+    supported_reasoning_levels: [
+      { effort: 'low', description: 'Fast responses with lighter reasoning' },
+      { effort: 'medium', description: 'Balances speed and reasoning depth for everyday tasks' },
+      { effort: 'high', description: 'Greater reasoning depth for complex problems' },
+      { effort: 'xhigh', description: 'Extra high reasoning depth for complex problems' },
+    ],
+    service_tiers: [
+      { id: 'priority', name: 'Fast', description: '1.5x speed, increased usage' },
+    ],
+    visibility: 'list',
+  },
+  {
+    slug: 'gpt-5.4-mini',
+    display_name: 'GPT-5.4 Mini',
+    description: 'Small, fast, and cost-efficient model for simpler coding tasks.',
+    default_reasoning_level: 'medium',
+    supported_reasoning_levels: [
+      { effort: 'low', description: 'Fast responses with lighter reasoning' },
+      { effort: 'medium', description: 'Balances speed and reasoning depth for everyday tasks' },
+      { effort: 'high', description: 'Greater reasoning depth for complex problems' },
+    ],
+    visibility: 'list',
+  },
+  {
+    slug: 'gpt-5.3-codex-spark',
+    display_name: 'GPT-5.3 Codex Spark',
+    description: 'Ultra-fast coding model.',
+    default_reasoning_level: 'medium',
+    supported_reasoning_levels: [
+      { effort: 'low', description: 'Fast responses with lighter reasoning' },
+      { effort: 'medium', description: 'Balances speed and reasoning depth for everyday tasks' },
+    ],
+    visibility: 'list',
+  },
+];
+
+const EFFORT_LABELS = {
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High',
+  xhigh: 'Extra High',
+  max: 'Max',
+};
+
+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 = options.timeout || 3000;
+
+  return new Promise((resolve) => {
+    const fallback = () => resolve({
+      models: buildModelOptions(FALLBACK_MODELS, 'fallback'),
+      catalog: buildModelCatalog(FALLBACK_MODELS, 'fallback'),
+      source: 'fallback',
+    });
+
+    try {
+      execFile(codexBin, ['debug', 'models'], {
+        timeout,
+        maxBuffer: 20 * 1024 * 1024,
+      }, (error, stdout) => {
+        if (!error && stdout) {
+          try {
+            const models = catalogModelsFromJson(stdout);
+            const modelOptions = buildModelOptions(models, 'codex');
+            if (modelOptions.length > 0) {
+              resolve({
+                models: modelOptions,
+                catalog: buildModelCatalog(models, 'codex'),
+                source: 'codex',
+              });
+              return;
+            }
+          } catch {
+            // fall through to fallback catalog
+          }
+        }
+
+        fallback();
+      });
+    } catch {
+      fallback();
+    }
+  });
+}
+
+module.exports = {
+  buildModelCatalog,
+  buildModelOptions,
+  catalogModelsFromJson,
+  listCodexModelOptions,
+};

package/backend/codex-rollout-follower.js

@@ -0,0 +1,243 @@
+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 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,
+  formatCodexRolloutEvent,
+};