creditdaddy 0.8.1 → 0.9.2

package/src/providers.js

@@ -10,7 +10,7 @@
 
 import { productOf } from './constants.js';
 import { checkinOne as checkinQoder, fetchQuotaUsage, fetchUserinfo } from './qoderClient.js';
-import { checkinWorkbuddy, fetchWorkbuddyQuota, inspectToken } from './workbuddyClient.js';
+import { checkinWorkbuddy, checkinWorkbuddyIntl, fetchWorkbuddyQuota, inspectToken } from './workbuddyClient.js';
 import { fetchZcodeQuota } from './zcodeClient.js';
 
 /** 从 userinfo 响应中挑一个可读的显示名 */
@@ -51,7 +51,8 @@ const PRODUCTS = {
   },
   workbuddy: {
     label: 'WorkBuddy',
-    checkin: (account, ctx) => checkinWorkbuddy(account, ctx),
+    // 国内版走 billing daily-checkin 签到；国际版没有签到接口，走「活跃领取」（免费档对话探测）
+    checkin: (account, ctx) => (account.provider === 'workbuddy-intl' ? checkinWorkbuddyIntl(account, ctx) : checkinWorkbuddy(account, ctx)),
     quota: (account, ctx) => fetchWorkbuddyQuota(account, ctx),
     verify: async (account) => {
       const info = inspectToken(account.token);

package/src/store.js

@@ -44,14 +44,39 @@ async function ensureDir() {
   await fs.mkdir(dataDir(), { recursive: true, mode: 0o700 });
 }
 
-/** 原子写：临时文件 + rename，失败不留半截文件 */
-export async function atomicWrite(file, content) {
+// Windows 上 rename 覆盖已有文件时，外部程序（杀软扫描、同步盘、另一守护进程）瞬时占用
+// 会直接抛 EPERM/EBUSY/EACCES：先按递增间隔重试，仍失败则兜底直写目标（牺牲原子性换可用性）。
+const RENAME_TRANSIENT = new Set(['EPERM', 'EBUSY', 'EACCES']);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+let renameImpl = null;
+export function _setRenameForTests(fn) { renameImpl = fn || null; }
+
+/** 原子写：临时文件 + rename（带故障重试与直写兜底） */
+export async function atomicWrite(file, content, { retries = 6 } = {}) {
   const tmp = path.join(
     path.dirname(file),
     `.tmp-${path.basename(file)}-${crypto.randomBytes(4).toString('hex')}`
   );
   await fs.writeFile(tmp, content, { mode: 0o600 });
-  await fs.rename(tmp, file);
+  const doRename = renameImpl || ((a, b) => fs.rename(a, b));
+  let transientRetries = 0;
+  try {
+    for (let i = 0; i <= retries; i++) {
+      try { await doRename(tmp, file); return; } catch (e) {
+        if (!RENAME_TRANSIENT.has(e?.code)) throw e;   // 非占用类错误立即走兜底（如 EXDEV）
+        transientRetries++;
+        if (i < retries) await sleep(120 * (i + 1));
+      }
+    }
+  } catch { /* 落入兜底 */ }
+  // 兜底：读回临时文件直接覆盖写目标，并清理临时文件（避免 .tmp-* 残留）
+  try {
+    const data = await fs.readFile(tmp, 'utf8');
+    await fs.writeFile(file, data, { mode: 0o600 });
+  } finally {
+    await fs.unlink(tmp).catch(() => {});
+  }
 }
 
 async function readJson(file, fallback) {

package/src/workbuddyClient.js

@@ -91,6 +91,51 @@ async function post(account, path, token) {
   return { status: res.status, body, text };
 }
 
+// 国际版「活跃领取」探测：官方规则为「当天有 ≥1 次有效对话请求即视为活跃用户，发放每日赠送积分」。
+// 没有签到接口，所以每天发一条免费档模型（rateMultiplier 0，~0 消耗）的极短流式请求。
+// 对齐 10router src/sse/services/codebuddyCheckin.js 的 intl 探测（stream 网关的系统提示与 typed blocks 是必需的，否则 11101）。
+const INTL_PROBE_MODEL = 'hy4-preview';
+async function postIntlProbe(account, token) {
+  const res = await fetch(`https://${apiHost(account)}/v2/chat/completions`, {
+    method: 'POST',
+    headers: { ...headersFor(account, token), 'Content-Type': 'application/json', Accept: 'text/event-stream' },
+    body: JSON.stringify({
+      model: INTL_PROBE_MODEL,
+      stream: true,
+      max_tokens: 16,
+      messages: [
+        { role: 'system', content: 'You are CodeBuddy Code.' },
+        { role: 'user', content: [{ type: 'text', text: 'hi' }] },
+      ],
+    }),
+    signal: AbortSignal.timeout(Math.max(FETCH_TIMEOUT_MS, 25_000)),
+  });
+  // 2xx = 会话建立成功，把 SSE 流排干（最多几个 token）
+  const text = await res.text().catch(() => '');
+  return { status: res.status, text };
+}
+
+/**
+ * 国际版「活跃领取」：一次免费档对话请求使账号成为当日活跃用户。
+ * 返回与每日签到一致的结果对象（session-ok → checked-in，claimedAmount 0 表示额度随官方结算发放）。
+ */
+export async function checkinWorkbuddyIntl(account, { onRefresh } = {}) {
+  const label = account.name || account.id;
+  const base = { accountId: account.id, account: label, provider: account.provider };
+  try {
+    const r = await withToken(account, (t) => postIntlProbe(account, t), onRefresh);
+    if (r.status === 401) return { ...base, status: 'failed', error: '鉴权失败（401），token 已失效，请在客户端重新登录后重新导入' };
+    if (r.status === 429) return { ...base, status: 'no-activity', message: '今日额度已耗尽，活跃请求暂不可达（等官方发放后再试）', claimedAmount: 0 };
+    if (r.status >= 200 && r.status < 300) {
+      return { ...base, uid: account.uid, status: 'checked-in', claimedAmount: 0, message: '已发送活跃请求（保持活跃，活跃不等于必有奖励）' };
+    }
+    const m = (() => { try { return JSON.parse(r.text)?.error?.data?.msg || ''; } catch { return ''; } })();
+    return { ...base, status: 'failed', error: `活跃请求失败：HTTP ${r.status} ${m || r.text.slice(0, 120)}`.trim() };
+  } catch (e) {
+    return { ...base, status: 'failed', error: e?.message || '网络错误' };
+  }
+}
+
 export function isExpired(account, now = Date.now()) {
   const exp = account.expiresAt || inspectToken(account.token).expiresAt;
   return Boolean(exp) && new Date(exp).getTime() - EXPIRY_SKEW_MS <= now;

package/src/zcodeAutoClaim.js

@@ -0,0 +1,96 @@
+/**
+ * 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); }
+
+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

@@ -59,26 +59,46 @@ export function zcodeAppVersion() {
 export function _resetAppVersionCache(v) { appVersionCache = v || null; }
 
 // ── HTTP 出口：直连优先 / 代理优先（可切换），任一路成功即返回 ──
+// 代理地址：优先用面板里保存的 proxyUrl（zcode-net.json，0600），没有则退回 HTTPS_PROXY 环境变量
 
 function codeHome() {
   return process.env.CREDITDADDY_HOME || process.env.QODERDADDY_HOME || path.join(os.homedir(), '.creditdaddy');
 }
 const NET_PREFS_FILE = () => path.join(codeHome(), 'zcode-net.json');
 
-let proxyFirstCache = null;
-export function proxyFirst() {
-  if (proxyFirstCache !== null) return proxyFirstCache;
-  try { proxyFirstCache = JSON.parse(fs.readFileSync(NET_PREFS_FILE(), 'utf8')).proxyFirst === true; }
-  catch { proxyFirstCache = false; }
-  return proxyFirstCache;
+let netPrefCache = null;
+function netPref() {
+  if (netPrefCache) return netPrefCache;
+  try {
+    const j = JSON.parse(fs.readFileSync(NET_PREFS_FILE(), 'utf8'));
+    netPrefCache = {
+      proxyFirst: j.proxyFirst === true,
+      proxyUrl: typeof j.proxyUrl === 'string' && j.proxyUrl.trim() ? j.proxyUrl.trim() : null,
+      autoClaim: j.autoClaim === true,
+    };
+  } catch { netPrefCache = { proxyFirst: false, proxyUrl: null, autoClaim: false }; }
+  return netPrefCache;
 }
-export function setProxyFirst(v) {
-  proxyFirstCache = v === true;
+function writeNetPref(p) {
+  netPrefCache = p;
   fs.mkdirSync(codeHome(), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(NET_PREFS_FILE(), JSON.stringify({ proxyFirst: proxyFirstCache }, null, 2), { mode: 0o600 });
+  fs.writeFileSync(NET_PREFS_FILE(), JSON.stringify({ proxyFirst: p.proxyFirst, proxyUrl: p.proxyUrl, autoClaim: p.autoClaim }, null, 2), { mode: 0o600 });
+}
+export function proxyFirst() { return netPref().proxyFirst; }
+export function proxyUrl() { return netPref().proxyUrl; }
+/** 活动自动轮询领取开关（默认关：活动期前再开，平时不轮询） */
+export function autoClaimEnabled() { return netPref().autoClaim; }
+export function setAutoClaimEnabled(v) { writeNetPref({ ...netPref(), autoClaim: v === true }); }
+export function setProxyFirst(v) { writeNetPref({ ...netPref(), proxyFirst: v === true }); }
+export function setProxyUrl(u) {
+  const t = typeof u === 'string' ? u.trim() : '';
+  if (t && !/^http:\/\/\S+/i.test(t)) throw new Error('目前只支持 http:// 代理地址');
+  writeNetPref({ ...netPref(), proxyUrl: t || null });
 }
 
 const envProxy = () => process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy || null;
+/** 生效代理：面板保存的优先，其次环境变量 */
+const effectiveProxy = () => proxyUrl() || envProxy();
 
 /** 目标是否应绕过代理（loopback / NO_PROXY 后缀匹配） */
 function proxyBypass(url) {
@@ -118,8 +138,8 @@ function connectTunnel(proxyUrl, target) {
 }
 
 async function fetchViaProxy(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000 } = {}) {
-  const proxy = envProxy();
-  if (!proxy || !/^http:\/\//i.test(proxy)) throw new Error('没有可用的 http 代理（HTTPS_PROXY 未设置）');
+  const proxy = effectiveProxy();
+  if (!proxy || !/^http:\/\//i.test(proxy)) throw new Error('没有可用的 http 代理（面板配置或 HTTPS_PROXY 环境变量）');
   const u = new URL(url);
   const p = new URL(proxy);
   const isHttps = u.protocol === 'https:';
@@ -163,7 +183,7 @@ export function _setViaProxyForTests(fn) { viaProxyImpl = fn || null; }
 
 export async function fetchJsonRace(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000 } = {}) {
   const base = { method, headers: { ...headers }, ...(body != null ? { body: typeof body === 'string' ? body : JSON.stringify(body) } : {}), signal: AbortSignal.timeout(timeoutMs) };
-  const useProxy = Boolean(envProxy()) && !proxyBypass(url);
+  const useProxy = Boolean(effectiveProxy()) && !proxyBypass(url);
   const direct = () => fetch(url, base);
   const viaProxy = viaProxyImpl
     ? () => viaProxyImpl(url, { method, headers, body, timeoutMs })