claude-code-watch 0.1.4 → 0.2.0

package/src/server/server.js

@@ -9,6 +9,7 @@ var readline = require('readline');
 var { WebSocketServer } = require('ws');
 var { Watcher, listSessions, listActiveSessions } = require('../watcher/watcher');
 var { setDebugAll, contextWindowFor } = require('../parser/parser');
+var { fullScanTokenUsage } = require('../scanner/scanner');
 
 var PACKAGE_VERSION = require('../../package.json').version;
 
@@ -37,6 +38,17 @@ class DashboardServer {
     this._contextCleanupTimer = null;
     this._pendingItems = [];
     this._flushTimer = null;
+    this._tokenStatsDirty = false;
+
+    // Incremental last-activity tracking: "sessionID:agentID" → { toolName, content }
+    this.lastActivities = new Map();
+
+    // Time-series token stats: daily aggregation (never cleaned up)
+    // Key: "YYYY-MM-DD", value: { messages, input, output, cacheCreation, cacheRead, models: { modelName: { input, output, cacheCreation, cacheRead } } }
+    this.dailyStats = new Map();
+
+    // Hourly distribution: 24-hour array of API call counts (local timezone)
+    this.hourlyStats = new Array(24).fill(0);
 
     this.server = null;
     this.wss = null;
@@ -67,6 +79,12 @@ class DashboardServer {
     return Date.now();
   }
 
+  _getDateKey(ts) {
+    let d = new Date(ts);
+    if (isNaN(d.getTime())) d = new Date();
+    return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
+  }
+
   updateContext(item) {
     const key = this.getCtxKey(item.sessionID, item.agentID);
     let ctx = this.contextMap.get(key);
@@ -85,6 +103,42 @@ class DashboardServer {
       ctx.contextWindow = contextWindowFor(item.model);
     }
     ctx.lastActivity = Math.max(ctx.lastActivity || 0, this.itemTime(item));
+
+    // ── Time-series aggregation for token stats ──
+    // All 4 token fields are summed (incremental for billing/consumption perspective)
+    const hasTokens = item.inputTokens || item.outputTokens || item.cacheCreationTokens || item.cacheReadTokens;
+    if (hasTokens) {
+      const dateKey = this._getDateKey(this.itemTime(item));
+      let day = this.dailyStats.get(dateKey);
+      if (!day) {
+        day = { messages: 0, input: 0, output: 0, cacheCreation: 0, cacheRead: 0, models: {} };
+        this.dailyStats.set(dateKey, day);
+      }
+      day.messages++;
+      if (item.inputTokens) day.input += item.inputTokens;
+      if (item.outputTokens) day.output += item.outputTokens;
+      if (item.cacheCreationTokens) day.cacheCreation += item.cacheCreationTokens;
+      if (item.cacheReadTokens) day.cacheRead += item.cacheReadTokens;
+
+      // Hourly distribution: increment the hour bucket
+      const tsDate = new Date(this.itemTime(item));
+      if (!isNaN(tsDate.getTime())) {
+        this.hourlyStats[tsDate.getHours()]++;
+      }
+
+      // Per-model breakdown within this day
+      if (item.model) {
+        let m = day.models[item.model];
+        if (!m) {
+          m = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
+          day.models[item.model] = m;
+        }
+        if (item.inputTokens) m.input += item.inputTokens;
+        if (item.outputTokens) m.output += item.outputTokens;
+        if (item.cacheCreationTokens) m.cacheCreation += item.cacheCreationTokens;
+        if (item.cacheReadTokens) m.cacheRead += item.cacheReadTokens;
+      }
+    }
   }
 
   cleanupContextMap() {
@@ -112,6 +166,48 @@ class DashboardServer {
     return result;
   }
 
+  getTokenStatsSnapshot() {
+    // Convert dailyStats Map to plain object, sorted by date descending
+    const daily = {};
+    const sortedKeys = [...this.dailyStats.keys()].sort().reverse();
+    for (const k of sortedKeys) {
+      const d = this.dailyStats.get(k);
+      daily[k] = {
+        messages: d.messages,
+        input: d.input,
+        output: d.output,
+        cacheCreation: d.cacheCreation,
+        cacheRead: d.cacheRead,
+        models: d.models,
+      };
+    }
+
+    // Compute global totals
+    let totalMessages = 0, totalInput = 0, totalOutput = 0, totalCacheCreation = 0, totalCacheRead = 0;
+    const modelTotals = {};
+    for (const [, d] of this.dailyStats) {
+      totalMessages += d.messages;
+      totalInput += d.input;
+      totalOutput += d.output;
+      totalCacheCreation += d.cacheCreation;
+      totalCacheRead += d.cacheRead;
+      for (const [modelName, m] of Object.entries(d.models)) {
+        if (!modelTotals[modelName]) modelTotals[modelName] = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
+        modelTotals[modelName].input += m.input;
+        modelTotals[modelName].output += m.output;
+        modelTotals[modelName].cacheCreation += m.cacheCreation;
+        modelTotals[modelName].cacheRead += m.cacheRead;
+      }
+    }
+
+    return {
+      totals: { messages: totalMessages, input: totalInput, output: totalOutput, cacheCreation: totalCacheCreation, cacheRead: totalCacheRead, days: this.dailyStats.size },
+      modelTotals,
+      daily,
+      hourly: this.hourlyStats,
+    };
+  }
+
   broadcast(type, payload) {
     const msg = JSON.stringify({ type, payload });
     const toRemove = [];
@@ -137,9 +233,16 @@ class DashboardServer {
     const ext = path.extname(filePath).toLowerCase();
     try {
       const data = await fs.promises.readFile(filePath);
+      // Vendor files (highlight.js, marked, DOMPurify, CSS) are versioned with the
+      // package and rarely change — cache for 1 year. Everything else (index.html,
+      // favicon) stays no-cache to ensure users always get the latest.
+      const isVendor = filePath.includes('/vendor/');
+      const cacheControl = isVendor
+        ? 'public, max-age=31536000, immutable'
+        : 'no-cache, no-store, must-revalidate';
       res.writeHead(200, {
         'Content-Type': MIME[ext] || 'application/octet-stream',
-        'Cache-Control': 'no-cache, no-store, must-revalidate',
+        'Cache-Control': cacheControl,
       });
       res.end(data);
     } catch {
@@ -207,6 +310,11 @@ class DashboardServer {
       return;
     }
 
+    if (route === '/token-stats') {
+      this.sendJSON(res, this.getTokenStatsSnapshot());
+      return;
+    }
+
     if (route === '/task-output') {
       const filePath = params.get('path');
       if (!filePath) { this.sendJSON(res, { error: 'Missing path param' }, 400); return; }
@@ -262,6 +370,7 @@ class DashboardServer {
     this.sendSnapshot(ws);
     this.sendItemBatch(ws);
     this.sendContext(ws);
+    this.sendTokenStats(ws);
     this.sendConfig(ws);
   }
 
@@ -294,6 +403,10 @@ class DashboardServer {
     try { ws.send(JSON.stringify({ type, payload })); } catch {}
   }
 
+  sendTokenStats(ws) {
+    this.send(ws, 'tokenStats', this.getTokenStatsSnapshot());
+  }
+
   sendSnapshot(ws) {
     if (!this.watcher) return;
     const sessions = this.watcher.getSessionsSnapshot().map(s => ({
@@ -301,7 +414,7 @@ class DashboardServer {
       projectPath: s.projectPath,
       birthtimeMs: s.birthtimeMs || 0,
       subagents: Object.entries(s.subagentTypes || s.subagents || {}).reduce((acc, [id, type]) => {
-        acc[id] = typeof type === 'string' ? type : '';
+        acc[id] = { type: typeof type === 'string' ? type : '', birthtimeMs: (s.subagentBirthtimes && s.subagentBirthtimes[id]) || 0 };
         return acc;
       }, {}),
       backgroundTasks: Object.entries(s.backgroundTasks || {}).map(([id, t]) => ({
@@ -312,15 +425,10 @@ class DashboardServer {
         isComplete: t.isComplete,
       })),
     }));
-    // Compute last activity per agent from itemBuffer (handles skipped history)
+    // Use incrementally maintained lastActivities map (O(1) instead of O(itemBuffer))
     const lastActivities = {};
-    for (const item of this.itemBuffer) {
-      const actKey = item.sessionID + ':' + (item.agentID || '');
-      if (item.type === 'user_text') {
-        lastActivities[actKey] = { toolName: '', content: (item.content || '').slice(0, 200) };
-      } else if (item.type === 'tool_input' && item.agentID) {
-        lastActivities[actKey] = { toolName: item.toolName || '', content: (item.content || '').slice(0, 200) };
-      }
+    for (const [key, val] of this.lastActivities) {
+      lastActivities[key] = val;
     }
     this.send(ws, 'snapshot', {
       sessions,
@@ -349,6 +457,9 @@ class DashboardServer {
       for (const key of this.contextMap.keys()) {
         if (key.startsWith(sessionID + ':')) this.contextMap.delete(key);
       }
+      for (const key of this.lastActivities.keys()) {
+        if (key.startsWith(sessionID + ':')) this.lastActivities.delete(key);
+      }
     });
 
     const FLUSH_BATCH_LIMIT = 50;
@@ -358,13 +469,32 @@ class DashboardServer {
         this.itemBuffer = this.itemBuffer.slice(-MAX_ITEM_BUFFER);
       }
       this.updateContext(item);
+
+      // Incrementally track last activity per agent
+      if (item.type === 'user_text') {
+        const actKey = item.sessionID + ':' + (item.agentID || '');
+        this.lastActivities.set(actKey, { toolName: '', content: (item.content || '').slice(0, 200) });
+      } else if (item.type === 'tool_input' && item.agentID) {
+        const actKey = item.sessionID + ':' + item.agentID;
+        this.lastActivities.set(actKey, { toolName: item.toolName || '', content: (item.content || '').slice(0, 200) });
+      }
+
       this._pendingItems.push(item);
+      // Track if any item in this batch has token data (for tokenStats broadcast)
+      if (item.inputTokens || item.outputTokens || item.cacheCreationTokens || item.cacheReadTokens) {
+        this._tokenStatsDirty = true;
+      }
       if (this._pendingItems.length >= FLUSH_BATCH_LIMIT) {
         // Batch size hit limit — flush immediately
         if (this._flushTimer) { clearTimeout(this._flushTimer); this._flushTimer = null; }
         const batch = this._pendingItems;
         this._pendingItems = [];
         this.broadcast('itemBatch', batch);
+        this.broadcast('context', this.getContextSnapshot());
+        if (this._tokenStatsDirty) {
+          this._tokenStatsDirty = false;
+          this.broadcast('tokenStats', this.getTokenStatsSnapshot());
+        }
       } else if (!this._flushTimer) {
         this._flushTimer = setTimeout(() => {
           this._flushTimer = null;
@@ -375,6 +505,11 @@ class DashboardServer {
           } else if (batch.length > 1) {
             this.broadcast('itemBatch', batch);
           }
+          this.broadcast('context', this.getContextSnapshot());
+          if (this._tokenStatsDirty) {
+            this._tokenStatsDirty = false;
+            this.broadcast('tokenStats', this.getTokenStatsSnapshot());
+          }
         }, 50);
       }
     });
@@ -497,6 +632,29 @@ class DashboardServer {
       }
     });
 
+    // ── Full-scan historical JSONL files for token stats ──
+    // This runs BEFORE watcher starts, scanning ALL files regardless of age
+    console.log('  Scanning historical token data...');
+    try {
+      const scanned = await fullScanTokenUsage((done, total) => {
+        if (total > 0 && (done % 100 === 0 || done === total)) {
+          console.log(`  Scanned ${done}/${total} files...`);
+        }
+      });
+      // Merge scanned data into this.dailyStats and this.hourlyStats
+      for (const [dateStr, day] of scanned.dailyStats) {
+        this.dailyStats.set(dateStr, day);
+      }
+      for (let h = 0; h < 24; h++) {
+        this.hourlyStats[h] += scanned.hourlyStats[h];
+      }
+      const totalDays = this.dailyStats.size;
+      const totalMsgs = [...this.dailyStats.values()].reduce((s, d) => s + d.messages, 0);
+      console.log(`  Token scan complete: ${totalDays} days, ${totalMsgs.toLocaleString()} messages`);
+    } catch (err) {
+      console.error('  Token scan error (non-critical, continuing):', err.message);
+    }
+
     const w = this.setupWatcher(watcherOpts);
 
     try {
@@ -581,4 +739,4 @@ function askYesNo(prompt) {
   });
 }
 
-module.exports = { DashboardServer, startServer };
+module.exports = { DashboardServer, startServer };

package/src/watcher/watcher.js

@@ -134,6 +134,7 @@ class Session {
     this.birthtimeMs = birthtimeMs || 0;
     this.subagents = {};       // agentID -> file path
     this.subagentTypes = {};   // agentID -> agentType
+    this.subagentBirthtimes = {}; // agentID -> birthtimeMs
     this.backgroundTasks = {}; // toolID -> BackgroundTask
     this.toolIndex = new Map(); // toolID -> { toolName, parentAgentID, hasResult }
     this.toolIndexPopulated = false;
@@ -275,6 +276,10 @@ class Watcher extends EventEmitter {
           if (agentType) {
             session.subagentTypes[agentID] = agentType;
           }
+          try {
+            const agentStats = await fsp.stat(jsonlPath);
+            session.subagentBirthtimes[agentID] = agentStats.birthtimeMs || agentStats.mtimeMs || 0;
+          } catch {}
         }
       }
     } catch (err) {
@@ -312,7 +317,7 @@ class Watcher extends EventEmitter {
         // Broadcast so connected clients learn about the new session
         this.emit('broadcast', 'newSession', { sessionID: session.id, projectPath: session.projectPath, birthtimeMs: session.birthtimeMs });
         for (const [agentID, agentType] of Object.entries(session.subagentTypes)) {
-          this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType });
+          this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType, birthtimeMs: session.subagentBirthtimes[agentID] || 0 });
         }
 
         const pending = this.pendingSubagents.get(session.id);
@@ -589,7 +594,7 @@ class Watcher extends EventEmitter {
 
     // Broadcast pre-existing subagents to frontend
     for (const [agentID, agentType] of Object.entries(session.subagentTypes)) {
-      this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType });
+      this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType, birthtimeMs: session.subagentBirthtimes[agentID] || 0 });
     }
 
     // Read initial data from the new session's files
@@ -636,9 +641,13 @@ class Watcher extends EventEmitter {
 
     session.subagents[agentID] = p;
     if (agentType) session.subagentTypes[agentID] = agentType;
+    try {
+      const agentStats = await fsp.stat(p);
+      session.subagentBirthtimes[agentID] = agentStats.birthtimeMs || agentStats.mtimeMs || 0;
+    } catch {}
 
     this._addFileWatch(p, sessionID, agentID);
-    this.emit('broadcast', 'newAgent', { sessionID, agentID, agentType });
+    this.emit('broadcast', 'newAgent', { sessionID, agentID, agentType, birthtimeMs: session.subagentBirthtimes[agentID] || 0 });
 
     // Read initial data from the new subagent file
     if (this.useFsnotify) {
@@ -726,7 +735,7 @@ class Watcher extends EventEmitter {
       this.emit('broadcast', 'newSession', { sessionID: c.session.id, projectPath: c.session.projectPath, birthtimeMs: c.session.birthtimeMs });
 
       for (const [agentID, agentType] of Object.entries(c.session.subagentTypes)) {
-        this.emit('broadcast', 'newAgent', { sessionID: c.session.id, agentID, agentType });
+        this.emit('broadcast', 'newAgent', { sessionID: c.session.id, agentID, agentType, birthtimeMs: c.session.subagentBirthtimes[agentID] || 0 });
       }
 
       const pending = this.pendingSubagents.get(c.session.id);
@@ -754,8 +763,12 @@ class Watcher extends EventEmitter {
       const agentType = await readAgentType(agentPath);
       session.subagents[agentID] = agentPath;
       if (agentType) session.subagentTypes[agentID] = agentType;
+      try {
+        const agentStats = await fsp.stat(agentPath);
+        session.subagentBirthtimes[agentID] = agentStats.birthtimeMs || agentStats.mtimeMs || 0;
+      } catch {}
 
-      this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType });
+      this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType, birthtimeMs: session.subagentBirthtimes[agentID] || 0 });
     }
   }
 
@@ -828,59 +841,66 @@ class Watcher extends EventEmitter {
       ...Object.entries(session.subagents).map(([id, p]) => ({ path: p, agentID: id })),
     ];
 
-    for (const { path: filePath, agentID } of files) {
-      if (!filePath) continue;
-      try {
-        const input = fs.createReadStream(filePath, { encoding: 'utf-8' });
-        const rl = readline.createInterface({ input, crlfDelay: Infinity });
-
-        for await (const line of rl) {
-          if (!line.includes('"tool_')) continue;
-
-          if (line.includes('"tool_use"')) {
-            try {
-              var raw = JSON.parse(line);
-              var content = raw.message && raw.message.content;
-              if (!Array.isArray(content)) continue;
-              for (var block of content) {
-                if (block.type !== 'tool_use' || !block.id) continue;
-                if (session.toolIndex.has(block.id)) continue;
-                session.toolIndex.set(block.id, {
-                  toolName: block.name || '',
-                  parentAgentID: agentID,
-                  hasResult: false,
-                });
-              }
-            } catch { continue; }
-          }
+    // Read all files in parallel — each scans its file independently and writes
+    // to session.toolIndex (safe under Node single-threaded event loop).
+    await Promise.all(files.map(({ path: filePath, agentID }) =>
+      this._scanFileForTools(session, filePath, agentID)
+    ));
 
-          if (line.includes('"tool_result"')) {
-            try {
-              var raw2 = JSON.parse(line);
-              var content2 = raw2.message && raw2.message.content;
-              if (!Array.isArray(content2)) continue;
-              for (var block2 of content2) {
-                if (block2.type !== 'tool_result' || !block2.tool_use_id) continue;
-                var tid = block2.tool_use_id;
-                var existing = session.toolIndex.get(tid);
-                if (existing) {
-                  existing.hasResult = true;
-                } else {
-                  session.toolIndex.set(tid, {
-                    toolName: '',
-                    parentAgentID: '',
-                    hasResult: true,
-                  });
-                }
+    session.toolIndexPopulated = true;
+  }
+
+  async _scanFileForTools(session, filePath, agentID) {
+    if (!filePath) return;
+    try {
+      const input = fs.createReadStream(filePath, { encoding: 'utf-8' });
+      const rl = readline.createInterface({ input, crlfDelay: Infinity });
+
+      for await (const line of rl) {
+        if (!line.includes('"tool_')) continue;
+
+        if (line.includes('"tool_use"')) {
+          try {
+            var raw = JSON.parse(line);
+            var content = raw.message && raw.message.content;
+            if (!Array.isArray(content)) continue;
+            for (var block of content) {
+              if (block.type !== 'tool_use' || !block.id) continue;
+              if (session.toolIndex.has(block.id)) continue;
+              session.toolIndex.set(block.id, {
+                toolName: block.name || '',
+                parentAgentID: agentID,
+                hasResult: false,
+              });
+            }
+          } catch { continue; }
+        }
+
+        if (line.includes('"tool_result"')) {
+          try {
+            var raw2 = JSON.parse(line);
+            var content2 = raw2.message && raw2.message.content;
+            if (!Array.isArray(content2)) continue;
+            for (var block2 of content2) {
+              if (block2.type !== 'tool_result' || !block2.tool_use_id) continue;
+              var tid = block2.tool_use_id;
+              var existing = session.toolIndex.get(tid);
+              if (existing) {
+                existing.hasResult = true;
+              } else {
+                session.toolIndex.set(tid, {
+                  toolName: '',
+                  parentAgentID: '',
+                  hasResult: true,
+                });
               }
-            } catch { continue; }
-          }
+            }
+          } catch { continue; }
         }
-      } catch (err) {
-        if (this.debug) console.error('[watcher] _populateToolIndex error reading', filePath + ':', err.message);
       }
+    } catch (err) {
+      if (this.debug) console.error('[watcher] _populateToolIndex error reading', filePath + ':', err.message);
     }
-    session.toolIndexPopulated = true;
   }
 
   // =========================================================================
@@ -1087,7 +1107,9 @@ class Watcher extends EventEmitter {
               rawLine = rawLine.slice(0, -1);
             }
 
-            chunkBytes += Buffer.byteLength(rawLine, 'utf-8') + nlLen;
+            // Fast path: use rawLine.length for ASCII-only lines (1 byte per char).
+            // Only call Buffer.byteLength when multi-byte characters are detected.
+            chunkBytes += (/[^\x00-\x7F]/.test(rawLine) ? Buffer.byteLength(rawLine, 'utf-8') : rawLine.length) + nlLen;
 
             if (!rawLine.trim()) continue;
 
@@ -1251,22 +1273,38 @@ class Watcher extends EventEmitter {
 
 function createWalkDir(readdirFn) {
   const walk = async (dir, callback) => {
+    let entries;
     try {
-      const entries = await readdirFn(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await walk(fullPath, callback);
-        } else {
-          let stats;
-          try { stats = await fsp.stat(fullPath); } catch { continue; }
-          callback(fullPath, stats);
-        }
-      }
+      entries = await readdirFn(dir, { withFileTypes: true });
     } catch (err) {
       if (err.code !== 'ENOENT' && err.code !== 'EACCES') {
         console.error(`[watcher] _walkDir error on ${dir}: ${err.message}`);
       }
+      return;
+    }
+
+    // Separate directories and files for parallel processing
+    const dirs = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) dirs.push(entry);
+      else files.push(entry);
+    }
+
+    // Stat all files in parallel
+    if (files.length > 0) {
+      const results = await Promise.all(files.map(async (entry) => {
+        const fullPath = path.join(dir, entry.name);
+        try { return { path: fullPath, stats: await fsp.stat(fullPath) }; } catch { return null; }
+      }));
+      for (const r of results) {
+        if (r) callback(r.path, r.stats);
+      }
+    }
+
+    // Recurse into subdirectories
+    for (const entry of dirs) {
+      await walk(path.join(dir, entry.name), callback);
     }
   };
   return walk;