@tencent-weixin/openclaw-weixin 2.1.8 → 2.1.10

package/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 This project follows the [Keep a Changelog](https://keepachangelog.com/) format.
 
+## [2.1.9] - 2026-04-20
+
+### Added
+
+- **Outbound hook support:** Add `message_sending` (pre-send interception/modification) and `message_sent` (post-send notification) hook integration for all outbound paths — `sendText`, `sendMedia`, and the inbound-reply `deliver` in `process-message`. Hook logic is extracted into a shared `src/messaging/outbound-hooks.ts` module.
+
+### Changed
+
+- **Cleanup:** Remove unused `mediaUrl` parameter from `sendWeixinOutbound` signature.
+
+## [2.1.8] - 2026-04-07
+
+### Changed
+
+- **Markdown filter:** `StreamingMarkdownFilter` now preserves more Markdown constructs in outbound text.
+
 ## [2.1.7] - 2026-04-07
 
 ### Fixed

package/CHANGELOG.zh_CN.md

@@ -4,6 +4,22 @@
 
 本项目遵循 [Keep a Changelog](https://keepachangelog.com/) 格式。
 
+## [2.1.9] - 2026-04-20
+
+### 新增
+
+- **外发 hook 支持：** 为所有外发路径（`sendText`、`sendMedia`、`process-message` 中的入站回复 `deliver`）接入 `message_sending`（发送前拦截/修改）和 `message_sent`（发送后通知）hook。hook 逻辑抽取至共享模块 `src/messaging/outbound-hooks.ts`。
+
+### 变更
+
+- **清理：** 移除 `sendWeixinOutbound` 签名中未使用的 `mediaUrl` 参数。
+
+## [2.1.8] - 2026-04-07
+
+### 变更
+
+- **Markdown 过滤器：** `StreamingMarkdownFilter` 放开了更多 Markdown 格式的保留。
+
 ## [2.1.7] - 2026-04-07
 
 ### 修复

package/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "openclaw-weixin",
-  "version": "2.1.8",
+  "version": "2.1.10",
   "channels": [
     "openclaw-weixin"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tencent-weixin/openclaw-weixin",
-  "version": "2.1.8",
+  "version": "2.1.10",
   "description": "OpenClaw Weixin channel",
   "license": "MIT",
   "author": "Tencent",

package/src/api/api.ts

@@ -13,6 +13,8 @@ import type {
   GetUploadUrlResp,
   GetUpdatesReq,
   GetUpdatesResp,
+  NotifyStopResp,
+  NotifyStartResp,
   SendMessageReq,
   SendTypingReq,
   GetConfigResp,
@@ -316,3 +318,35 @@ export async function sendTyping(
     label: "sendTyping",
   });
 }
+
+/**
+ * Notify Weixin that this channel client is stopping (gateway shutdown / channel stop).
+ * Uses a standalone timeout (not the gateway abort signal) so the request can finish
+ * after OpenClaw has already aborted the long-poll.
+ */
+export async function notifyStop(params: WeixinApiOptions): Promise<NotifyStopResp> {
+  const rawText = await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/msg/notifystop",
+    body: JSON.stringify({ base_info: buildBaseInfo() }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+    label: "notifyStop",
+  });
+  return JSON.parse(rawText) as NotifyStopResp;
+}
+
+/**
+ * Notify Weixin that this channel client is starting (gateway startup / channel start).
+ */
+export async function notifyStart(params: WeixinApiOptions): Promise<NotifyStartResp> {
+  const rawText = await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/msg/notifystart",
+    body: JSON.stringify({ base_info: buildBaseInfo() }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+    label: "notifyStart",
+  });
+  return JSON.parse(rawText) as NotifyStartResp;
+}

package/src/api/types.ts

@@ -224,3 +224,25 @@ export interface GetConfigResp {
   /** Base64-encoded typing ticket for sendTyping. */
   typing_ticket?: string;
 }
+
+/** proto: NotifyStopReq — notify server when the channel client is stopping. */
+export interface NotifyStopReq {
+  base_info?: BaseInfo;
+}
+
+/** proto: NotifyStopResp */
+export interface NotifyStopResp {
+  ret?: number;
+  errmsg?: string;
+}
+
+/** proto: NotifyStartReq — notify server when the channel client is starting. */
+export interface NotifyStartReq {
+  base_info?: BaseInfo;
+}
+
+/** proto: NotifyStartResp */
+export interface NotifyStartResp {
+  ret?: number;
+  errmsg?: string;
+}

package/src/channel.ts

@@ -15,6 +15,7 @@ import {
   DEFAULT_BASE_URL,
 } from "./auth/accounts.js";
 import type { ResolvedWeixinAccount } from "./auth/accounts.js";
+import { notifyStop, notifyStart } from "./api/api.js";
 import { assertSessionActive } from "./api/session-guard.js";
 import { getContextToken, findAccountIdsByContextToken, restoreContextTokens, clearContextTokensForAccount } from "./messaging/inbound.js";
 import { logger } from "./util/logger.js";
@@ -27,6 +28,7 @@ import type { WeixinQrStartResult, WeixinQrWaitResult } from "./auth/login-qr.js
 // Lazy-imported inside startAccount to avoid pulling in the monitor -> process-message ->
 // command-auth chain during plugin registration, which can re-enter plugin/provider registry
 // resolution before the account actually starts.
+import { applyWeixinMessageSendingHook, emitWeixinMessageSent } from "./messaging/outbound-hooks.js";
 import { sendWeixinMediaFile } from "./messaging/send-media.js";
 import { sendMessageWeixin, StreamingMarkdownFilter } from "./messaging/send.js";
 import { downloadRemoteImageToTemp } from "./cdn/upload.js";
@@ -109,7 +111,6 @@ async function sendWeixinOutbound(params: {
   text: string;
   accountId?: string | null;
   contextToken?: string;
-  mediaUrl?: string;
 }): Promise<{ channel: string; messageId: string }> {
   const account = resolveWeixinAccount(params.cfg, params.accountId);
   const aLog = logger.withAccount(account.accountId);
@@ -123,13 +124,31 @@ async function sendWeixinOutbound(params: {
   }
   const f = new StreamingMarkdownFilter();
   const rawText = params.text ?? "";
-  const filteredText = f.feed(rawText) + f.flush();
-  const result = await sendMessageWeixin({ to: params.to, text: filteredText, opts: {
-    baseUrl: account.baseUrl,
-    token: account.token,
-    contextToken: params.contextToken,
-  }});
-  return { channel: "openclaw-weixin", messageId: result.messageId };
+  let filteredText = f.feed(rawText) + f.flush();
+
+  const sendingResult = await applyWeixinMessageSendingHook({
+    to: params.to,
+    text: filteredText,
+    accountId: account.accountId,
+  });
+  if (sendingResult.cancelled) {
+    aLog.info(`sendWeixinOutbound: cancelled by message_sending hook to=${params.to}`);
+    return { channel: "openclaw-weixin", messageId: "" };
+  }
+  filteredText = sendingResult.text;
+
+  try {
+    const result = await sendMessageWeixin({ to: params.to, text: filteredText, opts: {
+      baseUrl: account.baseUrl,
+      token: account.token,
+      contextToken: params.contextToken,
+    }});
+    emitWeixinMessageSent({ to: params.to, content: filteredText, success: true, accountId: account.accountId });
+    return { channel: "openclaw-weixin", messageId: result.messageId };
+  } catch (err) {
+    emitWeixinMessageSent({ to: params.to, content: filteredText, success: false, error: String(err), accountId: account.accountId });
+    throw err;
+  }
 }
 
 export const weixinPlugin: ChannelPlugin<ResolvedWeixinAccount> = {
@@ -215,6 +234,19 @@ export const weixinPlugin: ChannelPlugin<ResolvedWeixinAccount> = {
       }
 
       const mediaUrl = ctx.mediaUrl;
+      let text = ctx.text ?? "";
+
+      const sendingResult = await applyWeixinMessageSendingHook({
+        to: ctx.to,
+        text,
+        accountId: account.accountId,
+        mediaUrl,
+      });
+      if (sendingResult.cancelled) {
+        aLog.info(`sendMedia: cancelled by message_sending hook to=${ctx.to}`);
+        return { channel: "openclaw-weixin", messageId: "" };
+      }
+      text = sendingResult.text;
 
       if (mediaUrl && (isLocalFilePath(mediaUrl) || isRemoteUrl(mediaUrl))) {
         let filePath: string;
@@ -227,24 +259,35 @@ export const weixinPlugin: ChannelPlugin<ResolvedWeixinAccount> = {
           aLog.debug(`sendMedia: remote image downloaded to ${filePath}`);
         }
         const contextToken = getContextToken(account.accountId, ctx.to);
-        const result = await sendWeixinMediaFile({
-          filePath,
-          to: ctx.to,
-          text: ctx.text ?? "",
-          opts: { baseUrl: account.baseUrl, token: account.token, contextToken },
-          cdnBaseUrl: account.cdnBaseUrl,
-        });
-        return { channel: "openclaw-weixin", messageId: result.messageId };
+        try {
+          const result = await sendWeixinMediaFile({
+            filePath,
+            to: ctx.to,
+            text,
+            opts: { baseUrl: account.baseUrl, token: account.token, contextToken },
+            cdnBaseUrl: account.cdnBaseUrl,
+          });
+          emitWeixinMessageSent({ to: ctx.to, content: text, success: true, accountId: account.accountId });
+          return { channel: "openclaw-weixin", messageId: result.messageId };
+        } catch (err) {
+          emitWeixinMessageSent({ to: ctx.to, content: text, success: false, error: String(err), accountId: account.accountId });
+          throw err;
+        }
       }
 
-      const result = await sendWeixinOutbound({
-        cfg: ctx.cfg,
-        to: ctx.to,
-        text: ctx.text ?? "",
-        accountId,
-        contextToken: getContextToken(account.accountId, ctx.to),
-      });
-      return result;
+      const contextToken = getContextToken(account.accountId, ctx.to);
+      try {
+        const result = await sendMessageWeixin({ to: ctx.to, text, opts: {
+          baseUrl: account.baseUrl,
+          token: account.token,
+          contextToken,
+        }});
+        emitWeixinMessageSent({ to: ctx.to, content: text, success: true, accountId: account.accountId });
+        return { channel: "openclaw-weixin", messageId: result.messageId };
+      } catch (err) {
+        emitWeixinMessageSent({ to: ctx.to, content: text, success: false, error: String(err), accountId: account.accountId });
+        throw err;
+      }
     },
   },
   status: {
@@ -385,6 +428,18 @@ export const weixinPlugin: ChannelPlugin<ResolvedWeixinAccount> = {
 
       ctx.log?.info?.(`[${account.accountId}] starting weixin provider (${DEFAULT_BASE_URL})`);
 
+      try {
+        const resp = await notifyStart({
+          baseUrl: account.baseUrl,
+          token: account.token,
+        });
+        if (resp.ret !== undefined && resp.ret !== 0) {
+          aLog.warn(`notifyStart: ret=${resp.ret} errmsg=${resp.errmsg ?? ""}`);
+        }
+      } catch (err) {
+        aLog.warn(`notifyStart failed during startup (ignored): ${String(err)}`);
+      }
+
       const logPath = aLog.getLogFilePath();
       ctx.log?.info?.(`[${account.accountId}] weixin logs: ${logPath}`);
 
@@ -400,6 +455,25 @@ export const weixinPlugin: ChannelPlugin<ResolvedWeixinAccount> = {
         setStatus: ctx.setStatus,
       });
     },
+    stopAccount: async (ctx) => {
+      const account = ctx.account;
+      const aLog = logger.withAccount(account.accountId);
+      if (!account.configured || !account.token?.trim()) {
+        aLog.debug(`gateway.stopAccount: skip notifyStop (not configured or no token)`);
+        return;
+      }
+      try {
+        const resp = await notifyStop({
+          baseUrl: account.baseUrl,
+          token: account.token,
+        });
+        if (resp.ret !== undefined && resp.ret !== 0) {
+          aLog.warn(`notifyStop: ret=${resp.ret} errmsg=${resp.errmsg ?? ""}`);
+        }
+      } catch (err) {
+        aLog.warn(`notifyStop failed during shutdown (ignored): ${String(err)}`);
+      }
+    },
     loginWithQrStart: async ({ accountId, force, timeoutMs, verbose }) => {
       // For re-login: use saved baseUrl from account data; fall back to default for new accounts.
       const savedBaseUrl = accountId ? loadWeixinAccount(accountId)?.baseUrl?.trim() : "";

package/src/messaging/outbound-hooks.ts

@@ -0,0 +1,84 @@
+import {
+  fireAndForgetHook,
+  buildCanonicalSentMessageHookContext,
+  toPluginMessageContext,
+  toPluginMessageSentEvent,
+} from "openclaw/plugin-sdk/hook-runtime";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+
+import { logger } from "../util/logger.js";
+
+const CHANNEL_ID = "openclaw-weixin";
+
+/**
+ * Run message_sending hook before sending.
+ * Returns the (possibly modified) text content plus a cancelled flag.
+ * Hook errors are caught and logged — sending proceeds regardless.
+ */
+export async function applyWeixinMessageSendingHook(params: {
+  to: string;
+  text: string;
+  accountId?: string;
+  mediaUrl?: string;
+}): Promise<{ cancelled: boolean; text: string }> {
+  const hookRunner = getGlobalHookRunner();
+  if (!hookRunner?.hasHooks("message_sending")) {
+    return { cancelled: false, text: params.text };
+  }
+  try {
+    const hookResult = await hookRunner.runMessageSending(
+      {
+        to: params.to,
+        content: params.text,
+        metadata: {
+          channel: CHANNEL_ID,
+          accountId: params.accountId,
+          ...(params.mediaUrl ? { mediaUrls: [params.mediaUrl] } : {}),
+        },
+      },
+      { channelId: CHANNEL_ID, accountId: params.accountId },
+    );
+    if (hookResult?.cancel) {
+      return { cancelled: true, text: params.text };
+    }
+    return {
+      cancelled: false,
+      text: hookResult?.content ?? params.text,
+    };
+  } catch (err) {
+    logger.warn(`message_sending hook error, proceeding with send: ${String(err)}`);
+    return { cancelled: false, text: params.text };
+  }
+}
+
+/**
+ * Fire message_sent hook (fire-and-forget) after a send attempt.
+ */
+export function emitWeixinMessageSent(params: {
+  to: string;
+  content: string;
+  success: boolean;
+  error?: string;
+  accountId?: string;
+}): void {
+  const hookRunner = getGlobalHookRunner();
+  if (!hookRunner?.hasHooks("message_sent")) return;
+  const canonical = buildCanonicalSentMessageHookContext({
+    to: params.to,
+    content: params.content,
+    success: params.success,
+    error: params.error,
+    channelId: CHANNEL_ID,
+    accountId: params.accountId,
+    conversationId: params.to,
+  });
+  fireAndForgetHook(
+    Promise.resolve(
+      hookRunner!.runMessageSent(
+        toPluginMessageSentEvent(canonical),
+        toPluginMessageContext(canonical),
+      ),
+    ),
+    "weixin: message_sent plugin hook failed",
+  );
+}

package/src/messaging/process-message.ts

@@ -20,6 +20,7 @@ import { redactBody, redactToken } from "../util/redact.js";
 
 import { isDebugMode } from "./debug-mode.js";
 import { sendWeixinErrorNotice } from "./error-notice.js";
+import { applyWeixinMessageSendingHook, emitWeixinMessageSent } from "./outbound-hooks.js";
 import {
   setContextToken,
   weixinMessageToMsgContext,
@@ -311,7 +312,7 @@ export async function processOneMessage(
       typingCallbacks,
       deliver: async (payload) => {
         const rawText = payload.text ?? "";
-        const text = (() => {
+        let text = (() => {
           const f = new StreamingMarkdownFilter();
           return f.feed(rawText) + f.flush();
         })();
@@ -330,11 +331,22 @@ export async function processOneMessage(
           });
         }
 
+        const sendingResult = await applyWeixinMessageSendingHook({
+          to: ctx.To,
+          text,
+          accountId: deps.accountId,
+          mediaUrl,
+        });
+        if (sendingResult.cancelled) {
+          logger.info(`outbound: cancelled by message_sending hook to=${ctx.To}`);
+          return;
+        }
+        text = sendingResult.text;
+
         try {
           if (mediaUrl) {
             let filePath: string;
             if (!mediaUrl.includes("://") || mediaUrl.startsWith("file://")) {
-              // Local path: absolute, relative, or file:// URL
               if (mediaUrl.startsWith("file://")) {
                 filePath = new URL(mediaUrl).pathname;
               } else if (!path.isAbsolute(mediaUrl)) {
@@ -357,6 +369,7 @@ export async function processOneMessage(
                 token: deps.token,
                 contextToken,
               }});
+              emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId });
               logger.info(`outbound: text sent to=${ctx.To}`);
               return;
             }
@@ -367,6 +380,7 @@ export async function processOneMessage(
               opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken },
               cdnBaseUrl: deps.cdnBaseUrl,
             });
+            emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId });
             logger.info(`outbound: media sent OK to=${ctx.To}`);
           } else {
             logger.debug(`outbound: sending text message to=${ctx.To}`);
@@ -375,9 +389,11 @@ export async function processOneMessage(
               token: deps.token,
               contextToken,
             }});
+            emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId });
             logger.info(`outbound: text sent OK to=${ctx.To}`);
           }
         } catch (err) {
+          emitWeixinMessageSent({ to: ctx.To, content: text, success: false, error: String(err), accountId: deps.accountId });
           logger.error(
             `outbound: FAILED to=${ctx.To} mediaUrl=${mediaUrl ?? "none"} err=${String(err)} stack=${(err as Error).stack ?? ""}`,
           );