@vibe-cafe/vibe-usage 0.7.17 → 0.7.19

package/README.md

@@ -47,7 +47,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Tool | Data Location |
 |------|---------------|
 | Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only) |
-| Codex CLI | `~/.codex/sessions/` |
+| Codex CLI | `~/.codex/sessions/` and `~/.codex/archived_sessions/` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`) |
 | Gemini CLI | `~/.gemini/tmp/` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.7.17",
+  "version": "0.7.19",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {

package/src/parsers/codex.js

@@ -1,9 +1,21 @@
-import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { createReadStream, readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
-const SESSIONS_DIR = join(homedir(), '.codex', 'sessions');
+// Codex stores live sessions in ~/.codex/sessions and, once a session is
+// "completed", moves its rollout file verbatim into ~/.codex/archived_sessions.
+// A session can be archived between two syncs, so scanning only the live dir
+// loses that session's usage forever. We scan both: the parser is stateless
+// and the server dedups on (source, sessionHash/bucket), so re-reading an
+// archived file that was already synced from sessions/ is idempotent. Indexing
+// both together also keeps fork replay-skip correct when a fork and its parent
+// end up split across the two directories.
+const SESSIONS_DIRS = [
+  join(homedir(), '.codex', 'sessions'),
+  join(homedir(), '.codex', 'archived_sessions'),
+];
 
 /**
  * Recursively find all .jsonl files under a directory.
@@ -27,32 +39,63 @@ function findJsonlFiles(dir) {
   return results;
 }
 
+function readLines(filePath) {
+  return createInterface({
+    input: createReadStream(filePath, { encoding: 'utf-8' }),
+    crlfDelay: Infinity,
+  });
+}
+
+function extractProject(meta) {
+  if (meta.git?.repository_url) {
+    // e.g. https://github.com/org/repo.git → org/repo
+    const match = meta.git.repository_url.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (match) return match[1];
+  }
+  if (meta.cwd) return meta.cwd.split('/').pop() || 'unknown';
+  return 'unknown';
+}
+
 /**
- * Count the leading `event_msg/token_count` records in a session file.
- * Used to size the replayed-history block of a forked session: a fork
- * copies the original conversation verbatim, so it begins with exactly as
- * many token_count records as the original session has in total.
+ * Stream a session file once and extract its index metadata: the session
+ * id, the forked-from id, the project name, and the total count of
+ * `event_msg/token_count` records. The token_count total is used to size
+ * the replayed-history block of a forked session — a fork copies the
+ * original conversation verbatim, so it begins with exactly as many
+ * token_count records as the source session has in total.
  */
-function countTokenCountRecords(content) {
-  let n = 0;
-  for (const line of content.split('\n')) {
+async function indexSessionFile(filePath) {
+  let sessionId = null;
+  let forkedFromId = null;
+  let sessionProject = 'unknown';
+  let tokenCountRecords = 0;
+
+  for await (const line of readLines(filePath)) {
     if (!line.trim()) continue;
     try {
       const obj = JSON.parse(line);
-      if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') n++;
+      if (obj.type === 'session_meta' && obj.payload) {
+        const meta = obj.payload;
+        sessionId = meta.id || sessionId;
+        forkedFromId = meta.forked_from_id || null;
+        sessionProject = extractProject(meta);
+      } else if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
+        tokenCountRecords++;
+      }
     } catch {
       continue;
     }
   }
-  return n;
+
+  return { sessionId, forkedFromId, sessionProject, tokenCountRecords };
 }
 
 export async function parse() {
-  if (!existsSync(SESSIONS_DIR)) return { buckets: [], sessions: [] };
+  if (!SESSIONS_DIRS.some(existsSync)) return { buckets: [], sessions: [] };
 
   const entries = [];
   const sessionEvents = [];
-  const files = findJsonlFiles(SESSIONS_DIR);
+  const files = SESSIONS_DIRS.flatMap(findJsonlFiles);
   if (files.length === 0) return { buckets: [], sessions: [] };
 
   // Pass 1: index every session by its UUID and count its token_count
@@ -66,30 +109,17 @@ export async function parse() {
   // instant, within the same 1–3s window), so we instead skip exactly the
   // original session's token_count count from the start of each fork.
   const tokenCountById = new Map(); // sessionId → number of token_count records
-  const fileMeta = new Map(); // filePath → { content, forkedFromId }
+  const fileMeta = new Map(); // filePath -> { forkedFromId, sessionProject }
   for (const filePath of files) {
-    let content;
+    let meta;
     try {
-      content = readFileSync(filePath, 'utf-8');
+      meta = await indexSessionFile(filePath);
     } catch {
       continue;
     }
-    let sessionId = null;
-    let forkedFromId = null;
-    for (const line of content.split('\n')) {
-      if (!line.trim()) continue;
-      try {
-        const obj = JSON.parse(line);
-        if (obj.type === 'session_meta' && obj.payload) {
-          sessionId = obj.payload.id || null;
-          forkedFromId = obj.payload.forked_from_id || null;
-        }
-      } catch { /* ignore */ }
-      break; // session_meta is always the first line
-    }
-    fileMeta.set(filePath, { content, forkedFromId });
-    if (sessionId) {
-      tokenCountById.set(sessionId, countTokenCountRecords(content));
+    fileMeta.set(filePath, meta);
+    if (meta.sessionId) {
+      tokenCountById.set(meta.sessionId, meta.tokenCountRecords);
     }
   }
 
@@ -97,9 +127,7 @@ export async function parse() {
   for (const filePath of files) {
     const fm = fileMeta.get(filePath);
     if (!fm) continue;
-    const { content, forkedFromId } = fm;
-
-    const lines = content.split('\n');
+    const { forkedFromId } = fm;
 
     // How many leading token_count records are copied history. A fork's file
     // begins with the *entire* source file replayed verbatim, so the count
@@ -116,31 +144,17 @@ export async function parse() {
     }
     let tokenCountSeen = 0;
 
-    // Extract project name from session_meta.
-    let sessionProject = 'unknown';
-    let sessionModel = 'unknown';
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const obj = JSON.parse(line);
-        if (obj.type === 'session_meta' && obj.payload) {
-          const meta = obj.payload;
-          if (meta.cwd) {
-            sessionProject = meta.cwd.split('/').pop() || 'unknown';
-          }
-          if (meta.git?.repository_url) {
-            // e.g. https://github.com/org/repo.git → org/repo
-            const match = meta.git.repository_url.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
-            if (match) sessionProject = match[1];
-          }
-        }
-      } catch { /* ignore */ }
-      break; // session_meta is always the first line
-    }
+    const sessionProject = fm.sessionProject;
+    // Group timing events by the real Codex session id, not the file path: the
+    // same session can briefly exist in both sessions/ and archived_sessions/
+    // (mid-archive, or a re-synced archive). Path-keyed grouping would emit it
+    // as two different sessionHashes and double-count its session stats. Fall
+    // back to the path only when the id is unknown (corrupt/missing meta).
+    const sessionKey = fm.sessionId || filePath;
 
     let turnContextModel = 'unknown';
     const prevTotal = new Map();
-    for (const line of lines) {
+    for await (const line of readLines(filePath)) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
@@ -164,7 +178,7 @@ export async function parse() {
             if (!isReplay) {
               const isUserTurn = obj.type === 'turn_context' || obj.type === 'session_meta';
               sessionEvents.push({
-                sessionId: filePath,
+                sessionId: sessionKey,
                 source: 'codex',
                 project: sessionProject,
                 timestamp: evTs,
@@ -225,7 +239,7 @@ export async function parse() {
         if (!usage) continue;
         if (isReplayedHistory) continue;
 
-        const model = info.model || payload.model || turnContextModel || sessionModel;
+        const model = info.model || payload.model || turnContextModel || 'unknown';
 
         // OpenAI API: input_tokens INCLUDES cached, output_tokens INCLUDES reasoning.
         // Normalize to Anthropic-style semantics where each field is non-overlapping.

package/src/tools.js

@@ -80,6 +80,16 @@ function findOpenclawDataDirs() {
   return dirs;
 }
 
+// Codex keeps live sessions in ~/.codex/sessions and moves completed ones to
+// ~/.codex/archived_sessions. Detect Codex if either dir exists, so a user
+// whose sessions have all been archived is still recognized.
+function findCodexDataDirs() {
+  return [
+    join(homedir(), '.codex', 'sessions'),
+    join(homedir(), '.codex', 'archived_sessions'),
+  ].filter(existsSync);
+}
+
 export const TOOLS = [
   {
     name: 'Antigravity',
@@ -101,6 +111,7 @@ export const TOOLS = [
     name: 'Codex CLI',
     id: 'codex',
     dataDir: join(homedir(), '.codex', 'sessions'),
+    detectDataDirs: findCodexDataDirs,
   },
   {
     name: 'GitHub Copilot CLI',