tokentracker-cli 0.67.0 → 0.68.1

package/src/lib/rollout.js

@@ -7,6 +7,7 @@ const crypto = require("node:crypto");
 const { ensureDir } = require("./fs");
 const { readSqliteJsonRows } = require("./sqlite-reader");
 const wsl = require("./wsl-probe");
+const { resolveInstallPaths } = require("./install-resolver");
 
 const DEFAULT_SOURCE = "codex";
 const DEFAULT_MODEL = "unknown";
@@ -3787,23 +3788,11 @@ function resolveHermesPath(env = process.env, deps = {}) {
   }
   const home = require("node:os").homedir();
   const defaultPath = path.join(home, ".hermes");
-  // On Windows, scan BOTH the native install (%LOCALAPPDATA%\hermes) and
-  // any WSL distros running Hermes Agent. Each install has its own independent
-  // state.db with different sessions, so there is no double-counting risk.
-  // TOKENTRACKER_WSL_MODE controls which source takes priority.
   if (process.platform === "win32") {
-    let nativePath = null;
-    if (wsl.shouldProbeNative(env)) {
-      const localAppData = typeof env.LOCALAPPDATA === "string" ? env.LOCALAPPDATA.trim() : "";
-      if (localAppData.length > 0) {
-        const candidate = path.join(localAppData, "hermes");
-        try {
-          if (fssync.existsSync(candidate)) nativePath = candidate;
-        } catch (_e) { }
-      }
-    }
-    const wslPath = wsl.shouldProbeWsl(env) ? discoverWslHermesHome(deps) : null;
-    const picked = wsl.pickWin32Path({ wslValue: wslPath, nativeValue: nativePath, env, platform: "win32" });
+    const localAppData = typeof env.LOCALAPPDATA === "string" ? env.LOCALAPPDATA.trim() : "";
+    const nativeValue = localAppData.length > 0 ? path.join(localAppData, "hermes") : null;
+    const paths = resolveInstallPaths({ nativeValue, wslDir: ".hermes" }, env, deps);
+    const picked = paths.native || paths.wsl;
     if (picked) return picked;
     const mode = wsl.getWslMode(env);
     if (mode === "wsl-only" || mode === "native-only") return null;
@@ -3838,17 +3827,13 @@ function discoverWslHermesHome(deps = {}) {
   return wsl.discoverWslHome(".hermes", deps);
 }
 
-function pickWin32ProviderPath({ env = process.env, nativeValue, wslProviderDir, wslValue }) {
-  const nativeCandidate = wsl.shouldProbeNative(env) ? nativeValue : null;
-  const wslCandidate = wslValue !== undefined
-    ? wslValue
-    : (wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(wslProviderDir) : null);
-  return wsl.pickWin32Path({
-    wslValue: wslCandidate,
-    nativeValue: nativeCandidate,
-    env,
-    platform: "win32",
-  });
+function pickWin32ProviderPath({ env = process.env, nativeValue, wslProviderDir, wslValue, deps = {} }) {
+  const paths = resolveInstallPaths({ nativeValue, wslDir: wslProviderDir, wslValue }, env, deps);
+  return paths.native || paths.wsl;
+}
+
+function resolveAllWin32ProviderPaths({ env = process.env, nativeValue, wslProviderDir, wslValue, deps = {} }) {
+  return resolveInstallPaths({ nativeValue, wslDir: wslProviderDir, wslValue }, env, deps);
 }
 
 function resolveHermesDbPath(env = process.env) {
@@ -3936,6 +3921,86 @@ function readHermesSessions(dbPath, lastCompletedEpoch, unfinishedSessionIds = [
   }
 }
 
+// ── Dual-install cursor ownership probes ────────────────────────────────────
+// When a flat (pre-namespaced) cursor migrates to per-install namespaces
+// (multiInstallParse "both" mode), the migration must know which install the
+// flat cursor was tracking: only then may the OTHER install's namespace start
+// empty so its full history backfills. Guessing wrong wipes dedup state
+// (snapshots / sessionTotals / threadTotals) for an already-counted install,
+// and every re-read session lands in the hourly buckets a second time.
+// These probes answer "does this install's DB contain the flat cursor's own
+// ids?" — sampled from the cursor's per-session dedup maps. Any failure or
+// missing evidence returns false so the caller falls back to seeding every
+// namespace (bounded backfill loss, never a double count).
+
+function sqliteDbContainsIds(dbPath, table, ids, sqliteOptions = {}) {
+  if (!dbPath || !Array.isArray(ids) || ids.length === 0) return false;
+  if (!fssync.existsSync(dbPath)) return false;
+  const inList = ids.map(sqliteStringLiteral).join(",");
+  const sql = `SELECT id FROM ${table} WHERE id IN (${inList}) LIMIT 1`;
+
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_e) { }
+  }
+  try {
+    const rows = readSqliteJsonRows(effectiveDbPath, sql, {
+      label: "InstallProbe",
+      maxBuffer: 1024 * 1024,
+      timeout: 10_000,
+      ...sqliteOptions,
+    });
+    return Array.isArray(rows) && rows.length > 0;
+  } catch (_e) {
+    return false;
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
+}
+
+// Sample the most recently inserted keys — most likely to still exist in the
+// DB (providers may delete old sessions, which would blind the probe).
+function sampleRecentKeys(obj, limit = 16) {
+  if (!obj || typeof obj !== "object") return [];
+  const keys = Object.keys(obj).filter((k) => typeof k === "string" && k.length > 0);
+  return keys.slice(-limit);
+}
+
+function gooseInstallOwnsCursor(dbPath, flatState, sqliteOptions) {
+  return sqliteDbContainsIds(dbPath, "sessions", sampleRecentKeys(flatState?.sessionTotals), sqliteOptions);
+}
+
+function zedInstallOwnsCursor(dbPath, flatState, sqliteOptions) {
+  return sqliteDbContainsIds(dbPath, "threads", sampleRecentKeys(flatState?.threadTotals), sqliteOptions);
+}
+
+function hermesInstallOwnsCursor(hermesPath, flatState, sqliteOptions) {
+  const ids = new Set();
+  const collect = (state) => {
+    if (!state || typeof state !== "object") return;
+    for (const key of sampleRecentKeys(state.snapshots)) ids.add(key);
+    if (Array.isArray(state.unfinishedSessionIds)) {
+      for (const id of state.unfinishedSessionIds) {
+        if (typeof id === "string" && id.length > 0) ids.add(id);
+      }
+    }
+  };
+  collect(flatState);
+  if (flatState?.profiles && typeof flatState.profiles === "object") {
+    for (const profileState of Object.values(flatState.profiles)) collect(profileState);
+  }
+  const sample = [...ids].slice(-16);
+  if (sample.length === 0) return false;
+
+  const dbPaths = resolveAllHermesDBPaths({ hermesPath });
+  const allDbs = [dbPaths.default, ...Object.values(dbPaths.profiles)].filter(Boolean);
+  return allDbs.some((db) => sqliteDbContainsIds(db, "sessions", sample, sqliteOptions));
+}
+
 function hasLegacyHermesDefaultState(hermesState) {
   return (
     typeof hermesState.lastStartedAt === "number" ||
@@ -6526,13 +6591,11 @@ function resolveZedDbPath(env = process.env) {
   if (process.platform === "win32") {
     const local = env.LOCALAPPDATA || path.join(home, "AppData", "Local");
     const native = path.join(local, "Zed", "threads", "threads.db");
-    let nativeExists = null;
-    if (wsl.shouldProbeNative(env)) {
-      try { if (fssync.existsSync(native)) nativeExists = native; } catch (_e) { }
-    }
-    const wslDir = wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(".local/share/zed/threads", { env }) : null;
-    const wslValue = wslDir ? path.join(wslDir, "threads.db") : null;
-    const picked = wsl.pickWin32Path({ wslValue, nativeValue: nativeExists, env, platform: "win32" });
+    const wslThreadsDir = wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(".local/share/zed/threads", { env }) : null;
+    const wslDbPath = wslThreadsDir && fssync.existsSync(path.join(wslThreadsDir, "threads.db"))
+      ? path.join(wslThreadsDir, "threads.db") : null;
+    const paths = resolveInstallPaths({ nativeValue: native, wslValue: wslDbPath }, env);
+    const picked = paths.native || paths.wsl;
     if (picked) return picked;
     const mode = wsl.getWslMode(env);
     return mode === "wsl-only" || mode === "native-only" ? null : native;
@@ -6909,13 +6972,11 @@ function resolveGooseDbPath(env = process.env) {
   } else if (process.platform === "win32") {
     const appData = env.APPDATA || path.join(home, "AppData", "Roaming");
     const native = path.join(appData, "goose", "sessions", "sessions.db");
-    let nativeExists = null;
-    if (wsl.shouldProbeNative(env)) {
-      try { if (fssync.existsSync(native)) nativeExists = native; } catch (_e) { }
-    }
     const wslDir = wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(".local/share/goose/sessions", { env }) : null;
-    const wslValue = wslDir ? path.join(wslDir, "sessions.db") : null;
-    const picked = wsl.pickWin32Path({ wslValue, nativeValue: nativeExists, env, platform: "win32" });
+    const wslValue = wslDir && fssync.existsSync(path.join(wslDir, "sessions.db"))
+      ? path.join(wslDir, "sessions.db") : null;
+    const paths = resolveInstallPaths({ nativeValue: native, wslValue }, env);
+    const picked = paths.native || paths.wsl;
     if (picked) candidates.push(picked);
     for (const c of candidates) {
       if (fssync.existsSync(c)) return c;
@@ -9919,6 +9980,9 @@ module.exports = {
   parseCursorApiIncremental,
   parseKiroIncremental,
   parseHermesIncremental,
+  gooseInstallOwnsCursor,
+  zedInstallOwnsCursor,
+  hermesInstallOwnsCursor,
   parseCopilotIncremental,
   resolveKimiWireFiles,
   resolveKimiDefaultModel,

package/src/lib/wsl-probe.js

@@ -16,6 +16,7 @@ const WSL_MODES = new Set([
   "native-first",
   "wsl-only",
   "native-only",
+  "both",
 ]);
 
 function defaultRunWsl(args, { utf16 = false } = {}) {
@@ -98,6 +99,7 @@ function pickWin32Path({
 
   const mode = getWslMode(env);
 
+  if (mode === "both") return wslValue ?? nativeValue ?? null;
   if (mode === "wsl-only") return wslValue ?? null;
   if (mode === "native-only") return nativeValue ?? null;
   if (mode === "native-first") return nativeValue ?? wslValue ?? null;
@@ -105,6 +107,24 @@ function pickWin32Path({
   return wslValue ?? nativeValue ?? null;
 }
 
+function resolveAllWin32Paths({
+  nativeValue,
+  wslValue,
+  env = process.env,
+  platform = process.platform,
+}) {
+  if (platform !== "win32") return { native: null, wsl: null };
+
+  const mode = getWslMode(env);
+
+  if (mode === "both") {
+    return { native: nativeValue ?? null, wsl: wslValue ?? null };
+  }
+
+  const single = pickWin32Path({ wslValue, nativeValue, env, platform });
+  return { native: single, wsl: null };
+}
+
 function lookupWslUser(distroName, runWsl, useCache) {
   if (useCache && _cachedWslUsers.has(distroName)) {
     return _cachedWslUsers.get(distroName);
@@ -177,5 +197,6 @@ module.exports = {
   shouldProbeWsl,
   shouldProbeNative,
   pickWin32Path,
+  resolveAllWin32Paths,
   normalizeWslMode,
 };