npm - tokentracker-cli - Versions diffs - 0.84.6 → 0.84.8 - Mend

tokentracker-cli 0.84.6 → 0.84.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (118) hide show

package/dashboard/dist/share.html CHANGED Viewed

@@ -75,8 +75,8 @@
         "description": "Shareable Token Tracker dashboard snapshot."
       }
     </script>
-    <script type="module" crossorigin src="/assets/__vite-browser-external-UqlSqI-1.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/__vite-browser-external-WKilYZnq.css">
+    <script type="module" crossorigin src="/assets/__vite-browser-external-C3VH6nS4.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/__vite-browser-external-hXV_ZYTG.css">
   </head>
   <body>
     <main class="aeo-seed-content" aria-label="Token Tracker share page summary">

package/package.json CHANGED Viewed

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

package/src/commands/init.js CHANGED Viewed

@@ -124,6 +124,7 @@ const SUPPORTED_PROVIDERS = [
   "Droid",
   "Mimo",
   "ZCode",
+  "Qoder",
   "AnythingLLM Desktop",
 ];

package/src/commands/status.js CHANGED Viewed

@@ -62,6 +62,7 @@ const {
   resolveKilocodeTaskFiles,
   resolveRoocodeTaskFiles,
   resolveZedDbPath,
+  resolveQoderDbPaths,
   resolveAnythingllmDbPath,
   resolveGooseDbPath,
   listDroidSettingsFiles,
@@ -321,6 +322,16 @@ async function cmdStatus(argv = []) {
   const zcodeInstalled = zcodeActive.length > 0;
   const zcodeDbPath = zcodeActive.join(" | ");
+  // Qoder Desktop 1.18+ — token usage lives in SharedClientCache/local.db.
+  const qoderPaths = resolveQoderDbPaths({
+    home,
+    env: process.env,
+    platform: process.platform,
+  });
+  const qoderActive = formatResolvedPaths(qoderPaths);
+  const qoderInstalled = qoderActive.length > 0;
+  const qoderDbPath = qoderActive.join(" | ");
   // OpenCode (JSON files + SQLite DB) — passive scan of storage/message/ and opencode.db.
   const opencodeStorageNativeValue = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
   const wslOpencodeStorageDir = process.platform === "win32" && shouldProbeWsl(process.env)
@@ -673,6 +684,9 @@ async function cmdStatus(argv = []) {
         zcode: zcodeInstalled
           ? { installed: true, detail: zcodeDbPath }
           : { installed: false },
+        qoder: qoderInstalled
+          ? { installed: true, detail: qoderDbPath }
+          : { installed: false },
         kilocode: kilocodeInstalled
           ? { installed: true, files: kilocodeTaskFiles.length }
           : { installed: false },
@@ -785,6 +799,9 @@ async function cmdStatus(argv = []) {
       zcodeInstalled
         ? `- ZCode: passive reader (${zcodeDbPath})`
         : null,
+      qoderInstalled
+        ? `- Qoder: passive reader (${qoderDbPath})`
+        : null,
       opencodeInstalled
         ? `- OpenCode: passive reader (storage: ${opencodeStorageActive.join(" | ") || "not found"}, DB: ${opencodeDbActive.join(" | ") || "not found"})`
         : null,

package/src/commands/sync.js CHANGED Viewed

@@ -20,6 +20,8 @@ const {
   readOpencodeDbMessages,
   readMimoDbMessages,
   readZcodeDbMessages,
+  resolveQoderDbPaths,
+  readQoderDbMessages,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
   resolveHermesPath,
@@ -35,6 +37,7 @@ const {
   parseGeminiIncremental,
   parseOpencodeIncremental,
   parseOpencodeDbIncremental,
+  parseQoderDbIncremental,
   parseOpenclawIncremental,
   parseCursorApiIncremental,
   parseKiroIncremental,
@@ -198,7 +201,10 @@ const CODEX_FORK_REPLAY_REPAIR_KEY = "codexForkReplayRepair_2026_07";
 // interleaved SessionState instances. Older parsers subtracted each cumulative
 // total from the most recently observed total, even when it belonged to another
 // state, which could turn an ordinary turn into a multi-billion-token delta.
-const CODEX_USAGE_LINEAGE_REPAIR_KEY = "codexUsageLineageRepair_2026_07";
+// v2 removes the unreliable multi_agent_version pre-gate and validates every
+// contributing rollout before committing the rebuild. The new key is required
+// so installs that finalized the original migration on a false negative retry.
+const CODEX_USAGE_LINEAGE_REPAIR_KEY = "codexUsageLineageRepair_2026_07_v2";
 // Keep the one escalated desktop refresh bounded; explicit full syncs can retry
 // the same migration without this ceiling when the history needs a deeper scan.
 const CODEX_BACKGROUND_LINEAGE_SCAN_MAX_BYTES = 1024 * 1024;
@@ -249,6 +255,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "opencode",
   "openclaw",
   "pi",
+  "qoder",
   "roocode",
   "workbuddy",
   "zcode",
@@ -974,6 +981,47 @@ async function cmdSync(argv, context = {}) {
       };
     }
+    let qoderResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (sourceAllowed("qoder")) {
+      const qoderPaths = resolveQoderDbPaths({
+        home,
+        env: process.env,
+        platform: process.platform,
+      });
+      if (qoderPaths.native || qoderPaths.wsl) {
+        if (progress?.enabled) {
+          progress.start(`Parsing Qoder ${renderBar(0)} | buckets 0`);
+        }
+        try {
+          const result = await multiInstallParse({
+            paths: qoderPaths,
+            parserFn: async ({ dbPath, ...rest }) => {
+              const dbMessages = await readQoderDbMessages(dbPath);
+              const parsed = await parseQoderDbIncremental({ dbMessages, ...rest });
+              return {
+                recordsProcessed: parsed.messagesProcessed || 0,
+                eventsAggregated: parsed.eventsAggregated || 0,
+                bucketsQueued: parsed.bucketsQueued || 0,
+              };
+            },
+            providerName: "qoder",
+            cursors,
+            queuePath,
+            projectQueuePath,
+            getParams: (dbPath) => ({ dbPath }),
+            onProgress: makeProviderProgress("Qoder"),
+          });
+          qoderResult = {
+            recordsProcessed: result.recordsProcessed || 0,
+            eventsAggregated: result.eventsAggregated || 0,
+            bucketsQueued: result.bucketsQueued || 0,
+          };
+        } catch (err) {
+          warnProviderParseFailure("Qoder", err, opts);
+        }
+      }
+    }
     async function parseOpencodeDbForInstall({ dbPath, readFn, source, cursorKey, ...rest }) {
       if (!dbPath || !fssync.existsSync(dbPath)) {
         return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
@@ -2068,6 +2116,7 @@ async function cmdSync(argv, context = {}) {
       geminiResult.filesProcessed +
       antigravityResult.filesProcessed +
       opencodeResult.filesProcessed +
+      qoderResult.recordsProcessed +
       cursorResult.recordsProcessed +
       kiroResult.recordsProcessed +
       kiroCliResult.recordsProcessed +
@@ -2097,6 +2146,7 @@ async function cmdSync(argv, context = {}) {
       geminiResult.bucketsQueued +
       antigravityResult.bucketsQueued +
       opencodeResult.bucketsQueued +
+      qoderResult.bucketsQueued +
       cursorResult.bucketsQueued +
       kiroResult.bucketsQueued +
       kiroCliResult.bucketsQueued +
@@ -3479,6 +3529,7 @@ async function repairCodexRescanInflation({
   projectQueuePath,
   projectQueueStatePath,
   rolloutFiles,
+  expectedCodexFileSnapshots = null,
   // The fork-replay repair (#169 follow-up) re-runs this exact rebuild under
   // its own key: the rebuild always uses the CURRENT parser, so any parser fix
   // shipped since the last run is applied to the rebuilt history.
@@ -3667,6 +3718,16 @@ async function repairCodexRescanInflation({
     }
   }
+  const rebuildValidation = expectedCodexFileSnapshots instanceof Map
+    ? await validateCodexRebuildFileSnapshots(rebuilt.files, expectedCodexFileSnapshots)
+    : { ok: true };
+  if (!rebuildValidation.ok) {
+    console.error(
+      `[sync] codex rescan repair: ${rebuildValidation.reason} — skipping to avoid data loss`,
+    );
+    return false;
+  }
   // COMMIT (only after a verified rebuild). A crash partway just leaves the
   // migration to re-run next sync — re-rebuild + re-strip + re-commit converges.
   //
@@ -3903,10 +3964,11 @@ async function repairCodexForkReplayInflation({
 }
 // Rebuild historical Codex usage only when a rollout proves that the old
-// single-baseline parser crossed cumulative SessionState lineages. The cheap
-// head gate keeps the one-time migration from fully reading installations that
-// predate Codex multi-agent support; the rebuild itself retains the existing
-// missing-history, project-queue, atomic-swap, and upload-reset guards.
+// single-baseline parser crossed cumulative SessionState lineages. Detection is
+// based on the token counter stream itself, not multi_agent_version metadata:
+// affected legacy rollouts can predate that marker or carry it only in the
+// middle of a large file. Every contributing rollout must also be valid and
+// stable before the atomic rebuild can replace live history.
 async function repairCodexInterleavedUsageInflation({
   cursors,
   queuePath,
@@ -3961,8 +4023,9 @@ async function repairCodexInterleavedUsageInflation({
     projectQueuePath,
     projectQueueStatePath,
     rolloutFiles,
+    expectedCodexFileSnapshots: scan.fileSnapshots,
     migrationKey: CODEX_USAGE_LINEAGE_REPAIR_KEY,
-    uploadNote: "reset_after_codex_usage_lineage_2026_07",
+    uploadNote: "reset_after_codex_usage_lineage_2026_07_v2",
   });
 }
@@ -3970,138 +4033,41 @@ async function scanForInterleavedCodexUsage(
   rolloutFiles,
   { maxLineageScanBytes = Infinity } = {},
 ) {
+  let affected = false;
+  let remainingBytes = Number.isFinite(maxLineageScanBytes)
+    ? Math.max(0, maxLineageScanBytes)
+    : Infinity;
+  const fileSnapshots = new Map();
+  const seenPaths = new Set();
   for (const entry of Array.isArray(rolloutFiles) ? rolloutFiles : []) {
     const fp = typeof entry === "string" ? entry : entry?.path;
     const src = typeof entry === "string" ? "codex" : String(entry?.source || "codex");
-    if (!fp || src !== "codex") continue;
-    const head = await scanCodexMultiAgentHead(fp);
-    if (head.indeterminate) return { affected: false, indeterminate: true };
-    if (!head.candidate) continue;
+    if (!fp || src !== "codex" || seenPaths.has(fp)) continue;
+    seenPaths.add(fp);
-    const lineage = await scanCodexUsageLineages(fp, maxLineageScanBytes);
-    if (lineage.indeterminate) return { affected: false, indeterminate: true };
-    if (lineage.affected) return { affected: true, indeterminate: false };
-  }
-  return { affected: false, indeterminate: false };
-}
-// New rollouts emit multi_agent_version in the initial turn_context. A session
-// created by an older Codex build can later be resumed under a multi-agent
-// build, though, so an inactive initial context also checks the final context
-// from a bounded tail read. The 1 MiB ceilings protect this one-time migration
-// from malformed metadata; an inconclusive bound is retryable, never a final
-// "not affected" verdict.
-async function scanCodexMultiAgentHead(filePath) {
-  const MAX_BYTES = 1024 * 1024;
-  let stream = null;
-  let rl = null;
-  let needsTail = false;
-  try {
-    stream = fssync.createReadStream(filePath, {
-      encoding: "utf8",
-      highWaterMark: 32 * 1024,
-    });
-    rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let bytesRead = 0;
-    for await (const line of rl) {
-      bytesRead += Buffer.byteLength(line, "utf8") + 1;
-      if (line.includes('"turn_context"')) {
-        let obj;
-        try {
-          obj = JSON.parse(line);
-        } catch (_e) {
-          return { candidate: false, indeterminate: true };
-        }
-        if (obj?.type === "turn_context") {
-          if (isActiveMultiAgentVersion(obj?.payload?.multi_agent_version)) {
-            return { candidate: true, indeterminate: false };
-          }
-          needsTail = true;
-        }
-      }
-      if (line.includes('"token_count"')) {
-        needsTail = true;
-        break;
-      }
-      if (bytesRead >= MAX_BYTES) return { candidate: false, indeterminate: true };
+    const lineage = await scanCodexUsageLineages(fp, remainingBytes);
+    if (lineage.indeterminate) {
+      return { affected: false, indeterminate: true, fileSnapshots: new Map() };
     }
-  } catch (_e) {
-    return { candidate: false, indeterminate: true };
-  } finally {
-    if (rl) rl.close();
-    if (stream) stream.destroy();
-  }
-  if (needsTail) return scanCodexMultiAgentTail(filePath);
-  return { candidate: false, indeterminate: false };
-}
-async function scanCodexMultiAgentTail(filePath) {
-  const MAX_BYTES = 1024 * 1024;
-  let handle = null;
-  try {
-    handle = await fs.open(filePath, "r");
-    const stat = await handle.stat();
-    const size = Number(stat.size || 0);
-    const start = Math.max(0, size - MAX_BYTES);
-    const length = Math.max(0, size - start);
-    const buffer = Buffer.alloc(length);
-    let bytesRead = 0;
-    while (bytesRead < length) {
-      const result = await handle.read(
-        buffer,
-        bytesRead,
-        length - bytesRead,
-        start + bytesRead,
-      );
-      if (result.bytesRead <= 0) break;
-      bytesRead += result.bytesRead;
-    }
-    if (bytesRead !== length) return { candidate: false, indeterminate: true };
-    const lines = buffer.toString("utf8").split("\n");
-    if (start > 0) lines.shift(); // discard a line truncated by the tail boundary
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-      const line = lines[index];
-      if (!line.includes('"turn_context"')) continue;
-      let obj;
-      try {
-        obj = JSON.parse(line);
-      } catch (_e) {
-        return { candidate: false, indeterminate: true };
-      }
-      if (obj?.type !== "turn_context") continue;
-      return {
-        candidate: isActiveMultiAgentVersion(obj?.payload?.multi_agent_version),
-        indeterminate: false,
-      };
+    affected ||= lineage.affected;
+    fileSnapshots.set(fp, lineage.fileSnapshot);
+    if (Number.isFinite(remainingBytes)) {
+      remainingBytes = Math.max(0, remainingBytes - lineage.bytesRead);
     }
-    return { candidate: false, indeterminate: start > 0 };
-  } catch (_e) {
-    return { candidate: false, indeterminate: true };
-  } finally {
-    if (handle) await handle.close().catch(() => {});
   }
-}
-function isActiveMultiAgentVersion(value) {
-  if (value === true) return true;
-  if (typeof value !== "string") return false;
-  const normalized = value.trim().toLowerCase();
-  return Boolean(
-    normalized &&
-      normalized !== "off" &&
-      normalized !== "none" &&
-      normalized !== "disabled",
-  );
+  return { affected, indeterminate: false, fileSnapshots };
 }
 async function scanCodexUsageLineages(filePath, maxBytes = Infinity) {
   let stream = null;
   let rl = null;
   try {
+    const before = await readCodexFileSnapshot(filePath);
     const state = createUsageDeltaState();
     const byteLimit = Number.isFinite(maxBytes) ? Math.max(0, maxBytes) : Infinity;
     let bytesRead = 0;
+    let affected = false;
     stream = fssync.createReadStream(filePath, {
       encoding: "utf8",
       highWaterMark: 32 * 1024,
@@ -4110,22 +4076,31 @@ async function scanCodexUsageLineages(filePath, maxBytes = Infinity) {
     for await (const line of rl) {
       bytesRead += Buffer.byteLength(line, "utf8") + 1;
       if (bytesRead > byteLimit) return { affected: false, indeterminate: true };
-      if (!line.includes('"token_count"')) continue;
+      if (!line.trim()) continue;
       let obj;
       try {
         obj = JSON.parse(line);
       } catch (_e) {
-        continue;
+        return { affected: false, indeterminate: true };
       }
       const token = extractTokenCount(obj);
       const info = token?.info;
       if (!info || typeof info !== "object") continue;
       consumeUsageDelta(state, info.last_token_usage, info.total_token_usage);
       if (state.sawInterleaved || state.sawDivergentCumulative) {
-        return { affected: true, indeterminate: false };
+        affected = true;
       }
     }
-    return { affected: false, indeterminate: false };
+    const after = await readCodexFileSnapshot(filePath);
+    if (!sameCodexFileSnapshot(before, after)) {
+      return { affected: false, indeterminate: true };
+    }
+    return {
+      affected,
+      indeterminate: false,
+      bytesRead,
+      fileSnapshot: after,
+    };
   } catch (_e) {
     return { affected: false, indeterminate: true };
   } finally {
@@ -4134,6 +4109,51 @@ async function scanCodexUsageLineages(filePath, maxBytes = Infinity) {
   }
 }
+async function readCodexFileSnapshot(filePath) {
+  const stat = await fs.stat(filePath);
+  return {
+    size: Number(stat.size),
+    mtimeMs: Number(stat.mtimeMs),
+    ctimeMs: Number(stat.ctimeMs),
+    ino: Number(stat.ino),
+    dev: Number(stat.dev),
+  };
+}
+function sameCodexFileSnapshot(left, right) {
+  return Boolean(
+    left &&
+      right &&
+      left.size === right.size &&
+      left.mtimeMs === right.mtimeMs &&
+      left.ctimeMs === right.ctimeMs &&
+      left.ino === right.ino &&
+      left.dev === right.dev
+  );
+}
+async function validateCodexRebuildFileSnapshots(rebuiltFiles, expectedSnapshots) {
+  for (const [filePath, expected] of expectedSnapshots) {
+    let actual;
+    try {
+      actual = await readCodexFileSnapshot(filePath);
+    } catch (_e) {
+      return { ok: false, reason: "a scanned rollout became unreadable during rebuild" };
+    }
+    if (!sameCodexFileSnapshot(expected, actual)) {
+      return { ok: false, reason: "a scanned rollout changed during rebuild" };
+    }
+    const rebuiltCursor = rebuiltFiles?.[filePath];
+    if (!rebuiltCursor) {
+      return { ok: false, reason: "the rebuild omitted a scanned rollout cursor" };
+    }
+    if (Number(rebuiltCursor.offset) !== expected.size) {
+      return { ok: false, reason: "the rebuild did not consume a scanned rollout through EOF" };
+    }
+  }
+  return { ok: true };
+}
 function isCodexHistoryCovered(cursors, rolloutFiles) {
   const scannedPaths = new Set();
   const scannedSessionIds = new Set();

package/src/lib/local-api.js CHANGED Viewed

@@ -2684,7 +2684,10 @@ function createLocalApiHandler({ queuePath }) {
             json(res, { importable, codexDetected: importable.length > 0 });
             return true;
           }
-          json(res, { pets: pets.listInstalledPets() });
+          json(res, {
+            pets: pets.listInstalledPets(),
+            hiddenBuiltinIds: pets.readHiddenBuiltinIds(),
+          });
           return true;
         }
         if (method === "POST") {

package/src/lib/pet-packages.js CHANGED Viewed

@@ -10,6 +10,8 @@ const MAX_PACKAGE_BYTES = 12 * 1024 * 1024;
 const MAX_MANIFEST_BYTES = 16 * 1024;
 const MAX_SPRITESHEET_BYTES = 10 * 1024 * 1024;
 const BUILTIN_IDS = new Set(["clawd", "sprout", "byte", "ember"]);
+const REMOVABLE_BUILTIN_IDS = new Set(["sprout", "byte", "ember"]);
+const HIDDEN_BUILTINS_FILE = ".hidden-builtins.json";
 // codex-pets.net added `kind` to pet.json long after launch, and its enum may keep
 // growing — packages published before that (and future kinds) must stay importable,
 // so kind is optional metadata validated only as a short slug.
@@ -35,6 +37,44 @@ function resolveCodexPetsDir() {
   );
 }
+function readHiddenBuiltinIds() {
+  const file = path.join(resolvePetsDir(), HIDDEN_BUILTINS_FILE);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    return [...new Set(parsed
+      .map((id) => String(id || "").trim().toLowerCase())
+      .filter((id) => REMOVABLE_BUILTIN_IDS.has(id)))].sort();
+  } catch {
+    return [];
+  }
+}
+function hideBuiltinPet(id) {
+  const normalized = String(id || "").trim().toLowerCase();
+  if (normalized === "clawd") throw new Error("Clawd cannot be removed");
+  if (!REMOVABLE_BUILTIN_IDS.has(normalized)) throw new Error("Invalid built-in pet id");
+  const root = resolvePetsDir();
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  const hidden = new Set(readHiddenBuiltinIds());
+  hidden.add(normalized);
+  const destination = path.join(root, HIDDEN_BUILTINS_FILE);
+  const stage = path.join(root, `${HIDDEN_BUILTINS_FILE}.${process.pid}-${crypto.randomBytes(6).toString("hex")}`);
+  const backup = `${stage}-backup`;
+  try {
+    fs.writeFileSync(stage, `${JSON.stringify([...hidden].sort(), null, 2)}\n`, { mode: 0o600 });
+    if (fs.existsSync(destination)) fs.renameSync(destination, backup);
+    fs.renameSync(stage, destination);
+  } catch (error) {
+    try { fs.rmSync(stage, { force: true }); } catch {}
+    if (!fs.existsSync(destination) && fs.existsSync(backup)) fs.renameSync(backup, destination);
+    throw error;
+  }
+  try { fs.rmSync(backup, { force: true }); } catch {}
+  return { id: normalized, hidden: true };
+}
 function readUInt24LE(buffer, offset) {
   return buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16);
 }
@@ -368,10 +408,11 @@ async function installFromCodexPets(input, fetchImpl = fetch) {
 function removeInstalledPet(id) {
   const normalized = String(id || "").trim().toLowerCase();
-  if (!PET_ID_RE.test(normalized) || BUILTIN_IDS.has(normalized)) throw new Error("Invalid custom pet id");
+  if (!PET_ID_RE.test(normalized)) throw new Error("Invalid pet id");
+  if (BUILTIN_IDS.has(normalized)) return hideBuiltinPet(normalized);
   const root = resolvePetsDir();
   const destination = path.join(root, normalized);
-  if (!destination.startsWith(`${root}${path.sep}`)) throw new Error("Invalid custom pet path");
+  if (!destination.startsWith(`${root}${path.sep}`)) throw new Error("Invalid pet path");
   fs.rmSync(destination, { recursive: true, force: true });
   petDirectoryCache.delete(destination);
   return { id: normalized };
@@ -627,6 +668,7 @@ module.exports = {
   petIdFromCodexPetsUrl,
   readCodexBuiltinPets,
   readCodexImportableAsset,
+  readHiddenBuiltinIds,
   readWebpDimensions,
   removeInstalledPet,
   resolveCodexPetsDir,