claude-usage-dashboard 1.3.14 → 1.4.0

package/server/routes/api.js

@@ -1,127 +1,130 @@
-import { Router } from 'express';
-import { parseLogDirectory } from '../parser.js';
-import { filterByDateRange, autoGranularity, aggregateByTime, aggregateBySession, aggregateByProject, aggregateByModel, aggregateCache } from '../aggregator.js';
-import { calculateRecordCost, PLAN_DEFAULTS } from '../pricing.js';
-import { createQuotaFetcher } from '../quota.js';
-import { getSubscriptionInfo } from '../credentials.js';
-
-export function createApiRouter(logBaseDir, options = {}) {
-  const router = Router();
-  const CACHE_TTL_MS = options.cacheTtlMs || 5000;
-  let cachedRecords = [];
-  let lastRefreshed = null;
-
-  function refreshRecords() {
-    const now = Date.now();
-    if (lastRefreshed && (now - lastRefreshed) < CACHE_TTL_MS) return cachedRecords;
-    try {
-      cachedRecords = parseLogDirectory(logBaseDir);
-      lastRefreshed = now;
-      console.log(`Parsed ${cachedRecords.length} records from ${logBaseDir}`);
-    } catch (err) {
-      console.error('Failed to parse log directory:', err.message);
-      // Keep stale data on failure
-      if (!lastRefreshed) lastRefreshed = now;
-    }
-    return cachedRecords;
-  }
-
-  // Initial parse
-  refreshRecords();
-
-  function applyFilters(query) {
-    let records = filterByDateRange(refreshRecords(), query.from, query.to);
-    if (query.project) records = records.filter(r => r.project === query.project);
-    if (query.model) records = records.filter(r => r.model === query.model);
-    return records;
-  }
-
-  router.get('/usage', (req, res) => {
-    try {
-      const records = applyFilters(req.query);
-      const granularity = req.query.granularity || autoGranularity(req.query.from, req.query.to);
-      const buckets = aggregateByTime(records, granularity);
-      const total = { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_creation_tokens: 0, estimated_api_cost_usd: 0 };
-      for (const r of records) {
-        total.input_tokens += r.input_tokens; total.output_tokens += r.output_tokens;
-        total.cache_read_tokens += r.cache_read_tokens; total.cache_creation_tokens += r.cache_creation_tokens;
-        total.estimated_api_cost_usd += calculateRecordCost(r);
-      }
-      total.estimated_api_cost_usd = Math.round(total.estimated_api_cost_usd * 100) / 100;
-      res.json({ granularity, buckets, total });
-    } catch (err) {
-      res.status(500).json({ error: err.message, code: 'PARSE_ERROR' });
-    }
-  });
-
-  router.get('/models', (req, res) => { res.json({ models: aggregateByModel(applyFilters(req.query)) }); });
-  router.get('/projects', (req, res) => { res.json({ projects: aggregateByProject(applyFilters(req.query)) }); });
-
-  router.get('/sessions', (req, res) => {
-    const records = applyFilters(req.query);
-    let sessions = aggregateBySession(records);
-    const sort = req.query.sort || 'date';
-    const order = req.query.order || 'desc';
-    const sortFn = { date: (a, b) => new Date(b.startTime) - new Date(a.startTime), cost: (a, b) => b.estimated_cost_usd - a.estimated_cost_usd, tokens: (a, b) => b.total_tokens - a.total_tokens }[sort] || ((a, b) => new Date(b.startTime) - new Date(a.startTime));
-    sessions.sort(sortFn);
-    if (order === 'asc') sessions.reverse();
-    const totalTokens = sessions.reduce((sum, s) => sum + s.total_tokens, 0);
-    const totalCost = sessions.reduce((sum, s) => sum + s.estimated_cost_usd, 0);
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || 20;
-    const totalSessions = sessions.length;
-    const totalPages = Math.ceil(totalSessions / limit);
-    sessions = sessions.slice((page - 1) * limit, page * limit);
-    res.json({ sessions, pagination: { page, limit, total_sessions: totalSessions, total_pages: totalPages }, totals: { total_tokens: totalTokens, estimated_cost_usd: Math.round(totalCost * 100) / 100 } });
-  });
-
-  router.get('/cost', (req, res) => {
-    const records = applyFilters(req.query);
-    const plan = req.query.plan || 'max5x';
-    const customPrice = req.query.customPrice ? parseFloat(req.query.customPrice) : null;
-    const subscriptionCost = customPrice || PLAN_DEFAULTS[plan] || 100;
-    let apiCost = 0;
-    for (const r of records) apiCost += calculateRecordCost(r);
-    apiCost = Math.round(apiCost * 100) / 100;
-    const dayMap = new Map();
-    for (const r of records) {
-      const d = new Date(r.timestamp);
-      const day = `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`;
-      dayMap.set(day, (dayMap.get(day) || 0) + calculateRecordCost(r));
-    }
-    const costPerDay = Array.from(dayMap.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([date, cost]) => {
-      const d = new Date(date);
-      const daysInMonth = new Date(d.getUTCFullYear(), d.getUTCMonth() + 1, 0).getUTCDate();
-      return { date, api_cost: Math.round(cost * 100) / 100, subscription_daily: Math.round((subscriptionCost / daysInMonth) * 100) / 100 };
-    });
-    const savings = apiCost - subscriptionCost;
-    res.json({ plan, subscription_cost_usd: subscriptionCost, api_equivalent_cost_usd: apiCost, savings_usd: Math.round(savings * 100) / 100, savings_percent: apiCost > 0 ? Math.round((savings / apiCost) * 1000) / 10 : 0, cost_per_day: costPerDay });
-  });
-
-  router.get('/cache', (req, res) => { res.json(aggregateCache(applyFilters(req.query))); });
-
-  const quotaFetcher = options.quotaFetcher || createQuotaFetcher();
-  router.get('/quota', async (req, res) => {
-    try {
-      const data = await quotaFetcher.fetchQuota();
-      res.json(data);
-    } catch (err) {
-      res.json({ available: false, error: err.message });
-    }
-  });
-
-  router.get('/subscription', (req, res) => {
-    const info = options.getSubscriptionInfo ? options.getSubscriptionInfo() : getSubscriptionInfo();
-    res.json(info || { plan: null, subscriptionType: null, rateLimitTier: null });
-  });
-
-  router.get('/status', (req, res) => {
-    res.json({
-      record_count: cachedRecords.length,
-      last_refreshed: lastRefreshed ? new Date(lastRefreshed).toISOString() : null,
-      cache_ttl_ms: CACHE_TTL_MS,
-    });
-  });
-
-  return router;
-}
+import { Router } from 'express';
+import { parseLogDirectory, parseMultiMachineDirectory } from '../parser.js';
+import { syncLocalToShared } from '../sync.js';
+import { filterByDateRange, autoGranularity, aggregateByTime, aggregateBySession, aggregateByProject, aggregateByModel, aggregateCache } from '../aggregator.js';
+import { calculateRecordCost, PLAN_DEFAULTS } from '../pricing.js';
+import { createQuotaFetcher } from '../quota.js';
+import { getSubscriptionInfo } from '../credentials.js';
+
+export function createApiRouter(logBaseDir, options = {}) {
+  const router = Router();
+  const CACHE_TTL_MS = options.cacheTtlMs || 5000;
+  let cachedRecords = [];
+  let lastRefreshed = null;
+
+  async function refreshRecords() {
+    const now = Date.now();
+    if (lastRefreshed && (now - lastRefreshed) < CACHE_TTL_MS) return cachedRecords;
+    try {
+      if (options.syncDir) {
+        await syncLocalToShared(logBaseDir, options.syncDir, options.machineName);
+        cachedRecords = parseMultiMachineDirectory(options.syncDir);
+      } else {
+        cachedRecords = parseLogDirectory(logBaseDir);
+      }
+      lastRefreshed = now;
+      console.log(`Parsed ${cachedRecords.length} records${options.syncDir ? ' (sync mode)' : ''}`);
+    } catch (err) {
+      console.error('Failed to parse log directory:', err.message);
+      if (!lastRefreshed) lastRefreshed = now;
+    }
+    return cachedRecords;
+  }
+
+  async function applyFilters(query) {
+    let records = filterByDateRange(await refreshRecords(), query.from, query.to);
+    if (query.project) records = records.filter(r => r.project === query.project);
+    if (query.model) records = records.filter(r => r.model === query.model);
+    return records;
+  }
+
+  router.get('/usage', async (req, res) => {
+    try {
+      const records = await applyFilters(req.query);
+      const granularity = req.query.granularity || autoGranularity(req.query.from, req.query.to);
+      const buckets = aggregateByTime(records, granularity);
+      const total = { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_creation_tokens: 0, estimated_api_cost_usd: 0 };
+      for (const r of records) {
+        total.input_tokens += r.input_tokens; total.output_tokens += r.output_tokens;
+        total.cache_read_tokens += r.cache_read_tokens; total.cache_creation_tokens += r.cache_creation_tokens;
+        total.estimated_api_cost_usd += calculateRecordCost(r);
+      }
+      total.estimated_api_cost_usd = Math.round(total.estimated_api_cost_usd * 100) / 100;
+      res.json({ granularity, buckets, total });
+    } catch (err) {
+      res.status(500).json({ error: err.message, code: 'PARSE_ERROR' });
+    }
+  });
+
+  router.get('/models', async (req, res) => { res.json({ models: aggregateByModel(await applyFilters(req.query)) }); });
+  router.get('/projects', async (req, res) => { res.json({ projects: aggregateByProject(await applyFilters(req.query)) }); });
+
+  router.get('/sessions', async (req, res) => {
+    const records = await applyFilters(req.query);
+    let sessions = aggregateBySession(records);
+    const sort = req.query.sort || 'date';
+    const order = req.query.order || 'desc';
+    const sortFn = { date: (a, b) => new Date(b.startTime) - new Date(a.startTime), cost: (a, b) => b.estimated_cost_usd - a.estimated_cost_usd, tokens: (a, b) => b.total_tokens - a.total_tokens }[sort] || ((a, b) => new Date(b.startTime) - new Date(a.startTime));
+    sessions.sort(sortFn);
+    if (order === 'asc') sessions.reverse();
+    const totalTokens = sessions.reduce((sum, s) => sum + s.total_tokens, 0);
+    const totalCost = sessions.reduce((sum, s) => sum + s.estimated_cost_usd, 0);
+    const page = parseInt(req.query.page) || 1;
+    const limit = parseInt(req.query.limit) || 20;
+    const totalSessions = sessions.length;
+    const totalPages = Math.ceil(totalSessions / limit);
+    sessions = sessions.slice((page - 1) * limit, page * limit);
+    res.json({ sessions, pagination: { page, limit, total_sessions: totalSessions, total_pages: totalPages }, totals: { total_tokens: totalTokens, estimated_cost_usd: Math.round(totalCost * 100) / 100 } });
+  });
+
+  router.get('/cost', async (req, res) => {
+    const records = await applyFilters(req.query);
+    const plan = req.query.plan || 'max5x';
+    const customPrice = req.query.customPrice ? parseFloat(req.query.customPrice) : null;
+    const subscriptionCost = customPrice || PLAN_DEFAULTS[plan] || 100;
+    let apiCost = 0;
+    for (const r of records) apiCost += calculateRecordCost(r);
+    apiCost = Math.round(apiCost * 100) / 100;
+    const dayMap = new Map();
+    for (const r of records) {
+      const d = new Date(r.timestamp);
+      const day = `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`;
+      dayMap.set(day, (dayMap.get(day) || 0) + calculateRecordCost(r));
+    }
+    const costPerDay = Array.from(dayMap.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([date, cost]) => {
+      const d = new Date(date);
+      const daysInMonth = new Date(d.getUTCFullYear(), d.getUTCMonth() + 1, 0).getUTCDate();
+      return { date, api_cost: Math.round(cost * 100) / 100, subscription_daily: Math.round((subscriptionCost / daysInMonth) * 100) / 100 };
+    });
+    const savings = apiCost - subscriptionCost;
+    res.json({ plan, subscription_cost_usd: subscriptionCost, api_equivalent_cost_usd: apiCost, savings_usd: Math.round(savings * 100) / 100, savings_percent: apiCost > 0 ? Math.round((savings / apiCost) * 1000) / 10 : 0, cost_per_day: costPerDay });
+  });
+
+  router.get('/cache', async (req, res) => { res.json(aggregateCache(await applyFilters(req.query))); });
+
+  const quotaFetcher = options.quotaFetcher || createQuotaFetcher();
+  router.get('/quota', async (req, res) => {
+    try {
+      const data = await quotaFetcher.fetchQuota();
+      res.json(data);
+    } catch (err) {
+      res.json({ available: false, error: err.message });
+    }
+  });
+
+  router.get('/subscription', (req, res) => {
+    const info = options.getSubscriptionInfo ? options.getSubscriptionInfo() : getSubscriptionInfo();
+    res.json(info || { plan: null, subscriptionType: null, rateLimitTier: null });
+  });
+
+  router.get('/status', async (req, res) => {
+    await refreshRecords();
+    res.json({
+      record_count: cachedRecords.length,
+      last_refreshed: lastRefreshed ? new Date(lastRefreshed).toISOString() : null,
+      cache_ttl_ms: CACHE_TTL_MS,
+    });
+  });
+
+  return router;
+}

package/server/sync.js

@@ -0,0 +1,69 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+const ILLEGAL_CHARS = /[/\\:*?"<>|]/g;
+
+export function sanitizeMachineName(name) {
+  let clean = name.replace(ILLEGAL_CHARS, '-').trim().replace(/^\.+|\.+$/g, '').trim();
+  return clean || 'unknown-host';
+}
+
+export async function syncLocalToShared(localDir, syncDir, machineName) {
+  const safeName = sanitizeMachineName(machineName);
+  const machineDir = path.join(syncDir, safeName);
+  let syncedFiles = 0;
+  const startTime = Date.now();
+
+  let projectDirs;
+  try {
+    const entries = await fs.readdir(localDir, { withFileTypes: true });
+    projectDirs = entries.filter(d => d.isDirectory());
+  } catch {
+    return { syncedFiles, machineName: safeName };
+  }
+
+  for (const dir of projectDirs) {
+    const localProjPath = path.join(localDir, dir.name);
+    let files;
+    try {
+      files = (await fs.readdir(localProjPath)).filter(f => f.endsWith('.jsonl'));
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      const localFile = path.join(localProjPath, file);
+      const sharedFile = path.join(machineDir, dir.name, file);
+
+      try {
+        const localStat = await fs.stat(localFile);
+        let needsSync = false;
+
+        try {
+          const sharedStat = await fs.stat(sharedFile);
+          needsSync = localStat.size > sharedStat.size;
+        } catch {
+          needsSync = true;
+        }
+
+        if (needsSync) {
+          await fs.mkdir(path.join(machineDir, dir.name), { recursive: true });
+          await fs.copyFile(localFile, sharedFile);
+          syncedFiles++;
+        }
+      } catch (err) {
+        console.warn(`Sync warning: failed to sync ${file}: ${err.message}`);
+      }
+    }
+  }
+
+  const elapsed = Date.now() - startTime;
+  if (syncedFiles > 0) {
+    console.log(`Synced ${syncedFiles} files to ${machineDir}`);
+  }
+  if (elapsed > 30000) {
+    console.warn(`Sync took ${Math.round(elapsed / 1000)}s — shared folder may be on a slow mount`);
+  }
+
+  return { syncedFiles, machineName: safeName };
+}