creditdaddy 1.6.2 → 1.6.5

package/src/loomyLocal.js

@@ -0,0 +1,188 @@
+/**
+ * 科大讯飞 Loomy 桌面客户端本机凭据读取与多账号切换。
+ *
+ * 凭据存储（Windows）：
+ *   C:\Users\Public\Loomy\<UserHash>\userData\auth-session.json
+ *   UserHash = sha256(os.userInfo().username).slice(0, 12)
+ *   结构：{ session, userid, phone, updatedAt }
+ *
+ * 账号切换：Loomy 启动时读取该文件恢复登录，写入目标账号的 session/userid/phone
+ * 并重启客户端即完成换号。
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+
+const EXE_NAME = 'Loomy.exe';
+
+function userHash() {
+  const username = os.userInfo().username;
+  return crypto.createHash('sha256').update(username).digest('hex').slice(0, 12);
+}
+
+export function credentialFile() {
+  if (process.env.LOOMY_CREDENTIAL_FILE) return process.env.LOOMY_CREDENTIAL_FILE;
+  if (process.platform !== 'win32') {
+    return path.join(os.homedir(), '.config', 'loomy', 'userData', 'auth-session.json');
+  }
+  return path.join('C:', 'Users', 'Public', 'Loomy', userHash(), 'userData', 'auth-session.json');
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+/** 读取本机当前登录的 Loomy 凭据 → { session, userid, phone, updatedAt }；未登录返回 null */
+export function readCredential() {
+  const file = credentialFile();
+  const j = readJson(file);
+  if (!j || !j.session || !j.userid) return null;
+  return {
+    session: String(j.session).trim(),
+    userid: String(j.userid).trim(),
+    phone: String(j.phone || '').trim(),
+    updatedAt: j.updatedAt || null,
+  };
+}
+
+/** 写回凭据文件（用于换号） */
+export function writeCredential({ session, userid, phone = '' }) {
+  const file = credentialFile();
+  const existing = readJson(file) || {};
+  const next = {
+    ...existing,
+    session: String(session).trim(),
+    userid: String(userid).trim(),
+    phone: String(phone || '').trim(),
+    updatedAt: Date.now(),
+  };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${crypto.randomUUID()}`;
+  fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, file);
+}
+
+/** 探测 Loomy 是否在运行 */
+export function loomyRunning() {
+  if (process.platform !== 'win32') return false;
+  try {
+    const out = execFileSync('tasklist.exe',
+      ['/FI', `IMAGENAME eq ${EXE_NAME}`, '/NH'],
+      { windowsHide: true, encoding: 'utf8', timeout: 8000 });
+    return out.toLowerCase().includes(EXE_NAME.toLowerCase()) && !/no tasks|没有找到|没有任务/i.test(out);
+  } catch { return false; }
+}
+
+/** 获取本机 Loomy.exe 路径 */
+export function candidateClientPath() {
+  if (process.platform !== 'win32') return null;
+  const candidates = [
+    'C:\\Program Files\\Loomy\\Loomy.exe',
+    'C:\\Program Files (x86)\\Loomy\\Loomy.exe',
+    path.join(process.env.LOCALAPPDATA || '', 'Programs', 'Loomy', 'Loomy.exe'),
+  ];
+  return candidates.find((p) => fs.existsSync(p)) || null;
+}
+
+/** 本机 Loomy 综合探测 */
+export function detectLoomy() {
+  const file = credentialFile();
+  const cred = readCredential();
+  const clientPath = candidateClientPath();
+  return {
+    dataDir: path.dirname(file),
+    exists: fs.existsSync(file),
+    signedIn: Boolean(cred),
+    clientInstalled: Boolean(clientPath),
+    clientPath,
+    running: loomyRunning(),
+    credential: cred ? {
+      userid: cred.userid,
+      phone: cred.phone ? `${cred.phone.slice(0, 3)}****${cred.phone.slice(-4)}` : null,
+      updatedAt: cred.updatedAt,
+    } : null,
+  };
+}
+
+const nap = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+export function terminateLoomy({ timeoutMs = 8000 } = {}) {
+  if (process.platform !== 'win32') return { closed: false, supported: false };
+  if (!loomyRunning()) return { closed: false, running: false };
+  try { execFileSync('taskkill.exe', ['/IM', EXE_NAME, '/T'], { windowsHide: true, stdio: 'ignore', timeout: 15_000 }); } catch {}
+  let deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline && loomyRunning()) nap(250);
+  if (loomyRunning()) {
+    try { execFileSync('taskkill.exe', ['/IM', EXE_NAME, '/T', '/F'], { windowsHide: true, stdio: 'ignore', timeout: 15_000 }); } catch {}
+    deadline = Date.now() + 3000;
+    while (Date.now() < deadline && loomyRunning()) nap(250);
+  }
+  return { closed: !loomyRunning(), running: loomyRunning() };
+}
+
+/** 当前客户端登录的用户 ID（面板「客户端当前」徽章按 uid 比对——publicAccount 不下发 token，面板侧只能比 uid） */
+export function currentLoomyUid() {
+  try { return readCredential()?.userid || null; } catch { return null; }
+}
+
+/**
+ * 读取 Loomy 客户端当前登录，返回标准化账号对象（供 addAccount / 本机导入）。
+ */
+export async function liveToAccount() {
+  const cred = readCredential();
+  if (!cred) return null;
+  const phoneMasked = cred.phone ? `${cred.phone.slice(0, 3)}****${cred.phone.slice(-4)}` : null;
+  return {
+    provider: 'loomy',
+    token: cred.session,
+    refreshToken: null,
+    uid: cred.userid,
+    name: phoneMasked ? `Loomy (${phoneMasked})` : `Loomy (${cred.userid.slice(-6)})`,
+    expiresAt: null,
+    source: 'local-app',
+    meta: {
+      phone: cred.phone,
+      capturedAt: new Date().toISOString(),
+    },
+  };
+}
+
+const napAsync = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * 硬切换：客户端退出清理会把内存里的旧登录写回 auth-session.json（迟到写入者——
+ * 「客户端没跑就直接写」的温和路径实测会被它回写冲掉，表现为「切了没生效」）。
+ * 统一走：先杀客户端 → 写凭据 → 延时复核 → 发现被回写冲掉就再补写一次 → 报告是否落定。
+ * 客户端重新打开时 restore() 无校验直接应用文件里的 session，落定即换号成功。
+ * 注意：Loomy 客户端界面登录态真源在其渲染层 localStorage（启动时反向推给主进程），
+ * 本函数落定的是主进程/opencode 侧的凭据；界面换号仍需在客户端内退出重登。
+ */
+export async function hardSwitchLoomy(account) {
+  if (!account?.token) throw new Error('目标账号缺少 session token');
+  const cred = readCredential();
+  // 凭据文件缺失（未装过客户端 / 用户在客户端里退出登录把它清空）不该挡切换——
+  // 目标账号的 session/userid/phone 在账号库里齐全，直接写就是
+  const userid = account.uid || cred?.userid;
+  if (!userid) throw new Error('目标账号缺少 userid，无法写入 Loomy 凭据（请重新登录该账号后再切换）');
+  if (cred && account.token === cred.session) {
+    return { switched: false, alreadyActive: true, closedClient: false, verified: true };
+  }
+
+  const wasRunning = loomyRunning();
+  const t = terminateLoomy();
+  const closedClient = wasRunning && t.running === false;
+
+  const next = { session: account.token, userid, phone: account.meta?.phone || '' };
+  writeCredential(next);
+  await napAsync(1200);
+  let verified = readCredential()?.session === account.token;
+  if (!verified) {
+    writeCredential(next);
+    await napAsync(1200);
+    verified = readCredential()?.session === account.token;
+  }
+  return { switched: true, alreadyActive: false, closedClient, verified };
+}

package/src/minimaxGateway.js

@@ -54,6 +54,8 @@ const coolingStreak = new Map();
 const dead = new Map();     // accountId → 拉黑时的凭据指纹（指纹变化 = 已重新授权/刷新，自动复活）
 const weights = new Map();  // accountId → { w: 剩余积分权重, at: 查询时刻 }(查询失败时保留旧快照)
 const WEIGHT_TTL_MS = 10 * 60_000;  // 权重超过该时长重新查询额度,让用量变化能反映到分流上
+const WEIGHT_REFRESH_CAP_MS = 2_000;   // 请求路径等新权重的上限；超时先用旧快照，刷新转后台
+const weightInflight = new Map();      // accountId → 刷新中 Promise（并发请求共用一次查询）
 
 export const stats = {
   lastCallAt: null,
@@ -69,6 +71,15 @@ function credFingerprint(a) {
   return `${a.token || ''}|${a.refreshToken || ''}`;
 }
 
+/** 账号被删除时清掉它在各轮换 Map 里的残留（daemon DELETE /api/accounts/:id 调用） */
+export function forgetAccount(id) {
+  cooling.delete(id);
+  coolingStreak.delete(id);
+  dead.delete(id);
+  weights.delete(id);
+  if (stickyId === id) stickyId = null;
+}
+
 function markCooling(id, ms = ACCOUNT_COOLING_MS) {
   cooling.set(id, Date.now() + ms);
 }
@@ -121,6 +132,7 @@ export function __resetForTests() {
   coolingStreak.clear();
   dead.clear();
   weights.clear();
+  weightInflight.clear();
   stickyId = null;
   stats.lastCallAt = null;
   stats.calls = 0;
@@ -132,15 +144,40 @@ export function __resetForTests() {
 async function accountWeight(a) {
   const hit = weights.get(a.id);
   if (hit && Date.now() - hit.at < WEIGHT_TTL_MS) return hit.w;
-  let w = hit?.w ?? MIN_WEIGHT;
+  const fallback = hit?.w ?? MIN_WEIGHT;
+  // 请求路径只等一个很短的上限：额度接口健康时照常拿到新权重精准选主力；
+  // 上游黑洞时最多等这么久就先用旧快照——刷新仍在后台继续，下一个请求就有新值。
+  // 此前是完整等待额度查询且逐号串行，一个黑洞的上游能让权重过期后的
+  // 第一个补全请求卡 1-2 分钟（客户端还挂着已连接的 SSE 请求）
+  const refresh = weightRefresh(a);
+  let timer;
+  const capped = new Promise((r) => { timer = setTimeout(() => r(fallback), WEIGHT_REFRESH_CAP_MS); });
   try {
-    const q = await fetchMiniMaxQuota(a, refreshContext(a, (m) => logger.info("MINIMAX-GW", t('{label} {msg}', { label: a.name || a.uid || a.id, msg: m }))));
-    w = Math.max(MIN_WEIGHT, Number(q?.remaining) || 0);
-  } catch {
-    // 额度查询失败时保留上次快照权重：一次网络抖动不该把主力账号踢成保底权重、引发主力来回切换
+    return await Promise.race([refresh, capped]);
+  } finally {
+    clearTimeout(timer);
   }
-  weights.set(a.id, { w, at: Date.now() });
-  return w;
+}
+
+/** 去重后的权重刷新：并发请求共用同一次额度查询；查询失败保留旧快照权重（时间戳仍刷新，避免每请求都撞同一坏接口） */
+function weightRefresh(a) {
+  const existing = weightInflight.get(a.id);
+  if (existing) return existing;
+  const run = (async () => {
+    const hit = weights.get(a.id);
+    let w = hit?.w ?? MIN_WEIGHT;
+    try {
+      const q = await fetchMiniMaxQuota(a, refreshContext(a, (m) => logger.info("MINIMAX-GW", t('{label} {msg}', { label: a.name || a.uid || a.id, msg: m }))));
+      w = Math.max(MIN_WEIGHT, Number(q?.remaining) || 0);
+    } catch {
+      // 额度查询失败时保留上次快照权重：一次网络抖动不该把主力账号踢成保底权重、引发主力来回切换
+    }
+    weights.set(a.id, { w, at: Date.now() });
+    return w;
+  })();
+  weightInflight.set(a.id, run);
+  run.finally(() => { if (weightInflight.get(a.id) === run) weightInflight.delete(a.id); }).catch(() => {});
+  return run;
 }
 
 // ── 粘性主力选型 ──
@@ -158,13 +195,16 @@ const STICKY_MARGIN_ABS = 50;    // 且绝对差超过 50 积分
 async function rotationQueue() {
   const all = (await loadAccounts()).filter((a) => a.provider === 'minimax');
   const now = Date.now();
-  const ready = [];
+  const candidates = [];
   for (const a of all) {
     if (isDead(a)) continue;
     if ((cooling.get(a.id) || 0) > now) continue;
     if (!a.token) continue;
-    ready.push({ account: a, weight: await accountWeight(a) });
+    candidates.push(a);
   }
+  // 权重并行取（各自 2s 封顶），不再逐号串行等
+  const ws = await Promise.all(candidates.map((a) => accountWeight(a)));
+  const ready = candidates.map((a, i) => ({ account: a, weight: ws[i] }));
   if (!ready.length) return [];
 
   ready.sort((x, y) => y.weight - x.weight);
@@ -296,6 +336,8 @@ export async function handleGateway(req, res) {
   const attempted = [];
   const clientAbort = new AbortController();
   req.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
+  // 优雅断开（客户端 fetch abort 在上游响应前）只触发 res 'close'，不触发 req 'close'
+  res.once('close', () => { if (!res.writableEnded) clientAbort.abort(); });
 
   for (let i = 0; i < Math.min(MAX_ATTEMPTS, queue.length); i++) {
     const account = queue[i];
@@ -376,8 +418,16 @@ export async function handleGateway(req, res) {
             }
           }
         } catch (e) {
-          // 客户端主动断开（点停止/换一句）属正常收尾，不是故障
-          logger.debug('MINIMAX-GW', '流式转发中断:{err}', { err: e.message });
+          if (clientAbort.signal.aborted) {
+            // 客户端主动断开（点停止/换一句）属正常收尾，不是故障
+            logger.debug('MINIMAX-GW', '流式转发中断:{err}', { err: e.message });
+          } else {
+            // 上游中途断了：补一帧 Anthropic error 事件再收尾，别让客户端只见裸 EOF
+            logger.warn('MINIMAX-GW', '上游流中断:{err}', { err: e.message });
+            try {
+              res.write(`event: error\ndata: ${JSON.stringify({ type: 'error', error: { type: 'api_error', message: `上游流中断：${e.message}` } })}\n\n`);
+            } catch { /* 客户端已不在 */ }
+          }
         }
         res.end();
       } else {