tokentracker-cli 1.3.15 → 1.4.1

package/src/lib/qoder-cn-cli-limits.js

@@ -61,15 +61,16 @@ async function cnRequest(url, options, fetchImpl, { tokenExchange = false } = {}
 function normalizeQoderCnCliUsage(response, normalizeRpcUsage) {
   const usage = response?.displayMode === "qoder" ? response.qoderUsage : response;
   const rawQuota = usage?.userQuota ?? usage?.user_quota;
-  if (!rawQuota || typeof rawQuota !== "object") {
+  const addOnQuota = usage?.addOnQuota ?? usage?.add_on_quota;
+  if ((!rawQuota || typeof rawQuota !== "object") && !addOnQuota) {
     throw new Error("Qoder CN usage response is missing the plan quota.");
   }
-  const total = Number(rawQuota.total);
-  const used = Number(rawQuota.used);
-  const remaining = rawQuota.remaining == null ? Math.max(0, total - used) : Number(rawQuota.remaining);
-  if (rawQuota.total == null || rawQuota.used == null
+  const total = Number(rawQuota?.total);
+  const used = Number(rawQuota?.used);
+  const remaining = rawQuota?.remaining == null ? Math.max(0, total - used) : Number(rawQuota.remaining);
+  if (rawQuota && (rawQuota.total == null || rawQuota.used == null
     || ![total, used, remaining].every(Number.isFinite) || Math.min(total, used, remaining) < 0
-    || (total === 0 && (used !== 0 || remaining !== 0))) {
+    || (total === 0 && (used !== 0 || remaining !== 0)))) {
     throw new Error("Qoder CN usage response has invalid quota values.");
   }
   // The OpenAPI returns fractions; the old desktop IPC already returns percents.
@@ -77,7 +78,8 @@ function normalizeQoderCnCliUsage(response, normalizeRpcUsage) {
     userType: usage.userType ?? usage.user_type,
     expiresAt: usage.expiresAt ?? usage.expires_at,
     isQuotaExceeded: usage.isQuotaExceeded ?? usage.is_quota_exceeded,
-    userQuota: { used, total, remaining, unit: rawQuota.unit },
+    userQuota: rawQuota ? { used, total, remaining, unit: rawQuota.unit } : null,
+    addOnQuota,
   });
   result.source = "cli-api";
   return result;

package/src/lib/qoder-limits.js

@@ -240,21 +240,47 @@ function qoderRpcRequest(method, params = {}, {
   });
 }
 
+function normalizeQoderAddOnQuota(quota) {
+  if (quota == null) return null;
+  const used = Number(quota.used);
+  const total = Number(quota.total);
+  const remaining = quota.remaining == null ? Math.max(0, total - used) : Number(quota.remaining);
+  if (quota.used == null || quota.total == null
+    || ![used, total, remaining].every(Number.isFinite) || Math.min(used, total, remaining) < 0
+    || (total === 0 && (used !== 0 || remaining !== 0))) {
+    throw new Error("Qoder add-on quota values are invalid.");
+  }
+  return {
+    used_percent: total > 0 ? Math.min(100, (used / total) * 100) : 0,
+    // The official addOnQuota has no renewal date. Plan expiry does not apply.
+    reset_at: null,
+    used_credits: used,
+    limit_credits: total,
+    remaining_credits: remaining,
+    unit: typeof quota.unit === "string" && quota.unit.trim() ? quota.unit.trim() : "credits",
+  };
+}
+
 function normalizeQoderRpcUsage(response) {
   if (!response || typeof response !== "object") return null;
   const quota = response.userQuota;
-  if (!quota || typeof quota !== "object") return null;
-  const used = finiteNumber(quota.used, "userQuota.used");
-  const total = finiteNumber(quota.total, "userQuota.total");
-  const remaining = finiteNumber(quota.remaining, "userQuota.remaining");
-  const reportedPercent = Number(response.totalUsagePercentage ?? quota.percentage);
+  // Qoder CN CLI 1.1.71 renders userQuota and addOnQuota as separate buckets.
+  // Only its account-level total_remaining adds them together.
+  const addOnWindow = normalizeQoderAddOnQuota(response.addOnQuota);
+  if ((!quota || typeof quota !== "object") && !addOnWindow) return null;
+  const used = quota ? finiteNumber(quota.used, "userQuota.used") : 0;
+  const total = quota ? finiteNumber(quota.total, "userQuota.total") : 0;
+  const remaining = quota ? finiteNumber(quota.remaining, "userQuota.remaining") : 0;
+  const reportedPercent = Number(response.totalUsagePercentage ?? quota?.percentage);
   const usedPercent = total === 0
     ? 0
-    : response.isQuotaExceeded === true
-      ? 100
-      : Number.isFinite(reportedPercent)
-        ? reportedPercent
-        : (used / total) * 100;
+    : addOnWindow
+      ? (used / total) * 100
+      : response.isQuotaExceeded === true
+        ? 100
+        : Number.isFinite(reportedPercent)
+          ? reportedPercent
+          : (used / total) * 100;
   const normalizedExpiry = normalizeResetAt(response.expiresAt);
   const expiryMs = normalizedExpiry ? Date.parse(normalizedExpiry) : NaN;
   return {
@@ -262,7 +288,7 @@ function normalizeQoderRpcUsage(response) {
     error: null,
     plan_label: typeof response.userType === "string" ? response.userType : null,
     quota_exceeded: response.isQuotaExceeded === true,
-    primary_window: {
+    primary_window: quota ? {
       used_percent: Math.max(0, Math.min(100, usedPercent)),
       // Qoder uses 9999-12-31 as a no-expiry sentinel for Free accounts.
       reset_at: Number.isFinite(expiryMs) && expiryMs < Date.UTC(2100, 0, 1)
@@ -272,7 +298,8 @@ function normalizeQoderRpcUsage(response) {
       limit_credits: total,
       remaining_credits: remaining,
       unit: typeof quota.unit === "string" && quota.unit.trim() ? quota.unit.trim() : "credits",
-    },
+    } : null,
+    ...(addOnWindow ? { tertiary_window: addOnWindow } : {}),
     source: "local-ipc",
   };
 }
@@ -389,8 +416,9 @@ function readQoderLimitsCache({
     if (!Number.isFinite(cachedAtMs) || cachedAtMs > nowMs + 60_000) return null;
     const primaryWindow = qoderCachedWindow(raw.primary_window, { cachedAtMs, nowMs });
     const secondaryWindow = qoderCachedWindow(raw.secondary_window, { cachedAtMs, nowMs });
-    if (!primaryWindow && !secondaryWindow) return null;
-    const hasUnexpiredDatedWindow = [primaryWindow, secondaryWindow]
+    const tertiaryWindow = qoderCachedWindow(raw.tertiary_window, { cachedAtMs, nowMs });
+    if (!primaryWindow && !secondaryWindow && !tertiaryWindow) return null;
+    const hasUnexpiredDatedWindow = [primaryWindow, secondaryWindow, tertiaryWindow]
       .some((window) => Number.isFinite(Date.parse(window?.reset_at || "")));
     if (nowMs - cachedAtMs > QODER_LIMITS_CACHE_MAX_AGE_MS && !hasUnexpiredDatedWindow) {
       return null;
@@ -402,6 +430,7 @@ function readQoderLimitsCache({
       quota_exceeded: raw.quota_exceeded === true,
       primary_window: primaryWindow,
       secondary_window: secondaryWindow,
+      ...(tertiaryWindow ? { tertiary_window: tertiaryWindow } : {}),
       cached: true,
       stale: true,
       cached_at: raw.cached_at,
@@ -417,7 +446,7 @@ function writeQoderLimitsCache(limits, {
   nowMs = Date.now(),
   namespace,
 } = {}) {
-  if (!limits?.configured || limits.error || (!limits.primary_window && !limits.secondary_window)) return;
+  if (!limits?.configured || limits.error || (!limits.primary_window && !limits.secondary_window && !limits.tertiary_window)) return;
   const cachePath = qoderLimitsCachePath({ home, namespace });
   const payload = {
     qoder: {
@@ -425,6 +454,7 @@ function writeQoderLimitsCache(limits, {
       quota_exceeded: limits.quota_exceeded === true,
       primary_window: limits.primary_window || null,
       secondary_window: limits.secondary_window || null,
+      ...(limits.tertiary_window ? { tertiary_window: limits.tertiary_window } : {}),
       cached_at: new Date(nowMs).toISOString(),
     },
   };

package/src/lib/rollout.js

@@ -9750,8 +9750,8 @@ async function parseKimiCodeIncremental({ wireFiles, cursors, queuePath, onProgr
     const prevIno = prevEntry.ino;
     const inodeChanged = typeof prevIno === "number" && prevIno !== stat.ino;
     const startOffset = stat.size < prevSize || inodeChanged ? 0 : prevSize;
-    // Model is declared in a `config.update` near the file head; persist it on
-    // the cursor so incremental resumes (which start past that line) keep it.
+    // Persist the latest config/profile/request model so an incremental read
+    // starting after that declaration keeps the same attribution.
     let fileModel = (typeof prevEntry.model === "string" && prevEntry.model) || fallbackModel;
     if (stat.size <= startOffset) continue;
 
@@ -9766,8 +9766,10 @@ async function parseKimiCodeIncremental({ wireFiles, cursors, queuePath, onProgr
       let entry;
       try { entry = JSON.parse(line); } catch { continue; }
 
-      if (entry.type === "config.update") {
-        const alias = kimiCodeModelAlias(entry.modelAlias);
+      // Kimi Code 2.x can bind or reroute the model without config.update.
+      // These records precede step.end and carry the model actually requested.
+      if (["config.update", "profile.bind", "llm.request"].includes(entry.type)) {
+        const alias = kimiCodeModelAlias(entry.modelAlias || entry.model);
         if (alias) fileModel = alias;
         continue;
       }

package/src/lib/session-analytics.js

@@ -37,6 +37,7 @@ const { resolveZcodeNativeDbPath, resolveInstallPaths } = require("./install-res
 const { readCursorStateSummary } = require("./cursor-store");
 const { USD_TICKS_PER_USD, normalizeGrokUsage } = require("./grok-usage");
 const wsl = require("./wsl-probe");
+const { discoverKimiWireFiles, kimiSessionDependencies, readKimiSessions } = require("./kimi-session");
 const {
   appendUniqueDirs,
   dedupeDirsByRealpath,
@@ -85,7 +86,8 @@ const {
 // v22 adds metadata-only OpenCode database sessions.
 // v23 excludes database updates and user records from request durations.
 // v24 keeps OpenCode usage dates at event time and fork history on its ancestor.
-const SIDECAR_VERSION = 24;
+// v25 adds Kimi wire sessions, including official/legacy migration dedup.
+const SIDECAR_VERSION = 25;
 const EDIT_TOOLS = new Set([
   "apply_patch",
   "edit",
@@ -1925,6 +1927,14 @@ function groupCodexFiles(filePaths) {
   return ordered;
 }
 
+async function scanKimiSessions(filePaths) {
+  const rows = await readKimiSessions(Array.isArray(filePaths) ? filePaths : [filePaths]);
+  return rows.map(({ identity, files, ...row }) => finalizeRecord({
+    ...row, version: SIDECAR_VERSION, source: "kimi", session_hash: sessionHash("kimi", identity),
+    project_key: projectKey(row.project_ref, files[0]), ...sessionStorageUsage(files),
+  }));
+}
+
 async function discoverSessionFiles(home, env = process.env, deps = {}) {
   const grokHome = resolveGrokHome(home);
   // config.scanRoots (#657): read from the tracker config unless the caller
@@ -2007,7 +2017,17 @@ async function discoverSessionFiles(home, env = process.env, deps = {}) {
   const opencodePaths = resolveInstallPaths({ nativeValue: opencodeNativeDir, wslValue: opencodeWslDir }, env, { platform: zcodePlatform });
   const opencode = [...new Set(Object.values(opencodePaths).filter(Boolean)
     .map((dir) => path.join(dir, "opencode.db")).filter((dbPath) => fs.existsSync(dbPath)))];
-  return { claude, codex: groupCodexFiles([...codex, ...archived]), grok, zcode, opencode, incomplete };
+  const kimiRoots = [".kimi", ".kimi-code"].flatMap((directory) => {
+    const roots = providerRoots(home, directory, env, deps);
+    const override = env[directory === ".kimi" ? "KIMI_HOME" : "KIMI_CODE_HOME"];
+    if (override && path.resolve(home) === path.resolve((deps.homedir || os.homedir)())) {
+      const native = path.join(home, directory);
+      return roots.map((root) => root === native ? expandHome(override, home) : root);
+    }
+    return roots;
+  });
+  const kimi = discoverKimiWireFiles(dedupeDirsByRealpath(kimiRoots), incomplete);
+  return { claude, codex: groupCodexFiles([...codex, ...archived]), grok, zcode, opencode, kimi, incomplete };
 }
 
 // Warn once per unreadable directory per process: the dashboard polls this
@@ -2108,6 +2128,9 @@ function analyticsEntryStatKey(source, filePath) {
     ));
     return `${sessionStat}|title-index:${titleStats.join("|")}`;
   }
+  if (source === "kimi") {
+    return `${sessionStat}|metadata:${filesSignature(kimiSessionDependencies(filePaths))}`;
+  }
   if (source === "grok") {
     const primary = filePaths[0];
     return `${sessionStat}|summary:${sessionFileStatKey(grokSummaryPathFor(primary)) || "missing"}|signals:${sessionFileStatKey(grokSignalsPathFor(primary)) || "missing"}`;
@@ -2147,13 +2170,15 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
   const retryZcodeScan = fs.existsSync(incompleteZcodePath);
   const incompleteOpencodePath = `${metaPath}.opencode-incomplete`;
   const retryOpencodeScan = fs.existsSync(incompleteOpencodePath);
+  const incompleteKimiPath = `${metaPath}.kimi-incomplete`;
+  const retryKimiScan = fs.existsSync(incompleteKimiPath);
   let previousMeta = null;
   if (!force) {
     try {
       previousMeta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
       const checkedAt = Date.parse(previousMeta.checked_at || previousMeta.generated_at || "");
       if (
-        !retryZcodeScan && !retryOpencodeScan && previousMeta.version === SIDECAR_VERSION &&
+        !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && previousMeta.version === SIDECAR_VERSION &&
         Number.isFinite(checkedAt) &&
         Date.now() - checkedAt < Math.max(0, Number(cacheTtlMs) || 0)
       ) {
@@ -2183,13 +2208,15 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     ...discovered.claude.flat(),
     ...discovered.codex.flat(),
     ...discovered.codex.flat().map(codexTitleIndexPathFor).filter(Boolean),
+    ...discovered.kimi,
+    ...kimiSessionDependencies(discovered.kimi),
     ...discovered.grok,
     ...discovered.grok.map(grokSummaryPathFor),
     ...discovered.grok.map(grokSignalsPathFor),
     // db + its WAL sidecars: the trio is one logical file for change detection.
     ...[...(discovered.zcode || []), ...(discovered.opencode || [])].flatMap((dbPath) => [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]),
   ]);
-  if (!force && !retryZcodeScan && !retryOpencodeScan && previousMeta?.version === SIDECAR_VERSION && previousMeta.signature === signature) {
+  if (!force && !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && previousMeta?.version === SIDECAR_VERSION && previousMeta.signature === signature) {
     await writeAtomic(metaPath, `${JSON.stringify({ ...previousMeta, checked_at: new Date().toISOString() })}\n`);
     return readSidecar(sidecarPath);
   }
@@ -2211,6 +2238,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     ...discovered.grok.map((filePath) => ({ source: "grok", filePath, scan: scanGrokSession })),
     ...(discovered.zcode.length ? [{ source: "zcode", filePath: discovered.zcode, scan: scanZcodeSessions }] : []),
     ...(discovered.opencode.length ? [{ source: "opencode", filePath: discovered.opencode, scan: scanOpencodeSessions }] : []),
+    ...(discovered.kimi.length ? [{ source: "kimi", filePath: discovered.kimi, scan: scanKimiSessions }] : []),
   ];
   // Files we could not turn into a row (permission denied, half-written line,
   // vanished mid-scan). Swallowing these silently made sessions disappear with
@@ -2218,6 +2246,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
   let skippedFiles = 0;
   let incompleteZcodeScan = false;
   let incompleteOpencodeScan = false;
+  let incompleteKimiScan = false;
   for (const entry of entries) {
     const cacheKey = sessionFileCacheKey(entry.source, entry.filePath);
     const statKey = analyticsEntryStatKey(entry.source, entry.filePath);
@@ -2225,11 +2254,12 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
       skippedFiles += 1;
       if (entry.source === "zcode") incompleteZcodeScan = true;
       if (entry.source === "opencode") incompleteOpencodeScan = true;
+      if (entry.source === "kimi") incompleteKimiScan = true;
       continue;
     }
     let rows = null;
-    if (!force && !(entry.source === "zcode" && retryZcodeScan) && !(entry.source === "opencode" && retryOpencodeScan) && previousFiles[cacheKey]?.stat_key === statKey) {
-      if (entry.source === "zcode" || entry.source === "opencode") {
+    if (!force && !(entry.source === "zcode" && retryZcodeScan) && !(entry.source === "opencode" && retryOpencodeScan) && !(entry.source === "kimi" && retryKimiScan) && previousFiles[cacheKey]?.stat_key === statKey) {
+      if (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi") {
         // One db scans to many cached rows; recover them all from the previous
         // pass. An empty recovery means the sidecar lost its rows — rescan.
         const cached = previousRows.filter((row) => row?.source === entry.source);
@@ -2249,6 +2279,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
         skippedFiles += 1;
         if (entry.source === "zcode") incompleteZcodeScan = true;
         if (entry.source === "opencode") incompleteOpencodeScan = true;
+        if (entry.source === "kimi") incompleteKimiScan = true;
         if (!process.env.NODE_TEST_CONTEXT) {
           console.warn(`[session-analytics] skipped ${entry.source} session file: ${error?.message || error}`);
         }
@@ -2262,8 +2293,8 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
       // so key each by the db path plus its session id; a bare session id as a
       // separate path element would be path.resolve()d against the process cwd
       // and never match across runs.
-      row._cache_key = (entry.source === "zcode" || entry.source === "opencode") && row.session_id
-        ? `${cacheKey}#${sessionHash(entry.source, row.session_id)}`
+      row._cache_key = (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi") && (row.session_id || row.session_hash)
+        ? `${cacheKey}#${sessionHash(entry.source, row.session_id || row.session_hash)}`
         : cacheKey;
       sessions.push(row);
     }
@@ -2282,10 +2313,14 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     sessions.push(...readSidecar(sidecarPath).filter((row) =>
       row.source === "opencode" && row.version === SIDECAR_VERSION));
   }
+  if (incompleteKimiScan) {
+    await writeAtomic(incompleteKimiPath, "1\n");
+    sessions.push(...readSidecar(sidecarPath).filter((row) => row.source === "kimi" && row.version === SIDECAR_VERSION));
+  }
   sessions.sort((a, b) => String(b.ended_at || "").localeCompare(String(a.ended_at || "")));
   // A failed database scan is an incomplete inventory. Keep the last complete
   // snapshot and signature so an unchanged database is retried next build.
-  if (incompleteDirs.length === 0 && !incompleteZcodeScan && !incompleteOpencodeScan) {
+  if (incompleteDirs.length === 0 && !incompleteZcodeScan && !incompleteOpencodeScan && !incompleteKimiScan) {
     const content = sessions.map(serializeSessionRecord).join("\n") + (sessions.length ? "\n" : "");
     await writeAtomic(sidecarPath, content);
     const generatedAt = new Date().toISOString();
@@ -2298,6 +2333,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     })}\n`);
     await fsp.rm(incompleteZcodePath, { force: true });
     await fsp.rm(incompleteOpencodePath, { force: true });
+    await fsp.rm(incompleteKimiPath, { force: true });
   }
   // Non-enumerable so the array still behaves exactly like a plain row list
   // for every existing caller (map/filter/JSON of the rows is unaffected).
@@ -2579,6 +2615,7 @@ function resumeCommandFor(source, sessionId) {
   if (source === "claude") return `claude --resume ${id}`;
   if (source === "codex") return `codex resume ${id}`;
   if (source === "opencode") return `opencode --session ${id}`;
+  if (source === "kimi") return `kimi --session ${id}`;
   // Grok Build: `grok --resume <session-id>` (also accepts a title). The
   // command must still be run from the session's project_ref cwd.
   if (source === "grok") return `grok --resume ${id}`;
@@ -2922,6 +2959,7 @@ module.exports = {
   scanGrokSession,
   scanZcodeSessions,
   scanOpencodeSessions,
+  scanKimiSessions,
   buildSessionAnalytics,
   summarizeSessions,
   listSessionsForBrowser,