tokentracker-cli 1.3.13 → 1.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokentracker-cli",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Local-first AI coding token usage and cost tracker for 45 tools, with a dashboard, desktop pet, widgets, achievements, and native macOS/Windows apps.",
   "main": "src/cli.js",
   "bin": {

package/src/commands/status.js

@@ -106,6 +106,7 @@ const {
   resolveCopilotAppDbPath,
   resolveCopilotAppDbPaths,
   probeWslDistros,
+  resolveZcodeInstallPaths,
 } = require("../lib/rollout");
 const {
   TRAE_CN_USAGE_ENV,
@@ -584,7 +585,10 @@ async function cmdStatus(argv = []) {
   const wslZcodeDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
     ? wsl.discoverWslHome(".zcode")
     : null;
-  const zcodePaths = resolveInstallPaths({ nativeValue: zcodeNativeValue, wslValue: wslZcodeDir ? path.join(wslZcodeDir, "cli", "db", "db.sqlite") : null });
+  const zcodePaths = resolveZcodeInstallPaths(
+    { nativeValue: zcodeNativeValue, wslValue: wslZcodeDir ? path.join(wslZcodeDir, "cli", "db", "db.sqlite") : null },
+    process.env, { cursors },
+  );
   const zcodeActive = formatResolvedPaths(zcodePaths);
   const zcodeInstalled = zcodeActive.length > 0;
   const zcodeDbPath = zcodeActive.join(" | ");

package/src/commands/sync.js

@@ -145,6 +145,8 @@ const {
   toUtcHalfHourStart,
   totalsKey,
   claudeMessageDedupKey,
+  hasZcodeCursorState,
+  resolveZcodeInstallPaths,
 } = require("../lib/rollout");
 const { computeClaudeGroundTruthBuckets } = require("../lib/claude-categorizer");
 const { createProgress, renderBar, formatNumber, formatBytes } = require("../lib/progress");
@@ -1733,8 +1735,23 @@ async function cmdSync(argv, context = {}) {
       const wslZcodeDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
         ? wsl.discoverWslHome(".zcode")
         : null;
-      const zcodePaths = resolveInstallPaths({ nativeValue: zcodeNativeValue, wslValue: wslZcodeDir ? path.join(wslZcodeDir, "cli", "db", "db.sqlite") : null });
+      const zcodeWslValue = wslZcodeDir ? path.join(wslZcodeDir, "cli", "db", "db.sqlite") : null;
+      const zcodePaths = resolveZcodeInstallPaths(
+        { nativeValue: zcodeNativeValue, wslValue: zcodeWslValue }, process.env,
+        { cursors },
+      );
       if (zcodePaths.native || zcodePaths.wsl) {
+        const mode = wsl.getWslMode(process.env);
+        if (process.platform === "win32" && ["native-first", "wsl-first"].includes(mode) &&
+            !cursors.zcodeInstallSelection && hasZcodeCursorState(cursors)) {
+          // Preserve legacy ownership before a repair can clear old buckets,
+          // even when the selected database currently has no rows to parse.
+          cursors.zcodeInstallSelection = {
+            mode, zcodeHome: process.env.ZCODE_HOME?.trim() || null,
+            dbPath: zcodePaths.native || zcodePaths.wsl,
+          };
+          cursorStore.requiresCommit = true;
+        }
         if (progress?.enabled) progress.start(`Parsing ZCode ${renderBar(0)} | buckets 0`);
         try {
           const nativeUsageAvailable = [zcodePaths.native, zcodePaths.wsl]
@@ -1761,6 +1778,16 @@ async function cmdSync(argv, context = {}) {
             cursors, getParams: (p) => ({ dbPath: p, readFn: readZcodeDbMessages, source: "zcode", cursorKey: "zcode" }),
             queuePath, projectQueuePath, onProgress: makeProviderProgress("ZCode"),
           });
+          if (zcodeResult.recordsProcessed > 0) {
+            if (process.platform === "win32" && ["native-first", "wsl-first"].includes(mode)) {
+              cursors.zcodeInstallSelection = {
+                mode, zcodeHome: process.env.ZCODE_HOME?.trim() || null,
+                dbPath: zcodePaths.native || zcodePaths.wsl,
+              };
+            } else {
+              delete cursors.zcodeInstallSelection;
+            }
+          }
         } catch (err) { warnProviderParseFailure("ZCode", err, opts); }
       }
     }

package/src/lib/jsonl-lines.js

@@ -5,6 +5,9 @@
  * only LF as a record separator so valid U+2028/U+2029 characters inside JSON
  * strings remain part of the record. Reading raw bytes keeps byte budgets exact
  * and lets malformed UTF-8 fail closed.
+ * Records longer than maxRecordBytes content bytes (excluding LF) are reported
+ * as { line: null, utf8Valid: null, oversized: true } without being buffered
+ * beyond the limit or decoded.
  */
 class PhysicalJsonlLimitError extends Error {
   constructor(maxPhysicalBytes) {
@@ -26,6 +29,7 @@ function decodePhysicalLine(buffer, { stripCr = false } = {}) {
 async function* physicalJsonlRecords(input, {
   invalidUtf8 = "throw",
   maxPhysicalBytes = Infinity,
+  maxRecordBytes = Infinity,
 } = {}) {
   if (invalidUtf8 !== "throw" && invalidUtf8 !== "record") {
     throw new TypeError(`unsupported invalidUtf8 policy: ${invalidUtf8}`);
@@ -33,8 +37,12 @@ async function* physicalJsonlRecords(input, {
   const byteLimit = Number.isFinite(maxPhysicalBytes)
     ? Math.max(0, Number(maxPhysicalBytes))
     : Infinity;
+  const recordLimit = Number.isFinite(maxRecordBytes)
+    ? Math.max(0, Number(maxRecordBytes))
+    : Infinity;
   const fragments = [];
   let fragmentsBytes = 0;
+  let oversized = false;
   let physicalBytesRead = 0;
 
   for await (const value of input) {
@@ -53,6 +61,17 @@ async function* physicalJsonlRecords(input, {
       if (physicalBytesRead + physicalBytes > byteLimit) {
         throw new PhysicalJsonlLimitError(byteLimit);
       }
+      const contentBytes = fragmentsBytes + fragment.length;
+      if (oversized || contentBytes > recordLimit) {
+        fragments.length = 0;
+        fragmentsBytes = 0;
+        oversized = false;
+        physicalBytesRead += physicalBytes;
+        start = newline + 1;
+        newline = chunk.indexOf(0x0a, start);
+        yield { line: null, utf8Valid: null, oversized: true, physicalBytes, terminated: true };
+        continue;
+      }
       const lineBuffer = fragments.length === 0
         ? fragment
         : Buffer.concat([...fragments, fragment], fragmentsBytes + fragment.length);
@@ -66,10 +85,10 @@ async function* physicalJsonlRecords(input, {
         line = decodePhysicalLine(lineBuffer, { stripCr: true });
       } catch (error) {
         if (invalidUtf8 === "throw") throw error;
-        yield { line: null, utf8Valid: false, physicalBytes, terminated: true };
+        yield { line: null, utf8Valid: false, oversized: false, physicalBytes, terminated: true };
         continue;
       }
-      yield { line, utf8Valid: true, physicalBytes, terminated: true };
+      yield { line, utf8Valid: true, oversized: false, physicalBytes, terminated: true };
     }
 
     if (start < chunk.length) {
@@ -77,12 +96,23 @@ async function* physicalJsonlRecords(input, {
       if (physicalBytesRead + fragmentsBytes + fragment.length > byteLimit) {
         throw new PhysicalJsonlLimitError(byteLimit);
       }
-      fragments.push(Buffer.from(fragment));
+      if (!oversized) {
+        if (fragmentsBytes + fragment.length > recordLimit) {
+          fragments.length = 0;
+          oversized = true;
+        } else {
+          fragments.push(Buffer.from(fragment));
+        }
+      }
       fragmentsBytes += fragment.length;
     }
   }
 
   if (fragmentsBytes > 0) {
+    if (oversized) {
+      yield { line: null, utf8Valid: null, oversized: true, physicalBytes: fragmentsBytes, terminated: false };
+      return;
+    }
     const lineBuffer = fragments.length === 1
       ? fragments[0]
       : Buffer.concat(fragments, fragmentsBytes);
@@ -94,7 +124,7 @@ async function* physicalJsonlRecords(input, {
       if (invalidUtf8 === "throw") throw error;
       utf8Valid = false;
     }
-    yield { line, utf8Valid, physicalBytes: fragmentsBytes, terminated: false };
+    yield { line, utf8Valid, oversized: false, physicalBytes: fragmentsBytes, terminated: false };
   }
 }
 

package/src/lib/pricing/curated-overrides.json

@@ -201,6 +201,25 @@
       "output": 7.5,
       "cache_read": 0.15
     },
+    "composer-2.5": {
+      "input": 0.5,
+      "output": 2.5,
+      "cache_read": 0.2,
+      "note": "Cursor Composer 2.5. Cursor Models & Pricing: $0.50/M input, $0.20/M cached input, $2.50/M output; no cache-write rate is published. https://cursor.com/docs/models-and-pricing"
+    },
+    "composer-2.5-fast": {
+      "input": 3.0,
+      "output": 15.0,
+      "cache_read": 0.5,
+      "note": "Cursor Composer 2.5 Fast. Cursor Models & Pricing: $3/M input, $0.50/M cached input, $15/M output. Kept separate from the cheaper base SKU."
+    },
+    "gemini-4-argon": {
+      "input": 2.0,
+      "output": 10.0,
+      "cache_read": 0.1,
+      "cache_write": 0,
+      "note": "Google Gemini 4 Argon introductory list rate (through 2026-11-30) matching Cursor Other Models pool: $2/M input, $0.10/M cached input, $10/M output. Effort suffixes (-high/-medium/-low/-minimal) are stripped by normalizeCursorModel. Sources: https://cursor.com/docs/models-and-pricing and https://ai.google.dev/gemini-api/docs/pricing"
+    },
     "MiniMax-M2.7": {
       "input": 0.3,
       "output": 1.2,
@@ -277,6 +296,34 @@
       "cache_write": 0,
       "note": "Cursor Grok 4.5 Fast rate. Cursor publishes $4/M input and $18/M output; the Cursor usage breakdown reports $1/M cached input. Kept separate from the cheaper base SKU."
     },
+    "cursor-grok-4.6": {
+      "input": 2.0,
+      "output": 6.0,
+      "cache_read": 0.5,
+      "cache_write": 0,
+      "note": "Cursor Grok 4.6 base rate. Cursor Models & Pricing: $2/M input, $0.50/M cached input, $6/M output; no cache-write rate is published."
+    },
+    "cursor-grok-4.6-fast": {
+      "input": 4.0,
+      "output": 12.0,
+      "cache_read": 1.0,
+      "cache_write": 0,
+      "note": "Cursor Grok 4.6 Fast rate. Cursor publishes $4/M input, $1/M cached input, $12/M output. Kept separate from the cheaper base SKU."
+    },
+    "cursor-grok-4.7": {
+      "input": 2.0,
+      "output": 6.0,
+      "cache_read": 0.5,
+      "cache_write": 0,
+      "note": "Cursor Grok 4.7 base rate. Cursor Models & Pricing: $2/M input, $0.50/M cached input, $6/M output. Long-context (>256k) premiums are not applied here yet because Cursor CSV rows do not expose per-request long-context flags."
+    },
+    "cursor-grok-4.7-fast": {
+      "input": 4.0,
+      "output": 12.0,
+      "cache_read": 1.0,
+      "cache_write": 0,
+      "note": "Cursor Grok 4.7 Fast rate. Cursor publishes $4/M input, $1/M cached input, $12/M output. Kept separate from the cheaper base SKU."
+    },
     "grok-4-0709": {
       "input": 3.0,
       "output": 15.0,

package/src/lib/pricing/matcher.js

@@ -122,7 +122,9 @@ function normalizeClaudeModel(model) {
 
 // Cursor decorates model ids with reasoning effort and sometimes places the
 // Claude version before the tier. Normalize those lookup-only aliases while
-// preserving Grok 4.5's distinct Fast SKU (its rate is not the base rate).
+// preserving Cursor Grok Fast SKUs (4.5/4.6/4.7 Fast rates are not the base
+// rates). Gemini 4 Argon effort suffixes (-high/-medium/-low/-minimal) are
+// stripped with the shared decorations set below.
 function normalizeCursorModel(model) {
   if (!model || typeof model !== "string") return model;
   let m = model
@@ -135,6 +137,12 @@ function normalizeCursorModel(model) {
   const parts = m.split("-");
   const isFast = parts.includes("fast");
 
+  if (/^(?:cursor-)?grok-4[.-]7(?:-|$)/.test(m)) {
+    return isFast ? "cursor-grok-4.7-fast" : "cursor-grok-4.7";
+  }
+  if (/^(?:cursor-)?grok-4[.-]6(?:-|$)/.test(m)) {
+    return isFast ? "cursor-grok-4.6-fast" : "cursor-grok-4.6";
+  }
   if (/^(?:cursor-)?grok-4[.-]5(?:-|$)/.test(m)) {
     return isFast ? "cursor-grok-4.5-fast" : "cursor-grok-4.5";
   }
@@ -142,8 +150,8 @@ function normalizeCursorModel(model) {
   // `fast` can be a separately priced SKU (for example composer-2-fast and
   // claude-opus-5-fast). Preserve it for the exact lookups below; when it is
   // merely a decoration, lookupPricing's later suffix-strip still falls back
-  // to the base LiteLLM model.
-  const decorations = new Set(["thinking", "xhigh", "high", "medium", "low"]);
+  // to the base LiteLLM model. Gemini Argon uses "minimal" as an effort level.
+  const decorations = new Set(["thinking", "xhigh", "high", "medium", "low", "minimal"]);
   m = parts.filter((part) => !decorations.has(part)).join("-");
   if (m.startsWith("claude-")) return normalizeClaudeModel(m);
   return m;