farming-code 2.2.7 → 2.2.11

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

@@ -13,6 +13,7 @@ const USAGE_TIMELINE_WINDOW_MS = 60 * 60 * 1000;
 const USAGE_TIMELINE_BUCKET_COUNT = 30;
 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;
@@ -847,6 +848,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 +882,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;
       }
@@ -890,6 +893,7 @@ async function collectOpenCodeDailyEvents(homePaths, options = {}) {
         );
         const exported = JSON.parse(String(result?.stdout || '{}'));
         const sessionEvents = openCodeTokenEventsFromExport(exported, { cutoffMs, now });
+        successfulExports += 1;
         openCodeSessionEventCache.set(cacheKey, { updatedAt: session.updatedAt, events: sessionEvents });
         events.push(...sessionEvents);
       } catch (error) {
@@ -906,9 +910,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 +986,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 +1203,13 @@ 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;
   }
 
   getDailyUsage(options = {}) {
@@ -1232,8 +1243,60 @@ 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
+        ? buildUsageDayDetail(this.dailyCache.value.providerEvents, { date: 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 = buildUsageDayDetail(history.providerEvents, { date: 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 });
@@ -1272,6 +1335,7 @@ class UsageMonitor {
       claude: claudeUsage.tokenEvents,
       opencode: openCodeUsage.tokenEvents,
     }, { now, windowMs: historyWindowMs });
+    const openCodeCoverage = history.coverage.find(entry => entry.provider === 'opencode');
     const qoderCoverage = history.coverage.find(entry => entry.provider === 'qoder');
 
     return {
@@ -1297,13 +1361,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 +1416,7 @@ module.exports = {
   USAGE_TIMELINE_BUCKET_COUNT,
   USAGE_DAILY_DAYS,
   USAGE_DAILY_CACHE_MS,
+  USAGE_LIVE_DAY_CACHE_MS,
   UsageMonitor,
   buildUsageTimeline,
   buildDailyUsage,

package/backend/workspace-directory.js

@@ -0,0 +1,152 @@
+const express = require('express');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CREATE_FORBIDDEN_CODES = new Set(['EACCES', 'EPERM', 'EROFS']);
+const INVALID_PATH_CODES = new Set(['EINVAL', 'ENAMETOOLONG']);
+
+function resolveWorkspaceDirectory(value, homeDir = process.env.HOME || os.homedir()) {
+  const input = typeof value === 'string' ? value.trim() : '';
+  if (!input) return '';
+  const expanded = input === '~'
+    ? homeDir
+    : input.startsWith('~/')
+      ? path.join(homeDir, input.slice(2))
+      : input;
+  return path.resolve(expanded);
+}
+
+function workspaceDirectoryError(error, workspace) {
+  const code = error?.code || '';
+  if (CREATE_FORBIDDEN_CODES.has(code)) {
+    return {
+      status: 403,
+      body: {
+        status: 'rejected',
+        code: 'workspace-create-forbidden',
+        workspace,
+        message: `Farming does not have permission to create this directory: ${workspace}`,
+      },
+    };
+  }
+  if (code === 'ENOTDIR') {
+    return {
+      status: 409,
+      body: {
+        status: 'rejected',
+        code: 'workspace-parent-not-directory',
+        workspace,
+        message: `A parent path is not a directory: ${workspace}`,
+      },
+    };
+  }
+  if (code === 'EEXIST') {
+    return {
+      status: 409,
+      body: {
+        status: 'rejected',
+        code: 'workspace-not-directory',
+        workspace,
+        message: `Workspace path is not a directory: ${workspace}`,
+      },
+    };
+  }
+  if (INVALID_PATH_CODES.has(code)) {
+    return {
+      status: 400,
+      body: {
+        status: 'rejected',
+        code: 'workspace-invalid-path',
+        workspace,
+        message: 'Workspace path is invalid',
+      },
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      status: 'rejected',
+      code: 'workspace-create-failed',
+      workspace,
+      message: `Failed to create workspace directory: ${workspace}`,
+    },
+  };
+}
+
+async function prepareWorkspaceDirectory(value, options = {}) {
+  const workspace = resolveWorkspaceDirectory(value, options.homeDir);
+  if (!workspace) {
+    return {
+      status: 400,
+      body: {
+        status: 'rejected',
+        code: 'workspace-path-required',
+        workspace: '',
+        message: 'Workspace path is required',
+      },
+    };
+  }
+
+  const fileSystem = options.fileSystem || fs.promises;
+  try {
+    const stat = await fileSystem.stat(workspace);
+    if (!stat.isDirectory()) {
+      return {
+        status: 409,
+        body: {
+          status: 'rejected',
+          code: 'workspace-not-directory',
+          workspace,
+          message: `Workspace path is not a directory: ${workspace}`,
+        },
+      };
+    }
+    return { status: 200, body: { status: 'ready', workspace } };
+  } catch (error) {
+    if (error?.code !== 'ENOENT') return workspaceDirectoryError(error, workspace);
+  }
+
+  if (options.create !== true) {
+    return {
+      status: 409,
+      body: {
+        status: 'missing',
+        code: 'workspace-not-found',
+        workspace,
+        message: `Workspace directory does not exist: ${workspace}`,
+      },
+    };
+  }
+
+  try {
+    await fileSystem.mkdir(workspace, { recursive: true });
+    const stat = await fileSystem.stat(workspace);
+    if (!stat.isDirectory()) {
+      return workspaceDirectoryError({ code: 'EEXIST' }, workspace);
+    }
+    return { status: 201, body: { status: 'created', workspace } };
+  } catch (error) {
+    return workspaceDirectoryError(error, workspace);
+  }
+}
+
+function createWorkspaceDirectoryRouter(options = {}) {
+  const router = express.Router();
+  router.use(express.json({ limit: '8kb' }));
+  router.post('/prepare', async (req, res) => {
+    const result = await prepareWorkspaceDirectory(req.body?.workspace, {
+      create: req.body?.create === true,
+      fileSystem: options.fileSystem,
+      homeDir: options.homeDir,
+    });
+    res.status(result.status).json(result.body);
+  });
+  return router;
+}
+
+module.exports = {
+  createWorkspaceDirectoryRouter,
+  prepareWorkspaceDirectory,
+  resolveWorkspaceDirectory,
+};