farming-code 2.2.8 → 2.2.12

package/backend/terminal-state-serialization.js

@@ -0,0 +1,127 @@
+const TERMINAL_STATE_VERSION = 1;
+const MAX_SERIALIZED_TERMINAL_STATE_BYTES = 32 * 1024 * 1024;
+const MAX_REPLAY_EVENT_BYTES = 8 * 1024 * 1024;
+
+function finitePositiveInteger(value, fallback) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function normalizeReplayEvent(replayEvent) {
+  const events = Array.isArray(replayEvent?.events) ? replayEvent.events : [];
+  if (events.length !== 1) {
+    throw new Error('Serialized terminal state requires exactly one replay event');
+  }
+  const event = events[0] || {};
+  const data = typeof event.data === 'string' ? event.data : '';
+  if (Buffer.byteLength(data, 'utf8') > MAX_REPLAY_EVENT_BYTES) {
+    throw new Error('Serialized terminal replay event exceeds the size limit');
+  }
+  return {
+    events: [{
+      data,
+      cols: finitePositiveInteger(event.cols, 80),
+      rows: finitePositiveInteger(event.rows, 30),
+    }],
+  };
+}
+
+function normalizeTerminalStateEntry(entry) {
+  if (!entry || typeof entry !== 'object') {
+    throw new Error('Serialized terminal state entry must be an object');
+  }
+  const id = typeof entry.id === 'string' ? entry.id.trim() : '';
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/.test(id)) {
+    throw new Error('Serialized terminal state has an invalid session id');
+  }
+  const metadata = entry.metadata && typeof entry.metadata === 'object' && !Array.isArray(entry.metadata)
+    ? { ...entry.metadata }
+    : {};
+  const processDetails = entry.processDetails && typeof entry.processDetails === 'object'
+    ? entry.processDetails
+    : {};
+  const processLaunchConfig = entry.processLaunchConfig && typeof entry.processLaunchConfig === 'object'
+    ? entry.processLaunchConfig
+    : {};
+  return {
+    id,
+    metadata: {
+      ...metadata,
+      agentId: id,
+    },
+    processDetails: {
+      cwd: typeof processDetails.cwd === 'string' ? processDetails.cwd : '',
+      title: typeof processDetails.title === 'string' ? processDetails.title : '',
+    },
+    processLaunchConfig: {
+      command: typeof processLaunchConfig.command === 'string' ? processLaunchConfig.command : '',
+      args: Array.isArray(processLaunchConfig.args)
+        ? processLaunchConfig.args.filter(arg => typeof arg === 'string')
+        : [],
+      category: typeof processLaunchConfig.category === 'string' ? processLaunchConfig.category : '',
+    },
+    replayEvent: normalizeReplayEvent(entry.replayEvent),
+    timestamp: Number.isFinite(Number(entry.timestamp))
+      ? Math.max(0, Math.floor(Number(entry.timestamp)))
+      : Date.now(),
+  };
+}
+
+function serializeTerminalState(entries) {
+  const state = (Array.isArray(entries) ? entries : []).map(normalizeTerminalStateEntry);
+  const ids = new Set();
+  for (const entry of state) {
+    if (ids.has(entry.id)) {
+      throw new Error(`Serialized terminal state contains duplicate session id ${entry.id}`);
+    }
+    ids.add(entry.id);
+  }
+  const serialized = JSON.stringify({
+    version: TERMINAL_STATE_VERSION,
+    state,
+  });
+  if (Buffer.byteLength(serialized, 'utf8') > MAX_SERIALIZED_TERMINAL_STATE_BYTES) {
+    throw new Error('Serialized terminal state exceeds the size limit');
+  }
+  return serialized;
+}
+
+function deserializeTerminalState(serialized) {
+  if (typeof serialized !== 'string' || !serialized) return [];
+  if (Buffer.byteLength(serialized, 'utf8') > MAX_SERIALIZED_TERMINAL_STATE_BYTES) {
+    throw new Error('Serialized terminal state exceeds the size limit');
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error('Serialized terminal state is not valid JSON');
+  }
+  if (!parsed || typeof parsed !== 'object' || parsed.version !== TERMINAL_STATE_VERSION || !Array.isArray(parsed.state)) {
+    throw new Error('Serialized terminal state has an unsupported format or version');
+  }
+  const state = parsed.state.map(normalizeTerminalStateEntry);
+  const ids = new Set();
+  for (const entry of state) {
+    if (ids.has(entry.id)) {
+      throw new Error(`Serialized terminal state contains duplicate session id ${entry.id}`);
+    }
+    ids.add(entry.id);
+  }
+  return state;
+}
+
+function terminalReplayText(entry) {
+  const normalized = normalizeTerminalStateEntry(entry);
+  return normalized.replayEvent.events[0].data;
+}
+
+module.exports = {
+  MAX_REPLAY_EVENT_BYTES,
+  MAX_SERIALIZED_TERMINAL_STATE_BYTES,
+  TERMINAL_STATE_VERSION,
+  deserializeTerminalState,
+  normalizeTerminalStateEntry,
+  serializeTerminalState,
+  terminalReplayText,
+};

package/backend/terminal-status.js

@@ -150,13 +150,12 @@ function latestTerminalKindFromText(title, previewText) {
 
 function inferKindFromText(title, previewText, command) {
   const commandName = executableName(command).toLowerCase();
-  if (commandName === 'claude') return 'claude';
-  if (commandName === 'codex') return 'codex';
   if (DIRECT_PROCESS_AGENTS.has(commandName)) return 'process';
-  if (commandName && !SHELL_COMMANDS.has(commandName)) return 'process';
-
+  if (commandName && !SHELL_COMMANDS.has(commandName) && commandName !== 'codex' && commandName !== 'claude') return 'process';
   const terminalKind = latestTerminalKindFromText(title, previewText);
   if (terminalKind) return terminalKind;
+  if (commandName === 'claude') return 'claude';
+  if (commandName === 'codex') return 'codex';
   if (SHELL_COMMANDS.has(commandName)) return 'shell';
   return commandName ? 'process' : 'unknown';
 }
@@ -350,7 +349,27 @@ function deriveTerminalStatus(options = {}) {
   return status;
 }
 
+function terminalInputReady(options = {}) {
+  const status = deriveTerminalStatus(options);
+  if (status.activity !== 'idle') return false;
+
+  const previewText = typeof options.previewText === 'string' ? options.previewText : '';
+  if (status.kind === 'codex') {
+    const text = stripTerminalControlSequences(previewText).replace(/\r/g, '').toLowerCase();
+    return lastCodexIdleFooterIndex(text) >= 0 || codexBlockedIndex(text) >= 0;
+  }
+  if (status.kind === 'claude') {
+    const text = stripTerminalControlSequences(previewText).replace(/\r/g, '');
+    return /(?:^|\n)\s*❯(?:\s|$)/u.test(text);
+  }
+  if (status.kind === 'shell') {
+    return options.terminalBusy === false || terminalTextLooksIdleShellPrompt(previewText);
+  }
+  return Boolean(stripTerminalControlSequences(previewText).trim());
+}
+
 module.exports = {
   deriveTerminalStatus,
+  terminalInputReady,
   terminalTextLooksIdleShellPrompt,
 };

package/backend/usage-monitor.js

@@ -9,10 +9,11 @@ const { attachQuotaForecasts } = require('./usage-forecast');
 const execFileAsync = promisify(execFile);
 
 const USAGE_WINDOW_MS = 5 * 60 * 1000;
-const USAGE_TIMELINE_WINDOW_MS = 60 * 60 * 1000;
-const USAGE_TIMELINE_BUCKET_COUNT = 30;
+const USAGE_TIMELINE_WINDOW_MS = 24 * 60 * 60 * 1000;
+const USAGE_TIMELINE_BUCKET_COUNT = 24;
 const USAGE_DAILY_DAYS = 52 * 7;
 const USAGE_DAILY_CACHE_MS = 5 * 60 * 1000;
+const USAGE_LIVE_DAY_CACHE_MS = 5 * 1000;
 const JSONL_FILE_LIMIT = 60;
 const JSONL_SCAN_LIMIT = 2000;
 const DAILY_JSONL_FILE_LIMIT = 5000;
@@ -151,6 +152,32 @@ function addTokenBreakdown(target, source) {
   return target;
 }
 
+function usageAgentIdFromFilePath(filePath) {
+  const basename = path.basename(String(filePath || ''), path.extname(String(filePath || '')));
+  const uuid = basename.match(/([0-9a-f]{8}-[0-9a-f-]{27})$/i);
+  return uuid?.[1] || basename || 'unattributed';
+}
+
+function usageAgentLabel(provider, agentId) {
+  const providerName = {
+    codex: 'Codex',
+    claude: 'Claude',
+    opencode: 'OpenCode',
+    qoder: 'Qoder',
+  }[provider] || provider;
+  if (!agentId || agentId === 'unattributed') return providerName;
+  const shortId = agentId.length > 12 ? `…${agentId.slice(-6)}` : agentId;
+  return `${providerName} · ${shortId}`;
+}
+
+function attributeUsageEvent(event, provider, agentId) {
+  return {
+    ...event,
+    agentId,
+    agentLabel: usageAgentLabel(provider, agentId),
+  };
+}
+
 function subtractTokenBreakdown(current, previous) {
   const result = emptyTokenBreakdown();
   for (const field of Object.keys(result)) {
@@ -267,7 +294,9 @@ function buildUsageTimeline(providerEvents, options = {}) {
   const windowMs = Math.max(60_000, options.windowMs ?? USAGE_TIMELINE_WINDOW_MS);
   const bucketCount = Math.max(1, Math.floor(options.bucketCount ?? USAGE_TIMELINE_BUCKET_COUNT));
   const bucketMs = windowMs / bucketCount;
-  const endAt = now;
+  const endAt = options.alignToBucket
+    ? Math.ceil(now / bucketMs) * bucketMs
+    : now;
   const startAt = endAt - windowMs;
   const providerNames = Object.keys(providerEvents || {});
   const points = Array.from({ length: bucketCount }, (_, index) => ({
@@ -651,11 +680,14 @@ function buildUsageDayDetail(providerEvents, options = {}) {
     hour,
     label: String(hour).padStart(2, '0'),
     ...emptyTokenBreakdown(),
+    agents: {},
   }));
   const providers = Object.fromEntries(
     providerNames.map(provider => [provider, emptyTokenBreakdown()]),
   );
   const total = emptyTokenBreakdown();
+  const agents = new Map();
+  const agentLabels = options.agentLabels instanceof Map ? options.agentLabels : new Map();
 
   for (const provider of providerNames) {
     for (const event of providerEvents[provider] || []) {
@@ -663,8 +695,24 @@ function buildUsageDayDetail(providerEvents, options = {}) {
       if (localDateKey(timestamp) !== date) continue;
       const hour = new Date(timestamp).getHours();
       if (!Number.isInteger(hour) || hour < 0 || hour > 23) continue;
+      const agentId = String(event?.agentId || 'unattributed');
+      const agentKey = `${provider}:${agentId}`;
+      let agent = agents.get(agentKey);
+      if (!agent) {
+        agent = {
+          key: agentKey,
+          provider,
+          sessionId: agentId === 'unattributed' ? '' : agentId,
+          label: agentLabels.get(agentKey) || event?.agentLabel || usageAgentLabel(provider, agentId),
+          ...emptyTokenBreakdown(),
+        };
+        agents.set(agentKey, agent);
+      }
+      if (!hours[hour].agents[agentKey]) hours[hour].agents[agentKey] = emptyTokenBreakdown();
       addTokenBreakdown(hours[hour], event);
+      addTokenBreakdown(hours[hour].agents[agentKey], event);
       addTokenBreakdown(providers[provider], event);
+      addTokenBreakdown(agent, event);
       addTokenBreakdown(total, event);
     }
   }
@@ -676,6 +724,9 @@ function buildUsageDayDetail(providerEvents, options = {}) {
     total,
     hours,
     providers,
+    agents: Array.from(agents.values()).sort((left, right) => (
+      right.totalTokens - left.totalTokens || left.label.localeCompare(right.label)
+    )),
   };
 }
 
@@ -708,9 +759,11 @@ async function readDailyFileEvents(filePath, provider, minimumMtimeMs = 0) {
     }
   }
 
+  const agentId = usageAgentIdFromFilePath(filePath);
+  const attributedEvents = events.map(event => attributeUsageEvent(event, provider, agentId));
   const truncated = stat.size > JSONL_TAIL_BYTES;
-  dailyFileEventCache.set(cacheKey, { signature, events, truncated });
-  return { events, mtimeMs: stat.mtimeMs, truncated };
+  dailyFileEventCache.set(cacheKey, { signature, events: attributedEvents, truncated });
+  return { events: attributedEvents, mtimeMs: stat.mtimeMs, truncated };
 }
 
 async function collectCodexDailyEventsWithRipgrep(roots, options = {}) {
@@ -764,7 +817,9 @@ async function collectCodexDailyEventsWithRipgrep(roots, options = {}) {
         states.set(filePath, state);
       }
       const event = codexTokenEventFromRecord(record, state);
-      if (event && event.timestamp >= cutoffMs && event.timestamp <= now + 60_000) events.push(event);
+      if (event && event.timestamp >= cutoffMs && event.timestamp <= now + 60_000) {
+        events.push(attributeUsageEvent(event, 'codex', usageAgentIdFromFilePath(filePath)));
+      }
     });
     child.once('close', code => {
       if (unavailable || (code !== 0 && code !== 1)) {
@@ -847,6 +902,7 @@ async function collectOpenCodeDailyEvents(homePaths, options = {}) {
   const sessions = [];
   const seenSessionIds = new Set();
   let successfulHomes = 0;
+  let successfulExports = 0;
   let partial = false;
   let reason = '';
 
@@ -880,6 +936,7 @@ async function collectOpenCodeDailyEvents(homePaths, options = {}) {
       const cacheKey = `${session.openCodeHome}:${session.id}`;
       const cached = openCodeSessionEventCache.get(cacheKey);
       if (cached?.updatedAt === session.updatedAt) {
+        successfulExports += 1;
         events.push(...cached.events);
         continue;
       }
@@ -889,7 +946,9 @@ async function collectOpenCodeDailyEvents(homePaths, options = {}) {
           { openCodeHome: session.openCodeHome, timeoutMs: OPENCODE_COMMAND_TIMEOUT_MS },
         );
         const exported = JSON.parse(String(result?.stdout || '{}'));
-        const sessionEvents = openCodeTokenEventsFromExport(exported, { cutoffMs, now });
+        const sessionEvents = openCodeTokenEventsFromExport(exported, { cutoffMs, now })
+          .map(event => attributeUsageEvent(event, 'opencode', session.id));
+        successfulExports += 1;
         openCodeSessionEventCache.set(cacheKey, { updatedAt: session.updatedAt, events: sessionEvents });
         events.push(...sessionEvents);
       } catch (error) {
@@ -906,9 +965,11 @@ async function collectOpenCodeDailyEvents(homePaths, options = {}) {
   return {
     events,
     partial,
-    available: successfulHomes > 0,
+    available: successfulHomes === homePaths.length
+      && (sessions.length === 0 || successfulExports === sessions.length),
     reason,
     sessionCount: sessions.length,
+    exportCount: successfulExports,
   };
 }
 
@@ -980,6 +1041,8 @@ async function collectUsageHistory(options = {}) {
       available: openCode.available,
       homeCount: openCodeHomes.length,
       sessionCount: openCode.sessionCount,
+      exportCount: openCode.exportCount,
+      partial: openCode.partial,
       source: 'opencode session export',
       ...(openCode.reason ? { reason: openCode.reason } : {}),
     },
@@ -1195,10 +1258,40 @@ class UsageMonitor {
     this.dailyDays = options.dailyDays ?? USAGE_DAILY_DAYS;
     this.dailyCacheMs = options.dailyCacheMs ?? USAGE_DAILY_CACHE_MS;
     this.dailyCache = { value: null, fetchedAt: 0, pending: null };
+    this.liveDayCacheMs = options.liveDayCacheMs ?? USAGE_LIVE_DAY_CACHE_MS;
+    this.liveDayCache = { date: '', value: null, fetchedAt: 0, pending: null };
   }
 
   invalidateDailyCache() {
     this.dailyCache.fetchedAt = 0;
+    this.liveDayCache.fetchedAt = 0;
+  }
+
+  usageAgentLabels() {
+    const labels = new Map();
+    const agents = this.agentManager?.getState?.().agents;
+    if (!Array.isArray(agents)) return labels;
+    for (const agent of agents) {
+      const provider = String(agent?.providerSessionProvider || '').trim();
+      const sessionId = String(agent?.providerSessionId || '').trim();
+      if (!provider || !sessionId) continue;
+      const label = String(
+        agent.customTitle
+        || agent.task
+        || agent.sessionTitle
+        || agent.providerSessionTitle
+        || '',
+      ).trim();
+      if (label) labels.set(`${provider}:${sessionId}`, label);
+    }
+    return labels;
+  }
+
+  buildUsageDay(providerEvents, date) {
+    return buildUsageDayDetail(providerEvents, {
+      date,
+      agentLabels: this.usageAgentLabels(),
+    });
   }
 
   getDailyUsage(options = {}) {
@@ -1232,11 +1325,63 @@ class UsageMonitor {
   }
 
   async getUsageDay(date, options = {}) {
+    const now = options.now ?? Date.now();
+    if (options.live === true && String(date || '').trim() === localDateKey(now)) {
+      const liveDate = String(date).trim();
+      const dailyFallback = this.dailyCache.value?.providerEvents
+        ? this.buildUsageDay(this.dailyCache.value.providerEvents, liveDate)
+        : null;
+      const cachedFallback = this.liveDayCache.date === liveDate
+        ? this.liveDayCache.value
+        : null;
+      const fallback = cachedFallback || dailyFallback;
+      const recoverWithFallback = error => {
+        if (!fallback) throw error;
+        if (this.liveDayCache.date === liveDate) {
+          this.liveDayCache.value = fallback;
+          this.liveDayCache.fetchedAt = now;
+        }
+        return fallback;
+      };
+      if (
+        options.fresh !== true
+        && this.liveDayCache.date === liveDate
+        && this.liveDayCache.value
+        && now - this.liveDayCache.fetchedAt < this.liveDayCacheMs
+      ) {
+        return this.liveDayCache.value;
+      }
+      if (this.liveDayCache.pending && this.liveDayCache.date === liveDate) {
+        return this.liveDayCache.pending.catch(recoverWithFallback);
+      }
+      this.liveDayCache.date = liveDate;
+      const pending = collectUsageHistory({
+        codexHome: this.codexHome,
+        claudeHome: this.claudeHome,
+        openCodeHome: this.openCodeHome,
+        qoderHome: this.qoderHome,
+        providerHomes: this.getProviderHomes ? this.getProviderHomes() : undefined,
+        openCodeCommandRunner: this.openCodeCommandRunner,
+        now,
+        days: 1,
+      }).then(history => {
+        const detail = this.buildUsageDay(history.providerEvents, liveDate);
+        if (this.liveDayCache.date === liveDate) {
+          this.liveDayCache.value = detail;
+          this.liveDayCache.fetchedAt = now;
+        }
+        return detail;
+      }).finally(() => {
+        if (this.liveDayCache.pending === pending) this.liveDayCache.pending = null;
+      });
+      this.liveDayCache.pending = pending;
+      return pending.catch(recoverWithFallback);
+    }
     const history = await this.getDailyUsage({
-      now: options.now,
+      now,
       force: options.fresh === true,
     });
-    return buildUsageDayDetail(history.providerEvents, { date });
+    return this.buildUsageDay(history.providerEvents, date);
   }
 
   async getUsageSummary(options = {}) {
@@ -1267,11 +1412,12 @@ class UsageMonitor {
       historyWindowMs,
       source: 'opencode session export',
     });
-    const timeline = buildUsageTimeline({
-      codex: codexUsage.tokenEvents,
-      claude: claudeUsage.tokenEvents,
-      opencode: openCodeUsage.tokenEvents,
-    }, { now, windowMs: historyWindowMs });
+    const timeline = buildUsageTimeline(history.providerEvents, {
+      now,
+      windowMs: historyWindowMs,
+      alignToBucket: true,
+    });
+    const openCodeCoverage = history.coverage.find(entry => entry.provider === 'opencode');
     const qoderCoverage = history.coverage.find(entry => entry.provider === 'qoder');
 
     return {
@@ -1297,13 +1443,25 @@ class UsageMonitor {
         {
           provider: 'opencode',
           providerName: 'OpenCode',
-          auth: { available: true, status: 'Local session export', source: 'opencode session export' },
+          auth: {
+            available: openCodeCoverage?.available === true,
+            status: openCodeCoverage?.available === true
+              ? 'Local session export'
+              : openCodeCoverage?.reason || 'OpenCode unavailable',
+            source: 'opencode session export',
+          },
           quota: {
             available: false,
             source: 'opencode session export',
             reason: 'OpenCode session exports do not expose quota remaining.',
           },
-          tokenUsage: openCodeUsage.tokenUsage,
+          tokenUsage: openCodeCoverage?.available === true
+            ? openCodeUsage.tokenUsage
+            : {
+                ...openCodeUsage.tokenUsage,
+                available: false,
+                reason: openCodeCoverage?.reason || 'OpenCode token usage is unavailable.',
+              },
         },
         {
           provider: 'qoder',
@@ -1340,6 +1498,7 @@ module.exports = {
   USAGE_TIMELINE_BUCKET_COUNT,
   USAGE_DAILY_DAYS,
   USAGE_DAILY_CACHE_MS,
+  USAGE_LIVE_DAY_CACHE_MS,
   UsageMonitor,
   buildUsageTimeline,
   buildDailyUsage,