tokentracker-cli 0.93.3 → 0.93.5

package/src/commands/status.js

@@ -654,9 +654,9 @@ async function cmdStatus(argv = []) {
   // official API, so status surfaces the opt-in flag, the resolved storage
   // path, and whether the auth blob decrypts — the three inputs a "why is my
   // TRAE CN data missing" diagnosis needs.
-  // A resolvable default path does NOT mean the app is installed - the macOS
-  // resolver always derives one. Match the sync path semantics exactly:
-  // installed iff the storage file actually exists on disk.
+  // A resolvable default path does NOT mean the app is installed - the
+  // macOS/Windows resolver always derives one. Match the sync path semantics
+  // exactly: installed iff the storage file actually exists on disk.
   const traeCnStoragePath = resolveTraeCnStoragePath({ env: process.env, home });
   const traeCnInstalled = Boolean(
     traeCnStoragePath && fssync.existsSync(traeCnStoragePath),

package/src/commands/sync.js

@@ -28,6 +28,7 @@ const {
   readOpencodeDbMessages,
   readMimoDbMessages,
   readZcodeDbMessages,
+  hasZcodeNativeUsageSchema,
   resolveQoderDbPaths,
   resolveQoderCnDbPaths,
   readQoderDbMessages,
@@ -257,6 +258,7 @@ const CODEX_COLD_SCAN_AUDIT_MAX_SYNCS = 288;
 // state so the next sync (providerID-filtered reader) rebuilds it correctly.
 const MIMO_PROVIDER_REPAIR_KEY = "mimoClaudeMislabelRepair_2026_06";
 const DSH_LEGACY_SOURCE_MIGRATION_KEY = "deepseekHarnessSourceMigration_2026_08";
+const ZCODE_NATIVE_USAGE_REPAIR_KEY = "zcodeNativeUsageRepair_2026_08";
 const AUTO_SYNC_SOURCE_ALIASES = new Map([
   ["code", "every-code"],
   ["deepseek", "dsh"],
@@ -468,6 +470,9 @@ async function cmdSync(argv, context = {}) {
   const traeCnNowMs = context && typeof context === "object"
     ? context.traeCnNowMs
     : undefined;
+  const cursorSyncDeps = context && typeof context.cursorSyncDeps === "object"
+    ? context.cursorSyncDeps
+    : {};
   const syncDiagnostics = diagnostics && typeof diagnostics === "object" ? diagnostics : null;
   const home = os.homedir();
   const { trackerDir } = await resolveTrackerPaths({ home });
@@ -1403,6 +1408,18 @@ async function cmdSync(argv, context = {}) {
       if (zcodePaths.native || zcodePaths.wsl) {
         if (progress?.enabled) progress.start(`Parsing ZCode ${renderBar(0)} | buckets 0`);
         try {
+          const nativeUsageAvailable = [zcodePaths.native, zcodePaths.wsl]
+            .filter(Boolean)
+            .some((dbPath) => hasZcodeNativeUsageSchema(dbPath));
+          if (nativeUsageAvailable) {
+            await repairZcodeNativeUsageMigration({
+              cursors,
+              queuePath,
+              queueStatePath,
+              projectQueuePath,
+              projectQueueStatePath,
+            });
+          }
           zcodeResult = await multiInstallParse({
             paths: zcodePaths, parserFn: parseOpencodeDbForInstall, providerName: "zcode",
             cursors, getParams: (p) => ({ dbPath: p, readFn: readZcodeDbMessages, source: "zcode", cursorKey: "zcode" }),
@@ -1640,14 +1657,17 @@ async function cmdSync(argv, context = {}) {
     }
 
     let cursorResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    if (!isBackgroundLightweightSync && sourceAllowed("cursor") && isCursorInstalled({ home })) {
-      const cursorAuth = extractCursorSessionToken({ home });
+    const cursorInstalled = cursorSyncDeps.isInstalled || isCursorInstalled;
+    const cursorAuthExtractor = cursorSyncDeps.extractAuth || extractCursorSessionToken;
+    const cursorUsageFetcher = cursorSyncDeps.fetchUsageCsv || fetchCursorUsageCsv;
+    if (sourceAllowed("cursor") && cursorInstalled({ home })) {
+      const cursorAuth = cursorAuthExtractor({ home });
       if (cursorAuth) {
         try {
           if (progress?.enabled) {
             progress.start(`Fetching Cursor usage...`);
           }
-          const csvText = await fetchCursorUsageCsv({ cookie: cursorAuth.cookie });
+          const csvText = await cursorUsageFetcher({ cookie: cursorAuth.cookie });
           const records = parseCursorCsv(csvText);
           if (records.length > 0) {
             if (progress?.enabled) {
@@ -3105,6 +3125,7 @@ module.exports = {
   repairCodexInterleavedUsageInflation,
   repairDroidDuplicateSessionInflation,
   repairMimoClaudeMislabel,
+  repairZcodeNativeUsageMigration,
   reincludeClaudeMemObserverFiles,
   repairGrokQueueFromSessionSnapshots,
   applyCloudConversationsBackfill,
@@ -4083,6 +4104,128 @@ async function repairMimoClaudeMislabel({
   return true;
 }
 
+async function resetUploadOffsetForZcodeNativeRepair(queueStatePath) {
+  if (typeof queueStatePath !== "string" || !queueStatePath) return false;
+  let state = {};
+  try {
+    state = JSON.parse(await fs.readFile(queueStatePath, "utf8"));
+  } catch (_error) {
+    state = {};
+  }
+  state.offset = 0;
+  state.updatedAt = new Date().toISOString();
+  state.note = "reset_after_zcode_native_usage_repair_2026_08";
+  await ensureDir(path.dirname(queueStatePath));
+  await fs.writeFile(queueStatePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+  return true;
+}
+
+async function dropZcodeQueueRows(filePath, { retainRetractions = false } = {}) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return { removed: 0, retractions: 0 };
+    throw error;
+  }
+  const kept = [];
+  const retractions = new Map();
+  let removed = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch (_error) {
+      kept.push(line);
+      continue;
+    }
+    if (row?.source === "zcode") {
+      removed += 1;
+      const model = typeof row.model === "string" && row.model.trim()
+        ? row.model.trim()
+        : "unknown";
+      const hourStart = typeof row.hour_start === "string" ? row.hour_start : "";
+      if (retainRetractions && hourStart) {
+        retractions.set(`${model}|${hourStart}`, {
+          source: "zcode",
+          model,
+          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,
+          conversation_count: 0,
+        });
+      }
+      continue;
+    }
+    kept.push(line);
+  }
+  if (removed === 0) return { removed: 0, retractions: 0 };
+  await backupExistingFile(filePath);
+  const tmp = `${filePath}.zcoderepair.${process.pid}.${Date.now()}`;
+  const rewritten = [
+    ...kept,
+    ...[...retractions.values()].map((row) => JSON.stringify(row)),
+  ];
+  await fs.writeFile(tmp, rewritten.length ? rewritten.join("\n") + "\n" : "", "utf8");
+  await fs.rename(tmp, filePath);
+  return { removed, retractions: retractions.size };
+}
+
+async function repairZcodeNativeUsageMigration({
+  cursors,
+  queuePath,
+  queueStatePath,
+  projectQueuePath,
+  projectQueueStatePath,
+} = {}) {
+  if (!cursors || typeof cursors !== "object") return false;
+  const migrations = (cursors.migrations ||= {});
+  if (migrations[ZCODE_NATIVE_USAGE_REPAIR_KEY]) return false;
+
+  const mainRepair = await dropZcodeQueueRows(queuePath, { retainRetractions: true });
+  const projectRepair = projectQueuePath
+    ? await dropZcodeQueueRows(projectQueuePath)
+    : { removed: 0, retractions: 0 };
+
+  const hourly = cursors.hourly && typeof cursors.hourly === "object" ? cursors.hourly : null;
+  if (hourly?.buckets) {
+    for (const key of Object.keys(hourly.buckets)) {
+      if (key.startsWith("zcode|")) delete hourly.buckets[key];
+    }
+  }
+  if (hourly?.groupQueued) {
+    for (const key of Object.keys(hourly.groupQueued)) {
+      if (key.startsWith("zcode|")) delete hourly.groupQueued[key];
+    }
+  }
+  const projectHourly = cursors.projectHourly && typeof cursors.projectHourly === "object"
+    ? cursors.projectHourly
+    : null;
+  if (projectHourly?.buckets) {
+    for (const key of Object.keys(projectHourly.buckets)) {
+      if (key.includes("|zcode|")) delete projectHourly.buckets[key];
+    }
+  }
+  delete cursors.zcode;
+
+  if (mainRepair.removed > 0) await resetUploadOffsetForZcodeNativeRepair(queueStatePath);
+  if (projectRepair.removed > 0) {
+    await resetUploadOffsetForZcodeNativeRepair(projectQueueStatePath);
+  }
+  migrations[ZCODE_NATIVE_USAGE_REPAIR_KEY] = {
+    appliedAt: new Date().toISOString(),
+    removedMain: mainRepair.removed,
+    removedProject: projectRepair.removed,
+    retractions: mainRepair.retractions,
+  };
+  return true;
+}
+
 async function repairGrokQueueFromSessionSnapshots({ cursors, queuePath, queueStatePath } = {}) {
   if (!cursors || typeof cursors !== "object") return false;
   const grokState = (cursors.grok ||= {});

package/src/lib/opencode-go-limits.js

@@ -266,6 +266,9 @@ async function resolveWorkspaceId(authCookie, fetchImpl, timeoutMs) {
         headers: postHeaders,
         body: "[]"
       });
+      if (response.status === 401 || response.status === 403) {
+        throw new Error("Unauthorized or forbidden (401/403)");
+      }
       text = await response.text();
       ids = parseWorkspaceIds(text);
     } catch (postErr) {
@@ -414,7 +417,18 @@ function buildLocalWindow({ used, limit, resetMs }) {
 // so we sum in SQLite and return a single row rather than streaming every
 // opencode-go turn into JS — keeps the limits poll cheap, cf. the spawnSync
 // freeze lesson).
-function buildGoAggregateSql({ sessionStart, weekStart, weekEnd, monthStart, monthEnd }) {
+//
+// Two schema generations share the same file (see src/lib/rollout.js):
+//   v1 keeps the `message` table with `$.role`/flat `$.providerID`.
+//   v2 (`opencode2`) moved messages to `session_message` (role is now the
+//     `type` column) and nests the provider under `$.model.providerID`.
+function buildGoAggregateSql({ sessionStart, weekStart, weekEnd, monthStart, monthEnd }, variant = "v1") {
+  const isV2 = variant === "v2";
+  const table = isV2 ? "session_message" : "message";
+  const rolePredicate = isV2 ? "type = 'assistant'" : "json_extract(data,'$.role') = 'assistant'";
+  const providerPredicate = isV2
+    ? "json_extract(data,'$.model.providerID') = 'opencode-go'"
+    : "json_extract(data,'$.providerID') = 'opencode-go'";
   return (
     "SELECT " +
     `COALESCE(SUM(CASE WHEN createdMs >= ${sessionStart} THEN cost ELSE 0 END), 0) AS sessionCost, ` +
@@ -425,15 +439,41 @@ function buildGoAggregateSql({ sessionStart, weekStart, weekEnd, monthStart, mon
     "FROM (" +
     "SELECT CAST(COALESCE(json_extract(data,'$.time.created'), time_created) AS INTEGER) AS createdMs, " +
     "CAST(json_extract(data,'$.cost') AS REAL) AS cost " +
-    "FROM message " +
+    `FROM ${table} ` +
     "WHERE json_valid(data) " +
-    "AND json_extract(data,'$.providerID') = 'opencode-go' " +
-    "AND json_extract(data,'$.role') = 'assistant' " +
+    `AND ${providerPredicate} ` +
+    `AND ${rolePredicate} ` +
     "AND json_type(data,'$.cost') IN ('integer','real')" +
     ")"
   );
 }
 
+// Detect whether the database has any rows in session_message. This is the
+// shared opencode2 probe (see src/lib/rollout.js): a pure v1 database has an
+// empty session_message table, and blindly running the v2 aggregate against it
+// is harmless here (no JOIN, no directory lookup) — but the probe result still
+// drives variant ordering so v2 is preferred when data exists.
+//
+// A database carrying BOTH tables resolves to "v1 first" on purpose: unlike the
+// message parser (which dedups rows by sessionID|messageID), this aggregate is
+// a blind SUM with no key to dedup on, so unioning two generations could
+// double-count cost if the tables overlap. Undercounting an opt-in estimate is
+// the safe side of that trade.
+async function detectOpencodeGoHasSessionMessages(dbPath, sqliteOptions = {}) {
+  let rows;
+  try {
+    rows = await readSqliteJsonRowsAsync(
+      dbPath,
+      `SELECT (SELECT 1 FROM session_message LIMIT 1) AS hasRows`,
+      { label: "OpenCode Go", timeout: 5_000, ...sqliteOptions },
+    );
+  } catch (_e) {
+    return null;
+  }
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+  return Boolean(rows[0]?.hasRows);
+}
+
 // Returns { source:'local', primary/secondary/tertiary_window } or null when no
 // opencode.db / no opencode-go rows are found. The caller labels this result as
 // an estimate and only exposes it when explicitly opted in.
@@ -445,32 +485,42 @@ async function collectOpencodeGoLocal({ home, env = process.env, nowMs = Date.no
   const weekStart = weekStartMs(nowMs);
   const weekEnd = weekStart + WEEK_MS;
   const { startMs: monthStart, endMs: monthEnd } = monthBoundsMs(nowMs);
-  const sql = buildGoAggregateSql({ sessionStart, weekStart, weekEnd, monthStart, monthEnd });
+  const windowArgs = { sessionStart, weekStart, weekEnd, monthStart, monthEnd };
 
   let agg = null;
   for (const dbPath of paths) {
-    let rows;
-    try {
-      rows = await readSqliteJsonRowsAsync(dbPath, sql, {
-        label: "OpenCode Go",
-        timeout: 5_000,
-        ...sqliteOptions,
-      });
-    } catch (_e) {
-      continue;
-    }
-    const row = rows && rows[0];
-    if (!row) continue;
-    const rowCount = Number(row.rowCount) || 0;
-    if (rowCount <= 0) continue;
-    if (!agg) agg = { sessionCost: 0, weeklyCost: 0, monthlyCost: 0, sessionOldest: null, rowCount: 0 };
-    agg.sessionCost += Number(row.sessionCost) || 0;
-    agg.weeklyCost += Number(row.weeklyCost) || 0;
-    agg.monthlyCost += Number(row.monthlyCost) || 0;
-    agg.rowCount += rowCount;
-    const oldest = row.sessionOldest == null ? null : Number(row.sessionOldest);
-    if (oldest != null && Number.isFinite(oldest)) {
-      agg.sessionOldest = agg.sessionOldest == null ? oldest : Math.min(agg.sessionOldest, oldest);
+    // Each database can be a different OpenCode generation. When sqlite_master
+    // is unreadable, fall back to v1-then-v2 so the legacy query runs first.
+    const hasRows = await detectOpencodeGoHasSessionMessages(dbPath, sqliteOptions);
+    const variants = hasRows === true ? ["v2", "v1"] : hasRows === false ? ["v1", "v2"] : ["v1", "v2"];
+
+    for (const variant of variants) {
+      const sql = buildGoAggregateSql(windowArgs, variant);
+      let rows;
+      try {
+        rows = await readSqliteJsonRowsAsync(dbPath, sql, {
+          label: "OpenCode Go",
+          timeout: 5_000,
+          ...sqliteOptions,
+          throwOnReadFailure: true,
+        });
+      } catch (_e) {
+        continue;
+      }
+      const row = rows && rows[0];
+      if (!row) continue;
+      const rowCount = Number(row.rowCount) || 0;
+      if (rowCount <= 0) continue;
+      if (!agg) agg = { sessionCost: 0, weeklyCost: 0, monthlyCost: 0, sessionOldest: null, rowCount: 0 };
+      agg.sessionCost += Number(row.sessionCost) || 0;
+      agg.weeklyCost += Number(row.weeklyCost) || 0;
+      agg.monthlyCost += Number(row.monthlyCost) || 0;
+      agg.rowCount += rowCount;
+      const oldest = row.sessionOldest == null ? null : Number(row.sessionOldest);
+      if (oldest != null && Number.isFinite(oldest)) {
+        agg.sessionOldest = agg.sessionOldest == null ? oldest : Math.min(agg.sessionOldest, oldest);
+      }
+      break; // this database answered — don't re-run the other schema on it
     }
   }
   if (!agg || agg.rowCount <= 0) return null;
@@ -602,7 +652,13 @@ async function scrapeOpencodeGoWeb({ cfg, fetchImpl, nowMs, timeoutMs }) {
     try {
       workspaceId = await resolveWorkspaceId(cfg.authCookie, fetchImpl, timeoutMs);
     } catch (err) {
-      return { configured: true, error: `Failed to resolve Workspace ID: ${sanitizeMessage(err?.message || err)}` };
+      const msg = sanitizeMessage(err?.message || err);
+      const isAuth = /401|403|Unauthorized or forbidden/i.test(msg);
+      return {
+        configured: true,
+        error: `Failed to resolve Workspace ID: ${msg}`,
+        ...(isAuth ? { auth_error: true } : {}),
+      };
     }
     if (!workspaceId) {
       return { configured: true, error: "Could not auto-resolve OpenCode Workspace ID from cookie. Please set OPENCODE_GO_WORKSPACE_ID manually." };
@@ -696,8 +752,7 @@ async function fetchOpencodeGoLimits({
       return { ...api, source: "api" };
     }
     if (api?.auth_error) {
-      const { auth_error, ...result } = api;
-      return result;
+      return { ...api, source: "api" };
     }
     if (!cfg) return api || { configured: true, error: "OpenCode Go unavailable" };
   }