@ian2018cs/agenthub 0.1.0

package/server/routes/usage.js

@@ -0,0 +1,206 @@
+import express from 'express';
+import { userDb, usageDb } from '../database/db.js';
+import { authenticateToken } from '../middleware/auth.js';
+import { triggerManualScan } from '../services/usage-scanner.js';
+
+const router = express.Router();
+
+// Admin middleware
+const requireAdmin = (req, res, next) => {
+  if (req.user.role !== 'admin') {
+    return res.status(403).json({ error: 'Admin access required' });
+  }
+  next();
+};
+
+// Apply auth and admin middleware to all routes
+router.use(authenticateToken);
+router.use(requireAdmin);
+
+/**
+ * Get usage summary for all users
+ * Used in the user list page to show cost per user
+ */
+router.get('/summary', (req, res) => {
+  try {
+    const usageSummary = usageDb.getAllUsersSummary();
+    const users = userDb.getAllUsers();
+
+    // Create a map of uuid to user info
+    const userMap = {};
+    for (const user of users) {
+      userMap[user.uuid] = {
+        id: user.id,
+        username: user.username,
+        role: user.role,
+        status: user.status
+      };
+    }
+
+    // Merge usage data with user info
+    const result = usageSummary.map(usage => ({
+      ...usage,
+      ...userMap[usage.user_uuid]
+    }));
+
+    // Add users with no usage
+    for (const user of users) {
+      if (!usageSummary.find(u => u.user_uuid === user.uuid)) {
+        result.push({
+          user_uuid: user.uuid,
+          id: user.id,
+          username: user.username,
+          role: user.role,
+          status: user.status,
+          total_cost: 0,
+          total_requests: 0,
+          total_sessions: 0,
+          last_active: null
+        });
+      }
+    }
+
+    res.json({ users: result });
+  } catch (error) {
+    console.error('Error fetching usage summary:', error);
+    res.status(500).json({ error: 'Failed to fetch usage summary' });
+  }
+});
+
+/**
+ * Get detailed usage for a specific user
+ */
+router.get('/users/:uuid', (req, res) => {
+  try {
+    const { uuid } = req.params;
+    const { period = 'week' } = req.query;
+
+    // Validate user exists
+    const user = userDb.getUserByUuid(uuid);
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+
+    // Calculate date range
+    const endDate = new Date().toISOString().split('T')[0];
+    let startDate;
+
+    switch (period) {
+      case 'week':
+        startDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        break;
+      case 'month':
+        startDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        break;
+      case 'all':
+        startDate = '2020-01-01';
+        break;
+      default:
+        startDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+    }
+
+    // Get usage data
+    const dailyUsage = usageDb.getUserUsageByPeriod(uuid, startDate, endDate);
+    const totalUsage = usageDb.getUserTotalUsage(uuid);
+    const modelDistribution = usageDb.getUserModelDistribution(uuid, startDate, endDate);
+
+    // Aggregate daily data
+    const dailyMap = {};
+    for (const record of dailyUsage) {
+      if (!dailyMap[record.date]) {
+        dailyMap[record.date] = { date: record.date, cost: 0, requests: 0 };
+      }
+      dailyMap[record.date].cost += record.total_cost_usd;
+      dailyMap[record.date].requests += record.request_count;
+    }
+    const dailyTrend = Object.values(dailyMap).sort((a, b) => a.date.localeCompare(b.date));
+
+    res.json({
+      user: {
+        uuid: user.uuid,
+        username: user.username,
+        role: user.role
+      },
+      period,
+      totalCost: totalUsage?.total_cost || 0,
+      totalRequests: totalUsage?.total_requests || 0,
+      totalSessions: totalUsage?.total_sessions || 0,
+      dailyTrend,
+      modelDistribution
+    });
+  } catch (error) {
+    console.error('Error fetching user usage:', error);
+    res.status(500).json({ error: 'Failed to fetch user usage' });
+  }
+});
+
+/**
+ * Get global dashboard statistics
+ */
+router.get('/dashboard', (req, res) => {
+  try {
+    const { period = 'week' } = req.query;
+
+    // Calculate date range
+    const endDate = new Date().toISOString().split('T')[0];
+    let startDate;
+
+    switch (period) {
+      case 'week':
+        startDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        break;
+      case 'month':
+        startDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        break;
+      default:
+        startDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+    }
+
+    const stats = usageDb.getDashboardStats(startDate, endDate);
+    const users = userDb.getAllUsers();
+
+    // Create username map
+    const usernameMap = {};
+    for (const user of users) {
+      usernameMap[user.uuid] = user.username;
+    }
+
+    // Enrich top users with usernames
+    const topUsers = stats.topUsers.map(user => ({
+      ...user,
+      username: usernameMap[user.user_uuid] || 'Unknown'
+    }));
+
+    res.json({
+      period,
+      totals: {
+        totalCost: stats.totals?.total_cost || 0,
+        totalRequests: stats.totals?.total_requests || 0,
+        totalSessions: stats.totals?.total_sessions || 0,
+        activeUsers: stats.totals?.active_users || 0,
+        totalUsers: users.length
+      },
+      dailyTrend: stats.dailyTrend,
+      modelDistribution: stats.modelDistribution,
+      topUsers
+    });
+  } catch (error) {
+    console.error('Error fetching dashboard stats:', error);
+    res.status(500).json({ error: 'Failed to fetch dashboard statistics' });
+  }
+});
+
+/**
+ * Trigger a manual usage scan
+ */
+router.post('/scan', async (req, res) => {
+  try {
+    const result = await triggerManualScan();
+    res.json(result);
+  } catch (error) {
+    console.error('Error triggering manual scan:', error);
+    res.status(500).json({ error: 'Failed to trigger scan' });
+  }
+});
+
+export default router;

package/server/services/pricing.js

@@ -0,0 +1,196 @@
+/**
+ * Claude Model Pricing Table
+ *
+ * Prices are in USD per token.
+ * Reference: https://www.anthropic.com/pricing
+ */
+
+// Pricing per million tokens
+// Reference: https://platform.claude.com/docs/en/about-claude/pricing
+// Cache pricing: read = 0.1x base, write (5min) = 1.25x base, write (1h) = 2x base
+const PRICING_PER_MILLION = {
+  // ============ Latest Models ============
+  // Claude Opus 4.5 (latest flagship)
+  'claude-opus-4-5-20251101': {
+    input: 5.00,
+    output: 25.00,
+    cacheRead: 0.50,
+    cacheCreate: 6.25
+  },
+  // Claude Sonnet 4.5
+  'claude-sonnet-4-5-20250929': {
+    input: 3.00,
+    output: 15.00,
+    cacheRead: 0.30,
+    cacheCreate: 3.75
+  },
+  // Claude Haiku 4.5
+  'claude-haiku-4-5-20251001': {
+    input: 1.00,
+    output: 5.00,
+    cacheRead: 0.10,
+    cacheCreate: 1.25
+  },
+  // ============ Legacy Models ============
+  // Claude Opus 4.1
+  'claude-opus-4-1-20250805': {
+    input: 15.00,
+    output: 75.00,
+    cacheRead: 1.50,
+    cacheCreate: 18.75
+  },
+  // Claude Opus 4
+  'claude-opus-4-20250514': {
+    input: 15.00,
+    output: 75.00,
+    cacheRead: 1.50,
+    cacheCreate: 18.75
+  },
+  // Claude Sonnet 4
+  'claude-sonnet-4-20250514': {
+    input: 3.00,
+    output: 15.00,
+    cacheRead: 0.30,
+    cacheCreate: 3.75
+  },
+  // Claude Sonnet 3.7
+  'claude-3-7-sonnet-20250219': {
+    input: 3.00,
+    output: 15.00,
+    cacheRead: 0.30,
+    cacheCreate: 3.75
+  },
+  // Claude Haiku 3.5
+  'claude-3-5-haiku-20241022': {
+    input: 0.80,
+    output: 4.00,
+    cacheRead: 0.08,
+    cacheCreate: 1.00
+  },
+  // Claude Haiku 3
+  'claude-3-haiku-20240307': {
+    input: 0.25,
+    output: 1.25,
+    cacheRead: 0.03,
+    cacheCreate: 0.30
+  },
+  // ============ Aliases ============
+  // Aliases for simplified model names (pointing to latest versions)
+  'sonnet': {
+    input: 3.00,
+    output: 15.00,
+    cacheRead: 0.30,
+    cacheCreate: 3.75
+  },
+  'opus': {
+    input: 5.00,
+    output: 25.00,
+    cacheRead: 0.50,
+    cacheCreate: 6.25
+  },
+  'haiku': {
+    input: 1.00,
+    output: 5.00,
+    cacheRead: 0.10,
+    cacheCreate: 1.25
+  }
+};
+
+// Convert to price per token
+const PRICING = {};
+for (const [model, prices] of Object.entries(PRICING_PER_MILLION)) {
+  PRICING[model] = {
+    input: prices.input / 1_000_000,
+    output: prices.output / 1_000_000,
+    cacheRead: prices.cacheRead / 1_000_000,
+    cacheCreate: prices.cacheCreate / 1_000_000
+  };
+}
+
+/**
+ * Normalize model name to a standard format
+ * @param {string} model - Raw model name
+ * @returns {string} Normalized model name
+ */
+function normalizeModelName(model) {
+  if (!model) return 'sonnet';
+
+  const modelLower = model.toLowerCase();
+
+  // Check for exact match
+  if (PRICING[model]) {
+    return model;
+  }
+
+  // Check for partial matches
+  if (modelLower.includes('opus')) {
+    return 'opus';
+  }
+  if (modelLower.includes('haiku')) {
+    return 'haiku';
+  }
+  if (modelLower.includes('sonnet')) {
+    return 'sonnet';
+  }
+
+  // Default to sonnet
+  return 'sonnet';
+}
+
+/**
+ * Calculate cost for token usage
+ * @param {Object} usage - Token usage object
+ * @param {string} usage.model - Model name
+ * @param {number} usage.inputTokens - Input tokens
+ * @param {number} usage.outputTokens - Output tokens
+ * @param {number} usage.cacheReadTokens - Cache read tokens
+ * @param {number} usage.cacheCreationTokens - Cache creation tokens
+ * @returns {number} Cost in USD
+ */
+function calculateCost(usage) {
+  const model = normalizeModelName(usage.model);
+  const prices = PRICING[model];
+
+  if (!prices) {
+    console.warn(`Unknown model: ${usage.model}, using sonnet pricing`);
+    return calculateCost({ ...usage, model: 'sonnet' });
+  }
+
+  const inputCost = (usage.inputTokens || 0) * prices.input;
+  const outputCost = (usage.outputTokens || 0) * prices.output;
+  const cacheReadCost = (usage.cacheReadTokens || 0) * prices.cacheRead;
+  const cacheCreateCost = (usage.cacheCreationTokens || 0) * prices.cacheCreate;
+
+  return inputCost + outputCost + cacheReadCost + cacheCreateCost;
+}
+
+/**
+ * Get pricing for a model
+ * @param {string} model - Model name
+ * @returns {Object} Pricing object
+ */
+function getModelPricing(model) {
+  const normalizedModel = normalizeModelName(model);
+  return PRICING[normalizedModel] || PRICING['sonnet'];
+}
+
+/**
+ * Format cost for display
+ * @param {number} cost - Cost in USD
+ * @returns {string} Formatted cost string
+ */
+function formatCost(cost) {
+  if (cost < 0.01) {
+    return `$${cost.toFixed(4)}`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+
+export {
+  PRICING,
+  PRICING_PER_MILLION,
+  normalizeModelName,
+  calculateCost,
+  getModelPricing,
+  formatCost
+};

package/server/services/usage-scanner.js

@@ -0,0 +1,283 @@
+/**
+ * Usage Scanner Service
+ *
+ * Scans Claude session files (JSONL) for token usage data and records it to the database.
+ * This handles CLI mode usage tracking and serves as a backup for SDK mode.
+ *
+ * Features:
+ * - Scans all users' Claude session directories
+ * - Tracks scan position to avoid re-processing
+ * - Updates daily summaries
+ * - Cleans up old records (30 days)
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { usageDb, userDb } from '../database/db.js';
+import { calculateCost, normalizeModelName } from './pricing.js';
+import { DATA_DIR, getUserPaths } from './user-directories.js';
+
+// Scan interval: 5 minutes
+const SCAN_INTERVAL_MS = 5 * 60 * 1000;
+
+// Retention period: 30 days
+const RETENTION_DAYS = 30;
+
+// Scanner state
+let scannerInterval = null;
+let isScanning = false;
+
+/**
+ * Start the usage scanner
+ */
+export function startUsageScanner() {
+  console.log('[UsageScanner] Starting usage scanner service');
+
+  // Run initial scan after a short delay
+  setTimeout(() => {
+    runScan();
+  }, 10000);
+
+  // Schedule periodic scans
+  scannerInterval = setInterval(() => {
+    runScan();
+  }, SCAN_INTERVAL_MS);
+
+  console.log(`[UsageScanner] Scheduled to run every ${SCAN_INTERVAL_MS / 1000 / 60} minutes`);
+}
+
+/**
+ * Stop the usage scanner
+ */
+export function stopUsageScanner() {
+  if (scannerInterval) {
+    clearInterval(scannerInterval);
+    scannerInterval = null;
+    console.log('[UsageScanner] Stopped usage scanner service');
+  }
+}
+
+/**
+ * Run a scan cycle
+ */
+async function runScan() {
+  if (isScanning) {
+    console.log('[UsageScanner] Scan already in progress, skipping');
+    return;
+  }
+
+  isScanning = true;
+  console.log('[UsageScanner] Starting scan cycle');
+
+  try {
+    // Get all users
+    const users = userDb.getAllUsers();
+
+    for (const user of users) {
+      if (!user.uuid) continue;
+
+      try {
+        await scanUserSessions(user.uuid);
+      } catch (error) {
+        console.error(`[UsageScanner] Error scanning user ${user.uuid}:`, error.message);
+      }
+    }
+
+    // Cleanup old records
+    const deletedCount = usageDb.cleanupOldRecords(RETENTION_DAYS);
+    if (deletedCount > 0) {
+      console.log(`[UsageScanner] Cleaned up ${deletedCount} old usage records`);
+    }
+
+    console.log('[UsageScanner] Scan cycle completed');
+  } catch (error) {
+    console.error('[UsageScanner] Error during scan cycle:', error);
+  } finally {
+    isScanning = false;
+  }
+}
+
+/**
+ * Scan a user's session files
+ */
+async function scanUserSessions(userUuid) {
+  const userPaths = getUserPaths(userUuid);
+  const projectsDir = path.join(userPaths.claudeDir, 'projects');
+  const scanStatePath = path.join(userPaths.claudeDir, '.usage-scan-state.json');
+
+  // Check if projects directory exists
+  try {
+    await fs.access(projectsDir);
+  } catch {
+    // No projects directory yet
+    return;
+  }
+
+  // Load scan state
+  let scanState = { lastScanTime: null, scannedSessions: {} };
+  try {
+    const stateContent = await fs.readFile(scanStatePath, 'utf8');
+    scanState = JSON.parse(stateContent);
+  } catch {
+    // File doesn't exist or is invalid, start fresh
+  }
+
+  // Get all project directories
+  const projectDirs = await fs.readdir(projectsDir, { withFileTypes: true });
+
+  let newRecordsCount = 0;
+
+  for (const projectDir of projectDirs) {
+    if (!projectDir.isDirectory()) continue;
+
+    const projectPath = path.join(projectsDir, projectDir.name);
+    const sessionFiles = await fs.readdir(projectPath);
+
+    for (const sessionFile of sessionFiles) {
+      if (!sessionFile.endsWith('.jsonl')) continue;
+
+      const sessionId = sessionFile.replace('.jsonl', '');
+      const sessionPath = path.join(projectPath, sessionFile);
+
+      // Get file stats
+      const stats = await fs.stat(sessionPath);
+      const lastModified = stats.mtime.toISOString();
+
+      // Check if we need to scan this session
+      const lastScanned = scanState.scannedSessions[sessionId];
+      if (lastScanned && lastScanned.lastModified === lastModified) {
+        // Already scanned and file hasn't changed
+        continue;
+      }
+
+      // Scan the session file
+      try {
+        const recordsAdded = await scanSessionFile(
+          userUuid,
+          sessionId,
+          sessionPath,
+          lastScanned?.lastLine || 0
+        );
+        newRecordsCount += recordsAdded;
+
+        // Update scan state
+        scanState.scannedSessions[sessionId] = {
+          lastModified,
+          lastLine: lastScanned?.lastLine || 0,
+          lastScan: new Date().toISOString()
+        };
+      } catch (error) {
+        console.error(`[UsageScanner] Error scanning session ${sessionId}:`, error.message);
+      }
+    }
+  }
+
+  // Save scan state
+  scanState.lastScanTime = new Date().toISOString();
+  await fs.writeFile(scanStatePath, JSON.stringify(scanState, null, 2));
+
+  if (newRecordsCount > 0) {
+    console.log(`[UsageScanner] User ${userUuid}: added ${newRecordsCount} new records`);
+  }
+}
+
+/**
+ * Scan a session JSONL file for usage data
+ */
+async function scanSessionFile(userUuid, sessionId, filePath, startLine) {
+  const content = await fs.readFile(filePath, 'utf8');
+  const lines = content.trim().split('\n');
+
+  let recordsAdded = 0;
+  const sessionDates = new Set();
+
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+
+    try {
+      const entry = JSON.parse(line);
+
+      // Only process assistant messages with usage data
+      if (entry.type !== 'assistant' || !entry.message?.usage) {
+        continue;
+      }
+
+      const usage = entry.message.usage;
+      const model = normalizeModelName(entry.message?.model || 'sonnet');
+
+      const inputTokens = usage.input_tokens || 0;
+      const outputTokens = usage.output_tokens || 0;
+      const cacheReadTokens = usage.cache_read_input_tokens || 0;
+      const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+
+      const cost = calculateCost({
+        model,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens
+      });
+
+      // Determine the date from the entry timestamp or use current date
+      const entryDate = entry.timestamp
+        ? new Date(entry.timestamp).toISOString().split('T')[0]
+        : new Date().toISOString().split('T')[0];
+
+      // Insert usage record (source: cli)
+      usageDb.insertRecord({
+        user_uuid: userUuid,
+        session_id: sessionId,
+        model,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_read_tokens: cacheReadTokens,
+        cache_creation_tokens: cacheCreationTokens,
+        cost_usd: cost,
+        source: 'cli',
+        created_at: entry.timestamp || new Date().toISOString()
+      });
+
+      // Update daily summary
+      usageDb.upsertDailySummary({
+        user_uuid: userUuid,
+        date: entryDate,
+        model,
+        total_input_tokens: inputTokens,
+        total_output_tokens: outputTokens,
+        total_cost_usd: cost,
+        session_count: 0,
+        request_count: 1
+      });
+
+      sessionDates.add(entryDate);
+      recordsAdded++;
+    } catch (parseError) {
+      // Skip lines that can't be parsed
+      continue;
+    }
+  }
+
+  // Update session count for each date (once per scan, not per record)
+  for (const date of sessionDates) {
+    try {
+      // We count this as a session activity for today
+      // Note: This is approximate since we're scanning multiple messages at once
+    } catch (error) {
+      // Ignore session count errors
+    }
+  }
+
+  return recordsAdded;
+}
+
+/**
+ * Manually trigger a scan (for testing or admin use)
+ */
+export async function triggerManualScan() {
+  console.log('[UsageScanner] Manual scan triggered');
+  await runScan();
+  return { success: true, message: 'Scan completed' };
+}
+
+export { SCAN_INTERVAL_MS, RETENTION_DAYS };