@mrrisega/dsh-remote 0.7.12-beta.4 → 0.7.12-beta.6

package/clients/dsh-remote/test/dingtalk-bot.test.mjs

@@ -49,6 +49,11 @@ const FAKE_CLIENT = "ding-fake-client-id";
 
 function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
 
+/** 读 JSON 文件（不存在/坏 JSON → null）。 */
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; }
+}
+
 async function waitFor(fn, { label = "条件", timeout = 5000, interval = 20 } = {}) {
   const t0 = Date.now();
   for (;;) {
@@ -162,7 +167,7 @@ async function startWebhook(payload = { errcode: 0, errmsg: "ok" }, status = 200
 /** 最小 fake 订阅器（与 bridge 里 dsh-events 的对外接口同形）。 */
 function fakeSubscriber({ sessions = [{ sessionId: "session-live", running: true, title: "活跃会话" }], answer = "这是 agent 的最终回答" } = {}) {
   const emitter = new EventEmitter();
-  const calls = { prompt: [], listSessions: 0, lastAssistant: 0 };
+  const calls = { prompt: [], listSessions: 0, lastAssistant: 0, cancel: [] };
   return {
     on(evt, fn) { emitter.on(evt, fn); return this; },
     once(evt, fn) { emitter.once(evt, fn); return this; },
@@ -172,6 +177,7 @@ function fakeSubscriber({ sessions = [{ sessionId: "session-live", running: true
     sessions() { return sessions.map((s) => s.sessionId); },
     async listSessions() { calls.listSessions += 1; return { ok: true, sessions }; },
     async promptSession({ sessionId, text }) { calls.prompt.push({ sessionId, text }); return { ok: true }; },
+    async cancelSession({ sessionId } = {}) { calls.cancel.push({ sessionId }); return { ok: true }; },
     async lastAssistantText() { calls.lastAssistant += 1; return { ok: true, text: answer }; },
     calls
   };
@@ -553,6 +559,185 @@ test("controller：DSH_IM_BOTS=0 全关（env 优先）", async () => {
 
 // ─────────────────────────── 常量/默认值 ───────────────────────────
 
+// ─────────────────── 回复通道三层降级（2026-11-08 实测 bug：回答回传发不出） ───────────────────
+
+/** 包一层 fetch：把 openapi（accessToken / oToMessages / groupMessages）拦成本地假响应并记录。 */
+function makeOpenapiFetch() {
+  const calls = [];
+  const fetchImpl = (url, init) => {
+    const u = String(url);
+    if (u.includes("/oauth2/accessToken")) {
+      calls.push({ kind: "token", url: u, body: init && init.body });
+      return Promise.resolve({ ok: true, status: 200, json: async () => ({ accessToken: "tok-123", expireIn: 7200 }) });
+    }
+    if (u.includes("/robot/oToMessages/batchSend") || u.includes("/robot/groupMessages/send")) {
+      let body = null;
+      try { body = JSON.parse(init && init.body ? init.body : "{}"); } catch { body = null; }
+      calls.push({ kind: "send", url: u, body, headers: init && init.headers });
+      return Promise.resolve({ ok: true, status: 200, json: async () => ({ processQueryKey: "pq-1" }) });
+    }
+    return fetch(url, init);
+  };
+  return { fetchImpl, calls };
+}
+
+test("★ 回复通道①：入站缓存 sessionWebhook → 回答回传直接 POST 它（跨重启保持）", async () => {
+  const relayDir = tmpRelayDir();
+  const hook = await startWebhook();
+  const gateway = await startGateway();
+  const sub = fakeSubscriber({ answer: "重启后也要能回传答案" });
+  const botOptions = {
+    clientId: FAKE_CLIENT, clientSecret: FAKE_SECRET, robotCode: "ding-robot",
+    gatewayUrl: gateway.openUrl, relayDir, subscriber: sub,
+    logger: () => {}, reconnectBaseMs: 40, reconnectMaxMs: 160, tierDenyThrottleMs: 0
+  };
+  const bot1 = createDingtalkBot(botOptions);
+  try {
+    bot1.start();
+    await waitFor(() => bot1.status().connected, { label: "连接1" });
+    gateway.push({
+      type: "CALLBACK", headers: { messageId: "mid-c1", topic: TOPIC_ROBOT },
+      data: JSON.stringify({
+        conversationId: "cid-1", conversationType: "2", senderStaffId: "staff-9",
+        msgtype: "text", msgId: "m-c1", text: { content: "你好" },
+        sessionWebhook: hook.url, sessionWebhookExpiredTime: Date.now() + 5 * 60_000
+      })
+    });
+    await waitFor(() => hook.state.calls.length >= 1, { label: "被动回复" });
+    const st1 = bot1.status();
+    assert.equal(st1.replyChannel.kind, "sessionWebhook");
+    assert.equal(st1.replyChannel.hasWebhook, true);
+    await bot1.stop();
+  } finally {
+    await gateway.close();
+  }
+  // 重启（新进程语义）：只靠磁盘缓存也要能回传
+  const gateway2 = await startGateway();
+  const bot2 = createDingtalkBot({ ...botOptions, gatewayUrl: gateway2.openUrl });
+  try {
+    bot2.start();
+    await waitFor(() => bot2.status().connected, { label: "连接2" });
+    assert.equal(bot2.status().replyChannel.kind, "sessionWebhook", "★ 重启后回复通道来自持久化缓存");
+    const before = hook.state.calls.length;
+    const r = await bot2.sendMarkdown("重启后的回答回传");
+    assert.equal(r.ok, true);
+    assert.equal(r.kind, "sessionWebhook");
+    await waitFor(() => hook.state.calls.length > before, { label: "重启后回传到 webhook" });
+    assert.match(hook.last().body.markdown.text, /重启后的回答回传/);
+  } finally {
+    await bot2.stop();
+    await gateway2.close();
+    await hook.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
+test("★ 回复通道②：sessionWebhook 过期 → 降级 openapi（userIds=[senderStaffId]）", async () => {
+  const relayDir = tmpRelayDir();
+  const gateway = await startGateway();
+  const hook = await startWebhook();
+  const api = makeOpenapiFetch();
+  const sub = fakeSubscriber({ answer: "x" });
+  const bot = createDingtalkBot({
+    clientId: FAKE_CLIENT, clientSecret: FAKE_SECRET, robotCode: "ding-robot",
+    gatewayUrl: gateway.openUrl, relayDir, subscriber: sub,
+    fetchImpl: api.fetchImpl, logger: () => {},
+    reconnectBaseMs: 40, reconnectMaxMs: 160, tierDenyThrottleMs: 0
+  });
+  try {
+    bot.start();
+    await waitFor(() => bot.status().connected, { label: "连接" });
+    gateway.push({
+      type: "CALLBACK", headers: { messageId: "mid-exp", topic: TOPIC_ROBOT },
+      data: JSON.stringify({
+        conversationId: "cid-exp", conversationType: "1", senderStaffId: "staff-exp",
+        msgtype: "text", msgId: "m-exp", text: { content: "hi" },
+        sessionWebhook: hook.url, sessionWebhookExpiredTime: Date.now() - 1000 // 已过期
+      })
+    });
+    await waitFor(() => bot.status().messages >= 1, { label: "入站" });
+    assert.equal(bot.status().replyChannel.kind, "openapi", "★ webhook 过期 → 显示 openapi 可用");
+    const hookCalls = hook.state.calls.length;
+    const r = await bot.sendMarkdown("降级 openapi 回答");
+    assert.equal(r.ok, true);
+    assert.equal(r.kind, "openapi");
+    const send = api.calls.filter((c) => c.kind === "send");
+    assert.equal(send.length, 1);
+    assert.deepEqual(send[0].body.userIds, ["staff-exp"], "★ 用缓存的 senderStaffId 发单聊");
+    assert.match(send[0].headers["x-acs-dingtalk-access-token"], /tok-123/);
+    assert.equal(hook.state.calls.length, hookCalls, "过期 webhook 不得再被调用");
+  } finally {
+    await bot.stop(); await gateway.close(); await hook.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
+test("★ 回复通道③：webhook 与 openapi 都不可用 → 明确日志 no_reply_channel + 状态人话（不静默）", async () => {
+  const relayDir = tmpRelayDir();
+  const gateway = await startGateway();
+  const logs = [];
+  const bot = createDingtalkBot({
+    clientId: FAKE_CLIENT, clientSecret: FAKE_SECRET, robotCode: "", // 无 robotCode
+    gatewayUrl: gateway.openUrl, relayDir,
+    logger: (level, line) => logs.push(line),
+    reconnectBaseMs: 40, reconnectMaxMs: 160, tierDenyThrottleMs: 0
+  });
+  try {
+    bot.start();
+    await waitFor(() => bot.status().connected, { label: "连接" });
+    const r = await bot.sendMarkdown("发不出去的");
+    assert.equal(r.ok, false);
+    assert.match(String(r.reason), /no_reply_channel|no_robot_code|no_target_user|no_webhook/);
+    await waitFor(() => logs.join("\n").match(/no_reply_channel|no_robot_code/), { label: "明确日志" });
+    const st = bot.status();
+    assert.equal(st.replyChannel.kind, "none");
+    assert.ok(String(st.replyChannel.lastError || "").length > 0, "状态要有人话原因");
+    const stFile = readJson(path.join(relayDir, IM_BOT_STATUS_FILE));
+    assert.equal(stFile.dingtalk.replyChannel.kind, "none");
+    assert.match(String(stFile.dingtalk.replyChannel.lastError || ""), /回复通道|robotCode/, "面板可显示可操作原因（补 robotCode / 再发一条消息激活）");
+  } finally {
+    await bot.stop(); await gateway.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
+test("★ 脱敏：日志/状态只出现 webhook host 与哈希，不含整条 webhook URL 或 secret", async () => {
+  const relayDir = tmpRelayDir();
+  const gateway = await startGateway();
+  const logs = [];
+  const sub = fakeSubscriber();
+  const bot = createDingtalkBot({
+    clientId: FAKE_CLIENT, clientSecret: FAKE_SECRET, robotCode: "ding-robot",
+    gatewayUrl: gateway.openUrl, relayDir, subscriber: sub,
+    logger: (level, line) => logs.push(line),
+    reconnectBaseMs: 40, reconnectMaxMs: 160, tierDenyThrottleMs: 0
+  });
+  try {
+    bot.start();
+    await waitFor(() => bot.status().connected, { label: "连接" });
+    const webhookUrl = "https://oapi.dingtalk.test/robot/sendBySession?session=TOKEN-SECRET-AAA";
+    gateway.push({
+      type: "CALLBACK", headers: { messageId: "mid-sec", topic: TOPIC_ROBOT },
+      data: JSON.stringify({
+        conversationId: "cid-sec", conversationType: "1", senderStaffId: "staff-sec",
+        msgtype: "text", msgId: "m-sec", text: { content: "hi" },
+        sessionWebhook: webhookUrl, sessionWebhookExpiredTime: Date.now() + 60_000
+      })
+    });
+    await waitFor(() => bot.status().messages >= 1, { label: "入站" });
+    await waitFor(() => logs.join("\n").includes("oapi.dingtalk.test"), { label: "host 日志" });
+    const joined = logs.join("\n");
+    assert.ok(!joined.includes("TOKEN-SECRET-AAA"), "★ 日志不得含 webhook 会话令牌");
+    assert.ok(!joined.includes(FAKE_SECRET), "★ 日志不得含 clientSecret");
+    const raw = fs.readFileSync(path.join(relayDir, IM_BOT_STATUS_FILE), "utf8");
+    assert.ok(!raw.includes("TOKEN-SECRET-AAA"), "★ 状态文件不得含 webhook 原值");
+    assert.ok(!raw.includes(FAKE_SECRET));
+  } finally {
+    await bot.stop(); await gateway.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
 // ─────────────────── robotCode 可选（扫码一键创建机器人，2026-11-08） ───────────────────
 
 test("★ robotCode 可选：只给 clientId/clientSecret 也能启动、收/回消息；状态 capabilities 如实降级", async () => {
@@ -628,3 +813,35 @@ test("常量：默认 open 端点 / ticket 90s / 退避 1s→60s", () => {
   assert.equal(TICKET_TTL_MS, 90_000);
   assert.equal(TOPIC_ROBOT, "/v1.0/im/bot/messages/get");
 });
+
+// ─────────────────────── 命令层（2026-11-08：/ls 不再转给模型）───────────────────────
+
+test("★ 命令层：/help 回复、免费档 /ls 被拦（会员文案）、/stop 免费急停；命令不进 promptSession", async () => {
+  const rt = await setupBot();
+  try {
+    await rt.start();
+    const pushCmd = async (msgId, text) => {
+      rt.gateway.push({
+        type: "CALLBACK", headers: { messageId: `mid-${msgId}`, topic: TOPIC_ROBOT },
+        data: JSON.stringify({
+          conversationId: "cid-cmd", conversationType: "2", senderStaffId: "staff-cmd",
+          msgtype: "text", msgId: `m-${msgId}`, text: { content: text },
+          sessionWebhook: rt.hook.url, sessionWebhookExpiredTime: Date.now() + 60_000
+        })
+      });
+    };
+    pushCmd("help", "/help");
+    await waitFor(() => rt.hook.state.calls.find((c) => /可用命令/.test(c.body.markdown.text)), { label: "/help 回复" });
+    assert.equal(rt.sub.calls.prompt.length, 0, "★ 命令不得进模型");
+    pushCmd("ls", "/ls");
+    await waitFor(() => rt.hook.state.calls.find((c) => /会员功能/.test(c.body.markdown.text)), { label: "/ls 会员拦截" });
+    assert.equal(rt.sub.calls.prompt.length, 0);
+    pushCmd("stop", "/stop");
+    await waitFor(() => rt.hook.state.calls.find((c) => /已急停|没有正在运行/.test(c.body.markdown.text)), { label: "/stop 回复" });
+    assert.equal(rt.sub.calls.cancel.length, 1, "★ /stop 调 cancelSession");
+    assert.equal(rt.sub.calls.prompt.length, 0);
+    // 普通文本照旧转发
+    await rt.inbound({ text: "帮我看看日志", msgId: "m-normal-cmd" });
+    await waitFor(() => rt.sub.calls.prompt.length === 1, { label: "普通文本转发" });
+  } finally { await rt.close(); }
+});

package/clients/dsh-remote/test/feishu-bot.test.mjs

@@ -152,7 +152,7 @@ function makeFetch({ tokenCode = 0, sendCode = 0, sendMsg = "", patchCode = 0 }
 // ── 假事件订阅器 ──────────────────────────────────────────────────────────
 function makeSubscriber() {
   const emitter = new EventEmitter();
-  const calls = { sessions: [], prompts: [], started: 0, stopped: 0, listenSessions: 0 };
+  const calls = { sessions: [], prompts: [], cancels: [], started: 0, stopped: 0, listenSessions: 0 };
   return {
     calls,
     on: (evt, cb) => emitter.on(evt, cb),
@@ -161,7 +161,8 @@ function makeSubscriber() {
     stop() { calls.stopped += 1; },
     sessions() { return ["session-abc"]; },
     async listSessions() { calls.listenSessions += 1; return [{ sessionId: "session-abc", title: "t" }]; },
-    async promptSession(req) { calls.prompts.push(req); return { ok: true }; }
+    async promptSession(req) { calls.prompts.push(req); return { ok: true }; },
+    async cancelSession(req) { calls.cancels.push(req); return { ok: true }; }
   };
 }
 
@@ -1087,3 +1088,34 @@ test("向导：主路径只有两件事（填 App ID/Secret + 发一句话自动
   assert.match(FEISHU_SETUP_GUIDE.oneAppOnePc, /一台电脑/);
   assert.match(FEISHU_SETUP_GUIDE.docs.registerApp, /open\.feishu\.cn\/app/);
 });
+
+// ─────────────────────── 命令层（2026-11-08：/ls 不再转给模型）───────────────────────
+
+test("controller：命令层 — /help 直接回复、免费档 /ls 被拦、/stop 急停；命令绝不进模型", async () => {
+  const relayDir = mkRelayDir("ctl-cmd");
+  writeConfig(relayDir, { enabled: true, appId: APP_ID, appSecret: APP_SECRET, receiveId: "oc_chat_1", receiveIdType: "chat_id" });
+  const sub = makeSubscriber();
+  const { controller, fetchCalls } = startController(relayDir, { subscriber: sub, capsProvider: async () => "free" });
+  await controller.start();
+  const lastText = () => {
+    const rows = fetchCalls.filter((c) => c.url.includes("/im/v1/messages") && JSON.parse(c.body).msg_type === "text");
+    return rows.length ? JSON.parse(rows[rows.length - 1].body).content : "";
+  };
+  controller._bot()._dispatch("im.message.receive_v1", inboundText("/help"));
+  await waitFor(() => /可用命令/.test(lastText()));
+  assert.match(lastText(), /可用命令/);
+  assert.equal(sub.calls.prompts.length, 0, "★ 命令不得进模型");
+  controller._bot()._dispatch("im.message.receive_v1", inboundText("/ls"));
+  await waitFor(() => /会员功能/.test(lastText()));
+  assert.match(lastText(), /会员功能/, "免费档 /ls 必须被拦");
+  assert.equal(sub.calls.prompts.length, 0);
+  controller._bot()._dispatch("im.message.receive_v1", inboundText("/stop"));
+  await waitFor(() => /已急停|没有正在运行/.test(lastText()));
+  assert.equal(sub.calls.cancels.length, 1, "★ /stop 调 cancelSession");
+  assert.equal(sub.calls.prompts.length, 0, "★ 全部命令都不进模型");
+  // 普通文本照旧转发
+  controller._bot()._dispatch("im.message.receive_v1", inboundText("继续跑"));
+  await waitFor(() => sub.calls.prompts.length === 1);
+  assert.equal(sub.calls.prompts.length, 1);
+  await controller.stop();
+});

package/clients/dsh-remote/test/im-caps-fixture.mjs

@@ -0,0 +1,8 @@
+/** 测试共用的能力集夹具（与 wechat-runtime 的 WECHAT_CAPABILITY_TABLE 对齐，避免各测试各抄一份）。 */
+export function freeCaps() {
+  return ["notify", "approve", "status", "stop", "assign.continue"];
+}
+
+export function paidCaps() {
+  return ["notify", "approve", "status", "stop", "assign", "sessions", "summary", "steer", "attach", "multi"];
+}

package/clients/dsh-remote/test/im-commands.test.mjs

@@ -0,0 +1,283 @@
+/**
+ * im-commands — 三家 IM 机器人共用命令层单测（2026-11-08）。
+ *
+ * 纯函数 + 注入式执行器，覆盖：解析（大小写/参数/未知）、/help 全命令、未知命令不转发、
+ * 免费档 /ls /use 被拦 + 升级文案、/stop 免费立即生效、/use 越界/缺参、/status 与快照同源、
+ * /unbind 免费、命令回复不含裸表格、写配置 sessionId（保留其它段）。
+ */
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  IM_COMMANDS,
+  commandAllowed,
+  executeImCommand,
+  helpText,
+  lsText,
+  parseImCommand,
+  writeImBotsSession
+} from "../im-commands.mjs";
+import { freeCaps, paidCaps } from "./im-caps-fixture.mjs";
+import { fileMode } from "../wecom-bot.mjs";
+
+function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), "dsh-imcmd-")); }
+
+function sessionsFixture() {
+  const rows = [
+    { sessionId: "session-alpha", title: "重构支付回调链路（很长的标题会被截断到二十四字以内）", updatedAt: Date.UTC(2026, 10, 8, 1, 30), running: true },
+    { sessionId: "session-beta", title: "修端口探测", updatedAt: Date.UTC(2026, 10, 7, 22, 0) },
+    { sessionId: "session-gamma", title: "写测试", updatedAt: 0 }
+  ];
+  return async () => rows;
+}
+
+/** 一个记录调用的 ctx（各用例按需覆盖）。 */
+function makeCtx(over = {}) {
+  const calls = { switch: [], cancel: [], unbind: 0 };
+  const ctx = {
+    caps: freeCaps(),
+    tier: "free",
+    appUrl: "https://app.test/",
+    channelLabel: "钉钉",
+    sessions: sessionsFixture(),
+    currentSessionId: () => "session-alpha",
+    currentSessionTitle: "重构支付回调链路",
+    switchSession: async (arg) => { calls.switch.push(arg); return { ok: true }; },
+    cancelSession: async (arg) => { calls.cancel.push(arg); return { ok: true }; },
+    unbind: async () => { calls.unbind += 1; return { ok: true }; },
+    statusSnapshot: async () => ({
+      connected: true, authenticated: true, state: "connected", lastError: "",
+      tier: "free", usage: { month: "2026-11", messages: 3 }, messagesPerMonth: 20, remainingMessages: 17,
+      currentSessionId: "session-alpha", currentSessionTitle: "重构支付回调链路"
+    }),
+    ...over
+  };
+  return { ctx, calls };
+}
+
+const run = (text, ctx) => executeImCommand({ text, ctx });
+const assertNoRawTable = (text) => {
+  assert.ok(!/\|\s*-{2,}/.test(text), `不得含表格分隔行：${text}`);
+  assert.ok(!/^\s*\|.*\|\s*$/m.test(text), `不得含裸表格行：${text}`);
+};
+
+// ─────────────────────────── 解析 ───────────────────────────
+
+test("parseImCommand：命令/大小写/参数/未知；普通文本返回 null", () => {
+  assert.deepEqual(parseImCommand("/help"), { name: "/help", arg: "", rest: "", unknown: false, raw: "/help" });
+  assert.equal(parseImCommand("/HELP").name, "/help", "大小写不敏感");
+  assert.equal(parseImCommand("  /Status  ").name, "/status");
+  assert.equal(parseImCommand("/use 3").arg, "3");
+  assert.equal(parseImCommand("/use").arg, "");
+  assert.equal(parseImCommand("/use   abc").arg, "abc");
+  assert.equal(parseImCommand("/ls 额外 参数").arg, "额外");
+  assert.equal(parseImCommand("/").unknown, true, "光一个 / 算未知命令");
+  assert.equal(parseImCommand("/wat").unknown, false);
+  assert.equal(parseImCommand("hello"), null, "普通文本不是命令");
+  assert.equal(parseImCommand("ls"), null);
+  assert.equal(parseImCommand("  /help 看下  ").arg, "看下");
+});
+
+// ─────────────────────────── /help / 未知 ───────────────────────────
+
+test("★ /help：列出全部命令（免费/会员标注），免费档看到会员命令标注", async () => {
+  const { ctx } = makeCtx();
+  const r = await run("/help", ctx);
+  assert.equal(r.handled, true);
+  assert.equal(r.ok, true);
+  for (const c of IM_COMMANDS) assert.ok(r.text.includes(c.usage), `/help 必须包含 ${c.usage}`);
+  assert.match(r.text, /命令不会发给模型/);
+  assert.match(r.text, /\/stop/);
+  assert.match(r.text, /\/unbind/);
+  assert.match(r.text, /会员/, "免费档要标注会员命令");
+  assertNoRawTable(r.text);
+});
+
+test("★ 未知命令：不转发给模型（handled=true），回「未知命令 + 帮助」", async () => {
+  let promptCalls = 0;
+  const { ctx } = makeCtx();
+  const r = await run("/deploy now", ctx);
+  assert.equal(r.handled, true, "★ 未知 /xxx 必须被命令层拦下");
+  assert.ok(promptCalls === 0);
+  assert.match(r.text, /未知命令：\/deploy/);
+  assert.match(r.text, /\/help/);
+  assertNoRawTable(r.text);
+  // 非命令文本仍返回 handled:false（照旧进模型）
+  const normal = await run("帮我改一下代码", ctx);
+  assert.deepEqual(normal, { handled: false });
+});
+
+// ─────────────────────────── 能力门禁 ───────────────────────────
+
+test("★ 免费档 /ls、/use 被拦：回会员文案 + /app/promo；命令不进模型", async () => {
+  const { ctx } = makeCtx();
+  const ls = await run("/ls", ctx);
+  assert.equal(ls.handled, true);
+  assert.equal(ls.gated, true);
+  assert.match(ls.text, /会员功能/);
+  assert.match(ls.text, /https:\/\/app\.test\/promo/);
+  assert.match(ls.text, /免费可用/);
+  assertNoRawTable(ls.text);
+  const use = await run("/use 1", ctx);
+  assert.equal(use.gated, true);
+  assert.match(use.text, /\/use 是会员功能/);
+  // 免费命令不受影响
+  for (const cmd of ["/help", "/status", "/stop", "/unbind"]) {
+    const r = await run(cmd, ctx);
+    assert.equal(r.gated, undefined, `${cmd} 必须免费可用`);
+    assert.equal(r.handled, true);
+  }
+});
+
+// ─────────────────────────── /ls ───────────────────────────
+
+test("★ /ls（会员）：≤10 条、标题截断 24、索引 + 当前标记 + 更新时间；不含裸表格", async () => {
+  const many = Array.from({ length: 15 }, (_, i) => ({ sessionId: `session-${i}`, title: `会话 ${i} 号很长的标题需要被截断处理一下`, updatedAt: Date.UTC(2026, 10, 8, 10, i % 60) }));
+  const { ctx } = makeCtx({ caps: paidCaps(), sessions: async () => many, currentSessionId: () => "session-3" });
+  const r = await run("/ls", ctx);
+  assert.equal(r.ok, true);
+  const lines = r.text.split("\n").filter((l) => /^\d+\. /.test(l));
+  assert.equal(lines.length, 10, "最多 10 条");
+  assert.match(r.text, /1\. 会话 0 号/);
+  assert.match(r.text, /4\. 会话 3 号[^\n]*（当前）/, "当前会话要有标记");
+  assert.match(r.text, /· \d{2}-\d{2} \d{2}:\d{2}/, "带更新时间");
+  for (const line of lines) {
+    const titlePart = line.replace(/^\d+\. /, "").split(" ")[0];
+    assert.ok(Array.from(titlePart.replace(/…$/, "")).length <= 24, `标题超过 24 字：${line}`);
+  }
+  assert.match(r.text, /\/use <序号>/);
+  assertNoRawTable(r.text);
+});
+
+test("/ls：没有会话时给可操作提示", async () => {
+  const { ctx } = makeCtx({ caps: paidCaps(), sessions: async () => [] });
+  const r = await run("/ls", ctx);
+  assert.equal(r.ok, true);
+  assert.match(r.text, /最近没有可列出的会话/);
+  assert.match(r.text, /打开\/运行一个会话/);
+});
+
+// ─────────────────────────── /use ───────────────────────────
+
+test("★ /use <N>：合法序号切换（写配置由 ctx.switchSession 完成）+ 回执", async () => {
+  const { ctx, calls } = makeCtx({ caps: paidCaps() });
+  const r = await run("/use 2", ctx);
+  assert.equal(r.ok, true);
+  assert.deepEqual(calls.switch, [{ sessionId: "session-beta", title: "修端口探测" }]);
+  assert.match(r.text, /已切换到 #2 修端口探测/);
+});
+
+test("★ /use 越界 / 缺参 / 无会话：给可操作提示，不崩", async () => {
+  const { ctx, calls } = makeCtx({ caps: paidCaps() });
+  const out = await run("/use 99", ctx);
+  assert.equal(out.ok, true, "越界是提示不是崩溃");
+  assert.match(out.text, /序号超出范围：当前列表是 1-3/);
+  assert.match(out.text, /\/ls/);
+  assert.equal(calls.switch.length, 0);
+  const missing = await run("/use", ctx);
+  assert.match(missing.text, /用法：\/use <序号>/);
+  const none = await run("/use 1", makeCtx({ caps: paidCaps(), sessions: async () => [] }).ctx);
+  assert.match(none.text, /没有可切换的会话/);
+  const failing = await run("/use 1", makeCtx({ caps: paidCaps(), switchSession: async () => ({ ok: false, reason: "写配置失败" }) }).ctx);
+  assert.match(failing.text, /切换失败：写配置失败/);
+});
+
+// ─────────────────────────── /stop / /status / /unbind ───────────────────────────
+
+test("★ /stop：免费可用、立即调 cancelSession、回执明确（没会话给说明）", async () => {
+  const { ctx, calls } = makeCtx();
+  const r = await run("/stop", ctx);
+  assert.equal(r.ok, true);
+  assert.deepEqual(calls.cancel, [{ sessionId: "session-alpha" }]);
+  assert.match(r.text, /已急停：重构支付回调链路/);
+  // 无会话
+  const none = await run("/stop", makeCtx({ currentSessionId: () => "" }).ctx);
+  assert.match(none.text, /没有正在运行的会话/);
+  // 取消失败要给"没收到确认"
+  const fail = await run("/stop", makeCtx({ cancelSession: async () => ({ ok: false, message: "通道断开" }) }).ctx);
+  assert.match(fail.text, /没收到确认：通道断开/);
+});
+
+test("★ /status：连接状态 + 当前会话 + 本月剩余（与状态快照同源；不限量显示不限）", async () => {
+  const { ctx } = makeCtx();
+  const r = await run("/status", ctx);
+  assert.equal(r.ok, true);
+  assert.match(r.text, /连接状态/);
+  assert.match(r.text, /✅ 已连接/);
+  assert.match(r.text, /当前会话：重构支付回调链路/);
+  assert.match(r.text, /本月指令：已用 3\/20/);
+  assert.match(r.text, /剩余：17 条/);
+  assertNoRawTable(r.text);
+  // 付费不限量
+  const pro = await run("/status", makeCtx({
+    caps: paidCaps(), tier: "pro",
+    statusSnapshot: async () => ({ connected: false, state: "reconnecting", tier: "pro", usage: { messages: 0 }, messagesPerMonth: 0, currentSessionId: "" })
+  }).ctx);
+  assert.match(pro.text, /未连接（reconnecting/);
+  assert.match(pro.text, /本月指令：不限（pro）/);
+  assert.match(pro.text, /当前会话：未选择/);
+});
+
+test("★ /unbind：免费可用、任何人可退订（调 unbind + 明确回执）", async () => {
+  const { ctx, calls } = makeCtx();
+  const r = await run("/unbind", ctx);
+  assert.equal(r.ok, true);
+  assert.equal(calls.unbind, 1);
+  assert.match(r.text, /已解绑/);
+  assert.match(r.text, /重新绑定/);
+});
+
+// ─────────────────────────── 执行器健壮性 / 配置写入 ───────────────────────────
+
+test("执行器：ctx 抛错也返回 handled:true（命令层绝不把异常漏给模型）", async () => {
+  const r = await run("/ls", makeCtx({ caps: paidCaps(), sessions: async () => { throw new Error("订阅器挂了"); } }).ctx);
+  assert.equal(r.handled, true);
+  assert.match(r.text, /命令执行失败：订阅器挂了/);
+});
+
+test("★ writeImBotsSession：写对应通道的 sessionId/sessionTitle（保留其它段，0600）", () => {
+  const dir = tmpDir();
+  try {
+    fs.writeFileSync(path.join(dir, "im-bots.json"), JSON.stringify({
+      version: 1,
+      wecom: { enabled: true, botId: "b" },
+      dingtalk: { enabled: true, clientId: "c" },
+      feishu: { enabled: false }
+    }), { mode: 0o600 });
+    const r = writeImBotsSession(dir, "dingtalk", { sessionId: "session-beta", sessionTitle: "修端口探测" });
+    assert.equal(r.ok, true);
+    const disk = JSON.parse(fs.readFileSync(path.join(dir, "im-bots.json"), "utf8"));
+    assert.equal(disk.dingtalk.sessionId, "session-beta");
+    assert.equal(disk.dingtalk.sessionTitle, "修端口探测");
+    assert.equal(disk.dingtalk.clientId, "c", "其它字段保留");
+    assert.equal(disk.wecom.botId, "b", "其它通道段保留");
+    if (process.platform !== "win32") assert.equal(fileMode(path.join(dir, "im-bots.json")) & 0o777, 0o600);
+    // 非法参数
+    assert.equal(writeImBotsSession(dir, "", {}).ok, false);
+    assert.equal(writeImBotsSession(dir, "dingtalk", { sessionId: "" }).ok, false);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("helpText/commandAllowed：能力表判断与 /help 文案一致（单一真相源）", () => {
+  assert.equal(commandAllowed(IM_COMMANDS.find((c) => c.name === "/stop"), []), true, "急停不需要能力");
+  assert.equal(commandAllowed(IM_COMMANDS.find((c) => c.name === "/ls"), freeCaps()), false);
+  assert.equal(commandAllowed(IM_COMMANDS.find((c) => c.name === "/ls"), paidCaps()), true);
+  const paidHelp = helpText({ caps: paidCaps(), appUrl: "https://a/" });
+  assert.match(paidHelp, /你的档位已包含会话管理/);
+  const freeHelp = helpText({ caps: freeCaps() });
+  assert.ok(!/已包含会话管理/.test(freeHelp));
+});
+
+test("三家接线（源级契约）：wecom/dingtalk/feishu 都在进模型前调用命令层", () => {
+  for (const file of ["wecom-bot.mjs", "dingtalk-bot.mjs", "feishu-bot.mjs"]) {
+    const src = fs.readFileSync(new URL(`../${file}`, import.meta.url), "utf8");
+    assert.ok(/from "\.\/im-commands\.mjs"/.test(src), `${file} 必须 import im-commands.mjs`);
+    assert.ok(/executeImCommand\(/.test(src), `${file} 必须调用 executeImCommand`);
+    const cmdAt = src.indexOf("executeImCommand(");
+    const promptAt = src.indexOf("promptSession(");
+    assert.ok(cmdAt > -1 && (promptAt === -1 || cmdAt < promptAt), `${file} 命令层必须出现在 promptSession 之前（cmdAt=${cmdAt}, promptAt=${promptAt}）`);
+  }
+});

package/clients/dsh-remote/test/wecom-bot.test.mjs

@@ -152,6 +152,8 @@ function fakeSubscriber(over = {}) {
   sub.started = false;
   sub.closed = false;
   sub.promptCalls = [];
+  sub.cancelCalls = [];
+  sub.cancelSession = async ({ sessionId } = {}) => { sub.cancelCalls.push({ sessionId }); return { ok: true }; };
   sub.sessionDetails = Array.isArray(over.sessions) ? over.sessions.slice() : [];
   sub.start = () => { sub.started = true; };
   sub.close = () => { sub.closed = true; };
@@ -1716,3 +1718,38 @@ test("atomicWriteJson：覆盖写、目录自动创建、0600、失败不留临
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// ─────────────────────── 命令层（2026-11-08：/ls 不再转给模型）───────────────────────
+
+test("★ 命令层：/help /status 直接回复、/ls 免费档被拦、/stop 免费急停；命中命令**不进 promptSession**", async () => {
+  const rt = await setupRelayBot();
+  try {
+    rt.bot.start();
+    await waitFor(() => rt.bot.status().authenticated, { label: "认证" });
+    const replies = () => rt.server.state.frames.filter((f) => f.cmd === "aibot_respond_msg");
+    const sendCmd = async (msgid, content) => {
+      const before = replies().length;
+      rt.server.push({ cmd: "aibot_msg_callback", headers: { req_id: `cmd-${msgid}` }, body: { msgid: `m-${msgid}`, msgtype: "text", text: { content }, from: { userid: "user-a" } } });
+      await waitFor(() => replies().length > before, { label: `命令 ${msgid} 回复` });
+      return String(replies()[before].body.stream.content || "");
+    };
+    const help = await sendCmd("help", "/help");
+    assert.match(help, /可用命令/);
+    assert.match(help, /\/ls/);
+    assert.match(help, /\/unbind/);
+    assert.equal(rt.sub.promptCalls.length, 0, "★ 命令不得进模型");
+    const status = await sendCmd("status", "/status");
+    assert.match(status, /连接状态/);
+    assert.match(status, /当前会话/);
+    const ls = await sendCmd("ls", "/ls");
+    assert.match(ls, /会员功能/, "免费档 /ls 必须被拦");
+    assert.equal(rt.sub.promptCalls.length, 0);
+    const stop = await sendCmd("stop", "/stop");
+    assert.match(stop, /已急停|没有正在运行/);
+    assert.deepEqual(rt.sub.cancelCalls, [{ sessionId: "session-abc" }], "★ /stop 调 cancelSession");
+    assert.equal(rt.sub.promptCalls.length, 0, "★ 全部命令都不进模型");
+    // 普通文本照旧进模型
+    await rt.inbound("normal-1", "帮我改一下代码");
+    assert.equal(rt.sub.promptCalls.length, 1);
+  } finally { await rt.close(); }
+});