tokentracker-cli 0.64.3 → 0.65.1

package/src/lib/usage-limits.js

@@ -144,6 +144,34 @@ function formatClaudeRateLimitMessage(retryAfterSec) {
   return "Claude API rate limited (429) — retry shortly.";
 }
 
+// Model-scoped weekly windows (e.g. Fable) arrive only in the newer generic `limits`
+// array (`kind: "weekly_scoped"` + `scope.model.display_name`) — the legacy top-level
+// fields (`seven_day_opus` etc.) stay null for them. Extract them into
+// `weekly_scoped: [{ label, utilization, resets_at }]`. Entries that duplicate a
+// populated legacy field (an "Opus" scoped entry alongside `seven_day_opus`) are
+// dropped so the same window never renders twice.
+function extractClaudeScopedWeekly(body) {
+  if (!Array.isArray(body?.limits)) return null;
+  const out = [];
+  for (const entry of body.limits) {
+    if (!entry || typeof entry !== "object" || entry.kind !== "weekly_scoped") continue;
+    const model = entry.scope?.model;
+    const label = typeof model?.display_name === "string" && model.display_name.trim()
+      ? model.display_name.trim()
+      : typeof model?.id === "string" && model.id.trim() ? model.id.trim() : null;
+    if (!label) continue;
+    if (body.seven_day_opus && label.toLowerCase() === "opus") continue;
+    const utilization = Number(entry.percent);
+    if (!Number.isFinite(utilization)) continue;
+    out.push({
+      label,
+      utilization,
+      resets_at: typeof entry.resets_at === "string" ? entry.resets_at : null,
+    });
+  }
+  return out.length > 0 ? out : null;
+}
+
 async function fetchClaudeUsageLimits(accessToken, { fetchImpl = fetch, maxAttempts = 3 } = {}) {
   const url = "https://api.anthropic.com/api/oauth/usage";
   const headers = {
@@ -178,6 +206,7 @@ async function fetchClaudeUsageLimits(accessToken, { fetchImpl = fetch, maxAttem
       five_hour: body.five_hour ?? null,
       seven_day: body.seven_day ?? null,
       seven_day_opus: body.seven_day_opus ?? null,
+      weekly_scoped: extractClaudeScopedWeekly(body),
       extra_usage: body.extra_usage ?? null,
     };
   }
@@ -1848,7 +1877,21 @@ function isClaudeCacheWindowUsable(window, { nowMs } = {}) {
 }
 
 function hasClaudeWindow(limits) {
-  return Boolean(limits?.five_hour || limits?.seven_day || limits?.seven_day_opus);
+  return Boolean(
+    limits?.five_hour || limits?.seven_day || limits?.seven_day_opus ||
+    (Array.isArray(limits?.weekly_scoped) && limits.weekly_scoped.length > 0),
+  );
+}
+
+// Cached scoped windows are filtered per-entry like the fixed windows: a scoped
+// window whose reset has passed is stale data, not a usable fallback.
+function normalizeClaudeCachedScopedWeekly(raw, { nowMs } = {}) {
+  if (!Array.isArray(raw)) return null;
+  const usable = raw.filter(
+    (w) => w && typeof w.label === "string" && Number.isFinite(Number(w.utilization)) &&
+      isClaudeCacheWindowUsable(w, { nowMs }),
+  );
+  return usable.length > 0 ? usable : null;
 }
 
 function normalizeClaudeCachedLimits(
@@ -1870,6 +1913,7 @@ function normalizeClaudeCachedLimits(
     five_hour: isClaudeCacheWindowUsable(raw?.five_hour, { nowMs }) ? raw.five_hour : null,
     seven_day: isClaudeCacheWindowUsable(raw?.seven_day, { nowMs }) ? raw.seven_day : null,
     seven_day_opus: isClaudeCacheWindowUsable(raw?.seven_day_opus, { nowMs }) ? raw.seven_day_opus : null,
+    weekly_scoped: normalizeClaudeCachedScopedWeekly(raw?.weekly_scoped, { nowMs }),
     extra_usage: raw?.extra_usage ?? null,
     stale,
     cached_at: raw.cached_at,
@@ -1909,6 +1953,9 @@ function writeClaudeLimitsCache(limits, { home, nowMs = Date.now() } = {}) {
       five_hour: limits.five_hour || null,
       seven_day: limits.seven_day || null,
       seven_day_opus: limits.seven_day_opus || null,
+      weekly_scoped: Array.isArray(limits.weekly_scoped) && limits.weekly_scoped.length > 0
+        ? limits.weekly_scoped
+        : null,
       extra_usage: limits.extra_usage || null,
       cached_at: new Date(nowMs).toISOString(),
     },
@@ -2646,6 +2693,7 @@ async function fetchUsageLimitsUncached({
       five_hour: claudeResult.value.five_hour,
       seven_day: claudeResult.value.seven_day,
       seven_day_opus: claudeResult.value.seven_day_opus,
+      weekly_scoped: claudeResult.value.weekly_scoped,
       extra_usage: claudeResult.value.extra_usage,
     };
     writeClaudeLimitsCache(claude, { home, nowMs });

package/src/lib/wsl-probe.js

@@ -0,0 +1,181 @@
+const fssync = require("node:fs");
+const path = require("node:path");
+
+const DEFAULT_EXEC_OPTS = { timeout: 15000, windowsHide: true, maxBuffer: 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] };
+
+let _cachedDistros = null;
+const _cachedWslUsers = new Map();
+
+function resetWslProbeCache() {
+  _cachedDistros = null;
+  _cachedWslUsers.clear();
+}
+
+const WSL_MODES = new Set([
+  "wsl-first",
+  "native-first",
+  "wsl-only",
+  "native-only",
+]);
+
+function defaultRunWsl(args, { utf16 = false } = {}) {
+  const { execFileSync } = require("node:child_process");
+  const buf = execFileSync("wsl.exe", args, DEFAULT_EXEC_OPTS);
+  return utf16 ? buf.toString("utf16le") : buf.toString("utf8");
+}
+
+function parseWslListVerbose(raw) {
+  if (typeof raw !== "string") return [];
+  const distros = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const clean = line.replace(/\0/g, "").replace(/\uFEFF/g, "").trim();
+    if (!clean) continue;
+    const cells = clean.split(/\s+/);
+    let isDefault = false;
+    let idx = 0;
+    if (cells[0] === "*") {
+      isDefault = true;
+      idx = 1;
+    }
+    const name = cells[idx];
+    if (!name || name === "NAME") continue;
+    const version = parseInt(cells[cells.length - 1], 10);
+    distros.push({ name, version: Number.isFinite(version) ? version : null, isDefault });
+  }
+  return distros;
+}
+
+function probeWslDistros(deps = {}) {
+  const hasDeps = Object.keys(deps).length > 0;
+  if (!hasDeps && _cachedDistros) return _cachedDistros;
+  const runWsl = deps.runWsl || defaultRunWsl;
+  let raw;
+  try {
+    raw = runWsl(["-l", "-v"], { utf16: true });
+  } catch (_e) {
+    if (!hasDeps) _cachedDistros = [];
+    return [];
+  }
+  const distros = parseWslListVerbose(raw);
+  const sorted = distros.sort((a, b) => (b.isDefault ? 1 : 0) - (a.isDefault ? 1 : 0));
+  if (!hasDeps) _cachedDistros = sorted;
+  return sorted;
+}
+
+function normalizeWslMode(value) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replaceAll("_", "-");
+}
+
+function getWslMode(env = process.env) {
+  const raw = normalizeWslMode(env.TOKENTRACKER_WSL_MODE);
+  return WSL_MODES.has(raw) ? raw : "wsl-first";
+}
+
+function isInvalidWslMode(env = process.env) {
+  const value = env.TOKENTRACKER_WSL_MODE;
+  if (value == null || String(value).trim() === "") return false;
+  return !WSL_MODES.has(normalizeWslMode(value));
+}
+
+function shouldProbeWsl(env = process.env) {
+  return getWslMode(env) !== "native-only";
+}
+
+function shouldProbeNative(env = process.env) {
+  return getWslMode(env) !== "wsl-only";
+}
+
+function pickWin32Path({
+  wslValue,
+  nativeValue,
+  env = process.env,
+  platform = process.platform,
+}) {
+  if (platform !== "win32") return null;
+
+  const mode = getWslMode(env);
+
+  if (mode === "wsl-only") return wslValue ?? null;
+  if (mode === "native-only") return nativeValue ?? null;
+  if (mode === "native-first") return nativeValue ?? wslValue ?? null;
+
+  return wslValue ?? nativeValue ?? null;
+}
+
+function lookupWslUser(distroName, runWsl, useCache) {
+  if (useCache && _cachedWslUsers.has(distroName)) {
+    return _cachedWslUsers.get(distroName);
+  }
+  let user = "";
+  try {
+    user = String(runWsl(["-d", distroName, "-e", "whoami"], { utf16: false }) || "").trim();
+  } catch (_e) { }
+  if (useCache) _cachedWslUsers.set(distroName, user);
+  return user;
+}
+
+function discoverWslHome(providerDir, deps = {}) {
+  if (!shouldProbeWsl(deps.env)) return null;
+
+  const runWsl = deps.runWsl || defaultRunWsl;
+  const existsSync = deps.existsSync || fssync.existsSync;
+  const distros = deps.runWsl ? probeWslDistros({ runWsl: deps.runWsl }) : probeWslDistros();
+  const useCache = !deps.runWsl;
+  for (const distro of distros) {
+    const user = lookupWslUser(distro.name, runWsl, useCache);
+    if (!user) continue;
+    const roots = distro.version === 1
+      ? ["\\\\wsl.localhost\\", "\\\\wsl$\\"]
+      : ["\\\\wsl$\\", "\\\\wsl.localhost\\"];
+    for (const root of roots) {
+      const candidate = `${root}${distro.name}\\home\\${user}\\${providerDir}`;
+      try {
+        if (existsSync(candidate)) return candidate;
+      } catch (_e) { }
+    }
+  }
+  return null;
+}
+
+function isUncPath(p) {
+  return typeof p === "string" && (p.startsWith("\\\\") || p.startsWith("//"));
+}
+
+function snapshotSqliteDb(dbPath) {
+  const tmpRoot = fssync.mkdtempSync(
+    path.join(require("node:os").tmpdir(), "tokentracker-wsl-snap-"),
+  );
+  const target = path.join(tmpRoot, path.basename(dbPath));
+  fssync.copyFileSync(dbPath, target);
+  for (const suffix of ["-wal", "-shm", "-journal"]) {
+    const src = dbPath + suffix;
+    try {
+      if (fssync.existsSync(src)) fssync.copyFileSync(src, target + suffix);
+    } catch (_e) { }
+  }
+  return {
+    path: target,
+    cleanup() {
+      try { fssync.rmSync(tmpRoot, { recursive: true, force: true }); } catch (_e) { }
+    },
+  };
+}
+
+module.exports = {
+  defaultRunWsl,
+  parseWslListVerbose,
+  probeWslDistros,
+  resetWslProbeCache,
+  discoverWslHome,
+  isUncPath,
+  snapshotSqliteDb,
+  getWslMode,
+  isInvalidWslMode,
+  shouldProbeWsl,
+  shouldProbeNative,
+  pickWin32Path,
+  normalizeWslMode,
+};