tokentracker-cli 1.1.10 → 1.1.12

package/src/lib/grok-limits.js

@@ -644,15 +644,28 @@ async function fetchGrokBilling(
       headers,
       deadlineMs,
     );
-    if (creditsResult.ok) return creditsResult.body;
-    creditsFailure = `HTTP ${creditsResult.status}`;
+    if (creditsResult.ok) {
+      // Keep the unified pool even when its fields are malformed. The caller
+      // must surface its parse error rather than substitute a legacy pool.
+      if (creditsResult.body?.config?.currentPeriod) return creditsResult.body;
+      try {
+        // Only a response without a unified period is eligible for shape
+        // fallback; a parseable legacy response can already be used as-is.
+        normalizeGrokBillingResponse(creditsResult.body);
+        return creditsResult.body;
+      } catch (error) {
+        creditsFailure = `unrecognized response (${error?.message || "invalid billing data"})`;
+      }
+    } else {
+      creditsFailure = `HTTP ${creditsResult.status}`;
+    }
   } catch (error) {
     if (error?.code === "GROK_AUTH_REQUIRED") throw error;
     if (error?.code === "GROK_BILLING_TIMEOUT") throw error;
   }
 
-  // Non-auth HTTP, network, or response-decoding failure → try the legacy
-  // shape once, while sharing the original request deadline.
+  // Non-auth HTTP, network, response-decoding, or shape failure → try the
+  // legacy shape once, while sharing the original request deadline.
   let legacyResult;
   try {
     legacyResult = await fetchGrokBillingAttempt(

package/src/lib/kimi-profile.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { parse } = require("smol-toml");
+const { expandHome } = require("./scan-roots");
+
+const MAINLAND = { oauthHost: "https://auth.kimi.com", baseUrl: "https://api.kimi.com/coding/v1" };
+const GLOBAL = { oauthHost: "https://auth.kimi.ai", baseUrl: "https://api.kimi.ai/coding/v1" };
+
+function endpoint(value, fallback) {
+  return typeof value === "string" ? value.trim().replace(/\/+$/, "") : fallback;
+}
+
+// The two supported official endpoint pairs have stable upstream credential
+// slots. The global suffix is SHA-256(JSON.stringify({ oauthHost, baseUrl }))
+// truncated to 16 hex characters, matching managed-kimi-code.ts. Keeping the
+// filenames constant also prevents remote configuration from shaping paths.
+function credentialKey(oauthHost, baseUrl) {
+  return oauthHost === GLOBAL.oauthHost && baseUrl === GLOBAL.baseUrl
+    ? "kimi-code-env-0e4f99c69cc27850" : "kimi-code";
+}
+
+function resolveKimiProfile({ home, env = process.env } = {}) {
+  const base = home || os.homedir();
+  const explicit = expandHome(env?.KIMI_HOME, base);
+  const explicitCode = expandHome(env?.KIMI_CODE_HOME, base);
+  const codeHome = explicit || explicitCode || path.join(base, ".kimi-code");
+  const codeConfig = path.join(codeHome, "config.toml");
+  let provider = null;
+  let error = null;
+  if (fs.existsSync(codeConfig)) {
+    try {
+      provider = parse(fs.readFileSync(codeConfig, "utf8"))?.providers?.["managed:kimi-code"] || null;
+    } catch {
+      error = "Could not parse Kimi Code config.toml";
+    }
+  }
+  let hasCodeLogin = false;
+  try {
+    hasCodeLogin = Boolean(JSON.parse(fs.readFileSync(path.join(codeHome, "credentials", "kimi-code.json"), "utf8"))?.access_token);
+  } catch { /* No default-slot login. */ }
+  const hasEnvOverride = env?.KIMI_CODE_BASE_URL != null || env?.KIMI_CODE_OAUTH_HOST != null || env?.KIMI_OAUTH_HOST != null;
+  const kimiHome = explicit || explicitCode || provider || error || hasCodeLogin || hasEnvOverride
+    ? codeHome : path.join(base, ".kimi");
+  const oauthHost = endpoint(hasEnvOverride ? env?.KIMI_CODE_OAUTH_HOST ?? env?.KIMI_OAUTH_HOST : provider?.oauth?.oauth_host, MAINLAND.oauthHost);
+  const baseUrl = endpoint(env?.KIMI_CODE_BASE_URL ?? provider?.base_url, MAINLAND.baseUrl);
+  if (![MAINLAND, GLOBAL].some((region) => region.oauthHost === oauthHost && region.baseUrl === baseUrl)) {
+    error = "Unsupported Kimi quota endpoints; configure a matching official mainland or global profile";
+  }
+  if (provider?.oauth?.storage && provider.oauth.storage !== "file") {
+    error = "Kimi quota supports file credentials; the configured credential storage is unsupported";
+  }
+  // Derive the endpoint-scoped slot, just as upstream does when a stored key
+  // mismatches the endpoints. Never read an unrelated slot or legacy login.
+  const credsPath = path.join(kimiHome, "credentials", `${credentialKey(oauthHost, baseUrl)}.json`);
+  return { home: kimiHome, credsPath, oauthHost, baseUrl, error, configured: fs.existsSync(path.join(kimiHome, "config.toml")) };
+}
+
+module.exports = { resolveKimiProfile };

package/src/lib/local-api.js

@@ -1357,23 +1357,25 @@ function createLocalApiHandler({ queuePath, serverVersion = null }) {
   // sync is on. Cloud sync is a dashboard (WebView) preference persisted in
   // localStorage; the dashboard mirrors it here via POST
   // /functions/tokentracker-cloud-sync-pref so the auth-unaware popover can key
-  // off the same flag. Defaults ON, exactly like the dashboard toggle — every
-  // consumer additionally requires a relayed refresh token, so the default only
-  // takes effect for signed-in users; an explicit {enabled:false} still wins.
+  // off the same flag. Defaults OFF, exactly like the dashboard toggle;
+  // existing saved choices are preserved.
   const cloudSyncPrefPath = path.join(trackerDataDir, "cloud-sync-pref.json");
   let cloudSyncPrefCache;
   let cloudSyncPrefGeneration = 0;
   function getCloudSyncPref() {
     if (cloudSyncPrefCache === undefined) {
-      try {
-        cloudSyncPrefCache = JSON.parse(fs.readFileSync(cloudSyncPrefPath, "utf8"))?.enabled !== false;
-      } catch {
-        cloudSyncPrefCache = true;
-      }
+      cloudSyncPrefCache = require("./cloud-sync-prefs").readCloudSyncEnabled(trackerDataDir);
     }
     return cloudSyncPrefCache;
   }
-  function setCloudSyncPref(enabled) {
+  function setCloudSyncPref(enabled, changedAtMs = Date.now()) {
+    // Multiple dashboard windows can deliver mirrors out of order. Keep the
+    // newest saved choice; old files without an ordering marker remain valid.
+    try {
+      const saved = JSON.parse(fs.readFileSync(cloudSyncPrefPath, "utf8"));
+      if (Number(saved?.changedAtMs || 0) > changedAtMs ||
+          (changedAtMs > 0 && saved?.changedAtMs === changedAtMs && saved?.enabled === false && enabled)) return;
+    } catch { /* first choice or an unreadable preference */ }
     if (getCloudSyncPref() !== Boolean(enabled)) {
       cloudSyncPrefGeneration += 1;
       clearLocalSyncDeviceTokenCache();
@@ -1384,7 +1386,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null }) {
       if (!fs.existsSync(trackerDataDir)) fs.mkdirSync(trackerDataDir, { recursive: true });
       fs.writeFileSync(
         cloudSyncPrefPath,
-        JSON.stringify({ enabled: cloudSyncPrefCache, updatedAt: new Date().toISOString() }),
+        JSON.stringify({ enabled: cloudSyncPrefCache, changedAtMs, updatedAt: new Date().toISOString() }),
         { encoding: "utf8", mode: 0o600 },
       );
     } catch (e) {
@@ -2875,7 +2877,11 @@ function createLocalApiHandler({ queuePath, serverVersion = null }) {
           json(res, { ok: false, error: "enabled must be a boolean" }, 400);
           return true;
         }
-        setCloudSyncPref(body.enabled);
+        if (body.changedAtMs != null && (!Number.isSafeInteger(body.changedAtMs) || body.changedAtMs < 0)) {
+          json(res, { ok: false, error: "changedAtMs must be a nonnegative safe integer" }, 400);
+          return true;
+        }
+        setCloudSyncPref(body.enabled, body.changedAtMs ?? Date.now());
         json(res, { ok: true, enabled: getCloudSyncPref() });
         return true;
       }

package/src/lib/multi-install-parser.js

@@ -47,7 +47,9 @@ async function multiInstallParse({ paths, parserFn, providerName, cursors, getPa
       eventsAggregated += result.eventsAggregated || 0;
       bucketsQueued += result.bucketsQueued || 0;
     } catch (parseErr) {
-      cursors[providerName] = ns;
+      if (parseErr?.code !== "TOKENTRACKER_CURSOR_STORE_RETRY") {
+        cursors[providerName] = ns;
+      }
       throw parseErr;
     }
   }