tokentracker-cli 0.93.4 → 0.93.6

package/src/lib/rollout.js

@@ -24,6 +24,26 @@ const CLAUDE_MEM_OBSERVER_PROJECT_REF =
   "https://local.tokentracker/claude-mem/observer-sessions";
 const PROJECT_ABSENT_CONTEXT_RESCAN_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_CODEX_COLD_SKIP_RECENT_DAYS = 2;
+const FILE_METADATA_CONCURRENCY = 32;
+
+async function mapConcurrent(items, concurrency, mapper) {
+  if (!Array.isArray(items) || items.length === 0) return [];
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(
+    items.length,
+    Math.max(1, Math.floor(Number(concurrency) || 1)),
+  );
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
 
 async function listRolloutFiles(sessionsDir, options = {}) {
   const out = [];
@@ -41,23 +61,37 @@ async function listRolloutFiles(sessionsDir, options = {}) {
       dayInventoryCache.days = {};
     }
   }
-  const years = await safeReadDir(sessionsDir);
-  for (const y of years) {
-    if (!/^[0-9]{4}$/.test(y.name) || !y.isDirectory()) continue;
-    const yearDir = path.join(sessionsDir, y.name);
-    const months = await safeReadDir(yearDir);
-    for (const m of months) {
-      if (!/^[0-9]{2}$/.test(m.name) || !m.isDirectory()) continue;
-      const monthDir = path.join(yearDir, m.name);
+  const years = (await safeReadDir(sessionsDir))
+    .filter((entry) => /^[0-9]{4}$/.test(entry.name) && entry.isDirectory());
+  const monthGroups = await mapConcurrent(
+    years,
+    FILE_METADATA_CONCURRENCY,
+    async (year) => {
+      const yearDir = path.join(sessionsDir, year.name);
+      const months = await safeReadDir(yearDir);
+      return months
+        .filter((entry) => /^[0-9]{2}$/.test(entry.name) && entry.isDirectory())
+        .map((entry) => path.join(yearDir, entry.name));
+    },
+  );
+  const monthDirs = monthGroups.flat();
+  const dayGroups = await mapConcurrent(
+    monthDirs,
+    FILE_METADATA_CONCURRENCY,
+    async (monthDir) => {
       const days = await safeReadDir(monthDir);
-      for (const d of days) {
-        if (!/^[0-9]{2}$/.test(d.name) || !d.isDirectory()) continue;
-        const dayDir = path.join(monthDir, d.name);
-        const files = await listRolloutDayFiles(dayDir, { dayInventoryCache, stats });
-        out.push(...files);
-      }
-    }
-  }
+      return days
+        .filter((entry) => /^[0-9]{2}$/.test(entry.name) && entry.isDirectory())
+        .map((entry) => path.join(monthDir, entry.name));
+    },
+  );
+  const dayDirs = dayGroups.flat();
+  const fileGroups = await mapConcurrent(
+    dayDirs,
+    FILE_METADATA_CONCURRENCY,
+    (dayDir) => listRolloutDayFiles(dayDir, { dayInventoryCache, stats }),
+  );
+  for (const files of fileGroups) out.push(...files);
 
   out.sort((a, b) => a.localeCompare(b));
   return out;
@@ -354,6 +388,18 @@ async function parseRolloutIncremental({
     return false;
   };
 
+  // Metadata reads are independent while parsing and bucket mutation are not.
+  // Prefetch stats with bounded concurrency, then retain the original stable
+  // file order for parsing, deduplication, cursor updates, and queue writes.
+  const rolloutStats = await mapConcurrent(
+    rolloutFiles,
+    FILE_METADATA_CONCURRENCY,
+    async (entry) => {
+      const filePath = typeof entry === "string" ? entry : entry?.path;
+      if (!filePath) return null;
+      return fs.stat(filePath).catch(() => null);
+    },
+  );
   for (let idx = 0; idx < rolloutFiles.length; idx++) {
     const entry = rolloutFiles[idx];
     const filePath = typeof entry === "string" ? entry : entry?.path;
@@ -363,7 +409,7 @@ async function parseRolloutIncremental({
         ? defaultSource
         : normalizeSourceInput(entry?.source) || defaultSource;
     if (syncDiagnostics && fileSource === DEFAULT_SOURCE) syncDiagnostics.stat_candidates += 1;
-    const st = await fs.stat(filePath).catch(() => null);
+    const st = rolloutStats[idx];
     if (!st || !st.isFile()) continue;
 
     const key = filePath;
@@ -4422,8 +4468,7 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
   // by the existing cursor-key + #426 fingerprint dedup in
   // parseOpencodeDbIncremental, so unioning here is safe — the downstream
   // parser collapses identical sessionID|messageID pairs before bucketing.
-  const collectRows = (rows, isV2) => {
-    const out = [];
+  const appendRows = (rows, isV2, out) => {
     for (const row of rows) {
       if (!row || typeof row.data !== "string") continue;
       let data;
@@ -4450,7 +4495,6 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
         data,
       });
     }
-    return out;
   };
 
   const readGeneration = (sql) => {
@@ -4477,11 +4521,11 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
     const out = [];
 
     const rows1 = readGeneration(OPENCODE_DB_V1_MESSAGE_SQL);
-    if (rows1) out.push(...collectRows(rows1, false));
+    if (rows1) appendRows(rows1, false, out);
 
     if (probe?.hasRows) {
       const rows2 = readGeneration(buildV2Sql(probe.sessionTable));
-      if (rows2) out.push(...collectRows(rows2, true));
+      if (rows2) appendRows(rows2, true, out);
     }
 
     return out;
@@ -4551,10 +4595,195 @@ function isZcodeNativeMessage(data) {
   );
 }
 
+const ZCODE_NATIVE_USAGE_COLUMNS = new Set([
+  "id",
+  "logical_request_id",
+  "attempt_index",
+  "session_id",
+  "provider_id",
+  "model_id",
+  "status",
+  "started_at",
+  "input_tokens",
+  "output_tokens",
+  "reasoning_tokens",
+  "cache_creation_input_tokens",
+  "cache_read_input_tokens",
+]);
+
+function detectZcodeNativeUsageLayout(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return null;
+  let rows;
+  try {
+    rows = readSqliteJsonRows(
+      dbPath,
+      `SELECT 'model_usage' AS table_name, name FROM pragma_table_info('model_usage')
+       UNION ALL
+       SELECT 'session' AS table_name, name FROM pragma_table_info('session')`,
+      {
+        label: "ZCode",
+        timeout: 10_000,
+        maxBuffer: 1024 * 1024,
+        ...sqliteOptions,
+        throwOnReadFailure: true,
+      },
+    );
+  } catch (_error) {
+    return null;
+  }
+  const modelUsageColumns = new Set(
+    rows
+      .filter((row) => !row?.table_name || row.table_name === "model_usage")
+      .map((row) => String(row?.name || "")),
+  );
+  if (![...ZCODE_NATIVE_USAGE_COLUMNS].every((name) => modelUsageColumns.has(name))) {
+    return null;
+  }
+  const sessionColumns = new Set(
+    rows
+      .filter((row) => row?.table_name === "session")
+      .map((row) => String(row?.name || "")),
+  );
+  return {
+    hasSessionDirectory: sessionColumns.has("id") && sessionColumns.has("directory"),
+  };
+}
+
+function hasZcodeNativeUsageSchema(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return false;
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_error) {
+      // Fall through to the direct read: some UNC servers support SQLite's
+      // read-only locking semantics even when the WSL bridge does not.
+    }
+  }
+  try {
+    return detectZcodeNativeUsageLayout(effectiveDbPath, sqliteOptions) !== null;
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
+}
+
+function buildZcodeNativeUsageSql({ hasSessionDirectory }) {
+  const directorySelect = hasSessionDirectory ? ", s.directory AS directory" : "";
+  const directoryJoin = hasSessionDirectory
+    ? " LEFT JOIN session AS s ON s.id = mu.session_id"
+    : "";
+  return `SELECT
+    mu.id,
+    mu.logical_request_id,
+    mu.attempt_index,
+    mu.session_id,
+    mu.provider_id,
+    mu.model_id,
+    mu.started_at,
+    mu.input_tokens,
+    mu.output_tokens,
+    mu.reasoning_tokens,
+    mu.cache_creation_input_tokens,
+    mu.cache_read_input_tokens
+    ${directorySelect}
+    FROM model_usage AS mu${directoryJoin}
+    WHERE mu.status = 'completed'
+      AND trim(mu.model_id) != ''
+      AND (
+        mu.input_tokens > 0 OR mu.output_tokens > 0 OR mu.reasoning_tokens > 0 OR
+        mu.cache_creation_input_tokens > 0 OR mu.cache_read_input_tokens > 0
+      )
+    ORDER BY mu.started_at ASC, mu.id ASC`;
+}
+
+function readZcodeNativeUsageMessages(dbPath, sqliteOptions = {}) {
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_error) {
+      // Preserve the existing direct-read fallback for transient snapshot
+      // failures and UNC implementations that support SQLite locking.
+    }
+  }
+
+  let rows;
+  try {
+    const layout = detectZcodeNativeUsageLayout(effectiveDbPath, sqliteOptions);
+    if (!layout) return null;
+    rows = readSqliteJsonRows(effectiveDbPath, buildZcodeNativeUsageSql(layout), {
+      label: "ZCode",
+      maxBuffer: 50 * 1024 * 1024,
+      timeout: 30_000,
+      ...sqliteOptions,
+      throwOnReadFailure: true,
+    });
+  } catch (_error) {
+    return null;
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
+
+  const messages = [];
+  for (const row of rows) {
+    const providerID = String(row?.provider_id || "").trim();
+    const modelID = String(row?.model_id || "").trim();
+    const sessionID = String(row?.session_id || "").trim();
+    const logicalRequestId = String(row?.logical_request_id || "").trim();
+    const attemptIndex = toNonNegativeInt(row?.attempt_index);
+    const id = String(row?.id || "").trim() ||
+      (logicalRequestId ? `${logicalRequestId}#${attemptIndex}` : "");
+    const startedAt = coerceEpochMs(row?.started_at);
+    if (!providerID || !modelID || !sessionID || !id || !startedAt) continue;
+
+    // ZCode's persisted input/output columns are inclusive parents:
+    // cache read/write are subsets of input, and reasoning is a subset of
+    // output. TokenTracker stores those five columns disjointly, so split the
+    // subsets here before entering the shared OpenCode parser. This preserves
+    // sum(input + cache read + cache write + output + reasoning) without
+    // billing either subset twice.
+    const rawInput = toNonNegativeInt(row?.input_tokens);
+    const rawOutput = toNonNegativeInt(row?.output_tokens);
+    const cacheRead = toNonNegativeInt(row?.cache_read_input_tokens);
+    const cacheWrite = toNonNegativeInt(row?.cache_creation_input_tokens);
+    const reasoning = toNonNegativeInt(row?.reasoning_tokens);
+
+    const data = {
+      id,
+      sessionID,
+      role: "assistant",
+      providerID,
+      modelID,
+      time: { created: startedAt, completed: startedAt },
+      tokens: {
+        input: Math.max(0, rawInput - cacheRead - cacheWrite),
+        output: Math.max(0, rawOutput - reasoning),
+        reasoning,
+        cache: {
+          read: cacheRead,
+          write: cacheWrite,
+        },
+      },
+    };
+    if (typeof row?.directory === "string" && row.directory.trim()) {
+      data.path = { cwd: row.directory.trim() };
+    }
+    if (!isZcodeNativeMessage(data)) continue;
+    messages.push({ id, sessionID, timeUpdated: startedAt, data });
+  }
+  return messages;
+}
+
 // Read only genuine ZCode assistant messages (its own GLM models via Z.ai /
 // BigModel), dropping any bundled sub-agent turns. See isZcodeNativeMessage.
 function readZcodeDbMessages(dbPath, sqliteOptions = {}) {
   if (!dbPath || !fssync.existsSync(dbPath)) return [];
+  const nativeMessages = readZcodeNativeUsageMessages(dbPath, sqliteOptions);
+  if (nativeMessages !== null) return nativeMessages;
   const all = readOpencodeDbMessages(dbPath, sqliteOptions);
   return all.filter((m) => isZcodeNativeMessage(m.data));
 }
@@ -18054,6 +18283,7 @@ module.exports = {
   readOpencodeDbMessages,
   readMimoDbMessages,
   readZcodeDbMessages,
+  hasZcodeNativeUsageSchema,
   resolveQoderDbPath,
   resolveQoderDbPaths,
   resolveQoderCnDbPaths,

package/src/lib/usage-limits.js

@@ -66,6 +66,13 @@ const CLAUDE_LIMITS_CACHE_FRESH_TTL_MS = 10 * 60 * 1000;
 // error, mirroring the Claude stale-fallback path.
 const CODEX_LIMITS_CACHE_FILE = "codex-usage-limits-cache.json";
 const CODEX_LIMITS_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+// OpenCode Go hits opencode.ai over the public internet (15s timeout) with no local CLI to
+// fall back on. A transient 5xx / timeout previously left the panel blank until the next
+// 2-minute poll — persist the last successful windows so a blip serves stale bars instead
+// of a flash of "fetch failed" (mirrors Claude / Codex / Antigravity).
+const OPENCODE_GO_LIMITS_CACHE_FILE = "opencode-go-usage-limits-cache.json";
+const OPENCODE_GO_LIMITS_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const OPENCODE_GO_LOCAL_ESTIMATE_CACHE_MAX_AGE_MS = 60 * 60 * 1000;
 // A 429 from the usage endpoint carries a long `retry-after` (often 20+ minutes). Persist
 // the cooldown so every surface — this process, the menu bar app's embedded server, a later
 // restart — stops calling until it expires. Hammering during the cooldown just renews the
@@ -2398,6 +2405,82 @@ function writeCodexLimitsCache(limits, { home, nowMs = Date.now() } = {}) {
   } catch (_error) {}
 }
 
+function resolveOpencodeGoLimitsCachePath({ home } = {}) {
+  return path.join(home || os.homedir(), ".tokentracker", "tracker", OPENCODE_GO_LIMITS_CACHE_FILE);
+}
+
+function hasOpencodeGoWindow(limits) {
+  return Boolean(limits?.primary_window || limits?.secondary_window || limits?.tertiary_window);
+}
+
+function isOpencodeGoCacheWindowUsable(window, { nowMs } = {}) {
+  if (!window || typeof window !== "object") return false;
+  const resetAtMs = parseTimeMs(window.reset_at);
+  if (resetAtMs === null) return true;
+  return resetAtMs > nowMs;
+}
+
+function normalizeOpencodeGoCachedLimits(
+  raw,
+  { nowMs = Date.now(), maxAgeMs } = {},
+) {
+  const effectiveMaxAge = Number.isFinite(maxAgeMs)
+    ? maxAgeMs
+    : raw?.source === "local-estimate"
+      ? OPENCODE_GO_LOCAL_ESTIMATE_CACHE_MAX_AGE_MS
+      : OPENCODE_GO_LIMITS_CACHE_MAX_AGE_MS;
+  const cachedAtMs = parseTimeMs(raw?.cached_at);
+  if (!Number.isFinite(cachedAtMs)) return null;
+  if (cachedAtMs > nowMs + 60_000) return null;
+  if (nowMs - cachedAtMs > effectiveMaxAge) return null;
+
+  const cached = {
+    configured: true,
+    error: null,
+    source: typeof raw?.source === "string" ? raw.source : "api",
+    subscription_status: typeof raw?.subscription_status === "string" ? raw.subscription_status : null,
+    plan_label: typeof raw?.plan_label === "string" ? raw.plan_label : null,
+    primary_window: isOpencodeGoCacheWindowUsable(raw?.primary_window, { nowMs }) ? raw.primary_window : null,
+    secondary_window: isOpencodeGoCacheWindowUsable(raw?.secondary_window, { nowMs }) ? raw.secondary_window : null,
+    tertiary_window: isOpencodeGoCacheWindowUsable(raw?.tertiary_window, { nowMs }) ? raw.tertiary_window : null,
+    stale: true,
+    cached_at: raw.cached_at,
+  };
+  return hasOpencodeGoWindow(cached) ? cached : null;
+}
+
+function readOpencodeGoLimitsCache({ home, nowMs = Date.now() } = {}) {
+  const cachePath = resolveOpencodeGoLimitsCachePath({ home });
+  try {
+    const parsed = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+    return normalizeOpencodeGoCachedLimits(parsed?.opencodeGo, { nowMs });
+  } catch (_error) {
+    return null;
+  }
+}
+
+function writeOpencodeGoLimitsCache(limits, { home, nowMs = Date.now() } = {}) {
+  if (!limits?.configured || limits.error || !hasOpencodeGoWindow(limits)) return;
+  const cachePath = resolveOpencodeGoLimitsCachePath({ home });
+  const payload = {
+    opencodeGo: {
+      source: limits.source || "api",
+      subscription_status: limits.subscription_status || null,
+      plan_label: limits.plan_label || null,
+      primary_window: limits.primary_window || null,
+      secondary_window: limits.secondary_window || null,
+      tertiary_window: limits.tertiary_window || null,
+      cached_at: new Date(nowMs).toISOString(),
+    },
+  };
+  try {
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    const tmpPath = `${cachePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(payload, null, 2), { encoding: "utf8", mode: 0o600 });
+    fs.renameSync(tmpPath, cachePath);
+  } catch (_error) {}
+}
+
 function resolveClaudeRateLimitPath({ home } = {}) {
   return path.join(home || os.homedir(), ".tokentracker", "tracker", CLAUDE_RATE_LIMIT_FILE);
 }
@@ -3063,7 +3146,7 @@ async function fetchUsageLimitsUncached({
     : null;
 
   const providerFetch = withFetchTimeout(fetchImpl, providerTimeoutMs);
-  const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok, zcode, opencodeGo, qoder, qoderCn, codingPlan, claudeServiceStatus] = await Promise.all([
+  const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok, zcode, opencodeGoRaw, qoder, qoderCn, codingPlan, claudeServiceStatus] = await Promise.all([
     claudeToken && !freshClaudeCache && !claudeRetryAtMs
       ? withProviderTimeout(fetchClaudeUsageLimits(claudeToken, { fetchImpl: providerFetch, maxAttempts: 1 }), "Claude", providerTimeoutMs).then(
           (value) => ({ status: "fulfilled", value }),
@@ -3276,6 +3359,41 @@ async function fetchUsageLimitsUncached({
     }
   }
 
+  // OpenCode Go: persist last successful windows so a transient timeout/5xx
+  // (common on GFW-affected routes to opencode.ai) serves stale bars instead of
+  // a flashing "fetch failed". Mirrors Codex / Claude / Antigravity.
+  // Auth errors (401/403 invalid key, missing subscription, expired cookie) are
+  // actionable and must not be hidden behind stale cache — they carry
+  // `auth_error:true` from opencode-go-limits.js.
+  const opencodeGoIsAuthError =
+    Boolean(opencodeGoRaw?.auth_error) ||
+    (typeof opencodeGoRaw?.error === "string" &&
+      /Not signed in|auth cookie|Refresh the auth cookie|Failed to resolve Workspace ID.*401|Failed to resolve Workspace ID.*403/i.test(
+        opencodeGoRaw.error,
+      ));
+  let opencodeGo;
+  if (opencodeGoRaw && opencodeGoRaw.configured === false) {
+    opencodeGo = opencodeGoRaw;
+  } else if (opencodeGoIsAuthError) {
+    opencodeGo = opencodeGoRaw;
+  } else if (opencodeGoRaw?.subscription_status === "inactive") {
+    opencodeGo = opencodeGoRaw;
+  } else if (opencodeGoRaw && !opencodeGoRaw.error && hasOpencodeGoWindow(opencodeGoRaw)) {
+    opencodeGo = {
+      ...opencodeGoRaw,
+      stale: false,
+      cached_at: new Date(nowMs).toISOString(),
+    };
+    writeOpencodeGoLimitsCache(opencodeGo, { home, nowMs });
+  } else {
+    const cached = readOpencodeGoLimitsCache({ home, nowMs });
+    if (cached) {
+      opencodeGo = cached;
+    } else {
+      opencodeGo = opencodeGoRaw || { configured: true, error: "Unknown error" };
+    }
+  }
+
   const data = {
     fetched_at: new Date(nowMs).toISOString(),
     claude: withPlanLabel(claude, claudePlanType, "Claude"),

package/dashboard/dist/assets/DialogDescription-DAKoQCEv.js

@@ -1 +0,0 @@
-import{r as n,z as a}from"./__vite-browser-external-D_dICEUB.js";import{u as p}from"./DialogTitle-F6W1aTiE.js";import{u as c}from"./useScrollLock-C3TFkbz0.js";const x=n.forwardRef(function(e,r){const{render:l,className:u,style:m,id:s,...t}=e,i=p(),o=c(s);return i.useSyncedValueWithCleanup("descriptionElementId",o),a("p",e,{ref:r,props:[{id:o},t]})});export{x as D};