farming-code 2.2.11 → 2.2.13

package/backend/usage-monitor.js

@@ -9,8 +9,8 @@ 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;
@@ -152,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)) {
@@ -268,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) => ({
@@ -652,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] || []) {
@@ -664,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);
     }
   }
@@ -677,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)
+    )),
   };
 }
 
@@ -709,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 = {}) {
@@ -765,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)) {
@@ -892,7 +946,8 @@ 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);
@@ -1212,6 +1267,33 @@ class UsageMonitor {
     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 = {}) {
     const now = options.now ?? Date.now();
     if (
@@ -1247,7 +1329,7 @@ class UsageMonitor {
     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 })
+        ? this.buildUsageDay(this.dailyCache.value.providerEvents, liveDate)
         : null;
       const cachedFallback = this.liveDayCache.date === liveDate
         ? this.liveDayCache.value
@@ -1283,7 +1365,7 @@ class UsageMonitor {
         now,
         days: 1,
       }).then(history => {
-        const detail = buildUsageDayDetail(history.providerEvents, { date: liveDate });
+        const detail = this.buildUsageDay(history.providerEvents, liveDate);
         if (this.liveDayCache.date === liveDate) {
           this.liveDayCache.value = detail;
           this.liveDayCache.fetchedAt = now;
@@ -1299,7 +1381,7 @@ class UsageMonitor {
       now,
       force: options.fresh === true,
     });
-    return buildUsageDayDetail(history.providerEvents, { date });
+    return this.buildUsageDay(history.providerEvents, date);
   }
 
   async getUsageSummary(options = {}) {
@@ -1330,11 +1412,11 @@ 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');
 

package/backend/workspace-directory.js

@@ -5,6 +5,7 @@ const path = require('path');
 
 const CREATE_FORBIDDEN_CODES = new Set(['EACCES', 'EPERM', 'EROFS']);
 const INVALID_PATH_CODES = new Set(['EINVAL', 'ENAMETOOLONG']);
+const DEFAULT_BROWSE_LIMIT = 500;
 
 function resolveWorkspaceDirectory(value, homeDir = process.env.HOME || os.homedir()) {
   const input = typeof value === 'string' ? value.trim() : '';
@@ -131,9 +132,87 @@ async function prepareWorkspaceDirectory(value, options = {}) {
   }
 }
 
+async function browseWorkspaceDirectory(value, options = {}) {
+  const workspace = resolveWorkspaceDirectory(value || '~', options.homeDir);
+  const fileSystem = options.fileSystem || fs.promises;
+  let entries;
+  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}`,
+        },
+      };
+    }
+    entries = await fileSystem.readdir(workspace, { withFileTypes: true });
+  } catch (error) {
+    const forbidden = CREATE_FORBIDDEN_CODES.has(error?.code);
+    const missing = error?.code === 'ENOENT';
+    return {
+      status: forbidden ? 403 : missing ? 404 : 500,
+      body: {
+        status: 'rejected',
+        code: forbidden
+          ? 'workspace-browse-forbidden'
+          : missing
+            ? 'workspace-not-found'
+            : 'workspace-browse-failed',
+        workspace,
+        message: forbidden
+          ? `Farming does not have permission to read this directory: ${workspace}`
+          : missing
+            ? `Workspace directory does not exist: ${workspace}`
+            : `Failed to read workspace directory: ${workspace}`,
+      },
+    };
+  }
+
+  const directories = (await Promise.all(entries.map(async (entry) => {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) return null;
+    const childPath = path.join(workspace, entry.name);
+    if (entry.isSymbolicLink()) {
+      try {
+        const stat = await fileSystem.stat(childPath);
+        if (!stat.isDirectory()) return null;
+      } catch {
+        return null;
+      }
+    }
+    return { name: entry.name, path: childPath };
+  })))
+    .filter(Boolean)
+    .sort((left, right) => left.name.localeCompare(right.name));
+  const limit = Math.max(1, Math.min(Number(options.limit) || DEFAULT_BROWSE_LIMIT, DEFAULT_BROWSE_LIMIT));
+  const parentPath = path.dirname(workspace);
+
+  return {
+    status: 200,
+    body: {
+      status: 'ready',
+      workspace,
+      parent: parentPath === workspace ? null : parentPath,
+      directories: directories.slice(0, limit),
+      truncated: directories.length > limit,
+    },
+  };
+}
+
 function createWorkspaceDirectoryRouter(options = {}) {
   const router = express.Router();
   router.use(express.json({ limit: '8kb' }));
+  router.get('/browse', async (req, res) => {
+    const result = await browseWorkspaceDirectory(req.query?.path, {
+      fileSystem: options.fileSystem,
+      homeDir: options.homeDir,
+      limit: req.query?.limit,
+    });
+    res.status(result.status).json(result.body);
+  });
   router.post('/prepare', async (req, res) => {
     const result = await prepareWorkspaceDirectory(req.body?.workspace, {
       create: req.body?.create === true,
@@ -146,6 +225,7 @@ function createWorkspaceDirectoryRouter(options = {}) {
 }
 
 module.exports = {
+  browseWorkspaceDirectory,
   createWorkspaceDirectoryRouter,
   prepareWorkspaceDirectory,
   resolveWorkspaceDirectory,