@newrelic/preflight 0.0.1-pre.1 → 1.0.1

package/dist/hooks/collector-script.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+/**
+ * Hook collector script for Claude Code PreToolUse / PostToolUse / PostToolUseFailure hooks.
+ *
+ * Called by Claude Code on every tool invocation. Reads the hook JSON from stdin,
+ * extracts key fields, and appends a single JSONL line to the buffer file.
+ *
+ * Design constraints:
+ *   - <5ms execution budget — must never slow Claude Code
+ *   - No heavy imports (no shared package, no commander, no zod)
+ *   - All errors caught silently — always exits 0
+ *   - Config via env vars only (no file reads for config)
+ */
+import { readFileSync, readSync, writeFileSync, openSync, closeSync, mkdirSync, existsSync, constants as fsConstants, statSync, } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+// ---------------------------------------------------------------------------
+// Lightweight config (env vars only — no file reads)
+// ---------------------------------------------------------------------------
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+const DEFAULT_STORAGE_DIR = resolve(homedir(), '.newrelic-preflight');
+/**
+ * Resolve the per-session buffer path. Validates sessionId against
+ * /^[a-zA-Z0-9_-]{1,128}$/ so a malicious session_id can't escape the storage
+ * dir. When sessionId is missing or fails validation, falls back to
+ * `buffer-unknown.jsonl` rather than the legacy shared `buffer.jsonl` — the
+ * MCP no longer reads the shared path.
+ *
+ * `NEW_RELIC_AI_MCP_BUFFER_PATH` is honored verbatim when set (used by tests
+ * and one-off configurations) and bypasses session-scoping.
+ */
+function getBufferPath(sessionId) {
+    if (process.env.NEW_RELIC_AI_MCP_BUFFER_PATH !== undefined) {
+        return process.env.NEW_RELIC_AI_MCP_BUFFER_PATH;
+    }
+    const storageDir = process.env.NEW_RELIC_AI_MCP_STORAGE_PATH ?? DEFAULT_STORAGE_DIR;
+    const safeId = typeof sessionId === 'string' && SESSION_ID_RE.test(sessionId) ? sessionId : 'unknown';
+    return resolve(storageDir, `buffer-${safeId}.jsonl`);
+}
+// Cache only the file-read result to avoid repeated disk I/O on the hot path
+// (<5ms budget per hook invocation) while keeping the env-var check dynamic
+// so runtime changes in tests (and future dynamic config) are respected.
+// This also eliminates the TOCTOU window between existsSync and readFileSync.
+const HIGH_SECURITY_FROM_FILE = (() => {
+    // Check new path first; fall back to legacy path during the migration window
+    // (between upgrade and first server startup that runs migrateStoragePath).
+    for (const dir of ['.newrelic-preflight', '.nr-ai-observe']) {
+        try {
+            const configPath = resolve(homedir(), dir, 'config.json');
+            if (existsSync(configPath)) {
+                const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+                return config.highSecurity === true;
+            }
+        }
+        catch {
+            // Silently ignore config read errors
+        }
+    }
+    return false;
+})();
+function getHighSecurity() {
+    // Accept both names — NEW_RELIC_AI_HIGH_SECURITY matches config.ts (preferred);
+    // NEW_RELIC_AI_MCP_HIGH_SECURITY is the legacy collector-only name.
+    return (process.env.NEW_RELIC_AI_HIGH_SECURITY === 'true' ||
+        process.env.NEW_RELIC_AI_MCP_HIGH_SECURITY === 'true' ||
+        HIGH_SECURITY_FROM_FILE);
+}
+function getRecordContent() {
+    const highSecurity = getHighSecurity();
+    if (highSecurity)
+        return false;
+    return process.env.NEW_RELIC_AI_MCP_RECORD_CONTENT === 'true';
+}
+function getMaxContentLength() {
+    const val = process.env.NEW_RELIC_AI_MCP_MAX_CONTENT_LENGTH;
+    if (val === undefined)
+        return 10_240;
+    const parsed = parseInt(val, 10);
+    return Number.isNaN(parsed) ? 10_240 : parsed;
+}
+// ---------------------------------------------------------------------------
+// Inline redaction (mirrors config.ts DEFAULT_REDACTION_PATTERNS)
+// ---------------------------------------------------------------------------
+const REDACTION_PATTERNS = [
+    /(?<![a-zA-Z])(?:API_KEY|SECRET|TOKEN|PASSWORD|PASSPHRASE|PRIVATE_KEY)(?![a-zA-Z])[\s]*[=:]\s*\S+/gi,
+    /(?:sk-|ghp_|gho_|ghs_|github_pat_|xoxb-|xoxp-|Bearer\s+)[A-Za-z0-9_-]{20,200}/g,
+    /-----BEGIN[^-\n]{0,100}-----[A-Za-z0-9+/=\r\n. ]{0,65536}-----END[^-\n]{0,100}-----/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bAIzaSy[0-9A-Za-z_-]{33}\b/g,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+    /\bnpm_[A-Za-z0-9]{36}\b/g,
+    /\bxox[a-z]-[0-9A-Za-z-]+/g,
+];
+const MAX_REDACT_BYTES = 1_048_576; // 1 MB
+function redact(value) {
+    // Truncate by byte count, not character count — 4-byte emoji chars would otherwise
+    // allow up to 4 MB of content through the regex pass.
+    let result = value;
+    if (Buffer.byteLength(value, 'utf8') > MAX_REDACT_BYTES) {
+        const buf = Buffer.from(value, 'utf8').subarray(0, MAX_REDACT_BYTES);
+        result = buf.toString('utf8').replace(/�$/, ''); // drop any partial surrogate at cut point
+    }
+    for (const pattern of REDACTION_PATTERNS) {
+        const re = new RegExp(pattern.source, pattern.flags);
+        result = result.replace(re, '[REDACTED]');
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function hashInput(input) {
+    const str = JSON.stringify(input) ?? '';
+    return createHash('sha256').update(str).digest('hex').slice(0, 16);
+}
+function sizeOf(value) {
+    if (value === undefined || value === null)
+        return 0;
+    if (typeof value === 'string')
+        return value.length;
+    try {
+        return JSON.stringify(value).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function truncate(value, maxLen) {
+    if (value.length <= maxLen)
+        return value;
+    return value.slice(0, maxLen) + '...[truncated]';
+}
+function countLines(text) {
+    if (text === '')
+        return 0;
+    return (text.match(/\n/g) || []).length + 1;
+}
+// ---------------------------------------------------------------------------
+// Transcript token collection
+// ---------------------------------------------------------------------------
+const TRANSCRIPT_TAIL_BYTES = 16_384;
+const DEFAULT_MODEL = 'claude-opus-4-6';
+function getClaudeHome() {
+    return process.env.NR_AI_OBSERVE_CLAUDE_HOME ?? resolve(homedir(), '.claude');
+}
+function getTranscriptPath(cwd, sessionId) {
+    if (!sessionId)
+        return null;
+    const projectDir = cwd ? cwd.replace(/\//g, '-') : process.env.PWD?.replace(/\//g, '-');
+    if (!projectDir)
+        return null;
+    return resolve(getClaudeHome(), 'projects', projectDir, `${sessionId}.jsonl`);
+}
+function readLastAssistantUsage(transcriptPath) {
+    try {
+        const stat = statSync(transcriptPath);
+        if (stat.size === 0)
+            return null;
+        const fd = openSync(transcriptPath, fsConstants.O_RDONLY);
+        try {
+            const readSize = Math.min(stat.size, TRANSCRIPT_TAIL_BYTES);
+            const buffer = Buffer.alloc(readSize);
+            const bytesRead = readSync(fd, buffer, 0, readSize, stat.size - readSize);
+            const tail = buffer.toString('utf-8', 0, bytesRead);
+            const lines = tail.split('\n').filter(Boolean);
+            for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                    const entry = JSON.parse(lines[i]);
+                    if (entry.type === 'assistant' && entry.message && typeof entry.message === 'object') {
+                        const msg = entry.message;
+                        // Skip synthetic entries (Claude Code's internal injections —
+                        // compaction summaries, system messages). They carry model:
+                        // '<synthetic>' which doesn't match any pricing table entry.
+                        if (msg.model === '<synthetic>')
+                            continue;
+                        if (msg.usage && typeof msg.usage === 'object') {
+                            const usage = { ...msg.usage };
+                            if (typeof msg.model === 'string' && msg.model.length > 0) {
+                                usage.model = msg.model;
+                            }
+                            return usage;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        // Silently ignore — transcript may not exist yet
+    }
+    return null;
+}
+function getLastTranscriptSize(sessionId) {
+    if (!SESSION_ID_RE.test(sessionId))
+        return 0;
+    try {
+        const bufferDir = dirname(getBufferPath(sessionId));
+        const statePath = resolve(bufferDir, `.transcript-pos-${sessionId}`);
+        if (existsSync(statePath)) {
+            return parseInt(readFileSync(statePath, 'utf-8').trim(), 10) || 0;
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return 0;
+}
+let _transcriptSizeWriteFailed = false;
+function setLastTranscriptSize(sessionId, size) {
+    if (!SESSION_ID_RE.test(sessionId))
+        return;
+    try {
+        const bufferDir = dirname(getBufferPath(sessionId));
+        if (!existsSync(bufferDir)) {
+            mkdirSync(bufferDir, { recursive: true, mode: 0o700 });
+        }
+        const statePath = resolve(bufferDir, `.transcript-pos-${sessionId}`);
+        writeFileSync(statePath, String(size), { mode: 0o600 });
+        _transcriptSizeWriteFailed = false;
+    }
+    catch (err) {
+        if (!_transcriptSizeWriteFailed) {
+            process.stderr.write(`[preflight-collector] Warning: cannot persist transcript size: ${String(err)}\n`);
+            _transcriptSizeWriteFailed = true;
+        }
+    }
+}
+function collectTranscriptTokens(data) {
+    const sessionId = data.session_id;
+    // Prefer Claude Code's own transcript_path field — it's authoritative and
+    // works under git worktrees, where deriving the path from cwd produces a
+    // dashed directory that doesn't match the parent project's transcript dir.
+    const transcriptPath = typeof data.transcript_path === 'string' && data.transcript_path.length > 0
+        ? data.transcript_path
+        : getTranscriptPath(data.cwd, sessionId);
+    if (!transcriptPath || !sessionId)
+        return;
+    let currentSize;
+    try {
+        currentSize = statSync(transcriptPath).size;
+    }
+    catch {
+        return;
+    }
+    let lastSize = getLastTranscriptSize(sessionId);
+    if (currentSize < lastSize) {
+        // Transcript file was rotated — reset tracking so we read from offset 0
+        setLastTranscriptSize(sessionId, 0);
+        lastSize = 0;
+    }
+    if (currentSize <= lastSize)
+        return;
+    const usage = readLastAssistantUsage(transcriptPath);
+    if (!usage)
+        return;
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    if (inputTokens === 0 && outputTokens === 0)
+        return;
+    const tokenEvent = {
+        mode: 'token',
+        timestamp: Date.now(),
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+        cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+        model: usage.model ?? DEFAULT_MODEL,
+    };
+    tokenEvent.sessionId = sessionId;
+    try {
+        const bufferPath = getBufferPath(sessionId);
+        const bufferDir = dirname(bufferPath);
+        if (!existsSync(bufferDir)) {
+            mkdirSync(bufferDir, { recursive: true, mode: 0o700 });
+        }
+        const line = JSON.stringify(tokenEvent) + '\n';
+        const fd = openSync(bufferPath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_APPEND, 0o600);
+        try {
+            writeFileSync(fd, line);
+        }
+        finally {
+            closeSync(fd);
+        }
+        // Persist the new size only after a successful buffer write so that a
+        // write failure doesn't silently drop the token event on the next invocation.
+        setLastTranscriptSize(sessionId, currentSize);
+    }
+    catch {
+        // Silent failure — never block Claude Code
+    }
+}
+// ---------------------------------------------------------------------------
+// PPID breadcrumb — lets the MCP server learn the Claude Code session_id
+//
+// Claude Code spawns its MCP server and hook collector scripts as children of
+// the same process; they share a PPID. The MCP can read its own process.ppid
+// (= Claude Code's PID) and look up the matching session_id here.
+//
+// Hot-path: every PreToolUse / PostToolUse hook runs this. The
+// existsSync + content-equality short-circuit makes the steady state a single
+// stat() and one read — well under the <5ms budget.
+// ---------------------------------------------------------------------------
+let _breadcrumbWriteFailed = false;
+function writePpidBreadcrumb(sessionId) {
+    if (!SESSION_ID_RE.test(sessionId))
+        return;
+    // process.ppid is undefined on a few exotic platforms; bail without writing.
+    const ppid = process.ppid;
+    if (typeof ppid !== 'number' || ppid <= 0)
+        return;
+    try {
+        const storageDir = process.env.NEW_RELIC_AI_MCP_STORAGE_PATH ?? DEFAULT_STORAGE_DIR;
+        const breadcrumbDir = resolve(storageDir, 'session-by-ppid');
+        const breadcrumbPath = resolve(breadcrumbDir, `${ppid}.txt`);
+        // Steady-state short-circuit: most hook fires after the first one are
+        // no-ops because the breadcrumb already contains the right session_id.
+        if (existsSync(breadcrumbPath)) {
+            try {
+                if (readFileSync(breadcrumbPath, 'utf-8').trim() === sessionId)
+                    return;
+            }
+            catch {
+                // Fall through and rewrite if the read failed for any reason
+            }
+        }
+        mkdirSync(breadcrumbDir, { recursive: true, mode: 0o700 });
+        writeFileSync(breadcrumbPath, sessionId, { mode: 0o600 });
+        _breadcrumbWriteFailed = false;
+    }
+    catch (err) {
+        if (!_breadcrumbWriteFailed) {
+            process.stderr.write(`[preflight-collector] Warning: cannot write PPID breadcrumb: ${String(err)}\n`);
+            _breadcrumbWriteFailed = true;
+        }
+    }
+}
+/**
+ * Extract only the metadata fields from tool_input that the tool-specific
+ * parsers need. Full content strings are replaced with their lengths to
+ * avoid writing sensitive data to the JSONL buffer on disk.
+ */
+function extractInputMeta(toolName, input) {
+    if (input === null || input === undefined || typeof input !== 'object')
+        return undefined;
+    const obj = input;
+    const meta = {};
+    // Common field: file_path (Read, Write, Edit)
+    if (typeof obj.file_path === 'string')
+        meta.file_path = obj.file_path;
+    switch (toolName) {
+        case 'Read':
+            if (typeof obj.offset === 'number')
+                meta.offset = obj.offset;
+            if (typeof obj.limit === 'number')
+                meta.limit = obj.limit;
+            break;
+        case 'Write':
+            if (typeof obj.content === 'string') {
+                meta.contentLength = obj.content.length;
+                meta.lineCount = obj.content.length > 0 ? countLines(obj.content) : 0;
+            }
+            break;
+        case 'Edit':
+            if (typeof obj.old_string === 'string') {
+                meta.oldStringLength = obj.old_string.length;
+                meta.oldLineCount = obj.old_string.length > 0 ? countLines(obj.old_string) : 0;
+            }
+            if (typeof obj.new_string === 'string') {
+                meta.newStringLength = obj.new_string.length;
+                meta.newLineCount = obj.new_string.length > 0 ? countLines(obj.new_string) : 0;
+                meta.isDelete = obj.new_string.length === 0;
+            }
+            if (typeof obj.replace_all === 'boolean')
+                meta.replace_all = obj.replace_all;
+            break;
+        case 'Bash':
+            if (typeof obj.command === 'string')
+                meta.command = redact(obj.command);
+            if (typeof obj.description === 'string')
+                meta.description = redact(obj.description);
+            if (typeof obj.timeout === 'number')
+                meta.timeout = obj.timeout;
+            if (typeof obj.run_in_background === 'boolean')
+                meta.run_in_background = obj.run_in_background;
+            break;
+        case 'Grep':
+            if (typeof obj.pattern === 'string')
+                meta.pattern = obj.pattern;
+            if (typeof obj.path === 'string')
+                meta.path = obj.path;
+            if (typeof obj.output_mode === 'string')
+                meta.output_mode = obj.output_mode;
+            break;
+        case 'Glob':
+            if (typeof obj.pattern === 'string')
+                meta.pattern = obj.pattern;
+            if (typeof obj.path === 'string')
+                meta.path = obj.path;
+            break;
+        case 'Agent':
+            if (typeof obj.description === 'string')
+                meta.description = obj.description;
+            if (typeof obj.subagent_type === 'string')
+                meta.subagent_type = obj.subagent_type;
+            if (typeof obj.prompt === 'string')
+                meta.promptLength = obj.prompt.length;
+            if (typeof obj.run_in_background === 'boolean')
+                meta.run_in_background = obj.run_in_background;
+            if (typeof obj.name === 'string')
+                meta.name = obj.name;
+            if (typeof obj.team_name === 'string')
+                meta.team_name = obj.team_name;
+            if (typeof obj.isolation === 'string')
+                meta.isolation = obj.isolation;
+            if (typeof obj.model === 'string')
+                meta.model = obj.model;
+            break;
+        case 'AskUserQuestion':
+            if (Array.isArray(obj.questions))
+                meta.questions = new Array(obj.questions.length);
+            break;
+        case 'TaskCreate':
+            if (typeof obj.subject === 'string')
+                meta.subject = obj.subject;
+            break;
+        case 'TaskUpdate':
+            if (typeof obj.taskId === 'string')
+                meta.taskId = obj.taskId;
+            if (typeof obj.status === 'string')
+                meta.status = obj.status;
+            if (typeof obj.subject === 'string')
+                meta.subject = obj.subject;
+            break;
+    }
+    return Object.keys(meta).length > 0 ? meta : undefined;
+}
+/**
+ * Extract only the metadata fields from tool_response that the tool-specific
+ * parsers need.
+ */
+function extractOutputMeta(toolName, output) {
+    if (output === null || output === undefined || typeof output !== 'object')
+        return undefined;
+    const obj = output;
+    if (toolName === 'Bash') {
+        if (typeof obj.exitCode === 'number') {
+            return { exitCode: obj.exitCode };
+        }
+        if (typeof obj.exitCode === 'string') {
+            const parsed = Number(obj.exitCode);
+            if (!Number.isNaN(parsed))
+                return { exitCode: parsed };
+        }
+    }
+    if (toolName === 'Edit') {
+        const meta = {};
+        if (typeof obj.success === 'boolean')
+            meta.editSuccess = obj.success;
+        if (typeof obj.error === 'string')
+            meta.editError = obj.error.slice(0, 200);
+        if (typeof obj.matched === 'boolean')
+            meta.editMatched = obj.matched;
+        return Object.keys(meta).length > 0 ? meta : undefined;
+    }
+    if (toolName === 'Grep') {
+        const meta = {};
+        if (typeof obj.matchCount === 'number')
+            meta.grepMatchCount = obj.matchCount;
+        else if (Array.isArray(obj.matches))
+            meta.grepMatchCount = obj.matches.length;
+        else if (Array.isArray(obj.results))
+            meta.grepMatchCount = obj.results.length;
+        if (Array.isArray(obj.content)) {
+            let lineCount = 0;
+            for (const block of obj.content) {
+                if (block &&
+                    typeof block === 'object' &&
+                    'text' in block &&
+                    typeof block.text === 'string') {
+                    lineCount += block.text.split('\n').length;
+                }
+            }
+            if (lineCount > 0)
+                meta.grepResultLines = lineCount;
+        }
+        return Object.keys(meta).length > 0 ? meta : undefined;
+    }
+    if (toolName === 'Agent') {
+        const meta = {};
+        if (typeof obj.completed === 'boolean')
+            meta.agentCompleted = obj.completed;
+        if (typeof obj.interrupted === 'boolean')
+            meta.agentInterrupted = obj.interrupted;
+        if (typeof obj.result === 'string')
+            meta.agentResultLength = obj.result.length;
+        else if (typeof obj.message === 'string')
+            meta.agentResultLength = obj.message.length;
+        else if (Array.isArray(obj.content)) {
+            let totalLen = 0;
+            for (const block of obj.content) {
+                if (block &&
+                    typeof block === 'object' &&
+                    'text' in block &&
+                    typeof block.text === 'string') {
+                    totalLen += block.text.length;
+                }
+            }
+            if (totalLen > 0)
+                meta.agentResultLength = totalLen;
+        }
+        return Object.keys(meta).length > 0 ? meta : undefined;
+    }
+    return undefined;
+}
+function processHook(raw) {
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return; // Malformed JSON — skip silently
+    }
+    // Drop a PPID breadcrumb at the very top so the MCP server can resolve its
+    // Claude Code session_id without an env-var or initialize-payload extension.
+    // The function itself is a no-op when sessionId is missing or invalid, and
+    // short-circuits if the breadcrumb is already current.
+    if (typeof data.session_id === 'string' && data.session_id.length > 0) {
+        writePpidBreadcrumb(data.session_id);
+    }
+    const eventName = data.hook_event_name;
+    const toolName = data.tool_name ?? 'unknown';
+    const timestamp = Date.now();
+    const recordContent = getRecordContent();
+    const maxContentLen = getMaxContentLength();
+    let event;
+    if (eventName === 'PreToolUse') {
+        event = {
+            mode: 'pre',
+            tool: toolName,
+            timestamp,
+            inputSize: sizeOf(data.tool_input),
+            inputHash: hashInput(data.tool_input),
+        };
+        // Store only the metadata fields needed for tool-specific parsing
+        const inputMeta = extractInputMeta(toolName, data.tool_input);
+        if (inputMeta !== undefined)
+            event.toolInput = inputMeta;
+        if (recordContent && data.tool_input !== undefined) {
+            const content = typeof data.tool_input === 'string' ? data.tool_input : JSON.stringify(data.tool_input);
+            event.inputContent = redact(truncate(content, maxContentLen));
+        }
+    }
+    else if (eventName === 'PostToolUse') {
+        event = {
+            mode: 'post',
+            tool: toolName,
+            timestamp,
+            outputSize: sizeOf(data.tool_response),
+            success: true,
+        };
+        // Store input metadata as fallback for orphaned-post pairing (pre-event may be missing)
+        const postInputMeta = extractInputMeta(toolName, data.tool_input);
+        if (postInputMeta !== undefined)
+            event.toolInput = postInputMeta;
+        // Store only the metadata fields needed for tool-specific parsing
+        const outputMeta = extractOutputMeta(toolName, data.tool_response);
+        if (outputMeta !== undefined)
+            event.toolOutput = outputMeta;
+        if (recordContent && data.tool_response !== undefined) {
+            const content = typeof data.tool_response === 'string'
+                ? data.tool_response
+                : JSON.stringify(data.tool_response);
+            event.outputContent = redact(truncate(content, maxContentLen));
+        }
+    }
+    else if (eventName === 'PostToolUseFailure') {
+        event = {
+            mode: 'post',
+            tool: toolName,
+            timestamp,
+            success: false,
+            error: redact(data.error ?? 'unknown error'),
+            isInterrupt: data.is_interrupt ?? false,
+        };
+    }
+    else {
+        // Unknown hook event — ignore silently
+        return;
+    }
+    // Attach session metadata
+    if (data.cwd)
+        event.cwd = data.cwd;
+    if (data.permission_mode)
+        event.permissionMode = data.permission_mode;
+    if (data.session_id)
+        event.sessionId = data.session_id;
+    if (data.tool_use_id)
+        event.toolUseId = data.tool_use_id;
+    // Write to buffer — wrapped in try/catch for resilience.
+    try {
+        const bufferPath = getBufferPath(data.session_id);
+        const bufferDir = dirname(bufferPath);
+        if (!existsSync(bufferDir)) {
+            mkdirSync(bufferDir, { recursive: true, mode: 0o700 });
+        }
+        const line = JSON.stringify(event) + '\n';
+        const fd = openSync(bufferPath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_APPEND, 0o600);
+        try {
+            writeFileSync(fd, line);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        // Silent failure — never block Claude Code
+    }
+    // After writing the tool event, collect token usage from the transcript.
+    // Only on PostToolUse — each assistant turn produces exactly one usage object.
+    if (eventName === 'PostToolUse') {
+        try {
+            collectTranscriptTokens(data);
+        }
+        catch {
+            // Silent failure — transcript reading is best-effort
+        }
+    }
+}
+// Exported for testing
+export { processHook, redact, hashInput, sizeOf, truncate, getRecordContent, collectTranscriptTokens, readLastAssistantUsage, getTranscriptPath, getBufferPath, writePpidBreadcrumb, };
+// ---------------------------------------------------------------------------
+// Entry point — only when run directly (not when imported by the MCP server)
+// ---------------------------------------------------------------------------
+import { realpathSync } from 'node:fs';
+const _resolvedScript = (() => {
+    try {
+        return realpathSync(process.argv[1]);
+    }
+    catch {
+        return process.argv[1];
+    }
+})();
+const _isDirectExecution = _resolvedScript != null && /collector-script\.[jt]s$/.test(_resolvedScript);
+if (_isDirectExecution) {
+    try {
+        const stdin = readFileSync('/dev/stdin', 'utf-8');
+        if (stdin.trim()) {
+            processHook(stdin);
+        }
+    }
+    catch {
+        // Silent failure — never block Claude Code
+    }
+}
+//# sourceMappingURL=collector-script.js.map