agent-tank 0.9.0

package/src/agents/pty-output-parser.js

@@ -0,0 +1,301 @@
+/**
+ * PTY Output Parser for Claude Agent
+ * Handles parsing of PTY terminal output from the Claude CLI /usage command
+ */
+
+const { calculatePace } = require('../pace-evaluator.js');
+const { CYCLE_DURATIONS } = require('../usage-formatters.js');
+
+/**
+ * Convert 12-hour time to 24-hour
+ * @param {string} hourRaw - Hour value as string
+ * @param {string} ampm - 'am' or 'pm'
+ * @returns {number} Hour in 24-hour format
+ */
+function to24Hour(hourRaw, ampm) {
+  let hour = parseInt(hourRaw);
+  if (ampm.toLowerCase() === 'pm' && hour !== 12) hour += 12;
+  if (ampm.toLowerCase() === 'am' && hour === 12) hour = 0;
+  return hour;
+}
+
+/**
+ * Format duration from seconds to readable text
+ * @param {number} diffSeconds - Duration in seconds
+ * @returns {string} Formatted duration string
+ */
+function formatDuration(diffSeconds) {
+  const mins = Math.floor(diffSeconds / 60);
+  const hours = Math.floor(mins / 60);
+  const m = mins % 60;
+  if (hours > 24) {
+    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+  }
+  return hours > 0 ? `${hours}h ${m}m` : `${m}m`;
+}
+
+/**
+ * Parse date with time: "Jan 22, 1pm" or date-only: "Apr 1"
+ * @param {string} cleanStr - Cleaned date string
+ * @param {Date} now - Current date/time
+ * @param {string[]} monthNames - Array of month name abbreviations
+ * @returns {Date|null} Parsed date or null
+ */
+function parseDateTimeStr(cleanStr, now, monthNames) {
+  const dateTimeMatch = cleanStr.match(/(\w+)\s+(\d{1,2}),?\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)/i);
+  // 24-hour format with date: "10:00 on 15 Mar" or "14:30 on 22 Jan"
+  const time24DateMatch = !dateTimeMatch && cleanStr.match(/^(\d{1,2}):(\d{2})\s+on\s+(\d{1,2})\s+(\w+)$/i);
+  const dateOnlyMatch = !dateTimeMatch && !time24DateMatch && cleanStr.match(/(\w+)\s+(\d{1,2})$/i);
+  if (!dateTimeMatch && !time24DateMatch && !dateOnlyMatch) return null;
+
+  let resetDate;
+  if (dateTimeMatch) {
+    const [, month, day, hourRaw, minutes = '0', ampm] = dateTimeMatch;
+    const monthIndex = monthNames.indexOf(month.toLowerCase().substring(0, 3));
+    if (monthIndex === -1) return null;
+    resetDate = new Date(now.getFullYear(), monthIndex, parseInt(day), to24Hour(hourRaw, ampm), parseInt(minutes));
+  } else if (time24DateMatch) {
+    const [, hours, minutes, day, month] = time24DateMatch;
+    const monthIndex = monthNames.indexOf(month.toLowerCase().substring(0, 3));
+    if (monthIndex === -1) return null;
+    resetDate = new Date(now.getFullYear(), monthIndex, parseInt(day), parseInt(hours), parseInt(minutes));
+  } else {
+    const [, month, day] = dateOnlyMatch;
+    const monthIndex = monthNames.indexOf(month.toLowerCase().substring(0, 3));
+    if (monthIndex === -1) return null;
+    resetDate = new Date(now.getFullYear(), monthIndex, parseInt(day));
+  }
+  if (resetDate < now) resetDate.setFullYear(resetDate.getFullYear() + 1);
+  return resetDate;
+}
+
+/**
+ * Convert reset timestamp to duration object with string and seconds
+ * @param {string} resetStr - Reset time string from PTY output
+ * @returns {Object|null} Object with text and seconds, or null
+ */
+function parseResetTime(resetStr) {
+  if (!resetStr) return null;
+  const now = new Date();
+  const cleanStr = resetStr.replace(/\s*\([^)]+\)\s*$/, '').trim();
+  const monthNames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+
+  let resetDate;
+  // Try time-only format first: "2:59am" or "12:30pm"
+  const timeOnlyMatch = cleanStr.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)$/i);
+  // Try 24-hour time-only format: "14:30" or "23:00"
+  const time24Match = !timeOnlyMatch && cleanStr.match(/^(\d{1,2}):(\d{2})$/);
+  if (timeOnlyMatch) {
+    const [, hourRaw, minutes = '0', ampm] = timeOnlyMatch;
+    resetDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), to24Hour(hourRaw, ampm), parseInt(minutes));
+    if (resetDate <= now) resetDate.setDate(resetDate.getDate() + 1);
+  } else if (time24Match) {
+    const [, hours, minutes] = time24Match;
+    resetDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), parseInt(hours), parseInt(minutes));
+    if (resetDate <= now) resetDate.setDate(resetDate.getDate() + 1);
+  } else {
+    resetDate = parseDateTimeStr(cleanStr, now, monthNames);
+    if (!resetDate) return { text: resetStr, seconds: null };
+  }
+
+  const diffMs = resetDate - now;
+  if (diffMs <= 0) return { text: 'soon', seconds: 0 };
+  const diffSeconds = Math.floor(diffMs / 1000);
+  return { text: formatDuration(diffSeconds), seconds: diffSeconds };
+}
+
+/**
+ * Extract section between two regex patterns from text
+ * @param {string} text - Full text to search
+ * @param {string} start - Start pattern
+ * @param {string} end - End pattern (optional)
+ * @returns {string|null} Extracted section or null
+ */
+function extractSection(text, start, end) {
+  const regex = end ? new RegExp(`${start}([\\s\\S]*?)(?=${end}|$)`, 'i') : new RegExp(`${start}([\\s\\S]*)$`, 'i');
+  return text.match(regex)?.[1] || null;
+}
+
+/**
+ * Extract reset time string from a section (handles PTY corruption)
+ * @param {string} section - Section text
+ * @returns {string|null} Reset time string or null
+ */
+function extractResetTime(section) {
+  // Look for date+time pattern FIRST (more specific)
+  const dateTimeMatch = section.match(/((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2},?\s*\d{1,2}(?::\d{2})?\s*(am|pm))\s*\(([^)]+)\)/i);
+  if (dateTimeMatch) return `${dateTimeMatch[1]} (${dateTimeMatch[3]})`;
+  // Try clean time-only pattern
+  const timeOnlyMatch = section.match(/(\d{1,2}(?::\d{2})?\s*(?:am|pm))\s*\(([^)]+)\)/i);
+  if (timeOnlyMatch) return `${timeOnlyMatch[1]} (${timeOnlyMatch[2]})`;
+  // Handle PTY-corrupted time: "1 m" or "2 59 m" (missing a/p)
+  const corruptedMatch = section.match(/(\d{1,2})(?:\s*:?\s*(\d{2}))?\s+m\s*\(([^)]+)\)/i);
+  if (corruptedMatch) {
+    const [, hour, minutes, tz] = corruptedMatch;
+    const mins = minutes ? `:${minutes}` : '';
+    const am = `${hour}${mins}am (${tz})`;
+    const pm = `${hour}${mins}pm (${tz})`;
+    const amSec = parseResetTime(am)?.seconds ?? Infinity;
+    const pmSec = parseResetTime(pm)?.seconds ?? Infinity;
+    return amSec <= pmSec ? am : pm;
+  }
+  return null;
+}
+
+/**
+ * Parse a usage section for percent and reset time
+ * @param {string|null} section - Section text
+ * @returns {Object|null} Parsed section data or null
+ */
+function parseUsageSection(section) {
+  if (!section) return null;
+  const percentMatch = section.match(/(\d+)\s*%\s*used/i);
+  if (!percentMatch) return null;
+  const resetsAt = extractResetTime(section);
+  const resetData = resetsAt ? parseResetTime(resetsAt) : null;
+  return {
+    percent: parseFloat(percentMatch[1]),
+    resetsAt,
+    resetsIn: resetData?.text || null,
+    resetsInSeconds: resetData?.seconds || null,
+  };
+}
+
+/**
+ * Parse extra usage section with budget info
+ * @param {string} extraSection - Extra usage section text
+ * @returns {Object|null} Parsed extra usage data or null
+ */
+function parseExtraUsage(extraSection) {
+  const percentMatch = extraSection.match(/(\d+)\s*%\s*used/i);
+  const spentMatch = extraSection.match(/\$([0-9.]+)\s*\/\s*\$([0-9.]+)\s*spent/i);
+  if (!percentMatch && !spentMatch) return null;
+  const dateMatch = extraSection.match(/((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2},?\s*(?:\d{1,2}(?::\d{2})?\s*(?:am|pm))?)\s*\(([^)]+)\)/i);
+  const resetsAt = dateMatch ? `${dateMatch[1].trim()} (${dateMatch[2]})` : null;
+  const resetData = resetsAt ? parseResetTime(resetsAt) : null;
+  return {
+    label: 'Extra usage',
+    percent: percentMatch ? parseFloat(percentMatch[1]) : null,
+    spent: spentMatch ? parseFloat(spentMatch[1]) : null,
+    budget: spentMatch ? parseFloat(spentMatch[2]) : null,
+    resetsAt,
+    resetsIn: resetData?.text || null,
+    resetsInSeconds: resetData?.seconds || null,
+  };
+}
+
+/**
+ * Parse legacy weekly format (single "Current week" without model qualifiers)
+ * @param {string} clean - Cleaned output text
+ * @returns {Object|null} Parsed legacy weekly data or null
+ */
+function parseLegacyWeekly(clean) {
+  const weeklyMatch = clean.match(/Current\s+week[\s\S]*?(\d+)\s*%\s*used[\s\S]*?Resets\s+([\s\S]*?)(?=esc\s+to\s+cancel|current\s+week|$)/i);
+  if (weeklyMatch) {
+    const resetSection = weeklyMatch[2];
+    const tzMatch = resetSection.match(/((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2},?\s*\d{1,2}(?::\d{2})?\s*(?:am|pm)\s*\([^)]+\)|\d{1,2}(?::\d{2})?\s*(?:am|pm)\s*\([^)]+\))/i);
+    const resetsAt = tzMatch ? tzMatch[1].trim() : resetSection.trim().split(/\s{2,}/)[0];
+    const resetData = parseResetTime(resetsAt);
+    return {
+      percent: parseFloat(weeklyMatch[1]),
+      label: 'Current week',
+      resetsAt,
+      resetsIn: resetData?.text || null,
+      resetsInSeconds: resetData?.seconds || null,
+    };
+  }
+  const percentMatch = clean.match(/Current\s+week[^%]*?(\d+)\s*%\s*used/i);
+  if (percentMatch) {
+    return {
+      percent: parseFloat(percentMatch[1]),
+      label: 'Current week',
+      resetsAt: null,
+      resetsIn: null,
+      resetsInSeconds: null,
+    };
+  }
+  return null;
+}
+
+/**
+ * Add pace data to a usage section
+ * @param {Object|null} sectionData - Usage section data
+ * @param {string} cycleType - Type of cycle ('session' or 'weekly')
+ * @returns {Object|null} Section data with pace info added
+ */
+function addPaceData(sectionData, cycleType) {
+  if (!sectionData || sectionData.resetsInSeconds == null) return sectionData;
+  const cycleDuration = CYCLE_DURATIONS[cycleType];
+  if (!cycleDuration) return sectionData;
+  const paceData = calculatePace({
+    usagePercent: sectionData.percent ?? 0,
+    resetsInSeconds: sectionData.resetsInSeconds,
+    cycleDurationSeconds: cycleDuration,
+  });
+  if (paceData) sectionData.pace = paceData;
+  return sectionData;
+}
+
+/**
+ * Parse PTY output from /usage command into unified usage schema
+ * @param {string} clean - Cleaned (ANSI-stripped) output text
+ * @returns {Object} Parsed usage object
+ */
+function parsePtyOutput(clean) {
+  const usage = { session: null, weeklyAll: null, weeklySonnet: null };
+
+  // Parse session
+  const sessionData = parseUsageSection(extractSection(clean, 'Current\\s+session', 'Current\\s+week'));
+  if (sessionData) {
+    usage.session = { label: 'Current session', ...sessionData };
+    addPaceData(usage.session, 'session');
+  }
+
+  // Parse weekly (all models)
+  const weeklyAllData = parseUsageSection(extractSection(clean, 'Current\\s+week\\s*\\(?\\s*all\\s+models\\s*\\)?', 'Current\\s+week\\s*\\(?\\s*Sonnet'));
+  if (weeklyAllData) {
+    usage.weeklyAll = { label: 'Current week (all models)', ...weeklyAllData };
+    addPaceData(usage.weeklyAll, 'weekly');
+  }
+
+  // Parse weekly (Sonnet only)
+  const weeklySonnetData = parseUsageSection(extractSection(clean, 'Current\\s+week\\s*\\(?\\s*Sonnet\\s+only\\s*\\)?', 'Extra\\s+usage|esc\\s+to\\s+cancel|Current\\s+week\\s*\\('));
+  if (weeklySonnetData) {
+    usage.weeklySonnet = { label: 'Current week (Sonnet only)', ...weeklySonnetData };
+    addPaceData(usage.weeklySonnet, 'weekly');
+  }
+
+  // Parse extra usage section
+  const extraSection = extractSection(clean, 'Extra\\s+usage', 'esc\\s+to\\s+cancel');
+  if (extraSection) {
+    const extraData = parseExtraUsage(extraSection);
+    if (extraData) {
+      usage.extraUsage = extraData;
+      addPaceData(usage.extraUsage, 'weekly');
+    }
+  }
+
+  // Legacy format fallback
+  if (!usage.weeklyAll && !usage.weeklySonnet) {
+    const legacyWeekly = parseLegacyWeekly(clean);
+    if (legacyWeekly) {
+      usage.weekly = legacyWeekly;
+      addPaceData(usage.weekly, 'weekly');
+    }
+  }
+
+  return usage;
+}
+
+module.exports = {
+  parsePtyOutput,
+  parseResetTime,
+  formatDuration,
+  to24Hour,
+  extractSection,
+  extractResetTime,
+  parseUsageSection,
+  parseExtraUsage,
+  parseLegacyWeekly,
+  addPaceData,
+};

package/src/auto-refresh-manager.js

@@ -0,0 +1,246 @@
+const { ActivityMonitor } = require('./activity-monitor.js');
+
+/**
+ * Manages auto-refresh behavior for AgentTank.
+ * Supports three modes: 'none', 'interval', and 'activity'.
+ */
+class AutoRefreshManager {
+  /**
+   * @param {Object} options
+   * @param {Object} options.config - Auto-refresh configuration
+   * @param {Map} options.agents - Map of agent instances
+   * @param {Function} options.onRefreshAll - Callback to refresh all agents
+   * @param {Function} options.onRefreshAgent - Callback to refresh a single agent
+   */
+  constructor(options) {
+    this.config = options.config;
+    this.agents = options.agents;
+    this.onRefreshAll = options.onRefreshAll;
+    this.onRefreshAgent = options.onRefreshAgent;
+
+    this.autoRefreshTimer = null;
+    this.agentRefreshTimers = new Map();
+    this.lastRefreshedAt = null;
+
+    // Activity monitor for activity-based polling
+    this.activityMonitor = null;
+    this.activityRefreshTimer = null;
+    this.isActivityRefreshing = false;
+  }
+
+  /**
+   * Start auto-refresh based on configured mode.
+   */
+  start() {
+    this.stop();
+
+    if (!this.config.enabled || this.config.mode === 'none') {
+      console.log('Backend auto-refresh: disabled');
+      return;
+    }
+
+    if (this.config.mode === 'activity') {
+      this._startActivityBasedRefresh();
+      return;
+    }
+
+    this._startIntervalBasedRefresh();
+  }
+
+  /**
+   * Stop all auto-refresh timers and monitors.
+   */
+  stop() {
+    if (this.autoRefreshTimer) {
+      clearInterval(this.autoRefreshTimer);
+      this.autoRefreshTimer = null;
+    }
+    for (const timer of this.agentRefreshTimers.values()) {
+      clearInterval(timer);
+    }
+    this.agentRefreshTimers.clear();
+
+    if (this.activityRefreshTimer) {
+      clearTimeout(this.activityRefreshTimer);
+      this.activityRefreshTimer = null;
+    }
+    if (this.activityMonitor) {
+      this.activityMonitor.stop();
+      this.activityMonitor = null;
+    }
+    this.isActivityRefreshing = false;
+  }
+
+  /**
+   * Get the last refresh timestamp.
+   * @returns {string|null}
+   */
+  getLastRefreshedAt() {
+    return this.lastRefreshedAt;
+  }
+
+  /**
+   * Update the last refresh timestamp.
+   * @param {string} timestamp
+   */
+  setLastRefreshedAt(timestamp) {
+    this.lastRefreshedAt = timestamp;
+  }
+
+  /**
+   * Get activity monitor status.
+   * @returns {Object}
+   */
+  getActivityMonitorStatus() {
+    if (this.activityMonitor) {
+      return {
+        ...this.activityMonitor.getStatus(),
+        isActivityRefreshing: this.isActivityRefreshing,
+      };
+    }
+    return {
+      isMonitoring: false,
+      debounceInterval: this.config.activityDebounce,
+      monitoredAgents: [],
+      agentCount: 0,
+      activityCount: 0,
+      lastActivityAt: {},
+      hasPendingActivity: false,
+      pendingAgents: [],
+      isActivityRefreshing: false,
+    };
+  }
+
+  /**
+   * Start activity-based auto-refresh.
+   * @private
+   */
+  _startActivityBasedRefresh() {
+    const agentNames = Array.from(this.agents.keys());
+    const debounceMs = this.config.activityDebounce;
+    const intervalSeconds = this.config.interval;
+
+    console.log(`Backend auto-refresh: activity mode (debounce: ${debounceMs}ms, cycle interval: ${intervalSeconds}s)`);
+
+    this.activityMonitor = new ActivityMonitor({
+      debounceInterval: debounceMs,
+      agents: agentNames,
+      onActivity: (event) => {
+        this._handleActivityDetected(event);
+      },
+    });
+
+    const startResult = this.activityMonitor.start();
+
+    if (startResult.agentCount === 0) {
+      console.log('[ActivityMonitor] No log directories found to monitor, falling back to interval mode');
+      this._startIntervalBasedRefresh();
+      return;
+    }
+
+    // Ignore short-lived startup churn immediately after the initial fetch/boot.
+    this.activityMonitor.suppressAll(Math.max(this.config.activityDebounce, 5000));
+
+    console.log(`[ActivityMonitor] Monitoring ${startResult.monitoredDirs.length} directories`);
+  }
+
+  /**
+   * Handle activity detection from the ActivityMonitor.
+   * @param {Object} event - Activity event from ActivityMonitor
+   * @private
+   */
+  _handleActivityDetected(event) {
+    console.log(`[Activity] Detected for ${event.agent}, starting refresh cycle...`);
+
+    if (this.isActivityRefreshing) {
+      console.log('[Activity] Already in refresh cycle, activity will extend it');
+      return;
+    }
+
+    this.isActivityRefreshing = true;
+    this._runActivityRefreshCycle();
+  }
+
+  /**
+   * Run a single iteration of the activity refresh cycle.
+   * @private
+   */
+  async _runActivityRefreshCycle() {
+    try {
+      if (this.activityMonitor) {
+        // Ignore short-lived filesystem churn caused by our own refresh commands.
+        this.activityMonitor.suppressAll(Math.max(this.config.activityDebounce, 5000));
+      }
+      console.log('[Activity-refresh] Running refresh cycle...');
+      await this.onRefreshAll();
+      this.lastRefreshedAt = new Date().toISOString();
+    } catch (err) {
+      console.error('[Activity-refresh] Error during refresh:', err.message);
+    }
+
+    const hasPending = this.activityMonitor && this.activityMonitor.hasPendingActivity();
+
+    if (hasPending) {
+      const intervalMs = this.config.interval * 1000;
+      console.log(`[Activity-refresh] More activity pending, scheduling next cycle in ${this.config.interval}s`);
+
+      this.activityRefreshTimer = setTimeout(() => {
+        this._runActivityRefreshCycle();
+      }, intervalMs);
+    } else {
+      console.log('[Activity-refresh] No more pending activity, going idle');
+      this.isActivityRefreshing = false;
+      this.activityRefreshTimer = null;
+    }
+  }
+
+  /**
+   * Start interval-based auto-refresh (traditional polling).
+   * @private
+   */
+  _startIntervalBasedRefresh() {
+    const globalInterval = this.config.interval;
+
+    if (globalInterval <= 0) {
+      console.log('Backend auto-refresh: disabled (interval is 0)');
+      return;
+    }
+
+    const globalAgents = [];
+    for (const [name, agent] of this.agents) {
+      const effective = agent.refreshInterval
+        ?? (agent.minRefreshInterval ? Math.max(globalInterval, agent.minRefreshInterval) : null);
+      if (effective && effective > globalInterval) {
+        const intervalMs = effective * 1000;
+        console.log(`Backend auto-refresh [${name}]: every ${effective}s`);
+        const timer = setInterval(async () => {
+          console.log(`[Auto-refresh] Refreshing ${name}...`);
+          await this.onRefreshAgent(name).catch(err =>
+            console.error(`Error refreshing ${name}:`, err.message)
+          );
+          this.lastRefreshedAt = new Date().toISOString();
+        }, intervalMs);
+        this.agentRefreshTimers.set(name, timer);
+      } else {
+        globalAgents.push(name);
+      }
+    }
+
+    if (globalAgents.length > 0) {
+      console.log(`Backend auto-refresh [${globalAgents.join(', ')}]: every ${globalInterval}s (interval mode)`);
+      this.autoRefreshTimer = setInterval(async () => {
+        console.log(`[Auto-refresh] Refreshing ${globalAgents.join(', ')}...`);
+        const promises = globalAgents.map(name => {
+          const agent = this.agents.get(name);
+          return agent ? agent.refresh().catch(err =>
+            console.error(`Error refreshing ${name}:`, err.message)
+          ) : Promise.resolve();
+        });
+        await Promise.all(promises);
+        this.lastRefreshedAt = new Date().toISOString();
+      }, globalInterval * 1000);
+    }
+  }
+}
+
+module.exports = { AutoRefreshManager };

package/src/client-auto-refresh-helpers.js

@@ -0,0 +1,143 @@
+// Client-side JavaScript helpers for auto-refresh system
+// These helper functions are injected into the client-side code
+
+const colorHelpers = `
+    // Color helper functions (mirrored from server-side usage-formatters.js)
+    function getColorClassFromPercent(value) {
+      if (value < 50) return 'high';
+      if (value < 80) return 'medium';
+      return 'low';
+    }
+
+    function getStatusDotClassFromPercent(value) {
+      if (value <= 50) return 'status-green';
+      if (value <= 80) return 'status-yellow';
+      return 'status-red';
+    }
+
+    function getProgressColorFromPercent(value) {
+      if (value < 50) return '#48bb78';
+      if (value < 80) return '#ecc94b';
+      return '#e53e3e';
+    }
+`;
+
+const timeHelpers = `
+    // Parse "Resets in" time string to seconds (mirrored from server-side)
+    function parseResetsInToSeconds(resetsIn) {
+      if (!resetsIn || typeof resetsIn !== 'string') return null;
+      let totalSeconds = 0;
+      const dayMatch = resetsIn.match(/(\\d+)\\s*d(?:ay)?s?/i);
+      const hourMatch = resetsIn.match(/(\\d+)\\s*h(?:our)?s?/i);
+      const minMatch = resetsIn.match(/(\\d+)\\s*m(?:in(?:ute)?)?s?/i);
+      const secMatch = resetsIn.match(/(\\d+)\\s*s(?:ec(?:ond)?)?s?/i);
+      if (dayMatch) totalSeconds += parseInt(dayMatch[1], 10) * 24 * 60 * 60;
+      if (hourMatch) totalSeconds += parseInt(hourMatch[1], 10) * 60 * 60;
+      if (minMatch) totalSeconds += parseInt(minMatch[1], 10) * 60;
+      if (secMatch) totalSeconds += parseInt(secMatch[1], 10);
+      return totalSeconds > 0 ? totalSeconds : null;
+    }
+
+    // Cycle duration constants (mirrored from server-side)
+    const CYCLE_DURATIONS = {
+      session: 5 * 60 * 60,
+      sessionGemini: 24 * 60 * 60,
+      weekly: 7 * 24 * 60 * 60,
+      fiveHour: 5 * 60 * 60
+    };
+`;
+
+const metricExtractors = `
+    // Extract metrics from Claude usage data
+    function extractClaudeMetrics(usage) {
+      const metrics = [];
+      const sections = [
+        { data: usage.session, label: 'Session', cycle: 'session' },
+        { data: usage.weeklyAll, label: 'Weekly (all)', cycle: 'weekly' },
+        { data: usage.weeklySonnet, label: 'Weekly (Sonnet)', cycle: 'weekly' },
+        { data: usage.weekly, label: 'Weekly', cycle: 'weekly' }
+      ];
+      for (const { data, label, cycle } of sections) {
+        if (data) {
+          const metricId = \`claude-\${label.toLowerCase().replace(/[^a-z0-9]/g, '-')}\`;
+          metrics.push({
+            metricId,
+            agent: 'claude',
+            label,
+            percent: data.percent ?? 0,
+            resetsIn: data.resetsIn || '',
+            resetsAt: data.resetsAt || '',
+            cycle
+          });
+        }
+      }
+      return metrics;
+    }
+
+    // Extract metrics from Gemini usage data
+    function extractGeminiMetrics(usage) {
+      const metrics = [];
+      if (usage.models && usage.models.length > 0) {
+        for (const model of usage.models) {
+          const modelName = model.model.toLowerCase();
+          const metricId = \`gemini-\${modelName.replace(/[^a-z0-9]/g, '-')}\`;
+          metrics.push({
+            metricId,
+            agent: 'gemini',
+            label: modelName,
+            percent: model.percentUsed ?? 0,
+            resetsIn: model.resetsIn || '',
+            resetsAt: model.resetsAt || '',
+            cycle: 'sessionGemini'
+          });
+        }
+      }
+      return metrics;
+    }
+
+    // Extract metrics from Codex usage data
+    function extractCodexMetrics(usage) {
+      const metrics = [];
+      const models = [];
+      if (usage.fiveHour || usage.weekly) {
+        models.push({ name: usage.model || 'Default', fiveHour: usage.fiveHour, weekly: usage.weekly });
+      }
+      if (usage.modelLimits) {
+        models.push(...usage.modelLimits);
+      }
+      for (const ml of models) {
+        const modelSlug = ml.name.toLowerCase().replace(/[^a-z0-9]/g, '-');
+        if (ml.fiveHour) {
+          metrics.push({
+            metricId: \`codex-\${modelSlug}-5h\`,
+            agent: 'codex',
+            label: '5h limit',
+            modelName: ml.name,
+            percent: ml.fiveHour.percentUsed ?? 0,
+            resetsIn: ml.fiveHour.resetsIn || '',
+            resetsAt: ml.fiveHour.resetsAt || '',
+            cycle: 'fiveHour'
+          });
+        }
+        if (ml.weekly) {
+          metrics.push({
+            metricId: \`codex-\${modelSlug}-weekly\`,
+            agent: 'codex',
+            label: 'Weekly',
+            modelName: ml.name,
+            percent: ml.weekly.percentUsed ?? 0,
+            resetsIn: ml.weekly.resetsIn || '',
+            resetsAt: ml.weekly.resetsAt || '',
+            cycle: 'weekly'
+          });
+        }
+      }
+      return metrics;
+    }
+`;
+
+module.exports = {
+  colorHelpers,
+  timeHelpers,
+  metricExtractors
+};