mslxdff 0.1.207 → 0.1.208

package/docs/cli_help_mini.md

@@ -111,6 +111,7 @@
 | 组员开关 | `-use-group [on\|off]` / `--use-group [on\|off]` | opencode 失败时是否走组员（默认 on，off 则所有供应商仅本机；key 供应商默认恒直连，`MSLXDFF_USE_GROUP_KEYS=1` 可开回；cline/workbuddy 恒禁） |
 | 白嫖雷达 | `-free` / `--free` / `-free-check` / `--free-check` | V2EX 单源白嫖雷达（`latest.json + hot.json` 按白嫖|限免|免费额度过滤） |
 | 白嫖 watch | `-free-watch` / `--free-watch` | V2EX 白嫖雷达 watch（每 5 分钟轮询） |
+| IPv6 出口对照 | `-v6-pool [test] [--count N] [--model <id>]` | **Linux VPS** 专用：直连（IPv4）打一条 free 层请求取基线，再从 v6 段随机采 N 个源地址各打同一条（只换源地址）→ **基线 429 + v6 有 200 ⇒ 换 IP 能换到新额度**；v6 也 429 ⇒ 换 IP 抬不动。自造 `/128` 用完即撤；非 Linux 如实跳过 |
 | 自启开 | `-enable-autostart` / `--enable-autostart` | 开机自启（Windows 任务计划 / Linux systemd） |
 | 自启关 | `-disable-autostart` / `--disable-autostart` | 关闭开机自启 |
 | 自启状态 | `-autostart status` / `--autostart status` | 查看自启状态 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.207",
+  "version": "0.1.208",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/cli/commands/v6-pool.js

@@ -0,0 +1,123 @@
+// mslxdff -v6-pool [test|help] —— IPv6 出口额度对照测试（在 VPS 上验证 v6 池值不值得用）。
+//
+// 目的（用户 2026-10-18 明确）：**当这台 VPS 的 IPv4 出口撞 429 时，对比测一下 IPv6 出口还有没有额度**。
+// 所以本命令做 A/B：
+//   ① 直连（IPv4/系统默认出口）打一条免费层请求，记下额度状态作基线；
+//   ② 从 v6 段里随机采 N 个源地址，各打**同一条**请求（同 UA/模型/stream/tools，只换源地址）；
+//   ③ 对照两者：v6 有 200 ⇒ 池有用（换 IP 换到新额度）；v6 全 429 ⇒ 换 IP 抬不动。
+//
+// 纯可逆：自造的 /128 用完即撤（bind 模式不碰网卡）。非 Linux 如实跳过。
+import { runV6PoolCompare, V6TEST_DEFAULT, DEFAULT_PROBE_MODEL } from "../../v6pool/selftest.js";
+import { argValue } from "../policy.js";
+
+const FLAG = "-v6-pool";
+
+function flagValue(args, ...names) {
+  for (const name of names) {
+    const v = argValue(args, name);
+    if (v !== null && v !== undefined && !String(v).startsWith("-")) return v;
+    const eq = args.find((a) => a.startsWith(`${name}=`));
+    if (eq) return eq.slice(eq.indexOf("=") + 1);
+  }
+  return null;
+}
+
+const kindZh = { "free-quota": "429 额度耗尽", "free-tier": "403 免费层资格", "ip-limit": "429 限流", "black-quota": "账号日配额", network: "网络不可达", none: "非额度信号" };
+const line = (r) => {
+  if (r.error) return `✗ 不可达（${String(r.error).slice(0, 50)}）`;
+  if (r.ok) return `✅ HTTP ${r.status} 有额度`;
+  return `⛔ HTTP ${r.status} ${kindZh[r.kind] || r.kind}`;
+};
+
+export async function handleV6Pool(args = []) {
+  const at = args.findIndex((x) => x === FLAG || x.startsWith(`${FLAG}=`));
+  if (at < 0) return false;
+  const sub = (args[at].includes("=") ? args[at].split("=")[1] : args[at + 1] || "test").toLowerCase();
+  if (["-h", "--help", "help"].includes(sub)) return printUsage();
+
+  const count = (() => { const v = flagValue(args, "--count", "-n"); return v === null ? V6TEST_DEFAULT : Math.max(1, Math.min(64, Number(v) || V6TEST_DEFAULT)); })();
+  const model = flagValue(args, "--model", "-m") || DEFAULT_PROBE_MODEL;
+
+  console.log("=".repeat(66));
+  console.log("  IPv6 出口额度对照 —— 「IPv4 撞 429 时，IPv6 还有额度吗」");
+  console.log("=".repeat(66));
+  console.log("");
+  console.log(`  探测模型 ${model}｜采样 ${count} 个 v6 源地址｜只换源地址，其余请求完全相同`);
+  console.log("");
+
+  const onProgress = (ev) => {
+    if (ev.phase === "baseline-start") console.log(`  ▸ 基线：直连（IPv4 / 系统默认出口）打一条免费层请求…`);
+    else if (ev.phase === "baseline-done") {
+      console.log(`    基线结果：${line(ev)}${ev.body ? `（${String(ev.body).slice(0, 80).replace(/\s+/g, " ")}）` : ""}`);
+      console.log("");
+    } else if (ev.phase === "v6-start") process.stdout.write(`  [${String(ev.i).padStart(2)}/${ev.n}] ${ev.addr}  … `);
+    else if (ev.phase === "v6-done") process.stdout.write(`${line(ev)}\n`);
+  };
+
+  let r;
+  try {
+    r = await runV6PoolCompare({ count, model, onProgress });
+  } catch (e) {
+    console.log("");
+    console.log(`❌ 测试执行出错：${e?.message ?? e}`);
+    console.log(`   重试：mslxdff ${FLAG}`);
+    process.exit(1);
+    return true;
+  }
+
+  if (r.status === "skip") {
+    console.log(`❌ 无法测 v6 出口：${r.reason}`);
+    console.log(`   下一步：${r.hint}`);
+    process.exit(1);
+    return true;
+  }
+
+  console.log("");
+  console.log("-".repeat(66));
+  console.log(`  基线（IPv4/直连）：${line(r.baseline)}`);
+  console.log(`  v6 采样：有额度 ${r.v6OkCount}｜429 ${r.v6LimitedCount}｜不可达 ${r.v6NetCount}（共 ${r.requested}）`);
+  console.log("");
+  const verdicts = {
+    "v6-works": {
+      mark: "✅",
+      text: `IPv6 **能换到新额度**：${r.v6OkCount}/${r.requested} 个 v6 出口拿到 200`,
+      next: `   结论：v6 池对这台机器**有用** —— IPv4 耗尽时换 v6 出口能续。daemon 建池时会自动启用。`,
+    },
+    "v6-also-limited": {
+      mark: "⛔",
+      text: `IPv6 **也全 429**：换 IP 没换到新额度`,
+      next: `   结论：v6 池对这台机器**无意义**（要么上游不按出口 IP 计额，要么该段没真路由出去）。建议 MSLXDFF_V6_POOL=0。`,
+    },
+    "v6-unreachable": {
+      mark: "❌",
+      text: `IPv6 源地址**全都够不着上游**（段没路由到本机）`,
+      next: `   结论：本机这段 v6 不能用作出口。查机房是否把该段 routed 过来，或用 MSLXDFF_V6_PREFIX 指更准的段。`,
+    },
+    mixed: {
+      mark: "△",
+      text: `部分可用：${r.v6OkCount}/${r.requested} 个 v6 出口有额度`,
+      next: `   结论：v6 池**部分可用**（可能有些 /128 被沿途丢弃）。够用即可开着。`,
+    },
+  }[r.verdict] || { mark: "?", text: "未判定", next: "" };
+  console.log(`  ${verdicts.mark} ${verdicts.text}`);
+  if (verdicts.next) console.log(verdicts.next);
+  console.log("");
+  console.log(`   重试：mslxdff ${FLAG} --count ${r.requested}${model !== DEFAULT_PROBE_MODEL ? ` --model ${model}` : ""}`);
+  process.exit(r.verdict === "v6-works" || r.verdict === "mixed" ? 0 : 1);
+}
+
+function printUsage() {
+  console.log(`用法: mslxdff ${FLAG} [test] [--count N] [--model <id>]`);
+  console.log("");
+  console.log("  在 Linux VPS 上做 A/B：直连（IPv4）打一条 free 层请求取基线，");
+  console.log("  再从 v6 段随机采 N 个源地址各打同一条，对照 IPv6 出口还有没有额度。");
+  console.log("    基线 429 + v6 有 200 ⇒ 池有用（换 IP 换到新额度）");
+  console.log("    基线 429 + v6 也 429 ⇒ 换 IP 抬不动（上游不按出口 IP 计额 / 段没路由过来）");
+  console.log("");
+  console.log("相关 env（与 daemon 建池同源）：");
+  console.log("    MSLXDFF_V6_PREFIX=<段>/<位数>   显式指定池前缀（缺省取本机全局地址前缀）");
+  console.log("    MSLXDFF_V6_IFACE=<网卡>        指定网卡");
+  console.log("    MSLXDFF_V6_CLAIM=auto|bind|add 认领方式（bind 需 ip_nonlocal_bind=1；add 需 root）");
+  process.exit(0);
+  return true;
+}

package/src/cli/index.js

@@ -41,6 +41,9 @@ export async function run(args = process.argv.slice(2)) {
   if (await handleAutostart(args)) return;
   if (await handleFree(args)) return;
 
+  const { handleV6Pool } = await import("./commands/v6-pool.js");
+  if (await handleV6Pool(args)) return;
+
   const { handleProviders, handleProvider } = await import("./commands/provider.js");
   if (await handleProviders(args)) return;
   if (await handleProvider(args)) return;

package/src/v6pool/selftest.js

@@ -0,0 +1,154 @@
+// v6pool · 出口对照测试：回答「这台 VPS 的 IPv4 出口撞 429 时，换成 IPv6 出口还有没有额度」。
+//
+// 这才是 v6 池的**唯一价值判据**：opencode 免费层按**出口 IP** 计额。若本机 IPv4 已耗尽
+// （打上游回 429 FreeUsageLimitError），而某个 IPv6 出口还能 200 ⇒ 池有用（换 IP 换到新额度）；
+// 若 IPv6 出口也 429 ⇒ 要么上游按别的东西计额（账号/session），要么该段没真路由出去。
+//
+// 对照纪律：**除"源地址"外一切相同** —— 同 URL、同 UA、同模型、同 `stream:true`+五核心工具
+// （否则会 403 FreeTierError 而非 429，测出来的不是额度）；差异只允许来自"哪个源地址出网"。
+// 判定复用 `warp-pool/verdict.js` 的 classifyWarpSignal（与生产换址判决同源，不自造一套）。
+//
+// IO 全部注入（agentFactory/fetch/detect/claimer），零真机依赖，可单测。
+import { getUndici, timeoutSignal } from "../compat.js";
+import { classifyWarpSignal } from "../warp-pool/verdict.js";
+import { opencodeUa } from "../opencode-identity.js";
+import { CORE_AGENT_TOOL_NAMES } from "../free-lane.js";
+import { detectPool } from "./detect.js";
+import { resolveV6Config } from "./config.js";
+import { createClaimer } from "./claim.js";
+import { randomAddress, parsePrefix, hostBitsOf } from "./prefix.js";
+
+/** 采样上限：抽查，不扫全段。 */
+export const V6TEST_MAX = 64;
+export const V6TEST_DEFAULT = 6;
+
+/** 默认探测模型：免费池里最有代表性、额度最容易耗的一个。 */
+export const DEFAULT_PROBE_MODEL = "deepseek-v4.1-flash-free";
+
+/** 免费层请求体形状（stream:true + 五核心工具名），缺了会 403 而非 429 ⇒ 测不出额度。 */
+export function freeLaneBody(model, prompt = "hi") {
+  return {
+    model,
+    stream: true,
+    max_tokens: 16,
+    messages: [{ role: "user", content: prompt }],
+    tools: CORE_AGENT_TOOL_NAMES.map((name) => ({
+      type: "function",
+      function: { name, description: `The ${name} tool.`, parameters: { type: "object", properties: {} } },
+    })),
+  };
+}
+
+/** 读响应正文（有上界，失败给空串——不读就无法判决 403/429 的具名类名）。 */
+async function readBody(res, max = 2048) {
+  try {
+    const t = await res.text();
+    return t.slice(0, max);
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 从某个源地址打一次免费层 chat，返回判决。
+ * `addr=""` 表示**直连**（走本机默认路由 = IPv4 出口，或双栈默认）。
+ * @returns {Promise<{addr, ok, status, kind, rotate, ms, body, error}>}
+ */
+export async function probeUpstreamFrom({ addr = "", model, baseUrl = "https://opencode.ai", agentFactory, fetchImpl, timeoutMs = 20_000, prompt } = {}) {
+  const t0 = Date.now();
+  let agent = null;
+  try {
+    agent = addr ? agentFactory(addr) : null; // 直连：不注入 dispatcher，走系统默认出口
+    const f = fetchImpl || getUndici().fetch;
+    const res = await f(`${baseUrl}/zen/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": opencodeUa(), Accept: "text/event-stream" },
+      body: JSON.stringify(freeLaneBody(model, prompt)),
+      ...(agent ? { dispatcher: agent } : {}),
+      signal: timeoutSignal(timeoutMs),
+    });
+    const body = await readBody(res);
+    const v = classifyWarpSignal({ status: res.status, text: body });
+    return { addr, ok: res.status >= 200 && res.status < 300, status: res.status, kind: v.kind, rotate: v.rotate, ms: Date.now() - t0, body };
+  } catch (e) {
+    return { addr, ok: false, status: 0, kind: "network", rotate: true, ms: Date.now() - t0, body: "", error: String(e?.message || e) };
+  } finally {
+    if (agent) { try { await agent.close?.(); } catch { /* 一次性 Agent */ } }
+  }
+}
+
+/**
+ * 跑一次出口对照测试。返回结构化结果，由 CLI 渲染（本模块不打印）。
+ *
+ * @param {{ env?: object, count?: number, model?: string, baseUrl?: string,
+ *           onProgress?: (ev: object) => void,
+ *           deps?: { detect?, claimer?, agentFactory?, fetchImpl?, probe?, randomAddress? } }} opts
+ */
+export async function runV6PoolCompare({
+  env = process.env,
+  count = V6TEST_DEFAULT,
+  model = DEFAULT_PROBE_MODEL,
+  baseUrl = "https://opencode.ai",
+  onProgress,
+  deps = {},
+} = {}) {
+  const cfg = resolveV6Config(env);
+  const tick = (ev) => { try { onProgress?.(ev); } catch { /* 渲染出错不打断测试 */ } };
+
+  const detect = deps.detect || detectPool;
+  const d = detect({ cfg, env });
+  if (!d.ok) return { status: "skip", reason: d.reason, hint: d.hint };
+  const prefix = parsePrefix(`${d.prefix}`);
+  if (!prefix) return { status: "skip", reason: `前缀解析失败：${d.prefix}`, hint: "用 MSLXDFF_V6_PREFIX=<段>/<位数> 显式指定" };
+
+  const { Agent } = getUndici();
+  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, connections: 1, keepAliveTimeout: 5_000 }));
+  const probe = deps.probe || probeUpstreamFrom;
+  const pick = deps.randomAddress || ((p) => randomAddress(p));
+
+  // ① 基准：直连（IPv4 / 系统默认出口），记下它的额度状态作为对照基线
+  tick({ phase: "baseline-start", prefix: d.prefix, model });
+  const baseline = await probe({ addr: "", model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl });
+  tick({ phase: "baseline-done", ...baseline });
+
+  // ② IPv6 池采样：每个随机源地址打同一条请求
+  const n = Math.max(1, Math.min(V6TEST_MAX, Number(count) || V6TEST_DEFAULT));
+  const claimer = deps.claimer ? deps.claimer(d, cfg) : createClaimer({ iface: d.iface, mode: d.mode, dir: cfg.dir });
+  const mineSet = new Set(d.mine || []);
+  const v6 = [];
+  try {
+    for (let i = 0; i < n; i++) {
+      let addr = pick(prefix);
+      for (let k = 0; k < 16 && mineSet.has(addr); k++) addr = pick(prefix);
+      await claimer.ensure(addr);
+      tick({ phase: "v6-start", i: i + 1, n, addr });
+      const r = await probe({ addr, model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl });
+      v6.push(r);
+      tick({ phase: "v6-done", i: i + 1, n, ...r });
+    }
+  } finally {
+    try { await claimer.releaseAll(); } catch { /* 释放失败交给下次 sweepStale */ }
+  }
+
+  // ③ 判语：对照基线
+  const baseLimited = baseline.status === 429 || baseline.kind === "free-quota" || baseline.kind === "free-tier" || baseline.kind === "ip-limit";
+  const v6Ok = v6.filter((r) => r.ok);
+  const v6Limited = v6.filter((r) => r.status === 429);
+  const v6Net = v6.filter((r) => !r.status);
+
+  let verdict;
+  const allOk = v6Ok.length === v6.length && v6.length > 0;
+  if (allOk) verdict = "v6-works";                                  // 全部 v6 出口都有额度
+  else if (v6Limited.length === v6.length) verdict = "v6-also-limited"; // 全部 429 ⇒ 没换到新额度
+  else if (v6Net.length === v6.length) verdict = "v6-unreachable";  // 全部够不着 ⇒ 段没路由过来
+  else verdict = "mixed";                                           // 有的成有的不成
+
+  return {
+    status: "ok",
+    prefix: d.prefix, iface: d.iface, mode: d.mode, hostBits: hostBitsOf(prefix.bits), model, baseUrl,
+    baseline, baseLimited,
+    v6, requested: n,
+    v6OkCount: v6Ok.length, v6LimitedCount: v6Limited.length, v6NetCount: v6Net.length,
+    verdict,
+  };
+}