@netcat-ai/openclaw-weixin 2.4.7

package/src/messaging/send-media.ts

@@ -0,0 +1,72 @@
+import path from "node:path";
+import type { WeixinApiOptions } from "../api/api.js";
+import { logger } from "../util/logger.js";
+import { getMimeFromFilename } from "../media/mime.js";
+import { sendFileMessageWeixin, sendImageMessageWeixin, sendVideoMessageWeixin } from "./send.js";
+import { uploadFileAttachmentToWeixin, uploadFileToWeixin, uploadVideoToWeixin } from "../cdn/upload.js";
+
+/**
+ * Upload a local file and send it as a weixin message, routing by MIME type:
+ *   video/*  → uploadVideoToWeixin        + sendVideoMessageWeixin
+ *   image/*  → uploadFileToWeixin         + sendImageMessageWeixin
+ *   else     → uploadFileAttachmentToWeixin + sendFileMessageWeixin
+ *
+ * Used by both the auto-reply deliver path (monitor.ts) and the outbound
+ * sendMedia path (channel.ts) so they stay in sync.
+ */
+export async function sendWeixinMediaFile(params: {
+  filePath: string;
+  to: string;
+  text: string;
+  opts: WeixinApiOptions & { contextToken?: string; runId?: string };
+  cdnBaseUrl: string;
+}): Promise<{ messageId: string }> {
+  const { filePath, to, text, opts, cdnBaseUrl } = params;
+  const mime = getMimeFromFilename(filePath);
+  const uploadOpts: WeixinApiOptions = { baseUrl: opts.baseUrl, token: opts.token };
+
+  if (mime.startsWith("video/")) {
+    logger.info(`[weixin] sendWeixinMediaFile: uploading video filePath=${filePath} to=${to}`);
+    const uploaded = await uploadVideoToWeixin({
+      filePath,
+      toUserId: to,
+      opts: uploadOpts,
+      cdnBaseUrl,
+    });
+    logger.info(
+      `[weixin] sendWeixinMediaFile: video upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`,
+    );
+    return sendVideoMessageWeixin({ to, text, uploaded, opts });
+  }
+
+  if (mime.startsWith("image/")) {
+    logger.info(`[weixin] sendWeixinMediaFile: uploading image filePath=${filePath} to=${to}`);
+    const uploaded = await uploadFileToWeixin({
+      filePath,
+      toUserId: to,
+      opts: uploadOpts,
+      cdnBaseUrl,
+    });
+    logger.info(
+      `[weixin] sendWeixinMediaFile: image upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`,
+    );
+    return sendImageMessageWeixin({ to, text, uploaded, opts });
+  }
+
+  // File attachment: pdf, doc, zip, etc.
+  const fileName = path.basename(filePath);
+  logger.info(
+    `[weixin] sendWeixinMediaFile: uploading file attachment filePath=${filePath} name=${fileName} to=${to}`,
+  );
+  const uploaded = await uploadFileAttachmentToWeixin({
+    filePath,
+    fileName,
+    toUserId: to,
+    opts: uploadOpts,
+    cdnBaseUrl,
+  });
+  logger.info(
+    `[weixin] sendWeixinMediaFile: file upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`,
+  );
+  return sendFileMessageWeixin({ to, text, fileName, uploaded, opts });
+}

package/src/messaging/send.ts

@@ -0,0 +1,294 @@
+import type { ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
+
+import { sendMessage as sendMessageApi } from "../api/api.js";
+import type { WeixinApiOptions } from "../api/api.js";
+import { logger } from "../util/logger.js";
+import { generateId } from "../util/random.js";
+import type { MessageItem, SendMessageReq } from "../api/types.js";
+import { MessageItemType, MessageState, MessageType } from "../api/types.js";
+import type { UploadedFileInfo } from "../cdn/upload.js";
+
+export { StreamingMarkdownFilter } from "./markdown-filter.js";
+
+type WeixinMessageSendOptions = WeixinApiOptions & {
+  contextToken?: string;
+  runId?: string;
+};
+
+function generateClientId(): string {
+  return generateId("openclaw-weixin");
+}
+
+/** Build a SendMessageReq containing a single text message. */
+function buildTextMessageReq(params: {
+  to: string;
+  text: string;
+  contextToken?: string;
+  runId?: string;
+  clientId: string;
+}): SendMessageReq {
+  const { to, text, contextToken, runId, clientId } = params;
+  const item_list: MessageItem[] = text
+    ? [{ type: MessageItemType.TEXT, text_item: { text } }]
+    : [];
+  return {
+    msg: {
+      from_user_id: "",
+      to_user_id: to,
+      client_id: clientId,
+      message_type: MessageType.BOT,
+      message_state: MessageState.FINISH,
+      item_list: item_list.length ? item_list : undefined,
+      context_token: contextToken ?? undefined,
+      run_id: runId ?? undefined,
+    },
+  };
+}
+
+/** Build a SendMessageReq from a reply payload (text only; image send uses sendImageMessageWeixin). */
+function buildSendMessageReq(params: {
+  to: string;
+  contextToken?: string;
+  runId?: string;
+  payload: ReplyPayload;
+  clientId: string;
+}): SendMessageReq {
+  const { to, contextToken, runId, payload, clientId } = params;
+  return buildTextMessageReq({
+    to,
+    text: payload.text ?? "",
+    contextToken,
+    runId,
+    clientId,
+  });
+}
+
+/**
+ * Send a plain text message downstream.
+ */
+export async function sendMessageWeixin(params: {
+  to: string;
+  text: string;
+  opts: WeixinMessageSendOptions;
+}): Promise<{ messageId: string }> {
+  const { to, text, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  const clientId = generateClientId();
+  const req = buildSendMessageReq({
+    to,
+    contextToken: opts.contextToken,
+    runId: opts.runId,
+    payload: { text },
+    clientId,
+  });
+  try {
+    await sendMessageApi({
+      baseUrl: opts.baseUrl,
+      token: opts.token,
+      timeoutMs: opts.timeoutMs,
+      body: req,
+    });
+  } catch (err) {
+    logger.error(`sendMessageWeixin: failed to=${to} clientId=${clientId} err=${String(err)}`);
+    throw err;
+  }
+  return { messageId: clientId };
+}
+
+/** Send a single structured MessageItem downstream. */
+export async function sendMessageItemWeixin(params: {
+  to: string;
+  item: MessageItem;
+  opts: WeixinMessageSendOptions;
+  clientId?: string;
+  label?: string;
+}): Promise<{ messageId: string }> {
+  const { to, item, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendMessageItemWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  const clientId = params.clientId ?? generateClientId();
+  const req: SendMessageReq = {
+    msg: {
+      from_user_id: "",
+      to_user_id: to,
+      client_id: clientId,
+      message_type: MessageType.BOT,
+      message_state: MessageState.FINISH,
+      item_list: [item],
+      context_token: opts.contextToken ?? undefined,
+      run_id: opts.runId,
+    },
+  };
+  try {
+    await sendMessageApi({
+      baseUrl: opts.baseUrl,
+      token: opts.token,
+      timeoutMs: opts.timeoutMs,
+      body: req,
+    });
+  } catch (err) {
+    logger.error(
+      `${params.label ?? "sendMessageItemWeixin"}: failed to=${to} clientId=${clientId} err=${String(err)}`,
+    );
+    throw err;
+  }
+  return { messageId: clientId };
+}
+
+/**
+ * Send one or more MessageItems (optionally preceded by a text caption) downstream.
+ * Each item is sent as its own request so that item_list always has exactly one entry.
+ */
+async function sendMediaItems(params: {
+  to: string;
+  text: string;
+  mediaItem: MessageItem;
+  opts: WeixinMessageSendOptions;
+  label: string;
+}): Promise<{ messageId: string }> {
+  const { to, text, mediaItem, opts, label } = params;
+  const runId = opts.runId;
+
+  const items: MessageItem[] = [];
+  if (text) {
+    items.push({ type: MessageItemType.TEXT, text_item: { text } });
+  }
+  items.push(mediaItem);
+
+  let lastClientId = "";
+  for (const item of items) {
+    lastClientId = generateClientId();
+    const req: SendMessageReq = {
+      msg: {
+        from_user_id: "",
+        to_user_id: to,
+        client_id: lastClientId,
+        message_type: MessageType.BOT,
+        message_state: MessageState.FINISH,
+        item_list: [item],
+        context_token: opts.contextToken ?? undefined,
+        run_id: runId,
+      },
+    };
+    try {
+      await sendMessageApi({
+        baseUrl: opts.baseUrl,
+        token: opts.token,
+        timeoutMs: opts.timeoutMs,
+        body: req,
+      });
+    } catch (err) {
+      logger.error(
+        `${label}: failed to=${to} clientId=${lastClientId} err=${String(err)}`,
+      );
+      throw err;
+    }
+  }
+
+  logger.info(`${label}: success to=${to} clientId=${lastClientId}`);
+  return { messageId: lastClientId };
+}
+
+/**
+ * Send an image message downstream using a previously uploaded file.
+ * Optionally include a text caption as a separate TEXT item before the image.
+ *
+ * ImageItem fields:
+ *   - media.encrypt_query_param: CDN download param
+ *   - media.aes_key: AES key, base64-encoded
+ *   - mid_size: original ciphertext file size
+ */
+export async function sendImageMessageWeixin(params: {
+  to: string;
+  text: string;
+  uploaded: UploadedFileInfo;
+  opts: WeixinMessageSendOptions;
+}): Promise<{ messageId: string }> {
+  const { to, text, uploaded, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendImageMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  logger.info(
+    `sendImageMessageWeixin: to=${to} filekey=${uploaded.filekey} fileSize=${uploaded.fileSize} aeskey=present`,
+  );
+
+  const imageItem: MessageItem = {
+    type: MessageItemType.IMAGE,
+    image_item: {
+      media: {
+        encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+        aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+        encrypt_type: 1,
+      },
+      mid_size: uploaded.fileSizeCiphertext,
+    },
+  };
+
+  return sendMediaItems({ to, text, mediaItem: imageItem, opts, label: "sendImageMessageWeixin" });
+}
+
+/**
+ * Send a video message downstream using a previously uploaded file.
+ * VideoItem: media (CDN ref), video_size (ciphertext bytes).
+ * Includes an optional text caption sent as a separate TEXT item first.
+ */
+export async function sendVideoMessageWeixin(params: {
+  to: string;
+  text: string;
+  uploaded: UploadedFileInfo;
+  opts: WeixinMessageSendOptions;
+}): Promise<{ messageId: string }> {
+  const { to, text, uploaded, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendVideoMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+
+  const videoItem: MessageItem = {
+    type: MessageItemType.VIDEO,
+    video_item: {
+      media: {
+        encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+        aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+        encrypt_type: 1,
+      },
+      video_size: uploaded.fileSizeCiphertext,
+    },
+  };
+
+  return sendMediaItems({ to, text, mediaItem: videoItem, opts, label: "sendVideoMessageWeixin" });
+}
+
+/**
+ * Send a file attachment downstream using a previously uploaded file.
+ * FileItem: media (CDN ref), file_name, len (plaintext bytes as string).
+ * Includes an optional text caption sent as a separate TEXT item first.
+ */
+export async function sendFileMessageWeixin(params: {
+  to: string;
+  text: string;
+  fileName: string;
+  uploaded: UploadedFileInfo;
+  opts: WeixinMessageSendOptions;
+}): Promise<{ messageId: string }> {
+  const { to, text, fileName, uploaded, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendFileMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  const fileItem: MessageItem = {
+    type: MessageItemType.FILE,
+    file_item: {
+      media: {
+        encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+        aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+        encrypt_type: 1,
+      },
+      file_name: fileName,
+      len: String(uploaded.fileSize),
+    },
+  };
+
+  return sendMediaItems({ to, text, mediaItem: fileItem, opts, label: "sendFileMessageWeixin" });
+}

package/src/messaging/slash-commands.ts

@@ -0,0 +1,110 @@
+/**
+ * Weixin 斜杠指令处理模块
+ *
+ * 支持的指令：
+ * - /echo <message>         直接回复消息（不经过 AI），并附带通道耗时统计
+ * - /toggle-debug           开关 debug 模式，启用后每条 AI 回复追加全链路耗时
+ */
+import type { WeixinApiOptions } from "../api/api.js";
+import { logger } from "../util/logger.js";
+
+import { toggleDebugMode, isDebugMode } from "./debug-mode.js";
+import { sendMessageWeixin } from "./send.js";
+
+export interface SlashCommandResult {
+  /** 是否是斜杠指令（true 表示已处理，不需要继续走 AI） */
+  handled: boolean;
+}
+
+export interface SlashCommandContext {
+  to: string;
+  contextToken?: string;
+  baseUrl: string;
+  token?: string;
+  accountId: string;
+  log: (msg: string) => void;
+  errLog: (msg: string) => void;
+}
+
+/** 发送回复消息 */
+async function sendReply(ctx: SlashCommandContext, text: string): Promise<void> {
+  const opts: WeixinApiOptions & { contextToken?: string } = {
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    contextToken: ctx.contextToken,
+  };
+  await sendMessageWeixin({ to: ctx.to, text, opts });
+}
+
+/** 处理 /echo 指令 */
+async function handleEcho(
+  ctx: SlashCommandContext,
+  args: string,
+  receivedAt: number,
+  eventTimestamp?: number,
+): Promise<void> {
+  const message = args.trim();
+  if (message) {
+    await sendReply(ctx, message);
+  }
+  const eventTs = eventTimestamp ?? 0;
+  const platformDelay = eventTs > 0 ? `${receivedAt - eventTs}ms` : "N/A";
+  const timing = [
+    "⏱ 通道耗时",
+    `├ 事件时间: ${eventTs > 0 ? new Date(eventTs).toISOString() : "N/A"}`,
+    `├ 平台→插件: ${platformDelay}`,
+    `└ 插件处理: ${Date.now() - receivedAt}ms`,
+  ].join("\n");
+  await sendReply(ctx, timing);
+}
+
+/**
+ * 尝试处理斜杠指令
+ *
+ * @returns handled=true 表示该消息已作为指令处理，不需要继续走 AI 管道
+ */
+export async function handleSlashCommand(
+  content: string,
+  ctx: SlashCommandContext,
+  receivedAt: number,
+  eventTimestamp?: number,
+): Promise<SlashCommandResult> {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("/")) {
+    return { handled: false };
+  }
+
+  const spaceIdx = trimmed.indexOf(" ");
+  const command = spaceIdx === -1 ? trimmed.toLowerCase() : trimmed.slice(0, spaceIdx).toLowerCase();
+  const args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
+
+  logger.info(`[weixin] Slash command: ${command}, args: ${args.slice(0, 50)}`);
+
+  try {
+    switch (command) {
+      case "/echo":
+        await handleEcho(ctx, args, receivedAt, eventTimestamp);
+        return { handled: true };
+      case "/toggle-debug": {
+        const enabled = toggleDebugMode(ctx.accountId);
+        await sendReply(
+          ctx,
+          enabled
+            ? "Debug 模式已开启"
+            : "Debug 模式已关闭",
+        );
+        return { handled: true };
+      }
+      default:
+        return { handled: false };
+    }
+  } catch (err) {
+    logger.error(`[weixin] Slash command error: ${String(err)}`);
+    try {
+      await sendReply(ctx, `❌ 指令执行失败: ${String(err).slice(0, 200)}`);
+    } catch {
+      // 发送错误消息也失败了，只能记日志
+    }
+    return { handled: true };
+  }
+}

package/src/monitor/monitor.ts

@@ -0,0 +1,224 @@
+import type { ChannelAccountSnapshot } from "openclaw/plugin-sdk/channel-contract";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
+
+import { getUpdates, classifyFetchError } from "../api/api.js";
+import { WeixinConfigManager } from "../api/config-cache.js";
+import { STALE_TOKEN_ERRCODE, pauseSession, getRemainingPauseMs } from "../api/session-guard.js";
+import { processOneMessage } from "../messaging/process-message.js";
+import { getSyncBufFilePath, loadGetUpdatesBuf, saveGetUpdatesBuf } from "../storage/sync-buf.js";
+import { logger } from "../util/logger.js";
+import type { Logger } from "../util/logger.js";
+import { redactBody } from "../util/redact.js";
+
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const BACKOFF_DELAY_MS = 30_000;
+const RETRY_DELAY_MS = 2_000;
+
+export type MonitorWeixinOpts = {
+  baseUrl: string;
+  cdnBaseUrl: string;
+  token?: string;
+  accountId: string;
+  /** When non-empty, only messages whose from_user_id is in this list are processed. */
+  allowFrom?: string[];
+  config: import("openclaw/plugin-sdk/core").OpenClawConfig;
+  runtime?: { log?: (msg: string) => void; error?: (msg: string) => void };
+  /**
+   * Gateway-injected channel runtime surface (reply/routing/session/media/commands/...).
+   * Required for inbound message processing; provided by `ChannelGatewayContext.channelRuntime`.
+   */
+  channelRuntime: PluginRuntime["channel"];
+  abortSignal?: AbortSignal;
+  longPollTimeoutMs?: number;
+  /** Gateway status callback — called on each successful poll and inbound message. */
+  setStatus?: (next: ChannelAccountSnapshot) => void;
+};
+
+/**
+ * Long-poll loop: getUpdates -> normalize -> recordInboundSession -> dispatchReplyFromConfig.
+ * Runs until abort.
+ */
+export async function monitorWeixinProvider(opts: MonitorWeixinOpts): Promise<void> {
+  const {
+    baseUrl,
+    cdnBaseUrl,
+    token,
+    accountId,
+    config,
+    channelRuntime,
+    abortSignal,
+    longPollTimeoutMs,
+    setStatus,
+  } = opts;
+  const log = opts.runtime?.log ?? (() => {});
+  const errLog = opts.runtime?.error ?? ((m: string) => log(m));
+  const aLog: Logger = logger.withAccount(accountId);
+
+  if (!channelRuntime) {
+    const msg =
+      "channelRuntime missing on monitor opts; gateway must inject ChannelGatewayContext.channelRuntime";
+    aLog.error(msg);
+    throw new Error(msg);
+  }
+
+  log(`weixin monitor started (${baseUrl}, account=${accountId})`);
+  aLog.info(
+    `Monitor started: baseUrl=${baseUrl} timeoutMs=${longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS}`,
+  );
+
+  const syncFilePath = getSyncBufFilePath(accountId);
+  aLog.debug(`syncFilePath: ${syncFilePath}`);
+
+  const previousGetUpdatesBuf = loadGetUpdatesBuf(syncFilePath);
+  let getUpdatesBuf = previousGetUpdatesBuf ?? "";
+
+  if (previousGetUpdatesBuf) {
+    log(`[weixin] resuming from previous sync buf (${getUpdatesBuf.length} bytes)`);
+    aLog.debug(`Using previous get_updates_buf (${getUpdatesBuf.length} bytes)`);
+  } else {
+    log(`[weixin] no previous sync buf, starting fresh`);
+    aLog.info(`No previous get_updates_buf found, starting fresh`);
+  }
+
+  const configManager = new WeixinConfigManager({ baseUrl, token }, log);
+
+  let nextTimeoutMs = longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+  let consecutiveFailures = 0;
+
+  while (!abortSignal?.aborted) {
+    try {
+      aLog.debug(
+        `getUpdates: get_updates_buf=${getUpdatesBuf.substring(0, 50)}..., timeoutMs=${nextTimeoutMs}`,
+      );
+      const resp = await getUpdates({
+        baseUrl,
+        token,
+        get_updates_buf: getUpdatesBuf,
+        timeoutMs: nextTimeoutMs,
+        // Stop/hot-reload should cancel the in-flight long-poll immediately
+        // instead of waiting for the server-side long-poll timeout.
+        abortSignal,
+      });
+      aLog.debug(
+        `getUpdates response: ret=${resp.ret}, msgs=${resp.msgs?.length ?? 0}, get_updates_buf_length=${resp.get_updates_buf?.length ?? 0}`,
+      );
+
+      if (resp.longpolling_timeout_ms != null && resp.longpolling_timeout_ms > 0) {
+        nextTimeoutMs = resp.longpolling_timeout_ms;
+        aLog.debug(`Updated next poll timeout: ${nextTimeoutMs}ms`);
+      }
+      const isApiError =
+        (resp.ret !== undefined && resp.ret !== 0) ||
+        (resp.errcode !== undefined && resp.errcode !== 0);
+      if (isApiError) {
+        const isStaleToken =
+          resp.errcode === STALE_TOKEN_ERRCODE || resp.ret === STALE_TOKEN_ERRCODE;
+
+        if (isStaleToken) {
+          pauseSession(accountId);
+          const pauseMs = getRemainingPauseMs(accountId);
+          aLog.error(
+            `getUpdates: token for ${accountId} is stale, pausing all requests for ${Math.ceil(pauseMs / 60_000)} min`,
+          );
+          consecutiveFailures = 0;
+          await sleep(pauseMs, abortSignal);
+          continue;
+        }
+
+        consecutiveFailures += 1;
+        errLog(
+          `weixin getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ""} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`,
+        );
+        aLog.error(
+          `getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg} response=${redactBody(JSON.stringify(resp))}`,
+        );
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          errLog(
+            `weixin getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`,
+          );
+          aLog.error(
+            `getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`,
+          );
+          consecutiveFailures = 0;
+          await sleep(BACKOFF_DELAY_MS, abortSignal);
+        } else {
+          await sleep(RETRY_DELAY_MS, abortSignal);
+        }
+        continue;
+      }
+      consecutiveFailures = 0;
+      setStatus?.({ accountId, lastEventAt: Date.now() });
+      if (resp.get_updates_buf != null && resp.get_updates_buf !== "") {
+        saveGetUpdatesBuf(syncFilePath, resp.get_updates_buf);
+        getUpdatesBuf = resp.get_updates_buf;
+        aLog.debug(`Saved new get_updates_buf (${getUpdatesBuf.length} bytes)`);
+      }
+      const list = resp.msgs ?? [];
+      for (const full of list) {
+        aLog.info(
+          `inbound message: from=${full.from_user_id} types=${full.item_list?.map((i) => i.type).join(",") ?? "none"}`,
+        );
+
+        const now = Date.now();
+        setStatus?.({ accountId, lastEventAt: now, lastInboundAt: now });
+
+        // allowFrom filtering is delegated to processOneMessage via the framework
+        // authorization pipeline (resolveSenderCommandAuthorizationWithRuntime).
+
+        const fromUserId = full.from_user_id ?? "";
+        const cachedConfig = await configManager.getForUser(fromUserId, full.context_token);
+
+        await processOneMessage(full, {
+          accountId,
+          config,
+          channelRuntime,
+          baseUrl,
+          cdnBaseUrl,
+          token,
+          typingTicket: cachedConfig.typingTicket,
+          log: opts.runtime?.log ?? (() => {}),
+          errLog,
+        });
+      }
+    } catch (err) {
+      if (abortSignal?.aborted) {
+        aLog.info(`Monitor stopped (aborted)`);
+        return;
+      }
+      consecutiveFailures += 1;
+      const classified = classifyFetchError(err);
+      errLog(
+        `weixin getUpdates error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${String(err)} type=${classified.type} description=${classified.description}${classified.code ? ` code=${classified.code}` : ""}`,
+      );
+      aLog.error(`getUpdates error: ${String(err)}, type=${classified.type} code=${classified.code ?? "none"}, stack=${(err as Error).stack}`);
+      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        errLog(
+          `weixin getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`,
+        );
+        aLog.error(
+          `getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`,
+        );
+        consecutiveFailures = 0;
+        await sleep(30_000, abortSignal);
+      } else {
+        await sleep(2000, abortSignal);
+      }
+    }
+  }
+  aLog.info(`Monitor ended`);
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        reject(new Error("aborted"));
+      },
+      { once: true },
+    );
+  });
+}