claude-code-watch 0.0.9 → 0.0.11

package/bin/claude-watch.js

@@ -7,6 +7,7 @@ const cp = require('child_process');
 
 const { startServer } = require('../src/server/server');
 const { listSessions, listActiveSessions } = require('../src/watcher/watcher');
+const { compareVersions, parseDuration } = require('../src/cli-helpers');
 
 const { version: VERSION } = require('../package.json');
 
@@ -41,14 +42,8 @@ ENVIRONMENT:
 `);
 }
 
-function compareVersions(a, b) {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    if (pa[i] > pb[i]) return 1;
-    if (pa[i] < pb[i]) return -1;
-  }
-  return 0;
+function printVersion() {
+  console.log(`claude-watch v${VERSION}`);
 }
 
 function fetchLatestVersion() {
@@ -128,19 +123,6 @@ async function runUpdate() {
   }
 }
 
-function parseDuration(s) {
-  const match = s.match(/^(\d+)(ms|s|m|h)$/);
-  if (!match) throw new Error(`Invalid duration: ${s}`);
-  const val = parseInt(match[1], 10);
-  switch (match[2]) {
-    case 'ms': return val;
-    case 's': return val * 1000;
-    case 'm': return val * 60 * 1000;
-    case 'h': return val * 3600 * 1000;
-    default: throw new Error(`Invalid duration unit: ${match[2]}`);
-  }
-}
-
 async function main() {
   const args = process.argv.slice(2);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-watch",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Web-based real-time monitor for Claude Code.",
   "main": "./src/server/server.js",
   "bin": {
@@ -10,7 +10,7 @@
   "scripts": {
     "start": "node bin/claude-watch.js",
     "dev": "node --watch bin/claude-watch.js --no-open",
-    "test": "node --test tests/all.test.js tests/watcher.test.js tests/server.test.js"
+    "test": "node --test tests/all.test.js tests/watcher.test.js tests/server.test.js tests/cli.test.js"
   },
   "files": [
     "bin",

package/public/favicon.svg

@@ -0,0 +1,17 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#7c3aed"/>
+      <stop offset="100%" stop-color="#4c1d95"/>
+    </linearGradient>
+  </defs>
+  <rect width="32" height="32" rx="6" fill="url(#bg)"/>
+  <!-- Eye outline - wide almond, flatter top/bottom -->
+  <path d="M4 16 C6 11 10 9 16 9 C22 9 26 11 28 16 C26 21 22 23 16 23 C10 23 6 21 4 16Z" fill="#1f2937" stroke="#c084fc" stroke-width="2"/>
+  <!-- Iris - horizontal ellipse -->
+  <ellipse cx="16" cy="16" rx="6" ry="4.5" fill="#a855f7" stroke="#e9d5ff" stroke-width="1.5"/>
+  <!-- Pupil -->
+  <ellipse cx="16" cy="16" rx="2.5" ry="2" fill="#0f0a1a"/>
+  <!-- Shine -->
+  <circle cx="14" cy="14.5" r="1.2" fill="#f9fafb"/>
+</svg>

package/public/index.html

@@ -4,6 +4,7 @@
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>claude-watch</title>
+<link rel="icon" type="image/svg+xml" href="favicon.svg">
 <link rel="stylesheet" href="vendor/github-dark.min.css">
 <style>
 *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
@@ -386,7 +387,6 @@ const MAX_ITEMS = 3000;
 const MAX_LINES = 50;
 let renderedItemCount = 0;
 let needsFullRender = true;
-  visibleDirty = true;
 
 // ══════════════════════════════════════════════════════════════════════════════
 // Markdown renderer (marked + highlight.js)
@@ -588,8 +588,8 @@ function handleNewBgTask(payload) {
 function handleSessionRemoved(payload) {
   const idx = sessions.findIndex(s => s.id === payload.sessionID);
   if (idx >= 0) {
-    const session = sessions.splice(idx, 1)[0];
-    sessions.push(session);
+    sessions.splice(idx, 1);
+    sessionsMap.delete(payload.sessionID);
   }
   updateFilters();
   rebuildNodes();
@@ -733,7 +733,7 @@ function getNodeHTML(node, idx) {
     return `<div class="tree-row${selClass ? ' selected' : ''}">
       <div class="tree-node" onclick="treeClick(${idx})" data-idx="${idx}">
         <span class="tree-prefix">${treePrefix(node)}</span>${activeDot} ${node.collapsed ? '▸' : '▾'} ${esc(displayName)}
-        ${node.collapsed && agentCount > 0 ? `(${agentCount})` : ''}
+        ${node.collapsed && agentCount > 0 ? `(${esc(String(agentCount))})` : ''}
         ${subInfo}
       </div>
       <span class="tree-actions">
@@ -1112,11 +1112,11 @@ function removeSelectedSession() {
   if (node.type === 'session') sid = node.id;
   else sid = node.sessionID;
   if (!sid) return;
-  if (!confirm(`Move session ${sid.slice(0, 12)}... to bottom?`)) return;
+  if (!confirm(`Remove session ${sid.slice(0, 12)}...?`)) return;
   const idx = sessions.findIndex(s => s.id === sid);
   if (idx >= 0) {
-    const session = sessions.splice(idx, 1)[0];
-    sessions.push(session);
+    sessions.splice(idx, 1);
+    sessionsMap.delete(sid);
   }
   sendCmd('removeSession', { sessionID: sid });
   updateFilters();

package/src/cli-helpers.js

@@ -0,0 +1,26 @@
+'use strict';
+
+function compareVersions(a, b) {
+  var pa = a.split('.').map(Number);
+  var pb = b.split('.').map(Number);
+  for (var i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function parseDuration(s) {
+  var match = s.match(/^(\d+)(ms|s|m|h)$/);
+  if (!match) throw new Error('Invalid duration: ' + s);
+  var val = parseInt(match[1], 10);
+  switch (match[2]) {
+    case 'ms': return val;
+    case 's': return val * 1000;
+    case 'm': return val * 60 * 1000;
+    case 'h': return val * 3600 * 1000;
+    default: throw new Error('Invalid duration unit: ' + match[2]);
+  }
+}
+
+module.exports = { compareVersions, parseDuration };

package/src/parser/parser.js

@@ -43,7 +43,8 @@ function setDebugAll(val) {
 
 function agentDisplayName(agentID) {
   if (!agentID) return 'Main';
-  return `Agent-${agentID.slice(0, Math.min(AgentIDDisplayLength, agentID.length))}`;
+  var id = String(agentID);
+  return 'Agent-' + id.slice(0, Math.min(AgentIDDisplayLength, id.length));
 }
 
 // ============================================================================
@@ -281,7 +282,7 @@ function diagnosticsBody(diagnostics) {
 // ============================================================================
 
 function parsePRLink(raw, timestamp) {
-  if (!raw.prNumber && !raw.prUrl) return [];
+  if (raw.prNumber == null && !raw.prUrl) return [];
   let content;
   if (raw.prRepository && raw.prUrl) {
     content = `PR #${raw.prNumber} ${raw.prRepository} \u2192 ${raw.prUrl}`;
@@ -441,8 +442,8 @@ function formatToolInput(toolName, input) {
       if (inp.path) return `${inp.pattern} in ${inp.path}`;
       return inp.pattern || '';
     case 'Grep':
-      if (inp.path) return `/${inp.pattern}/ in ${inp.path}`;
-      return `/${inp.pattern}/`;
+      if (inp.path) return `/${inp.pattern || ''}/ in ${inp.path}`;
+      return `/${inp.pattern || ''}/`;
     case 'WebFetch':
       return inp.prompt || '';
     case 'WebSearch':
@@ -493,4 +494,8 @@ module.exports = {
   contextWindowFor,
   formatTokenCount,
   AgentIDDisplayLength,
+  formatToolInput,
+  prettyToolName,
+  agentDisplayName,
+  MAX_TOOL_INPUT_LENGTH,
 };

package/src/server/server.js

@@ -93,11 +93,16 @@ class DashboardServer {
 
   broadcast(type, payload) {
     const msg = JSON.stringify({ type, payload });
+    const toRemove = [];
     for (const ws of this.clients) {
       if (ws.readyState === 1) {
-        try { ws.send(msg); } catch { this.clients.delete(ws); ws.terminate(); }
+        try { ws.send(msg); } catch { toRemove.push(ws); }
       }
     }
+    for (const ws of toRemove) {
+      this.clients.delete(ws);
+      try { ws.terminate(); } catch {}
+    }
   }
 
   sendJSON(res, data, status = 200) {
@@ -121,7 +126,7 @@ class DashboardServer {
   }
 
   async handleHTTP(req, res) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
+    const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
     const p = url.pathname;
 
     if (p === '/' || p === '/index.html') {
@@ -183,21 +188,25 @@ class DashboardServer {
       const filePath = params.get('path');
       if (!filePath) { this.sendJSON(res, { error: 'Missing path param' }, 400); return; }
       const resolved = path.resolve(filePath);
-      const allowedPrefix = path.resolve(os.homedir(), '.claude', 'projects');
-      // Resolve symlinks before prefix check to prevent symlink-based path traversal
+      // Resolve both the user-provided path AND the allowed prefix through realpath
+      // to ensure consistent comparison even if homedir contains symlinks
+      let realPath;
+      let allowedPrefix;
       try {
-        const realPath = await fs.promises.realpath(resolved);
+        const homeReal = await fs.promises.realpath(os.homedir());
+        allowedPrefix = path.join(homeReal, '.claude', 'projects');
+        realPath = await fs.promises.realpath(resolved);
         if (!realPath.startsWith(allowedPrefix)) {
           this.sendJSON(res, { error: 'Access denied' }, 403);
           return;
         }
       } catch {
-        // realpath fails for non-existent files — block them
+        // realpath fails for non-existent files or if homedir can't be resolved — block them
         this.sendJSON(res, { error: 'Access denied' }, 403);
         return;
       }
       try {
-        const content = await fs.promises.readFile(resolved, 'utf-8');
+        const content = await fs.promises.readFile(realPath, 'utf-8');
         this.sendJSON(res, { content });
       } catch (err) {
         this.sendJSON(res, { error: err.message }, 404);
@@ -239,11 +248,13 @@ class DashboardServer {
         this.broadcast('autoDiscoveryChanged', { enabled: this.watcher.isAutoDiscoveryEnabled() });
         break;
       case 'removeSession':
-        this.watcher.removeSession(cmd.sessionID);
-        this.broadcast('sessionRemoved', { sessionID: cmd.sessionID });
+        if (typeof cmd.sessionID === 'string' && cmd.sessionID) {
+          this.watcher.removeSession(cmd.sessionID);
+          this.broadcast('sessionRemoved', { sessionID: cmd.sessionID });
+        }
         break;
       case 'setSkipHistory':
-        this.watcher.setSkipHistory(cmd.skip);
+        this.watcher.setSkipHistory(cmd.skip === true);
         break;
       case 'getContext':
         this.sendContext(ws);
@@ -348,12 +359,14 @@ class DashboardServer {
       const confirmed = await askYesNo(`Port ${port} is occupied by process(es) ${pids.join(', ')}. Kill them? [y/N] `);
       if (!confirmed) {
         console.error(`Port ${port} is in use. Exiting.`);
+        this.stop();
         process.exit(1);
       }
 
+      const myPid = process.pid;
       for (const pid of pids) {
         const parsedPid = parseInt(pid, 10);
-        if (Number.isInteger(parsedPid) && parsedPid > 0) {
+        if (Number.isInteger(parsedPid) && parsedPid > 1 && parsedPid !== myPid) {
           try {
             if (process.platform === 'win32') {
               cp.execSync(`taskkill /PID ${parsedPid} /F`, { encoding: 'utf-8' });
@@ -369,7 +382,7 @@ class DashboardServer {
         await new Promise(r => setTimeout(r, 3000));
         for (const pid of pids) {
           const parsedPid = parseInt(pid, 10);
-          if (Number.isInteger(parsedPid) && parsedPid > 0) {
+          if (Number.isInteger(parsedPid) && parsedPid > 1 && parsedPid !== myPid) {
             try { process.kill(parsedPid, 0); process.kill(parsedPid, 'SIGKILL'); } catch {}
           }
         }
@@ -423,9 +436,11 @@ class DashboardServer {
     this.server.on('error', (err) => {
       if (err.code === 'EADDRINUSE') {
         console.error(`Port ${this.port} is still in use after attempting to free it. Exiting.`);
+        this.stop();
         process.exit(1);
       } else {
         console.error(`Server error: ${err.message}`);
+        this.stop();
         process.exit(1);
       }
     });
@@ -438,6 +453,7 @@ class DashboardServer {
       await w.start();
     } catch (err) {
       console.error('Watcher init error:', err.message);
+      this.stop();
       process.exit(1);
     }
 
@@ -490,6 +506,7 @@ async function startServer(options = {}) {
 }
 
 function askYesNo(prompt) {
+  if (!process.stdin.isTTY) return Promise.resolve(false);
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise(resolve => {
     rl.question(prompt, answer => {

package/src/watcher/watcher.js

@@ -456,8 +456,16 @@ class Watcher extends EventEmitter {
   }
 
   _handleFsWrite(p) {
-    const ctx = this.fileContexts.get(p);
-    if (!ctx) return;
+    let ctx = this.fileContexts.get(p);
+
+    // If fileContexts is missing (race condition during async session registration),
+    // try to infer the session context from the path
+    if (!ctx) {
+      ctx = this._inferFileContext(p);
+      if (!ctx) return;
+      // Register it so future events are found directly
+      this.fileContexts.set(p, ctx);
+    }
 
     // Debounce
     const existing = this.debounceTimers.get(p);
@@ -476,6 +484,28 @@ class Watcher extends EventEmitter {
     this.debounceTimers.set(p, timer);
   }
 
+  _inferFileContext(p) {
+    if (!p.endsWith('.jsonl')) return null;
+
+    // Subagent file: infer sessionID and agentID from path structure
+    if (p.includes('/subagents/')) {
+      const subagentsDir = path.dirname(p);
+      const sessionDir = path.dirname(subagentsDir);
+      const sessionID = path.basename(sessionDir);
+      const agentID = path.basename(p).replace(/^agent-/, '').replace(/\.jsonl$/, '');
+      const session = this.sessions.get(sessionID);
+      if (!session) return null;
+      return { sessionID, agentID };
+    }
+
+    // Main session file: infer sessionID from filename
+    const basename = path.basename(p);
+    const sessionID = basename.replace(/\.jsonl$/, '');
+    const session = this.sessions.get(sessionID);
+    if (!session) return null;
+    return { sessionID, agentID: '' };
+  }
+
   // =========================================================================
   // New session handlers
   // =========================================================================
@@ -500,6 +530,12 @@ class Watcher extends EventEmitter {
       this.emit('broadcast', 'newAgent', { sessionID: session.id, agentID, agentType });
     }
 
+    // Read initial data from the new session's files
+    if (this.useFsnotify) {
+      await this._skipToEndOfFiles(session);
+      await this._readSessionFiles(session);
+    }
+
     // Process any subagent files that arrived before the session was discovered
     const pending = this.pendingSubagents.get(session.id);
     if (pending) {
@@ -537,6 +573,13 @@ class Watcher extends EventEmitter {
 
     this._addFileWatch(p, sessionID, agentID);
     this.emit('broadcast', 'newAgent', { sessionID, agentID, agentType });
+
+    // Read initial data from the new subagent file
+    if (this.useFsnotify) {
+      const pos = await this._findPositionForLastNLines(p, KeepRecentLines);
+      this.filePositions.set(p, pos);
+      await this._readFile(p, sessionID, agentID, agentType);
+    }
   }
 
   async _handleNewToolResultFile(p) {
@@ -610,6 +653,8 @@ class Watcher extends EventEmitter {
 
       if (this.useFsnotify) {
         this._registerSessionWatches(c.session);
+        await this._skipToEndOfFiles(c.session);
+        await this._readSessionFiles(c.session);
       }
 
       this.emit('broadcast', 'newSession', { sessionID: c.session.id, projectPath: c.session.projectPath });
@@ -727,32 +772,42 @@ class Watcher extends EventEmitter {
           if (!line.includes('"tool_')) continue;
 
           if (line.includes('"tool_use"')) {
-            const idMatch = line.match(/"id"\s*:\s*"([^"]+)"/);
-            if (!idMatch) continue;
-            const tid = idMatch[1];
-            if (session.toolIndex.has(tid)) continue;
-            const nameMatch = line.match(/"name"\s*:\s*"([^"]+)"/);
-            session.toolIndex.set(tid, {
-              toolName: nameMatch ? nameMatch[1] : '',
-              parentAgentID: agentID,
-              hasResult: false,
-            });
+            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"')) {
-            const useIdMatch = line.match(/"tool_use_id"\s*:\s*"([^"]+)"/);
-            if (!useIdMatch) continue;
-            const tid = useIdMatch[1];
-            const existing = session.toolIndex.get(tid);
-            if (existing) {
-              existing.hasResult = true;
-            } else {
-              session.toolIndex.set(tid, {
-                toolName: '',
-                parentAgentID: '',
-                hasResult: true,
-              });
-            }
+            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 (err) {
@@ -914,18 +969,19 @@ class Watcher extends EventEmitter {
         newPos = pos;
         // Read in chunks to avoid large buffer allocations for big file deltas
         let carryOver = ''; // incomplete trailing line from previous chunk
+        let carryOverBytes = 0; // byte length of carryOver (to avoid re-reading it)
         const buf = Buffer.alloc(MaxReadChunk);
 
         while (true) {
           const currentStats = await handle.stat();
-          const currentPos = this.filePositions.get(filePath) || 0;
-          if (currentPos >= currentStats.size) break;
+          const readFrom = newPos + carryOverBytes;
+          if (readFrom >= currentStats.size) break;
 
-          const readLen = Math.min(MaxReadChunk, currentStats.size - currentPos);
-          const { bytesRead } = await handle.read(buf, 0, readLen, currentPos);
+          const readLen = Math.min(MaxReadChunk, currentStats.size - readFrom);
+          const { bytesRead } = await handle.read(buf, 0, readLen, readFrom);
           if (bytesRead === 0) break;
 
-          const chunk = bytesRead < readLen ? buf.toString('utf-8', 0, bytesRead) : buf.toString('utf-8');
+          const chunk = buf.toString('utf-8', 0, bytesRead);
           const combined = carryOver + chunk;
 
           // Detect CRLF from first newline in the combined text
@@ -939,9 +995,11 @@ class Watcher extends EventEmitter {
           // Save it as carryOver for the next chunk; don't process it yet.
           if (!chunk.endsWith('\n')) {
             carryOver = rawLines.pop();
+            carryOverBytes = Buffer.byteLength(carryOver, 'utf-8');
           } else {
             // chunk ends with \n — split produces a trailing empty string; clear carryOver
             carryOver = '';
+            carryOverBytes = 0;
           }
 
           let chunkBytes = 0;
@@ -1169,7 +1227,7 @@ async function _listSessionsFiltered(limit, activeWithin) {
 
   const candidates = [];
   try {
-    await _walkDirStatic(claudeDir, (filePath, stats) => {
+    await _walkDirAsync(claudeDir, (filePath, stats) => {
       if (!isMainSessionFile(filePath, stats)) return;
       if (activeWithin > 0 && (now - stats.mtimeMs) > activeWithin) return;
       candidates.push({ filePath, stats });
@@ -1196,14 +1254,13 @@ async function _listSessionsFiltered(limit, activeWithin) {
   return sessions;
 }
 
-async function _walkDirStatic(dir, callback) {
-  return _walkDirAsync(dir, callback);
-}
-
 module.exports = {
   Watcher,
   Session,
   BackgroundTask,
   listSessions,
   listActiveSessions,
+  resolveProjectPath,
+  isMainSessionFile,
+  readAgentType,
 };