tokentracker-cli 0.67.0 → 0.68.0

package/src/lib/install-resolver.js

@@ -0,0 +1,62 @@
+const fssync = require("node:fs");
+const wsl = require("./wsl-probe");
+
+function resolveInstallPaths({ nativeValue, wslDir, wslValue } = {}, env = process.env, deps = {}) {
+  if (process.platform !== "win32") {
+    return { native: nativeValue ?? null, wsl: null };
+  }
+
+  const wslCandidate = wslValue !== undefined
+    ? (wsl.shouldProbeWsl(env) ? wslValue : null)
+    : (wslDir && wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(wslDir, { ...deps, env }) : null);
+  const nativeCandidate = wsl.shouldProbeNative(env) && nativeValue
+    ? pathExists(nativeValue, deps.existsSync) : null;
+
+  return wsl.resolveAllWin32Paths({ nativeValue: nativeCandidate, wslValue: wslCandidate, env, platform: "win32" });
+}
+
+function pathExists(p, existsSync) {
+  try { return (existsSync || fssync.existsSync)(p) ? p : null; } catch (_e) { return null; }
+}
+
+// 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.
+// Leaving a namespace empty is only safe when its install was NEVER counted
+// under the flat cursor — the flat state holds the per-session dedup maps, and
+// an already-counted install re-parsed without them double-counts everything.
+// Callers that cannot prove which install the flat cursor tracked must seed
+// ALL namespaces (the default): bounded backfill loss, never a double count.
+function ensureNamespacedCursors(cursors, providerName, activeKeys = ["native", "wsl"]) {
+  const state = cursors[providerName] && typeof cursors[providerName] === "object" ? cursors[providerName] : {};
+
+  if (state.native !== undefined || state.wsl !== undefined) {
+    return state;
+  }
+
+  const keys = Array.isArray(activeKeys) ? activeKeys : [activeKeys];
+  cursors[providerName] = { native: {}, wsl: {} };
+  if (Object.keys(state).length > 0) {
+    for (const key of keys) {
+      cursors[providerName][key] = JSON.parse(JSON.stringify(state));
+    }
+  }
+  return cursors[providerName];
+}
+
+function ensureFlatCursor(cursors, providerName, env) {
+  const state = cursors[providerName];
+  if (!state || typeof state !== "object") return;
+  if (state.native === undefined && state.wsl === undefined) return;
+
+  const mode = wsl.getWslMode(env || process.env);
+  const preferWsl = mode === "wsl-first" || mode === "wsl-only";
+  const merged = preferWsl ? { ...state.native, ...state.wsl } : { ...state.wsl, ...state.native };
+  cursors[providerName] = merged;
+}
+
+module.exports = {
+  resolveInstallPaths,
+  ensureNamespacedCursors,
+  ensureFlatCursor,
+};

package/src/lib/multi-install-parser.js

@@ -0,0 +1,103 @@
+const wsl = require("./wsl-probe");
+const { ensureNamespacedCursors, ensureFlatCursor } = require("./install-resolver");
+
+function emptyResult() {
+  return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+}
+
+async function multiInstallParse({ paths, parserFn, providerName, cursors, getParams, onProgress, detectInstall, ...shared }) {
+  const installKeys = Object.keys(paths).filter(k => paths[k]);
+  if (installKeys.length === 0) return emptyResult();
+  const env = shared.env || process.env;
+
+  if (installKeys.length === 1) {
+    ensureFlatCursor(cursors, providerName, env);
+    return await parserFn({
+      ...getParams(paths[installKeys[0]], installKeys[0]),
+      ...shared,
+      cursors,
+      onProgress,
+    });
+  }
+
+  const activeKeys = resolveMigrationSeedKeys({ paths, installKeys, providerName, cursors, detectInstall });
+  const ns = ensureNamespacedCursors(cursors, providerName, activeKeys);
+  let recordsProcessed = 0;
+  let eventsAggregated = 0;
+  let bucketsQueued = 0;
+
+  for (let i = 0; i < installKeys.length; i++) {
+    const key = installKeys[i];
+    cursors[providerName] = ns[key];
+    try {
+      const result = await parserFn({
+        ...getParams(paths[key], key), ...shared, cursors,
+        onProgress: wrapProgress(onProgress, key),
+      });
+      ns[key] = cursors[providerName];
+      recordsProcessed += result.recordsProcessed || 0;
+      eventsAggregated += result.eventsAggregated || 0;
+      bucketsQueued += result.bucketsQueued || 0;
+    } catch (parseErr) {
+      cursors[providerName] = ns;
+      throw parseErr;
+    }
+  }
+  cursors[providerName] = ns;
+
+  return { recordsProcessed, eventsAggregated, bucketsQueued };
+}
+
+// Decide which namespaces the one-time flat→namespaced cursor migration seeds
+// with the flat state. `detectInstall(installPath, flatState, installKey)` is
+// a provider-specific probe answering "does this install's DB contain the
+// flat cursor's session ids?". Only when EXACTLY ONE install matches do we
+// know who owned the flat cursor — the other namespace then starts empty so
+// its full history backfills. No probe, no match, multiple matches, or a
+// probe error all fall back to seeding every namespace: an install re-parsed
+// without its dedup state would double-count its entire history, and a
+// bounded backfill gap is the cheaper failure.
+function resolveMigrationSeedKeys({ paths, installKeys, providerName, cursors, detectInstall }) {
+  if (typeof detectInstall !== "function") return installKeys;
+  const state = cursors[providerName] && typeof cursors[providerName] === "object" ? cursors[providerName] : {};
+  const isFlat = state.native === undefined && state.wsl === undefined;
+  if (!isFlat || Object.keys(state).length === 0) return installKeys;
+
+  const hits = [];
+  for (const key of installKeys) {
+    let owns = false;
+    try {
+      owns = detectInstall(paths[key], state, key) === true;
+    } catch (_e) { }
+    if (owns) hits.push(key);
+  }
+  return hits.length === 1 ? hits : installKeys;
+}
+
+function wrapProgress(onProgress, installKey) {
+  if (!onProgress) return undefined;
+  return (p) => onProgress({ ...p, install: installKey });
+}
+
+function mergeBothFileSources({ resolveFiles, env }) {
+  const isBoth = process.platform === "win32" && wsl.getWslMode(env) === "both";
+  if (!isBoth) {
+    const files = resolveFiles(env);
+    return files;
+  }
+
+  const nativeEnv = { ...env, TOKENTRACKER_WSL_MODE: "native-only" };
+  const wslEnv = { ...env, TOKENTRACKER_WSL_MODE: "wsl-only" };
+
+  const nativeFiles = resolveFiles(nativeEnv);
+  const wslFiles = resolveFiles(wslEnv);
+
+  const seen = new Set();
+  const merged = [];
+  for (const f of [...nativeFiles, ...wslFiles]) {
+    if (!seen.has(f)) { seen.add(f); merged.push(f); }
+  }
+  return merged;
+}
+
+module.exports = { multiInstallParse, emptyResult, mergeBothFileSources };