dsh-lan-peers 0.8.2 → 0.8.3

package/client/cli-code.test.mjs

@@ -0,0 +1,108 @@
+// dsh-lan-peers · M6 之后 `lan-peers code` 必须请本机 host 发码。
+//
+// 审计/产品口径：配对码只在 daemon 进程内存里，CLI 是独立进程 —— 它自己造的码对正在跑的
+// host 无效，用户抄走的是废码。所以 code 子命令改成打本机管理接口（带 token），
+// 本机没 host / 拿不到 token 时 exit 2 并说清怎么起 host，绝不本地造一个码。
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createAdmin } from '../lib/admin.mjs';
+import { makeTempStateDir } from '../host/test/helpers.mjs';
+
+const CLI = path.join(path.dirname(fileURLToPath(import.meta.url)), 'cli.mjs');
+
+const run = (args) => new Promise((resolve) => {
+  execFile(process.execPath, [CLI, ...args], { encoding: 'utf8' }, (error, stdout, stderr) => {
+    resolve({ code: error ? error.code : 0, stdout: String(stdout || ''), stderr: String(stderr || '') });
+  });
+});
+
+/** 真 admin 挂在真 HTTP 上：token 文件由它启动时写进这个 stateDir（CLI 读同一份）。 */
+async function startAdmin(t, { dir, code = '246810' } = {}) {
+  const state = { instanceId: 'inst-self', name: 'self' };
+  const store = {
+    instanceId: 'inst-self',
+    stateDir: dir,
+    state,
+    listPeers: () => [],
+    getPeer: () => null,
+    issuePairingCode: () => {
+      const issued = { code, expiresAt: Date.now() + 600_000 };
+      state.pairingCode = issued;
+      return issued;
+    },
+  };
+  const admin = createAdmin({
+    server: { config: { logger: () => {} }, store },
+    nameOf: () => 'self',
+    rename: (n) => n,
+  });
+  const calls = [];
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (chunk) => { body += chunk; });
+    req.on('end', () => {
+      calls.push({ url: String(req.url || ''), method: String(req.method || 'GET'), headers: req.headers });
+      const url = new URL(String(req.url || '/'), 'http://127.0.0.1');
+      Promise.resolve(admin.handle(req, res, url)).then((handled) => {
+        if (!handled) {
+          res.writeHead(404, { 'content-type': 'application/json' });
+          res.end('{"error":"not-found"}');
+        }
+      }).catch((error) => {
+        res.writeHead(500, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: String(error && error.message ? error.message : error) }));
+      });
+    });
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  t.after(() => new Promise((resolve) => server.close(resolve)));
+  return { admin, calls, state, url: 'http://127.0.0.1:' + server.address().port };
+}
+
+test('code：请本机 host 发码并原样打印（与 admin 手里的码一致）', async (t) => {
+  const dir = makeTempStateDir('lanb-cli-code-');
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const rig = await startAdmin(t, { dir, code: '246810' });
+
+  const out = await run(['code', '--state-dir', dir, '--url', rig.url]);
+  assert.equal(out.code, 0, out.stderr);
+  assert.match(out.stdout, /配对码: 246810/);
+  assert.doesNotMatch(out.stdout + out.stderr, /token/, '不能把 token 字样漏到界面上');
+
+  const issued = rig.calls.find((call) => call.url === '/api/lan-peers/code');
+  assert.ok(issued, '必须打 POST /api/lan-peers/code: ' + JSON.stringify(rig.calls.map((c) => c.url)));
+  assert.equal(issued.method, 'POST');
+  assert.equal(issued.headers['x-lan-peers-token'], rig.admin.token, 'token 从 <stateDir>/admin-token 读，只走请求头');
+
+  // 打印出来的码就是 host 手里的那一个：GET state 说「已生成」。
+  const state = await fetch(rig.url + '/api/lan-peers/state', { headers: { 'x-lan-peers-token': rig.admin.token } });
+  const body = await state.json();
+  assert.equal(body.pairing.active, true, 'CLI 打印的码必须是本机 host 活着的那一个');
+  assert.equal(JSON.stringify(body).includes('246810'), false, 'GET state 仍不回显码');
+});
+
+test('code：本机没有 host / 拿不到 token → exit 2，且绝不本地造码打印', async (t) => {
+  const dir = makeTempStateDir('lanb-cli-code-');
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const rig = await startAdmin(t, { dir, code: '246810' });
+  // 拿掉 token 文件：等价于「本机 host 没起 / 不是同一个进程」。
+  fs.rmSync(path.join(dir, 'admin-token'));
+
+  const out = await run(['code', '--state-dir', dir, '--url', rig.url]);
+  assert.equal(out.code, 2, '拿不到码就是 exit 2: ' + out.stdout + out.stderr);
+  assert.match(out.stderr, /请先启动本机 host/);
+  assert.match(out.stderr, /token-required/, '失败原因要如实转述');
+  assert.doesNotMatch(out.stdout, /\d{6}/, '失败时不能在 stdout 吐出任何 6 位数字（那会被当成码）');
+  assert.equal(fs.existsSync(path.join(dir, 'admin-token')), false, 'CLI 不该自己去造 token');
+});
+
+test('code --help 说明「请本机 host 发码」，不再声称写 state.json', async (t) => {
+  const out = await run(['code', '--help']);
+  assert.match(out.stdout, /请本机 host 生成一次性配对码/);
+  assert.doesNotMatch(out.stdout, /同时写入 state\.json/, 'M6 之后 state.json 不再存码');
+});

package/client/cli.mjs

@@ -7,11 +7,9 @@
 //   node cli.mjs events --peer <peerId|name> --session <sessionId> [--duration 300] [--verbose]
 //   node cli.mjs unpair --peer <peerId|name> [--local-only] [--timeout 10]
 import crypto from 'node:crypto';
-import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import {
   DEFAULT_ANSWER_WAIT_MS,
   MAX_ANSWER_WAIT_MS,
@@ -82,9 +80,11 @@ const USAGE = [
 ].join('\n');
 
 const CODE_USAGE = [
-  '用法: dsh-lan-peers code [--state-dir <目录>]',
+  '用法: dsh-lan-peers code [--state-dir <目录>] [--url <本机管理接口>]',
   '',
-  '生成一次性配对码，同时写入 state.json（10 分钟有效，用后即焚）。',
+  '请本机 host 生成一次性配对码（10 分钟有效，用后即焚）。',
+  'M6 起码只活在 host 进程内存里：本命令是独立进程，自己生成的码对正在跑的 host 无效，',
+  '所以必须先启动本机 host（或直接用界面面板的「生成配对码」）。',
 ].join('\n');
 
 const PAIR_USAGE = [
@@ -227,20 +227,40 @@ async function signedCall({ baseUrl, secret, senderId, method = 'GET', apiPath,
   return callPeer({ baseUrl, secret, senderId, method, apiPath, body, timeoutMs: 60_000 });
 }
 
+/**
+ * M6：配对码只活在 daemon 进程内存里（state.json 不再持久化它）。本命令是**独立进程**，
+ * 自己生成一个码打印出来，正在跑的 host 根本不知道 —— 用户抄走的是一条无效凭据
+ * （旧行为「另一个进程能写码」本身也正是要堵掉的植入路径）。所以这里改成请本机 host 发码：
+ * 它才是唯一该写这条的进程，也是唯一知道码的进程。
+ *
+ * 本机没有 host / 拿不到 token → exit 2 并说清怎么起 host，绝不本地造一个码糊弄过去。
+ */
 async function cmdCode(args) {
-  // The code lives in state.json, which the host process re-reads; issuing it via
-  // the host CLI keeps one writer instead of racing the running server.
-  const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-  const out = execFileSync(process.execPath, [
-    path.join(pkgRoot, 'host', 'server.mjs'),
-    '--code',
-    '--state-dir',
-    stateDir(args),
-  ], { encoding: 'utf8' });
-  const match = /(\d{6})/.exec(out);
-  if (!match) throw new Error(out.trim() || 'no pairing code');
-  console.log('配对码: ' + match[1] + '   有效期: 10 分钟，一次性');
+  const dir = stateDir(args);
+  const url = String(args.url ?? '').trim() || ADMIN_DEFAULT_URL;
+  let out;
+  try {
+    out = await adminCall(url, 'code', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{}',
+    }, dir);
+  } catch (error) {
+    const reason = String(error?.message ?? error);
+    process.stderr.write('生成配对码失败：本机 host 未接受 ' + url + '（' + reason + '）\n'
+      + '修法：请先启动本机 host（或用界面面板的「生成配对码」）—— 码只能在 host 进程里生成\n');
+    process.exitCode = 2;
+    return;
+  }
+  const code = String(out && out.code ? out.code : '').trim();
+  if (!/^\d{6}$/.test(code)) {
+    process.stderr.write('生成配对码失败：本机 host 未按契约回 6 位码\n');
+    process.exitCode = 2;
+    return;
+  }
+  console.log('配对码: ' + code + '   有效期: 10 分钟，一次性');
   console.log('对方把它填进「添加伙伴」里即可配对（地址填本机 http://<ip>:7788）');
+  console.log('提示: 这个码只在本机 host 进程里有效，重启 host 即失效');
 }
 
 async function cmdPair(args) {
@@ -718,6 +738,10 @@ function formatDispatchLine(dispatch) {
   const status = String(data.status ?? '');
   const who = String(data.targetName ?? '') || String(data.target ?? '') || '—';
   if (status === 'skipped') return '未派单（消息里没有 @! 目标）: ' + String(data.reason ?? 'no-target');
+  // M1：同名歧义是「用户得先选一个」，不是网络错误 —— 给出可操作的重发语法。
+  if (status === 'failed' && String(data.reason ?? '') === 'ambiguous') {
+    return '派单 → ' + who + '：有多个同名成员，请用 @!名字 (短id) 重发';
+  }
   const parts = [];
   // done 也可能带 reason（契约 §1：多个 @! 只取第一个，reason=multi-target-ignored）。
   const reason = String(data.reason ?? '');
@@ -751,7 +775,7 @@ async function triggerDispatch(args, command) {
         task: command.task,
         extraTargets: command.extraTargets,
       }),
-    });
+    }, stateDir(args));
   } catch (error) {
     const reason = String(error?.message ?? error);
     process.stderr.write('消息已发出，但派单未触发：本机 host 未响应 ' + url + '（' + reason + '）\n'
@@ -828,7 +852,7 @@ async function cmdGroupAccept(dir, args) {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ acceptDispatch: value }),
-    });
+    }, dir);
   } catch (error) {
     const reason = String(error?.message ?? error);
     process.stderr.write('切换接单失败：本机 host 未接受 ' + url + '（' + reason + '）\n'
@@ -1052,16 +1076,37 @@ async function cmdGroupClaim(dir, args) {
 
 const ADMIN_DEFAULT_URL = 'http://127.0.0.1:7788';
 const ADMIN_TIMEOUT_MS = 10000;
+// S3：管理接口要 X-Lan-Peers-Token。host 启动时把它写到 <stateDir>/admin-token（0600），
+// CLI 只读不写；token 本身绝不出现在 URL、日志或错误消息里（只说去哪读）。
+const ADMIN_TOKEN_FILE = 'admin-token';
+
+function readAdminToken(dir) {
+  try {
+    return fs.readFileSync(path.join(String(dir || DEFAULT_STATE_DIR), ADMIN_TOKEN_FILE), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
 
 /** 打本机回环管理接口；非 2xx 抛 `<status> <error>` 形式的 Error（与 group-client 同款）。 */
-async function adminCall(baseUrl, apiPath, init) {
+async function adminCall(baseUrl, apiPath, init, dir) {
   const base = String(baseUrl || ADMIN_DEFAULT_URL).replace(/\/+$/, '');
+  const token = readAdminToken(dir);
+  const headers = { ...(init && init.headers ? init.headers : {}) };
+  if (token !== '') headers['X-Lan-Peers-Token'] = token;
   const reply = await fetch(base + '/api/lan-peers/' + apiPath, {
     ...init,
+    headers,
     signal: AbortSignal.timeout(ADMIN_TIMEOUT_MS),
   });
   const body = await reply.json().catch(() => ({}));
-  if (!reply.ok) throw new Error(reply.status + ' ' + String(body.error || 'admin-call-failed'));
+  if (!reply.ok) {
+    const status = reply.status;
+    const where = path.join(String(dir || DEFAULT_STATE_DIR), ADMIN_TOKEN_FILE);
+    // 401 一定是 token 缺失/不匹配：直接指路（host 启动时写入，权限 0600）。
+    const hint = status === 401 ? '（管理接口需要 token：确认本机 host 在跑，且 ' + where + ' 可读）' : '';
+    throw new Error(status + ' ' + String(body.error || 'admin-call-failed') + hint);
+  }
   return body;
 }
 
@@ -1075,7 +1120,7 @@ function reportArchiveError(error) {
 async function cmdGroupArchives(dir, args) {
   let out;
   try {
-    out = await adminCall(args.url, 'group/archives');
+    out = await adminCall(args.url, 'group/archives', undefined, dir);
   } catch (error) {
     reportArchiveError(error);
     return;
@@ -1111,7 +1156,7 @@ async function cmdGroupArchiveDelete(dir, args) {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ file: file, action: 'delete' }),
-    });
+    }, dir);
   } catch (error) {
     reportArchiveError(error);
     return;

package/host/server.mjs

@@ -118,7 +118,7 @@ import { parseArgs } from 'node:util';
 // ---------------------------------------------------------------------------
 
 /** 插件版本，用于 /v1/health.version */
-export const PLUGIN_VERSION = '0.8.2';
+export const PLUGIN_VERSION = '0.8.3';
 
 /** §4.1 允许的时钟偏移 */
 export const CLOCK_SKEW_MS = 60_000;
@@ -743,6 +743,9 @@ export class StateStore {
 
   #state = null;
 
+  /** M6：配对码只活在本进程内存里（不落盘、不经文件被别的进程植入，重启即失效） */
+  #pairingCode = null;
+
   #peers = null;
 
   #lastTouchPersist = new Map();
@@ -802,7 +805,8 @@ export class StateStore {
       state.createdAt = nowIso(this.#now());
       dirty = true;
     }
-    if (state.pairingCode && this.#now() >= Number(state.pairingCode.expiresAt ?? 0)) {
+    // M6：配对码不再落盘。老版本留下的字段读回时一律清掉（迁移即焚）
+    if (Object.prototype.hasOwnProperty.call(state, 'pairingCode')) {
       delete state.pairingCode;
       dirty = true;
     }
@@ -831,31 +835,29 @@ export class StateStore {
     return name;
   }
 
-  /** 生成配对码：6 位数字、10 分钟、覆盖旧码（一次性由 consume 保证） */
+  /**
+   * 生成配对码：6 位数字、10 分钟、覆盖旧码（一次性由 consume 保证）。
+   * M6：码**只存进程内存** —— state.json 里不再有它，进程重启即失效，
+   * 同机另一个进程（或拿到文件写权限的人）也无法预置一枚可用的码。
+   */
   issuePairingCode() {
-    const state = this.#readState();
-    this.#state = state;
+    this.#state = this.#readState();
     const code = String(randomInt(0, 1_000_000)).padStart(6, '0');
     const expiresAt = this.#now() + PAIRING_CODE_TTL_MS;
-    state.pairingCode = { code, expiresAt };
-    writeJson0600(this.statePath, state);
+    this.#pairingCode = { code, expiresAt };
     return { code, expiresAt };
   }
 
   /** 消费配对码：不存在 / 过期 / 不匹配 -> 失败；成功即焚 */
   consumePairingCode(candidate) {
-    const state = this.#readState();
-    this.#state = state;
-    const pair = state.pairingCode;
+    const pair = this.#pairingCode;
     if (!pair || typeof pair.code !== 'string') return { ok: false, reason: 'invalid' };
     if (this.#now() >= Number(pair.expiresAt ?? 0)) {
-      delete state.pairingCode;
-      writeJson0600(this.statePath, state);
+      this.#pairingCode = null;
       return { ok: false, reason: 'expired' };
     }
     if (!timingSafeStringEqual(pair.code, String(candidate ?? ''))) return { ok: false, reason: 'invalid' };
-    delete state.pairingCode;
-    writeJson0600(this.statePath, state);
+    this.#pairingCode = null;
     return { ok: true };
   }
 
@@ -864,13 +866,10 @@ export class StateStore {
    * 握手失败、篡改、超时都不该把码烧掉，只有 confirm 成功才 consume。
    */
   peekPairingCode(candidate) {
-    const state = this.#readState();
-    this.#state = state;
-    const pair = state.pairingCode;
+    const pair = this.#pairingCode;
     if (!pair || typeof pair.code !== 'string') return { ok: false, reason: 'invalid' };
     if (this.#now() >= Number(pair.expiresAt ?? 0)) {
-      delete state.pairingCode;
-      writeJson0600(this.statePath, state);
+      this.#pairingCode = null;
       return { ok: false, reason: 'expired' };
     }
     if (!timingSafeStringEqual(pair.code, String(candidate ?? ''))) return { ok: false, reason: 'invalid' };
@@ -1450,6 +1449,14 @@ export class GroupStore {
     return this.#load().pending.length;
   }
 
+  /** 未提交区的某一条正文（H1：commit 只认这条，不再采信 body 里的 message） */
+  pendingMessage(seq) {
+    const data = this.#load();
+    const id = Math.floor(Number(seq) || 0);
+    const found = data.pending.find((entry) => Number(entry?.seq) === id);
+    return found ? { ...found, from: { ...found.from }, meta: { ...found.meta } } : null;
+  }
+
   /** 未提交区的 seq 列表（只给门面/测试看，不携带正文） */
   pendingSeqs() {
     return this.#load().pending.map((entry) => Number(entry?.seq)).filter((seq) => seq > 0);
@@ -2329,6 +2336,14 @@ export function createPeerServer(overrides = {}) {
     if (senderId !== store.instanceId && !Object.prototype.hasOwnProperty.call(ctx.members, senderId)) {
       // hub 是权威成员表：不认识就是不属于群，一律拒绝（自愈只给成员侧的副本用）
       if (!allowUnknownSender || groupStore) return { ok: false, status: 401, error: 'not-a-member' };
+      // H3：自愈不能再「凭签名把任意 id 写进 group-key.json」。
+      // 只允许**最近一次权威快照**（hub 的 state / pull 的 memberIds）里出现过的 id：
+      // 快照说这个人在群里、只是本机表还停在旧版本 → 补进来；
+      // 快照里根本没有的 id → 仍然 not-a-member（否则一个幽灵 id 就能把自己写进成员表）。
+      if (!authoritativeMemberIds.has(senderId)) {
+        if (config.logger) config.logger(`[group] self-heal refused peer=${shortPeerId(senderId)}`);
+        return { ok: false, status: 401, error: 'not-a-member' };
+      }
       // 自愈（真机 not-a-member 回归）：群密钥签名已经证明对端握有群密钥，只是本机成员表
       // 还停在一份不完整的快照上（成员在 bootstrap 之后才加入）。选举/心跳是领导权协议，
       // 先把它补进成员表，否则对端永远投不进来、整个群选不出 leader。
@@ -4034,11 +4049,47 @@ export function createPeerServer(overrides = {}) {
     if (!Number.isFinite(epoch) || epoch < 0) {
       return { status: 400, body: { error: 'bad-request' }, peerId: auth.peerId };
     }
+    // H2：副本只接「本机认定的 leader」推来的日志。
+    // 少了这道校验，任何握着群密钥的成员都能往别人的副本里写任意历史（第二作者）。
+    const recordedLeader = String(
+      ensureRole()?.leaderPeerId ?? '',
+    ) || String(replicaStore.state().leaderPeerId ?? '');
+    if (recordedLeader === '') {
+      return { status: 409, body: { error: 'no-leader' }, peerId: auth.peerId };
+    }
+    if (auth.peerId !== recordedLeader) {
+      if (config.logger) {
+        config.logger(
+          `[group] replicate refused not-leader from=${shortPeerId(auth.peerId)} leader=${shortPeerId(recordedLeader)}`,
+        );
+      }
+      return { status: 409, body: { error: 'not-leader', leaderPeerId: recordedLeader }, peerId: auth.peerId };
+    }
+    // H2：逐条校验作者在成员表里；不合规的那条丢弃并记一行（不整批拒，避免一条脏数据
+    // 把整次复制卡死 —— 复制是 best-effort 的追赶通道，不是权威写路径）
+    const knownAuthors = new Set(Object.keys(auth.ctx?.members ?? {}));
+    knownAuthors.add(store.instanceId);
+    const incoming = Array.isArray(body.messages) ? body.messages : [];
+    const messages = [];
+    let dropped = 0;
+    for (const message of incoming) {
+      const author = String(message?.from?.peerId ?? '');
+      if (author === '' || !knownAuthors.has(author)) {
+        dropped += 1;
+        continue;
+      }
+      messages.push(message);
+    }
+    if (dropped > 0 && config.logger) {
+      config.logger(
+        `[group] replicate dropped n=${dropped} from=${shortPeerId(auth.peerId)} reason=unknown-author`,
+      );
+    }
     const applied = replicaStore.append({
       groupId,
       epoch: Math.floor(epoch),
       leaderPeerId: String(body.leaderPeerId ?? ''),
-      messages: Array.isArray(body.messages) ? body.messages : [],
+      messages,
     });
     if (config.logger) {
       config.logger(
@@ -4997,15 +5048,41 @@ export function createPeerServer(overrides = {}) {
     }
     const commitSeq = Math.max(0, Math.floor(Number(body.commitSeq) || 0));
     const senderBaseUrl = headerValue(req, GROUP_BASE_HEADER.toLowerCase());
-    rememberPeerBaseUrl(leaderPeerId, senderBaseUrl);
-    // v0.8.0：心跳里 X-Peer-Base 是**发送方自己**的地址 —— 顺手记到发送方名下。
+    // v0.8.0：心跳里 X-Peer-Base 是**发送方自己**的地址 —— 只记到发送方名下。
     // 少了这一笔，成员重启换端口后只有下一次 pull（测试里 600s 一次）才会纠正地址，
     // 期间 leader 的提案会打到旧地址上（表现：post 503 quorum-unavailable，而成员明明在线）。
     rememberMemberBaseUrl(auth.peerId, senderBaseUrl);
     rememberMemberAcceptDispatch(auth.peerId, body.acceptDispatch);
-    if (Number.isFinite(Number(body.priority))) peerPriorities.set(leaderPeerId, Math.floor(Number(body.priority)));
     const st = ensureRole();
     if (!st) return { status: 404, body: { error: 'not-found' }, peerId: auth.peerId };
+    // S2：心跳只能为**自己**续租。少了这条，任何握着群密钥的成员发一条心跳就能把
+    // 对端的 leaderPeerId 改写成任意 id（实测：一句话让对面变 follower、leader 指向别人）。
+    if (leaderPeerId !== auth.peerId) {
+      if (config.logger) {
+        config.logger(
+          `[group] heartbeat refused not-self-leader from=${shortPeerId(auth.peerId)} claim=${shortPeerId(leaderPeerId)} epoch=${epoch}`,
+        );
+      }
+      return { status: 403, body: { error: 'not-self-leader', epoch: st.epoch }, peerId: auth.peerId };
+    }
+    // 地址与优先级也只许写在自己名下（以前 key 用的是 body 里的 leaderPeerId = 别人的 id）
+    rememberPeerBaseUrl(auth.peerId, senderBaseUrl);
+    if (Number.isFinite(Number(body.priority))) peerPriorities.set(auth.peerId, Math.floor(Number(body.priority)));
+    // S2：心跳不得推进 epoch —— epoch 只能由 /v1/group/election 的票数推进。
+    // 心跳带更高的 epoch 就是「靠一句话篡位」，按 stale-epoch 拒，并留一行告警。
+    if (epoch > st.epoch) {
+      noteEpochJump(st.epoch, epoch, 'heartbeat-rejected');
+      if (config.logger) {
+        config.logger(
+          `[group] heartbeat refused epoch-advance from=${shortPeerId(auth.peerId)} epoch=${epoch} keep=${st.epoch}`,
+        );
+      }
+      return {
+        status: 409,
+        body: { error: 'stale-epoch', epoch: st.epoch, leaderPeerId: st.leaderPeerId, commitSeq: st.commitSeq },
+        peerId: auth.peerId,
+      };
+    }
     if (epoch < st.epoch) {
       return {
         status: 409,
@@ -5013,26 +5090,20 @@ export function createPeerServer(overrides = {}) {
         peerId: auth.peerId,
       };
     }
-    if (epoch === st.epoch && st.leaderPeerId !== '' && st.leaderPeerId !== leaderPeerId) {
-      const wins = leaderWins(
-        { peerId: leaderPeerId, priority: priorityOf(leaderPeerId) },
-        { peerId: st.leaderPeerId, priority: priorityOf(st.leaderPeerId) },
-      );
-      if (!wins) {
-        if (config.logger) {
-          config.logger(
-            `[group] heartbeat conflict from=${shortPeerId(leaderPeerId)} epoch=${epoch} keep=${shortPeerId(st.leaderPeerId)}`,
-          );
-        }
-        return {
-          status: 409,
-          body: { error: 'leader-conflict', epoch: st.epoch, leaderPeerId: st.leaderPeerId, commitSeq: st.commitSeq },
-          peerId: auth.peerId,
-        };
-      }
+    // 同 epoch：只有本机记录的 leader 自己来才续租；领导权变更一律走 election 的票数。
+    // （st.leaderPeerId === '' = 本机还没有 leader 记录，这是成员的 bootstrap 路径：
+    //  此时接受发送方自报的 leader，等于把 group-key.json 里已知的那个 leader 学进角色表。）
+    if (st.leaderPeerId !== '' && st.leaderPeerId !== leaderPeerId) {
       if (config.logger) {
-        config.logger(`[group] heartbeat conflict from=${shortPeerId(leaderPeerId)} epoch=${epoch} adopt`);
+        config.logger(
+          `[group] heartbeat conflict from=${shortPeerId(leaderPeerId)} epoch=${epoch} keep=${shortPeerId(st.leaderPeerId)}`,
+        );
       }
+      return {
+        status: 409,
+        body: { error: 'leader-conflict', epoch: st.epoch, leaderPeerId: st.leaderPeerId, commitSeq: st.commitSeq },
+        peerId: auth.peerId,
+      };
     }
     const before = st.commitSeq;
     const accepted = acceptLeader({ epoch, leaderPeerId, commitSeq });
@@ -5159,6 +5230,17 @@ export function createPeerServer(overrides = {}) {
     return { status: 200, body: { ok: true, accepted: true, epoch: st.epoch }, peerId: auth.peerId };
   }
 
+  /**
+   * 本机未提交区里那一条。两条存放路径都要看：
+   *   · propose 收到的提案 → pendingProposals（内存，hub 与成员都走这里）；
+   *   · 本机自己 stage 的（leader 的 post 路径）→ hub 落 group.json.pending，成员落内存表。
+   */
+  function stagedProposal(seq) {
+    const inMemory = pendingProposals.get(seq)?.message ?? null;
+    if (inMemory) return inMemory;
+    return groupStore ? groupStore.pendingMessage(seq) : null;
+  }
+
   /** POST /v1/group/commit —— 提交确认：pending 转正并推进 commitSeq（契约 §5） */
   function groupCommit(req, rawBody, url, auth) {
     const body = parseS3Body(rawBody);
@@ -5175,10 +5257,30 @@ export function createPeerServer(overrides = {}) {
         peerId: auth.peerId,
       };
     }
-    const staged = pendingProposals.get(seq)?.message ?? null;
-    const raw = body.message && typeof body.message === 'object' ? body.message : staged;
-    let applied = false;
-    if (raw) applied = applyCommitted(normalizeIncomingMessage(raw, seq));
+    // H1：与 propose 同口径 —— 只有 leader 能提交。少了这条，任何成员都能把
+    // 自己发明的消息「转正」进别人的日志（并顺手把 commitSeq 抬到任意值）。
+    if (st.leaderPeerId !== '' && auth.peerId !== st.leaderPeerId) {
+      if (config.logger) {
+        config.logger(
+          `[group] commit refused not-leader from=${shortPeerId(auth.peerId)} seq=${seq} epoch=${epoch}`,
+        );
+      }
+      return { status: 409, body: { error: 'not-leader', epoch: st.epoch, commitSeq: st.commitSeq }, peerId: auth.peerId };
+    }
+    // H1：正文只认本机 pending 里那一条 —— body.message 不再被采信，
+    // 客户端也无法用一个没提案过的 seq 抬高 commitSeq。
+    const staged = stagedProposal(seq);
+    if (!staged) {
+      if (seq <= st.commitSeq) {
+        // 幂等：这条早就转正过了（广播重投），不重复应用、不推进号
+        return { status: 200, body: { ok: true, commitSeq: st.commitSeq, applied: false }, peerId: auth.peerId };
+      }
+      if (config.logger) {
+        config.logger(`[group] commit refused unknown-seq from=${shortPeerId(auth.peerId)} seq=${seq} epoch=${epoch}`);
+      }
+      return { status: 409, body: { error: 'unknown-seq', epoch: st.epoch, commitSeq: st.commitSeq }, peerId: auth.peerId };
+    }
+    const applied = applyCommitted(normalizeIncomingMessage(staged, seq));
     pendingProposals.delete(seq);
     const next = roleStore.update({
       commitSeq: Math.max(st.commitSeq, seq),

package/host/test/auth.test.mjs

@@ -350,7 +350,8 @@ test('§3/§2 配对码：6 位数字、10 分钟、一次性；成功后写入
 
   const statePath = path.join(stateDir, 'state.json');
   if (process.platform !== 'win32') assert.equal(fileMode(statePath), 0o600);
-  assert.equal(readJson(statePath).pairingCode.code, issued.code);
+  // M6：配对码只活在进程内存里 —— state.json 里绝不能出现它（重启即失效、也无法被预置）
+  assert.equal(readJson(statePath).pairingCode, undefined, 'M6：配对码不落盘');
 
   const pairBody = {
     code: issued.code,
@@ -453,20 +454,33 @@ test('§3 配对 body 缺字段 → 400；码格式不对 / 没发码 → 401 in
   assert.equal(badFormat.json.error, 'invalid-code');
 });
 
-test('配对码由另一个进程（CLI）写入时，正在运行的 server 也能看到', async (t) => {
+test('M6 配对码不再经 state.json 传递：另一个进程写入的码不被采信（进程内码照常可用）', async (t) => {
   const stateDir = makeTempStateDir();
-  const { baseUrl } = await startServer(t, { stateDir, name: 'nas-box' });
+  const { server, baseUrl } = await startServer(t, { stateDir, name: 'nas-box' });
 
-  // 模拟 `lan-peers code` 在另一个进程里写 state.json
-  const { code } = issuePairingCode({ stateDir, name: 'nas-box' });
+  // 同机另一个进程（CLI/别的身份）往 state.json 里塞一枚码：这是 M6 要堵的植入路径
+  const forged = issuePairingCode({ stateDir, name: 'nas-box' });
+  const onDisk = readJson(path.join(stateDir, 'state.json'));
+  assert.equal(onDisk.pairingCode, undefined, 'M6：issuePairingCode 不再往 state.json 写码');
 
+  const refused = await request(baseUrl, {
+    method: 'POST',
+    path: '/v1/pair',
+    signed: false,
+    body: { code: forged.code, peerId: 'peer-cli', peerName: 'CLI', secret: 's-cli' },
+  });
+  assert.equal(refused.status, 401, refused.text);
+  assert.equal(refused.json.error, 'invalid-code', '另一个进程发的码不能配到这台 server');
+
+  // 本进程发的码照常能用（配对流程本身没变）
+  const ours = server.issuePairingCode();
   const paired = await request(baseUrl, {
     method: 'POST',
     path: '/v1/pair',
     signed: false,
-    body: { code, peerId: 'peer-cli', peerName: 'CLI', secret: 's-cli' },
+    body: { code: ours.code, peerId: 'peer-cli', peerName: 'CLI', secret: 's-cli' },
   });
-  assert.equal(paired.status, 200);
+  assert.equal(paired.status, 200, paired.text);
   assert.equal(readJson(path.join(stateDir, 'state.json')).pairingCode, undefined);
 });
 

package/host/test/group-applications-admin.test.mjs

@@ -32,17 +32,19 @@ function makeResponse() {
 }
 
 /** 回环 admin 请求（与 GUI 面板同一个 handle 入口） */
-function makeRequest(method, apiPath, body) {
+function makeRequest(method, apiPath, body, admin) {
   const chunks = body === undefined ? [] : [Buffer.from(JSON.stringify(body))];
+  const token = admin && typeof admin.token === 'string' ? admin.token : '';
   const req = {
     method,
     url: apiPath,
     socket: { remoteAddress: '127.0.0.1', setNoDelay() {} },
-    // 回环 authority：admin 用 Host 头做回环门控
+    // 回环 authority + 进程 token：S3 之后两道门都要过（面板带的就是这两个头）
     headers: {
       host: '127.0.0.1:7788',
       'content-type': 'application/json',
       'content-length': String(chunks[0]?.length ?? 0),
+      ...(token === '' ? {} : { 'x-lan-peers-token': token }),
     },
     on() { return req; },
     once() { return req; },
@@ -53,7 +55,7 @@ function makeRequest(method, apiPath, body) {
 
 async function hit(admin, method, apiPath, body) {
   const res = makeResponse();
-  const handled = await admin.handle(makeRequest(method, apiPath, body), res, new URL('http://127.0.0.1' + apiPath));
+  const handled = await admin.handle(makeRequest(method, apiPath, body, admin), res, new URL('http://127.0.0.1' + apiPath));
   let json = null;
   try { json = JSON.parse(res.body); } catch { json = null; }
   return { handled, status: res.status, json };