@yanhaidao/wecom 2.3.10 → 2.3.13

package/src/outbound.ts

@@ -2,9 +2,10 @@ import type { ChannelOutboundAdapter, ChannelOutboundContext } from "openclaw/pl
 
 import { resolveWecomAccount, resolveWecomAccountConflict, resolveWecomAccounts } from "./config/index.js";
 import { WecomAgentDeliveryService } from "./capability/agent/index.js";
-import { getWecomRuntime } from "./runtime.js";
+import { getBotWsPushHandle, getWecomRuntime } from "./runtime.js";
+import { resolveScopedWecomTarget } from "./target.js";
 
-function resolveAgentConfigOrThrow(params: {
+function resolveOutboundAccountOrThrow(params: {
   cfg: ChannelOutboundContext["cfg"];
   accountId?: string | null;
 }) {
@@ -26,10 +27,17 @@ function resolveAgentConfigOrThrow(params: {
       );
     }
   }
-  const account = resolveWecomAccount({
+  return resolveWecomAccount({
     cfg: params.cfg,
     accountId: params.accountId,
-  }).agent;
+  });
+}
+
+function resolveAgentConfigOrThrow(params: {
+  cfg: ChannelOutboundContext["cfg"];
+  accountId?: string | null;
+}) {
+  const account = resolveOutboundAccountOrThrow(params).agent;
   if (!account?.apiConfigured) {
     throw new Error(
       `WeCom outbound requires Agent mode for account=${params.accountId ?? "default"}. Configure channels.wecom.accounts.<accountId>.agent (or legacy channels.wecom.agent).`,
@@ -45,6 +53,81 @@ function resolveAgentConfigOrThrow(params: {
   return account;
 }
 
+function isExplicitAgentTarget(raw: string | undefined): boolean {
+  return /^wecom-agent:/i.test(String(raw ?? "").trim());
+}
+
+function resolveBotWsChatTarget(params: {
+  to: string | undefined;
+  accountId: string;
+}): string | undefined {
+  const scoped = resolveScopedWecomTarget(params.to, params.accountId);
+  if (!scoped) {
+    return undefined;
+  }
+  if (scoped.accountId && scoped.accountId !== params.accountId) {
+    throw new Error(
+      `WeCom outbound account mismatch: target belongs to account=${scoped.accountId}, current account=${params.accountId}.`,
+    );
+  }
+  if (scoped.target.chatid) {
+    return scoped.target.chatid;
+  }
+  if (scoped.target.touser) {
+    return scoped.target.touser;
+  }
+  return undefined;
+}
+
+function shouldPreferBotWsOutbound(params: {
+  cfg: ChannelOutboundContext["cfg"];
+  accountId?: string | null;
+  to: string | undefined;
+}): { preferred: boolean; accountId: string } {
+  const account = resolveOutboundAccountOrThrow({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  return {
+    preferred: !isExplicitAgentTarget(params.to) && Boolean(account.bot?.configured && account.bot.primaryTransport === "ws" && account.bot.wsConfigured),
+    accountId: account.accountId,
+  };
+}
+
+async function sendTextViaBotWs(params: {
+  cfg: ChannelOutboundContext["cfg"];
+  accountId?: string | null;
+  to: string | undefined;
+  text: string;
+}): Promise<boolean> {
+  const { preferred, accountId } = shouldPreferBotWsOutbound(params);
+  if (!preferred) {
+    return false;
+  }
+  const chatId = resolveBotWsChatTarget({
+    to: params.to,
+    accountId,
+  });
+  if (!chatId) {
+    return false;
+  }
+  const handle = getBotWsPushHandle(accountId);
+  if (!handle) {
+    throw new Error(
+      `WeCom outbound account=${accountId} is configured for Bot WS active push, but no live WS runtime is registered.`,
+    );
+  }
+  if (!handle.isConnected()) {
+    throw new Error(
+      `WeCom outbound account=${accountId} is configured for Bot WS active push, but the WS transport is not connected.`,
+    );
+  }
+  console.log(`[wecom-outbound] Sending Bot WS active message to target=${String(params.to ?? "")} chatId=${chatId} (len=${params.text.length})`);
+  await handle.sendMarkdown(chatId, params.text);
+  console.log(`[wecom-outbound] Successfully sent Bot WS active message to ${chatId}`);
+  return true;
+}
+
 export const wecomOutbound: ChannelOutboundAdapter = {
   deliveryMode: "direct",
   chunkerMode: "text",
@@ -59,9 +142,6 @@ export const wecomOutbound: ChannelOutboundAdapter = {
   sendText: async ({ cfg, to, text, accountId }: ChannelOutboundContext) => {
     // signal removed - not supported in current SDK
 
-    const agent = resolveAgentConfigOrThrow({ cfg, accountId });
-    const deliveryService = new WecomAgentDeliveryService(agent);
-
     // 体验优化：/new /reset 的“New session started”回执在 OpenClaw 核心里是英文固定文案，
     // 且通过 routeReply 走 wecom outbound（Agent 主动发送）。
     // 在 WeCom“双模式”场景下，这会造成：
@@ -93,12 +173,23 @@ export const wecomOutbound: ChannelOutboundAdapter = {
 
     console.log(`[wecom-outbound] Sending text to target=${String(to ?? "")} (len=${outgoingText.length})`);
 
+    let sentViaBotWs = false;
     try {
-      await deliveryService.sendText({
+      sentViaBotWs = await sendTextViaBotWs({
+        cfg,
+        accountId,
         to,
         text: outgoingText,
       });
-      console.log(`[wecom-outbound] Successfully sent text to ${String(to ?? "")}`);
+      if (!sentViaBotWs) {
+        const agent = resolveAgentConfigOrThrow({ cfg, accountId });
+        const deliveryService = new WecomAgentDeliveryService(agent);
+        await deliveryService.sendText({
+          to,
+          text: outgoingText,
+        });
+        console.log(`[wecom-outbound] Successfully sent Agent text to ${String(to ?? "")}`);
+      }
     } catch (err) {
       console.error(`[wecom-outbound] Failed to send text to ${String(to ?? "")}:`, err);
       throw err;
@@ -106,13 +197,17 @@ export const wecomOutbound: ChannelOutboundAdapter = {
 
     return {
       channel: "wecom",
-      messageId: `agent-${Date.now()}`,
+      messageId: `${sentViaBotWs ? "bot-ws" : "agent"}-${Date.now()}`,
       timestamp: Date.now(),
     };
   },
   sendMedia: async ({ cfg, to, text, mediaUrl, accountId }: ChannelOutboundContext) => {
     // signal removed - not supported in current SDK
 
+    const { preferred } = shouldPreferBotWsOutbound({ cfg, accountId, to });
+    if (preferred) {
+      console.log(`[wecom-outbound] Bot WS active push does not support outbound media; falling back to Agent for target=${String(to ?? "")}`);
+    }
     const agent = resolveAgentConfigOrThrow({ cfg, accountId });
     const deliveryService = new WecomAgentDeliveryService(agent);
     if (!mediaUrl) {

package/src/runtime.ts

@@ -1,7 +1,10 @@
 export {
   getAccountRuntimeSnapshot,
+  getBotWsPushHandle,
   getWecomRuntime,
   registerAccountRuntime,
+  registerBotWsPushHandle,
   setWecomRuntime,
+  unregisterBotWsPushHandle,
   unregisterAccountRuntime,
 } from "./app/index.js";

package/src/shared/media-service.ts

@@ -2,6 +2,7 @@ import type { PluginRuntime } from "openclaw/plugin-sdk";
 
 import type { NormalizedMediaAttachment } from "./media-types.js";
 import type { UnifiedInboundEvent } from "../types/index.js";
+import { decryptWecomMediaWithMeta } from "../media.js";
 
 export class WecomMediaService {
   constructor(private readonly core: PluginRuntime) {}
@@ -15,6 +16,21 @@ export class WecomMediaService {
     };
   }
 
+  /**
+   * Download and decrypt WeCom AES-encrypted media.
+   * Bot-ws: each message carries a unique per-URL aeskey in the message body.
+   * Bot-webhook: uses the account-level EncodingAESKey.
+   * Both use AES-256-CBC with PKCS#7 padding (32-byte block), IV = key[:16].
+   */
+  async downloadEncryptedMedia(params: { url: string; aesKey: string }): Promise<NormalizedMediaAttachment> {
+    const decrypted = await decryptWecomMediaWithMeta(params.url, params.aesKey);
+    return {
+      buffer: decrypted.buffer,
+      contentType: decrypted.sourceContentType,
+      filename: decrypted.sourceFilename,
+    };
+  }
+
   async saveInboundAttachment(event: UnifiedInboundEvent, attachment: NormalizedMediaAttachment): Promise<string> {
     const saved = await this.core.channel.media.saveMediaBuffer(
       attachment.buffer,
@@ -31,6 +47,10 @@ export class WecomMediaService {
     if (!first?.remoteUrl) {
       return undefined;
     }
+    // Bot-ws media is AES-encrypted; use decryption when aesKey is present
+    if (first.aesKey) {
+      return this.downloadEncryptedMedia({ url: first.remoteUrl, aesKey: first.aesKey });
+    }
     return this.downloadRemoteMedia({ url: first.remoteUrl });
   }
 }

package/src/target.ts

@@ -35,12 +35,12 @@ export interface ScopedWecomTarget {
  * 2. 检查显式类型前缀 (party:, tag:, group:, user:)。
  * 3. 启发式回退 (无前缀时):
  *    - 以 "wr" 或 "wc" 开头 -> Chat ID (群聊)
- *    - 纯数字 -> Party ID (部门)
+ *    - 纯数字 -> 默认 Party ID (部门)；如果 preferUserForDigits 为 true 则视为 User ID
  *    - 其他 -> User ID (用户)
  * 
  * @param raw - The raw target string (e.g. "party:1", "zhangsan", "wecom:wr123")
  */
-export function resolveWecomTarget(raw: string | undefined): WecomTarget | undefined {
+export function resolveWecomTarget(raw: string | undefined, options?: { preferUserForDigits?: boolean }): WecomTarget | undefined {
     if (!raw?.trim()) return undefined;
 
     // 1. Remove standard namespace prefixes (移除标准命名空间前缀)
@@ -78,6 +78,9 @@ export function resolveWecomTarget(raw: string | undefined): WecomTarget | undef
     // 纯数字优先被视为部门 ID (Parties)，方便运维配置 (如 "1" 代表根部门)
     // 如果必须要发送给纯数字 ID 的用户，请使用显式前缀 "user:1001"
     if (/^\d+$/.test(clean)) {
+        if (options?.preferUserForDigits) {
+            return { touser: clean };
+        }
         return { toparty: clean };
     }
 
@@ -93,7 +96,9 @@ export function resolveScopedWecomTarget(raw: string | undefined, defaultAccount
     if (agentScoped) {
         const accountId = agentScoped[1]?.trim() || defaultAccountId;
         const rawTarget = agentScoped[2]?.trim() || "";
-        const target = resolveWecomTarget(rawTarget);
+        // Agent scoped targets are almost always users in a conversation context.
+        // In this scope, we prefer treating numeric IDs as User IDs to avoid 81013 errors.
+        const target = resolveWecomTarget(rawTarget, { preferUserForDigits: true });
         return target ? { accountId, target, rawTarget } : undefined;
     }
 

package/src/transport/bot-ws/inbound.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+
+import { mapBotWsFrameToInboundEvent } from "./inbound.js";
+import type { ResolvedBotAccount } from "../../types/index.js";
+
+function createBotAccount(): ResolvedBotAccount {
+  return {
+    accountId: "haidao",
+    configured: true,
+    primaryTransport: "ws",
+    wsConfigured: true,
+    webhookConfigured: false,
+    config: {},
+    ws: {
+      botId: "bot-id",
+      secret: "secret",
+    },
+    token: "",
+    encodingAESKey: "",
+    receiveId: "",
+    botId: "bot-id",
+    secret: "secret",
+  };
+}
+
+describe("mapBotWsFrameToInboundEvent", () => {
+  it("includes quote content in text events", () => {
+    const event = mapBotWsFrameToInboundEvent({
+      account: createBotAccount(),
+      frame: {
+        cmd: "aibot_msg_callback",
+        headers: { req_id: "req-1" },
+        body: {
+          msgid: "msg-1",
+          msgtype: "text",
+          chattype: "group",
+          chatid: "group-1",
+          from: { userid: "user-1" },
+          text: { content: "@daodao 这个线索价值" },
+          quote: {
+            msgtype: "text",
+            text: { content: "原始引用内容" },
+          },
+        },
+      },
+    });
+
+    expect(event.text).toBe("@daodao 这个线索价值\n\n> 原始引用内容");
+  });
+});

package/src/transport/bot-ws/inbound.ts

@@ -1,6 +1,12 @@
 import type { BaseMessage, EventMessage, WsFrame } from "@wecom/aibot-node-sdk";
 
-import type { ResolvedBotAccount, UnifiedInboundEvent, WecomInboundKind } from "../../types/index.js";
+import { buildInboundBody } from "../bot-webhook/message-shape.js";
+import type {
+  ResolvedBotAccount,
+  UnifiedInboundEvent,
+  WecomBotInboundMessage,
+  WecomInboundKind,
+} from "../../types/index.js";
 
 function resolveInboundKind(message: BaseMessage | EventMessage): WecomInboundKind {
   if (message.msgtype === "event") {
@@ -24,26 +30,10 @@ function resolveInboundKind(message: BaseMessage | EventMessage): WecomInboundKi
 }
 
 function resolveEventText(message: BaseMessage | EventMessage, account: ResolvedBotAccount): string {
-  if (message.msgtype === "text") {
-    return message.text?.content ?? "";
-  }
-  if (message.msgtype === "voice") {
-    return message.voice?.content ?? "";
-  }
-  if (message.msgtype === "mixed") {
-    return (message.mixed?.msg_item ?? [])
-      .map((item: { msgtype: string; text?: { content?: string } }) =>
-        item.msgtype === "text" ? item.text?.content ?? "" : "[image]",
-      )
-      .filter(Boolean)
-      .join("\n");
-  }
-  if (message.msgtype === "image") {
-    return "[image]";
-  }
-  if (message.msgtype === "file") {
-    return "[file]";
+  if (message.msgtype !== "event") {
+    return buildInboundBody(message as WecomBotInboundMessage);
   }
+
   const event = message as EventMessage;
   if (event.event?.eventtype === "enter_chat" && account.config.welcomeText) {
     return account.config.welcomeText;

package/src/transport/bot-ws/reply.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it, vi, afterEach } from "vitest";
+
+import { createBotWsReplyHandle } from "./reply.js";
+
+type ReplyHandleParams = Parameters<typeof createBotWsReplyHandle>[0];
+
+describe("createBotWsReplyHandle", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("uses configured placeholder content for immediate ws ack", async () => {
+    const replyStream = vi.fn().mockResolvedValue(undefined);
+    createBotWsReplyHandle({
+      client: {
+        replyStream,
+      } as unknown as ReplyHandleParams["client"],
+      frame: {
+        headers: { req_id: "req-1" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      placeholderContent: "正在思考...",
+    });
+
+    expect(replyStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: { req_id: "req-1" },
+      }),
+      expect.any(String),
+      "正在思考...",
+      false,
+    );
+  });
+
+  it("keeps placeholder alive until the first real ws chunk arrives", async () => {
+    vi.useFakeTimers();
+
+    const replyStream = vi.fn().mockResolvedValue(undefined);
+    const handle = createBotWsReplyHandle({
+      client: {
+        replyStream,
+      } as unknown as ReplyHandleParams["client"],
+      frame: {
+        headers: { req_id: "req-keepalive" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      placeholderContent: "正在思考...",
+    });
+
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(replyStream).toHaveBeenCalledTimes(2);
+
+    await handle.deliver({ text: "最终回复" }, { kind: "final" });
+    await vi.advanceTimersByTimeAsync(6000);
+
+    expect(replyStream).toHaveBeenCalledTimes(3);
+    expect(replyStream).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        headers: { req_id: "req-keepalive" },
+      }),
+      expect.any(String),
+      "最终回复",
+      true,
+    );
+  });
+
+  it("does not auto-send placeholder when disabled", () => {
+    const replyStream = vi.fn().mockResolvedValue(undefined);
+    createBotWsReplyHandle({
+      client: {
+        replyStream,
+      } as unknown as ReplyHandleParams["client"],
+      frame: {
+        headers: { req_id: "req-2" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      autoSendPlaceholder: false,
+    });
+
+    expect(replyStream).not.toHaveBeenCalled();
+  });
+
+  it("sends cumulative content for block streaming updates", async () => {
+    const replyStream = vi.fn().mockResolvedValue(undefined);
+    const handle = createBotWsReplyHandle({
+      client: {
+        replyStream,
+      } as unknown as ReplyHandleParams["client"],
+      frame: {
+        headers: { req_id: "req-blocks" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver({ text: "第一段" }, { kind: "block" });
+    await handle.deliver({ text: "第二段" }, { kind: "block" });
+    await handle.deliver({ text: "收尾" }, { kind: "final" });
+
+    expect(replyStream).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        headers: { req_id: "req-blocks" },
+      }),
+      expect.any(String),
+      "第一段",
+      false,
+    );
+    expect(replyStream).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        headers: { req_id: "req-blocks" },
+      }),
+      expect.any(String),
+      "第一段\n第二段",
+      false,
+    );
+    expect(replyStream).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        headers: { req_id: "req-blocks" },
+      }),
+      expect.any(String),
+      "第一段\n第二段\n收尾",
+      true,
+    );
+  });
+
+  it("swallows expired stream update errors during delivery", async () => {
+    const expiredError = {
+      headers: { req_id: "req-expired" },
+      errcode: 846608,
+      errmsg: "stream message update expired (>6 minutes), cannot update",
+    };
+    const replyStream = vi.fn().mockRejectedValue(expiredError);
+    const onFail = vi.fn();
+    const handle = createBotWsReplyHandle({
+      client: {
+        replyStream,
+      } as unknown as ReplyHandleParams["client"],
+      frame: {
+        headers: { req_id: "req-expired" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      autoSendPlaceholder: false,
+      onFail,
+    });
+
+    await expect(handle.deliver({ text: "最终回复" }, { kind: "final" })).resolves.toBeUndefined();
+
+    expect(replyStream).toHaveBeenCalledTimes(1);
+    expect(onFail).toHaveBeenCalledWith(expiredError);
+  });
+
+  it.each([
+    [{ headers: { req_id: "req-invalid" }, errcode: 846605, errmsg: "invalid req_id" }],
+    [{ headers: { req_id: "req-expired" }, errcode: 846608, errmsg: "stream message update expired (>6 minutes), cannot update" }],
+  ])("does not retry error reply when the ws reply window is already closed", async (error) => {
+    const replyStream = vi.fn().mockResolvedValue(undefined);
+    const onFail = vi.fn();
+    const handle = createBotWsReplyHandle({
+      client: {
+        replyStream,
+      } as unknown as ReplyHandleParams["client"],
+      frame: {
+        headers: { req_id: String(error.headers.req_id) },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      autoSendPlaceholder: false,
+      onFail,
+    });
+
+    await handle.fail?.(error);
+
+    expect(replyStream).not.toHaveBeenCalled();
+    expect(onFail).toHaveBeenCalledTimes(1);
+  });
+});