noctrace 1.2.0 → 1.4.0

package/dist/server/shared/providers/claude-code.js

@@ -0,0 +1,268 @@
+/**
+ * Claude Code provider implementation.
+ * Wraps the existing parseJsonlContent / parseSubAgentContent logic and the
+ * ~/.claude/projects directory structure into the Provider interface.
+ *
+ * Session id format: '<projectSlug>/<sessionId>'
+ * e.g. '-Users-lam-dev-noctrace/abc123def456'
+ *
+ * Phase A note: watch() returns a no-op unsubscribe. Real-time chokidar
+ * integration is deferred to Phase B when the server wires it up.
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import { parseJsonlContent, extractSessionId } from '../parser.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the Claude home directory.
+ * Prefers the CLAUDE_HOME environment variable, falls back to ~/.claude.
+ */
+function resolveClaudeHome(override) {
+    if (override)
+        return override;
+    return process.env['CLAUDE_HOME'] ?? path.join(os.homedir(), '.claude');
+}
+/**
+ * Convert a project directory slug back to a human-readable path.
+ * '-Users-lam-dev-noctrace' → '/Users/lam/dev/noctrace'
+ * The result is then replaced with '~' when it starts with the home directory.
+ */
+function deSlugifyProject(slug) {
+    const rawPath = slug.replace(/-/g, '/');
+    const home = os.homedir();
+    if (rawPath.startsWith(home)) {
+        return '~' + rawPath.slice(home.length);
+    }
+    return rawPath;
+}
+/**
+ * Read the mtime of a file; returns null on error.
+ */
+async function safeStatMtime(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.mtime;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+const CLAUDE_CODE_CAPABILITIES = {
+    toolCallGranularity: 'full',
+    contextTracking: true,
+    subAgents: true,
+    realtime: true,
+    tokenAccounting: 'per-turn',
+};
+/**
+ * Create a Claude Code provider instance.
+ *
+ * @param claudeHome - Override path to the Claude home directory.
+ *   Defaults to CLAUDE_HOME env var or ~/.claude.
+ */
+export function createClaudeCodeProvider(claudeHome) {
+    const home = resolveClaudeHome(claudeHome);
+    const projectsDir = path.join(home, 'projects');
+    return {
+        id: 'claude-code',
+        displayName: 'Claude Code',
+        capabilities: CLAUDE_CODE_CAPABILITIES,
+        async listSessions(window) {
+            const results = [];
+            let slugs;
+            try {
+                slugs = await fs.readdir(projectsDir);
+            }
+            catch {
+                // Projects directory doesn't exist — return empty list gracefully
+                return results;
+            }
+            for (const slug of slugs) {
+                const projectDir = path.join(projectsDir, slug);
+                let dirStat;
+                try {
+                    dirStat = await fs.stat(projectDir);
+                }
+                catch {
+                    continue;
+                }
+                if (!dirStat.isDirectory())
+                    continue;
+                let files;
+                try {
+                    files = await fs.readdir(projectDir);
+                }
+                catch {
+                    continue;
+                }
+                for (const file of files) {
+                    if (!file.endsWith('.jsonl'))
+                        continue;
+                    const sessionId = file.replace(/\.jsonl$/, '');
+                    const filePath = path.join(projectDir, file);
+                    const mtime = await safeStatMtime(filePath);
+                    if (!mtime)
+                        continue;
+                    const mtimeMs = mtime.getTime();
+                    // Filter by window: use mtime as endMs heuristic
+                    if (mtimeMs < window.startMs || mtimeMs >= window.endMs)
+                        continue;
+                    // Extract start time from first record (best-effort, fall back to mtime)
+                    let startMs = mtimeMs;
+                    try {
+                        const firstChunk = await readFirstChunk(filePath, 4096);
+                        const firstTs = extractFirstTimestamp(firstChunk);
+                        if (firstTs !== null)
+                            startMs = firstTs;
+                    }
+                    catch {
+                        // Leave startMs as mtime
+                    }
+                    results.push({
+                        provider: 'claude-code',
+                        sessionId,
+                        projectContext: deSlugifyProject(slug),
+                        rawSlug: `${slug}/${sessionId}`,
+                        startMs,
+                        endMs: mtimeMs,
+                    });
+                }
+            }
+            return results;
+        },
+        async readSession(id) {
+            // id format: '<projectSlug>/<sessionId>'
+            const slashIdx = id.indexOf('/');
+            if (slashIdx === -1) {
+                throw new Error(`Invalid Claude Code session id: "${id}". Expected "<projectSlug>/<sessionId>".`);
+            }
+            const projectSlug = id.slice(0, slashIdx);
+            const sessionId = id.slice(slashIdx + 1);
+            const filePath = path.join(projectsDir, projectSlug, `${sessionId}.jsonl`);
+            let content;
+            try {
+                content = await fs.readFile(filePath, 'utf8');
+            }
+            catch {
+                throw new Error(`Claude Code session not found: ${id}`);
+            }
+            const rows = parseJsonlContent(content);
+            const canonicalSessionId = extractSessionId(content) ?? sessionId;
+            // Extract mtime for endMs
+            const mtime = await safeStatMtime(filePath);
+            // Extract start time
+            const firstTs = extractFirstTimestamp(content.slice(0, 4096));
+            const startMs = firstTs ?? (mtime?.getTime() ?? Date.now());
+            const meta = {
+                provider: 'claude-code',
+                sessionId: canonicalSessionId,
+                projectContext: deSlugifyProject(projectSlug),
+                rawSlug: `${projectSlug}/${sessionId}`,
+                startMs,
+                endMs: mtime?.getTime() ?? null,
+            };
+            return { meta, native: rows };
+        },
+        watch(onEvent) {
+            // Phase B: real chokidar integration.
+            // Watches the projects directory for added and changed .jsonl files.
+            // Emits session-added for new files and session-updated for changed files.
+            // Uses persistent:true, ignoreInitial:true per architecture constraints.
+            let watcher = null;
+            try {
+                watcher = chokidar.watch(projectsDir, {
+                    persistent: true,
+                    ignoreInitial: true,
+                    depth: 2,
+                });
+                watcher.on('add', (filePath) => {
+                    if (!filePath.endsWith('.jsonl'))
+                        return;
+                    const relative = path.relative(projectsDir, filePath);
+                    const parts = relative.split(path.sep);
+                    if (parts.length < 2)
+                        return;
+                    const slug = parts[0];
+                    const sessionId = parts[1].replace(/\.jsonl$/, '');
+                    const id = `${slug}/${sessionId}`;
+                    onEvent({ kind: 'session-added', provider: 'claude-code', sessionId: id });
+                });
+                watcher.on('change', (filePath) => {
+                    if (!filePath.endsWith('.jsonl'))
+                        return;
+                    const relative = path.relative(projectsDir, filePath);
+                    const parts = relative.split(path.sep);
+                    if (parts.length < 2)
+                        return;
+                    const slug = parts[0];
+                    const sessionId = parts[1].replace(/\.jsonl$/, '');
+                    const id = `${slug}/${sessionId}`;
+                    onEvent({ kind: 'session-updated', provider: 'claude-code', sessionId: id });
+                });
+                watcher.on('error', (err) => {
+                    console.warn('[noctrace] claude-code provider watcher error:', err instanceof Error ? err.message : String(err));
+                });
+            }
+            catch (err) {
+                // If the projects directory doesn't exist, chokidar may throw — degrade gracefully
+                console.warn('[noctrace] claude-code provider: could not start watcher:', err instanceof Error ? err.message : String(err));
+            }
+            return () => {
+                watcher?.close().catch(() => { });
+            };
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Read the first `maxBytes` of a file as a UTF-8 string.
+ * Used for fast timestamp extraction without loading the full file.
+ */
+async function readFirstChunk(filePath, maxBytes) {
+    const fh = await fs.open(filePath, 'r');
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const { bytesRead } = await fh.read(buf, 0, maxBytes, 0);
+        return buf.slice(0, bytesRead).toString('utf8');
+    }
+    finally {
+        await fh.close();
+    }
+}
+/**
+ * Extract the Unix-ms timestamp from the first valid JSON record in a string.
+ * Returns null when no timestamp can be found.
+ */
+function extractFirstTimestamp(chunk) {
+    const lines = chunk.split('\n');
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            continue;
+        const ts = parsed['timestamp'];
+        if (typeof ts === 'string') {
+            const ms = new Date(ts).getTime();
+            if (!isNaN(ms))
+                return ms;
+        }
+    }
+    return null;
+}

package/dist/server/shared/providers/codex.js

@@ -0,0 +1,418 @@
+/**
+ * Codex CLI provider implementation.
+ * Parses OpenAI Codex CLI session JSONL rollout files into WaterfallRow[].
+ *
+ * Session id format (rawSlug): the path from the `sessions/` directory onward.
+ * e.g. '2026/04/15/rollout-2026-04-15T09-00-00-abc123.jsonl'
+ *
+ * Default home: ~/.codex  Override: CODEX_HOME env var or codexHome constructor param.
+ *
+ * Record types handled:
+ *   SessionMeta, TurnContext, EventMsg (TurnStarted, TurnComplete, TokenCount,
+ *   ExecCommandEnd), ResponseItem (FunctionCall, FunctionCallOutput, assistant message)
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import chokidar from 'chokidar';
+// ---------------------------------------------------------------------------
+// Capability descriptor
+// ---------------------------------------------------------------------------
+const CODEX_CAPABILITIES = {
+    toolCallGranularity: 'full',
+    contextTracking: true,
+    subAgents: true,
+    realtime: true,
+    tokenAccounting: 'per-turn',
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Resolve Codex home directory, respecting CODEX_HOME env var. */
+function resolveCodexHome(override) {
+    if (override)
+        return override;
+    return process.env['CODEX_HOME'] ?? path.join(os.homedir(), '.codex');
+}
+/** Read the mtime of a file; returns null on error. */
+async function safeStatMtime(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.mtime;
+    }
+    catch {
+        return null;
+    }
+}
+/** Convert cwd path to a display form, replacing home directory prefix with ~. */
+function toProjectContext(cwd) {
+    if (!cwd)
+        return 'unknown';
+    const home = os.homedir();
+    if (cwd.startsWith(home))
+        return '~' + cwd.slice(home.length);
+    return cwd;
+}
+/** Parse a single line defensively; returns null on malformed input. */
+function parseLine(line) {
+    const t = line.trim();
+    if (!t)
+        return null;
+    try {
+        const parsed = JSON.parse(t);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        console.warn('[noctrace] codex provider: skipping malformed JSONL line:', t.slice(0, 80));
+        return null;
+    }
+}
+/** Extract a nested value from an event object by key path. */
+function getEventVariant(event, key) {
+    const v = event[key];
+    if (typeof v !== 'object' || v === null)
+        return null;
+    return v;
+}
+// ---------------------------------------------------------------------------
+// Core parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse a Codex rollout JSONL string into WaterfallRow[].
+ * Skips malformed lines with console.warn — never throws.
+ */
+export function parseCodexContent(content) {
+    const lines = content.split('\n');
+    const rows = [];
+    // State for pairing and timing
+    /** Pending FunctionCall rows awaiting their FunctionCallOutput. */
+    const callMap = new Map();
+    /** All rows by call_id (including completed ones), for retroactive ExecCommandEnd patching. */
+    const rowByCallId = new Map();
+    const turnTokens = new Map();
+    let latestTurnId = null;
+    let latestTurnStartMs = 0;
+    let latestTokenData = null;
+    let sequence = 0;
+    for (const line of lines) {
+        const rec = parseLine(line);
+        if (!rec)
+            continue;
+        const recType = rec['type'];
+        const timestamp = typeof rec['timestamp'] === 'string'
+            ? new Date(rec['timestamp']).getTime()
+            : Date.now();
+        if (recType === 'EventMsg') {
+            const event = rec['event'];
+            if (typeof event !== 'object' || event === null)
+                continue;
+            const ev = event;
+            const turnStarted = getEventVariant(ev, 'TurnStarted');
+            if (turnStarted) {
+                latestTurnId = typeof turnStarted['turn_id'] === 'string' ? turnStarted['turn_id'] : null;
+                latestTurnStartMs = timestamp;
+                continue;
+            }
+            const turnComplete = getEventVariant(ev, 'TurnComplete');
+            if (turnComplete) {
+                latestTurnId = typeof turnComplete['turn_id'] === 'string' ? turnComplete['turn_id'] : latestTurnId;
+                continue;
+            }
+            const tokenCount = getEventVariant(ev, 'TokenCount');
+            if (tokenCount) {
+                const info = tokenCount['info'];
+                if (info?.total_token_usage) {
+                    const td = {
+                        inputTokens: info.total_token_usage.input_tokens,
+                        outputTokens: info.total_token_usage.output_tokens,
+                        cachedInputTokens: info.total_token_usage.cached_input_tokens,
+                        contextWindow: info.model_context_window,
+                    };
+                    latestTokenData = td;
+                    if (latestTurnId)
+                        turnTokens.set(latestTurnId, td);
+                }
+                continue;
+            }
+            const execEnd = getEventVariant(ev, 'ExecCommandEnd');
+            if (execEnd) {
+                const execData = execEnd;
+                const isFailure = execData.timed_out === true || execData.exit_code !== 0;
+                if (isFailure && execData.call_id) {
+                    // Patch the row retroactively (ExecCommandEnd may arrive after FunctionCallOutput)
+                    const target = rowByCallId.get(execData.call_id) ?? callMap.get(execData.call_id)?.row;
+                    if (target) {
+                        target.isFailure = true;
+                        target.status = 'error';
+                    }
+                }
+                continue;
+            }
+            continue;
+        }
+        if (recType === 'ResponseItem') {
+            const item = rec['item'];
+            if (typeof item !== 'object' || item === null)
+                continue;
+            const it = item;
+            // FunctionCallOutput: pairs with a pending FunctionCall
+            if (typeof it['call_id'] === 'string' && typeof it['output'] === 'string' && !it['name'] && !it['role']) {
+                const output = it;
+                const pending = callMap.get(output.call_id);
+                if (pending) {
+                    const { row } = pending;
+                    row.endTime = timestamp;
+                    row.duration = timestamp - row.startTime;
+                    row.output = output.output;
+                    row.status = 'success';
+                    callMap.delete(output.call_id);
+                    // Keep in rowByCallId so ExecCommandEnd can patch retroactively
+                    rowByCallId.set(output.call_id, row);
+                }
+                continue;
+            }
+            // FunctionCall: name + arguments + call_id
+            if (typeof it['name'] === 'string' && typeof it['call_id'] === 'string' && typeof it['arguments'] === 'string') {
+                const call = it;
+                let parsedArgs = {};
+                try {
+                    const a = JSON.parse(call.arguments);
+                    if (typeof a === 'object' && a !== null && !Array.isArray(a)) {
+                        parsedArgs = a;
+                    }
+                }
+                catch { /* leave empty */ }
+                const tokens = latestTurnId ? (turnTokens.get(latestTurnId) ?? latestTokenData) : latestTokenData;
+                const contextWindow = tokens?.contextWindow ?? 128000;
+                const fillPct = tokens ? (tokens.inputTokens / contextWindow) * 100 : 0;
+                const toolLabel = buildLabel(call.name, parsedArgs);
+                const row = {
+                    id: call.call_id,
+                    type: 'tool',
+                    toolName: call.name === 'shell' ? 'Bash' : call.name,
+                    label: toolLabel,
+                    startTime: timestamp,
+                    endTime: null,
+                    duration: null,
+                    status: 'running',
+                    parentAgentId: null,
+                    input: parsedArgs,
+                    output: null,
+                    inputTokens: tokens?.inputTokens ?? 0,
+                    outputTokens: tokens?.outputTokens ?? 0,
+                    tokenDelta: 0,
+                    contextFillPercent: fillPct,
+                    isReread: false,
+                    isFailure: false,
+                    children: [],
+                    tips: [],
+                    modelName: null,
+                    estimatedCost: null,
+                    agentType: null,
+                    agentColor: null,
+                    sequence: sequence++,
+                    isFastMode: false,
+                    parentToolUseId: null,
+                };
+                rows.push(row);
+                callMap.set(call.call_id, { row, timestamp });
+                continue;
+            }
+        }
+    }
+    // Any tool calls still in callMap have no matching output (session truncated / running)
+    // Leave them as status: 'running'
+    return rows;
+}
+/** Build a human-readable label for a tool call. */
+function buildLabel(toolName, args) {
+    const displayName = toolName === 'shell' ? 'Bash' : toolName;
+    if (toolName === 'shell') {
+        const cmd = typeof args['command'] === 'string' ? args['command'] : '';
+        const short = cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd;
+        return `Bash: ${short}`;
+    }
+    const first = Object.values(args)[0];
+    if (typeof first === 'string') {
+        const short = first.length > 60 ? first.slice(0, 57) + '...' : first;
+        return `${displayName}: ${short}`;
+    }
+    return displayName;
+}
+/** Extract the session-level metadata record from parsed lines. */
+function extractCodexSessionMeta(lines) {
+    for (const line of lines) {
+        const rec = parseLine(line);
+        if (rec?.['type'] === 'SessionMeta')
+            return rec;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// listSessions helpers
+// ---------------------------------------------------------------------------
+/** Recursively collect all .jsonl rollout files under a directory. */
+async function collectRolloutFiles(dir) {
+    const results = [];
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return results;
+    }
+    for (const name of names) {
+        const full = path.join(dir, name);
+        let stat;
+        try {
+            stat = await fs.stat(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            const sub = await collectRolloutFiles(full);
+            results.push(...sub);
+        }
+        else if (stat.isFile() && name.endsWith('.jsonl') && name.startsWith('rollout-')) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a Codex CLI provider instance.
+ *
+ * @param codexHome - Override path to the Codex home directory.
+ *   Defaults to CODEX_HOME env var or ~/.codex.
+ */
+export function createCodexProvider(codexHome) {
+    const home = resolveCodexHome(codexHome);
+    const sessionsDir = path.join(home, 'sessions');
+    return {
+        id: 'codex',
+        displayName: 'Codex CLI',
+        capabilities: CODEX_CAPABILITIES,
+        async listSessions(window) {
+            const results = [];
+            const files = await collectRolloutFiles(sessionsDir);
+            for (const filePath of files) {
+                const mtime = await safeStatMtime(filePath);
+                if (!mtime)
+                    continue;
+                const mtimeMs = mtime.getTime();
+                if (mtimeMs < window.startMs || mtimeMs >= window.endMs)
+                    continue;
+                // rawSlug: path relative to sessionsDir
+                const rawSlug = path.relative(sessionsDir, filePath).split(path.sep).join('/');
+                // Read first 2048 bytes to get SessionMeta without loading full file
+                let metaRecord = null;
+                try {
+                    const fh = await fs.open(filePath, 'r');
+                    try {
+                        const buf = Buffer.alloc(2048);
+                        const { bytesRead } = await fh.read(buf, 0, 2048, 0);
+                        const chunk = buf.slice(0, bytesRead).toString('utf8');
+                        metaRecord = extractCodexSessionMeta(chunk.split('\n'));
+                    }
+                    finally {
+                        await fh.close();
+                    }
+                }
+                catch { /* leave metaRecord as null */ }
+                const startMs = metaRecord?.timestamp
+                    ? new Date(metaRecord.timestamp).getTime()
+                    : mtimeMs;
+                const cwd = metaRecord?.cwd ?? null;
+                const sessionId = metaRecord?.id ?? rawSlug;
+                const forkedFrom = metaRecord?.forked_from_id ?? null;
+                const meta = {
+                    provider: 'codex',
+                    sessionId,
+                    projectContext: toProjectContext(cwd),
+                    rawSlug,
+                    startMs,
+                    endMs: mtimeMs,
+                    ...(metaRecord?.model_provider ? { modelHint: metaRecord.model_provider } : {}),
+                    ...(forkedFrom ? { parentSessionId: forkedFrom } : {}),
+                };
+                results.push(meta);
+            }
+            return results;
+        },
+        async readSession(id) {
+            // id is the rawSlug: relative path from sessions/, e.g. '2026/04/15/rollout-....jsonl'
+            const filePath = path.join(sessionsDir, ...id.split('/'));
+            let content;
+            try {
+                content = await fs.readFile(filePath, 'utf8');
+            }
+            catch {
+                throw new Error(`Codex session not found: ${id}`);
+            }
+            const lines = content.split('\n');
+            const metaRecord = extractCodexSessionMeta(lines);
+            const mtime = await safeStatMtime(filePath);
+            const startMs = metaRecord?.timestamp
+                ? new Date(metaRecord.timestamp).getTime()
+                : (mtime?.getTime() ?? Date.now());
+            const cwd = metaRecord?.cwd ?? null;
+            const sessionId = metaRecord?.id ?? id;
+            const forkedFrom = metaRecord?.forked_from_id ?? null;
+            const meta = {
+                provider: 'codex',
+                sessionId,
+                projectContext: toProjectContext(cwd),
+                rawSlug: id,
+                startMs,
+                endMs: mtime?.getTime() ?? null,
+                ...(metaRecord?.model_provider ? { modelHint: metaRecord.model_provider } : {}),
+                ...(forkedFrom ? { parentSessionId: forkedFrom } : {}),
+            };
+            const rows = parseCodexContent(content);
+            return { meta, native: rows };
+        },
+        watch(onEvent) {
+            let watcher = null;
+            try {
+                watcher = chokidar.watch(sessionsDir, {
+                    persistent: true,
+                    ignoreInitial: true,
+                    depth: 4,
+                });
+                watcher.on('add', (filePath) => {
+                    if (!filePath.endsWith('.jsonl'))
+                        return;
+                    const rawSlug = path.relative(sessionsDir, filePath).split(path.sep).join('/');
+                    onEvent({ kind: 'session-added', provider: 'codex', sessionId: rawSlug });
+                });
+                watcher.on('change', (filePath) => {
+                    if (!filePath.endsWith('.jsonl'))
+                        return;
+                    const rawSlug = path.relative(sessionsDir, filePath).split(path.sep).join('/');
+                    onEvent({ kind: 'session-updated', provider: 'codex', sessionId: rawSlug });
+                });
+                watcher.on('unlink', (filePath) => {
+                    if (!filePath.endsWith('.jsonl'))
+                        return;
+                    const rawSlug = path.relative(sessionsDir, filePath).split(path.sep).join('/');
+                    onEvent({ kind: 'session-removed', provider: 'codex', sessionId: rawSlug });
+                });
+                watcher.on('error', (err) => {
+                    console.warn('[noctrace] codex provider watcher error:', err instanceof Error ? err.message : String(err));
+                });
+            }
+            catch (err) {
+                console.warn('[noctrace] codex provider: could not start watcher:', err instanceof Error ? err.message : String(err));
+            }
+            return () => {
+                watcher?.close().catch(() => { });
+            };
+        },
+    };
+}