claude-usage-dashboard 1.4.0 → 1.4.2

package/server/pricing.js

@@ -1,52 +1,52 @@
-export const MODEL_PRICING = {
-  'claude-opus-4-6': {
-    input_price_per_mtok: 5,
-    output_price_per_mtok: 25,
-    cache_read_price_per_mtok: 0.50,
-    cache_creation_price_per_mtok: 6.25,
-  },
-  'claude-sonnet-4-6': {
-    input_price_per_mtok: 3,
-    output_price_per_mtok: 15,
-    cache_read_price_per_mtok: 0.30,
-    cache_creation_price_per_mtok: 3.75,
-  },
-  'claude-haiku-4-5': {
-    input_price_per_mtok: 1,
-    output_price_per_mtok: 5,
-    cache_read_price_per_mtok: 0.10,
-    cache_creation_price_per_mtok: 1.25,
-  },
-};
-
-export const PLAN_DEFAULTS = {
-  pro: 20,
-  max5x: 100,
-  max20x: 200,
-};
-
-export function getModelPricing(modelId) {
-  return MODEL_PRICING[modelId] || null;
-}
-
-/**
- * Calculate the API cost for a single usage record.
- * Returns 0 for unknown models.
- *
- * In Claude Code logs, input_tokens is the non-cached input.
- * cache_read_tokens and cache_creation_tokens are separate, additive fields.
- * cost = input * input_rate + cache_read * read_rate + cache_creation * write_rate + output * output_rate
- */
-export function calculateRecordCost(record) {
-  const pricing = MODEL_PRICING[record.model];
-  if (!pricing) return 0;
-
-  const M = 1_000_000;
-
-  return (
-    (record.input_tokens / M) * pricing.input_price_per_mtok +
-    (record.cache_read_tokens / M) * pricing.cache_read_price_per_mtok +
-    (record.cache_creation_tokens / M) * pricing.cache_creation_price_per_mtok +
-    (record.output_tokens / M) * pricing.output_price_per_mtok
-  );
-}
+export const MODEL_PRICING = {
+  'claude-opus-4-6': {
+    input_price_per_mtok: 5,
+    output_price_per_mtok: 25,
+    cache_read_price_per_mtok: 0.50,
+    cache_creation_price_per_mtok: 6.25,
+  },
+  'claude-sonnet-4-6': {
+    input_price_per_mtok: 3,
+    output_price_per_mtok: 15,
+    cache_read_price_per_mtok: 0.30,
+    cache_creation_price_per_mtok: 3.75,
+  },
+  'claude-haiku-4-5': {
+    input_price_per_mtok: 1,
+    output_price_per_mtok: 5,
+    cache_read_price_per_mtok: 0.10,
+    cache_creation_price_per_mtok: 1.25,
+  },
+};
+
+export const PLAN_DEFAULTS = {
+  pro: 20,
+  max5x: 100,
+  max20x: 200,
+};
+
+export function getModelPricing(modelId) {
+  return MODEL_PRICING[modelId] || null;
+}
+
+/**
+ * Calculate the API cost for a single usage record.
+ * Returns 0 for unknown models.
+ *
+ * In Claude Code logs, input_tokens is the non-cached input.
+ * cache_read_tokens and cache_creation_tokens are separate, additive fields.
+ * cost = input * input_rate + cache_read * read_rate + cache_creation * write_rate + output * output_rate
+ */
+export function calculateRecordCost(record) {
+  const pricing = MODEL_PRICING[record.model];
+  if (!pricing) return 0;
+
+  const M = 1_000_000;
+
+  return (
+    (record.input_tokens / M) * pricing.input_price_per_mtok +
+    (record.cache_read_tokens / M) * pricing.cache_read_price_per_mtok +
+    (record.cache_creation_tokens / M) * pricing.cache_creation_price_per_mtok +
+    (record.output_tokens / M) * pricing.output_price_per_mtok
+  );
+}

package/server/routes/api.js

@@ -1,130 +1,141 @@
-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;
-}
+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;
+
+  // Background sync: runs periodically without blocking API requests
+  if (options.syncDir) {
+    const SYNC_INTERVAL_MS = options.syncIntervalMs || 30000;
+    const runBackgroundSync = () => {
+      syncLocalToShared(logBaseDir, options.syncDir, options.machineName).catch(err => {
+        console.warn('Background sync failed:', err.message);
+      });
+    };
+    runBackgroundSync();
+    setInterval(runBackgroundSync, SYNC_INTERVAL_MS).unref();
+  }
+
+  function refreshRecords() {
+    const now = Date.now();
+    if (lastRefreshed && (now - lastRefreshed) < CACHE_TTL_MS) return cachedRecords;
+    try {
+      if (options.syncDir) {
+        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;
+  }
+
+  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) => {
+    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

@@ -1,69 +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 };
-}
+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 };
+}