mslxdff 0.1.66 → 0.1.68

package/src/cli/status.js

@@ -13,6 +13,7 @@ import { refreshGroupMembers } from "../groups.js";
 import { fmtShanghaiYMDHM } from "../time.js";
 import { fmtStatus, fmtUptime, fmtTs } from "./format.js";
 import { compareSemver } from "./policy.js";
+import { buildProviderRows, formatProviderRow } from "./provider-row.js";
 
 export async function printStatus(VERSION) {
   const daemon = readPid();
@@ -50,61 +51,11 @@ export async function printStatus(VERSION) {
   } catch {}
 
   try {
-    const configs = loadProviderConfigs();
-    const upstreamBase = process.env.UPSTREAM_BASE_URL || "https://opencode.ai";
-    const providerRows = [];
-    const opAllowed = loadProviderAllowedModels("opencode");
-    providerRows.push({ id: "opencode", enabled: true, baseUrl: upstreamBase, keys: [], allowed: opAllowed, share: false, note: "built-in, no key, cannot share" });
-    const genericIds = new Set(Object.keys(configs).filter((id) => id !== "opencode"));
-    try {
-      const raw = JSON.parse(readFileSync(stateFile, "utf8"));
-      const pk = raw.providerKeys || {};
-      for (const id of Object.keys(pk)) if (id !== "opencode") genericIds.add(id);
-      const cfgRaw = raw.providerConfigs || {};
-      for (const id of Object.keys(cfgRaw)) if (id !== "opencode") genericIds.add(id);
-    } catch {}
-    for (const k of Object.keys(process.env)) {
-      const m = k.match(/^MSLXDFF_(.+)_KEY$/);
-      if (m) {
-        const id = m[1].toLowerCase().replace(/__/g, "-");
-        if (id !== "opencode") genericIds.add(id);
-      }
-    }
-    for (const gid of [...genericIds].sort()) {
-      const cfg = configs[gid];
-      const keys = loadProviderKeys(gid);
-      const baseUrl = loadProviderBaseUrl(gid) || cfg?.baseUrl || (gid === "openrouter" ? "https://openrouter.ai/api/v1" : gid === "workbuddy" ? "https://copilot.tencent.com" : "");
-      const share = loadProviderShareKeys(gid);
-      const allowed = loadProviderAllowedModels(gid);
-      let enabled = Boolean(baseUrl && keys.length) || (gid === "openrouter" && keys.length > 0);
-      const auths = gid === "workbuddy" ? (loadProviderAuths(gid) || []) : [];
-      let note = "";
-      const isWorkbuddyStub = gid === "workbuddy" && (keys.includes("k-new") || baseUrl.includes("127.0.0.1") || (keys.length === 1 && keys[0].length < 20));
-      if (isWorkbuddyStub) {
-        enabled = false;
-        note = "测试桩 (key=k-new, baseUrl=127.0.0.1) — 请重跑 node workbuddy-token-auto.js 写入真实 JWT";
-      } else if (!enabled) {
-        if (!baseUrl && !keys.length) note = "no baseUrl, no keys";
-        else if (!baseUrl) note = "missing baseUrl";
-        else if (!keys.length) note = "no keys";
-      } else if (gid === "workbuddy" && auths.length && auths.length !== keys.length) {
-        note = `${auths.length} auth(s) / ${keys.length} key(s) — 数量不一致请重跑 workbuddy-token-auto.js`;
-      }
-      providerRows.push({ id: gid, enabled, baseUrl: baseUrl || "(none)", keys, allowed, share, note, authCount: auths.length });
-    }
+    const providerRows = buildProviderRows({});
     const enabledCount = providerRows.filter((r) => r.enabled).length;
     console.log(`\nupstream providers (${providerRows.length}, ${enabledCount} enabled)  —  mslxdff -providers list 查看详情`);
     for (const p of providerRows) {
-      const dot = p.enabled ? "●" : "○";
-      const state = p.enabled ? "enabled " : "disabled";
-      let keysInfo;
-      if (p.id === "opencode") keysInfo = "无需 key (内置)";
-      else keysInfo = p.keys.length ? `${p.keys.length} key${p.keys.length > 1 ? "s" : ""} ${p.keys.map((k) => `${k.slice(0, 3)}…${k.slice(-3)}`).join(", ")}` : "0 keys";
-      const authInfo = p.authCount ? ` ${p.authCount} acc` : "";
-      const allowInfo = p.allowed.length ? `allow=${p.allowed.length}(${p.allowed.slice(0, 2).join(",")}${p.allowed.length > 2 ? "…" : ""})` : "allow=all";
-      const shareInfo = p.id === "opencode" ? "cannot share" : `share=${p.share ? "ON" : "off"}`;
-      const note = p.note ? `  (${p.note})` : "";
-      console.log(`  ${dot} ${p.id.padEnd(12)} ${state}  ${keysInfo}${authInfo}  ${allowInfo.padEnd(18)}  baseUrl=${p.baseUrl}  ${shareInfo}${note}`);
+      console.log(formatProviderRow(p));
     }
     if (enabledCount === 1 && providerRows.length === 1) {
       console.log(`  (仅 opencode 内置免费通道；按需加：mslxdff -provider add bai https://api.b.ai/v1 <key>  或  node workbuddy-token-auto.js)`);

package/src/metrics.js

@@ -0,0 +1,63 @@
+import { normalizeFullId, toFullId } from "./providers/model-id.js";
+
+export { normalizeFullId, toFullId };
+
+// 从上游 usage 或文本兜底算 tps / charsPerSec
+export function computeMetrics({ ttfbMs, totalMs, promptTokens, completionTokens, chars }) {
+  const ttfb = Number(ttfbMs);
+  const total = Number(totalMs);
+  const hasTtfb = Number.isFinite(ttfb) && ttfb >= 0;
+  const hasTotal = Number.isFinite(total) && total >= 0;
+  const completionMs = hasTtfb && hasTotal ? Math.max(0, total - ttfb) : hasTotal ? total : null;
+  const comp = Number(completionTokens);
+  const hasComp = Number.isFinite(comp) && comp > 0 && Number.isFinite(completionMs) && completionMs > 0;
+  const tps = hasComp ? Number((comp / (completionMs / 1000)).toFixed(1)) : null;
+  const c = Number(chars);
+  const hasChars = Number.isFinite(c) && c > 0 && Number.isFinite(completionMs) && completionMs > 0;
+  const charsPerSec = !hasComp && hasChars ? Math.round(c / (completionMs / 1000)) : null;
+  return { completionMs, tps, charsPerSec };
+}
+
+// 从 Response 文本或 SSE 末帧提取 usage
+export function extractUsageFromJson(parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  const u = parsed.usage;
+  if (!u || typeof u !== "object") return null;
+  const prompt = Number(u.prompt_tokens ?? u.promptTokens ?? u.input_tokens);
+  const comp = Number(u.completion_tokens ?? u.completionTokens ?? u.output_tokens);
+  const total = Number(u.total_tokens ?? u.totalTokens);
+  const out = {};
+  if (Number.isFinite(prompt)) out.prompt_tokens = prompt;
+  if (Number.isFinite(comp)) out.completion_tokens = comp;
+  if (Number.isFinite(total)) out.total_tokens = total;
+  // reasoning_tokens 透传
+  const rt = u.completion_tokens_details?.reasoning_tokens ?? u.reasoning_tokens;
+  if (Number.isFinite(Number(rt))) out.reasoning_tokens = Number(rt);
+  return Object.keys(out).length ? out : null;
+}
+
+export function extractUsageFromSseText(sseText) {
+  if (!sseText) return null;
+  const lines = String(sseText).split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice(5).trim();
+    if (data === "[DONE]") continue;
+    try {
+      const j = JSON.parse(data);
+      if (j.usage) return extractUsageFromJson(j);
+      if (j.choices?.[0]?.finish_reason && j.usage) return extractUsageFromJson(j);
+    } catch {}
+  }
+  return null;
+}
+
+// 归一模型全称：provider + raw -> opencode/xxx
+export function resolveFullId(rawModel, providerHint) {
+  const raw = String(rawModel || "").trim();
+  if (!raw) return "";
+  if (raw.includes("/")) return normalizeFullId(raw);
+  const prov = String(providerHint || "opencode").trim() || "opencode";
+  return toFullId(prov, raw);
+}

package/src/providers/dispatcher.js

@@ -1,10 +1,22 @@
 import { splitModelId, DEFAULT_PROVIDER, joinModelId } from "./model-id.js";
-import { isModelAllowed, loadProviderAllowedModels, loadProviderAllowAnyModels } from "../state.js";
+import { isModelAllowed as stateIsAllowed, loadProviderAllowedModels as stateLoadAllowed, loadProviderAllowAnyModels as stateLoadAllowAny } from "../state.js";
 
 // 多供应商 dispatcher：把多个 Provider 聚合成一个 `upstream` 形状（chat/preheat/close），
 // 按 body.model 的前缀路由到对应供应商，转发上游前剥掉前缀只发原始 id。
-export function createProviderDispatcher(providers = []) {
+// 纯化：第二参可注入纯函数 isAllowed/getAllowed/getAllowAny，便于单测不读盘
+export function createProviderDispatcher(providers = [], opts = {}) {
   const byId = new Map(providers.map((p) => [p.id, p]));
+  // 纯化注入：第二参可为 {isAllowed, getAllowedModels, getAllowAny} 或直接函数 isAllowed
+  let isAllowedFn, getAllowedFn, getAllowAnyFn;
+  if (typeof opts === "function") {
+    isAllowedFn = opts;
+    getAllowedFn = stateLoadAllowed;
+    getAllowAnyFn = stateLoadAllowAny;
+  } else {
+    isAllowedFn = opts.isAllowed || stateIsAllowed;
+    getAllowedFn = opts.getAllowedModels || stateLoadAllowed;
+    getAllowAnyFn = opts.getAllowAny || stateLoadAllowAny;
+  }
 
   function resolve(model) {
     const split = splitModelId(model, providers.map((p) => p.id));
@@ -29,8 +41,8 @@ export function createProviderDispatcher(providers = []) {
         raw = modelPart;
       }
     }
-    if (!isModelAllowed(provider.id, raw)) {
-      const allowed = loadProviderAllowedModels(provider.id);
+    if (!isAllowedFn(provider.id, raw)) {
+      const allowed = getAllowedFn(provider.id) || [];
       const msg = `model not allowed for provider "${provider.id}": "${raw}" — allowed: ${allowed.join(", ") || "(none)"} (use: mslxdff -provider ${provider.id} allowlist add <model>)`;
       return new Response(JSON.stringify({ error: msg }), { status: 403, headers: { "Content-Type": "application/json", "x-mslxdff-allowlist": "1" } });
     }
@@ -58,8 +70,8 @@ export function createProviderDispatcher(providers = []) {
       } catch {
         list = [];
       }
-      const allowed = loadProviderAllowedModels(p.id);
-      const allowAny = loadProviderAllowAnyModels(p.id);
+      const allowed = getAllowedFn(p.id) || [];
+      const allowAny = getAllowAnyFn(p.id);
       const allowedSet = allowed.length ? new Set(allowed) : null;
       // 空名单且不允许任意模型 => 该供应商不暴露任何模型（安全默认）
       if (!allowedSet && !allowAny) continue;

package/src/providers/generic.js

@@ -29,6 +29,7 @@ export function createGenericProvider({
   },
   fetchImpl,
   headers: extraHeaders,
+  mapModel,
   noAgent = false,
   file,
 } = {}) {
@@ -79,6 +80,7 @@ export function createGenericProvider({
   const { listModels } = createListModelsRunner({
     id, ring, dispatcher, fetchImpl,
     getUrl: () => joinUrl(resolvedBase, resolvedModelsPath),
+    mapModel,
   });
 
   const { preheat } = createPreheatRunner({

package/src/providers/openrouter.js

@@ -1,87 +1,31 @@
-import { createKeyRing } from "./keyring.js";
-import { loadProviderKeys } from "../state.js";
-import { envInt, joinUrl, getUndici, createAgent, createChatRunner, createListModelsRunner, createPreheatRunner } from "./base.js";
-import { joinModelId } from "./model-id.js";
+import { createGenericProvider } from "./generic.js";
 
-const { UndiciFetch } = getUndici();
 const DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
 
-function collectApiKeys(apiKeys, apiKey) {
-  const list = [
-    ...(Array.isArray(apiKeys) ? apiKeys : [apiKeys].filter(Boolean)),
-    apiKey,
-    ...(apiKeys === undefined && apiKey === undefined ? loadProviderKeys("openrouter") : []),
-  ].filter((k) => typeof k === "string" && k.trim().length);
-  return [...new Set(list.map((k) => k.trim()))];
-}
-
 export function createOpenRouterProvider({
   apiKeys,
   apiKey,
   baseUrl = process.env.MSLXDFF_OPENROUTER_BASE_URL || DEFAULT_BASE_URL,
-  connectTimeoutMs = Number(process.env.MSLXDFF_OPENROUTER_TIMEOUT_MS) || 30_000,
-  cooldownMs = envInt("MSLXDFF_OPENROUTER_COOLDOWN_MS", 30_000),
-  retry = {
-    network: { attempts: 2, delayMs: 300 },
-    429: { attempts: 1, delayMs: 100 },
-    502: { attempts: 1, delayMs: 100 },
-    503: { attempts: 1, delayMs: 100 },
-    504: { attempts: 1, delayMs: 100 },
-  },
   fetchImpl,
-  headers: extraHeaders,
+  headers,
   noAgent = false,
+  ...rest
 } = {}) {
-  if (!fetchImpl) fetchImpl = UndiciFetch || fetch;
-  const ring = createKeyRing(collectApiKeys(apiKeys, apiKey), { cooldownMs });
-  let dispatcher = null; let agent = null;
-  if (!noAgent) {
-    const a = createAgent({
-      keepAliveTimeout: envInt("MSLXDFF_OA_KEEPALIVE_TIMEOUT", 30_000),
-      keepAliveMaxTimeout: envInt("MSLXDFF_OA_KEEPALIVE_MAX_TIMEOUT", 60_000),
-      connections: envInt("MSLXDFF_OA_KEEPALIVE_CONNECTIONS", 20),
-    });
-    agent = a.agent; dispatcher = a.dispatcher;
-  }
-
-  function buildHeaders(body, key) {
-    const isStream = body?.stream !== false;
-    const h = {
-      "Content-Type": "application/json",
-      Accept: isStream ? "text/event-stream" : "*/*",
-      "User-Agent": "mslxdff",
+  return createGenericProvider({
+    id: "openrouter",
+    baseUrl,
+    apiKeys,
+    apiKey,
+    modelsPath: "/models",
+    chatPath: "/chat/completions",
+    headers: {
       "HTTP-Referer": process.env.MSLXDFF_OPENROUTER_REFERER || "https://github.com/mslxdff",
       "X-Title": process.env.MSLXDFF_OPENROUTER_TITLE || "mslxdff",
-    };
-    if (key) h["Authorization"] = `Bearer ${key}`;
-    return { ...h, ...extraHeaders };
-  }
-
-  const { runChat } = createChatRunner({
-    id: "openrouter", ring, cooldownMs, retry, fetchImpl, dispatcher, buildHeaders,
-    getUrl: () => `${baseUrl}/chat/completions`,
-    connectTimeoutMs,
-  });
-
-  async function chat(body) { return runChat(body, ring, "MSLXDFF_OPENROUTER_KEY"); }
-  async function chatWithKeys(body, keys) {
-    const tmp = createKeyRing(keys, { cooldownMs });
-    return runChat(body, tmp, "shared provider keys");
-  }
-
-  const { listModels } = createListModelsRunner({
-    id: "openrouter", ring, dispatcher, fetchImpl,
-    getUrl: () => `${baseUrl}/models`,
-    // openrouter 仅暴露免费模型
+      ...(headers || {}),
+    },
     mapModel: (raw) => raw.filter((m) => Number(m.pricing?.prompt || 0) === 0 && Number(m.pricing?.completion || 0) === 0),
+    fetchImpl,
+    noAgent,
+    ...rest,
   });
-
-  const { preheat } = createPreheatRunner({
-    dispatcher, fetchImpl, getUrl: () => `${baseUrl}/models`,
-    id: "openrouter", ring,
-  });
-
-  async function close() { if (agent?.close) { try { await agent.close(); } catch {} } }
-
-  return { id: "openrouter", chat, chatWithKeys, listModels, preheat, close, agent, keyRing: ring };
 }

package/src/providers/workbuddy/auth.js

@@ -0,0 +1,175 @@
+import { joinUrl } from "../base.js";
+import { WORKBUDDY_DEFAULT_BASE_URL } from "../../state/schemas/provider.js";
+
+export function decodeJwtExp(token) {
+  try {
+    const payload = String(token || "").split(".")[1];
+    if (!payload) return 0;
+    let b64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = b64.length % 4;
+    if (pad) b64 += "=".repeat(4 - pad);
+    const json = JSON.parse(Buffer.from(b64, "base64").toString("utf8"));
+    return Number(json.exp || 0);
+  } catch {
+    return 0;
+  }
+}
+
+export function isInsufficientStatus(status, bodyText, cached) {
+  if (cached && Number(cached.total) === 0) return true;
+  if (status === 402) return true;
+  if (status === 403 || status === 429) {
+    const t = String(bodyText || "").toLowerCase();
+    if (t.includes("insufficient") || t.includes("quota") || t.includes("balance") || t.includes("credit") || t.includes("exhaust") || t.includes("402") || t.includes("10002") || t.includes("10003")) return true;
+  }
+  return false;
+}
+
+export function isAuthError(status, bodyText) {
+  if (status === 401 || status === 403) return true;
+  const t = String(bodyText || "").toLowerCase();
+  if (t.includes("unauthorized") || t.includes("authenticate") || t.includes("invalid token") || t.includes("token expired") || t.includes("token invalid") || t.includes("access token") || t.includes("login expired") || t.includes("need login") || t.includes("session expired")) return true;
+  if (t.includes("code") && (t.includes("401") || t.includes("403")) && t.includes("token")) return true;
+  if (status === 400 && t.includes("token")) return true;
+  return false;
+}
+
+export function createAuthService({
+  baseUrl,
+  fetchImpl,
+  clock = Date.now,
+  dispatcher,
+  file,
+  store, // optional { saveProviderConfig, keysRef, authListRef } or custom saveFn
+  saveFn,
+} = {}) {
+  const resolvedBase = baseUrl ? String(baseUrl).trim().replace(/\/+$/, "") : WORKBUDDY_DEFAULT_BASE_URL;
+  if (!fetchImpl) {
+    try {
+      const { getUndici } = awaitImportUndici();
+      fetchImpl = getUndici()?.UndiciFetch || fetch;
+    } catch {
+      fetchImpl = fetch;
+    }
+  }
+  // lazy resolve UndiciFetch if not provided
+  if (!fetchImpl) fetchImpl = fetch;
+
+  const inflightRefresh = new Map();
+
+  async function refreshTokenFor(key, auth) {
+    const rt = auth?.refreshToken;
+    const uid = auth?.uid;
+    if (!rt || !uid) return null;
+    const dedupKey = String(uid);
+    if (inflightRefresh.has(dedupKey)) {
+      try { return await inflightRefresh.get(dedupKey); } catch { return null; }
+    }
+    const p = (async () => {
+      const url = joinUrl(resolvedBase, "/v2/plugin/auth/token/refresh");
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`,
+        "X-Refresh-Token": rt,
+        "X-User-Id": uid,
+        "X-Domain": auth.domain || "www.codebuddy.cn",
+        "User-Agent": "CLI/2.115.0 WorkBuddy/2.115.0",
+        Origin: "https://www.codebuddy.cn",
+        Referer: "https://www.codebuddy.cn/",
+      };
+      try {
+        const opts = { method: "POST", headers, body: "{}" };
+        if (dispatcher) opts.dispatcher = dispatcher;
+        const res = await fetchImpl(url, opts);
+        const text = await res.text();
+        let j;
+        try { j = JSON.parse(text); } catch { return null; }
+        if (j.code === 0 && j.data?.accessToken) {
+          const newAt = j.data.accessToken;
+          const newRt = j.data.refreshToken || rt;
+          // attempt to persist if store provided
+          try {
+            if (saveFn) {
+              await saveFn({ newAt, newRt, uid, oldKey: key, auth });
+            } else if (store && typeof store.save === "function") {
+              await store.save({ newAt, newRt, uid, oldKey: key, auth });
+            } else if (store && Array.isArray(store.keys) && Array.isArray(store.authList)) {
+              // direct mutation fallback (legacy shape)
+              const idx = store.keys.indexOf(key);
+              if (idx >= 0) {
+                store.keys[idx] = newAt;
+                store.authList[idx] = { ...auth, refreshToken: newRt };
+                try {
+                  const { saveProviderConfig } = await import("../../state.js");
+                  saveProviderConfig("workbuddy", { baseUrl: resolvedBase, keys: [...store.keys], auths: [...store.authList] }, file ? { file } : {});
+                } catch {}
+                try {
+                  const { writeFileSync, mkdirSync, existsSync } = await import("node:fs");
+                  const { join, dirname } = await import("node:path");
+                  const { tmpdir } = await import("node:os");
+                  const isTest = process.env.NODE_ENV === "test" || (process.env.MSLXDFF_STATE_FILE && String(process.env.MSLXDFF_STATE_FILE).includes("mslxdff-test"));
+                  const authDir = process.env.WORKBUDDY_AUTH_DIR || (isTest ? join(tmpdir(), "mslxdff-test-auths") : (file && String(file).includes("mslxdff-") ? join(dirname(String(file)), "auths") : join(process.cwd(), "auths")));
+                  mkdirSync(authDir, { recursive: true });
+                  const expAt = (() => { try { return JSON.parse(Buffer.from(newAt.split(".")[1], "base64").toString()).exp; } catch { return Math.floor(Date.now() / 1000) + 5184000; } })();
+                  const doc = { account: { uid, enterpriseId: auth.enterpriseId || "", nickname: "" }, auth: { accessToken: newAt, refreshToken: newRt, expiresAt: expAt, domain: auth.domain || "www.codebuddy.cn" } };
+                  const fp = join(authDir, `workbuddy-${uid}.json`);
+                  const tmp = fp + ".tmp";
+                  writeFileSync(tmp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+                  try {
+                    if (existsSync(fp)) {
+                      const { unlinkSync, renameSync } = await import("node:fs");
+                      unlinkSync(fp);
+                      renameSync(tmp, fp);
+                    } else {
+                      const { renameSync } = await import("node:fs");
+                      renameSync(tmp, fp);
+                    }
+                  } catch {
+                    writeFileSync(fp, JSON.stringify(doc, null, 2), { mode: 0o600 });
+                  }
+                } catch {}
+              }
+            }
+          } catch {}
+          return newAt;
+        }
+      } catch {}
+      return null;
+    })();
+    inflightRefresh.set(dedupKey, p);
+    try {
+      const r = await p;
+      return r;
+    } finally {
+      inflightRefresh.delete(dedupKey);
+    }
+  }
+
+  function maybeProactiveRefresh(auth, key) {
+    try {
+      const exp = decodeJwtExp(key);
+      if (!exp) return;
+      const remain = exp * 1000 - clock();
+      if (remain < 5 * 60 * 1000 && remain > -60 * 60 * 1000) {
+        void refreshTokenFor(key, auth).catch(() => {});
+      }
+    } catch {}
+  }
+
+  return { refreshTokenFor, maybeProactiveRefresh, decodeJwtExp, isAuthError, isInsufficientStatus, _inflight: inflightRefresh };
+}
+
+function awaitImportUndici() {
+  try {
+    // dynamic to avoid top-level await
+    let UndiciFetch = null;
+    try {
+      // eslint-disable-next-line no-undef
+      const mod = globalThis.__mslxdff_undici || null;
+      if (mod) return mod;
+    } catch {}
+    return { UndiciFetch: null };
+  } catch {
+    return { UndiciFetch: null };
+  }
+}

package/src/providers/workbuddy/balance.js

@@ -0,0 +1,84 @@
+const BALANCE_TTL_MS = 5 * 60 * 1000;
+
+export function createBalanceCache({ ttlMs = BALANCE_TTL_MS, now = Date.now } = {}) {
+  const map = new Map(); // uid -> { total, dailyPacks, activeCount, nextExpire, fetchedAt, totalStr? }
+  function getCachedBalance(uid) {
+    const v = map.get(String(uid));
+    if (!v) return null;
+    if (now() - v.fetchedAt > ttlMs) {
+      map.delete(String(uid));
+      return null;
+    }
+    return v;
+  }
+  function setCachedBalance(uid, data) {
+    const v = { ...data, fetchedAt: now() };
+    map.set(String(uid), v);
+    return v;
+  }
+  function getBalanceCache() { return map; }
+  function clearBalanceCache() { map.clear(); }
+
+  async function fetchBalance({ uid, key, auth, domain, baseUrl = "https://www.codebuddy.cn", fetchImpl } = {}) {
+    const at = key || auth?.accessToken || "";
+    const u = uid || auth?.uid || "";
+    const d = domain || auth?.domain || "www.codebuddy.cn";
+    if (!u || !at) return null;
+    const fetcher = fetchImpl || fetch;
+    const body = JSON.stringify({
+      PageNumber: 1, PageSize: 100, ProductCode: "p_tcaca", Status: [0, 3],
+      PackageEndTimeRangeBegin: "2026-08-01 00:00:00",
+      PackageEndTimeRangeEnd: "2030-01-01 00:00:00",
+    });
+    try {
+      const res = await fetcher(`${baseUrl.replace(/\/+$/, "")}/v2/billing/meter/get-user-resource`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${at}`,
+          "Content-Type": "application/json",
+          "X-User-Id": u,
+          "X-Domain": d,
+        },
+        body,
+      });
+      if (!res.ok) return null;
+      const j = await res.json().catch(() => null);
+      const accs = j?.data?.Response?.Data?.Accounts || j?.data?.Response?.data?.Accounts || [];
+      const accounts = Array.isArray(accs) ? accs : [];
+      const active = accounts.filter(a => a.Status === 0);
+      const total = active.reduce((s, a) => s + Number(a.CycleCapacityRemainPrecise || a.CycleCapacityRemain || 0), 0);
+      const dailyPacks = active.filter(a => a.PackageName?.includes("裂变包") && String(a.CycleCapacitySizePrecise) === "100");
+      const sorted = [...active].sort((a,b)=> new Date(a.CycleEndTime) - new Date(b.CycleEndTime));
+      const nextExpire = sorted[0]?.CycleEndTime || null;
+      const data = {
+        total: Number(total.toFixed(2)),
+        dailyPacks: dailyPacks.length,
+        activeCount: active.length,
+        nextExpire,
+        fetchedAt: now(),
+      };
+      data.totalStr = total.toFixed(2);
+      setCachedBalance(u, data);
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
+  async function getBalanceWithCache({ uid, key, auth, domain, baseUrl, fetchImpl } = {}) {
+    const cached = getCachedBalance(uid || auth?.uid);
+    if (cached) return cached;
+    return fetchBalance({ uid, key, auth, domain, baseUrl, fetchImpl });
+  }
+
+  return { getCachedBalance, setCachedBalance, getBalanceCache, clearBalanceCache, fetchBalance, getBalanceWithCache, _map: map, _ttlMs: ttlMs };
+}
+
+// 默认单例（保持与 src/providers/workbuddy-balance.js 兼容，供未注入场景使用）
+const defaultCache = createBalanceCache();
+export const getCachedBalance = defaultCache.getCachedBalance;
+export const setCachedBalance = defaultCache.setCachedBalance;
+export const getBalanceCache = defaultCache.getBalanceCache;
+export const clearBalanceCache = defaultCache.clearBalanceCache;
+export const fetchBalance = defaultCache.fetchBalance;
+export const getBalanceWithCache = defaultCache.getBalanceWithCache;