@statforge/claudestat 1.3.0 → 1.5.0

package/dist/watchers/claude-code.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * claude-code.ts — WatcherAdapter para Claude Code
+ *
+ * Claude Code escribe trazas JSONL en ~/.claude/projects/{hash}/{session-id}.jsonl
+ * Cada línea "assistant" contiene usage tokens y modelo.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeCodeAdapter = void 0;
+exports.getContextWindow = getContextWindow;
+exports.getAllBlockCostsForSession = getAllBlockCostsForSession;
+exports.getSessionPrompts = getSessionPrompts;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = __importDefault(require("fs"));
+const adapter_1 = require("./adapter");
+const paths_1 = require("../paths");
+const pricing_1 = require("../pricing");
+const PROJECTS_DIR = path_1.default.join((0, paths_1.getClaudeDir)(), 'projects');
+const KNOWN_CONTEXT_WINDOWS = {
+    'claude-opus-4-6': 200000,
+    'claude-sonnet-4-6': 200000,
+    'claude-haiku-4-5': 200000,
+};
+function getContextWindow(model) {
+    return KNOWN_CONTEXT_WINDOWS[model] ?? 200000;
+}
+const fileOffsets = new Map();
+const FILE_OFFSET_TTL = 30 * 60000;
+function cleanupStaleOffsets() {
+    const now = Date.now();
+    for (const [key, entry] of fileOffsets) {
+        if (now - entry.lastAccess > FILE_OFFSET_TTL)
+            fileOffsets.delete(key);
+    }
+}
+async function processJSONL(filePath) {
+    let fileContent;
+    try {
+        fileContent = await promises_1.default.readFile(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const currentSize = Buffer.byteLength(fileContent, 'utf8');
+    const knownEntry = fileOffsets.get(filePath);
+    const knownOffset = knownEntry?.offset ?? 0;
+    if (currentSize < knownOffset)
+        fileOffsets.set(filePath, { offset: 0, lastAccess: Date.now() });
+    const totals = {
+        input_tokens: 0, output_tokens: 0,
+        cache_read: 0, cache_creation: 0, cost_usd: 0,
+        context_used: 0, context_window: 200000
+    };
+    let lastInputUsd = 0;
+    let lastOutputUsd = 0;
+    let lastInputTokens = 0;
+    let lastOutputTokens = 0;
+    let lastModel;
+    let firstTs;
+    for (const raw of fileContent.split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (obj.type !== 'assistant')
+                continue;
+            const msg = obj.message;
+            if (!msg?.usage)
+                continue;
+            const usage = msg.usage;
+            const model = msg.model ?? 'claude-sonnet-4-6';
+            if (firstTs === undefined && obj.timestamp) {
+                try {
+                    firstTs = new Date(obj.timestamp).getTime();
+                }
+                catch { /* ignore */ }
+            }
+            totals.input_tokens += usage.input_tokens ?? 0;
+            totals.output_tokens += usage.output_tokens ?? 0;
+            totals.cache_read += usage.cache_read_input_tokens ?? 0;
+            totals.cache_creation += usage.cache_creation_input_tokens ?? 0;
+            totals.cost_usd += (0, pricing_1.calcCost)(model, usage);
+            totals.context_used = (usage.input_tokens ?? 0)
+                + (usage.cache_read_input_tokens ?? 0)
+                + (usage.cache_creation_input_tokens ?? 0);
+            totals.context_window = getContextWindow(model);
+            const price = pricing_1.PRICING[model] ?? pricing_1.DEFAULT_PRICING;
+            const M = 1000000;
+            lastInputUsd = ((usage.input_tokens ?? 0) * price.input +
+                (usage.cache_read_input_tokens ?? 0) * price.cacheRead +
+                (usage.cache_creation_input_tokens ?? 0) * price.cacheCreate) / M;
+            lastOutputUsd = ((usage.output_tokens ?? 0) * price.output) / M;
+            lastInputTokens = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+            lastOutputTokens = usage.output_tokens ?? 0;
+            lastModel = model ?? lastModel;
+        }
+        catch { /* skip malformed lines */ }
+    }
+    if (lastInputUsd + lastOutputUsd > 0) {
+        totals.lastEntry = {
+            inputUsd: lastInputUsd, outputUsd: lastOutputUsd,
+            totalUsd: lastInputUsd + lastOutputUsd,
+            inputTokens: lastInputTokens, outputTokens: lastOutputTokens,
+        };
+    }
+    totals.lastModel = lastModel;
+    totals.firstTs = firstTs;
+    fileOffsets.set(filePath, { offset: currentSize, lastAccess: Date.now() });
+    return totals;
+}
+exports.claudeCodeAdapter = {
+    name: 'claude-code',
+    label: 'Claude Code',
+    get shortName() { return 'CC'; },
+    detect() {
+        try {
+            return fs_1.default.existsSync(PROJECTS_DIR);
+        }
+        catch {
+            return false;
+        }
+    },
+    getWatchPaths() {
+        return [`${PROJECTS_DIR}/**/*.jsonl`];
+    },
+    parseEvent(raw, _filePath) {
+        try {
+            const obj = JSON.parse(raw);
+            if (!obj.type || !obj.session_id)
+                return null;
+            return {
+                sessionId: obj.session_id,
+                type: obj.type,
+                toolName: obj.tool_name,
+                toolInput: obj.tool_input ? JSON.stringify(obj.tool_input) : undefined,
+                ts: obj.ts ?? obj.timestamp ?? Date.now(),
+                cwd: obj.cwd,
+            };
+        }
+        catch {
+            return null;
+        }
+    },
+    async getSessionCost(filePath) {
+        return processJSONL(filePath);
+    },
+};
+setInterval(cleanupStaleOffsets, 5 * 60000).unref();
+(0, adapter_1.registerAdapter)(exports.claudeCodeAdapter);
+// ─── Session-level utilities (used by routes/stream and routes/misc) ───────────
+const blockCostCache = new Map();
+const costCacheLocks = new Map();
+const BLOCK_COST_TTL = 5 * 60000;
+async function getAllBlockCostsForSession(sessionId) {
+    const cached = blockCostCache.get(sessionId);
+    if (cached && Date.now() - cached.ts < BLOCK_COST_TTL)
+        return cached.data;
+    if (costCacheLocks.get(sessionId))
+        return cached?.data ?? [];
+    costCacheLocks.set(sessionId, true);
+    try {
+        if (!fs_1.default.existsSync(PROJECTS_DIR))
+            return [];
+        const dirs = await promises_1.default.readdir(PROJECTS_DIR);
+        for (const dir of dirs) {
+            const dirPath = path_1.default.join(PROJECTS_DIR, dir);
+            try {
+                const stat = await promises_1.default.stat(dirPath);
+                if (!stat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const filePath = path_1.default.join(dirPath, `${sessionId}.jsonl`);
+            try {
+                await promises_1.default.access(filePath);
+            }
+            catch {
+                continue;
+            }
+            const result = [];
+            let current = null;
+            const content = await promises_1.default.readFile(filePath, 'utf8');
+            for (const raw of content.split('\n')) {
+                const line = raw.trim();
+                if (!line)
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj.type === 'human' || obj.type === 'user') {
+                        const msgContent = obj.message?.content;
+                        if (Array.isArray(msgContent) && msgContent[0]?.type === 'tool_result')
+                            continue;
+                        const text = typeof msgContent === 'string' ? msgContent
+                            : Array.isArray(msgContent)
+                                ? (msgContent.find((c) => c?.type === 'text')?.text ?? '')
+                                : '';
+                        if (text.includes('<system-reminder>') || text.includes('<command-name>'))
+                            continue;
+                        current = { inputUsd: 0, outputUsd: 0, totalUsd: 0, inputTokens: 0, outputTokens: 0 };
+                        result.push(current);
+                    }
+                    if (obj.type === 'assistant' && current) {
+                        const usage = obj.message?.usage;
+                        const model = obj.message?.model ?? 'claude-sonnet-4-6';
+                        if (!usage)
+                            continue;
+                        const price = pricing_1.PRICING[model] ?? pricing_1.DEFAULT_PRICING;
+                        const M = 1000000;
+                        const inUsd = ((usage.input_tokens ?? 0) * price.input + (usage.cache_read_input_tokens ?? 0) * price.cacheRead + (usage.cache_creation_input_tokens ?? 0) * price.cacheCreate) / M;
+                        const outUsd = ((usage.output_tokens ?? 0) * price.output) / M;
+                        const inTok = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+                        const outTok = usage.output_tokens ?? 0;
+                        current.inputUsd += inUsd;
+                        current.outputUsd += outUsd;
+                        current.totalUsd += inUsd + outUsd;
+                        current.inputTokens += inTok;
+                        current.outputTokens += outTok;
+                    }
+                }
+                catch { /* skip malformed */ }
+            }
+            const filtered = result.filter(b => b.totalUsd > 0);
+            blockCostCache.set(sessionId, { data: filtered, ts: Date.now() });
+            return filtered;
+        }
+    }
+    catch (e) {
+        console.warn('[enricher] Error calculating block costs:', e);
+    }
+    finally {
+        costCacheLocks.delete(sessionId);
+    }
+    return cached?.data ?? [];
+}
+async function getSessionPrompts(sessionId) {
+    try {
+        if (!fs_1.default.existsSync(PROJECTS_DIR))
+            return [];
+        const dirs = await promises_1.default.readdir(PROJECTS_DIR);
+        for (const dir of dirs) {
+            const dirPath = path_1.default.join(PROJECTS_DIR, dir);
+            try {
+                const stat = await promises_1.default.stat(dirPath);
+                if (!stat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const filePath = path_1.default.join(dirPath, `${sessionId}.jsonl`);
+            try {
+                await promises_1.default.access(filePath);
+            }
+            catch {
+                continue;
+            }
+            const results = [];
+            const content = await promises_1.default.readFile(filePath, 'utf8');
+            let index = 0;
+            for (const raw of content.split('\n')) {
+                const line = raw.trim();
+                if (!line)
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj.type !== 'human' && obj.type !== 'user')
+                        continue;
+                    const ts = obj.timestamp ? new Date(obj.timestamp).getTime() : 0;
+                    if (!ts || isNaN(ts))
+                        continue;
+                    const msgContent = obj.message?.content;
+                    let text = '';
+                    if (typeof msgContent === 'string')
+                        text = msgContent;
+                    else if (Array.isArray(msgContent)) {
+                        const textBlocks = msgContent.filter(c => c?.type === 'text');
+                        if (textBlocks.length === 0)
+                            continue;
+                        text = textBlocks.map((c) => c.text ?? '').join('\n').trim();
+                    }
+                    if (text.includes('<command-name>') || text.includes('<local-command-stdout>') || text.includes('<system-reminder>') || text.length === 0)
+                        continue;
+                    index++;
+                    results.push({ index, ts, text });
+                }
+                catch { /* skip */ }
+            }
+            return results;
+        }
+    }
+    catch { /* skip */ }
+    return [];
+}

package/dist/watchers/codebuff.d.ts

@@ -0,0 +1,8 @@
+/**
+ * codebuff.ts — WatcherAdapter para Codebuff (coding CLI agent)
+ *
+ * Codebuff stores traces in ~/.codebuff/logs/ as JSONL files.
+ * This is a scaffold — fill in parseEvent/getSessionCost with sample traces.
+ */
+import { type WatcherAdapter } from './adapter';
+export declare const codebuffAdapter: WatcherAdapter;

package/dist/watchers/codebuff.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * codebuff.ts — WatcherAdapter para Codebuff (coding CLI agent)
+ *
+ * Codebuff stores traces in ~/.codebuff/logs/ as JSONL files.
+ * This is a scaffold — fill in parseEvent/getSessionCost with sample traces.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codebuffAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const adapter_1 = require("./adapter");
+const CODEBUFF_DIR = path_1.default.join(os_1.default.homedir(), '.codebuff', 'logs');
+exports.codebuffAdapter = {
+    name: 'codebuff',
+    label: 'Codebuff',
+    get shortName() { return 'CB'; },
+    detect() {
+        try {
+            return fs_1.default.existsSync(CODEBUFF_DIR);
+        }
+        catch {
+            return false;
+        }
+    },
+    getWatchPaths() {
+        return [`${CODEBUFF_DIR}/**/*.jsonl`];
+    },
+    parseEvent(_raw, _filePath) {
+        // TODO: implement when Codebuff trace format is known
+        return null;
+    },
+    async getSessionCost(_filePath) {
+        // TODO: implement when Codebuff trace format is known
+        return null;
+    },
+};
+(0, adapter_1.registerAdapter)(exports.codebuffAdapter);

package/dist/watchers/codex.d.ts

@@ -0,0 +1,9 @@
+/**
+ * codex.ts — WatcherAdapter para Codex (OpenAI CLI coding agent)
+ *
+ * Codex stores traces in ~/.codex/logs/ as JSONL files.
+ * Format differs from Claude Code — this is a scaffold.
+ * Fill in parseEvent/getSessionCost once you have sample traces.
+ */
+import { type WatcherAdapter } from './adapter';
+export declare const codexAdapter: WatcherAdapter;

package/dist/watchers/codex.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * codex.ts — WatcherAdapter para Codex (OpenAI CLI coding agent)
+ *
+ * Codex stores traces in ~/.codex/logs/ as JSONL files.
+ * Format differs from Claude Code — this is a scaffold.
+ * Fill in parseEvent/getSessionCost once you have sample traces.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const adapter_1 = require("./adapter");
+const CODEX_DIR = path_1.default.join(os_1.default.homedir(), '.codex', 'logs');
+exports.codexAdapter = {
+    name: 'codex',
+    label: 'Codex',
+    get shortName() { return 'Codex'; },
+    detect() {
+        try {
+            return fs_1.default.existsSync(CODEX_DIR);
+        }
+        catch {
+            return false;
+        }
+    },
+    getWatchPaths() {
+        return [`${CODEX_DIR}/**/*.jsonl`];
+    },
+    parseEvent(_raw, _filePath) {
+        // TODO: implement when Codex trace format is known
+        return null;
+    },
+    async getSessionCost(_filePath) {
+        // TODO: implement when Codex trace format is known
+        return null;
+    },
+};
+(0, adapter_1.registerAdapter)(exports.codexAdapter);

package/dist/watchers/droid.d.ts

@@ -0,0 +1,8 @@
+/**
+ * droid.ts — WatcherAdapter para Droid (coding CLI agent)
+ *
+ * Droid stores traces in ~/.droid/logs/ as JSONL files.
+ * This is a scaffold — fill in parseEvent/getSessionCost with sample traces.
+ */
+import { type WatcherAdapter } from './adapter';
+export declare const droidAdapter: WatcherAdapter;

package/dist/watchers/droid.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * droid.ts — WatcherAdapter para Droid (coding CLI agent)
+ *
+ * Droid stores traces in ~/.droid/logs/ as JSONL files.
+ * This is a scaffold — fill in parseEvent/getSessionCost with sample traces.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.droidAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const adapter_1 = require("./adapter");
+const DROID_DIR = path_1.default.join(os_1.default.homedir(), '.droid', 'logs');
+exports.droidAdapter = {
+    name: 'droid',
+    label: 'Droid',
+    get shortName() { return 'Droid'; },
+    detect() {
+        try {
+            return fs_1.default.existsSync(DROID_DIR);
+        }
+        catch {
+            return false;
+        }
+    },
+    getWatchPaths() {
+        return [`${DROID_DIR}/**/*.jsonl`];
+    },
+    parseEvent(_raw, _filePath) {
+        // TODO: implement when Droid trace format is known
+        return null;
+    },
+    async getSessionCost(_filePath) {
+        // TODO: implement when Droid trace format is known
+        return null;
+    },
+};
+(0, adapter_1.registerAdapter)(exports.droidAdapter);

package/dist/watchers/opencode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * opencode.ts — WatcherAdapter para OpenCode
+ *
+ * OpenCode stores traces in ~/.opencode/logs/ as JSONL files.
+ * Format is similar to Claude Code but with different field names.
+ * This is a scaffold — fill in parseEvent/getSessionCost with sample traces.
+ */
+import { type WatcherAdapter } from './adapter';
+export declare const opencodeAdapter: WatcherAdapter;

package/dist/watchers/opencode.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * opencode.ts — WatcherAdapter para OpenCode
+ *
+ * OpenCode stores traces in ~/.opencode/logs/ as JSONL files.
+ * Format is similar to Claude Code but with different field names.
+ * This is a scaffold — fill in parseEvent/getSessionCost with sample traces.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const adapter_1 = require("./adapter");
+const OPENCODE_DIR = path_1.default.join(os_1.default.homedir(), '.opencode', 'logs');
+exports.opencodeAdapter = {
+    name: 'opencode',
+    label: 'OpenCode',
+    get shortName() { return 'OC'; },
+    detect() {
+        try {
+            return fs_1.default.existsSync(OPENCODE_DIR);
+        }
+        catch {
+            return false;
+        }
+    },
+    getWatchPaths() {
+        return [`${OPENCODE_DIR}/**/*.jsonl`];
+    },
+    parseEvent(_raw, _filePath) {
+        // TODO: implement when OpenCode trace format is known
+        return null;
+    },
+    async getSessionCost(_filePath) {
+        // TODO: implement when OpenCode trace format is known
+        return null;
+    },
+};
+(0, adapter_1.registerAdapter)(exports.opencodeAdapter);

package/hooks/event.js

@@ -46,18 +46,13 @@ process.stdin.on('end', () => {
         signal: AbortSignal.timeout(1500),
       })
         .then(r => r.json())
-        .catch(() => {
-          // Si el daemon no responde, loggeamos en stderr (visible en logs de Claude)
-          // pero NO bloqueamos — un fallo del daemon no debe interrumpir el trabajo
-          process.stderr.write(`[claudetrace] daemon no disponible — kill-switch desactivado\n`)
-          return { blocked: false }
-        }),
+        .catch(() => ({ blocked: false })),  // daemon no disponible → fail-open
     ])
     .then(([_, ks]) => {
       if (ks && ks.blocked) {
-        // Claude Code muestra este stderr al usuario antes de cancelar la acción
-        process.stderr.write(`\n🚫 claudetrace kill switch activado\n`)
-        process.stderr.write(`   ${ks.reason ?? 'Cuota de uso superada.'}\n\n`)
+        process.stderr.write(`\n🚫 claudestat — kill switch active\n`)
+        process.stderr.write(`   ${ks.reason ?? 'Usage quota exceeded.'}\n`)
+        process.stderr.write(`   To disable: claudestat config --kill-switch false\n\n`)
         process.exit(2)
       } else {
         process.exit(0)

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.3.0",
+  "version": "1.5.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "description": "Observability layer for Claude Code — live token tracking, cost analytics, quota guard, loop detection, and usage dashboard. The htop for Claude Code.",
   "keywords": [
     "claude-code",
@@ -54,12 +58,16 @@
   "scripts": {
     "build": "tsc && npm run build:dashboard",
     "build:dashboard": "cd dashboard && npm install && npm run build",
+    "build:bun": "bun run scripts/build-binary.ts",
+    "build:bun:all": "bun run scripts/build-binary.ts --all",
     "prepublishOnly": "npm run build",
     "prepack": "npm run build",
     "dev": "tsx src/index.ts",
     "dev:full": "tsx src/index.ts start & sleep 1 && cd dashboard && npm run dev",
     "start": "node dist/index.js",
-    "test": "node --require tsx/cjs tests/index.ts"
+    "test": "node --require tsx/cjs tests/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit --strict"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.88.0",