mslxdff 0.1.208 → 0.1.210

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.210",
   "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 };
+}

package/src/daemon.js

@@ -102,12 +102,26 @@ export function isPidAlive(pid) {
   }
 }
 
-export function stopDaemon({ reason = "stop", kill = process.kill, taskkill = spawnSync } = {}) {
+export function stopDaemon({ reason = "stop", kill = process.kill, taskkill = spawnSync, isAlive = isPidAlive } = {}) {
   const pid = readPid();
   if (!pid) return { stopped: false, reason: "no pid file" };
+  // 自杀护栏（最高优先级）：pid 文件里写着**本进程**时，杀它就是杀自己。
+  // 这不是假想情形 —— daemon 自己 `writePid(process.pid)`（server-lifecycle.js），而 `enableAutostart()`
+  // 会在 systemd 托管下被 daemon 自己调起（server-lifecycle 的 autostart 自检块）：systemd **系统** unit
+  // 的 daemon 去查 **user** unit 必然判「未启用」⇒ 走进 enableAutostart ⇒ stopDaemon ⇒ SIGTERM 自己
+  // ⇒ 优雅关停 exit 0 ⇒ systemd Restart=always 拉起 ⇒ 每 2.5 秒一轮的无限重启
+  //（真机 2026-10-19：0.1.209 + 系统 unit，每进程活 2~3s 被 SIGTERM；0.1.160 不炸只因当时
+  //  `enableAutostart` 里 import 路径写错、这段从未执行过，2026-10-17 c7bf8af 修正路径后暴露）。
+  if (pid === process.pid) {
+    try {
+      appendFileSync(logFile(), `[lifecycle] stopDaemon refused: pid file points at self (pid=${pid}, reason=${reason})\n`);
+    } catch {}
+    return { stopped: false, pid, reason: "self — pid 文件写的就是本进程，拒绝自杀" };
+  }
+
   // 杀者牌（验尸官的另一半证据）：动手前写、自带死者身份。只给在世者留牌——给尸体留牌
   // 会让下次验尸把"早已静默死亡"误判成"被本次杀死"。
-  const victimAlive = isPidAlive(pid);
+  const victimAlive = isAlive(pid);
   // 杀者留痕（写 daemon.log）：Windows 的 SIGTERM 是 TerminateProcess 强杀，被杀的 daemon
   // 在 JS 层收不到任何事件（无法自记），故由"杀者"记录调用方 pid——
   // 没有这行 = 非我方所杀（外部 taskkill/任务管理器/崩溃），配合最后一条 heartbeat 定位死亡时刻。

package/src/runtime/proc-info.js

@@ -92,6 +92,17 @@ export function isDaemonArgv(argv) {
   return list.includes("--daemon") && list.some((a) => /(^|[\\/])mslxdff(\.js)?$/i.test(String(a)));
 }
 
+/**
+ * 是否跑在 systemd 托管下（system 或 user unit 都算）。
+ * 判据：systemd 给被管服务注入 `INVOCATION_ID`（每个 invocation 唯一）与 `JOURNAL_STREAM`（stdout 连接信息）。
+ * 为什么要问：托管时 supervisor 已保证单实例与重启策略，daemon 再自己「杀旧进程/杀端口占用者」是职责重叠，
+ * 会与 systemd 的拉起时序打架成死循环（真机 2026-10-19：0.1.209 + 系统 unit 每 2.5s 自杀一轮）。
+ * @returns {boolean}
+ */
+export function underSystemd(env = process.env) {
+  return Boolean(env.INVOCATION_ID || env.JOURNAL_STREAM);
+}
+
 /** 「已运行 6h12m」这种人话时长（取证日志用）。 */
 export function fmtAlive(sec) {
   if (!Number.isFinite(sec)) return "运行时长未知";

package/src/runtime/server-lifecycle.js

@@ -5,6 +5,7 @@ import { runHook } from "../plugins.js";
 import { effectiveHost, maxHopsValue } from "../cli/policy.js";
 import { fmtEvent } from "../cli/format.js";
 import { writePid } from "../daemon.js";
+import { underSystemd } from "./proc-info.js";
 
 /**
  * 服务生命周期 — router 装配 → server 创建/ready-EADDRINUSE 自愈 →
@@ -66,6 +67,13 @@ export async function startServerLifecycle({ VERSION, token, created, upstream,
     const msg = String(err?.message || err);
     const code = err?.code || "";
     if (code === "EADDRINUSE" || msg.includes("EADDRINUSE")) {
+      // systemd 托管下不许杀端口占用者：supervisor 保证单实例，去杀「占用者」是越权，且会与
+      // systemd 的拉起时序互杀成循环（报告的另一半）。非零退出，让 systemd 按 Restart/RestartSec
+      // 退避重试——这才是托管语义下正确的收口。
+      if (underSystemd()) {
+        console.error(`[lifecycle] EADDRINUSE on port ${resolvePort()} under systemd — exit(1), let systemd backoff-retry（不杀任何进程）`);
+        process.exit(1);
+      }
       console.log(`[lifecycle] EADDRINUSE on port ${resolvePort()} — freeing stale holder and retrying...`);
       try {
         const { execFile } = await import("node:child_process");
@@ -166,7 +174,13 @@ export async function startServerLifecycle({ VERSION, token, created, upstream,
   } catch {}
 
   // best-effort: ensure autostart on Linux (so daemon survives reboot/SSH disconnect without manual cmd)
-  if (process.platform === "linux" && !process.env.MSLXDFF_NO_AUTOSTART) {
+  // **systemd 托管下必须跳过**（2026-10-19 真机无限重启的根因）：
+  //  - 托管时 supervisor 已经保证单实例+开机自启，这里再 enable 一次多余；
+  //  - 本块查的是 **user** unit（`~/.config/systemd/user/mslxdff.service`），而 systemd **系统**
+  //    unit 托管的 daemon 查它必然得 enabled=false ⇒ 走 enableAutostart() ⇒ linuxEnable() ⇒ stopDaemon()。
+  //    那条路径里 pid 文件写的就是**本进程**，过去等于每 2.5s 自杀一次（见 daemon.js 的自杀护栏）。
+  // systemd 会给被管进程注入 INVOCATION_ID / JOURNAL_STREAM，判据可靠、无需用户配置。
+  if (process.platform === "linux" && !process.env.MSLXDFF_NO_AUTOSTART && !underSystemd()) {
     setTimeout(async () => {
       try {
         const { getAutostartStatus, enableAutostart } = await import("../autostart.js");