@openclaw-china/shared 2026.3.18 → 2026.3.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw-china/shared",
-  "version": "2026.3.18",
+  "version": "2026.3.20",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/cli/china-setup.test.ts

@@ -44,6 +44,31 @@ type ConfigRoot = {
 
 const CLI_STATE_KEY = Symbol.for("@openclaw-china/china-cli-state");
 
+function setupTTYMocks(): () => void {
+  const stdinDescriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
+  const stdoutDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+
+  vi.clearAllMocks();
+  delete (globalThis as Record<PropertyKey, unknown>)[CLI_STATE_KEY];
+  Object.defineProperty(process.stdin, "isTTY", {
+    configurable: true,
+    value: true,
+  });
+  Object.defineProperty(process.stdout, "isTTY", {
+    configurable: true,
+    value: true,
+  });
+
+  return () => {
+    if (stdinDescriptor) {
+      Object.defineProperty(process.stdin, "isTTY", stdinDescriptor);
+    }
+    if (stdoutDescriptor) {
+      Object.defineProperty(process.stdout, "isTTY", stdoutDescriptor);
+    }
+  };
+}
+
 function createCommandNode(): CommandNode {
   const node: CommandNode = {
     children: new Map<string, CommandNode>(),
@@ -103,29 +128,14 @@ async function runSetup(
 }
 
 describe("china setup wecom", () => {
-  const stdinDescriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
-  const stdoutDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+  let restoreTTY: (() => void) | undefined;
 
   beforeEach(() => {
-    vi.clearAllMocks();
-    delete (globalThis as Record<PropertyKey, unknown>)[CLI_STATE_KEY];
-    Object.defineProperty(process.stdin, "isTTY", {
-      configurable: true,
-      value: true,
-    });
-    Object.defineProperty(process.stdout, "isTTY", {
-      configurable: true,
-      value: true,
-    });
+    restoreTTY = setupTTYMocks();
   });
 
   afterEach(() => {
-    if (stdinDescriptor) {
-      Object.defineProperty(process.stdin, "isTTY", stdinDescriptor);
-    }
-    if (stdoutDescriptor) {
-      Object.defineProperty(process.stdout, "isTTY", stdoutDescriptor);
-    }
+    restoreTTY?.();
   });
 
   it("stores ws-only credentials for wecom setup", async () => {
@@ -183,42 +193,146 @@ describe("china setup wecom", () => {
   });
 });
 
+describe("china setup wechat-mp", () => {
+  let restoreTTY: (() => void) | undefined;
+
+  beforeEach(() => {
+    restoreTTY = setupTTYMocks();
+  });
+
+  afterEach(() => {
+    restoreTTY?.();
+  });
+
+  it("stores wechat-mp callback and account config", async () => {
+    selectMock
+      .mockResolvedValueOnce("wechat-mp")
+      .mockResolvedValueOnce("safe")
+      .mockResolvedValueOnce("passive");
+    confirmMock.mockResolvedValueOnce(true); // renderMarkdown enabled (default)
+    textMock
+      .mockResolvedValueOnce("/wechat-mp")
+      .mockResolvedValueOnce("wx-test-appid")
+      .mockResolvedValueOnce("wx-test-secret")
+      .mockResolvedValueOnce("callback-token")
+      .mockResolvedValueOnce("encoding-aes-key")
+      .mockResolvedValueOnce("欢迎关注");
+
+    const { writeConfigFile } = await runSetup({}, ["wechat-mp"]);
+
+    expect(writeConfigFile).toHaveBeenCalledTimes(1);
+    const savedConfig = writeConfigFile.mock.calls[0]?.[0] as ConfigRoot;
+    const wechatMpConfig = savedConfig.channels?.["wechat-mp"];
+
+    expect(wechatMpConfig?.enabled).toBe(true);
+    expect(wechatMpConfig?.webhookPath).toBe("/wechat-mp");
+    expect(wechatMpConfig?.appId).toBe("wx-test-appid");
+    expect(wechatMpConfig?.appSecret).toBe("wx-test-secret");
+    expect(wechatMpConfig?.token).toBe("callback-token");
+    expect(wechatMpConfig?.encodingAESKey).toBe("encoding-aes-key");
+    expect(wechatMpConfig?.messageMode).toBe("safe");
+    expect(wechatMpConfig?.replyMode).toBe("passive");
+    expect(wechatMpConfig?.welcomeText).toBe("欢迎关注");
+    expect(wechatMpConfig?.renderMarkdown).toBe(true);
+  });
+
+  it("stores activeDeliveryMode when replyMode is active", async () => {
+    selectMock
+      .mockResolvedValueOnce("wechat-mp")
+      .mockResolvedValueOnce("safe")
+      .mockResolvedValueOnce("active")
+      .mockResolvedValueOnce("split");
+    textMock
+      .mockResolvedValueOnce("/wechat-mp-active")
+      .mockResolvedValueOnce("wx-active-appid")
+      .mockResolvedValueOnce("wx-active-secret")
+      .mockResolvedValueOnce("active-token")
+      .mockResolvedValueOnce("active-aes-key")
+      .mockResolvedValueOnce("welcome");
+
+    const { writeConfigFile } = await runSetup({}, ["wechat-mp"]);
+
+    expect(writeConfigFile).toHaveBeenCalledTimes(1);
+    const savedConfig = writeConfigFile.mock.calls[0]?.[0] as ConfigRoot;
+    const wechatMpConfig = savedConfig.channels?.["wechat-mp"];
+
+    expect(wechatMpConfig?.enabled).toBe(true);
+    expect(wechatMpConfig?.replyMode).toBe("active");
+    expect(wechatMpConfig?.activeDeliveryMode).toBe("split");
+  });
+
+  it("stores renderMarkdown when explicitly disabled", async () => {
+    selectMock
+      .mockResolvedValueOnce("wechat-mp")
+      .mockResolvedValueOnce("safe")
+      .mockResolvedValueOnce("active")
+      .mockResolvedValueOnce("merged");
+    confirmMock.mockResolvedValueOnce(false); // Disable renderMarkdown
+    textMock
+      .mockResolvedValueOnce("/wechat-mp-no-md")
+      .mockResolvedValueOnce("wx-no-md-appid")
+      .mockResolvedValueOnce("wx-no-md-secret")
+      .mockResolvedValueOnce("no-md-token")
+      .mockResolvedValueOnce("no-md-aes-key")
+      .mockResolvedValueOnce("welcome");
+
+    const { writeConfigFile } = await runSetup({}, ["wechat-mp"]);
+
+    expect(writeConfigFile).toHaveBeenCalledTimes(1);
+    const savedConfig = writeConfigFile.mock.calls[0]?.[0] as ConfigRoot;
+    const wechatMpConfig = savedConfig.channels?.["wechat-mp"];
+
+    expect(wechatMpConfig?.enabled).toBe(true);
+    expect(wechatMpConfig?.activeDeliveryMode).toBe("merged");
+    expect(wechatMpConfig?.renderMarkdown).toBe(false);
+  });
+
+  it("defaults renderMarkdown to true when not explicitly disabled", async () => {
+    selectMock
+      .mockResolvedValueOnce("wechat-mp")
+      .mockResolvedValueOnce("safe")
+      .mockResolvedValueOnce("passive");
+    confirmMock.mockResolvedValueOnce(true); // Keep renderMarkdown enabled (default)
+    textMock
+      .mockResolvedValueOnce("/wechat-mp-default-md")
+      .mockResolvedValueOnce("wx-default-appid")
+      .mockResolvedValueOnce("wx-default-secret")
+      .mockResolvedValueOnce("default-token")
+      .mockResolvedValueOnce("default-aes-key")
+      .mockResolvedValueOnce("welcome");
+
+    const { writeConfigFile } = await runSetup({}, ["wechat-mp"]);
+
+    expect(writeConfigFile).toHaveBeenCalledTimes(1);
+    const savedConfig = writeConfigFile.mock.calls[0]?.[0] as ConfigRoot;
+    const wechatMpConfig = savedConfig.channels?.["wechat-mp"];
+
+    expect(wechatMpConfig?.enabled).toBe(true);
+    // setup writes the value explicitly, even when it's the default true
+    expect(wechatMpConfig?.renderMarkdown).toBe(true);
+  });
+});
+
 describe("china setup wecom-kf", () => {
-  const stdinDescriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
-  const stdoutDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+  let restoreTTY: (() => void) | undefined;
 
   beforeEach(() => {
-    vi.clearAllMocks();
-    delete (globalThis as Record<PropertyKey, unknown>)[CLI_STATE_KEY];
-    Object.defineProperty(process.stdin, "isTTY", {
-      configurable: true,
-      value: true,
-    });
-    Object.defineProperty(process.stdout, "isTTY", {
-      configurable: true,
-      value: true,
-    });
+    restoreTTY = setupTTYMocks();
   });
 
   afterEach(() => {
-    if (stdinDescriptor) {
-      Object.defineProperty(process.stdin, "isTTY", stdinDescriptor);
-    }
-    if (stdoutDescriptor) {
-      Object.defineProperty(process.stdout, "isTTY", stdoutDescriptor);
-    }
+    restoreTTY?.();
   });
 
-  it("stores wecom-kf callback and api credentials", async () => {
+  it("stores only the initial wecom-kf callback setup fields", async () => {
     selectMock.mockResolvedValueOnce("wecom-kf");
     textMock
       .mockResolvedValueOnce("/kf-hook")
       .mockResolvedValueOnce("callback-token")
       .mockResolvedValueOnce("encoding-aes-key")
       .mockResolvedValueOnce("ww-test-corp")
-      .mockResolvedValueOnce("kf-secret")
       .mockResolvedValueOnce("wk-test")
-      .mockResolvedValueOnce("你好，这里是 AI 客服");
+      .mockResolvedValueOnce("");
 
     const { writeConfigFile } = await runSetup({}, ["wecom-kf"]);
 
@@ -231,9 +345,12 @@ describe("china setup wecom-kf", () => {
     expect(wecomKfConfig?.token).toBe("callback-token");
     expect(wecomKfConfig?.encodingAESKey).toBe("encoding-aes-key");
     expect(wecomKfConfig?.corpId).toBe("ww-test-corp");
-    expect(wecomKfConfig?.corpSecret).toBe("kf-secret");
     expect(wecomKfConfig?.openKfId).toBe("wk-test");
-    expect(wecomKfConfig?.welcomeText).toBe("你好，这里是 AI 客服");
+    expect(wecomKfConfig?.corpSecret).toBeUndefined();
+    expect(wecomKfConfig?.apiBaseUrl).toBeUndefined();
+    expect(wecomKfConfig?.welcomeText).toBeUndefined();
+    expect(wecomKfConfig?.dmPolicy).toBeUndefined();
+    expect(wecomKfConfig?.allowFrom).toBeUndefined();
 
     const promptMessages = textMock.mock.calls.map((call) => {
       const firstArg = call[0] as { message?: string } | undefined;
@@ -244,37 +361,38 @@ describe("china setup wecom-kf", () => {
       "微信客服回调 Token",
       "微信客服回调 EncodingAESKey",
       "corpId",
-      "微信客服 Secret",
       "open_kfid",
-      "欢迎语（可选）",
+      "微信客服 Secret（最后填写；首次接入可先留空）",
     ]);
+
+    const noteMessages = noteMock.mock.calls.map((call) => {
+      const firstArg = call[0] as string | undefined;
+      return firstArg ?? "";
+    });
+    expect(
+      noteMessages.some((message) =>
+        message.includes(
+          "配置文档：https://github.com/BytePioneer-AI/openclaw-china/tree/main/doc/guides/wecom-kf/configuration.md"
+        )
+      )
+    ).toBe(true);
+    expect(
+      noteMessages.some((message) =>
+        message.includes("corpSecret 会作为最后一个参数询问；首次接入可先留空，待回调 URL 校验通过并点击“开始使用”后再补")
+      )
+    ).toBe(true);
   });
 });
 
 describe("china setup dingtalk", () => {
-  const stdinDescriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
-  const stdoutDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "isTTY");
+  let restoreTTY: (() => void) | undefined;
 
   beforeEach(() => {
-    vi.clearAllMocks();
-    delete (globalThis as Record<PropertyKey, unknown>)[CLI_STATE_KEY];
-    Object.defineProperty(process.stdin, "isTTY", {
-      configurable: true,
-      value: true,
-    });
-    Object.defineProperty(process.stdout, "isTTY", {
-      configurable: true,
-      value: true,
-    });
+    restoreTTY = setupTTYMocks();
   });
 
   afterEach(() => {
-    if (stdinDescriptor) {
-      Object.defineProperty(process.stdin, "isTTY", stdinDescriptor);
-    }
-    if (stdoutDescriptor) {
-      Object.defineProperty(process.stdout, "isTTY", stdoutDescriptor);
-    }
+    restoreTTY?.();
   });
 
   it("stores gateway token when dingtalk AI Card streaming is enabled", async () => {

package/src/cli/china-setup.ts

@@ -51,7 +51,7 @@ type ConfigRoot = {
   [key: string]: unknown;
 };
 
-export type ChannelId = "dingtalk" | "feishu-china" | "wecom" | "wecom-app" | "wecom-kf" | "qqbot";
+export type ChannelId = "dingtalk" | "feishu-china" | "wecom" | "wecom-app" | "wecom-kf" | "qqbot" | "wechat-mp";
 
 export type RegisterChinaSetupCliOptions = {
   channels?: readonly ChannelId[];
@@ -78,6 +78,7 @@ const CHANNEL_ORDER: readonly ChannelId[] = [
   "wecom",
   "wecom-app",
   "wecom-kf",
+  "wechat-mp",
   "feishu-china",
 ];
 const CHANNEL_DISPLAY_LABELS: Record<ChannelId, string> = {
@@ -86,6 +87,7 @@ const CHANNEL_DISPLAY_LABELS: Record<ChannelId, string> = {
   wecom: "WeCom（企业微信-智能机器人）",
   "wecom-app": "WeCom App（自建应用-可接入微信）",
   "wecom-kf": "WeCom KF（微信客服）",
+  "wechat-mp": "WeChat MP（微信公众号）",
   qqbot: "QQBot（QQ 机器人）",
 };
 const CHANNEL_GUIDE_LINKS: Record<ChannelId, string> = {
@@ -94,6 +96,7 @@ const CHANNEL_GUIDE_LINKS: Record<ChannelId, string> = {
   wecom: `${GUIDES_BASE}/wecom/configuration.md`,
   "wecom-app": `${GUIDES_BASE}/wecom-app/configuration.md`,
   "wecom-kf": "https://github.com/BytePioneer-AI/openclaw-china/blob/main/extensions/wecom-kf/README.md",
+  "wechat-mp": `${GUIDES_BASE}/wechat-mp/configuration.md`,
   qqbot: `${GUIDES_BASE}/qqbot/configuration.md`,
 };
 const CHINA_CLI_STATE_KEY = Symbol.for("@openclaw-china/china-cli-state");
@@ -341,10 +344,11 @@ function isChannelConfigured(cfg: ConfigRoot, channelId: ChannelId): boolean {
     case "wecom-kf":
       return (
         hasNonEmptyString(channelCfg.corpId) &&
-        hasNonEmptyString(channelCfg.corpSecret) &&
         hasNonEmptyString(channelCfg.token) &&
         hasNonEmptyString(channelCfg.encodingAESKey)
       );
+    case "wechat-mp":
+      return hasNonEmptyString(channelCfg.appId) && hasNonEmptyString(channelCfg.token);
     default:
       return false;
   }
@@ -652,6 +656,15 @@ async function configureWecomKf(prompter: SetupPrompter, cfg: ConfigRoot): Promi
   section("配置 WeCom KF（微信客服）");
   showGuideLink("wecom-kf");
   const existing = getChannelConfig(cfg, "wecom-kf");
+  clackNote(
+    [
+      "向导顺序：webhookPath / token / encodingAESKey / corpId / open_kfid / corpSecret",
+      "基础必填：corpId / token / encodingAESKey / open_kfid",
+      "corpSecret 会作为最后一个参数询问；首次接入可先留空，待回调 URL 校验通过并点击“开始使用”后再补",
+      "webhookPath 默认值：/wecom-kf",
+    ].join("\n"),
+    "参数说明"
+  );
 
   const webhookPath = await prompter.askText({
     label: "Webhook 路径（默认 /wecom-kf）",
@@ -673,19 +686,14 @@ async function configureWecomKf(prompter: SetupPrompter, cfg: ConfigRoot): Promi
     defaultValue: toTrimmedString(existing.corpId),
     required: true,
   });
-  const corpSecret = await prompter.askSecret({
-    label: "微信客服 Secret",
-    existingValue: toTrimmedString(existing.corpSecret),
-    required: true,
-  });
   const openKfId = await prompter.askText({
     label: "open_kfid",
     defaultValue: toTrimmedString(existing.openKfId),
     required: true,
   });
-  const welcomeText = await prompter.askText({
-    label: "欢迎语（可选）",
-    defaultValue: toTrimmedString(existing.welcomeText),
+  const corpSecret = await prompter.askSecret({
+    label: "微信客服 Secret（最后填写；首次接入可先留空）",
+    existingValue: toTrimmedString(existing.corpSecret),
     required: false,
   });
 
@@ -694,8 +702,95 @@ async function configureWecomKf(prompter: SetupPrompter, cfg: ConfigRoot): Promi
     token,
     encodingAESKey,
     corpId,
-    corpSecret,
     openKfId,
+    corpSecret: corpSecret || undefined,
+  });
+}
+
+async function configureWechatMp(prompter: SetupPrompter, cfg: ConfigRoot): Promise<ConfigRoot> {
+  section("配置 WeChat MP（微信公众号）");
+  showGuideLink("wechat-mp");
+  const existing = getChannelConfig(cfg, "wechat-mp");
+
+  const webhookPath = await prompter.askText({
+    label: "Webhook 路径（默认 /wechat-mp）",
+    defaultValue: toTrimmedString(existing.webhookPath) ?? "/wechat-mp",
+    required: true,
+  });
+  const appId = await prompter.askText({
+    label: "公众号 appId",
+    defaultValue: toTrimmedString(existing.appId),
+    required: true,
+  });
+  const appSecret = await prompter.askSecret({
+    label: "公众号 appSecret（主动发送需要）",
+    existingValue: toTrimmedString(existing.appSecret),
+    required: false,
+  });
+  const token = await prompter.askSecret({
+    label: "服务器配置 token",
+    existingValue: toTrimmedString(existing.token),
+    required: true,
+  });
+  const messageMode = await prompter.askSelect<"plain" | "safe" | "compat">(
+    "消息加解密模式",
+    [
+      { value: "plain", label: "plain（明文）" },
+      { value: "safe", label: "safe（安全模式）" },
+      { value: "compat", label: "compat（兼容模式）" },
+    ],
+    (toTrimmedString(existing.messageMode) as "plain" | "safe" | "compat" | undefined) ?? "safe"
+  );
+  let encodingAESKey = toTrimmedString(existing.encodingAESKey);
+  if (messageMode !== "plain") {
+    encodingAESKey = await prompter.askSecret({
+      label: "EncodingAESKey（safe/compat 必填）",
+      existingValue: encodingAESKey,
+      required: true,
+    });
+  }
+  const replyMode = await prompter.askSelect<"passive" | "active">(
+    "回复模式",
+    [
+      { value: "passive", label: "passive（5 秒内被动回复）" },
+      { value: "active", label: "active（客服消息主动发送）" },
+    ],
+    (toTrimmedString(existing.replyMode) as "passive" | "active" | undefined) ?? "passive"
+  );
+
+  let activeDeliveryMode: "merged" | "split" | undefined;
+  if (replyMode === "active") {
+    activeDeliveryMode = await prompter.askSelect<"merged" | "split">(
+      "主动发送模式（activeDeliveryMode）",
+      [
+        { value: "split", label: "split（逐块发送，推荐）" },
+        { value: "merged", label: "merged（合并后单次发送）" },
+      ],
+      (toTrimmedString(existing.activeDeliveryMode) as "merged" | "split" | undefined) ?? "split"
+    );
+  }
+
+  const renderMarkdown = await prompter.askConfirm(
+    "启用 Markdown 渲染（推荐开启）",
+    toBoolean(existing.renderMarkdown, true)
+  );
+
+  const welcomeText = await prompter.askText({
+    label: "欢迎语（可选）",
+    defaultValue: toTrimmedString(existing.welcomeText),
+    required: false,
+  });
+
+  return mergeChannelConfig(cfg, "wechat-mp", {
+    webhookPath,
+    appId,
+    appSecret: appSecret || undefined,
+    token,
+    encodingAESKey: messageMode === "plain" ? undefined : encodingAESKey,
+    messageMode,
+    replyMode,
+    activeDeliveryMode,
+    renderMarkdown,
     welcomeText: welcomeText || undefined,
   });
 }
@@ -766,6 +861,8 @@ async function configureSingleChannel(
       return configureWecomApp(prompter, cfg);
     case "wecom-kf":
       return configureWecomKf(prompter, cfg);
+    case "wechat-mp":
+      return configureWechatMp(prompter, cfg);
     case "qqbot":
       return configureQQBot(prompter, cfg);
     default:

package/src/cli/install-hint.ts

@@ -24,6 +24,7 @@ const SUPPORTED_CHANNELS: readonly ChannelId[] = [
   "wecom",
   "wecom-app",
   "wecom-kf",
+  "wechat-mp",
   "qqbot",
 ];
 const CHINA_INSTALL_HINT_SHOWN_KEY = Symbol.for("@openclaw-china/china-install-hint-shown");