tokentracker-cli 0.87.8 → 0.87.9

package/src/commands/sync.js

@@ -83,6 +83,7 @@ const {
   listAntigravityTranscripts,
   parseAntigravityIncremental,
   resolveCodebuddyProjectFiles,
+  codebuddyJsonlHasUsage,
   parseCodebuddyIncremental,
   resolveWorkbuddyProjectFiles,
   parseWorkbuddyIncremental,
@@ -142,6 +143,7 @@ const CURSOR_UNKNOWN_MIGRATION_KEY = "cursorUnknownPurge_2026_04";
 const ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY = "rolloutCumulativeDeltaReparse_2026_05";
 const CLAUDE_MEM_OBSERVER_REINCLUDE_KEY = "claudeMemObserverReinclude_2026_05_v3";
 const GROK_APPEND_ONLY_REPAIR_MIGRATION_KEY = "grokAppendOnlyRepair_2026_05_v4";
+const CODEBUDDY_LOG_JSONL_REPAIR_KEY = "codebuddyLogJsonlOverlapRepair_2026_08";
 const CLAUDE_MEM_OBSERVER_PATH_SEGMENT = "--claude-mem-observer-sessions";
 // v1 had a cursor-format bug (wrote plain integer instead of {inode, offset,
 // updatedAt}), which made parseClaudeIncremental reread every jsonl from
@@ -589,7 +591,16 @@ async function cmdSync(argv, context = {}) {
       const wslCodexDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
         ? wsl.discoverWslHome(".codex")
         : null;
-      const codexPaths = resolveInstallPaths({ nativeValue: codexNativeValue, wslValue: wslCodexDir });
+      // resolveInstallPaths stays the single authority for wsl-first /
+      // native-first / wsl-only / native-only / both selection; requireAnyChild
+      // makes it validate that a candidate actually holds sessions/ or
+      // archived_sessions/ so an empty WSL ~/.codex shell cannot shadow the
+      // native install (issue #codex-wsl-shadow).
+      const codexPaths = resolveInstallPaths({
+        nativeValue: codexNativeValue,
+        wslValue: wslCodexDir,
+        requireAnyChild: ["sessions", "archived_sessions"],
+      });
       if (codexPaths.native) {
         sources.push({ source: "codex", sessionsDir: path.join(codexPaths.native, "sessions"), codexInventoryCache: true });
         if (!isBackgroundLightweightSync || backgroundCodexUsageRepair) {
@@ -1770,6 +1781,26 @@ async function cmdSync(argv, context = {}) {
     // Tencent's CodeBuddy CLI is a Claude Code clone; no hook system, so we
     // tail the per-session JSONL conversation logs incrementally on each sync.
     let codebuddyResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (isFullSourceScan && sourceAllowed("codebuddy")) {
+      const repairCodebuddyFiles = mergeBothFileSources({
+        resolveFiles: (env) => resolveCodebuddyProjectFiles({
+          ...env,
+          TOKENTRACKER_CODEBUDDY_LOG_FALLBACK: "1",
+        }),
+        env: process.env,
+      });
+      try {
+        await repairCodebuddyLogJsonlOverlap({
+          cursors,
+          queuePath,
+          queueStatePath,
+          codebuddyFiles: repairCodebuddyFiles,
+          env: process.env,
+        });
+      } catch (err) {
+        warnProviderParseFailure("CodeBuddy log/JSONL repair", err, opts);
+      }
+    }
     const codebuddyFiles = sourceAllowed("codebuddy")
       ? mergeBothFileSources({ resolveFiles: resolveCodebuddyProjectFiles, env: process.env })
       : [];
@@ -2730,6 +2761,7 @@ module.exports = {
   acquireSyncLock,
   migrateCursorUnknownBuckets,
   migrateRolloutCumulativeDeltaBuckets,
+  repairCodebuddyLogJsonlOverlap,
   repairCodexRescanInflation,
   repairCodexForkReplayInflation,
   repairCodexInterleavedUsageInflation,
@@ -2744,6 +2776,7 @@ module.exports = {
   recordCodexColdScanAudit,
   CURSOR_UNKNOWN_MIGRATION_KEY,
   ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY,
+  CODEBUDDY_LOG_JSONL_REPAIR_KEY,
   CODEX_RESCAN_DEDUP_REPAIR_KEY,
   CODEX_FORK_REPLAY_REPAIR_KEY,
   CODEX_USAGE_LINEAGE_REPAIR_KEY,
@@ -3809,6 +3842,217 @@ async function migrateRolloutCumulativeDeltaBuckets({ cursors, queuePath, rollou
   cursors.migrations[ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY] = new Date().toISOString();
 }
 
+function codebuddyUsageRowKey(row) {
+  if (!row || row.source !== "codebuddy") return null;
+  const model = typeof row.model === "string" && row.model ? row.model : "unknown";
+  const hourStart = typeof row.hour_start === "string" && row.hour_start ? row.hour_start : null;
+  return hourStart ? bucketKey("codebuddy", model, hourStart) : null;
+}
+
+function codebuddyZeroUsageRow(model, hourStart) {
+  return {
+    source: "codebuddy",
+    model: model || "unknown",
+    hour_start: hourStart,
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0,
+    billable_total_tokens: 0,
+    conversation_count: 0,
+  };
+}
+
+// Issue #403 historical repair. Before the JSONL usage fix, CodeBuddy could
+// ingest the same round-trip once from ~/.codebuddy/projects and once from the
+// IDE extension log. The forward resolver now disables logs whenever any JSONL
+// has usable rawUsage, but existing queues/hourly state need one guarded,
+// atomic rebuild so the old double-count is not left visible forever.
+async function repairCodebuddyLogJsonlOverlap({
+  cursors,
+  queuePath,
+  queueStatePath,
+  codebuddyFiles,
+  env = process.env,
+} = {}) {
+  if (!cursors || typeof cursors !== "object") return false;
+  const migrations = (cursors.migrations ||= {});
+  const prior = migrations[CODEBUDDY_LOG_JSONL_REPAIR_KEY];
+  if (prior && !(typeof prior === "object" && prior.skipped)) return false;
+
+  const files = Array.isArray(codebuddyFiles) ? codebuddyFiles : [];
+  const jsonlFiles = files.filter((filePath) => typeof filePath === "string" && filePath.endsWith(".jsonl"));
+  const logFiles = files.filter((filePath) => typeof filePath === "string" && filePath.endsWith(".log"));
+  const hasDetailedJsonl = jsonlFiles.some((filePath) => codebuddyJsonlHasUsage(filePath));
+
+  const hourly = cursors.hourly && typeof cursors.hourly === "object" ? cursors.hourly : {};
+  const liveHourlyKeys = new Set(
+    Object.keys(hourly.buckets || {}).filter((key) => key.startsWith("codebuddy|")),
+  );
+  let queueRaw = "";
+  try {
+    queueRaw = await fs.readFile(queuePath, "utf8");
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw e;
+  }
+  const queueCodebuddyKeys = new Set();
+  const keptQueueLines = [];
+  for (const line of queueRaw.split("\n")) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch (_e) {
+      keptQueueLines.push(line);
+      continue;
+    }
+    const key = codebuddyUsageRowKey(row);
+    if (!key) {
+      keptQueueLines.push(line);
+      continue;
+    }
+    queueCodebuddyKeys.add(key);
+  }
+  const liveKeys = new Set([...liveHourlyKeys, ...queueCodebuddyKeys]);
+  if (liveKeys.size === 0) {
+    migrations[CODEBUDDY_LOG_JSONL_REPAIR_KEY] = {
+      status: "noop",
+      appliedAt: new Date().toISOString(),
+      reason: "no-codebuddy-history",
+    };
+    return false;
+  }
+
+  // Keep this condition retryable when old CodeBuddy history exists but the
+  // extension log is temporarily rotated/missing. A permanent no-op here
+  // would close the repair window before a later full scan can rediscover it.
+  if (jsonlFiles.length === 0 || logFiles.length === 0 || !hasDetailedJsonl) {
+    migrations[CODEBUDDY_LOG_JSONL_REPAIR_KEY] = {
+      skipped: true,
+      reason: "no-mixed-detailed-sources",
+      at: new Date().toISOString(),
+    };
+    return false;
+  }
+
+  // A rebuild from the currently discoverable JSONL is safe only if every
+  // file previously tailed by CodeBuddy is still available in this scan. If a
+  // rotated/deleted log is missing, retain the user's history and retry later
+  // rather than silently erasing an unreproducible bucket.
+  const discovered = new Set(files);
+  const priorFiles = cursors.codebuddy?.fileOffsets && typeof cursors.codebuddy.fileOffsets === "object"
+    ? Object.keys(cursors.codebuddy.fileOffsets)
+    : [];
+  const missingPriorFile = priorFiles.find((filePath) => !discovered.has(filePath));
+  if (missingPriorFile) {
+    migrations[CODEBUDDY_LOG_JSONL_REPAIR_KEY] = {
+      skipped: true,
+      reason: "codebuddy_file_unreproducible",
+      filePath: missingPriorFile,
+      at: new Date().toISOString(),
+    };
+    return false;
+  }
+
+  const tmpQueue = `${queuePath}.codebuddyrebuild.${process.pid}.${Date.now()}`;
+  const tmpCursors = {
+    version: 1,
+    hourly: { buckets: {}, groupQueued: {} },
+    codebuddy: {},
+  };
+  let rebuiltRows = [];
+  try {
+    await parseCodebuddyIncremental({
+      projectFiles: jsonlFiles,
+      cursors: tmpCursors,
+      queuePath: tmpQueue,
+      env,
+    });
+    let rebuiltRaw = "";
+    try {
+      rebuiltRaw = await fs.readFile(tmpQueue, "utf8");
+    } catch (e) {
+      if (e?.code !== "ENOENT") throw e;
+    }
+    rebuiltRows = rebuiltRaw.split("\n").filter((line) => line.trim());
+  } catch (e) {
+    console.error("[sync] CodeBuddy log/JSONL repair: rebuild failed, leaving history untouched:", e?.message || e);
+    return false;
+  } finally {
+    await fs.rm(tmpQueue, { force: true }).catch(() => {});
+  }
+
+  const rebuiltKeys = new Set();
+  const validRebuiltRows = [];
+  for (const line of rebuiltRows) {
+    let row;
+    try { row = JSON.parse(line); } catch (_e) { continue; }
+    const key = codebuddyUsageRowKey(row);
+    if (!key) continue;
+    rebuiltKeys.add(key);
+    validRebuiltRows.push(line);
+  }
+  if (rebuiltKeys.size === 0) {
+    migrations[CODEBUDDY_LOG_JSONL_REPAIR_KEY] = {
+      skipped: true,
+      reason: "jsonl_rebuild_empty",
+      at: new Date().toISOString(),
+    };
+    return false;
+  }
+
+  const staleRetractions = [];
+  for (const key of liveKeys) {
+    if (rebuiltKeys.has(key)) continue;
+    const [, model, ...hourParts] = key.split("|");
+    staleRetractions.push(JSON.stringify(codebuddyZeroUsageRow(model, hourParts.join("|"))));
+  }
+
+  const nextQueueLines = keptQueueLines.concat(staleRetractions, validRebuiltRows);
+  await ensureDir(path.dirname(queuePath));
+  const queueTmp = `${queuePath}.tmp.${process.pid}.${Date.now()}`;
+  await fs.writeFile(queueTmp, nextQueueLines.length ? `${nextQueueLines.join("\n")}\n` : "", "utf8");
+  await fs.rename(queueTmp, queuePath);
+
+  const nextHourly = (cursors.hourly ||= { buckets: {}, groupQueued: {} });
+  nextHourly.buckets ||= {};
+  nextHourly.groupQueued ||= {};
+  for (const key of Object.keys(nextHourly.buckets)) {
+    if (key.startsWith("codebuddy|")) delete nextHourly.buckets[key];
+  }
+  for (const key of Object.keys(nextHourly.groupQueued)) {
+    if (key.startsWith("codebuddy|")) delete nextHourly.groupQueued[key];
+  }
+  for (const [key, bucket] of Object.entries(tmpCursors.hourly.buckets || {})) {
+    if (key.startsWith("codebuddy|")) nextHourly.buckets[key] = bucket;
+  }
+  for (const [key, value] of Object.entries(tmpCursors.hourly.groupQueued || {})) {
+    if (key.startsWith("codebuddy|")) nextHourly.groupQueued[key] = value;
+  }
+  cursors.codebuddy = tmpCursors.codebuddy || {};
+
+  let uploadState = {};
+  try { uploadState = JSON.parse(await fs.readFile(queueStatePath, "utf8")); } catch (_e) {}
+  uploadState.offset = 0;
+  uploadState.updatedAt = new Date().toISOString();
+  uploadState.note = "reset_after_codebuddy_log_jsonl_repair_2026_08";
+  await ensureDir(path.dirname(queueStatePath));
+  await fs.writeFile(queueStatePath, JSON.stringify(uploadState, null, 2) + "\n", "utf8");
+
+  migrations[CODEBUDDY_LOG_JSONL_REPAIR_KEY] = {
+    status: "applied",
+    appliedAt: new Date().toISOString(),
+    jsonlFiles: jsonlFiles.length,
+    logFiles: logFiles.length,
+    previousBuckets: liveKeys.size,
+    rebuiltBuckets: rebuiltKeys.size,
+    retractedBuckets: staleRetractions.length,
+  };
+  return true;
+}
+
 // One-time repair (#187): rebuild codex hourly buckets that the inode-keyed
 // re-scan double-counted before the codexHashes event-dedup landed, and push
 // the corrected values to the cloud. Runs BEFORE the codex parse in the same

package/src/lib/install-resolver.js

@@ -1,18 +1,29 @@
 const fssync = require("node:fs");
+const path = require("node:path");
 const wsl = require("./wsl-probe");
 
-function resolveInstallPaths({ nativeValue, wslDir, wslValue } = {}, env = process.env, deps = {}) {
-  if (process.platform !== "win32") {
+function resolveInstallPaths({ nativeValue, wslDir, wslValue, requireAnyChild } = {}, env = process.env, deps = {}) {
+  const platform = deps.platform || process.platform;
+  if (platform !== "win32") {
     return { native: nativeValue ?? null, wsl: null };
   }
 
+  // requireAnyChild (opt-in): a candidate install must hold at least one of
+  // the named children (e.g. "sessions"/"archived_sessions") to qualify — an
+  // empty shell dir must not shadow a populated install. For wslDir discovery
+  // the check is folded into the existsSync probe so discoverWslHome skips an
+  // empty-shell distro and continues to the next one.
+  const populated = (p) => !requireAnyChild || hasAnyChild(p, requireAnyChild, deps.existsSync);
+  const wslExists = requireAnyChild
+    ? (p) => Boolean(pathExists(p, deps.existsSync)) && hasAnyChild(p, requireAnyChild, deps.existsSync)
+    : deps.existsSync;
   const wslCandidate = wslValue !== undefined
-    ? (wsl.shouldProbeWsl(env) && pathExists(wslValue, deps.existsSync) ? wslValue : null)
-    : (wslDir && wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(wslDir, { ...deps, env }) : null);
-  const nativeCandidate = wsl.shouldProbeNative(env) && nativeValue
+    ? (wsl.shouldProbeWsl(env) && pathExists(wslValue, deps.existsSync) && populated(wslValue) ? wslValue : null)
+    : (wslDir && wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(wslDir, { ...deps, env, existsSync: wslExists }) : null);
+  const nativeCandidate = wsl.shouldProbeNative(env) && nativeValue && populated(nativeValue)
     ? pathExists(nativeValue, deps.existsSync) : null;
 
-  return wsl.resolveAllWin32Paths({ nativeValue: nativeCandidate, wslValue: wslCandidate, env, platform: "win32" });
+  return wsl.resolveAllWin32Paths({ nativeValue: nativeCandidate, wslValue: wslCandidate, env, platform });
 }
 
 function pathExists(p, existsSync) {
@@ -20,6 +31,11 @@ function pathExists(p, existsSync) {
   try { return (existsSync || fssync.existsSync)(p) ? p : null; } catch (_e) { return null; }
 }
 
+function hasAnyChild(p, children, existsSync) {
+  const ex = existsSync || fssync.existsSync;
+  return children.some((c) => { try { return ex(path.join(p, c)); } catch (_e) { return false; } });
+}
+
 // Migrate a flat (single-install) cursor to { native, wsl } namespaces.
 // `activeKeys` names the namespaces seeded with a copy of the flat state; the
 // others start empty so their install's full history backfills on first parse.