@statforge/claudestat 1.5.1 → 1.6.0

package/dashboard/dist/index.html

@@ -11,7 +11,7 @@
       ::-webkit-scrollbar-track { background: #161b22 }
       ::-webkit-scrollbar-thumb { background: #30363d; border-radius: 3px }
     </style>
-    <script type="module" crossorigin src="/assets/index-CB01c5lb.js"></script>
+    <script type="module" crossorigin src="/assets/index-DgbWvj42.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-lucide-Cym0q5l_.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-B_Jzs0gY.js">
   </head>

package/dist/daemon.js

@@ -66,6 +66,7 @@ const history_1 = require("./routes/history");
 const misc_1 = require("./routes/misc");
 const reports_1 = require("./routes/reports");
 const top_1 = require("./routes/top");
+const opencode_reader_1 = require("./routes/opencode-reader");
 const projects_cache_1 = require("./cache/projects-cache");
 const rate_limiter_1 = require("./middleware/rate-limiter");
 const summarizer_1 = require("./summarizer");
@@ -89,6 +90,7 @@ app.use(history_1.historyRouter);
 app.use(misc_1.miscRouter);
 app.use(reports_1.reportsRouter);
 app.use(top_1.topRouter);
+app.use(opencode_reader_1.opencodeReaderRouter);
 // ─── GET /health — necesita acceso al tamaño del pool SSE ─────────────────────
 app.get('/health', (_req, res) => {
     res.json({ status: 'ok', port: PORT, clients: (0, stream_1.getSseClientsSize)() });

package/dist/db.d.ts

@@ -72,6 +72,7 @@ export declare const dbOps: {
     getSessionEvents(sessionId: string): EventRow[];
     getSession(sessionId: string): SessionRow | undefined;
     getLatestSession(): SessionRow | undefined;
+    getLatestClaudeSession(): SessionRow | undefined;
     getAllSessions(limit?: number): SessionRow[];
     getSessionEventsRecent(sessionId: string, limit?: number): EventRow[];
     updateSessionProject(sessionId: string, projectPath: string): void;

package/dist/db.js

@@ -155,6 +155,11 @@ const stmts = {
   `),
     getLatestSession: db.prepare(`
     SELECT * FROM sessions ORDER BY last_event_at DESC LIMIT 1
+  `),
+    getLatestClaudeSession: db.prepare(`
+    SELECT * FROM sessions
+    WHERE source IS NULL OR source = 'claude-code'
+    ORDER BY last_event_at DESC LIMIT 1
   `),
     getAllSessions: db.prepare(`
     SELECT * FROM sessions ORDER BY started_at DESC LIMIT 500
@@ -515,6 +520,9 @@ exports.dbOps = {
     getLatestSession() {
         return stmts.getLatestSession.get();
     },
+    getLatestClaudeSession() {
+        return stmts.getLatestClaudeSession.get();
+    },
     getAllSessions(limit = 500) {
         return db.prepare(`SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?`).all(limit);
     },

package/dist/enricher.js

@@ -39,6 +39,7 @@ const prevContextBySession = new Map();
 let watcher = null;
 const pendingFiles = new Map();
 const fileLocks = new Map();
+const pollIntervals = [];
 // ─── Adapter lookup por filePath ───────────────────────────────────────────────
 const adapterByDir = new Map();
 function findAdapter(filePath) {
@@ -70,7 +71,6 @@ async function processFile(filePath) {
     }
 }
 // ─── Start / Stop ──────────────────────────────────────────────────────────────
-let offsetCleanupInterval = null;
 function startEnricher(onUpdate, onCompact) {
     const adapters = (0, adapter_1.getActiveAdapters)();
     if (adapters.length === 0) {
@@ -117,26 +117,35 @@ function startEnricher(onUpdate, onCompact) {
     };
     watcher.on('change', handleFile);
     watcher.on('add', handleFile);
-    offsetCleanupInterval = setInterval(() => {
-        for (const [, adapter] of adapterByDir) {
-            if (typeof adapter.constructor?.name === 'undefined') {
-                // cleanup per-adapter state if needed
+    // ─── Poll-based adapters (e.g. OpenCode SQLite) ─────────────────────────────
+    const POLL_INTERVAL_MS = 10000;
+    for (const adapter of adapters) {
+        if (!(0, adapter_1.isPollable)(adapter))
+            continue;
+        let lastPoll = Date.now();
+        const interval = setInterval(async () => {
+            const since = lastPoll;
+            lastPoll = Date.now();
+            const sessions = await adapter.pollSessions(since);
+            for (const { sessionId, cost } of sessions) {
+                onUpdate(sessionId, cost, adapter.name);
             }
-        }
-    }, 5 * 60000).unref();
+        }, POLL_INTERVAL_MS);
+        interval.unref();
+        pollIntervals.push(interval);
+    }
 }
 function stopEnricher() {
     if (watcher) {
         watcher.close();
         watcher = null;
     }
-    if (offsetCleanupInterval) {
-        clearInterval(offsetCleanupInterval);
-        offsetCleanupInterval = null;
-    }
     for (const [, timer] of pendingFiles)
         clearTimeout(timer);
     pendingFiles.clear();
+    for (const interval of pollIntervals)
+        clearInterval(interval);
+    pollIntervals.length = 0;
     prevContextBySession.clear();
     adapterByDir.clear();
     console.log('[enricher] Stopped');

package/dist/routes/events.js

@@ -197,11 +197,8 @@ exports.eventsRouter.post('/event', (req, res) => {
 const onCostUpdate = (sessionId, cost, source) => {
     // Ensure session row exists — sub-agent JSONLs arrive from the enricher without a
     // prior hook event (Claude Code does not fire hooks for sub-agent sessions).
+    db_1.dbOps.upsertSession({ id: sessionId, cwd: undefined, started_at: cost.firstTs ?? Date.now(), last_event_at: Date.now(), source });
     let sessionRow = db_1.dbOps.getSession(sessionId);
-    if (!sessionRow) {
-        db_1.dbOps.upsertSession({ id: sessionId, cwd: undefined, started_at: cost.firstTs ?? Date.now(), last_event_at: cost.firstTs ?? Date.now(), source });
-        sessionRow = db_1.dbOps.getSession(sessionId);
-    }
     // Sub-agent detection: first time we see a session, check if its firstTs falls after
     // a recent Agent PreToolUse from another session in the same CWD → tag as child.
     if (!exports.taggedSessionParents.has(sessionId) && cost.firstTs) {

package/dist/routes/misc.js

@@ -110,6 +110,13 @@ exports.miscRouter.get('/sessions', (_req, res) => {
     });
     res.json(enriched);
 });
+// ─── GET /api/session-events — todos los eventos de una sesión (sin límite) ──
+exports.miscRouter.get('/api/session-events', (req, res) => {
+    const sessionId = req.query.session_id;
+    if (!sessionId)
+        return res.status(400).json({ error: 'session_id required' });
+    res.json({ events: db_1.dbOps.getSessionEvents(sessionId) });
+});
 // ─── GET /prompts — mensajes del usuario para una sesión ─────────────────────
 exports.miscRouter.get('/prompts', async (req, res) => {
     const sessionId = req.query.session_id;
@@ -125,6 +132,33 @@ exports.miscRouter.get('/hidden-cost', (_req, res) => {
 exports.miscRouter.get('/claude-stats', (_req, res) => {
     res.json((0, claude_stats_1.readClaudeStats)());
 });
+// ─── GET /api/active-sessions — fuentes activas en los últimos 5 min ──────────
+exports.miscRouter.get('/api/active-sessions', (_req, res) => {
+    const cutoff = Date.now() - 5 * 60 * 1000;
+    const sessions = db_1.dbOps.getAllSessions();
+    const bySource = new Map();
+    for (const s of sessions) {
+        const lastSeen = s.last_event_at ?? s.started_at;
+        if (lastSeen < cutoff)
+            continue;
+        const src = s.source ?? 'claude-code';
+        const existing = bySource.get(src);
+        if (!existing || lastSeen > existing.last_seen_ms) {
+            bySource.set(src, {
+                sessionId: s.id,
+                model: s.dominant_model ?? 'unknown',
+                cost_usd: s.total_cost_usd ?? 0,
+                last_seen_ms: lastSeen,
+                input_tokens: s.total_input_tokens ?? 0,
+                output_tokens: s.total_output_tokens ?? 0,
+                cache_read: s.total_cache_read ?? 0,
+                cache_creation: s.total_cache_creation ?? 0,
+            });
+        }
+    }
+    const result = Array.from(bySource.entries()).map(([source, v]) => ({ source, ...v }));
+    res.json(result);
+});
 // ─── GET /system-config — mapa completo del setup de Claude ──────────────────
 let _systemConfigCache = null;
 let _systemConfigCacheTs = 0;

package/dist/routes/opencode-reader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * opencode-reader.ts — Lee sesiones de OpenCode desde su SQLite y las mapea
+ * al formato TraceEvent[] que entiende el dashboard.
+ *
+ * GET /api/opencode/session/:id → { events: TraceEvent[], totalParts: number }
+ */
+export declare const opencodeReaderRouter: import("express-serve-static-core").Router;

package/dist/routes/opencode-reader.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * opencode-reader.ts — Lee sesiones de OpenCode desde su SQLite y las mapea
+ * al formato TraceEvent[] que entiende el dashboard.
+ *
+ * GET /api/opencode/session/:id → { events: TraceEvent[], totalParts: number }
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeReaderRouter = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("express");
+exports.opencodeReaderRouter = (0, express_1.Router)();
+const OPENCODE_DB = path_1.default.join(os_1.default.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+// OpenCode tool names → claudestat canonical names
+const TOOL_NAME_MAP = {
+    glob: 'Glob', read: 'Read', write: 'Write', edit: 'Edit', bash: 'Bash',
+    grep: 'Grep', webfetch: 'WebFetch', websearch: 'WebSearch',
+    skill: 'Skill', agent: 'Agent', task: 'Task',
+};
+function mapToolName(raw) {
+    return TOOL_NAME_MAP[raw.toLowerCase()] ?? (raw.charAt(0).toUpperCase() + raw.slice(1));
+}
+function openDb() {
+    const { DatabaseSync } = require('node:sqlite');
+    return new DatabaseSync(OPENCODE_DB, { open: true });
+}
+exports.opencodeReaderRouter.get('/api/opencode/session/:id', (req, res) => {
+    if (!fs_1.default.existsSync(OPENCODE_DB)) {
+        res.status(404).json({ error: 'OpenCode DB not found' });
+        return;
+    }
+    try {
+        const { id: sessionId } = req.params;
+        const db = openDb();
+        // Get all messages for this session ordered by time
+        const messages = db.prepare(`
+      SELECT id, time_created, time_updated, data
+      FROM message
+      WHERE session_id = ?
+      ORDER BY time_created ASC
+    `).all(sessionId);
+        const events = [];
+        const prompts = [];
+        let totalParts = 0;
+        let blockIndex = 0;
+        let pendingPrompt = null;
+        // Accumulated state for the current assistant turn (may span multiple messages)
+        let turnHasTools = false;
+        let turnEndTs = 0;
+        let turnCwd = undefined;
+        function closeTurn() {
+            if (!turnHasTools)
+                return;
+            blockIndex++;
+            events.push({ type: 'Stop', ts: turnEndTs, cwd: turnCwd });
+            if (pendingPrompt) {
+                prompts.push({ index: blockIndex, ts: pendingPrompt.ts, text: pendingPrompt.text });
+                pendingPrompt = null;
+            }
+            turnHasTools = false;
+            turnEndTs = 0;
+            turnCwd = undefined;
+        }
+        for (const msg of messages) {
+            const msgData = JSON.parse(msg.data);
+            if (msgData.role === 'user') {
+                // Close previous assistant turn before processing user message
+                closeTurn();
+                const parts = db.prepare(`
+          SELECT data FROM part WHERE message_id = ? ORDER BY time_created ASC
+        `).all(msg.id);
+                const text = parts
+                    .map(p => { try {
+                    return JSON.parse(p.data);
+                }
+                catch {
+                    return null;
+                } })
+                    .filter((p) => p?.type === 'text' && typeof p.text === 'string')
+                    .map(p => p.text)
+                    .join('\n').trim();
+                if (text)
+                    pendingPrompt = { ts: msg.time_created, text };
+                continue;
+            }
+            if (msgData.role !== 'assistant')
+                continue;
+            const cwd = msgData.path?.cwd;
+            const parts = db.prepare(`
+        SELECT time_created, time_updated, data
+        FROM part
+        WHERE message_id = ?
+        ORDER BY time_created ASC
+      `).all(msg.id);
+            for (const part of parts) {
+                totalParts++;
+                const partData = JSON.parse(part.data);
+                if (partData.type !== 'tool' || !partData.tool || !partData.state)
+                    continue;
+                const toolName = mapToolName(partData.tool);
+                const toolInput = partData.state.input ? JSON.stringify(partData.state.input) : undefined;
+                const isCompleted = partData.state.status === 'completed';
+                turnHasTools = true;
+                turnCwd = cwd ?? turnCwd;
+                turnEndTs = Math.max(turnEndTs, part.time_updated);
+                events.push({
+                    type: isCompleted ? 'Done' : 'PreToolUse',
+                    tool_name: toolName,
+                    tool_input: toolInput,
+                    ts: part.time_created,
+                    ...(isCompleted && { duration_ms: part.time_updated - part.time_created }),
+                    cwd,
+                });
+            }
+        }
+        // Close the last assistant turn (no trailing user message)
+        closeTurn();
+        db.close();
+        res.json({ events, totalParts, prompts });
+    }
+    catch (err) {
+        res.status(500).json({ error: String(err) });
+    }
+});

package/dist/routes/stream.js

@@ -46,7 +46,7 @@ exports.streamRouter.get('/stream', (req, res) => {
     res.flushHeaders();
     const clientId = Math.random().toString(36).slice(2);
     sseClients.set(clientId, res);
-    const latestSession = db_1.dbOps.getLatestSession();
+    const latestSession = db_1.dbOps.getLatestClaudeSession();
     if (latestSession) {
         const allEvents = db_1.dbOps.getSessionEvents(latestSession.id);
         const events = allEvents.length > SSE_INIT_EVENT_LIMIT

package/dist/watchers/adapter.d.ts

@@ -30,6 +30,16 @@ export interface WatcherAdapter {
     /** Nombre amigable para el badge de la CLI (ej: "CC", "Codex") */
     get shortName(): string;
 }
+export interface PollSession {
+    sessionId: string;
+    cost: CostUpdate;
+}
+/** Adapters que no usan archivos JSONL sino una DB o API propia */
+export interface PollableAdapter extends WatcherAdapter {
+    /** Devuelve sesiones actualizadas desde `since` (epoch ms) */
+    pollSessions(since: number): Promise<PollSession[]>;
+}
+export declare function isPollable(adapter: WatcherAdapter): adapter is PollableAdapter;
 export declare function registerAdapter(adapter: WatcherAdapter): void;
 export declare function getAdapter(name: string): WatcherAdapter | undefined;
 export declare function getAllAdapters(): WatcherAdapter[];

package/dist/watchers/adapter.js

@@ -7,11 +7,15 @@
  * que claudestat las soporte todas con una interfaz común.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPollable = isPollable;
 exports.registerAdapter = registerAdapter;
 exports.getAdapter = getAdapter;
 exports.getAllAdapters = getAllAdapters;
 exports.getActiveAdapters = getActiveAdapters;
 exports.getAdapterNames = getAdapterNames;
+function isPollable(adapter) {
+    return 'pollSessions' in adapter && typeof adapter.pollSessions === 'function';
+}
 // ─── Factory ───────────────────────────────────────────────────────────────────
 const registry = new Map();
 function registerAdapter(adapter) {

package/dist/watchers/opencode.d.ts

@@ -1,9 +1,9 @@
 /**
- * opencode.ts — WatcherAdapter para OpenCode
+ * opencode.ts — WatcherAdapter para OpenCode (poll-based, SQLite)
  *
- * 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.
+ * OpenCode stores sessions in ~/.local/share/opencode/opencode.db (SQLite).
+ * The session table has cost, token counts, model, and timestamps directly.
+ * Uses PollableAdapter — no JSONL files, no chokidar.
  */
-import { type WatcherAdapter } from './adapter';
-export declare const opencodeAdapter: WatcherAdapter;
+import { type PollableAdapter } from './adapter';
+export declare const opencodeAdapter: PollableAdapter;

package/dist/watchers/opencode.js

@@ -1,10 +1,10 @@
 "use strict";
 /**
- * opencode.ts — WatcherAdapter para OpenCode
+ * opencode.ts — WatcherAdapter para OpenCode (poll-based, SQLite)
  *
- * 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.
+ * OpenCode stores sessions in ~/.local/share/opencode/opencode.db (SQLite).
+ * The session table has cost, token counts, model, and timestamps directly.
+ * Uses PollableAdapter — no JSONL files, no chokidar.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -15,29 +15,69 @@ 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');
+const OPENCODE_DB = path_1.default.join(os_1.default.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+function openDb() {
+    const { DatabaseSync } = require('node:sqlite');
+    return new DatabaseSync(OPENCODE_DB, { open: true });
+}
+function parseModel(raw) {
+    if (!raw)
+        return 'unknown';
+    try {
+        const obj = JSON.parse(raw);
+        return obj.id ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 exports.opencodeAdapter = {
     name: 'opencode',
     label: 'OpenCode',
     get shortName() { return 'OC'; },
     detect() {
         try {
-            return fs_1.default.existsSync(OPENCODE_DIR);
+            return fs_1.default.existsSync(OPENCODE_DB);
         }
         catch {
             return false;
         }
     },
     getWatchPaths() {
-        return [`${OPENCODE_DIR}/**/*.jsonl`];
+        return [];
     },
     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;
     },
+    async pollSessions(since) {
+        try {
+            const db = openDb();
+            const stmt = db.prepare(`SELECT id, model, cost, tokens_input, tokens_output, tokens_cache_read, tokens_cache_write, time_updated
+         FROM session
+         WHERE time_updated >= ?
+         AND time_archived IS NULL`);
+            const rows = stmt.all(since);
+            db.close();
+            return rows.map(row => ({
+                sessionId: row.id,
+                cost: {
+                    input_tokens: row.tokens_input,
+                    output_tokens: row.tokens_output,
+                    cache_read: row.tokens_cache_read,
+                    cache_creation: row.tokens_cache_write,
+                    cost_usd: row.cost,
+                    context_used: 0,
+                    context_window: 200000,
+                    lastModel: parseModel(row.model),
+                },
+            }));
+        }
+        catch {
+            return [];
+        }
+    },
 };
 (0, adapter_1.registerAdapter)(exports.opencodeAdapter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "private": false,
   "publishConfig": {
     "access": "public"