noctrace 0.1.0 → 0.2.0

package/dist/server/server/routes/api.js

@@ -7,6 +7,45 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { parseJsonlContent, parseCompactionBoundaries, extractSessionId, extractAgentIds, parseSubAgentContent, } from '../../shared/parser';
 import { computeContextHealth } from '../../shared/health';
+/**
+ * Read ~/.claude/sessions/*.json and return a Set of sessionIds
+ * whose PID is still a running claude process.
+ * The registry sessionId matches the JSONL filename.
+ */
+async function getRunningSessionIds(claudeHome) {
+    const sessionsDir = path.join(claudeHome, 'sessions');
+    const running = new Set();
+    let files;
+    try {
+        files = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return running;
+    }
+    for (const file of files) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const raw = await fs.readFile(path.join(sessionsDir, file), 'utf8');
+            const data = JSON.parse(raw);
+            const pid = typeof data['pid'] === 'number' ? data['pid'] : null;
+            const sid = typeof data['sessionId'] === 'string' ? data['sessionId'] : null;
+            if (pid !== null && sid) {
+                try {
+                    process.kill(pid, 0);
+                    running.add(sid);
+                }
+                catch {
+                    // process not running
+                }
+            }
+        }
+        catch {
+            // skip malformed files
+        }
+    }
+    return running;
+}
 /** Build the Express router, scoped to a given Claude home directory. */
 export function buildApiRouter(claudeHome) {
     const router = Router();
@@ -29,6 +68,7 @@ export function buildApiRouter(claudeHome) {
                 res.json([]);
                 return;
             }
+            const runningSessions = await getRunningSessionIds(claudeHome);
             const projects = [];
             for (const entry of entries) {
                 const entryPath = path.join(projectsDir, entry);
@@ -63,10 +103,26 @@ export function buildApiRouter(claudeHome) {
                     }
                 }
                 const decodedPath = entry.replace(/-/g, '/');
+                // Count sessions with a live process or recent file activity
+                let activeSessionCount = 0;
+                for (const jf of jsonlFiles) {
+                    const sid = jf.replace(/\.jsonl$/, '');
+                    if (runningSessions.has(sid)) {
+                        activeSessionCount++;
+                        continue;
+                    }
+                    try {
+                        const jstat = await fs.stat(path.join(entryPath, jf));
+                        if (Date.now() - jstat.mtime.getTime() < 120_000)
+                            activeSessionCount++;
+                    }
+                    catch { /* skip */ }
+                }
                 projects.push({
                     slug: entry,
                     path: decodedPath,
                     sessionCount,
+                    activeSessionCount,
                     lastModified: latestMtime.toISOString(),
                 });
             }
@@ -97,6 +153,7 @@ export function buildApiRouter(claudeHome) {
                 res.status(404).json({ error: `Project not found: ${slug}` });
                 return;
             }
+            const runningSessions = await getRunningSessionIds(claudeHome);
             const jsonlFiles = files.filter((f) => f.endsWith('.jsonl'));
             const sessions = [];
             for (const file of jsonlFiles) {
@@ -111,27 +168,42 @@ export function buildApiRouter(claudeHome) {
                 }
                 let startTime = null;
                 let rowCount = 0;
+                let permissionMode = null;
+                let isRemoteControlled = false;
+                let isActive = false;
                 try {
                     const content = await fs.readFile(filePath, 'utf8');
-                    // Extract startTime from the first non-empty line's timestamp field
-                    const firstLine = content.split('\n').find((l) => l.trim() !== '');
-                    if (firstLine) {
+                    const lines = content.split('\n');
+                    // Extract metadata from lines (scan first 50 for speed)
+                    const scanLimit = Math.min(lines.length, 50);
+                    for (let i = 0; i < scanLimit; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
                         let parsed;
                         try {
-                            parsed = JSON.parse(firstLine);
+                            parsed = JSON.parse(line);
                         }
                         catch {
-                            // skip
+                            continue;
                         }
-                        if (typeof parsed === 'object' &&
-                            parsed !== null &&
-                            !Array.isArray(parsed) &&
-                            'timestamp' in parsed &&
-                            typeof parsed['timestamp'] === 'string') {
+                        // Extract startTime from first record with timestamp
+                        if (startTime === null && typeof parsed['timestamp'] === 'string') {
                             startTime = parsed['timestamp'];
                         }
+                        // Extract permissionMode from user records
+                        if (parsed['type'] === 'user' && 'permissionMode' in parsed && permissionMode === null) {
+                            permissionMode = parsed['permissionMode'] ?? null;
+                        }
+                        // Detect remote control from bridge_status system records
+                        if (parsed['type'] === 'system' && parsed['subtype'] === 'bridge_status') {
+                            isRemoteControlled = true;
+                        }
                     }
                     rowCount = parseJsonlContent(content).length;
+                    // Active if: live process in registry OR file modified within last 2 minutes
+                    // Registry covers CLI sessions; mtime covers Desktop app sessions
+                    isActive = runningSessions.has(id) || (Date.now() - stat.mtime.getTime() < 120_000);
                 }
                 catch {
                     // Unreadable file — still include with null startTime
@@ -143,6 +215,9 @@ export function buildApiRouter(claudeHome) {
                     startTime,
                     lastModified: stat.mtime.toISOString(),
                     rowCount,
+                    isActive,
+                    permissionMode,
+                    isRemoteControlled,
                 });
             }
             // Sort by lastModified descending (most recent first)

package/dist/server/server/ws.js

@@ -3,6 +3,7 @@
  * Mounts at /ws. One watcher per connection, cleaned up on disconnect.
  */
 import { WebSocketServer, WebSocket } from 'ws';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { watchSession } from './watcher';
 // ---------------------------------------------------------------------------
@@ -12,7 +13,8 @@ function isClientMessage(val) {
     if (typeof val !== 'object' || val === null)
         return false;
     const obj = val;
-    return obj['type'] === 'watch' || obj['type'] === 'unwatch';
+    return obj['type'] === 'watch' || obj['type'] === 'unwatch'
+        || obj['type'] === 'resume' || obj['type'] === 'resume-cancel';
 }
 function send(ws, msg) {
     if (ws.readyState === WebSocket.OPEN) {
@@ -31,12 +33,19 @@ export function setupWebSocket(server, claudeHome) {
     const wss = new WebSocketServer({ server, path: '/ws' });
     wss.on('connection', (ws, _req) => {
         let stopWatcher = null;
+        let resumeProc = null;
         const stopCurrent = () => {
             if (stopWatcher) {
                 stopWatcher();
                 stopWatcher = null;
             }
         };
+        const killResume = () => {
+            if (resumeProc) {
+                resumeProc.kill('SIGTERM');
+                resumeProc = null;
+            }
+        };
         ws.on('message', (data) => {
             let parsed;
             try {
@@ -54,6 +63,102 @@ export function setupWebSocket(server, claudeHome) {
                 stopCurrent();
                 return;
             }
+            if (parsed.type === 'resume-cancel') {
+                killResume();
+                return;
+            }
+            if (parsed.type === 'resume') {
+                killResume();
+                const { sessionId, message: userMsg, fork } = parsed;
+                if (!sessionId || !userMsg) {
+                    send(ws, { type: 'resume-error', message: 'resume requires sessionId and message' });
+                    return;
+                }
+                const args = ['--resume', sessionId, '--print', '--verbose', '--output-format', 'stream-json'];
+                if (fork)
+                    args.push('--fork-session');
+                args.push(userMsg);
+                try {
+                    const proc = spawn('claude', args, {
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        env: { ...process.env },
+                    });
+                    resumeProc = proc;
+                    // Buffer for incomplete lines from chunked TCP data
+                    let lineBuffer = '';
+                    /**
+                     * Process a complete, newline-terminated stream-json line.
+                     * Extracts assistant text chunks and ignores result-type messages
+                     * (the final result is already accumulated via chunk messages).
+                     */
+                    const processLine = (line) => {
+                        if (!line.trim())
+                            return;
+                        try {
+                            const obj = JSON.parse(line);
+                            if (obj['type'] === 'assistant') {
+                                // Extract text from message content blocks
+                                const msgContent = obj['message'];
+                                if (typeof msgContent === 'object' && msgContent !== null) {
+                                    const content = msgContent['content'];
+                                    if (Array.isArray(content)) {
+                                        for (const block of content) {
+                                            if (typeof block === 'object' && block !== null &&
+                                                block['type'] === 'text' &&
+                                                typeof block['text'] === 'string') {
+                                                send(ws, { type: 'resume-chunk', text: block['text'] });
+                                            }
+                                        }
+                                    }
+                                }
+                                else if (typeof msgContent === 'string') {
+                                    send(ws, { type: 'resume-chunk', text: msgContent });
+                                }
+                            }
+                            // 'result' type: final accumulated text — no additional chunk needed
+                            // since assistant chunks have already been streamed incrementally
+                        }
+                        catch {
+                            // Non-JSON line (e.g. debug output) — ignore silently
+                        }
+                    };
+                    proc.stdout?.on('data', (chunk) => {
+                        lineBuffer += chunk.toString();
+                        const lines = lineBuffer.split('\n');
+                        // All but the last element are complete lines; last may be partial
+                        lineBuffer = lines.pop() ?? '';
+                        for (const line of lines) {
+                            processLine(line);
+                        }
+                    });
+                    proc.stdout?.on('end', () => {
+                        // Flush any remaining buffered content
+                        if (lineBuffer.trim()) {
+                            processLine(lineBuffer);
+                            lineBuffer = '';
+                        }
+                    });
+                    proc.stderr?.on('data', (_chunk) => {
+                        // Intentionally suppress stderr — claude CLI writes progress to stderr
+                        // which would pollute the chat output with non-content noise
+                    });
+                    proc.on('close', (code) => {
+                        send(ws, { type: 'resume-done', exitCode: code });
+                        if (resumeProc === proc)
+                            resumeProc = null;
+                    });
+                    proc.on('error', (err) => {
+                        send(ws, { type: 'resume-error', message: err.message });
+                        if (resumeProc === proc)
+                            resumeProc = null;
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    send(ws, { type: 'resume-error', message: msg });
+                }
+                return;
+            }
             // Watch message
             const { slug, id } = parsed;
             if (!slug || !id) {
@@ -72,10 +177,12 @@ export function setupWebSocket(server, claudeHome) {
         });
         ws.on('close', () => {
             stopCurrent();
+            killResume();
         });
         ws.on('error', (err) => {
             console.warn('[noctrace] ws error:', err.message);
             stopCurrent();
+            killResume();
         });
     });
 }

package/dist/server/shared/parser.js

@@ -289,6 +289,7 @@ export function parseJsonlContent(content) {
             output: p.output,
             inputTokens: p.inputTokens,
             outputTokens: p.outputTokens,
+            tokenDelta: 0,
             contextFillPercent: p.contextFillPercent,
             isReread: p.isReread,
             children: [],
@@ -321,6 +322,7 @@ export function parseJsonlContent(content) {
             output: res ? res.output : null,
             inputTokens: sp.inputTokens,
             outputTokens: sp.outputTokens,
+            tokenDelta: 0,
             contextFillPercent: ctxFill,
             isReread,
             children: [],
@@ -382,6 +384,19 @@ export function parseJsonlContent(content) {
     for (const row of rowById.values()) {
         row.contextFillPercent = (row.inputTokens / effectiveWindow) * 100;
     }
+    // Compute per-row token delta from consecutive inputTokens (sorted by startTime)
+    function computeDeltas(rows) {
+        const sorted = [...rows].sort((a, b) => a.startTime - b.startTime);
+        let prev = 0;
+        for (const row of sorted) {
+            row.tokenDelta = row.inputTokens > 0 ? Math.max(0, row.inputTokens - prev) : 0;
+            if (row.inputTokens > 0)
+                prev = row.inputTokens;
+            if (row.children.length > 0)
+                computeDeltas(row.children);
+        }
+    }
+    computeDeltas(top);
     return top;
 }
 /**
@@ -493,12 +508,21 @@ export function parseSubAgentContent(content) {
                 output: res ? res.output : null,
                 inputTokens,
                 outputTokens,
+                tokenDelta: 0,
                 contextFillPercent,
                 isReread,
                 children: [],
             });
         }
     }
+    // Compute per-row token delta for sub-agent rows
+    const sorted = [...rows].sort((a, b) => a.startTime - b.startTime);
+    let prevInput = 0;
+    for (const row of sorted) {
+        row.tokenDelta = row.inputTokens > 0 ? Math.max(0, row.inputTokens - prevInput) : 0;
+        if (row.inputTokens > 0)
+            prevInput = row.inputTokens;
+    }
     return rows;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noctrace",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Chrome DevTools Network-tab-style waterfall visualizer for Claude Code agent workflows",
   "type": "module",
   "license": "MIT",