mslxdff 0.1.208 → 0.1.209

package/docs/cli_help_mini.md

@@ -104,6 +104,7 @@
 | 组同步 | `-group sync` | 刷新全组成员 |
 | 组离开单 | `-group leave <name>` | 离开单组 |
 | 组列表 | `-group list` | 列组+成员+健康/序号 |
+| 组员链路测试 | `-group test <target\|seq> [--group <名>] [--model <id>] [--say <词>] [--json]` | 验「本机 → 组长 → 某组员（含 relay）→ 上游」整条路，**按阶段指出断在哪一跳**；target 可填 url / `relay://id` / `-group list` 序号 |
 | 组踢人 | `-group remove <seq>` | 仅 leader 按序号踢人 |
 | 全部离开 | `-leavegroup` / `--leavegroup` | 离开所有成员组 |
 | 解散组 | `-delgroup <name>` / `--delgroup` | 仅 leader 解散 |

package/package.json

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

package/src/cli/commands/group.js

@@ -110,6 +110,23 @@ export async function handleGroupCommand(args) {
     }
     console.log(`\njoined groups (${joinedList.length}):`);
     for (const g of joinedList) console.log(`  ${g.name}  ${g.leaderUrl || "(this node is the leader)"}`);
+  } else if (action === "test") {
+    // -group test <target> [--group <名>] [--model <id>] [--say <词>] [--json]
+    // target 可以是 url / relay://id / 或 -group list 里的序号（数字）。
+    const { resolveTargetArg, renderGroupTest } = await import("../group-test-cli.js");
+    const target = await resolveTargetArg(a, rest);
+    if (!target) {
+      console.error("usage: mslxdff -group test <target|seq> [--group <name>] [--model <id>] [--say <text>]");
+      process.exit(1);
+    }
+    const model = argValue(args, "--model", "-m") || undefined;
+    const say = argValue(args, "--say", "-s") || undefined;
+    const groupArg = argValue(args, "--group", "-g") || undefined;
+    const asJson = args.includes("--json");
+    const { runGroupLinkTest } = await import("../group-test.js");
+    const r = await runGroupLinkTest({ group: groupArg || "", target, ...(model ? { model } : {}), ...(say ? { prompt: say } : {}) });
+    renderGroupTest(r, { json: asJson });
+    process.exit(r.status === "ok" ? 0 : 1);
   } else if (action === "remove" && a) {
     const seq = Number(a);
     if (!Number.isInteger(seq) || seq < 1) {
@@ -138,7 +155,7 @@ export async function handleGroupCommand(args) {
       process.exit(1);
     }
   } else {
-    console.error("usage: mslxdff -group sync | -group leave <name> | -group list | -group remove <seq> | -creategroup <name>");
+    console.error("usage: mslxdff -group sync | -group leave <name> | -group list | -group test <target|seq> | -group remove <seq> | -creategroup <name>");
   }
   process.exit(0);
 }

package/src/cli/group-test-cli.js

@@ -0,0 +1,66 @@
+// `-group test` 的 CLI 适配层：把 -group list 的序号解析成 target，并把链路测试结果渲染成四态人话。
+import { loadPeers, loadGroupsJoined, loadToken } from "../state.js";
+import { refreshGroupMembers } from "../groups.js";
+import { compatFetch, timeoutSignal } from "../compat.js";
+import { resolveLeader } from "./group-test.js";
+
+/**
+ * 把用户给的 target 归一：数字 = -group list 里的序号；否则原样（url / relay://id）。
+ * 与 -group list 的编号口径一致（跳过 leader、broadband/static 都算）。
+ */
+export async function resolveTargetArg(a, rest = []) {
+  const raw = String(a ?? "").trim();
+  if (!raw) return "";
+  if (!/^\d+$/.test(raw)) return raw; // url 或 relay://id
+  const seq = Number(raw);
+  const joined = loadGroupsJoined();
+  const g = joined.find((x) => x?.leaderUrl) || joined[0];
+  if (!g) return "";
+  let members;
+  if (g.leaderUrl) {
+    try {
+      const { token } = await loadToken();
+      members = await refreshGroupMembers(g.name, {
+        leaderUrl: g.leaderUrl, memberName: g.memberName, url: g.myUrl, token,
+        fetchImpl: (url, opts) => compatFetch(url, { ...opts, signal: timeoutSignal(4000) }),
+      });
+    } catch { return ""; }
+  } else {
+    return ""; // 本机是组长时，序号口径见 -group list（此处不展开）
+  }
+  const entries = Object.entries(members || {}).filter(([id]) => id !== "leader");
+  const hit = entries[seq - 1];
+  return hit ? (hit[1]?.url || hit[0]) : "";
+}
+
+/** 结果 → 人话。`json` 时直接吐结构化结果（脚本用）。 */
+export function renderGroupTest(r, { json = false } = {}) {
+  if (json) { console.log(JSON.stringify(r, null, 2)); return; }
+  console.log("=".repeat(62));
+  console.log(`  组员链路测试：本机 → 组长 → ${r.target}`);
+  console.log("=".repeat(62));
+  console.log(`  组长 ${r.leaderUrl || "?"}｜组 ${r.group || "?"}${r.ms !== undefined ? `｜耗时 ${r.ms}ms` : ""}`);
+  console.log("");
+  if (r.status === "ok") {
+    console.log(`  ✅ 通了！经组长转发到该组员，上游返回：`);
+    console.log(`     "${String(r.content || "").slice(0, 200) || "(空正文)"}"`);
+    process.exitCode = 0;
+    return;
+  }
+  const stageZh = {
+    usage: "参数错误",
+    "resolve-leader": "定位组长失败",
+    "resolve-group": "确定组名失败",
+    "forward-fetch": "连不上组长",
+    auth: "鉴权被拒",
+    "target-missing": "目标不在组内",
+    "max-hops": "转发跳数超限",
+    "relay-timeout": "组长入了队但成员没回",
+    "forward-failed": "组长转发失败",
+    upstream: "成员打上游失败",
+  }[r.stage] || r.stage;
+  console.log(`  ❌ 没通 — 断在：**${stageZh}**${r.httpStatus ? `（HTTP ${r.httpStatus}）` : ""}`);
+  if (r.error) console.log(`     原因：${String(r.error).slice(0, 300)}`);
+  if (r.hint) console.log(`     下一步：${r.hint}`);
+  process.exitCode = 1;
+}

package/src/cli/group-test.js

@@ -0,0 +1,118 @@
+// 组员链路测试：验证「本机 → 组长 → 某组员（含 relay 宽带成员）→ 上游 → 回数据」整条路。
+//
+// 为什么需要它：这条链路跨 3 台机器 + 1 道鉴权，坏了只会看到一句 `502 fetch failed`，
+// 完全无法定位是哪一跳断的。本模块**按阶段**记录，把断点直接指出来：
+//   ① 定位本机组/组长 → ② 取组长 token（调组长 forward 要**组长的** token，见下）→
+//   ③ POST 组长 /v1/groups/relay/forward → ④ 判读回包（200 拿内容 / 401 鉴权 / 404 成员不存在 / 502·504 转发失败）
+//
+// ⚠ 鉴权事实（2026-10-19 实测）：`authorized()` 比的是**接收方自己的 token**，
+//   而 `/v1/groups/relay/forward` 在路由层 requiresAuth=true ⇒ 要**组长 token**。
+//   普通组员只有自己的 token ⇒ 调不动组长 forward（这就是"组员经组长"从没通的原因）。
+//   本命令调用时用组长 token；若拿不到组长 token（如你只是组员且未持有），会明确报出这一步。
+import { loadPeers, loadGroupsJoined, loadToken } from "../state.js";
+import { compatFetch, timeoutSignal } from "../compat.js";
+
+/** 默认探测模型与提示词。 */
+export const DEFAULT_TEST_MODEL = "deepseek-v4.1-flash-free";
+export const DEFAULT_TEST_PROMPT = "hi";
+
+/**
+ * 找一个可用的组长 token：优先 state.peers 里名为 leader 的记录，其次 groupsJoined 里非本机 url 的 peer。
+ * @returns {{ leaderUrl: string, leaderToken: string, group: string, source: string } | null}
+ */
+export function resolveLeader({ peers = [], joined = [] } = {}) {
+  const byName = (peers || []).find((p) => String(p?.name || "") === "leader" && p?.url);
+  if (byName) {
+    const g = joined.find((x) => x?.leaderUrl === byName.url);
+    return { leaderUrl: byName.url, leaderToken: String(byName.token || ""), group: g?.name || "", source: "peers[leader]" };
+  }
+  // 兜底：用 groupsJoined 的 leaderUrl 去 peers 里找同 url 的记录取 token
+  const g = (joined || []).find((x) => x?.leaderUrl);
+  if (g) {
+    const p = (peers || []).find((x) => x?.url === g.leaderUrl);
+    return { leaderUrl: g.leaderUrl, leaderToken: String(p?.token || ""), group: g.name, source: "groupsJoined.leaderUrl" };
+  }
+  return null;
+}
+
+/**
+ * 跑一次链路测试。返回结构化结果（不打印，由 CLI 渲染）。
+ *
+ * @param {{ group?: string, target: string, model?: string, prompt?: string, timeoutMs?: number,
+ *           deps?: { peers?, joined?, myToken?, fetchImpl? } }} opts
+ * @returns {Promise<{ status: "ok"|"error", stage: string, httpStatus?: number, content?: string,
+ *                      reply?: any, leaderUrl?: string, group?: string, target: string, ms?: number,
+ *                      error?: string, hint?: string }>}
+ */
+export async function runGroupLinkTest({
+  group = "",
+  target = "",
+  model = DEFAULT_TEST_MODEL,
+  prompt = DEFAULT_TEST_PROMPT,
+  timeoutMs = 45_000,
+  deps = {},
+} = {}) {
+  if (!target) return { status: "error", stage: "usage", target, error: "必须给目标组员（url、relay://id 或 -group list 里的序号对应项）" };
+
+  const peers = deps.peers ?? loadPeers();
+  const joined = deps.joined ?? loadGroupsJoined();
+  const myToken = deps.myToken ?? (await loadToken()).token;
+  const fetchImpl = deps.fetchImpl ?? compatFetch;
+
+  const lead = resolveLeader({ peers, joined });
+  if (!lead) return { status: "error", stage: "resolve-leader", target, error: "本机没有可用的组长记录（未加入任何组？）", hint: "先 mslxdff -addtogroup <组长host> <组名>" };
+  const groupName = group || lead.group;
+  if (!groupName) return { status: "error", stage: "resolve-group", target, error: "无法确定组名（state 里 peers/groupsJoined 缺 group）", hint: "用 -group 显式指定组名" };
+
+  const reqId = `gt-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+  const body = { group: groupName, target, reqId, body: { model, messages: [{ role: "user", content: prompt }], stream: false } };
+
+  const t0 = Date.now();
+  let res;
+  try {
+    res = await fetchImpl(`${lead.leaderUrl}/v1/groups/relay/forward`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${lead.leaderToken}` },
+      body: JSON.stringify(body),
+      signal: timeoutSignal(timeoutMs),
+    });
+  } catch (e) {
+    const msg = String(e?.message || e);
+    return { status: "error", stage: "forward-fetch", target, leaderUrl: lead.leaderUrl, group: groupName, ms: Date.now() - t0,
+      error: `连组长都打不通：${msg}`, hint: "组长地址/网络不通；先 mslxdff -group list 看组长健康" };
+  }
+  const ms = Date.now() - t0;
+  const txt = await res.text().catch(() => "");
+
+  // 按阶段归类失败 —— 这是本命令存在的意义：一眼看出断在哪一跳
+  if (res.status === 401) {
+    return { status: "error", stage: "auth", httpStatus: 401, target, leaderUrl: lead.leaderUrl, group: groupName, ms,
+      error: "组长拒了鉴权（401）：调 /v1/groups/relay/forward 需要**组长的** token，本机没有",
+      hint: "这是已知缺陷：组员中继链路的鉴权断了。修复 = 组长侧 forward 应接受成员 token（见 -group test 的 PR）" };
+  }
+  if (res.status === 404) {
+    return { status: "error", stage: "target-missing", httpStatus: 404, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 200), hint: "该目标不在组内（名称/url 对不上）；用 -group list 核对" };
+  }
+  if (res.status === 429) {
+    return { status: "error", stage: "max-hops", httpStatus: 429, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 200), hint: "转发跳数超限（有环）" };
+  }
+  if (res.status === 504) {
+    return { status: "error", stage: "relay-timeout", httpStatus: 504, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 200), hint: "组长入了队但目标成员没在 30s 内回结果（成员不在线/不通）" };
+  }
+  if (res.status !== 200) {
+    const isFetchFail = /fetch failed/i.test(txt);
+    const isRelay = String(target).startsWith("relay://");
+    return { status: "error", stage: "forward-failed", httpStatus: res.status, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 300),
+      hint: isFetchFail && isRelay
+        ? "对 relay 成员，502 fetch failed 通常是**该成员自己的上游**打不通（组长只负责转发，不碰上游）。判据：同组其他 relay 成员若正常，即证是这一台的网络/上游问题，不是组长。也可能是该成员离线。"
+        : isFetchFail ? "组长直连该静态成员失败（它离线或端口不通）" : "" };
+  }
+
+  let reply = null;
+  try { reply = JSON.parse(txt); } catch { reply = null; }
+  const content = reply?.choices?.[0]?.message?.content ?? reply?.content ?? "";
+  if (reply && (reply.error || reply.object === "error")) {
+    return { status: "error", stage: "upstream", httpStatus: 200, target, leaderUrl: lead.leaderUrl, group: groupName, ms, reply, error: String(reply.error?.message || reply.error || "").slice(0, 300), hint: "组长转到了成员，但成员打上游失败（该成员自己的上游/额度问题）" };
+  }
+  return { status: "ok", stage: "done", httpStatus: 200, target, leaderUrl: lead.leaderUrl, group: groupName, ms, content: String(content || ""), reply };
+}