mslxdff 0.1.227 → 0.1.229

package/src/routes/peer-serial.js

@@ -45,7 +45,7 @@ export function warmPeer(peer, deps = {}) {
 export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried, deps }) {
   const {
     resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
-    perAttemptCap, deadline, budgetMs,
+    perAttemptCap, deadline, budgetMs, probePeer,
   } = deps;
   const warm = deps.warmPeer || warmPeer;
   const failed = [];
@@ -71,22 +71,51 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
   const ipv4Chain = filterSlow(fresh(candidates));
   const ipv6Chain = filterSlow(fresh(v6Candidates));
 
-  // —— 预取：进循环前就把「下一个」定好，并顺手预热连接 ——
+  // —— 预取 + 探针（用户 2026-10-20 口径）——
+  // 「某个节点当备选的时候打一个 hi，准备轮到它了也打一个 hi；hi 都回不来就当它不行，直接换。」
+  // 两个 hi 都打，不做结果复用：备选是上一次切换时定的，中间可能已过了几十秒
+  // （上一个节点在大 body 上撞墙，实测 1.5MB 要 28~62s），那时活不代表现在活。
+  // 备选那个 hi 的作用是暖连接 + 提前暴露死节点，轮到时的那个才决定去留。
   let pending = null;
-  const prime = (peer) => {
+  // resolvePeerTarget 会打 /v1/models/status，别为探针白测两次：这里记住解析结果给下一轮复用。
+  const resolved = new Map(); // url -> Promise<{peer,target}|null>
+  const resolveOnce = (peer) => {
+    const hit = resolved.get(peer.url);
+    if (hit) return hit;
+    const p = Promise.resolve()
+      .then(() => resolvePeerTarget(ctx, peer))
+      .catch(() => null);
+    resolved.set(peer.url, p);
+    return p;
+  };
+  const prime = (peer, target) => {
+    if (!peer || !target || typeof probePeer !== "function") return;
+    try {
+      const p = probePeer(peer, target);
+      if (p && typeof p.then === "function") p.catch(() => {});
+    } catch { /* 预热失败不影响主流程 */ }
+  };
+  const primeAt = (peer) => {
     if (!peer) return;
-    warm(peer, deps.warmPeerDeps);
+    resolveOnce(peer)
+      .then((r) => { if (r) prime(r.peer, r.target); })
+      .catch(() => {});
   };
   const takeNext = (stage) => {
     const chain = stage === "ipv6" ? ipv6Chain : ipv4Chain;
     const p = chain.shift() || null;
-    if (p) prime(chain[0] || null); // 立即预热「再下一个」，保证永远有备选就绪
+    // 立刻给「再下一个」打 hi。模型名要现在解析——下一轮循环该它时 ctx.model 可能已变。
+    if (p) primeAt(chain[0] || null);
     return p;
   };
 
   let stage = "ipv4";
   let emptyIpv4Announced = false;
 
+  // 链头从没当过「备选」（它一上来就是主角），进入循环前先给它也打一个 hi ——
+  // 此时 ctx.model 还是本机刚失败的那个模型，解析目标与后面轮到时同源。
+  primeAt(ipv4Chain[0] || null);
+
   for (;;) {
     if (deadline > 0 && Date.now() >= deadline) {
       const remaining = ipv4Chain.length + ipv6Chain.length;
@@ -110,12 +139,33 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
     }
     if (!pending) break;
 
-    const prepared = await resolvePeerTarget(ctx, pending);
+    const prepared = await resolveOnce(pending);
     if (!prepared) continue;
     const { peer, target } = prepared;
     tried.add(peer.url);
     const ctrl = new AbortController();
     const name = peerName(peer);
+
+    // 轮到它了：再打一个 hi。回不来就当这个备选不行，直接换下一个。
+    if (typeof probePeer === "function") {
+      const t = performance.now();
+      let r;
+      try { r = await probePeer(peer, target); } catch { r = { ok: false }; }
+      const probeMs = Math.round(performance.now() - t);
+      if (r && r.ok === false) {
+        ctx.evt("peer-probe", { peer: peer.url, name, model: target, phase: "turn", ok: false, status: r.status ?? null, latencyMs: probeMs, action: "skip" });
+        failed.push({ ok: false, peer, target, res: null, status: r.status || 502 });
+        recordLater(() => ctx.peers.recordError(peer.url, { status: r.status || 502 }));
+        recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
+        continue;
+      }
+      ctx.evt("peer-probe", { peer: peer.url, name, model: target, phase: "turn", ok: true, status: r?.status ?? null, latencyMs: probeMs });
+      if (deadline > 0 && Date.now() >= deadline) {
+        ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽（探针后）`, budgetMs, remaining: ipv4Chain.length + ipv6Chain.length });
+        break;
+      }
+    }
+
     ctx.evt("peer-request", { peer: peer.url, name, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body), serial: 1, stage });
     if (ctx.plugins?.length) {
       runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});

package/src/routes/peers.js

@@ -5,6 +5,7 @@ import { runHook } from "../plugins.js";
 import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
 import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
 import { serialTryPeers, PEER_SERIAL } from "./peer-serial.js";
+import { probePeer, peerProbeTimeoutMs } from "./peer-probe.js";
 import { overForwardLimit, contextGuardMessage } from "../chat-pipeline/context-guard.js";
 
 // peer 阶段总预算：三批候选（ordered / orderedByLastError / coolingByLastError）共享同一个
@@ -252,6 +253,13 @@ export async function racePeerCandidates(candidates, ctx) {
         perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs,
         // 连接预热：对「下一个备选」提前打 /health，复用 chat 的同一连接池（见 warmPeerHealth 注释）
         warmPeer: (peer) => { if (peer?.url) warmPeerHealth(peer.url, { timeoutMs: 1500 }).catch(() => {}); },
+        // 用户 2026-10-20：备选时打一个 hi、轮到它时再打一个 hi，hi 回不来就换下一个。
+        // 走 getPeerDispatcher 的**同一条连接池**（与 chat 转发复用 socket，裸 fetch 热的是另一条等于白热）。
+        probePeer: (peer, model) => probePeer(peer, {
+          model: model || null,
+          timeoutMs: peerProbeTimeoutMs(),
+          dispatcher: getPeerDispatcher(),
+        }),
       },
     });
   }

package/src/runtime/raccoon-checkin.js

@@ -1,126 +1,175 @@
-/**
- * raccoon 登录奖励的 daemon 兜底扫描（仿 src/runtime/qoder-checkin.js 的排程形态）。
- * 开关：MSLXDFF_RACCOON_CHECKIN=0 关闭（默认开）；时间：MSLXDFF_RACCOON_CHECKIN_HOUR（默认 9 点本地时）。
- * ⚠ 性质纠偏（2026-10-10 账单实测）：**这家没有"每日签到"可领** ——
- *   每日 300 由服务端自动发放且当天 23:59:59 清零（无端点）；唯一要领的是「桌面端登录奖励 3000」，**每号一次性**。
- *   正常路径是 `raccoon login` 成功后立刻领掉（那时 token 最新鲜）；本任务只是兜底：
- *   扫出"历史上没领过"的号补领一次，领过的号每天只花一次账单查询即判"已领"，不再打写端点。
- */
-import { todayKey, nextRunDelayMs, shouldCatchUp } from "./workbuddy-checkin.js";
-
-export function isCheckinEnabled(env = process.env) {
-  const v = String(env.MSLXDFF_RACCOON_CHECKIN ?? "1").trim().toLowerCase();
-  return !["0", "false", "off", "no"].includes(v);
-}
-
-export function getCheckinHour(env = process.env) {
-  const h = Number(env.MSLXDFF_RACCOON_CHECKIN_HOUR);
-  return Number.isInteger(h) && h >= 0 && h <= 23 ? h : 9;
-}
-
-/** 账号文档 → credits.js 认的 credential 形状（与 provider 内 credentialFor 同构）。 */
-export function credentialFromAccountDoc(doc) {
-  return {
-    access_token: doc?.accessToken || "",
-    refresh_token: doc?.refreshToken || "",
-    // ⚠ expires_at 必须带上：少了它，isRaccoonExpired / isRaccoonExpiringSoon 一律判不出来（只能回落去解 JWT，
-    // 而假 token 解不出 → undefined → 保守判「未过期」），结果就是过期号照发请求去撞 401、临期号该续不续。
-    expires_at: doc?.expiresAt || "",
-    office_identity: doc?.officeIdentity || "",
-    device_id: doc?.deviceId || "",
-    uid: doc?.uid || "",
-  };
-}
-
-export async function setupRaccoonCheckin({ bus, logs, fetchImpl, dirs, env = process.env, now } = {}) {
-  function emit(type, data = {}) {
-    const entry = { ts: Date.now(), type, ...data };
-    try { bus?.emit(entry); } catch {}
-    try { logs?.appendEvent?.(entry); } catch {}
-    try { console.log(`[raccoon-checkin] ${type} ${JSON.stringify(data)}`.slice(0, 500)); } catch {}
-  }
-  if (!isCheckinEnabled(env)) {
-    console.log("[raccoon-checkin] disabled (set MSLXDFF_RACCOON_CHECKIN=1 to enable)");
-    emit("raccoon-checkin-disabled");
-    return { enabled: false };
-  }
-  const hour = getCheckinHour(env);
-  console.log(`[raccoon-checkin] enabled: daily ${String(hour).padStart(2, "0")}:00 local`);
-  emit("raccoon-checkin-enabled", { hour });
-
-  const stateMod = await import("../state.js");
-  const { listRaccoonAccountDocs } = await import("../providers/raccoon/account-store.js");
-  const { claimRaccoonLoginReward, raccoonClaimStatus } = await import("../providers/raccoon/credits.js");
-  const { isRaccoonExpired } = await import("../providers/raccoon/auth.js");
-
-  let running = false;
-  async function runOnce(reason) {
-    if (running) return { skipped: "already-running" };
-    running = true;
-    try {
-      const accounts = listRaccoonAccountDocs(dirs ? { dirs } : {}).filter((d) => d.accessToken);
-      if (!accounts.length) {
-        emit("raccoon-checkin-no-accounts", { reason });
-        return { ok: false, reason: "no-accounts" };
-      }
-      const results = [];
-      for (const a of accounts) {
-        const uid = String(a.uid).slice(0, 8);
-        const credential = credentialFromAccountDoc(a);
-        // access_token 只有约 3 小时寿命。过期的号一律跳过，**绝不去碰 refresh**：网关请求可能正在同一时刻
-        // 续同一个号，而 refresh_token 是一次性轮换的，两边抢同一条 token 等于亲手把号烧掉。
-        if (isRaccoonExpired(credential)) {
-          results.push({ uid, ok: false, claimed: false, status: "auth_stale", msg: "登录态已过期，需重新扫码：mslxdff -provider raccoon login" });
-          continue;
-        }
-        try {
-          const r = await claimRaccoonLoginReward({
-            credential,
-            ...(fetchImpl ? { fetchImpl } : {}),
-            env,
-          });
-          // 四种答复必须分开显示：只有 claimed 是真到账；already 是一次性礼包领过了（正常态）；
-          // phantom = 上游回 code:0 但账单没这笔（实测行为）；unverified = 账单查不动，不下结论。
-          const status = raccoonClaimStatus(r);
-          results.push({ uid, ok: status === "claimed" || status === "already", claimed: r.claimed, status, points: r.points });
-        } catch (e) {
-          results.push({ uid, ok: false, claimed: false, status: "error", msg: String(e?.message || e).slice(0, 120) });
-        }
-      }
-      const got = results.filter((r) => r.status === "claimed").length;
-      const already = results.filter((r) => r.status === "already").length;
-      const date = todayKey(now === undefined ? new Date() : new Date(now));
-      try {
-        stateMod.writeStateImmediate(stateMod.defaultStateFile(), {
-          raccoonCheckin: { date, at: Date.now(), ok: got + already, claimed: got, already, total: results.length, accounts: results },
-        });
-      } catch {}
-      for (const r of results) emit("raccoon-checkin-account", { ...r, reason });
-      emit("raccoon-checkin-done", { date, ok: got + already, claimed: got, already, total: results.length, reason });
-      return { ok: got + already > 0, claimed: got, already, total: results.length, results };
-    } catch (e) {
-      emit("raccoon-checkin-failed", { error: String(e?.message || e).slice(0, 200), reason });
-      return { ok: false, error: String(e?.message || e).slice(0, 200) };
-    } finally {
-      running = false;
-    }
-  }
-
-  // 启动补签：今天已过计划点、且（从没签过 或 上次不是今天）→ 90s 后跑（等网络/上游就绪）
-  try {
-    const lastDate = stateMod.readState(stateMod.defaultStateFile())?.raccoonCheckin?.date || "";
-    if (shouldCatchUp({ lastDate, hour })) {
-      setTimeout(() => { runOnce("catch-up").catch(() => {}); }, 90_000).unref?.();
-      console.log(`[raccoon-checkin] catch-up scheduled (last=${lastDate || "never"})`);
-    }
-  } catch {}
-  // 每日定时：对齐到下一个计划点，跑完再约 24h 后
-  function arm() {
-    const delay = nextRunDelayMs(new Date(), hour);
-    setTimeout(() => {
-      runOnce("daily").catch(() => {}).finally(arm);
-    }, delay).unref?.();
-  }
-  arm();
-  return { enabled: true, hour, runOnce };
-}
+/**
+ * raccoon 每日任务：**每日积分结算**（每天必做）+ 登录奖励补领（每号一次性）。
+ * 开关：MSLXDFF_RACCOON_CHECKIN=0 关闭（默认开）；时间：MSLXDFF_RACCOON_CHECKIN_HOUR（默认 9 点本地时）。
+ *
+ * ⚠ 性质纠偏（2026-10-21 账单实测，推翻 2026-10-10 的旧结论）：
+ *   这家的每日积分是**惰性结算**——服务端按天挂账，当天第一次访问 `/api/web/office/v3/setting_info`
+ *   才真正入账（入账即有效期到 T+6 的 23:59:59，即官方文案「当天登录后延长至 7 天」）。
+ *   不访问该端点，当天 `daily_points` 恒 0、账单里连 `daily_grant` 都没有。
+ *   所以本任务每天必做的第一件事就是打这个端点（幂等，连打多次只入账一次）。
+ *   第二件事才是「桌面端登录奖励 3000」的补领：**每号一次性**，正常路径是 `raccoon login` 时领掉，
+ *   本任务只是兜底：扫出"历史上没领过"的号补领一次，领过的号每天只花一次账单查询即判"已领"。
+ */
+import { todayKey, nextRunDelayMs, shouldCatchUp } from "./workbuddy-checkin.js";
+
+export function isCheckinEnabled(env = process.env) {
+  const v = String(env.MSLXDFF_RACCOON_CHECKIN ?? "1").trim().toLowerCase();
+  return !["0", "false", "off", "no"].includes(v);
+}
+
+export function getCheckinHour(env = process.env) {
+  const h = Number(env.MSLXDFF_RACCOON_CHECKIN_HOUR);
+  return Number.isInteger(h) && h >= 0 && h <= 23 ? h : 9;
+}
+
+/** 账号文档 → credits.js 认的 credential 形状（与 provider 内 credentialFor 同构）。 */
+export function credentialFromAccountDoc(doc) {
+  return {
+    access_token: doc?.accessToken || "",
+    refresh_token: doc?.refreshToken || "",
+    // ⚠ expires_at 必须带上：少了它，isRaccoonExpired / isRaccoonExpiringSoon 一律判不出来（只能回落去解 JWT，
+    // 而假 token 解不出 → undefined → 保守判「未过期」），结果就是过期号照发请求去撞 401、临期号该续不续。
+    expires_at: doc?.expiresAt || "",
+    office_identity: doc?.officeIdentity || "",
+    device_id: doc?.deviceId || "",
+    uid: doc?.uid || "",
+  };
+}
+
+export async function setupRaccoonCheckin({ bus, logs, fetchImpl, dirs, env = process.env, now } = {}) {
+  function emit(type, data = {}) {
+    const entry = { ts: Date.now(), type, ...data };
+    try { bus?.emit(entry); } catch {}
+    try { logs?.appendEvent?.(entry); } catch {}
+    try { console.log(`[raccoon-checkin] ${type} ${JSON.stringify(data)}`.slice(0, 500)); } catch {}
+  }
+  if (!isCheckinEnabled(env)) {
+    console.log("[raccoon-checkin] disabled (set MSLXDFF_RACCOON_CHECKIN=1 to enable)");
+    emit("raccoon-checkin-disabled");
+    return { enabled: false };
+  }
+  const hour = getCheckinHour(env);
+  console.log(`[raccoon-checkin] enabled: daily ${String(hour).padStart(2, "0")}:00 local`);
+  emit("raccoon-checkin-enabled", { hour });
+
+  const stateMod = await import("../state.js");
+  const { listRaccoonAccountDocs } = await import("../providers/raccoon/account-store.js");
+  const { claimRaccoonDailyPoints, claimRaccoonLoginReward, raccoonClaimStatus, raccoonDailyStatus } = await import("../providers/raccoon/credits.js");
+  const { isRaccoonExpired } = await import("../providers/raccoon/auth.js");
+
+  let running = false;
+  async function runOnce(reason) {
+    if (running) return { skipped: "already-running" };
+    running = true;
+    try {
+      const accounts = listRaccoonAccountDocs(dirs ? { dirs } : {}).filter((d) => d.accessToken);
+      if (!accounts.length) {
+        emit("raccoon-checkin-no-accounts", { reason });
+        return { ok: false, reason: "no-accounts" };
+      }
+      const results = [];
+      for (const a of accounts) {
+        const uid = String(a.uid).slice(0, 8);
+        const credential = credentialFromAccountDoc(a);
+        // 登录态过期的号一律跳过，**绝不去碰 refresh**：网关请求可能正在同一时刻
+        // 续同一个号，而 refresh_token 是一次性轮换的，两边抢同一条 token 等于亲手把号烧掉。
+        // （实测 access_token 寿命是 30 天而非注释里旧写的 3 小时，所以正常情况下每日任务不会撞上这条）
+        if (isRaccoonExpired(credential)) {
+          results.push({ uid, ok: false, claimed: false, daily: "auth_stale", status: "auth_stale", msg: "登录态已过期，需重新扫码：mslxdff -provider raccoon login" });
+          continue;
+        }
+
+        // 第一件：每日积分结算（惰性钩子，幂等）。失败不拖累下面的补领 —— 两件事互不依赖。
+        let daily = "error";
+        let dailyPoints = 0;
+        try {
+          const d = await claimRaccoonDailyPoints({ credential, ...(fetchImpl ? { fetchImpl } : {}), env, ...(now === undefined ? {} : { now }) });
+          daily = raccoonDailyStatus(d);
+          dailyPoints = d.points || 0;
+        } catch {
+          daily = "error";
+        }
+
+        // 第二件：一次性登录奖励补领。四种答复必须分开显示：只有 claimed 是真到账；
+        // already 是一次性礼包领过了（正常态）；phantom = 上游回 code:0 但账单没这笔（实测行为）；
+        // unverified = 账单查不动，不下结论。
+        let reward = "error";
+        let rewardPoints = 0;
+        let msg;
+        try {
+          const r = await claimRaccoonLoginReward({ credential, ...(fetchImpl ? { fetchImpl } : {}), env });
+          reward = raccoonClaimStatus(r);
+          rewardPoints = r.points || 0;
+        } catch (e) {
+          msg = String(e?.message || e).slice(0, 120);
+        }
+
+        results.push({
+          uid,
+          ok: daily === "claimed" || daily === "already",
+          daily,
+          dailyPoints,
+          reward,
+          rewardPoints,
+          status: daily === "auth_stale" ? "auth_stale" : daily,
+          ...(msg === undefined ? {} : { msg }),
+        });
+      }
+      const dailyGot = results.filter((r) => r.daily === "claimed").length;
+      const dailyDone = results.filter((r) => r.daily === "claimed" || r.daily === "already").length;
+      const rewardGot = results.filter((r) => r.reward === "claimed").length;
+      const already = results.filter((r) => r.reward === "already").length;
+      const date = todayKey(now === undefined ? new Date() : new Date(now));
+      try {
+        stateMod.writeStateImmediate(stateMod.defaultStateFile(), {
+          raccoonCheckin: {
+            date,
+            at: Date.now(),
+            ok: dailyDone,
+            dailyClaimed: dailyGot,
+            dailyDone,
+            claimed: rewardGot,
+            already,
+            total: results.length,
+            accounts: results,
+          },
+        });
+      } catch {}
+      for (const r of results) emit("raccoon-checkin-account", { ...r, reason });
+      emit("raccoon-checkin-done", {
+        date,
+        ok: dailyDone,
+        dailyClaimed: dailyGot,
+        dailyDone,
+        claimed: rewardGot,
+        already,
+        total: results.length,
+        reason,
+      });
+      return { ok: dailyDone > 0, dailyClaimed: dailyGot, dailyDone, claimed: rewardGot, already, total: results.length, results };
+    } catch (e) {
+      emit("raccoon-checkin-failed", { error: String(e?.message || e).slice(0, 200), reason });
+      return { ok: false, error: String(e?.message || e).slice(0, 200) };
+    } finally {
+      running = false;
+    }
+  }
+
+  // 启动补签：今天已过计划点、且（从没签过 或 上次不是今天）→ 90s 后跑（等网络/上游就绪）
+  try {
+    const lastDate = stateMod.readState(stateMod.defaultStateFile())?.raccoonCheckin?.date || "";
+    if (shouldCatchUp({ lastDate, hour })) {
+      setTimeout(() => { runOnce("catch-up").catch(() => {}); }, 90_000).unref?.();
+      console.log(`[raccoon-checkin] catch-up scheduled (last=${lastDate || "never"})`);
+    }
+  } catch {}
+  // 每日定时：对齐到下一个计划点，跑完再约 24h 后
+  function arm() {
+    const delay = nextRunDelayMs(new Date(), hour);
+    setTimeout(() => {
+      runOnce("daily").catch(() => {}).finally(arm);
+    }, delay).unref?.();
+  }
+  arm();
+  return { enabled: true, hour, runOnce };
+}