@ipv9/tokentracker-cli 0.39.45 → 0.39.47

package/src/lib/rollout.js

@@ -3237,21 +3237,48 @@ function isUncPath(p) {
   return typeof p === "string" && (p.startsWith("\\\\") || p.startsWith("//"));
 }
 
+function sqliteDbChangeFingerprint(dbPath) {
+  const parts = [];
+  for (const suffix of ["", "-wal", "-shm", "-journal"]) {
+    const filePath = dbPath + suffix;
+    const label = suffix || "main";
+    try {
+      const stat = fssync.statSync(filePath, { bigint: true });
+      parts.push(`${label}:${stat.size}:${stat.mtimeNs}`);
+    } catch (error) {
+      if (error && error.code === "ENOENT") {
+        parts.push(`${label}:missing`);
+        continue;
+      }
+      // A partial fingerprint must never authorize the no-change fast path.
+      // Retry the read instead of treating repeated stat failures as stable.
+      return null;
+    }
+  }
+  return parts.join("|");
+}
+
 function snapshotSqliteDb(dbPath) {
   const tmpRoot = fssync.mkdtempSync(
     path.join(require("node:os").tmpdir(), "tokentracker-hermes-snap-"),
   );
   const target = path.join(tmpRoot, path.basename(dbPath));
   fssync.copyFileSync(dbPath, target);
-  // Best-effort copy of SQLite sidecars; missing -wal/-shm/-journal is fine.
+  // Copy SQLite sidecars as one logical snapshot. A missing sidecar is normal,
+  // but any other copy failure makes the snapshot incomplete and must prevent
+  // callers from advancing a change fingerprint based on stale main-DB data.
+  let sidecarsComplete = true;
   for (const suffix of ["-wal", "-shm", "-journal"]) {
     const src = dbPath + suffix;
     try {
-      if (fssync.existsSync(src)) fssync.copyFileSync(src, target + suffix);
-    } catch (_e) { }
+      fssync.copyFileSync(src, target + suffix);
+    } catch (error) {
+      if (!error || error.code !== "ENOENT") sidecarsComplete = false;
+    }
   }
   return {
     path: target,
+    sidecarsComplete,
     cleanup() {
       try { fssync.rmSync(tmpRoot, { recursive: true, force: true }); } catch (_e) { }
     },
@@ -6116,8 +6143,10 @@ async function parseGooseIncremental({
   onProgress,
   env,
   sqliteOptions,
+  now = () => new Date(),
 } = {}) {
   await ensureDir(path.dirname(queuePath));
+  const observedAt = now().toISOString();
   const resolvedDb = dbPath || resolveGooseDbPath(env || process.env);
   const gooseState =
     cursors.goose && typeof cursors.goose === "object" ? cursors.goose : {};
@@ -6126,21 +6155,25 @@ async function parseGooseIncremental({
       ? { ...gooseState.sessionTotals }
       : {};
 
-  const cursorDbMtime = Number.isFinite(gooseState.lastDbMtimeMs) ? gooseState.lastDbMtimeMs : 0;
+  const cursorDbFingerprint =
+    typeof gooseState.lastDbFingerprint === "string" ? gooseState.lastDbFingerprint : null;
   let currentMtime = 0;
   try {
     currentMtime = fssync.statSync(resolvedDb).mtimeMs;
   } catch (e) {
     if (e && e.code === "ENOENT") {
-      cursors.goose = { ...gooseState, sessionTotals, updatedAt: new Date().toISOString() };
+      cursors.goose = { ...gooseState, sessionTotals, updatedAt: observedAt };
       return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     }
     throw e;
   }
-  // mtime short-circuit: skip the full sessions table scan when the DB
-  // hasn't been touched since the last sync.
-  if (currentMtime > 0 && currentMtime === cursorDbMtime) {
-    cursors.goose = { ...gooseState, sessionTotals, updatedAt: new Date().toISOString() };
+  const currentDbFingerprint = sqliteDbChangeFingerprint(resolvedDb);
+  // Goose commonly commits active-session writes only to SQLite's WAL. Skip
+  // the table scan only when the main DB and every sidecar are unchanged.
+  // Legacy cursors without a fingerprint intentionally perform one read to
+  // establish the sidecar-aware baseline.
+  if (cursorDbFingerprint && currentDbFingerprint === cursorDbFingerprint) {
+    cursors.goose = { ...gooseState, sessionTotals, updatedAt: observedAt };
     return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
   }
 
@@ -6149,13 +6182,22 @@ async function parseGooseIncremental({
   const snap = snapshotSqliteDb(resolvedDb);
   let rows = [];
   try {
+    if (!snap.sidecarsComplete) {
+      cursors.goose = {
+        ...gooseState,
+        sessionTotals,
+        lastDbFingerprint: null,
+        updatedAt: observedAt,
+      };
+      return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    }
     rows = readGooseSessionsFromSqlite(snap.path, sqliteOptions);
   } finally {
     snap.cleanup();
   }
 
   if (rows.length === 0) {
-    cursors.goose = { ...gooseState, sessionTotals, updatedAt: new Date().toISOString() };
+    cursors.goose = { ...gooseState, sessionTotals, updatedAt: observedAt };
     return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
   }
 
@@ -6188,6 +6230,7 @@ async function parseGooseIncremental({
     );
     if (totalNow === 0 && inputNow === 0 && outputNow === 0) continue;
 
+    const hadPreviousSnapshot = Object.prototype.hasOwnProperty.call(sessionTotals, row.id);
     const prev = sessionTotals[row.id] || { input: 0, output: 0, total: 0 };
     // Goose can wipe a session and re-create with the same id during
     // database migration. Treat shrinking cumulative as a reset and emit
@@ -6213,7 +6256,12 @@ async function parseGooseIncremental({
     const accountedDelta = dInput + dOutput;
     const reasoningDelta = Math.max(0, dTotal - accountedDelta);
 
-    const tsIso = parseGooseCreatedAt(row.created_at) || new Date().toISOString();
+    // The first observation has only created_at as a trustworthy timestamp.
+    // Later cumulative deltas belong to this sync's observation bucket so a
+    // long-lived session does not keep growing the day on which it started.
+    const tsIso = hadPreviousSnapshot
+      ? observedAt
+      : parseGooseCreatedAt(row.created_at) || observedAt;
     const bucketStart = toUtcHalfHourStart(tsIso);
     if (!bucketStart) continue;
 
@@ -6257,14 +6305,14 @@ async function parseGooseIncremental({
   }
 
   const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
-  const updatedAt = new Date().toISOString();
-  hourlyState.updatedAt = updatedAt;
+  hourlyState.updatedAt = observedAt;
   cursors.hourly = hourlyState;
   cursors.goose = {
     ...gooseState,
     sessionTotals,
     lastDbMtimeMs: currentMtime,
-    updatedAt,
+    lastDbFingerprint: currentDbFingerprint,
+    updatedAt: observedAt,
   };
 
   return { recordsProcessed, eventsAggregated, bucketsQueued };