tokentracker-cli 1.3.13 → 1.3.15

package/src/lib/rollout.js

@@ -2846,6 +2846,8 @@ async function parseClaudeFile({
       continue;
     }
 
+    if (isOmOClaudeSdkMirror(obj)) continue;
+
     const usage = obj?.message?.usage || obj?.usage;
     if (!usage || typeof usage !== "object") continue;
 
@@ -4901,6 +4903,14 @@ function isCodexTotalOnlyResetSentinel(lastUsage, totalUsage) {
 // backward compatibility for the (msgId, reqId) format already persisted in
 // cursors.claudeHashes (msgId strings don't contain `:`, so the two formats
 // share the same Set without collision).
+// OmO Native routes Anthropic-subscription turns through the Claude Agent SDK,
+// which mirrors the same usage into ~/.claude/projects with entrypoint "sdk-ts"
+// and userType "external". OmO's passive reader already counts those turns
+// under source=omo — skip the mirrored Claude transcript copy (#726).
+function isOmOClaudeSdkMirror(obj) {
+  return obj?.entrypoint === "sdk-ts" && obj?.userType === "external";
+}
+
 function claudeMessageDedupKey(obj) {
   const msgId = typeof obj?.message?.id === "string" && obj.message.id ? obj.message.id : null;
   if (!msgId) return null;
@@ -5542,6 +5552,79 @@ function hasZcodeNativeUsageSchema(dbPath, sqliteOptions = {}) {
   }
 }
 
+// true: readable with content; false: confirmed empty; null: unavailable or
+// unreadable. Only a confirmed empty database is safe to replace during discovery.
+function zcodeDbHasContent(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return null;
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_error) {
+      // Preserve the existing direct-read fallback for transient snapshot
+      // failures and UNC implementations that support SQLite locking.
+    }
+  }
+  try {
+    const rows = readSqliteJsonRows(
+      effectiveDbPath,
+      "SELECT (SELECT COUNT(*) FROM session) AS sessions, (SELECT COUNT(*) FROM model_usage) AS requests",
+      {
+        label: "ZCode",
+        timeout: 10_000,
+        maxBuffer: 1024 * 1024,
+        ...sqliteOptions,
+        throwOnReadFailure: true,
+      },
+    );
+    const row = Array.isArray(rows) ? rows[0] : null;
+    if (!row) return null;
+    return (Number(row.sessions) || 0) > 0 || (Number(row.requests) || 0) > 0;
+  } catch (_error) {
+    return null;
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
+}
+
+function hasZcodeCursorState(cursors) {
+  return [cursors?.zcode, cursors?.zcode?.native, cursors?.zcode?.wsl]
+    .some((state) => Object.keys(state?.messages || {}).length > 0) ||
+    Object.keys(cursors?.hourly?.buckets || {}).some((key) => key.startsWith("zcode|")) ||
+    Object.keys(cursors?.hourly?.groupQueued || {}).some((key) => key.startsWith("zcode|")) ||
+    Object.keys(cursors?.projectHourly?.buckets || {}).some((key) => key.includes("|zcode|"));
+}
+
+// Sync, session discovery and status must select the same installs. Once sync
+// records a priority-mode choice, retain it: switching databases underneath a
+// flat cursor would accumulate both installs in the same usage ledger.
+function resolveZcodeInstallPaths({ nativeValue, wslValue } = {}, env = process.env, deps = {}) {
+  const mode = wsl.getWslMode(env);
+  const priorityMode = (deps.platform || process.platform) === "win32" && ["native-first", "wsl-first"].includes(mode);
+  const selection = deps.selection || deps.cursors?.zcodeInstallSelection;
+  if (priorityMode && selection?.mode === mode &&
+      selection.zcodeHome === (env.ZCODE_HOME?.trim() || null) &&
+      typeof selection.dbPath === "string" && selection.dbPath) {
+    // A newly discovered or temporarily unavailable install must not change
+    // the cursor's owner. Only an explicit mode/home override releases it.
+    return { native: selection.dbPath, wsl: null };
+  }
+  const paths = resolveInstallPaths({ nativeValue, wslValue }, env, deps);
+  if (!priorityMode || (!selection && hasZcodeCursorState(deps.cursors))) {
+    // Legacy cursors followed the original install resolver. Keep that choice
+    // rather than feeding another database into an already-owned flat ledger.
+    return paths;
+  }
+  const picked = paths.native || paths.wsl;
+  const alternate = picked === nativeValue ? wslValue : nativeValue;
+  if (picked && alternate && zcodeDbHasContent(picked) === false && zcodeDbHasContent(alternate) === true) {
+    return { native: alternate, wsl: null };
+  }
+  return paths;
+}
+
 function buildZcodeNativeUsageSql({ hasSessionDirectory }) {
   const directorySelect = hasSessionDirectory ? ", s.directory AS directory" : "";
   const directoryJoin = hasSessionDirectory
@@ -15626,6 +15709,44 @@ function ompEntryTimestampMs(msg, entry) {
   return null;
 }
 
+// Tool results can be hundreds of MB, exceeding V8's ~2^29-character string
+// limit without carrying usage. Skip them without decoding; assistant usage
+// records are orders of magnitude smaller.
+const OMP_LIKE_MAX_RECORD_BYTES = 64 * 1024 * 1024;
+
+async function scanOmpLikeTranscript(filePath, startOffset, maxRecordBytes, onEntry) {
+  let stream;
+  try {
+    stream = fssync.createReadStream(filePath, { start: startOffset });
+  } catch {
+    return startOffset;
+  }
+  let scannedEndOffset = startOffset;
+  let committedEndOffset = startOffset;
+  for await (const record of physicalJsonlRecords(stream, {
+    invalidUtf8: "record",
+    maxRecordBytes,
+  })) {
+    scannedEndOffset += record.physicalBytes;
+    if (record.terminated) {
+      committedEndOffset = scannedEndOffset;
+      if (record.oversized || !record.utf8Valid || !record.line || !record.line.trim()) continue;
+      let entry;
+      try { entry = JSON.parse(record.line); } catch { continue; }
+      onEntry(entry);
+      continue;
+    }
+    // A final incomplete record may still be in the process of being written.
+    if (record.oversized || !record.utf8Valid || !record.line || !record.line.trim()) break;
+    let entry;
+    try { entry = JSON.parse(record.line); } catch { break; }
+    onEntry(entry);
+    committedEndOffset = scannedEndOffset;
+    break;
+  }
+  return committedEndOffset;
+}
+
 // Shared implementation for the oh-my-pi session format. omp and omo both
 // persist it verbatim, so they differ only in where the sessions live, which
 // cursor namespace they own, and how reasoning tokens are spelled.
@@ -15647,6 +15768,7 @@ async function parseOmpLikeIncremental({
   resolveFileCwd,
   reasoningFields,
   reasoningIncludedInOutput = false,
+  maxRecordBytes = OMP_LIKE_MAX_RECORD_BYTES,
 } = {}) {
   await ensureDir(path.dirname(queuePath));
   const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
@@ -15724,35 +15846,22 @@ async function parseOmpLikeIncremental({
     const startOffset = stat.size < prevSize || inodeChanged ? 0 : prevSize;
     if (stat.size <= startOffset) continue;
 
-    let stream;
-    try {
-      stream = fssync.createReadStream(filePath, {
-        encoding: "utf8",
-        start: startOffset,
-      });
-    } catch { continue; }
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-    for await (const line of rl) {
-      if (!line || !line.trim()) continue;
-      let entry;
-      try { entry = JSON.parse(line); } catch { continue; }
-
+    const committedEndOffset = await scanOmpLikeTranscript(filePath, startOffset, maxRecordBytes, (entry) => {
       // First line of each file is type:"session" (header) — skip all
       // non-message records.
-      if (!entry || entry.type !== "message") continue;
+      if (!entry || entry.type !== "message") return;
 
       // Only assistant messages carry token usage.
       const msg = entry.message;
-      if (!msg || msg.role !== "assistant") continue;
+      if (!msg || msg.role !== "assistant") return;
 
       const usage = msg.usage;
-      if (!usage || typeof usage !== "object") continue;
+      if (!usage || typeof usage !== "object") return;
 
       // Dedup by top-level entry id (8-char string assigned by oh-my-pi).
       const entryId = typeof entry.id === "string" && entry.id ? entry.id : null;
-      if (!entryId) continue;
-      if (seenIds.has(entryId)) continue;
+      if (!entryId) return;
+      if (seenIds.has(entryId)) return;
 
       recordsProcessed++;
 
@@ -15770,7 +15879,7 @@ async function parseOmpLikeIncremental({
         reasoningTokens === 0
       ) {
         seenIds.add(entryId);
-        continue;
+        return;
       }
 
       // Entries with no resolvable timestamp are skipped — they cannot be
@@ -15778,12 +15887,12 @@ async function parseOmpLikeIncremental({
       const tsMs = ompEntryTimestampMs(msg, entry);
       if (tsMs == null) {
         seenIds.add(entryId);
-        continue;
+        return;
       }
 
       const tsIso = new Date(tsMs).toISOString();
       const bucketStart = toUtcHalfHourStart(tsIso);
-      if (!bucketStart) continue;
+      if (!bucketStart) return;
 
       // Use provided totalTokens when available; otherwise sum all components.
       // OmO folds reasoning into output, so the fallback must not add it again.
@@ -15820,14 +15929,12 @@ async function parseOmpLikeIncremental({
           bucketsQueued: touchedBuckets.size,
         });
       }
-    }
+    });
 
-    let postStat = stat;
-    try { postStat = fssync.statSync(filePath); } catch {}
     fileOffsets[filePath] = {
-      size: postStat.size,
-      mtimeMs: postStat.mtimeMs,
-      ino: postStat.ino,
+      size: committedEndOffset,
+      mtimeMs: stat.mtimeMs,
+      ino: stat.ino,
     };
   }
 
@@ -15860,28 +15967,16 @@ async function parseOmpLikeIncremental({
         : null;
       const projectRef = projectContext?.projectRef || null;
       const projectKey = projectContext?.projectKey || null;
+      let committedEndOffset = stat.size;
 
       if (projectKey && projectRef) {
-        let stream;
-        try {
-          stream = fssync.createReadStream(filePath, {
-            encoding: "utf8",
-            start: startOffset,
-          });
-        } catch {
-          continue;
-        }
-        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-        for await (const line of rl) {
-          if (!line || !line.trim()) continue;
-          let entry;
-          try { entry = JSON.parse(line); } catch { continue; }
+        committedEndOffset = await scanOmpLikeTranscript(filePath, startOffset, maxRecordBytes, (entry) => {
           const msg = entry?.type === "message" ? entry.message : null;
           const usage = msg?.role === "assistant" ? msg.usage : null;
-          if (!usage || typeof usage !== "object") continue;
+          if (!usage || typeof usage !== "object") return;
 
           const entryId = typeof entry.id === "string" && entry.id ? entry.id : null;
-          if (!entryId || projectSeenIds.has(entryId)) continue;
+          if (!entryId || projectSeenIds.has(entryId)) return;
 
           const input = toNonNegativeInt(usage.input);
           const output = toNonNegativeInt(usage.output);
@@ -15896,7 +15991,7 @@ async function parseOmpLikeIncremental({
             reasoningTokens === 0
           ) {
             projectSeenIds.add(entryId);
-            continue;
+            return;
           }
 
           const tsMs = ompEntryTimestampMs(msg, entry);
@@ -15905,7 +16000,7 @@ async function parseOmpLikeIncremental({
             : toUtcHalfHourStart(new Date(tsMs).toISOString());
           if (!bucketStart) {
             projectSeenIds.add(entryId);
-            continue;
+            return;
           }
 
           const totalTokens =
@@ -15932,15 +16027,13 @@ async function parseOmpLikeIncremental({
           addTotals(projectBucket.totals, delta);
           projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
           projectSeenIds.add(entryId);
-        }
+        });
       }
 
-      let postStat = stat;
-      try { postStat = fssync.statSync(filePath); } catch {}
       projectFileOffsets[filePath] = {
-        size: postStat.size,
-        mtimeMs: postStat.mtimeMs,
-        ino: postStat.ino,
+        size: committedEndOffset,
+        mtimeMs: stat.mtimeMs,
+        ino: stat.ino,
       };
     }
   }
@@ -24595,6 +24688,9 @@ module.exports = {
   coerceEpochMs,
   normalizeOpencodeModelFields,
   hasZcodeNativeUsageSchema,
+  zcodeDbHasContent,
+  hasZcodeCursorState,
+  resolveZcodeInstallPaths,
   resolveQoderDbPath,
   resolveQoderDbPaths,
   resolveQoderCnDbPaths,

package/src/lib/session-analytics.js

@@ -28,12 +28,13 @@ const fsp = require("node:fs/promises");
 const os = require("node:os");
 const path = require("node:path");
 const readline = require("node:readline");
-const { listClaudeProjectFiles, listRolloutFilesDeep, claudeMessageDedupKey, normalizeClaudeUsage, readZcodeDbMessages, coerceEpochMs, normalizeOpencodeModelFields, normalizeOpencodeTokens, deriveOpencodeMessageFingerprint } = require("./rollout");
+const { listClaudeProjectFiles, listRolloutFilesDeep, claudeMessageDedupKey, normalizeClaudeUsage, readZcodeDbMessages, coerceEpochMs, resolveZcodeInstallPaths, normalizeOpencodeModelFields, normalizeOpencodeTokens, deriveOpencodeMessageFingerprint } = require("./rollout");
 const { parseCodexRolloutFile } = require("./codex-rollout-parser");
 const { computeRowCost, getModelPricingInfo } = require("./pricing");
 const { normalizePerformance, mergePerformance, createClaudePerformanceCollector, createCodexPerformanceCollector, createZcodePerformanceCollector } = require("./session-performance");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
 const { resolveZcodeNativeDbPath, resolveInstallPaths } = require("./install-resolver");
+const { readCursorStateSummary } = require("./cursor-store");
 const { USD_TICKS_PER_USD, normalizeGrokUsage } = require("./grok-usage");
 const wsl = require("./wsl-probe");
 const {
@@ -1975,7 +1976,7 @@ async function discoverSessionFiles(home, env = process.env, deps = {}) {
   // it like the usage sync does (src/commands/sync.js): native candidate first
   // (ZCODE_HOME, home, win32 APPDATA fallback), then the WSL install when the
   // WSL mode probes it, picked with the same mode priority (default wsl-first)
-  // so the browser reads the same installs the usage card counts. "both"
+  // so the browser reads the same install the usage card counts. "both"
   // preserves both paths; the scanner merges shared session/event identities.
   const zcodePlatform = deps.platform || process.platform;
   const zcodeNativeDbPath = (deps.resolveZcodeNativeDbPath || resolveZcodeNativeDbPath)({ home, env, platform: zcodePlatform });
@@ -1991,14 +1992,14 @@ async function discoverSessionFiles(home, env = process.env, deps = {}) {
     : null;
   const zcodeExisting = (dbPath) => (dbPath && fs.existsSync(dbPath) ? dbPath : null);
   const zcodeWslDbPath = zcodeWslHome ? path.join(zcodeWslHome, "cli", "db", "db.sqlite") : null;
-  const zcodePaths = zcodePlatform === "win32"
-    ? wsl.resolveAllWin32Paths({
-      nativeValue: zcodeExisting(zcodeNativeDbPath),
-      wslValue: zcodeExisting(zcodeWslDbPath),
-      env,
-      platform: zcodePlatform,
-    })
-    : { native: zcodeExisting(zcodeNativeDbPath), wsl: null };
+  const zcodeNativeExisting = zcodeExisting(zcodeNativeDbPath);
+  const { cursors } = zcodePlatform === "win32"
+    ? await readCursorStateSummary({ trackerDir: path.join(home, ".tokentracker", "tracker") })
+    : {};
+  const zcodePaths = resolveZcodeInstallPaths({
+    nativeValue: zcodePlatform === "win32" ? zcodeNativeDbPath : zcodeNativeExisting,
+    wslValue: zcodeWslDbPath,
+  }, env, { platform: zcodePlatform, cursors });
   const zcode = [...new Set(Object.values(zcodePaths).filter(Boolean))];
   const opencodeNativeDir = env.OPENCODE_HOME || path.join(env.XDG_DATA_HOME || path.join(home, ".local", "share"), "opencode");
   const opencodeWslDir = zcodePlatform === "win32" && zcodeProbeWsl && wsl.shouldProbeWsl(env)

package/src/lib/upload-queue.js

@@ -122,7 +122,7 @@ async function compactPendingQueue({ queuePath, offset = 0, minPendingBytes = BA
     temporary = null;
     return { compacted: true, removedRecords, pendingBytesBefore, pendingBytesAfter };
   } catch (error) {
-    if (error.code === "ENOENT" && !input) return { compacted: false, removedRecords: 0, pendingBytesBefore: 0, pendingBytesAfter: 0 };
+    if (error.code === "ENOENT" && !input && !temporary) return { compacted: false, removedRecords: 0, pendingBytesBefore: 0, pendingBytesAfter: 0 };
     throw error;
   } finally {
     await input?.close();

package/dashboard/dist/assets/DialogDescription-ChbOGLc_.js

@@ -1 +0,0 @@
-import{r as n,K as a}from"./__vite-browser-external-CPskAZuH.js";import{u as p}from"./DialogTitle-BBxNf3O8.js";import{u as c}from"./composite-I_1t6PMI.js";const x=n.forwardRef(function(e,r){const{render:l,className:u,style:m,id:s,...t}=e,i=p(),o=c(s);return i.useSyncedValueWithCleanup("descriptionElementId",o),a("p",e,{ref:r,props:[{id:o},t]})});export{x as D};