farming-code 2.2.16 → 2.2.18

package/backend/provider-session-service.js

@@ -1,12 +1,16 @@
+const fs = require('fs');
 const path = require('path');
 const { findAgentSession } = require('./agent-session-history');
-const { listCodexSessions } = require('./codex-session-history');
-const { isLinkedWorktreeOf } = require('./git-worktree-info');
+const {
+  codexSessionDateKeys,
+  listCodexSessionIdentities,
+} = require('./codex-session-history');
 const { mainPageAgentSessionKey } = require('./main-page-session');
 const { isTemporaryProviderSessionId } = require('./provider-session-id');
 
 const CODEX_RESOLVE_COOLDOWN_MS = 1000;
-const CODEX_MATCH_GRACE_MS = 30 * 1000;
+const CODEX_MATCH_WINDOW_MS = 30 * 1000;
+const CODEX_STARTUP_RETRY_DELAYS_MS = [500, 1000, 2000, 4000, 8000, 12000];
 const TITLE_RESOLVE_COOLDOWN_MS = 30 * 1000;
 
 function normalizePath(value) {
@@ -16,6 +20,16 @@ function normalizePath(value) {
   return trimmed.replace(/[\\/]+$/, '');
 }
 
+function canonicalPath(value) {
+  const normalized = normalizePath(value);
+  if (!normalized) return '';
+  try {
+    return normalizePath(fs.realpathSync.native(normalized));
+  } catch {
+    return normalized;
+  }
+}
+
 function timestampMs(value) {
   const parsed = Date.parse(value || '');
   return Number.isFinite(parsed) ? parsed : 0;
@@ -26,10 +40,14 @@ class ProviderSessionService {
     this.agents = options.agents || new Map();
     this.getProviderHomes = options.getProviderHomes || (() => undefined);
     this.commit = options.commit || (() => {});
-    this.listCodexSessions = options.listCodexSessions || listCodexSessions;
+    this.listCodexSessionIdentities = options.listCodexSessionIdentities || listCodexSessionIdentities;
     this.findAgentSession = options.findAgentSession || findAgentSession;
-    this.isLinkedWorktreeOf = options.isLinkedWorktreeOf || isLinkedWorktreeOf;
+    this.codexStartupRetryDelaysMs = Array.isArray(options.codexStartupRetryDelaysMs)
+      ? options.codexStartupRetryDelaysMs
+      : CODEX_STARTUP_RETRY_DELAYS_MS;
     this.resolutions = new Map();
+    this.codexIdentityScans = new Map();
+    this.codexStartupRetries = new Map();
   }
 
   activate(agentId) {
@@ -38,6 +56,7 @@ class ProviderSessionService {
 
     if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
       this.observe(agentId, { force: true });
+      this.scheduleTemporaryCodexStartupRetry(agentId);
       return;
     }
 
@@ -54,10 +73,71 @@ class ProviderSessionService {
   stop(agentId) {
     this.resolutions.delete(`codex:${agentId}`);
     this.resolutions.delete(`title:${agentId}`);
+    const startupRetry = this.codexStartupRetries.get(agentId);
+    if (startupRetry?.timer) clearTimeout(startupRetry.timer);
+    this.codexStartupRetries.delete(agentId);
   }
 
   dispose() {
+    for (const startupRetry of this.codexStartupRetries.values()) {
+      if (startupRetry?.timer) clearTimeout(startupRetry.timer);
+    }
     this.resolutions.clear();
+    this.codexIdentityScans.clear();
+    this.codexStartupRetries.clear();
+  }
+
+  scheduleTemporaryCodexStartupRetry(agentId) {
+    if (this.codexStartupRetries.has(agentId)) return;
+    const agent = this.agents.get(agentId);
+    const retry = {
+      attempt: 0,
+      timer: null,
+      deadlineAt: (Number(agent?.startedAt) || Date.now()) + CODEX_MATCH_WINDOW_MS,
+    };
+    this.codexStartupRetries.set(agentId, retry);
+
+    const scheduleNext = () => {
+      if (this.codexStartupRetries.get(agentId) !== retry) return;
+      const agent = this.agents.get(agentId);
+      if (
+        !agent
+        || agent.providerSessionProvider !== 'codex'
+        || agent.providerSessionTemporary !== true
+      ) {
+        this.stop(agentId);
+        return;
+      }
+      const delayMs = Number(this.codexStartupRetryDelaysMs[retry.attempt]);
+      if (!Number.isFinite(delayMs) || delayMs < 0) {
+        this.codexStartupRetries.delete(agentId);
+        return;
+      }
+      if (Date.now() + delayMs > retry.deadlineAt) {
+        this.codexStartupRetries.delete(agentId);
+        return;
+      }
+      retry.attempt += 1;
+      retry.timer = setTimeout(async () => {
+        retry.timer = null;
+        if (
+          this.codexStartupRetries.get(agentId) !== retry
+          || Date.now() > retry.deadlineAt
+        ) {
+          if (this.codexStartupRetries.get(agentId) === retry) {
+            this.codexStartupRetries.delete(agentId);
+          }
+          return;
+        }
+        const resolved = await this.resolveTemporaryCodex(agentId, { force: true });
+        if (this.codexStartupRetries.get(agentId) !== retry) return;
+        if (resolved) return;
+        scheduleNext();
+      }, delayMs);
+      retry.timer.unref?.();
+    };
+
+    scheduleNext();
   }
 
   bindConfirmed(agentId, provider, sessionId) {
@@ -97,6 +177,14 @@ class ProviderSessionService {
       this.resolutions.delete(`codex:${agentId}`);
       return Promise.resolve(false);
     }
+    const startedAt = Number(agent.startedAt) || 0;
+    if (
+      options.force !== true
+      && startedAt
+      && Date.now() > startedAt + CODEX_MATCH_WINDOW_MS
+    ) {
+      return Promise.resolve(false);
+    }
 
     return this.runResolution(
       'codex',
@@ -167,15 +255,30 @@ class ProviderSessionService {
   }
 
   async findTemporaryCodexSession(agent) {
-    const sessions = await this.listCodexSessions({
-      codexHome: agent.providerHomePath || undefined,
-      limit: 100,
-      scanLimit: 1000,
-    });
+    const startedAt = Number(agent.startedAt) || 0;
+    const codexHome = agent.providerHomePath || '';
+    const scanKey = [
+      codexHome,
+      ...codexSessionDateKeys(startedAt, CODEX_MATCH_WINDOW_MS),
+    ].join('\0');
+    let scan = this.codexIdentityScans.get(scanKey);
+    if (!scan) {
+      scan = Promise.resolve(this.listCodexSessionIdentities({
+        codexHome: codexHome || undefined,
+        startedAt,
+        windowMs: CODEX_MATCH_WINDOW_MS,
+      })).finally(() => {
+        if (this.codexIdentityScans.get(scanKey) === scan) {
+          this.codexIdentityScans.delete(scanKey);
+        }
+      });
+      this.codexIdentityScans.set(scanKey, scan);
+    }
+    const sessions = await scan;
     const workspace = normalizePath(
-      agent?.gitWorktree?.workspace || agent?.projectWorkspace || agent?.cwd || ''
+      agent?.projectWorkspace || agent?.cwd || agent?.gitWorktree?.workspace || ''
     );
-    const startedAt = Number(agent.startedAt) || 0;
+    if (!workspace) return null;
     const homeId = String(agent.providerHomeId || 'default').trim() || 'default';
     const claimedSessionIds = new Set([...this.agents.values()]
       .filter(candidate => candidate?.id !== agent.id
@@ -189,35 +292,36 @@ class ProviderSessionService {
         if (!session?.id || claimedSessionIds.has(session.id)) return false;
         const sessionWorkspace = normalizePath(session.workspace || session.cwd);
         if (workspace && !sessionWorkspace) return false;
-        const sessionTime = timestampMs(session.createdAt || session.updatedAt);
-        if (!sessionTime || !startedAt) return true;
-        return sessionTime >= startedAt - CODEX_MATCH_GRACE_MS;
-      })
-      .sort((a, b) => {
-        const aTime = timestampMs(a.createdAt || a.updatedAt);
-        const bTime = timestampMs(b.createdAt || b.updatedAt);
-        const aDistance = startedAt && aTime ? Math.abs(aTime - startedAt) : Number.MAX_SAFE_INTEGER;
-        const bDistance = startedAt && bTime ? Math.abs(bTime - startedAt) : Number.MAX_SAFE_INTEGER;
-        if (aDistance !== bDistance) return aDistance - bDistance;
-        return bTime - aTime;
+        const sessionTime = timestampMs(session.createdAt);
+        if (!sessionTime || !startedAt) return false;
+        return Math.abs(sessionTime - startedAt) <= CODEX_MATCH_WINDOW_MS;
       });
 
-    const exact = candidates.find(session => (
-      !workspace || workspace === normalizePath(session.workspace || session.cwd)
+    const exact = candidates.filter(session => (
+      workspace === normalizePath(session.workspace || session.cwd)
     ));
-    if (exact) return exact;
-    if (!workspace) return candidates[0] || null;
-
-    for (const session of candidates.slice(0, 12)) {
-      const sessionWorkspace = normalizePath(session.workspace || session.cwd);
-      if (!sessionWorkspace) continue;
-      if (await this.isLinkedWorktreeOf(workspace, sessionWorkspace)) return session;
-    }
+    if (exact.length === 1) return exact[0];
+    if (exact.length > 1) return null;
+    const canonicalWorkspace = canonicalPath(workspace);
+    const canonical = candidates.filter(session => (
+      canonicalWorkspace === canonicalPath(session.workspace || session.cwd)
+    ));
+    if (canonical.length === 1) return canonical[0];
     return null;
   }
 
   confirm(agentId, { provider, sessionId, source, title, workspace }) {
-    const previousSessionId = this.agents.get(agentId)?.providerSessionId || '';
+    const current = this.agents.get(agentId);
+    const homeId = String(current?.providerHomeId || 'default').trim() || 'default';
+    const claimedByAnotherAgent = [...this.agents.values()].some(candidate => (
+      candidate?.id !== agentId
+      && candidate?.providerSessionProvider === provider
+      && candidate?.providerSessionId === sessionId
+      && candidate?.providerSessionTemporary !== true
+      && (String(candidate.providerHomeId || 'default').trim() || 'default') === homeId
+    ));
+    if (claimedByAnotherAgent) return false;
+    const previousSessionId = current?.providerSessionId || '';
     const agent = this.bindConfirmed(agentId, provider, sessionId);
     if (!agent) return false;
     const providerSessionTitle = String(title || '').trim().slice(0, 160);

package/backend/server.js

@@ -122,7 +122,11 @@ const updateService = new FarmingUpdateService({
   packagedRuntime: Boolean(process.pkg || process.env.FARMING_PACKAGED_RUNTIME === '1'),
   getUpdateUrl: () => configManager.getSettings().updateUrl || '',
 });
-const usageMonitor = new UsageMonitor({ agentManager, getProviderHomes: configuredProviderHomes });
+const usageMonitor = new UsageMonitor({
+  agentManager,
+  configDir: configManager.farmingDir,
+  getProviderHomes: configuredProviderHomes,
+});
 const codexContextWindowReader = new CodexContextWindowReader();
 const usageSummaryCache = new AsyncCache(() => usageMonitor.getUsageSummary(), {
   ttlMs: 15_000,

package/backend/storage-layout.js

@@ -41,6 +41,10 @@ function reviewSessionsFile(configDir) {
   return path.join(historyDir(configDir), 'review-sessions.json');
 }
 
+function usageHistoryCacheFile(configDir) {
+  return path.join(historyDir(configDir), 'usage-history-v2.sqlite3');
+}
+
 function sessionIndexFile(configDir) {
   return path.join(sessionsDir(configDir), 'index.json');
 }
@@ -137,4 +141,5 @@ module.exports = {
   themeSettingsFile,
   updateLogFile,
   updateStateFile,
+  usageHistoryCacheFile,
 };

package/backend/usage-history-client.js

@@ -0,0 +1,305 @@
+const path = require('path');
+const fs = require('fs');
+const { Worker } = require('worker_threads');
+const { usageHistoryCacheFile } = require('./storage-layout');
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_RETENTION_DAYS = 52 * 7;
+const DEFAULT_RECENT_RAW_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_SCAN_BUDGET_MS = 5_000;
+const BACKGROUND_SCAN_DELAY_MS = 100;
+const RESULT_REUSE_MS = 2_000;
+const SOURCE_WORKER_FILE = 'usage-history-worker.js';
+const PACKAGED_WORKER_FILE = 'usage-history-worker.pkg.js';
+let sharedWorkerSession = null;
+let nextWorkerRequestId = 1;
+
+function resolveWorkerFile() {
+  if (!process.pkg && process.env.FARMING_PACKAGED_RUNTIME !== '1') {
+    return SOURCE_WORKER_FILE;
+  }
+  const packaged = path.join(__dirname, PACKAGED_WORKER_FILE);
+  return fs.existsSync(packaged) ? PACKAGED_WORKER_FILE : SOURCE_WORKER_FILE;
+}
+
+function runUsageWorker(request, options = {}) {
+  if (options.WorkerClass) {
+    return runOneShotUsageWorker(request, options);
+  }
+  const workerFile = path.join(__dirname, resolveWorkerFile());
+  if (!sharedWorkerSession || sharedWorkerSession.workerFile !== workerFile) {
+    sharedWorkerSession?.terminate();
+    sharedWorkerSession = createSharedWorkerSession(workerFile, options.WorkerClass || Worker);
+  }
+  return sharedWorkerSession.run(request, options.timeoutMs || DEFAULT_TIMEOUT_MS);
+}
+
+function runOneShotUsageWorker(request, options = {}) {
+  return new Promise((resolve, reject) => {
+    const worker = new (options.WorkerClass || Worker)(
+      path.join(__dirname, resolveWorkerFile()),
+      { workerData: { request } },
+    );
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      worker.terminate().catch(() => {});
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const timeout = setTimeout(() => {
+      const error = new Error(
+        `TypeScript usage scanner exceeded ${options.timeoutMs || DEFAULT_TIMEOUT_MS}ms`,
+      );
+      error.code = 'ETIMEDOUT';
+      finish(error);
+    }, options.timeoutMs || DEFAULT_TIMEOUT_MS);
+    timeout.unref?.();
+    worker.once('error', finish);
+    worker.once('exit', (code) => {
+      if (!settled) {
+        const error = new Error(
+          code === 0
+            ? 'TypeScript usage scanner exited without returning a result'
+            : `TypeScript usage scanner exited with code ${code}`,
+        );
+        error.code = 'EUSAGEWORKER';
+        finish(error);
+      }
+    });
+    worker.once('message', (message) => {
+      if (message?.error) {
+        const error = new Error(message.error.message || 'Usage scanner failed');
+        error.code = message.error.code || 'EUSAGE';
+        error.stack = message.error.stack || error.stack;
+        finish(error);
+        return;
+      }
+      finish(null, message?.result);
+    });
+  });
+}
+
+function createSharedWorkerSession(workerFile, WorkerClass) {
+  const worker = new WorkerClass(workerFile);
+  const pending = new Map();
+  const failAll = (error) => {
+    for (const request of pending.values()) {
+      clearTimeout(request.timeout);
+      request.reject(error);
+    }
+    pending.clear();
+    if (sharedWorkerSession?.worker === worker) sharedWorkerSession = null;
+  };
+  worker.on('message', (message) => {
+    const request = pending.get(message?.requestId);
+    if (!request) return;
+    pending.delete(message.requestId);
+    clearTimeout(request.timeout);
+    if (message?.error) {
+      const error = new Error(message.error.message || 'Usage scanner failed');
+      error.code = message.error.code || 'EUSAGE';
+      error.stack = message.error.stack || error.stack;
+      request.reject(error);
+    } else {
+      request.resolve(message?.result);
+    }
+    if (pending.size === 0) worker.unref?.();
+  });
+  worker.once('error', failAll);
+  worker.once('exit', (code) => {
+    if (pending.size > 0) {
+      const error = new Error(
+        code === 0
+          ? 'TypeScript usage scanner exited before returning all results'
+          : `TypeScript usage scanner exited with code ${code}`,
+      );
+      error.code = 'EUSAGEWORKER';
+      failAll(error);
+    } else if (sharedWorkerSession?.worker === worker) {
+      sharedWorkerSession = null;
+    }
+  });
+  worker.unref?.();
+  return {
+    worker,
+    workerFile,
+    run(request, timeoutMs) {
+      return new Promise((resolve, reject) => {
+        const requestId = nextWorkerRequestId++;
+        const timeout = setTimeout(() => {
+          if (!pending.delete(requestId)) return;
+          const error = new Error(`TypeScript usage scanner exceeded ${timeoutMs}ms`);
+          error.code = 'ETIMEDOUT';
+          reject(error);
+          worker.terminate().catch(() => {});
+          if (sharedWorkerSession?.worker === worker) sharedWorkerSession = null;
+        }, timeoutMs);
+        timeout.unref?.();
+        pending.set(requestId, { resolve, reject, timeout });
+        worker.ref?.();
+        worker.postMessage({ requestId, request });
+      });
+    },
+    terminate() {
+      const error = new Error('Usage scanner worker was replaced');
+      error.code = 'EUSAGEWORKER';
+      failAll(error);
+      worker.terminate().catch(() => {});
+    },
+  };
+}
+
+class UsageHistoryClient {
+  constructor(options = {}) {
+    this.configDir = options.configDir;
+    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    this.runner = options.runner || runUsageWorker;
+    this.pending = null;
+    this.pendingKey = '';
+    this.cached = null;
+    this.cachedAt = 0;
+    this.cacheKey = '';
+    this.backgroundTimer = null;
+    this.backgroundGeneration = 0;
+    this.backgroundDelayMs = options.backgroundDelayMs || BACKGROUND_SCAN_DELAY_MS;
+    this.backgroundErrorDelayMs = options.backgroundErrorDelayMs || 5_000;
+    this.backgroundErrorRetries = 0;
+    this.backgroundStalls = 0;
+    this.backgroundProgressSignature = '';
+  }
+
+  invoke(request) {
+    return this.runner(request, { timeoutMs: this.timeoutMs });
+  }
+
+  storeResult(result, cacheKey) {
+    if (cacheKey !== this.cacheKey) return;
+    this.cached = result;
+    this.cachedAt = Number.isFinite(result?.sampledAt)
+      ? result.sampledAt
+      : Date.now();
+  }
+
+  scheduleBackgroundScan(request, cacheKey, result) {
+    if (result?.cache?.scan_complete !== false || cacheKey !== this.cacheKey) {
+      this.backgroundErrorRetries = 0;
+      this.backgroundStalls = 0;
+      this.backgroundProgressSignature = '';
+      return;
+    }
+    if (this.backgroundTimer) return;
+    const hasErrors = Number(result?.cache?.errors) > 0;
+    this.backgroundErrorRetries = hasErrors ? this.backgroundErrorRetries + 1 : 0;
+    const progressSignature = [
+      result?.cache?.pending_directories,
+      result?.cache?.pending_files,
+      result?.cache?.discovered_files,
+      result?.cache?.committed_bytes,
+    ].join(':');
+    if (Number(result?.cache?.enumerated_entries) > 0) {
+      this.backgroundProgressSignature = progressSignature;
+      this.backgroundStalls = 0;
+    } else if (progressSignature === this.backgroundProgressSignature) {
+      this.backgroundStalls += 1;
+    } else {
+      this.backgroundProgressSignature = progressSignature;
+      this.backgroundStalls = 0;
+    }
+    if (this.backgroundErrorRetries >= 3 || this.backgroundStalls >= 3) return;
+    const generation = this.backgroundGeneration;
+    const retryDelayMs = hasErrors
+      ? this.backgroundErrorDelayMs
+      : this.backgroundDelayMs;
+    this.backgroundTimer = setTimeout(() => {
+      this.backgroundTimer = null;
+      if (generation !== this.backgroundGeneration || cacheKey !== this.cacheKey) return;
+      const backgroundRequest = { ...request, nowMs: Date.now() };
+      const pending = this.invoke(backgroundRequest).then((nextResult) => {
+        this.storeResult(nextResult, cacheKey);
+        this.scheduleBackgroundScan(backgroundRequest, cacheKey, nextResult);
+        return nextResult;
+      }).catch(() => {
+        // Keep the last usable snapshot. A later normal request retries.
+      }).finally(() => {
+        if (this.pending === pending) {
+          this.pending = null;
+          this.pendingKey = '';
+        }
+      });
+      this.pending = pending;
+      this.pendingKey = cacheKey;
+    }, retryDelayMs);
+    this.backgroundTimer.unref?.();
+  }
+
+  collect(options = {}) {
+    const now = options.now ?? Date.now();
+    const retentionDays = options.retentionDays ?? DEFAULT_RETENTION_DAYS;
+    const roots = {
+      codex: Array.from(new Set(options.codexRoots || [])).sort(),
+      claude: Array.from(new Set(options.claudeRoots || [])).sort(),
+    };
+    const recentRawMs = options.recentRawMs ?? DEFAULT_RECENT_RAW_MS;
+    const cacheKey = JSON.stringify({ roots, retentionDays, recentRawMs });
+    if (this.cacheKey && this.cacheKey !== cacheKey) {
+      this.backgroundGeneration += 1;
+      if (this.backgroundTimer) clearTimeout(this.backgroundTimer);
+      this.backgroundTimer = null;
+      this.backgroundErrorRetries = 0;
+      this.backgroundStalls = 0;
+      this.backgroundProgressSignature = '';
+    }
+    if (
+      options.fresh !== true
+      && this.cached
+      && this.cacheKey === cacheKey
+      && (
+        now - this.cachedAt <= RESULT_REUSE_MS
+        || this.backgroundTimer
+        || (this.pending && this.pendingKey === cacheKey)
+      )
+    ) {
+      return Promise.resolve(this.cached);
+    }
+    if (this.pending && this.pendingKey === cacheKey) return this.pending;
+    if (this.pending) return this.pending.then(() => this.collect(options));
+    this.cacheKey = cacheKey;
+    this.backgroundErrorRetries = 0;
+    this.backgroundStalls = 0;
+    this.backgroundProgressSignature = '';
+    const request = {
+      cacheFile: usageHistoryCacheFile(this.configDir),
+      legacyCacheFile: options.legacyCacheFile,
+      nowMs: now,
+      retentionDays,
+      recentRawMs,
+      scanBudgetMs: options.scanBudgetMs ?? DEFAULT_SCAN_BUDGET_MS,
+      roots,
+    };
+    const pending = this.invoke(request).then((result) => {
+      this.storeResult(result, cacheKey);
+      this.scheduleBackgroundScan(request, cacheKey, result);
+      return result;
+    }).finally(() => {
+      if (this.pending === pending) {
+        this.pending = null;
+        this.pendingKey = '';
+      }
+    });
+    this.pending = pending;
+    this.pendingKey = cacheKey;
+    return pending;
+  }
+}
+
+module.exports = {
+  UsageHistoryClient,
+  DEFAULT_RECENT_RAW_MS,
+  DEFAULT_RETENTION_DAYS,
+  DEFAULT_SCAN_BUDGET_MS,
+  resolveWorkerFile,
+  runUsageWorker,
+};