creditdaddy 1.2.0 → 1.3.2

package/src/zcodeAutoClaim.js

@@ -1,97 +1,97 @@
-/**
- * ZCode 活动自动领取 — 签到调度器每轮调用。
- *
- * 策略（对齐用户手动路径，逐级尝试）：
- *   1. billing/preview 查可领活动；为空 → 无事可做（返回 null，不留痕迹）
- *   2. 先直接 claim（不带验证码：服务端未风控时可直接成功）
- *   3. 返回 3007/3001（需要验证码 / 参数被拒）且有验证码提供者 → 拉 captcha 配置，
- *      让提供者（桌面版的隐藏窗口跑阿里云验证码 SDK 静默验证）拿 captchaVerifyParam 后重试
- *   4. 没有提供者（NAS / 纯 CLI）或验证码需要人工 → 标记「需手动领取」，卡片上提示
- *   - 1003（已领取过）按成功口径处理并记忆
- * 结果写入账号 lastResult（签到日历记忆用的是 status checked-in/already，第二天照常重查 preview）
- */
-
-import { logger } from './logger.js';
-import { fetchClaimPlans, claimPlan, fetchCaptchaConfig } from './zcodeClient.js';
-
-// 桌面版（Electron 主进程）注册的隐藏窗口验证码实现；NAS / CLI 为 null（走「需手动领取」分支）
-let captchaProvider = null;
-export function setZcodeCaptchaProvider(fn) { captchaProvider = typeof fn === 'function' ? fn : null; }
-export function hasZcodeCaptchaProvider() { return Boolean(captchaProvider); }
-export function getZcodeCaptchaProvider() { return captchaProvider; }
-
-const grantsText = (plan) => (plan.grants && plan.grants.length ? plan.grants.join('；') : '');
-
-/**
- * 为单个 ZCode 账号执行一次自动领取。
- * @returns {null | { status, message, claims: Array }} null = preview 为空或查询失败（已记日志，不上卡片）
- */
-export async function zcodeAutoClaim(account) {
-  const label = account.name || account.uid || account.id;
-  let plans;
-  try {
-    plans = (await fetchClaimPlans(account)).plans;
-  } catch (e) {
-    logger.debug('ZCODE-CLAIM', `${label} 活动查询失败：${e.message}`);
-    return null;
-  }
-  if (!plans.length) return null;
-
-  const claims = [];
-  let anySuccess = false;
-  let needManual = false;
-
-  for (const plan of plans) {
-    const planName = plan.name || plan.planId;
-    // 第 2 步：先试不带验证码
-    try {
-      const r = await claimPlan(account, plan.planId, {});
-      claims.push({ plan: planName, via: 'direct', ok: true });
-      anySuccess = true;
-      logger.info('ZCODE-CLAIM', `${label} 已领取「${planName}」（免验证码）${grantsText(plan) ? '：' + grantsText(plan) : ''}`);
-      continue;
-    } catch (e) {
-      if (e.code === 1003) {
-        claims.push({ plan: planName, ok: true, already: true });
-        logger.info('ZCODE-CLAIM', `${label}「${planName}」已领取过`);
-        continue;
-      }
-      if (e.code !== 3007 && e.code !== 3001) {
-        claims.push({ plan: planName, ok: false, message: e.message });
-        logger.warn('ZCODE-CLAIM', `${label} 领取「${planName}」失败：${e.message}`);
-        continue;
-      }
-    }
-    // 第 3 步：需要验证码
-    if (!captchaProvider) {
-      needManual = true;
-      claims.push({ plan: planName, ok: false, needManual: true });
-      logger.info('ZCODE-CLAIM', `${label}「${planName}」需要验证码，本环境无法自动通过，请在面板手动领取`);
-      continue;
-    }
-    try {
-      const cfg = await fetchCaptchaConfig();
-      if (!cfg.enabled || !cfg.sceneId) throw new Error('验证码配置不可用');
-      const { captchaParam, region } = await captchaProvider(cfg);
-      await claimPlan(account, plan.planId, { captchaParam, region });
-      claims.push({ plan: planName, via: 'captcha', ok: true });
-      anySuccess = true;
-      logger.info('ZCODE-CLAIM', `${label} 已领取「${planName}」（静默验证码）${grantsText(plan) ? '：' + grantsText(plan) : ''}`);
-    } catch (e2) {
-      needManual = true;
-      claims.push({ plan: planName, ok: false, needManual: true, message: e2.message });
-      logger.warn('ZCODE-CLAIM', `${label}「${planName}」验证码未完成：${e2.message}（可在面板手动领取）`);
-    }
-  }
-
-  const names = claims.filter((c) => c.ok && !c.already).map((c) => c.plan);
-  const status = names.length ? 'checked-in'
-    : claims.every((c) => c.already) ? 'already'
-    : 'failed';
-  const message = status === 'checked-in'
-    ? `已领取：${names.join('、')}${claims.some((c) => c.via === 'captcha') ? '（静默验证码）' : ''}`
-    : status === 'already' ? '活动均已领取过'
-    : needManual ? `有 ${claims.filter((c) => c.needManual).length} 个活动需要验证码，请在面板手动领取`
-    : `领取失败：${claims.filter((c) => !c.ok).map((c) => c.message).filter(Boolean)[0] || '未知错误'}`;
-  return { status, message, claims };
-}
+/**
+ * ZCode 活动自动领取 — 签到调度器每轮调用。
+ *
+ * 策略（对齐用户手动路径，逐级尝试）：
+ *   1. billing/preview 查可领活动；为空 → 无事可做（返回 null，不留痕迹）
+ *   2. 先直接 claim（不带验证码：服务端未风控时可直接成功）
+ *   3. 返回 3007/3001（需要验证码 / 参数被拒）且有验证码提供者 → 拉 captcha 配置，
+ *      让提供者（桌面版的隐藏窗口跑阿里云验证码 SDK 静默验证）拿 captchaVerifyParam 后重试
+ *   4. 没有提供者（NAS / 纯 CLI）或验证码需要人工 → 标记「需手动领取」，卡片上提示
+ *   - 1003（已领取过）按成功口径处理并记忆
+ * 结果写入账号 lastResult（签到日历记忆用的是 status checked-in/already，第二天照常重查 preview）
+ */
+
+import { logger } from './logger.js';
+import { fetchClaimPlans, claimPlan, fetchCaptchaConfig } from './zcodeClient.js';
+
+// 桌面版（Electron 主进程）注册的隐藏窗口验证码实现；NAS / CLI 为 null（走「需手动领取」分支）
+let captchaProvider = null;
+export function setZcodeCaptchaProvider(fn) { captchaProvider = typeof fn === 'function' ? fn : null; }
+export function hasZcodeCaptchaProvider() { return Boolean(captchaProvider); }
+export function getZcodeCaptchaProvider() { return captchaProvider; }
+
+const grantsText = (plan) => (plan.grants && plan.grants.length ? plan.grants.join('；') : '');
+
+/**
+ * 为单个 ZCode 账号执行一次自动领取。
+ * @returns {null | { status, message, claims: Array }} null = preview 为空或查询失败（已记日志，不上卡片）
+ */
+export async function zcodeAutoClaim(account) {
+  const label = account.name || account.uid || account.id;
+  let plans;
+  try {
+    plans = (await fetchClaimPlans(account)).plans;
+  } catch (e) {
+    logger.debug('ZCODE-CLAIM', `${label} 活动查询失败：${e.message}`);
+    return null;
+  }
+  if (!plans.length) return null;
+
+  const claims = [];
+  let anySuccess = false;
+  let needManual = false;
+
+  for (const plan of plans) {
+    const planName = plan.name || plan.planId;
+    // 第 2 步：先试不带验证码
+    try {
+      const r = await claimPlan(account, plan.planId, {});
+      claims.push({ plan: planName, via: 'direct', ok: true });
+      anySuccess = true;
+      logger.info('ZCODE-CLAIM', `${label} 已领取「${planName}」（免验证码）${grantsText(plan) ? '：' + grantsText(plan) : ''}`);
+      continue;
+    } catch (e) {
+      if (e.code === 1003) {
+        claims.push({ plan: planName, ok: true, already: true });
+        logger.info('ZCODE-CLAIM', `${label}「${planName}」已领取过`);
+        continue;
+      }
+      if (e.code !== 3007 && e.code !== 3001) {
+        claims.push({ plan: planName, ok: false, message: e.message });
+        logger.warn('ZCODE-CLAIM', `${label} 领取「${planName}」失败：${e.message}`);
+        continue;
+      }
+    }
+    // 第 3 步：需要验证码
+    if (!captchaProvider) {
+      needManual = true;
+      claims.push({ plan: planName, ok: false, needManual: true });
+      logger.info('ZCODE-CLAIM', `${label}「${planName}」需要验证码，本环境无法自动通过，请在面板手动领取`);
+      continue;
+    }
+    try {
+      const cfg = await fetchCaptchaConfig();
+      if (!cfg.enabled || !cfg.sceneId) throw new Error('验证码配置不可用');
+      const { captchaParam, region } = await captchaProvider(cfg);
+      await claimPlan(account, plan.planId, { captchaParam, region });
+      claims.push({ plan: planName, via: 'captcha', ok: true });
+      anySuccess = true;
+      logger.info('ZCODE-CLAIM', `${label} 已领取「${planName}」（静默验证码）${grantsText(plan) ? '：' + grantsText(plan) : ''}`);
+    } catch (e2) {
+      needManual = true;
+      claims.push({ plan: planName, ok: false, needManual: true, message: e2.message });
+      logger.warn('ZCODE-CLAIM', `${label}「${planName}」验证码未完成：${e2.message}（可在面板手动领取）`);
+    }
+  }
+
+  const names = claims.filter((c) => c.ok && !c.already).map((c) => c.plan);
+  const status = names.length ? 'checked-in'
+    : claims.every((c) => c.already) ? 'already'
+    : 'failed';
+  const message = status === 'checked-in'
+    ? `已领取：${names.join('、')}${claims.some((c) => c.via === 'captcha') ? '（静默验证码）' : ''}`
+    : status === 'already' ? '活动均已领取过'
+    : needManual ? `有 ${claims.filter((c) => c.needManual).length} 个活动需要验证码，请在面板手动领取`
+    : `领取失败：${claims.filter((c) => !c.ok).map((c) => c.message).filter(Boolean)[0] || '未知错误'}`;
+  return { status, message, claims };
+}

package/src/zcodeClient.js

@@ -205,7 +205,7 @@ function connectTunnel(proxyUrl, target) {
   });
 }
 
-async function fetchViaProxy(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000 } = {}) {
+async function fetchViaProxy(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000, signal = null } = {}) {
   const proxy = effectiveProxy();
   if (!proxy || !/^http:\/\//i.test(proxy)) throw new Error('没有可用的 http 代理（面板配置或 HTTPS_PROXY 环境变量）');
   const u = new URL(url);
@@ -227,12 +227,22 @@ async function fetchViaProxy(url, { method = 'GET', headers = {}, body = null, t
     };
   }
   return new Promise((resolve, reject) => {
+    // request 的 timeout 是「无活动」超时：对端每 14 秒吐一个字节就能一直吊着请求不放。
+    // 这里再补一个整条请求的墙钟上限，并接上外部 abort（客户端断开 / 上层取消）。
+    const deadline = setTimeout(() => req.destroy(new Error('请求超时')), timeoutMs);
+    const onAbort = () => req.destroy(Object.assign(new Error('请求已取消'), { name: 'AbortError' }));
+    if (signal) {
+      if (signal.aborted) { clearTimeout(deadline); reject(signal.reason || new Error('请求已取消')); return; }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+    const done = (fn, arg) => { clearTimeout(deadline); signal?.removeEventListener('abort', onAbort); fn(arg); };
     const req = (isHttps ? https : http).request(requestOpts, (res) => {
       const chunks = [];
       res.on('data', (c) => chunks.push(c));
-      res.on('end', () => resolve(new Response(Buffer.concat(chunks), { status: res.statusCode, headers: res.headers })));
+      res.on('end', () => done(resolve, new Response(Buffer.concat(chunks), { status: res.statusCode, headers: res.headers })));
+      res.on('error', (e) => done(reject, e));
     });
-    req.on('error', reject);
+    req.on('error', (e) => done(reject, e));
     req.on('timeout', () => req.destroy(new Error('请求超时')));
     if (body != null) req.write(typeof body === 'string' ? body : JSON.stringify(body));
     req.end();
@@ -249,19 +259,67 @@ async function fetchViaProxy(url, { method = 'GET', headers = {}, body = null, t
 let viaProxyImpl = null;
 export function _setViaProxyForTests(fn) { viaProxyImpl = fn || null; }
 
-export async function fetchJsonRace(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000, signal = null } = {}) {
-  const timeoutSignal = AbortSignal.timeout(timeoutMs);
-  const abortSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
-  const base = { method, headers: { ...headers }, ...(body != null ? { body: typeof body === 'string' ? body : JSON.stringify(body) } : {}), signal: abortSignal };
+/**
+ * 组合多个 AbortSignal 成一个：任一源触发即 abort。
+ * 与 AbortSignal.any 的区别——这里返回 { signal, releaseConnect }，releaseConnect()
+ * 可摘掉 connectSignal 的转发监听：两段式超时里，响应头到达后连接段限时就该失效，
+ * 但整墙钟（wallSignal）和外部取消（external）要继续管住流式 body。
+ */
+function combineSignals({ wallSignal, connectSignal, external }) {
+  const ctrl = new AbortController();
+  const onWall = () => ctrl.abort(wallSignal.reason);
+  const onConnect = () => ctrl.abort(connectSignal.reason);
+  const onExternal = () => ctrl.abort(external.reason);
+  if (wallSignal.aborted) ctrl.abort(wallSignal.reason);
+  else wallSignal.addEventListener('abort', onWall, { once: true });
+  if (connectSignal && !ctrl.signal.aborted) {
+    if (connectSignal.aborted) ctrl.abort(connectSignal.reason);
+    else connectSignal.addEventListener('abort', onConnect, { once: true });
+  }
+  if (external && !ctrl.signal.aborted) {
+    if (external.aborted) ctrl.abort(external.reason);
+    else external.addEventListener('abort', onExternal, { once: true });
+  }
+  // 连接段成功后调用：只摘掉 connectSignal 的转发，墙钟与外部取消继续管住 body 流
+  const releaseConnect = () => { connectSignal?.removeEventListener('abort', onConnect); };
+  return { signal: ctrl.signal, releaseConnect };
+}
+
+/**
+ * 直连 / 代理兜底的 fetch。可选 connectMs 启用两段式超时：
+ *   - 拿到响应头前（DNS/TCP/TLS/首字节）限时 connectMs——上游黑洞挂死时几秒内
+ *     就失败换下一条路，而不是吊满整个 timeoutMs（网关补全场景尤其重要）；
+ *   - 拿到响应头后解除连接段限时，只保留 timeoutMs 整墙钟——流式补全可能合法地
+ *     跑几分钟，不能因为「连接快、生成慢」被误杀。
+ * 不传 connectMs 时退回单段 timeoutMs（旧行为，所有既有调用方不受影响）。
+ */
+export async function fetchJsonRace(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000, connectMs = null, signal = null } = {}) {
   const useProxy = Boolean(effectiveProxy()) && !proxyBypass(url);
-  const direct = () => fetch(url, base);
-  const viaProxy = viaProxyImpl
-    ? () => viaProxyImpl(url, { method, headers, body, timeoutMs })
-    : () => fetchViaProxy(url, { method, headers, body, timeoutMs });
-  const attempts = useProxy ? (proxyFirst() ? [viaProxy, direct] : [direct, viaProxy]) : [direct];
+  const twoPhase = Number.isFinite(connectMs) && connectMs > 0 && connectMs < timeoutMs;
+  // 超时信号必须每次尝试各建一个：共用一个的话，代理优先模式下第一条路吃完 timeoutMs，
+  // 兜底那条就对着已触发的 signal 发请求，必定瞬间失败——「代理优先」就此形同虚设
+  const makeAttempt = () => {
+    const wallSignal = AbortSignal.timeout(timeoutMs);
+    const connectSignal = twoPhase ? AbortSignal.timeout(connectMs) : null;
+    const { signal: abortSignal, releaseConnect } = combineSignals({ wallSignal, connectSignal, external: signal });
+    const base = { method, headers: { ...headers }, ...(body != null ? { body: typeof body === 'string' ? body : JSON.stringify(body) } : {}), signal: abortSignal };
+    return {
+      // 响应头到达 = 连接段成功：摘掉 connectSignal 转发，此后只有墙钟/外部取消能中断流
+      direct: async () => { const r = await fetch(url, base); releaseConnect(); return r; },
+      viaProxy: async () => {
+        const r = viaProxyImpl
+          ? await viaProxyImpl(url, { method, headers, body, timeoutMs, signal: abortSignal })
+          : await fetchViaProxy(url, { method, headers, body, timeoutMs, signal: abortSignal });
+        releaseConnect();
+        return r;
+      },
+    };
+  };
+  const order = useProxy ? (proxyFirst() ? ['viaProxy', 'direct'] : ['direct', 'viaProxy']) : ['direct'];
   let lastErr = null;
-  for (const attempt of attempts) {
-    try { return await attempt(); } catch (e) { lastErr = e; }
+  for (const which of order) {
+    const attempts = makeAttempt();
+    try { return await attempts[which](); } catch (e) { lastErr = e; }
   }
   throw lastErr || new Error('fetch failed');
 }
@@ -305,7 +363,11 @@ async function bigmodelHeaders(token) {
 async function getJson(url, headers) {
   const res = await fetchJsonRace(url, { headers, timeoutMs: FETCH_TIMEOUT_MS });
   const text = await res.text();
-  try { return JSON.parse(text); } catch { return { code: res.status, msg: text.slice(0, 120) }; }
+  try { return JSON.parse(text); } catch {
+    // 解析失败（含 HTTP 200 + 空 body，服务端偶发对无效 token 就是这样）绝不能伪装成 code:200，
+    // 否则 businessOk 会放行并让额度链提前返回“无套餐”，短路后面的 balance 尝试
+    return { code: res.ok ? -1 : res.status, msg: (text || `empty response (HTTP ${res.status})`).slice(0, 120) };
+  }
 }
 
 const businessOk = (v) => {
@@ -480,6 +542,12 @@ export function normalizePlans(previewResp) {
   return out;
 }
 
+/** “当前用户不存在coding plan / 没有资格”属于无套餐的业务口径，不是查询失败（同 zcode-switch is_no_plan_message） */
+function isNoPlanMessage(msg) {
+  const m = String(msg || '');
+  return m.includes('不存在coding plan') || m.includes('没有资格') || /no.*coding.*plan/i.test(m);
+}
+
 /**
  * 额度查询：先试 BigModel Coding Plan（quota/limit），再试 Z.ai / Start Plan（billing/balance）。
  * 都没有有效套餐时返回 { empty: true }（不是错误：很多账号只用免费额度）。
@@ -488,28 +556,35 @@ export async function fetchZcodeQuota(account) {
   const tokens = candidateTokens(account);
   if (!tokens.length) throw new Error('账号快照里没有可用 token，请在 ZCode 登录后重新导入');
   let lastErr = null;
+  let sawNoPlan = false;
   let authFails = 0;
   for (const t of tokens) {
     try {
       const limit = await getJson(QUOTA_LIMIT_URL, await bigmodelHeaders(t));
       if (businessOk(limit)) {
         const sub = await getJson(SUBSCRIPTION_URL, await bigmodelHeaders(t)).catch(() => null);
-        return { ...normalizeQuotaLimit(limit, sub), source: 'bigmodel' };
+        const ov = normalizeQuotaLimit(limit, sub);
+        // BigModel 侧“有效响应但零额度项”不代表账号没额度（Start Plan 账号走 balance 有额度），
+        // 不能提前返回 empty，必须继续把 balance 链路试完——与 zcode-switch 每 token 双端点连查一致
+        if (!ov.empty) return { ...ov, source: 'bigmodel' };
       }
       if (limit?.code === 401) authFails++;
+      else if (isNoPlanMessage(limit?.msg)) sawNoPlan = true;
       else lastErr = limit?.msg || lastErr;
     } catch (e) { lastErr = e.message; }
   }
   for (const t of billingTokens(account)) {
     try {
       const bal = await getJson(`${BILLING_BALANCE_URL}?app_version=${await zcodeAppVersion()}`, await zaiHeaders(t, ensureVirtualDeviceMid(account)));
+      // balance 是账号级总余额端点，有效答复（含“确无套餐”）即可采信；
+      // 与 bigmodel 侧不同——那里“有效但零额度项”不代表账号没额度，必须继续往下试
       if (businessOk(bal)) return { ...normalizeBalance(bal), source: 'zcode.z.ai' };
       if (bal?.code === 401) authFails++;
     } catch (e) { lastErr = e.message; }
   }
   if (authFails && authFails >= tokens.length) throw new Error('鉴权失败，登录可能已过期，请在 ZCode 重新登录后重新导入');
-  // “当前用户不存在coding plan”之类属于无套餐，按空额度返回
-  if (!lastErr || /不存在|no.*plan/i.test(lastErr)) {
+  // 无套餐口径：显式的“不存在coding plan”或整条链没有任何错误
+  if (!lastErr || sawNoPlan) {
     return { total: 0, used: 0, remaining: 0, unit: '', plan: null, parts: [], empty: true, exceeded: false };
   }
   throw new Error(`额度查询失败：${lastErr}`);