claude-code-watch 0.1.5 → 0.2.1

package/src/server/server.js

@@ -7,12 +7,35 @@ var os = require('os');
 var cp = require('child_process');
 var readline = require('readline');
 var { WebSocketServer } = require('ws');
+var { compareVersions } = require('../cli-helpers');
 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;
 
+function fetchLatestVersion() {
+  return new Promise(function(resolve, reject) {
+    var opts = {
+      hostname: 'registry.npmjs.org',
+      path: '/claude-code-watch/latest',
+      timeout: 5000,
+    };
+    var req = require('https').get(opts, function(res) {
+      if (res.statusCode !== 200) { reject(new Error('HTTP ' + res.statusCode)); return; }
+      var data = '';
+      res.on('data', function(chunk) { data += chunk; });
+      res.on('end', function() {
+        try { resolve(JSON.parse(data).version); }
+        catch (err) { reject(err); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', function() { req.destroy(); reject(new Error('timeout')); });
+    req.end();
+  });
+}
+
 var MIME = {
   '.html': 'text/html; charset=utf-8',
   '.css': 'text/css; charset=utf-8',
@@ -40,14 +63,22 @@ class DashboardServer {
     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;
     this._heartbeatTimer = null;
     this._allowedPrefix = null;
+    this.latestVersion = null;
+    this._versionCheckTimer = null;
 
     setDebugAll(options.debugAll || false);
     this.debugAll = options.debugAll || false;
@@ -114,6 +145,12 @@ class DashboardServer {
       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];
@@ -192,6 +229,7 @@ class DashboardServer {
       totals: { messages: totalMessages, input: totalInput, output: totalOutput, cacheCreation: totalCacheCreation, cacheRead: totalCacheRead, days: this.dailyStats.size },
       modelTotals,
       daily,
+      hourly: this.hourlyStats,
     };
   }
 
@@ -220,9 +258,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 {
@@ -394,7 +439,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]) => ({
@@ -405,15 +450,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,
@@ -431,7 +471,17 @@ class DashboardServer {
   }
 
   sendConfig(ws) {
-    this.send(ws, 'config', { collapseAfter: this.collapseAfterMs, version: PACKAGE_VERSION });
+    this.send(ws, 'config', { collapseAfter: this.collapseAfterMs, version: PACKAGE_VERSION, latestVersion: this.latestVersion });
+  }
+
+  _checkLatestVersion() {
+    fetchLatestVersion().then((latest) => {
+      if (compareVersions(latest, PACKAGE_VERSION) > 0) {
+        this.latestVersion = latest;
+        // Notify all connected clients
+        this.broadcast('config', { collapseAfter: this.collapseAfterMs, version: PACKAGE_VERSION, latestVersion: latest });
+      }
+    }).catch(() => { /* network unavailable, skip */ });
   }
 
   setupWatcher(watcherOpts) {
@@ -442,6 +492,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;
@@ -451,6 +504,16 @@ 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) {
@@ -462,6 +525,7 @@ class DashboardServer {
         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());
@@ -476,6 +540,7 @@ 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());
@@ -606,15 +671,18 @@ class DashboardServer {
     // This runs BEFORE watcher starts, scanning ALL files regardless of age
     console.log('  Scanning historical token data...');
     try {
-      const scannedDaily = await fullScanTokenUsage((done, total) => {
+      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
-      for (const [dateStr, day] of scannedDaily) {
+      // 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`);
@@ -637,6 +705,10 @@ class DashboardServer {
     this._contextCleanupTimer = setInterval(() => this.cleanupContextMap(), CONTEXT_STALE_MS);
     this._heartbeatTimer = setInterval(() => this.broadcast('heartbeat', null), 30000);
 
+    // Check for latest version on startup and periodically (every hour)
+    this._checkLatestVersion();
+    this._versionCheckTimer = setInterval(() => this._checkLatestVersion(), 60 * 60 * 1000);
+
     // Start listening and wait for server to be ready before opening browser
     await new Promise((resolve) => {
       this.server.listen(this.port, this.host, () => {
@@ -669,6 +741,7 @@ class DashboardServer {
   stop() {
     if (this._contextCleanupTimer) clearInterval(this._contextCleanupTimer);
     if (this._heartbeatTimer) clearInterval(this._heartbeatTimer);
+    if (this._versionCheckTimer) clearInterval(this._versionCheckTimer);
     if (this._flushTimer) {
       clearTimeout(this._flushTimer);
       this._flushTimer = null;

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;