@vibe-cafe/vibe-usage 0.14.0 → 0.14.2

package/package.json

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

package/src/config.js

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, chmodSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { moveDirectoryOutOfFilePath } from './path-repair.js';
 
 // VIBE_USAGE_CONFIG_DIR overrides the dir (test hook).
 const CONFIG_DIR = process.env.VIBE_USAGE_CONFIG_DIR?.trim() || join(homedir(), '.vibe-usage');
@@ -22,6 +23,9 @@ export function loadConfig() {
 
 export function saveConfig(config) {
   mkdirSync(CONFIG_DIR, { recursive: true });
+  // A directory sitting where the config file belongs would make this write
+  // throw EISDIR forever; move it aside so the run can save.
+  moveDirectoryOutOfFilePath(CONFIG_FILE);
   // The file holds the vbu_ API key — never leave it group/world-readable.
   // mode only applies at file creation, so chmod explicitly for pre-existing
   // files written before this hardening.

package/src/init.js

@@ -21,7 +21,16 @@ function prompt(question) {
 }
 
 function openBrowser(url) {
-  const cmds = { darwin: 'open', linux: 'xdg-open', win32: 'start' };
+  // `start` is a cmd.exe builtin, not an executable: execFile('start', …) fails
+  // outright on Windows, so the device-flow login never opened a tab and the
+  // user was left staring at the code with no browser to type it into. Go
+  // through cmd, and escape a bare `&` (present in verificationUriComplete's
+  // query string) or cmd would read it as a command separator.
+  if (platform() === 'win32') {
+    execFile('cmd', ['/c', 'start', '', url.replace(/&/g, '^&')], { windowsHide: true }, () => {});
+    return;
+  }
+  const cmds = { darwin: 'open', linux: 'xdg-open' };
   const cmd = cmds[platform()] || cmds.linux;
   // Use execFile with args array to avoid shell injection via VIBE_USAGE_API_URL
   execFile(cmd, [url], () => {});

package/src/opencode-roots.js

@@ -24,10 +24,21 @@ export function openCodeStore(root) {
   return null;
 }
 
+// XDG first, then the Windows per-user store. A root that does not resolve is
+// skipped by the caller, so probing costs nothing when it is absent.
+function defaultOpenCodeRoots() {
+  const xdg = join(homedir(), '.local', 'share', 'opencode');
+  const localAppData = process.env.LOCALAPPDATA?.trim();
+  if (process.platform === 'win32' && localAppData) {
+    return [xdg, join(localAppData, 'opencode')];
+  }
+  return [xdg];
+}
+
 export function getOpenCodeStores({ extraRoots = [], onWarning = () => {} } = {}) {
   const override = process.env.VIBE_USAGE_OPENCODE_DIRS?.trim();
   const defaults = override ? override.split(delimiter).map(p => p.trim()).filter(Boolean)
-    : [join(homedir(), '.local', 'share', 'opencode')];
+    : defaultOpenCodeRoots();
   const seen = new Set(), stores = [];
   for (const root of [...defaults, ...extraRoots]) {
     try {

package/src/parsers/amp.js

@@ -3,9 +3,17 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
-function resolveThreadsDir() {
+/** Threads directory, XDG first and %LOCALAPPDATA% on Windows. Exported so the
+ *  Windows branch can be exercised from a POSIX test host. */
+export function resolveThreadsDir() {
   if (process.env.AMP_DATA_DIR) return process.env.AMP_DATA_DIR;
   if (process.env.XDG_DATA_HOME) return join(process.env.XDG_DATA_HOME, 'amp', 'threads');
+  // Amp on Windows keeps its threads under %LOCALAPPDATA%; without this the
+  // source silently collected nothing there.
+  if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
+    const winDir = join(process.env.LOCALAPPDATA, 'amp', 'threads');
+    if (existsSync(winDir)) return winDir;
+  }
   return join(homedir(), '.local', 'share', 'amp', 'threads');
 }
 

package/src/parsers/codex-cache.js

@@ -14,7 +14,7 @@ import { join } from 'node:path';
 // separate from ~/.vibe-usage/state.json, whose hashes are the authoritative
 // record of successful uploads and must remain backward-compatible.
 export const CODEX_CACHE_SCHEMA_VERSION = 1;
-export const CODEX_PARSER_ALGORITHM_VERSION = 4;
+export const CODEX_PARSER_ALGORITHM_VERSION = 5;
 
 function hash(value, length = 24) {
   return createHash('sha256').update(value).digest('hex').slice(0, length);

package/src/parsers/codex-segments.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { normalizeUsageRecord } from './codex-usage-record.js';
 
 const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('base64url');
 function pick(value, keys) {
@@ -10,6 +11,7 @@ const usageKeys = ['input_tokens', 'output_tokens', 'cached_input_tokens', 'cach
 // Retain only fields consumed by the existing token/timing parser. Full JSON is
 // hashed transiently to identify exact copies; chat/tool text is never retained.
 function accountingRecord(obj, context) {
+  obj = normalizeUsageRecord(obj);
   const next = { type: obj.type, timestamp: obj.timestamp };
   const p = obj.payload;
   if (obj.type === 'session_meta' && p) {
@@ -22,7 +24,7 @@ function accountingRecord(obj, context) {
   } else if (obj.type === 'turn_context') {
     next.payload = pick(p, ['model', 'service_tier']);
   } else if (obj.type === 'event_msg' && p) {
-    next.payload = pick(p, ['type', 'started_at', 'model']);
+    next.payload = pick(p, ['type', 'started_at', 'model', 'usage_record']);
     if (p.type === 'token_count') {
       next._tokenFingerprint = hash(p).slice(0, 16);
       next._segmentContext = { ...context };

package/src/parsers/codex-usage-record.js

@@ -0,0 +1,29 @@
+// Codex writes usage twice for the same request: once as the UI-facing
+// `event_msg` / `token_count`, and once as a durable `token_usage_record`.
+// The UI event can be missing entirely — an interrupted or crashed call never
+// reaches the point where it is emitted — while the durable record still lands,
+// so counting only the UI form under-reports real usage.
+//
+// Rewrite the durable form into the shape the parser already understands, and
+// keep a `usage_record` marker so the UI event that mirrors the same request is
+// not counted a second time when its cumulative total lags.
+export function normalizeUsageRecord(obj) {
+  if (obj?.type !== 'token_usage_record') return obj;
+  const p = obj.payload;
+  const usage = p?.usage;
+  const total = p?.thread_token_usage;
+  if (!usage || !total || !Number.isFinite(total.total_tokens) || total.total_tokens <= 0) return obj;
+  for (const value of [usage.input_tokens, usage.output_tokens, usage.cached_input_tokens ?? 0, usage.reasoning_output_tokens ?? 0]) {
+    if (!Number.isFinite(value) || value < 0) return obj;
+  }
+  return { ...obj, type: 'event_msg', payload: {
+    type: 'token_count', usage_record: true,
+    info: { last_token_usage: pickUsage(usage), total_token_usage: pickUsage(total) },
+  }};
+}
+
+function pickUsage(value) {
+  const keys = ['input_tokens', 'output_tokens', 'cached_input_tokens', 'cache_read_input_tokens',
+    'cache_write_input_tokens', 'reasoning_output_tokens', 'total_tokens'];
+  return Object.fromEntries(keys.filter(key => Number.isFinite(value[key])).map(key => [key, value[key]]));
+}

package/src/parsers/codex.js

@@ -1,3 +1,4 @@
+import { normalizeUsageRecord } from './codex-usage-record.js';
 import {
   closeSync,
   createReadStream,
@@ -104,7 +105,9 @@ function extractProject(meta) {
     const match = meta.git.repository_url.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
     if (match) return match[1];
   }
-  if (meta.cwd) return meta.cwd.split('/').pop() || 'unknown';
+  // Windows reports cwd with backslashes, so splitting on '/' alone yields the
+  // whole path as the "project".
+  if (meta.cwd) return meta.cwd.split(/[\\/]/).pop() || 'unknown';
   return 'unknown';
 }
 
@@ -137,7 +140,7 @@ async function readSessionHeader(filePath, snapshotSize) {
   for await (const line of readLines(filePath, snapshotSize)) {
     if (!line.trim()) continue;
     try {
-      const obj = JSON.parse(line);
+      const obj = normalizeUsageRecord(JSON.parse(line));
       if (obj.type !== 'session_meta' || !obj.payload) continue;
       const meta = obj.payload;
       return {
@@ -336,7 +339,7 @@ async function indexSessionFile(filePath, snapshotSize, lines = null) {
   for await (const line of (lines ?? readLines(filePath, snapshotSize))) {
     if (!line.trim()) continue;
     try {
-      const obj = JSON.parse(line);
+      const obj = normalizeUsageRecord(JSON.parse(line));
       parsedRecordCount++;
 
       const recordTimestamp = timestampMs(obj.timestamp);
@@ -633,12 +636,20 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
   let serviceTier = previousTail?.serviceTier || null;
   let prevTotal = previousTail?.prevTotal || null;
   let prevCumulativeTotal = previousTail?.prevCumulativeTotal ?? null;
+  // Durable records and UI counters are separate series whose cumulative totals
+  // can diverge after an interrupted call, so each keeps its own baseline.
+  let prevRecordTotal = previousTail?.prevRecordTotal ?? null;
+  let pendingUsageMirror = previousTail?.pendingUsageMirror ?? null;
   const start = previousTail?.parsedBytes || 0;
   for await (const line of (lines ?? readLines(filePath, snapshotSize, start))) {
     if (!line.trim()) continue;
     try {
-      const obj = JSON.parse(line);
+      const obj = normalizeUsageRecord(JSON.parse(line));
       parsedRecordIndex++;
+      // A resumed or new turn cannot be the delayed mirror of the preceding
+      // request, so the marker must not survive a turn boundary.
+      if (obj.type === 'session_meta' || obj.type === 'turn_context' || obj.type === 'token_usage_record'
+          || (obj.type === 'event_msg' && isTaskStarted(obj.payload))) pendingUsageMirror = null;
 
         // A direct child task boundary covers every copied record, including
         // timing/meta events. The raw-token ordinal covers full-history and
@@ -715,11 +726,21 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
         // compaction — and must count as zero, not a second copy of
         // last_token_usage. Guarded to positive totals so builds that leave
         // total_token_usage all-zero can't suppress real usage.
+      const isUsageRecord = payload.usage_record === true;
+      // The durable record and the UI event describe the same request, but their
+      // cumulative counters can diverge after an interrupted call, so the match
+      // is on per-request usage. The marker survives appends because the mirror
+      // can arrive in a later read.
+      const isMirror = !isUsageRecord && pendingUsageMirror && sameRequestUsage(pendingUsageMirror, info.last_token_usage);
+      pendingUsageMirror = isUsageRecord ? info.last_token_usage : null;
       const cumulativeTotal = info.total_token_usage?.total_tokens;
       const isDuplicateEmission = typeof cumulativeTotal === 'number'
         && cumulativeTotal > 0
-        && cumulativeTotal === prevCumulativeTotal;
-      if (typeof cumulativeTotal === 'number') prevCumulativeTotal = cumulativeTotal;
+        && cumulativeTotal === (isUsageRecord ? prevRecordTotal : prevCumulativeTotal);
+      if (typeof cumulativeTotal === 'number') {
+        if (isUsageRecord) prevRecordTotal = cumulativeTotal;
+        else prevCumulativeTotal = cumulativeTotal;
+      }
 
         // Prefer incremental per-request usage; compute delta from cumulative
         // totals as fallback. Always advance the cumulative baseline, even
@@ -747,7 +768,7 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
         // avoids counting the full cumulative total again after a model switch.
       if (curr) prevTotal = { ...curr };
       if (!usage) continue;
-      if (isReplayedHistory || isDuplicateEmission) continue;
+      if (isReplayedHistory || isDuplicateEmission || isMirror) continue;
 
       const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
       if (!timestamp || isNaN(timestamp.getTime())) continue;
@@ -814,6 +835,8 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
       serviceTier,
       prevTotal,
       prevCumulativeTotal,
+      prevRecordTotal,
+      pendingUsageMirror,
       buckets,
       sessionAccumulator,
       guardHash: guard.hash,
@@ -1169,6 +1192,12 @@ async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
   return { ...mergeFileResults(results), cache: cacheStats };
 }
 
+function sameRequestUsage(left, right) {
+  if (!left || !right) return false;
+  return ['input_tokens', 'cached_input_tokens', 'output_tokens', 'reasoning_output_tokens']
+    .every(key => (left[key] || 0) === (right[key] || 0));
+}
+
 export async function parse(options = {}) {
   const nativeResult = await parseNativeCodex(options);
   return mergeCindyHarnessUsage(nativeResult, readCindyHarnessUsage('codex'));

package/src/parsers/qwen-code.js

@@ -40,7 +40,9 @@ function findSessionFiles(baseDir) {
 
 function extractProject(cwd, filePath) {
   if (cwd) {
-    const parts = cwd.split('/').filter(Boolean);
+    // Windows reports cwd with backslashes; split on both separators so the
+    // project is the last path segment rather than the whole path.
+    const parts = cwd.split(/[\\/]/).filter(Boolean);
     if (parts.length > 0) return parts[parts.length - 1];
   }
   const tmpPrefix = QWEN_TMP_DIR + sep;

package/src/path-repair.js

@@ -0,0 +1,27 @@
+import { statSync, renameSync } from 'node:fs';
+
+/**
+ * Move a directory that is occupying a path we need as a file.
+ *
+ * Both the config file and the state file are written by this CLI, and a
+ * customer hit a layout where the *file* path had become a directory (the store
+ * was created by a different tool, or an earlier run was interrupted between
+ * mkdir and open). `writeFileSync` then fails with EISDIR and the CLI is stuck:
+ * every later run reads nothing, and the save that would fix it is the one that
+ * throws.
+ *
+ * Renaming it aside keeps whatever the user's data was — never delete it, the
+ * directory may hold real content — while letting the current run write a fresh
+ * file. Absence is not a repair, so ENOENT stays silent; anything else (a
+ * permission error, a read-only volume) is the caller's to report rather than
+ * something to swallow.
+ */
+export function moveDirectoryOutOfFilePath(path) {
+  try {
+    if (statSync(path).isDirectory()) {
+      renameSync(path, `${path}.directory-backup-${Date.now()}`);
+    }
+  } catch (err) {
+    if (err?.code !== 'ENOENT') throw err;
+  }
+}

package/src/state.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, unlinkSync, mkdirSync, existsSync, renameS
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash, randomBytes } from 'node:crypto';
+import { moveDirectoryOutOfFilePath } from './path-repair.js';
 
 // Persisted sync state, kept next to config.js's files (same dir + dev split).
 // Maps a stable item key -> hash of its mutable fields, recording what we have
@@ -79,6 +80,9 @@ export function loadState(identity) {
 
 export function saveState(state, identity) {
   mkdirSync(STATE_DIR, { recursive: true });
+  // Same EISDIR repair as config: a directory where the state file belongs
+  // would block every save, and with it every incremental sync.
+  moveDirectoryOutOfFilePath(STATE_FILE);
   // Only the durable fields are written: `identityChanged` is loadState()'s
   // one-run signal, not state. A CLI older than 0.11.1 reads just
   // buckets/sessions, so the extra top-level `identity` key is ignored there —