@link-assistant/hive-mind 1.50.7 → 1.50.9

package/src/telegram-solve-queue.lib.mjs

@@ -15,24 +15,12 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1041
  */
 
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execAsync = promisify(exec);
-
-// Import centralized limits and caching
-import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
-
-// Import centralized queue configuration
-// This ensures thresholds are consistent between queue logic and display formatting
-// See: https://github.com/link-assistant/hive-mind/issues/1242
-// See: https://github.com/link-assistant/hive-mind/issues/1253 (configurable strategies)
+import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
+export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
+import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 
-/**
- * Status enum for queue items
- */
 export const QueueItemStatus = {
   QUEUED: 'queued',
   WAITING: 'waiting',
@@ -42,136 +30,6 @@ export const QueueItemStatus = {
   CANCELLED: 'cancelled',
 };
 
-/**
- * Count running processes by name
- * @param {string} processName - Process name to search for (e.g., 'claude', 'agent')
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{count: number, processes: string[]}>}
- */
-export async function getRunningProcesses(processName, verbose = false) {
-  try {
-    const { stdout } = await execAsync(`pgrep -l -x ${processName} 2>/dev/null || true`);
-    const lines = stdout
-      .trim()
-      .split('\n')
-      .filter(line => line.trim());
-
-    const processes = lines
-      .map(line => {
-        const parts = line.trim().split(/\s+/);
-        return {
-          pid: parts[0],
-          name: parts.slice(1).join(' ') || processName,
-        };
-      })
-      .filter(p => p.pid);
-
-    if (verbose) {
-      console.log(`[VERBOSE] /solve_queue found ${processes.length} running ${processName} processes`);
-      if (processes.length > 0) {
-        console.log(`[VERBOSE] /solve_queue processes: ${JSON.stringify(processes)}`);
-      }
-    }
-
-    return {
-      count: processes.length,
-      processes: processes.map(p => `${p.pid}:${p.name}`),
-    };
-  } catch (error) {
-    if (verbose) {
-      console.error(`[VERBOSE] /solve_queue error counting ${processName} processes:`, error.message);
-    }
-    return { count: 0, processes: [] };
-  }
-}
-
-/**
- * Count running claude processes
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{count: number, processes: string[]}>}
- */
-export async function getRunningClaudeProcesses(verbose = false) {
-  return getRunningProcesses('claude', verbose);
-}
-
-/**
- * Count running agent processes
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{count: number, processes: string[]}>}
- */
-export async function getRunningAgentProcesses(verbose = false) {
-  return getRunningProcesses('agent', verbose);
-}
-
-/**
- * Format a threshold as percentage for display
- * @param {number} ratio - Ratio (0.0 - 1.0)
- * @returns {string} Formatted percentage
- */
-function formatThresholdPercent(ratio) {
-  return `${Math.round(ratio * 100)}%`;
-}
-
-/**
- * Format milliseconds into human-readable duration
- * Shows days, hours, minutes, and seconds as appropriate.
- * Examples: "5h 43m 23s", "2m 15s", "45s", "1d 3h 12m 5s"
- *
- * @param {number} ms - Duration in milliseconds
- * @returns {string} Human-readable duration
- * @see https://github.com/link-assistant/hive-mind/issues/1267
- */
-export function formatDuration(ms) {
-  if (ms < 0) ms = 0;
-
-  const totalSeconds = Math.floor(ms / 1000);
-  const days = Math.floor(totalSeconds / 86400);
-  const hours = Math.floor((totalSeconds % 86400) / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-
-  const parts = [];
-  if (days > 0) parts.push(`${days}d`);
-  if (hours > 0) parts.push(`${hours}h`);
-  if (minutes > 0) parts.push(`${minutes}m`);
-  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
-
-  return parts.join(' ');
-}
-
-/**
- * Generate human-readable waiting reason based on threshold violation
- * @param {string} metric - The metric name (ram, cpu, disk, etc.)
- * @param {number} currentValue - Current value (as percentage 0-100)
- * @param {number} threshold - Threshold ratio (0.0 - 1.0)
- * @returns {string} Human-readable reason
- */
-function formatWaitingReason(metric, currentValue, threshold) {
-  const thresholdPercent = formatThresholdPercent(threshold);
-  const currentPercent = Math.round(currentValue);
-
-  switch (metric) {
-    case 'ram':
-      return `RAM usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'cpu':
-      return `CPU usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'disk':
-      return `Disk usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'claude_5_hour_session':
-      return `Claude 5 hour session limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'claude_weekly':
-      return `Claude weekly limit is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'github':
-      return `GitHub API usage is ${currentPercent}% (threshold: ${thresholdPercent})`;
-    case 'min_interval':
-      return `Minimum interval between commands not reached`;
-    case 'claude_running':
-      return `Claude process is already running`;
-    default:
-      return `${metric} threshold exceeded`;
-  }
-}
-
 /**
  * Queue item representing a /solve command request
  */
@@ -281,6 +139,7 @@ export class SolveQueue {
     this.queues = {
       claude: [],
       agent: [],
+      codex: [],
     };
     this.processing = new Map();
     this.completed = [];
@@ -291,6 +150,7 @@ export class SolveQueue {
     this.lastStartTimeByTool = {
       claude: null,
       agent: null,
+      codex: null,
     };
     // Legacy: keep for compatibility with existing code that uses lastStartTime
     this.lastStartTime = null;
@@ -647,22 +507,29 @@ export class SolveQueue {
 
     // Check running claude processes (this is a metric, not a blocking reason by itself)
     const claudeProcs = await getRunningClaudeProcesses(this.verbose);
+    const codexProcs = await getRunningCodexProcesses(this.verbose);
+    const agentProcs = await getRunningAgentProcesses(this.verbose);
     const hasRunningClaude = claudeProcs.count > 0;
+    const hasRunningCodex = codexProcs.count > 0;
 
     // Calculate total processing count for system resources (all tools)
     // System resources (RAM, CPU, disk) apply to all tools
-    const totalProcessing = this.processing.size + claudeProcs.count;
+    const totalProcessing = this.processing.size + claudeProcs.count + codexProcs.count + agentProcs.count;
 
     // Calculate Claude-specific processing count for Claude API limits
     // Only counts Claude items in queue + external claude processes
     // Agent items don't count against Claude's one-at-a-time limit
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     const claudeProcessingCount = this.getProcessingCountByTool('claude');
+    const codexProcessingCount = this.getProcessingCountByTool('codex');
 
     // Track claude_running as a metric (but don't add to reasons yet)
     if (hasRunningClaude) {
       this.recordThrottle('claude_running');
     }
+    if (hasRunningCodex) {
+      this.recordThrottle('codex_running');
+    }
 
     // Check system resources with strategy support
     // System resources apply to ALL tools, not just Claude
@@ -685,7 +552,9 @@ export class SolveQueue {
     // This allows agent tasks to proceed when Claude limits are reached
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     // See: https://github.com/link-assistant/hive-mind/issues/1253 (strategies)
-    const limitCheck = await this.checkApiLimits(hasRunningClaude, claudeProcessingCount, tool);
+    const hasRunningToolProcess = tool === 'codex' ? hasRunningCodex : hasRunningClaude;
+    const toolProcessingCount = tool === 'codex' ? codexProcessingCount : claudeProcessingCount;
+    const limitCheck = await this.checkApiLimits(hasRunningToolProcess, toolProcessingCount, tool);
     if (limitCheck.rejected) {
       rejected = true;
       rejectReason = limitCheck.rejectReason;
@@ -705,6 +574,9 @@ export class SolveQueue {
       // See: https://github.com/link-assistant/hive-mind/issues/1078
       reasons.push(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
     }
+    if (tool === 'codex' && hasRunningCodex && reasons.length > 0) {
+      reasons.push(formatWaitingReason('codex_running', codexProcs.count, 0) + ` (${codexProcs.count} processes)`);
+    }
 
     const canStart = reasons.length === 0 && !rejected;
 
@@ -724,8 +596,10 @@ export class SolveQueue {
       reasons,
       oneAtATime,
       claudeProcesses: claudeProcs.count,
+      codexProcesses: codexProcs.count,
       totalProcessing,
       claudeProcessingCount,
+      codexProcessingCount,
     };
   }
 
@@ -868,12 +742,12 @@ export class SolveQueue {
    * - All thresholds now support configurable strategies (reject, enqueue, dequeue-one-at-a-time)
    * - Configuration via HIVE_MIND_QUEUE_CONFIG or individual env vars
    *
-   * @param {boolean} hasRunningClaude - Whether claude processes are running (from pgrep)
-   * @param {number} claudeProcessingCount - Count of 'claude' tool items being processed in queue
+   * @param {boolean} hasRunningToolProcess - Whether matching tool processes are running (from pgrep)
+   * @param {number} toolProcessingCount - Count of matching tool items being processed in queue
    * @param {string} tool - The tool being used ('claude', 'agent', etc.)
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
-  async checkApiLimits(hasRunningClaude = false, claudeProcessingCount = 0, tool = 'claude') {
+  async checkApiLimits(hasRunningToolProcess = false, toolProcessingCount = 0, tool = 'claude') {
     const reasons = [];
     let oneAtATime = false;
     let rejected = false;
@@ -884,12 +758,9 @@ export class SolveQueue {
     // affected by Claude API limits (5-hour session, weekly limits)
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     const applyClaudeLimits = tool === 'claude';
+    const applyCodexLimits = tool === 'codex';
 
-    // Calculate total Claude processing: queue-internal claude items + external claude processes
-    // This is used for Claude limits one-at-a-time mode - only counts Claude-related processing
-    // Agent items in the queue don't count against Claude's one-at-a-time limit
-    // See: https://github.com/link-assistant/hive-mind/issues/1159
-    const totalClaudeProcessing = claudeProcessingCount + (hasRunningClaude ? 1 : 0);
+    const totalToolProcessing = toolProcessingCount + (hasRunningToolProcess ? 1 : 0);
 
     // Check Claude limits (using cached value)
     // Only applied when tool is 'claude'
@@ -914,7 +785,7 @@ export class SolveQueue {
               rejectReason = reason;
             } else if (strategy === 'dequeue-one-at-a-time') {
               oneAtATime = true;
-              if (totalClaudeProcessing > 0) {
+              if (totalToolProcessing > 0) {
                 reasons.push(reason + ' (waiting for current command)');
               }
             } else {
@@ -939,7 +810,7 @@ export class SolveQueue {
               rejectReason = reason;
             } else if (strategy === 'dequeue-one-at-a-time') {
               oneAtATime = true;
-              if (totalClaudeProcessing > 0) {
+              if (totalToolProcessing > 0) {
                 reasons.push(reason + ' (waiting for current command)');
               }
             } else {
@@ -949,13 +820,62 @@ export class SolveQueue {
           }
         }
       }
+    } else if (applyCodexLimits) {
+      const codexResult = await getCachedCodexLimits(this.verbose);
+      if (codexResult.success) {
+        const sessionPercent = codexResult.usage.currentSession.percentage;
+        const weeklyPercent = codexResult.usage.allModels.percentage;
+
+        if (sessionPercent !== null) {
+          const sessionRatio = sessionPercent / 100;
+          if (sessionRatio >= QUEUE_CONFIG.thresholds.codex5Hour.value) {
+            const reason = formatWaitingReason('codex_5_hour_session', sessionPercent, QUEUE_CONFIG.thresholds.codex5Hour.value);
+            const strategy = QUEUE_CONFIG.thresholds.codex5Hour.strategy;
+            this.recordThrottle(sessionRatio >= 1.0 ? 'codex_5_hour_session_100' : `codex_5_hour_session_${strategy}`);
+
+            if (strategy === 'reject') {
+              rejected = true;
+              rejectReason = reason;
+            } else if (strategy === 'dequeue-one-at-a-time') {
+              oneAtATime = true;
+              if (totalToolProcessing > 0) {
+                reasons.push(reason + ' (waiting for current command)');
+              }
+            } else {
+              reasons.push(reason);
+            }
+          }
+        }
+
+        if (weeklyPercent !== null) {
+          const weeklyRatio = weeklyPercent / 100;
+          if (weeklyRatio >= QUEUE_CONFIG.thresholds.codexWeekly.value) {
+            const reason = formatWaitingReason('codex_weekly', weeklyPercent, QUEUE_CONFIG.thresholds.codexWeekly.value);
+            const strategy = QUEUE_CONFIG.thresholds.codexWeekly.strategy;
+            this.recordThrottle(weeklyRatio >= 1.0 ? 'codex_weekly_100' : `codex_weekly_${strategy}`);
+
+            if (strategy === 'reject') {
+              rejected = true;
+              rejectReason = reason;
+            } else if (strategy === 'dequeue-one-at-a-time') {
+              oneAtATime = true;
+              if (totalToolProcessing > 0) {
+                reasons.push(reason + ' (waiting for current command)');
+              }
+            } else {
+              reasons.push(reason);
+            }
+          }
+        }
+      }
     } else if (this.verbose) {
       this.log(`Claude limits not applied for --tool ${tool}`);
     }
 
-    // Check GitHub limits (only relevant if claude processes running)
+    // Check GitHub limits when the active tool already has a running process.
+    // This keeps the queue behavior aligned with the existing one-at-a-time throttling model.
     // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_GITHUB_API_STRATEGY
-    if (hasRunningClaude) {
+    if (hasRunningToolProcess) {
       const githubResult = await getCachedGitHubLimits(this.verbose);
       if (githubResult.success) {
         const usedPercent = githubResult.githubRateLimit.usedPercentage;
@@ -970,7 +890,7 @@ export class SolveQueue {
             rejectReason = reason;
           } else if (strategy === 'dequeue-one-at-a-time') {
             oneAtATime = true;
-            if (totalClaudeProcessing > 0) {
+            if (totalToolProcessing > 0) {
               reasons.push(reason + ' (waiting for current command)');
             }
           } else {
@@ -1273,22 +1193,11 @@ export class SolveQueue {
    * @see https://github.com/link-assistant/hive-mind/issues/1267
    */
   async formatStatus() {
-    // Get actual process counts for each tool queue
-    // The "processing" count is the number of running system processes, not queue internal state
-    // This ensures users see accurate counts of what's actually running
-    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
-    const agentProcs = await getRunningAgentProcesses(this.verbose);
-
-    const processCounts = {
-      claude: claudeProcs.count,
-      agent: agentProcs.count,
-    };
-
     // Always show per-tool breakdown for all known queues
     let message = 'Queues\n';
     for (const [tool, toolQueue] of Object.entries(this.queues)) {
       const pending = toolQueue.length;
-      const processing = processCounts[tool] || 0;
+      const processing = (await getRunningProcesses(tool, this.verbose)).count;
       message += `${tool} (pending: ${pending}, processing: ${processing})\n`;
     }
 
@@ -1326,20 +1235,12 @@ export class SolveQueue {
     // Get actual process counts for each tool queue
     // The "processing" count is the number of running system processes, not queue internal state
     // This ensures users see accurate counts of what's actually running
-    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
-    const agentProcs = await getRunningAgentProcesses(this.verbose);
-
-    const processCounts = {
-      claude: claudeProcs.count,
-      agent: agentProcs.count,
-    };
-
     let message = '📋 *Solve Queue Status*\n\n';
 
     // Show per-tool queue breakdown with items grouped by queue
     for (const [tool, toolQueue] of Object.entries(this.queues)) {
       const pending = toolQueue.length;
-      const processing = processCounts[tool] || 0;
+      const processing = (await getRunningProcesses(tool, this.verbose)).count;
       message += `*${tool}* (pending: ${pending}, processing: ${processing})\n`;
 
       // Show first 5 queued items for this tool

package/src/version-info.lib.mjs

@@ -562,7 +562,8 @@ const VERSION_COMMANDS = [
   { key: 'playwright', command: 'playwright --version 2>&1' },
   { key: 'playwrightTest', command: "npm list -g @playwright/test --depth=0 2>&1 | grep @playwright/test | awk '{print $2}'" },
   { key: 'playwrightMcp', command: "npm list -g @playwright/mcp --depth=0 2>&1 | grep @playwright/mcp | awk '{print $2}'" },
-  { key: 'playwrightMcpStatus', command: 'timeout 5 claude mcp list 2>&1 | grep -i playwright | head -1' },
+  { key: 'playwrightMcpClaudeStatus', command: 'timeout 5 claude mcp list 2>&1 | grep -i playwright | head -1' },
+  { key: 'playwrightMcpCodexStatus', command: 'timeout 5 codex mcp list 2>&1 | grep -i playwright | head -1' },
   { key: 'puppeteerBrowsers', command: "npm list -g @puppeteer/browsers --depth=0 2>&1 | grep @puppeteer/browsers | awk '{print $2}'" },
 
   // Browsers (installed via Playwright)
@@ -840,7 +841,8 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
         playwright: versions.playwright,
         playwrightTest: versions.playwrightTest,
         playwrightMcp: versions.playwrightMcp,
-        playwrightMcpStatus: versions.playwrightMcpStatus,
+        playwrightMcpClaudeStatus: versions.playwrightMcpClaudeStatus,
+        playwrightMcpCodexStatus: versions.playwrightMcpCodexStatus,
         puppeteerBrowsers: versions.puppeteerBrowsers,
 
         // Browsers
@@ -1179,11 +1181,12 @@ export function formatVersionMessage(versions) {
   const browserAutoLines = [];
   addVersionLine(browserAutoLines, 'Playwright', versions.playwright, 'playwright');
   addVersionLine(browserAutoLines, 'Playwright Test', versions.playwrightTest, 'playwrightTest');
-  // Playwright MCP: show version with Claude Code connection status inline
+  // Playwright MCP: show version with Claude Code and Codex connection status inline
   if (versions.playwrightMcp) {
     const mcpVersion = parseVersion('playwrightMcp', versions.playwrightMcp);
-    const claudeStatus = versions.playwrightMcpStatus ? 'connected' : 'not connected';
-    browserAutoLines.push(`• Playwright MCP: \`${mcpVersion} | Claude Code: ${claudeStatus}\``);
+    const claudeStatus = versions.playwrightMcpClaudeStatus ? 'connected' : 'not connected';
+    const codexStatus = versions.playwrightMcpCodexStatus ? 'connected' : 'not connected';
+    browserAutoLines.push(`• Playwright MCP: \`${mcpVersion} | Claude Code: ${claudeStatus} | Codex: ${codexStatus}\``);
   }
   addVersionLine(browserAutoLines, 'Puppeteer Browsers', versions.puppeteerBrowsers, 'puppeteerBrowsers');