npm - noctrace - Versions diffs - 0.7.4 → 0.8.0 - Mend

noctrace 0.7.4 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/.claude-plugin/plugin.json +7 -7
package/README.md +67 -38
package/dist/client/assets/index-DwPuae45.css +2 -0
package/dist/client/assets/index-x60cSMi2.js +30 -0
package/dist/client/index.html +2 -2
package/dist/server/server/routes/api.js +79 -4
package/dist/server/server/watcher.js +2 -1
package/dist/server/server/ws.js +1 -1
package/dist/server/shared/otlp-export.js +116 -0
package/dist/server/shared/parser.js +132 -16
package/dist/server/shared/reliability.js +186 -0
package/dist/server/shared/session-metadata.js +161 -0
package/hooks/hooks.json +33 -0
package/package.json +15 -6
package/dist/client/assets/index-BPKebIZj.js +0 -30
package/dist/client/assets/index-DyjeNSzP.css +0 -2

package/dist/client/index.html CHANGED Viewed

@@ -7,8 +7,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;600;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-BPKebIZj.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DyjeNSzP.css">
+    <script type="module" crossorigin src="/assets/index-x60cSMi2.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DwPuae45.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -7,10 +7,12 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { WebSocket } from 'ws';
 import { parseJsonlContent, parseCompactionBoundaries, extractSessionId, extractSessionTitle, extractAgentIds, parseSubAgentContent, parseInstructionsLoaded, } from '../../shared/parser.js';
+import { parseSessionResultMetrics, parseInitContext } from '../../shared/session-metadata.js';
 import { computeContextHealth } from '../../shared/health.js';
 import { parseAssistantTurns, computeDrift } from '../../shared/drift.js';
 import { attachEfficiencyTips } from '../../shared/tips.js';
 import { attachSecurityTips } from '../../shared/security-tips.js';
+import { sessionToOtlp } from '../../shared/otlp-export.js';
 /**
  * Read ~/.claude/sessions/*.json and return a Set of sessionIds
  * whose PID is still a running claude process.
@@ -222,17 +224,34 @@ export function buildApiRouter(claudeHome, wss) {
                 catch {
                     // config.json missing or malformed — include team with empty members
                 }
-                // Count task files in ~/.claude/tasks/{team-name}/
+                // Count task files and parse their contents from ~/.claude/tasks/{team-name}/
                 let taskCount = 0;
+                const tasks = [];
                 const teamTasksDir = path.join(tasksDir, teamName);
                 try {
                     const taskFiles = await fs.readdir(teamTasksDir);
                     taskCount = taskFiles.length;
+                    for (const tf of taskFiles) {
+                        if (!tf.endsWith('.json'))
+                            continue;
+                        try {
+                            const taskRaw = await fs.readFile(path.join(teamTasksDir, tf), 'utf8');
+                            const taskData = JSON.parse(taskRaw);
+                            tasks.push({
+                                id: tf.replace(/\.json$/, ''),
+                                subject: typeof taskData['subject'] === 'string' ? taskData['subject'] : tf,
+                                status: typeof taskData['status'] === 'string' ? taskData['status'] : 'pending',
+                                assignedTo: typeof taskData['assigned_to'] === 'string' ? taskData['assigned_to']
+                                    : typeof taskData['assignedTo'] === 'string' ? taskData['assignedTo'] : null,
+                            });
+                        }
+                        catch { /* skip malformed task files */ }
+                    }
                 }
                 catch {
                     // Task directory doesn't exist — taskCount stays 0
                 }
-                teams.push({ name: teamName, members, taskCount });
+                teams.push({ name: teamName, members, taskCount, tasks });
             }
             res.json(teams);
         }
@@ -382,6 +401,43 @@ export function buildApiRouter(claudeHome, wss) {
         }
     });
     // ---------------------------------------------------------------------------
+    // GET /api/session/:slug/:id/otlp (MUST be before :slug/:id to avoid param capture)
+    // ---------------------------------------------------------------------------
+    /**
+     * Export a session as OTLP/HTTP JSON trace format.
+     * The response can be POSTed directly to any OTLP collector at /v1/traces.
+     */
+    router.get('/session/:slug/:id/otlp', async (req, res) => {
+        const { slug, id } = req.params;
+        const filePath = path.join(projectsDir, slug, `${id}.jsonl`);
+        try {
+            assertWithinBase(filePath, projectsDir);
+        }
+        catch {
+            res.status(400).json({ error: 'Invalid path' });
+            return;
+        }
+        try {
+            let content;
+            try {
+                content = await fs.readFile(filePath, 'utf8');
+            }
+            catch {
+                res.status(404).json({ error: `Session not found: ${slug}/${id}` });
+                return;
+            }
+            const rows = parseJsonlContent(content);
+            const sessionId = extractSessionId(content) ?? id;
+            const otlp = sessionToOtlp(rows, sessionId);
+            res.setHeader('Content-Type', 'application/json');
+            res.json(otlp);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    // ---------------------------------------------------------------------------
     // GET /api/session/:slug/:id
     // ---------------------------------------------------------------------------
     /**
@@ -414,6 +470,8 @@ export function buildApiRouter(claudeHome, wss) {
             const turns = parseAssistantTurns(content);
             const drift = computeDrift(turns);
             const instructionsLoaded = parseInstructionsLoaded(content);
+            const resultMetrics = parseSessionResultMetrics(content);
+            const initContext = parseInitContext(content);
             // Load sub-agent JSONL files and attach as children to matching agent rows
             const subagentsDir = path.join(projectsDir, slug, id, 'subagents');
             let subagentsDirExists = false;
@@ -468,7 +526,8 @@ export function buildApiRouter(claudeHome, wss) {
                 }
             }
             // Attach efficiency tips to wasteful rows (mutates rows in place)
-            attachEfficiencyTips(rows, boundaries);
+            // tips.ts expects number[] (timestamps), so extract from CompactionBoundary[]
+            attachEfficiencyTips(rows, boundaries.map((b) => b.timestamp));
             // Attach security tips (mutates rows in place)
             attachSecurityTips(rows);
             // Count total tips across all rows (including children) for the client toolbar
@@ -476,7 +535,7 @@ export function buildApiRouter(claudeHome, wss) {
                 return r.reduce((sum, row) => sum + row.tips.length + countTips(row.children), 0);
             }
             const tipCount = countTips(rows);
-            res.json({ rows, compactionBoundaries: boundaries, health, sessionId, drift, tipCount, instructionsLoaded });
+            res.json({ rows, compactionBoundaries: boundaries, health, sessionId, drift, tipCount, instructionsLoaded, resultMetrics, initContext });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -509,6 +568,22 @@ export function buildApiRouter(claudeHome, wss) {
                 ...(typeof body['permission_mode'] === 'string' ? { permission_mode: body['permission_mode'] } : {}),
                 received_at: new Date().toISOString(),
             };
+            // For SubagentStart events, broadcast a separate message type
+            // so the client can show an in-progress agent row immediately
+            if (event.hook_event_name === 'SubagentStart' && event.agent_id) {
+                const subagentMsg = {
+                    type: 'subagent-start',
+                    agentId: event.agent_id,
+                    agentType: event.agent_type ?? null,
+                    sessionId: event.session_id,
+                };
+                const subPayload = JSON.stringify(subagentMsg);
+                for (const client of wss.clients) {
+                    if (client.readyState === WebSocket.OPEN) {
+                        client.send(subPayload);
+                    }
+                }
+            }
             const message = { type: 'hook-event', event };
             const payload = JSON.stringify(message);
             for (const client of wss.clients) {

package/dist/server/server/watcher.js CHANGED Viewed

@@ -67,7 +67,8 @@ export function watchSession(filePath, callbacks) {
             const turns = parseAssistantTurns(fullContent);
             const drift = computeDrift(turns);
             // Attach efficiency tips to wasteful rows (mutates allRows in place)
-            attachEfficiencyTips(allRows, boundaries);
+            // tips.ts expects number[] (timestamps), so extract from CompactionBoundary[]
+            attachEfficiencyTips(allRows, boundaries.map((b) => b.timestamp));
             // Attach security tips (mutates allRows in place)
             attachSecurityTips(allRows);
             callbacks.onNewRows(allRows, health, boundaries, drift);

package/dist/server/server/ws.js CHANGED Viewed

@@ -151,7 +151,7 @@ export function setupWebSocket(server, claudeHome) {
                 try {
                     const proc = spawn('claude', args, {
                         stdio: ['ignore', 'pipe', 'pipe'],
-                        env: { ...process.env },
+                        env: { PATH: process.env['PATH'] ?? '', HOME: process.env['HOME'] ?? '', CLAUDE_HOME: process.env['CLAUDE_HOME'] ?? '' },
                     });
                     resumeProc = proc;
                     // Buffer for incomplete lines from chunked TCP data

package/dist/server/shared/otlp-export.js ADDED Viewed

@@ -0,0 +1,116 @@
+/** OTLP span status code for OK */
+const STATUS_OK = 1;
+/** OTLP span status code for ERROR */
+const STATUS_ERROR = 2;
+/** Convert Unix ms timestamp to OTLP nanosecond string */
+function toNanos(ms) {
+    return (BigInt(ms) * BigInt(1_000_000)).toString();
+}
+/** Generate a 16-byte hex trace ID from session ID */
+function traceIdFromSession(sessionId) {
+    const hex = sessionId.replace(/[^a-f0-9]/gi, '');
+    return (hex + '0'.repeat(32)).slice(0, 32);
+}
+/** Generate an 8-byte hex span ID from row ID */
+function spanIdFromRow(rowId) {
+    const hex = rowId.replace(/[^a-f0-9]/gi, '');
+    return (hex + '0'.repeat(16)).slice(0, 16);
+}
+function strAttr(key, value) {
+    return { key, value: { stringValue: value } };
+}
+function intAttr(key, value) {
+    return { key, value: { intValue: String(value) } };
+}
+function boolAttr(key, value) {
+    return { key, value: { boolValue: value } };
+}
+function doubleAttr(key, value) {
+    return { key, value: { doubleValue: value } };
+}
+/** Convert a WaterfallRow to an OTLP span object */
+function rowToSpan(row, sessionId, parentSpanId) {
+    const traceId = traceIdFromSession(sessionId);
+    const spanId = spanIdFromRow(row.id);
+    const endTime = row.endTime ?? row.startTime;
+    const attributes = [
+        strAttr('tool.name', row.toolName),
+        strAttr('tool.type', row.type),
+        strAttr('tool.label', row.label),
+        strAttr('tool.status', row.status),
+        intAttr('token.input', row.inputTokens),
+        intAttr('token.output', row.outputTokens),
+        intAttr('token.delta', row.tokenDelta),
+        doubleAttr('context.fill_percent', row.contextFillPercent),
+        boolAttr('tool.is_reread', row.isReread),
+        boolAttr('tool.is_failure', row.isFailure),
+    ];
+    if (row.modelName)
+        attributes.push(strAttr('model.name', row.modelName));
+    if (row.estimatedCost != null)
+        attributes.push(doubleAttr('cost.usd', row.estimatedCost));
+    if (row.agentType)
+        attributes.push(strAttr('agent.type', row.agentType));
+    if (row.isFastMode)
+        attributes.push(boolAttr('model.fast_mode', true));
+    if (row.duration != null)
+        attributes.push(intAttr('duration_ms', row.duration));
+    const span = {
+        traceId,
+        spanId,
+        name: row.type === 'agent' ? `agent.${row.toolName}` : `tool.${row.toolName}`,
+        kind: 1, // SPAN_KIND_INTERNAL
+        startTimeUnixNano: toNanos(row.startTime),
+        endTimeUnixNano: toNanos(endTime),
+        attributes,
+        status: {
+            code: row.status === 'error' ? STATUS_ERROR : STATUS_OK,
+            ...(row.status === 'error' && row.output ? { message: row.output.slice(0, 256) } : {}),
+        },
+    };
+    if (parentSpanId) {
+        span['parentSpanId'] = parentSpanId;
+    }
+    return span;
+}
+/** Recursively flatten rows and their children into a flat array of OTLP spans */
+function flattenSpans(rows, sessionId, parentSpanId) {
+    const spans = [];
+    for (const row of rows) {
+        const spanId = spanIdFromRow(row.id);
+        spans.push(rowToSpan(row, sessionId, parentSpanId));
+        if (row.children.length > 0) {
+            spans.push(...flattenSpans(row.children, sessionId, spanId));
+        }
+    }
+    return spans;
+}
+/**
+ * Convert a noctrace session to OTLP/HTTP JSON trace export format.
+ * The output can be POSTed directly to any OTLP/HTTP collector at /v1/traces.
+ *
+ * @param rows - Parsed waterfall rows from parseJsonlContent()
+ * @param sessionId - Session UUID used to derive the OTLP trace ID
+ */
+export function sessionToOtlp(rows, sessionId) {
+    const spans = flattenSpans(rows, sessionId, null);
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: [
+                        strAttr('service.name', 'noctrace'),
+                        strAttr('service.version', '0.7.5'),
+                        strAttr('session.id', sessionId),
+                    ],
+                },
+                scopeSpans: [
+                    {
+                        scope: { name: 'noctrace', version: '0.7.5' },
+                        spans,
+                    },
+                ],
+            },
+        ],
+    };
+}

package/dist/server/shared/parser.js CHANGED Viewed

@@ -1,4 +1,6 @@
 import { getPricing, computeCost } from './token-cost.js';
+// Re-export from session-metadata (moved to reduce file size)
+export { parseCompactionBoundaries } from './session-metadata.js';
 // ---------------------------------------------------------------------------
 // Type guards and helpers
 // ---------------------------------------------------------------------------
@@ -64,7 +66,7 @@ function parseLine(line, idx) {
         return null;
     }
     const type = parsed['type'];
-    if (type !== 'assistant' && type !== 'user' && type !== 'system' && type !== 'progress')
+    if (type !== 'assistant' && type !== 'user' && type !== 'system' && type !== 'progress' && type !== 'result')
         return null;
     return parsed;
 }
@@ -105,6 +107,22 @@ function classifyStopFailure(message) {
         return 'Overloaded';
     return 'Server Error';
 }
+/**
+ * Map structured assistant.error field to a display label.
+ * Falls back to classifyStopFailure for unknown values.
+ */
+function classifyAssistantError(errorField) {
+    const map = {
+        rate_limit: 'Rate Limit',
+        billing_error: 'Billing Error',
+        authentication_failed: 'Auth Error',
+        server_error: 'Server Error',
+        invalid_request: 'Invalid Request',
+        max_output_tokens: 'Max Tokens',
+        unknown: 'Server Error',
+    };
+    return map[errorField] ?? classifyStopFailure(errorField);
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -245,6 +263,9 @@ export function parseJsonlContent(content) {
         const inputTokens = rawInputTokens + cacheCreateTokens + cacheReadTokens;
         const outputTokens = usage?.output_tokens ?? 0;
         const modelName = typeof ar.message.model === 'string' ? ar.message.model : null;
+        const isFastMode = ar.message.speed === 'fast';
+        const parentToolUseId = typeof ar.parent_tool_use_id === 'string' ? ar.parent_tool_use_id : null;
+        const sequence = typeof ar.sequence === 'number' ? ar.sequence : null;
         const contextFillPercent = 0; // recalculated after peak detection
         for (const block of ar.message.content) {
             if (!isToolUse(block))
@@ -283,6 +304,9 @@ export function parseJsonlContent(content) {
                 isReread,
                 assistantUuid: ar.uuid,
                 assistantParentUuid: ar.parentUuid,
+                sequence,
+                isFastMode,
+                parentToolUseId,
             });
         }
     }
@@ -350,6 +374,9 @@ export function parseJsonlContent(content) {
             estimatedCost,
             agentType: res?.agentType ?? null,
             agentColor: res?.agentColor ?? null,
+            sequence: p.sequence,
+            isFastMode: p.isFastMode,
+            parentToolUseId: p.parentToolUseId,
         });
     }
     // Create rows from sub-agent progress records
@@ -389,6 +416,9 @@ export function parseJsonlContent(content) {
             estimatedCost: null,
             agentType: null,
             agentColor: null,
+            sequence: null,
+            isFastMode: false,
+            parentToolUseId: null,
         });
     }
     // Nest children: top-level rows use parentUuid ancestry, sub-agent rows use parentToolUseID
@@ -422,7 +452,7 @@ export function parseJsonlContent(content) {
     // Sort children by startTime within each agent
     for (const row of rowById.values()) {
         if (row.children.length > 1) {
-            row.children.sort((a, b) => a.startTime - b.startTime);
+            row.children.sort((a, b) => a.startTime !== b.startTime ? a.startTime - b.startTime : (a.sequence ?? 0) - (b.sequence ?? 0));
         }
     }
     // Stretch agent rows to span from dispatch to last child completion
@@ -510,23 +540,103 @@ export function parseJsonlContent(content) {
             estimatedCost: null,
             agentType: null,
             agentColor: null,
+            sequence: null,
+            isFastMode: false,
+            parentToolUseId: null,
         });
     }
-    return top;
-}
-/**
- * Extract Unix ms timestamps of compact_boundary system records.
- */
-export function parseCompactionBoundaries(content) {
-    const lines = content.split('\n');
-    const out = [];
-    for (let i = 0; i < lines.length; i++) {
-        const r = parseLine(lines[i], i);
-        if (r && r.type === 'system' && r.subtype === 'compact_boundary') {
-            out.push(new Date(r.timestamp).getTime());
+    // Detect API errors from typed assistant.error field (newer Claude Code versions)
+    for (const rec of records) {
+        if (rec.type !== 'assistant')
+            continue;
+        const ar = rec;
+        if (!ar.message.error)
+            continue;
+        const ts = new Date(ar.timestamp).getTime();
+        const errorClass = classifyAssistantError(ar.message.error);
+        const rowId = `api-error-asst-${ar.uuid}`;
+        // Skip if a system-record api-error already exists at this timestamp (avoid duplicates)
+        if (top.some((r) => r.type === 'api-error' && Math.abs(r.startTime - ts) < 1000))
+            continue;
+        top.push({
+            id: rowId,
+            type: 'api-error',
+            toolName: errorClass,
+            label: ar.message.error,
+            startTime: ts,
+            endTime: ts,
+            duration: 0,
+            status: 'error',
+            parentAgentId: null,
+            input: {},
+            output: ar.message.error,
+            inputTokens: 0,
+            outputTokens: 0,
+            tokenDelta: 0,
+            contextFillPercent: 0,
+            isReread: false,
+            isFailure: false,
+            children: [],
+            tips: [],
+            modelName: null,
+            estimatedCost: null,
+            agentType: null,
+            agentColor: null,
+            sequence: typeof ar.sequence === 'number' ? ar.sequence : null,
+            isFastMode: false,
+            parentToolUseId: null,
+        });
+    }
+    // Detect hook lifecycle events from system records
+    const hookStartMap = new Map(); // hookKey → startTime
+    for (const rec of records) {
+        if (rec.type !== 'system')
+            continue;
+        const sr = rec;
+        const subtype = sr.subtype ?? '';
+        if (subtype !== 'hook_started' && subtype !== 'hook_response')
+            continue;
+        const raw = rec;
+        const hookName = typeof raw['hook_name'] === 'string' ? raw['hook_name'] : subtype;
+        const hookId = typeof raw['hook_id'] === 'string' ? raw['hook_id'] : sr.uuid;
+        const ts = new Date(sr.timestamp).getTime();
+        if (subtype === 'hook_started') {
+            hookStartMap.set(hookId, ts);
+        }
+        else if (subtype === 'hook_response') {
+            const startTs = hookStartMap.get(hookId) ?? ts;
+            const duration = ts - startTs;
+            top.push({
+                id: `hook-${hookId}`,
+                type: 'hook',
+                toolName: hookName,
+                label: `Hook: ${hookName}`,
+                startTime: startTs,
+                endTime: ts,
+                duration,
+                status: 'success',
+                parentAgentId: null,
+                input: {},
+                output: null,
+                inputTokens: 0,
+                outputTokens: 0,
+                tokenDelta: 0,
+                contextFillPercent: 0,
+                isReread: false,
+                isFailure: false,
+                children: [],
+                tips: [],
+                modelName: null,
+                estimatedCost: null,
+                agentType: null,
+                agentColor: null,
+                sequence: typeof sr.sequence === 'number' ? sr.sequence : null,
+                isFastMode: false,
+                parentToolUseId: null,
+            });
         }
     }
-    return out;
+    return top;
 }
 /**
  * Extract the sessionId from the first valid record. Returns null if none found.
@@ -673,6 +783,9 @@ export function parseSubAgentContent(content) {
                 estimatedCost,
                 agentType: null,
                 agentColor: null,
+                sequence: null,
+                isFastMode: false,
+                parentToolUseId: null,
             });
         }
     }
@@ -717,6 +830,9 @@ export function parseSubAgentContent(content) {
             estimatedCost: null,
             agentType: null,
             agentColor: null,
+            sequence: null,
+            isFastMode: false,
+            parentToolUseId: null,
         });
     }
     // Compute per-row token delta for sub-agent rows
@@ -784,7 +900,7 @@ export function parseInstructionsLoaded(content) {
             }
         }
         // Match user records with isMeta=true that list loaded context files
-        if (recordType === 'user' && parsed['isMeta'] === true) {
+        if (recordType === 'user' && (parsed['isMeta'] === true || parsed['isSynthetic'] === true)) {
             const metaContent = parsed['content'];
             const contentStr = typeof metaContent === 'string' ? metaContent : '';
             if (!contentStr)