tokentracker-cli 0.57.0 → 0.58.0

package/src/lib/rollout.js

@@ -2520,65 +2520,64 @@ function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
   return out;
 }
 
-// Mimo (mimocode) reuses OpenCode's `message` table schema, but its DB ALSO
-// contains the user's imported Claude Code history: on install, mimocode reads
-// ~/.claude/projects/*.jsonl and copies those sessions into its own DB,
-// recording each in the `claude_import` table (source_path → session_id +
-// message_ids). Those imported messages are already counted by the Claude
-// parser, so counting them here would double-count Claude usage AND mislabel it
-// as "mimo".
+// mimocode mirrors the user's Claude Code + claude-mem history into its own
+// `message` table — via an explicit `claude_import` AND a live observer /
+// session sync — so the overwhelming majority of rows are anthropic-endpoint
+// turns (providerID="anthropic") the Claude parser ALREADY counts as
+// source=claude. On the dev's box that's ~3.9B mirrored tokens vs ~22M genuine
+// mimo tokens. Counting the mirror under "mimo" double-counts and mislabels
+// Claude usage (user saw claude-* rows under the MIMO provider).
 //
-// `message_ids` was added to claude_import via a migration, so rows written by
-// an older mimocode have it NULL. For those we fall back to excluding the whole
-// imported session by session_id — a claude_import.session_id is always an
-// import-created session, never a native mimo one, so this is safe. Rows that
-// DO carry message_ids use precise per-id exclusion, which preserves any native
-// turns the user later added to an imported session.
-function readMimoImportedKeys(dbPath, sqliteOptions = {}) {
-  const sql = `SELECT session_id, message_ids FROM claude_import`;
-  let rows;
-  try {
-    rows = readSqliteJsonRows(dbPath, sql, {
-      label: "Mimo import",
-      maxBuffer: 200 * 1024 * 1024,
-      timeout: 30_000,
-      ...sqliteOptions,
-    });
-  } catch (_e) {
-    // claude_import table absent (older/newer mimocode) → treat as no imports.
-    return { ids: new Set(), sessions: new Set() };
-  }
-  const ids = new Set();
-  const sessions = new Set();
-  for (const row of rows) {
-    if (!row) continue;
-    let arr = null;
-    if (typeof row.message_ids === "string") {
-      try {
-        arr = JSON.parse(row.message_ids);
-      } catch (_e) {
-        arr = null;
-      }
-    }
-    if (Array.isArray(arr) && arr.length > 0) {
-      for (const id of arr) if (typeof id === "string") ids.add(id);
-    } else if (typeof row.session_id === "string" && row.session_id) {
-      sessions.add(row.session_id);
-    }
-  }
-  return { ids, sessions };
+// The discriminator is providerID, NOT the model id. mimo's own runtime tags
+// turns providerID="mimo" (its auto router) or "xiaomi". providerID="anthropic"
+// means the turn went through a Claude-compatible endpoint — plain Claude Code,
+// OR a mimo-named model the user picked IN Claude Code (e.g. model=mimo-v2.5-pro
+// run inside Claude Code, logged in ~/.claude, counted as source=claude). Keying
+// off the model id would wrongly re-count that mimo-v2.5-pro. claude_import is
+// irrelevant — it never covers the observer/session mirror; the provider rule
+// subsumes it.
+function isMimoNativeMessage(data) {
+  if (!data) return false;
+  const provider = String(data.providerID || "").toLowerCase();
+  return provider === "mimo" || provider === "xiaomi";
+}
+
+// Read only genuine mimo assistant messages (mimo's own models), dropping the
+// mirrored Claude/claude-mem rows. See isMimoNativeMessage for why.
+function readMimoDbMessages(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return [];
+  const all = readOpencodeDbMessages(dbPath, sqliteOptions);
+  return all.filter((m) => isMimoNativeMessage(m.data));
+}
+
+// ZCode is Z.ai's (Zhipu) coding agent — another OpenCode-fork that stores
+// assistant messages in the identical `message` table schema
+// (~/.zcode/cli/db/db.sqlite). Its own agent runs GLM models through Z.ai /
+// BigModel endpoints, tagged with a providerID like "builtin:zai-start-plan",
+// "builtin:zai-coding-plan", or "builtin:bigmodel-coding-plan". ZCode can ALSO
+// orchestrate bundled claude-code / codex / gemini-cli sub-agents; those turns
+// carry providerID "anthropic"/"openai"/"google" and are already counted by the
+// standalone Claude/Codex/Gemini parsers. Keep ONLY ZCode-native (Z.ai /
+// BigModel / Zhipu) rows so we never double-count. Key off providerID, NEVER the
+// model id — a GLM model the user ran *inside* Claude Code is source=claude, so
+// matching "glm" on the model would re-count it. Mirrors the Mimo discipline.
+function isZcodeNativeMessage(data) {
+  if (!data) return false;
+  const provider = String(data.providerID || "").toLowerCase();
+  return (
+    provider.includes("zai") ||
+    provider.includes("bigmodel") ||
+    provider.includes("zcode") ||
+    provider.includes("zhipu")
+  );
 }
 
-// Read only NATIVE mimo assistant messages — token-bearing rows that are not
-// part of any claude_import row (by message id, or session id for legacy import
-// rows without message_ids). See readMimoImportedKeys for why.
-function readMimoDbMessages(dbPath, sqliteOptions = {}) {
+// 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 all = readOpencodeDbMessages(dbPath, sqliteOptions);
-  if (all.length === 0) return all;
-  const { ids, sessions } = readMimoImportedKeys(dbPath, sqliteOptions);
-  if (ids.size === 0 && sessions.size === 0) return all;
-  return all.filter((m) => !ids.has(m.id) && !sessions.has(m.sessionID));
+  return all.filter((m) => isZcodeNativeMessage(m.data));
 }
 
 async function parseOpencodeDbIncremental({
@@ -9095,6 +9094,7 @@ module.exports = {
   listOpencodeMessageFiles,
   readOpencodeDbMessages,
   readMimoDbMessages,
+  readZcodeDbMessages,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
   resolveHermesPath,

package/src/lib/usage-limits.js

@@ -24,6 +24,7 @@ const {
   fetchCursorUsageSummary,
 } = require("./cursor-config");
 const { fetchGrokLimits } = require("./grok-limits");
+const { fetchZcodeLimits } = require("./zcode-limits");
 const { readSqliteJsonRows } = require("./sqlite-reader");
 
 // 2-minute in-memory cache
@@ -2289,7 +2290,7 @@ async function fetchUsageLimitsUncached({
   const freshClaudeCache = claudeToken ? readFreshClaudeLimitsCache({ home, nowMs }) : null;
 
   const providerFetch = withFetchTimeout(fetchImpl, providerTimeoutMs);
-  const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok] = await Promise.all([
+  const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok, zcode] = await Promise.all([
     claudeToken && !freshClaudeCache && !claudeRetryAtMs
       ? withProviderTimeout(fetchClaudeUsageLimits(claudeToken, { fetchImpl: providerFetch, maxAttempts: 1 }), "Claude", providerTimeoutMs).then(
           (value) => ({ status: "fulfilled", value }),
@@ -2318,6 +2319,8 @@ async function fetchUsageLimitsUncached({
       .catch((reason) => ({ configured: true, error: reason?.message || "Unknown error" })),
     withProviderTimeout(fetchGrokLimits({ home, env, fetchImpl: providerFetch }), "Grok Build", providerTimeoutMs)
       .catch((reason) => ({ configured: true, error: reason?.message || "Unknown error" })),
+    withProviderTimeout(fetchZcodeLimits({ home, env, fetchImpl: providerFetch }), "ZCode", providerTimeoutMs)
+      .catch((reason) => ({ configured: true, error: reason?.message || "Unknown error" })),
   ]);
 
   let claude;
@@ -2399,6 +2402,7 @@ async function fetchUsageLimitsUncached({
     antigravity: withPlanLabel(antigravity, antigravity.account_plan, "Antigravity"),
     copilot: withPlanLabel(copilot, copilot.plan_name, "Copilot"),
     grok: withPlanLabel(grok, null, "Grok"),
+    zcode: withPlanLabel(zcode, zcode.plan_label, "ZCode"),
   };
 
   cache = { data, fetchedAt: nowMs };
@@ -2430,4 +2434,5 @@ module.exports = {
   decryptCopilotAuthDbToken,
   describeCopilotOtelStatus,
   fetchGrokLimits,
+  fetchZcodeLimits,
 };

package/src/lib/zcode-limits.js

@@ -0,0 +1,213 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const DEFAULT_BILLING_BASE_URL = "https://zcode.z.ai/api/v1/zcode-plan";
+
+function resolveZcodeHome({ home, env = process.env } = {}) {
+  if (typeof env.TOKENTRACKER_ZCODE_HOME === "string" && env.TOKENTRACKER_ZCODE_HOME.trim()) {
+    return path.resolve(env.TOKENTRACKER_ZCODE_HOME.trim());
+  }
+  if (typeof env.ZCODE_HOME === "string" && env.ZCODE_HOME.trim()) {
+    return path.resolve(env.ZCODE_HOME.trim());
+  }
+  return path.join(home || os.homedir(), ".zcode");
+}
+
+function resolveZcodeBillingBaseUrl(env = process.env) {
+  const explicit =
+    typeof env.TOKENTRACKER_ZCODE_BILLING_BASE_URL === "string"
+      ? env.TOKENTRACKER_ZCODE_BILLING_BASE_URL.trim()
+      : "";
+  if (explicit) return explicit.replace(/\/$/, "");
+  return DEFAULT_BILLING_BASE_URL;
+}
+
+function isZcodeInstalled({ home, env } = {}) {
+  const zcodeHome = resolveZcodeHome({ home, env });
+  const configPath = path.join(zcodeHome, "v2", "config.json");
+  if (fs.existsSync(configPath)) return true;
+  const dbPath = path.join(zcodeHome, "cli", "db", "db.sqlite");
+  return fs.existsSync(dbPath);
+}
+
+function loadZcodeApiKey({ home, env } = {}) {
+  const zcodeHome = resolveZcodeHome({ home, env });
+  const configPath = path.join(zcodeHome, "v2", "config.json");
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (!config || typeof config !== "object") return null;
+    const providers = config.provider || {};
+    // Try the active start-plan first, then coding-plan variants
+    const candidates = [
+      "builtin:bigmodel-start-plan",
+      "builtin:zai-start-plan",
+      "builtin:bigmodel-coding-plan",
+      "builtin:zai-coding-plan",
+    ];
+    for (const key of candidates) {
+      const provider = providers[key];
+      if (!provider || typeof provider !== "object") continue;
+      if (provider.enabled === false) continue;
+      const apiKey = typeof provider?.options?.apiKey === "string" ? provider.options.apiKey.trim() : "";
+      if (apiKey) return { apiKey, providerKey: key, baseUrl: provider?.options?.baseURL || null };
+    }
+    return null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function zcodeValNumber(value) {
+  if (value == null) return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function zcodeTsToIso(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return new Date(value * 1000).toISOString();
+  }
+  return null;
+}
+
+function clampPercent(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  if (n <= 0) return 0;
+  if (n >= 100) return 100;
+  return n;
+}
+
+function buildWindow({ usedPercent, resetAt }) {
+  const pct = clampPercent(usedPercent);
+  if (pct === null) return null;
+  return {
+    used_percent: pct,
+    reset_at: typeof resetAt === "string" && resetAt ? resetAt : null,
+  };
+}
+
+// Z.ai coding-plan ids look like "zcode-v3-start-plan-0615". The raw id reads
+// terribly as a plan label, so extract just the human tier ("Start"/"Lite"/
+// "Pro"/"Max"); fall back to null (→ bare "ZCode") when no known tier matches.
+function deriveZcodePlanLabel(planId) {
+  if (typeof planId !== "string" || !planId) return null;
+  const m = planId.toLowerCase().match(/\b(lite|start|pro|max|team|enterprise)\b/);
+  if (!m) return null;
+  return m[1].charAt(0).toUpperCase() + m[1].slice(1);
+}
+
+function normalizeZcodeBalanceResponse(body) {
+  const data = body?.data;
+  if (!data || typeof data !== "object") {
+    throw new Error("Could not parse ZCode balance: missing data");
+  }
+
+  const balances = Array.isArray(data.balances) ? data.balances : [];
+  if (!balances.length) {
+    throw new Error("Could not parse ZCode balance: no balance buckets");
+  }
+
+  const serverTime = zcodeValNumber(data.server_time);
+  const buckets = balances.map((b) => {
+    const total = zcodeValNumber(b.total_units);
+    const used = zcodeValNumber(b.used_units);
+    const remaining = zcodeValNumber(b.remaining_units);
+    const periodEnd = zcodeValNumber(b.period_end) || zcodeValNumber(b.expires_at);
+    const resetAt = zcodeTsToIso(periodEnd);
+    const usedPercent =
+      total != null && total > 0 && used != null ? (used / total) * 100 : null;
+
+    return {
+      show_name: typeof b.show_name === "string" ? b.show_name : "",
+      entitlement_id: typeof b.entitlement_id === "string" ? b.entitlement_id : "",
+      total_units: total,
+      used_units: used,
+      remaining_units: remaining,
+      window: buildWindow({ usedPercent, resetAt }),
+    };
+  });
+
+  // Primary window: highest-priority bucket (GLM-5.2 typically)
+  // Secondary window: second bucket (GLM-5-Turbo typically)
+  const sorted = buckets.slice().sort((a, b) => {
+    const aTotal = a.total_units || 0;
+    const bTotal = b.total_units || 0;
+    return bTotal - aTotal;
+  });
+
+  const planId = typeof balances[0]?.plan_id === "string" ? balances[0].plan_id : null;
+  return {
+    server_time: serverTime,
+    plan_id: planId,
+    plan_label: deriveZcodePlanLabel(planId),
+    buckets: sorted,
+    primary_window: sorted[0]?.window || null,
+    secondary_window: sorted[1]?.window || null,
+  };
+}
+
+async function fetchZcodeBilling(apiKey, { fetchImpl = fetch, baseUrl, env } = {}) {
+  const root = (baseUrl || resolveZcodeBillingBaseUrl(env)).replace(/\/$/, "");
+  const res = await fetchImpl(`${root}/billing/balance`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "application/json",
+    },
+  });
+  if (res.status === 401 || res.status === 403) {
+    throw new Error("Not authenticated with ZCode. Run `zcode` in Terminal to log in.");
+  }
+  if (!res.ok) {
+    throw new Error(`ZCode billing API returned ${res.status}`);
+  }
+  return res.json();
+}
+
+async function fetchZcodeLimits({ home, env, fetchImpl = fetch } = {}) {
+  if (!isZcodeInstalled({ home, env })) {
+    return { configured: false };
+  }
+  const auth = loadZcodeApiKey({ home, env });
+  if (!auth) {
+    return { configured: false };
+  }
+  try {
+    const body = await fetchZcodeBilling(auth.apiKey, {
+      fetchImpl,
+      // Coding-plan baseURL is ".../zcode-plan/anthropic"; strip the trailing
+      // "/anthropic" (with or without a trailing slash) to reach the billing root.
+      baseUrl: auth.baseUrl ? auth.baseUrl.replace(/\/anthropic\/?$/, "") : undefined,
+      env,
+    });
+    const apiCode = typeof body?.code === "number" ? body.code : null;
+    if (apiCode !== null && apiCode !== 0) {
+      throw new Error(`ZCode billing API error: code=${apiCode} msg=${body?.msg || "unknown"}`);
+    }
+    return {
+      configured: true,
+      error: null,
+      ...normalizeZcodeBalanceResponse(body),
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      error: error?.message || "Unknown error",
+    };
+  }
+}
+
+module.exports = {
+  resolveZcodeHome,
+  resolveZcodeBillingBaseUrl,
+  isZcodeInstalled,
+  loadZcodeApiKey,
+  deriveZcodePlanLabel,
+  normalizeZcodeBalanceResponse,
+  fetchZcodeBilling,
+  fetchZcodeLimits,
+};