@sunnoy/wecom 1.1.2 → 1.3.0

package/index.js

@@ -1,1077 +1,25 @@
-import { WecomWebhook } from "./webhook.js";
 import { logger } from "./logger.js";
 import { streamManager } from "./stream-manager.js";
-import {
-  generateAgentId,
-  getDynamicAgentConfig,
-  shouldTriggerGroupResponse,
-  extractGroupMessageContent,
-} from "./dynamic-agent.js";
+import { wecomChannelPlugin } from "./wecom/channel-plugin.js";
+import { wecomHttpHandler } from "./wecom/http-handler.js";
+import { responseUrls, setOpenclawConfig, setRuntime, streamMeta } from "./wecom/state.js";
 
-
-const DEFAULT_ACCOUNT_ID = "default";
-
-// =============================================================================
-// 命令白名单配置
-// =============================================================================
-
-// 默认允许的斜杠命令（用户操作安全的命令）
-const DEFAULT_COMMAND_ALLOWLIST = [
-  "/new",      // 新建会话
-  "/compact", // 压缩会话
-  "/help",    // 帮助
-  "/status",  // 状态
-];
-
-// 默认拦截消息
-const DEFAULT_COMMAND_BLOCK_MESSAGE = `⚠️ 该命令不可用。
-
-支持的命令：
-• **/new** - 新建会话
-• **/compact** - 压缩会话（保留上下文摘要）
-• **/help** - 查看帮助
-• **/status** - 查看状态`;
-
-/**
- * 获取命令白名单配置
- */
-function getCommandConfig(config) {
-  const wecom = config?.channels?.wecom || {};
-  const commands = wecom.commands || {};
-  return {
-    allowlist: commands.allowlist || DEFAULT_COMMAND_ALLOWLIST,
-    blockMessage: commands.blockMessage || DEFAULT_COMMAND_BLOCK_MESSAGE,
-    enabled: commands.enabled !== false,  // 默认启用白名单
-  };
-}
-
-/**
- * 检查命令是否在白名单中
- * @param {string} message - 用户消息
- * @param {Object} config - 配置
- * @returns {{ isCommand: boolean, allowed: boolean, command: string | null }}
- */
-function checkCommandAllowlist(message, config) {
-  const trimmed = message.trim();
-
-  // 不是斜杠命令
-  if (!trimmed.startsWith("/")) {
-    return { isCommand: false, allowed: true, command: null };
-  }
-
-  // 提取命令（取第一个空格之前的部分）
-  const command = trimmed.split(/\s+/)[0].toLowerCase();
-
-  const cmdConfig = getCommandConfig(config);
-
-  // 如果白名单功能禁用，允许所有命令
-  if (!cmdConfig.enabled) {
-    return { isCommand: true, allowed: true, command };
-  }
-
-  // 检查是否在白名单中
-  const allowed = cmdConfig.allowlist.some(cmd =>
-    cmd.toLowerCase() === command
-  );
-
-  return { isCommand: true, allowed, command };
-}
-
-// Runtime state (module-level singleton)
-let _runtime = null;
-let _openclawConfig = null;
-const ensuredDynamicAgentIds = new Set();
-let ensureDynamicAgentWriteQueue = Promise.resolve();
-
-/**
- * Set the plugin runtime (called during plugin registration)
- */
-function setRuntime(runtime) {
-  _runtime = runtime;
-}
-
-function getRuntime() {
-  if (!_runtime) {
-    throw new Error("[wecom] Runtime not initialized");
-  }
-  return _runtime;
-}
-
-function upsertAgentIdOnlyEntry(cfg, agentId) {
-  const normalizedId = String(agentId || "").trim().toLowerCase();
-  if (!normalizedId) return false;
-
-  if (!cfg.agents || typeof cfg.agents !== "object") {
-    cfg.agents = {};
-  }
-
-  const currentList = Array.isArray(cfg.agents.list) ? cfg.agents.list : [];
-  const existingIds = new Set(
-    currentList
-      .map((entry) => (entry && typeof entry.id === "string" ? entry.id.trim().toLowerCase() : ""))
-      .filter(Boolean),
-  );
-
-  let changed = false;
-  const nextList = [...currentList];
-
-  // Keep "main" as the explicit default when creating agents.list for the first time.
-  if (nextList.length === 0) {
-    nextList.push({ id: "main" });
-    existingIds.add("main");
-    changed = true;
-  }
-
-  if (!existingIds.has(normalizedId)) {
-    nextList.push({ id: normalizedId });
-    changed = true;
-  }
-
-  if (changed) {
-    cfg.agents.list = nextList;
-  }
-
-  return changed;
-}
-
-async function ensureDynamicAgentListed(agentId) {
-  const normalizedId = String(agentId || "").trim().toLowerCase();
-  if (!normalizedId) return;
-  if (ensuredDynamicAgentIds.has(normalizedId)) return;
-
-  const runtime = getRuntime();
-  const configRuntime = runtime?.config;
-  if (!configRuntime?.loadConfig || !configRuntime?.writeConfigFile) return;
-
-  ensureDynamicAgentWriteQueue = ensureDynamicAgentWriteQueue
-    .then(async () => {
-      if (ensuredDynamicAgentIds.has(normalizedId)) return;
-
-      const latestConfig = configRuntime.loadConfig();
-      if (!latestConfig || typeof latestConfig !== "object") return;
-
-      const changed = upsertAgentIdOnlyEntry(latestConfig, normalizedId);
-      if (changed) {
-        await configRuntime.writeConfigFile(latestConfig);
-        logger.info("WeCom: dynamic agent added to agents.list", { agentId: normalizedId });
-      }
-
-      // Keep runtime in-memory config aligned to avoid stale reads in this process.
-      if (_openclawConfig && typeof _openclawConfig === "object") {
-        upsertAgentIdOnlyEntry(_openclawConfig, normalizedId);
-      }
-
-      ensuredDynamicAgentIds.add(normalizedId);
-    })
-    .catch((err) => {
-      logger.warn("WeCom: failed to sync dynamic agent into agents.list", {
-        agentId: normalizedId,
-        error: err?.message || String(err),
-      });
-    });
-
-  await ensureDynamicAgentWriteQueue;
-}
-
-// Webhook targets registry (similar to Google Chat)
-const webhookTargets = new Map();
-
-// Track active stream for each user, so outbound messages (like reset confirmation) 
-// can be added to the correct stream instead of using response_url
-const activeStreams = new Map();
-
-function normalizeWecomAllowFromEntry(raw) {
-  const trimmed = String(raw ?? "").trim();
-  if (!trimmed) return null;
-  if (trimmed === "*") return "*";
-  return trimmed.replace(/^(wecom|wework):/i, "").replace(/^user:/i, "").toLowerCase();
-}
-
-function resolveWecomAllowFrom(cfg, accountId) {
-  const wecom = cfg?.channels?.wecom;
-  if (!wecom) return [];
-
-  const normalizedAccountId = String(accountId || DEFAULT_ACCOUNT_ID).trim().toLowerCase();
-  const accounts = wecom.accounts;
-  const account =
-    accounts && typeof accounts === "object"
-      ? accounts[accountId] ??
-      accounts[
-      Object.keys(accounts).find((key) => key.toLowerCase() === normalizedAccountId) ?? ""
-      ]
-      : undefined;
-
-  const allowFromRaw =
-    account?.dm?.allowFrom ?? account?.allowFrom ?? wecom.dm?.allowFrom ?? wecom.allowFrom ?? [];
-
-  if (!Array.isArray(allowFromRaw)) return [];
-
-  return allowFromRaw
-    .map(normalizeWecomAllowFromEntry)
-    .filter((entry) => Boolean(entry));
-}
-
-function resolveWecomCommandAuthorized({ cfg, accountId, senderId }) {
-  const sender = String(senderId ?? "").trim().toLowerCase();
-  if (!sender) return false;
-
-  const allowFrom = resolveWecomAllowFrom(cfg, accountId);
-  if (allowFrom.includes("*") || allowFrom.length === 0) return true;
-  return allowFrom.includes(sender);
-}
-
-function normalizeWebhookPath(raw) {
-  const trimmed = (raw || "").trim();
-  if (!trimmed) return "/";
-  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  if (withSlash.length > 1 && withSlash.endsWith("/")) {
-    return withSlash.slice(0, -1);
-  }
-  return withSlash;
-}
-
-function registerWebhookTarget(target) {
-  const key = normalizeWebhookPath(target.path);
-  const existing = webhookTargets.get(key) ?? [];
-  webhookTargets.set(key, [...existing, { ...target, path: key }]);
-  return () => {
-    const updated = (webhookTargets.get(key) ?? []).filter((e) => e !== target);
-    if (updated.length > 0) {
-      webhookTargets.set(key, updated);
-    } else {
-      webhookTargets.delete(key);
-    }
-  };
-}
-
-// =============================================================================
-// Channel Plugin Definition
-// =============================================================================
-
-const wecomChannelPlugin = {
-  id: "wecom",
-  meta: {
-    id: "wecom",
-    label: "Enterprise WeChat",
-    selectionLabel: "Enterprise WeChat (AI Bot)",
-    docsPath: "/channels/wecom",
-    blurb: "Enterprise WeChat AI Bot channel plugin.",
-    aliases: ["wecom", "wework"],
-  },
-  capabilities: {
-    chatTypes: ["direct", "group"],  // 支持私聊和群聊
-    reactions: false,
-    threads: false,
-    media: true,  // Supports image sending via base64 encoding
-    nativeCommands: false,
-    blockStreaming: true, // WeCom AI Bot uses stream response format
-  },
-  reload: { configPrefixes: ["channels.wecom"] },
-  configSchema: {
-    schema: {
-      "$schema": "http://json-schema.org/draft-07/schema#",
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "enabled": {
-          "type": "boolean",
-          "description": "Enable WeCom channel",
-          "default": true
-        },
-        "token": {
-          "type": "string",
-          "description": "WeCom bot token from admin console"
-        },
-        "encodingAesKey": {
-          "type": "string",
-          "description": "WeCom message encryption key (43 characters)",
-          "minLength": 43,
-          "maxLength": 43
-        },
-        "commands": {
-          "type": "object",
-          "description": "Command whitelist configuration",
-          "additionalProperties": false,
-          "properties": {
-            "enabled": {
-              "type": "boolean",
-              "description": "Enable command whitelist filtering",
-              "default": true
-            },
-            "allowlist": {
-              "type": "array",
-              "description": "Allowed commands (e.g., /new, /status, /help)",
-              "items": {
-                "type": "string"
-              },
-              "default": ["/new", "/status", "/help", "/compact"]
-            }
-          }
-        },
-        "dynamicAgents": {
-          "type": "object",
-          "description": "Dynamic agent routing configuration",
-          "additionalProperties": false,
-          "properties": {
-            "enabled": {
-              "type": "boolean",
-              "description": "Enable per-user/per-group agent isolation",
-              "default": true
-            }
-          }
-        },
-        "dm": {
-          "type": "object",
-          "description": "Direct message (private chat) configuration",
-          "additionalProperties": false,
-          "properties": {
-            "createAgentOnFirstMessage": {
-              "type": "boolean",
-              "description": "Create separate agent for each user",
-              "default": true
-            }
-          }
-        },
-        "groupChat": {
-          "type": "object",
-          "description": "Group chat configuration",
-          "additionalProperties": false,
-          "properties": {
-            "enabled": {
-              "type": "boolean",
-              "description": "Enable group chat support",
-              "default": true
-            },
-            "requireMention": {
-              "type": "boolean",
-              "description": "Only respond when @mentioned in groups",
-              "default": true
-            }
-          }
-        }
-      }
-    },
-    uiHints: {
-      "token": {
-        "sensitive": true,
-        "label": "Bot Token"
-      },
-      "encodingAesKey": {
-        "sensitive": true,
-        "label": "Encoding AES Key",
-        "help": "43-character encryption key from WeCom admin console"
-      }
+// Periodic cleanup for streamMeta and expired responseUrls to prevent memory leaks.
+setInterval(() => {
+  const now = Date.now();
+  // Clean streamMeta entries whose stream no longer exists in streamManager.
+  for (const streamId of streamMeta.keys()) {
+    if (!streamManager.hasStream(streamId)) {
+      streamMeta.delete(streamId);
     }
-  },
-  config: {
-    listAccountIds: (cfg) => {
-      const wecom = cfg?.channels?.wecom;
-      if (!wecom || !wecom.enabled) return [];
-      return [DEFAULT_ACCOUNT_ID];
-    },
-    resolveAccount: (cfg, accountId) => {
-      const wecom = cfg?.channels?.wecom;
-      if (!wecom) return null;
-      return {
-        id: accountId || DEFAULT_ACCOUNT_ID,
-        accountId: accountId || DEFAULT_ACCOUNT_ID,
-        enabled: wecom.enabled !== false,
-        token: wecom.token || "",
-        encodingAesKey: wecom.encodingAesKey || "",
-        webhookPath: wecom.webhookPath || "/webhooks/wecom",
-        config: wecom,
-      };
-    },
-    defaultAccountId: (cfg) => {
-      const wecom = cfg?.channels?.wecom;
-      if (!wecom || !wecom.enabled) return null;
-      return DEFAULT_ACCOUNT_ID;
-    },
-    setAccountEnabled: ({ cfg, accountId, enabled }) => {
-      if (!cfg.channels) cfg.channels = {};
-      if (!cfg.channels.wecom) cfg.channels.wecom = {};
-      cfg.channels.wecom.enabled = enabled;
-      return cfg;
-    },
-    deleteAccount: ({ cfg, accountId }) => {
-      if (cfg.channels?.wecom) delete cfg.channels.wecom;
-      return cfg;
-    },
-  },
-  directory: {
-    self: async () => null,
-    listPeers: async () => [],
-    listGroups: async () => [],
-  },
-  // Outbound adapter: Send messages via stream (all messages go through stream now)
-  outbound: {
-    sendText: async ({ cfg, to, text, accountId }) => {
-      // to格式: \"wecom:userid\" 或 \"userid\"
-      const userId = to.replace(/^wecom:/, "");
-
-      // 获取该用户当前活跃的 streamId
-      const streamId = activeStreams.get(userId);
-
-      if (streamId && streamManager.hasStream(streamId)) {
-        logger.debug("Appending outbound text to stream", { userId, streamId, text: text.substring(0, 30) });
-        // 使用 appendStream 追加内容，保留之前的内容
-        const stream = streamManager.getStream(streamId);
-        const separator = stream && stream.content.length > 0 ? "\n\n" : "";
-        streamManager.appendStream(streamId, separator + text);
-
-        return {
-          channel: "wecom",
-          messageId: `msg_stream_${Date.now()}`,
-        };
-      }
-
-      // 如果没有活跃的流，记录警告
-      logger.warn("WeCom outbound: no active stream for user", { userId });
-
-      return {
-        channel: "wecom",
-        messageId: `fake_${Date.now()}`,
-      };
-    },
-    sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
-      const userId = to.replace(/^wecom:/, "");
-      const streamId = activeStreams.get(userId);
-
-      if (streamId && streamManager.hasStream(streamId)) {
-        // Check if mediaUrl is a local path (sandbox: prefix or absolute path)
-        const isLocalPath = mediaUrl.startsWith("sandbox:") || mediaUrl.startsWith("/");
-
-        if (isLocalPath) {
-          // Convert sandbox: URLs to absolute paths
-          // Support both sandbox:/ and sandbox:// formats
-          const absolutePath = mediaUrl
-            .replace(/^sandbox:\/\//, "")
-            .replace(/^sandbox:\//, "");
-
-          logger.debug("Queueing local image for stream", {
-            userId,
-            streamId,
-            mediaUrl,
-            absolutePath
-          });
-
-          // Queue the image for processing when stream finishes
-          const queued = streamManager.queueImage(streamId, absolutePath);
-
-          if (queued) {
-            // Append text content to stream (without markdown image)
-            if (text) {
-              const stream = streamManager.getStream(streamId);
-              const separator = stream && stream.content.length > 0 ? "\n\n" : "";
-              streamManager.appendStream(streamId, separator + text);
-            }
-
-            // Append placeholder indicating image will follow
-            const imagePlaceholder = "\n\n[图片]";
-            streamManager.appendStream(streamId, imagePlaceholder);
-
-            return {
-              channel: "wecom",
-              messageId: `msg_stream_img_${Date.now()}`,
-            };
-          } else {
-            logger.warn("Failed to queue image, falling back to markdown", {
-              userId,
-              streamId,
-              mediaUrl
-            });
-            // Fallback to old behavior
-          }
-        }
-
-        // OLD BEHAVIOR: For external URLs or if queueing failed, use markdown
-        const content = text ? `${text}\n\n![image](${mediaUrl})` : `![image](${mediaUrl})`;
-        logger.debug("Appending outbound media to stream (markdown)", {
-          userId,
-          streamId,
-          mediaUrl
-        });
-
-        // 使用 appendStream 追加内容
-        const stream = streamManager.getStream(streamId);
-        const separator = stream && stream.content.length > 0 ? "\n\n" : "";
-        streamManager.appendStream(streamId, separator + content);
-
-        return {
-          channel: "wecom",
-          messageId: `msg_stream_${Date.now()}`,
-        };
-      }
-
-      logger.warn("WeCom outbound sendMedia: no active stream", { userId });
-
-      return {
-        channel: "wecom",
-        messageId: `fake_${Date.now()}`,
-      };
-    },
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      logger.info("WeCom gateway starting", { accountId: account.accountId, webhookPath: account.webhookPath });
-
-      const unregister = registerWebhookTarget({
-        path: account.webhookPath || "/webhooks/wecom",
-        account,
-        config: ctx.cfg,
-      });
-
-      return {
-        shutdown: async () => {
-          logger.info("WeCom gateway shutting down");
-          unregister();
-        },
-      };
-    },
-  },
-};
-
-// =============================================================================
-// HTTP Webhook Handler
-// =============================================================================
-
-async function wecomHttpHandler(req, res) {
-  const url = new URL(req.url || "", "http://localhost");
-  const path = normalizeWebhookPath(url.pathname);
-  const targets = webhookTargets.get(path);
-
-  if (!targets || targets.length === 0) {
-    return false; // Not handled by this plugin
   }
-
-  const query = Object.fromEntries(url.searchParams);
-  logger.debug("WeCom HTTP request", { method: req.method, path });
-
-  // GET: URL Verification
-  if (req.method === "GET") {
-    const target = targets[0]; // Use first target for verification
-    if (!target) {
-      res.writeHead(503, { "Content-Type": "text/plain" });
-      res.end("No webhook target configured");
-      return true;
+  // Clean expired responseUrls (older than 1 hour).
+  for (const [key, entry] of responseUrls.entries()) {
+    if (now > entry.expiresAt) {
+      responseUrls.delete(key);
     }
-
-    const webhook = new WecomWebhook({
-      token: target.account.token,
-      encodingAesKey: target.account.encodingAesKey,
-    });
-
-    const echo = webhook.handleVerify(query);
-    if (echo) {
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end(echo);
-      logger.info("WeCom URL verification successful");
-      return true;
-    }
-
-    res.writeHead(403, { "Content-Type": "text/plain" });
-    res.end("Verification failed");
-    logger.warn("WeCom URL verification failed");
-    return true;
   }
-
-  // POST: Message handling
-  if (req.method === "POST") {
-    const target = targets[0];
-    if (!target) {
-      res.writeHead(503, { "Content-Type": "text/plain" });
-      res.end("No webhook target configured");
-      return true;
-    }
-
-    // Read request body
-    const chunks = [];
-    for await (const chunk of req) {
-      chunks.push(chunk);
-    }
-    const body = Buffer.concat(chunks).toString("utf-8");
-    logger.debug("WeCom message received", { bodyLength: body.length });
-
-    const webhook = new WecomWebhook({
-      token: target.account.token,
-      encodingAesKey: target.account.encodingAesKey,
-    });
-
-    const result = await webhook.handleMessage(query, body);
-    if (!result) {
-      res.writeHead(400, { "Content-Type": "text/plain" });
-      res.end("Bad Request");
-      return true;
-    }
-
-    // Handle text message
-    if (result.message) {
-      const msg = result.message;
-      const { timestamp, nonce } = result.query;
-      const content = (msg.content || "").trim();
-
-      // 统一使用流式回复处理所有消息（包括命令）
-      // 企业微信 AI Bot 的 response_url 只能使用一次，
-      // 所以必须通过流式来发送所有回复内容
-      const streamId = `stream_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-      streamManager.createStream(streamId);
-
-      // 被动回复：返回流式消息ID (同步响应)
-      const streamResponse = webhook.buildStreamResponse(
-        streamId,
-        "", // 初始内容为空
-        false, // 未完成
-        timestamp,
-        nonce
-      );
-
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(streamResponse);
-
-      logger.info("Stream initiated", { streamId, from: msg.fromUser, isCommand: content.startsWith("/") });
-      // 异步处理消息 - 调用AI并更新流内容
-      processInboundMessage({
-        message: msg,
-        streamId,
-        timestamp,
-        nonce,
-        account: target.account,
-        config: target.config,
-      }).catch(async (err) => {
-        logger.error("WeCom message processing failed", { error: err.message });
-        // 即使失败也要标记流为完成
-        await streamManager.finishStream(streamId);
-      });
-
-      return true;
-    }
-
-    // Handle stream refresh - return current stream state
-    if (result.stream) {
-      const { timestamp, nonce } = result.query;
-      const streamId = result.stream.id;
-
-      // 获取流的当前状态
-      const stream = streamManager.getStream(streamId);
-
-      if (!stream) {
-        // 流不存在或已过期,返回空的完成响应
-        logger.warn("Stream not found for refresh", { streamId });
-        const streamResponse = webhook.buildStreamResponse(
-          streamId,
-          "会话已过期",
-          true,
-          timestamp,
-          nonce
-        );
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(streamResponse);
-        return true;
-      }
-
-      // 返回当前流的内容
-      const streamResponse = webhook.buildStreamResponse(
-        streamId,
-        stream.content,
-        stream.finished,
-        timestamp,
-        nonce,
-        // Pass msgItem when stream is finished and has images
-        stream.finished && stream.msgItem.length > 0
-          ? { msgItem: stream.msgItem }
-          : {}
-      );
-
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(streamResponse);
-
-      logger.debug("Stream refresh response sent", {
-        streamId,
-        contentLength: stream.content.length,
-        finished: stream.finished
-      });
-
-      // 如果流已完成,在一段时间后清理
-      if (stream.finished) {
-        setTimeout(() => {
-          streamManager.deleteStream(streamId);
-        }, 30 * 1000); // 30秒后清理
-      }
-
-      return true;
-    }
-
-    // Handle event
-    if (result.event) {
-      logger.info("WeCom event received", { event: result.event });
-
-      // 处理进入会话事件 - 发送欢迎语
-      if (result.event?.event_type === "enter_chat") {
-        const { timestamp, nonce } = result.query;
-        const fromUser = result.event?.from?.userid || "";
-
-        // 欢迎语内容
-        const welcomeMessage = `你好！👋 我是 AI 助手。
-
-你可以使用下面的指令管理会话：
-• **/new** - 新建会话（清空上下文）
-• **/compact** - 压缩会话（保留上下文摘要）
-• **/help** - 查看更多命令
-
-有什么我可以帮你的吗？`;
-
-        // 创建流并返回欢迎语
-        const streamId = `welcome_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        streamManager.createStream(streamId);
-        streamManager.appendStream(streamId, welcomeMessage);
-        await streamManager.finishStream(streamId);
-
-        const streamResponse = webhook.buildStreamResponse(
-          streamId,
-          welcomeMessage,
-          true,  // 直接完成
-          timestamp,
-          nonce
-        );
-
-        logger.info("Sending welcome message", { fromUser, streamId });
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(streamResponse);
-        return true;
-      }
-
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end("success");
-      return true;
-    }
-
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.end("success");
-    return true;
-  }
-
-  res.writeHead(405, { "Content-Type": "text/plain" });
-  res.end("Method Not Allowed");
-  return true;
-}
-
-// =============================================================================
-// Inbound Message Processing (triggers AI response)
-// =============================================================================
-
-async function processInboundMessage({ message, streamId, timestamp, nonce, account, config }) {
-  const runtime = getRuntime();
-  const core = runtime.channel;
-
-  const senderId = message.fromUser;
-  const rawContent = message.content || "";
-  const responseUrl = message.responseUrl;
-  const chatType = message.chatType || "single";  // "single" 或 "group"
-  const chatId = message.chatId || "";  // 群聊 ID
-  const isGroupChat = chatType === "group" && chatId;
-
-  // 确定 peerId：群聊用 chatId，私聊用 senderId
-  const peerId = isGroupChat ? chatId : senderId;
-  const peerKind = isGroupChat ? "group" : "dm";
-  const conversationId = isGroupChat ? `wecom:group:${chatId}` : `wecom:${senderId}`;
-
-  // 设置用户当前活跃的 streamId，供 outbound.sendText 使用
-  // 群聊时用 chatId 作为 key
-  const streamKey = isGroupChat ? chatId : senderId;
-  if (streamId) {
-    activeStreams.set(streamKey, streamId);
-  }
-
-  // 群聊消息检查：是否满足触发条件（@提及）
-  let rawBody = rawContent;
-  if (isGroupChat) {
-    if (!shouldTriggerGroupResponse(rawContent, config)) {
-      logger.debug("WeCom: group message ignored (no mention)", { chatId, senderId });
-      return;
-    }
-    // 提取实际内容（移除 @提及）
-    rawBody = extractGroupMessageContent(rawContent, config);
-  }
-
-  const commandAuthorized = resolveWecomCommandAuthorized({
-    cfg: config,
-    accountId: account.accountId,
-    senderId,
-  });
-
-  if (!rawBody.trim()) {
-    logger.debug("WeCom: empty message, skipping");
-    return;
-  }
-
-  // ========================================================================
-  // 命令白名单检查
-  // ========================================================================
-  const commandCheck = checkCommandAllowlist(rawBody, config);
-
-  if (commandCheck.isCommand && !commandCheck.allowed) {
-    // 命令不在白名单中，返回拒绝消息
-    const cmdConfig = getCommandConfig(config);
-    logger.warn("WeCom: blocked command", {
-      command: commandCheck.command,
-      from: senderId,
-      chatType: peerKind
-    });
-
-    // 通过流式响应返回拦截消息
-    if (streamId) {
-      streamManager.appendStream(streamId, cmdConfig.blockMessage);
-      await streamManager.finishStream(streamId);
-      activeStreams.delete(streamKey);
-    }
-    return;
-  }
-
-  logger.info("WeCom processing message", {
-    from: senderId,
-    chatType: peerKind,
-    peerId,
-    content: rawBody.substring(0, 50),
-    streamId,
-    isCommand: commandCheck.isCommand,
-    command: commandCheck.command
-  });
-
-  // ========================================================================
-  // 动态 Agent 逻辑（极简版）
-  // 只需要生成 agentId 和构造 SessionKey，OpenClaw 会自动创建 workspace
-  // ========================================================================
-  const dynamicConfig = getDynamicAgentConfig(config);
-
-  // 生成目标 AgentId
-  const targetAgentId = dynamicConfig.enabled ? generateAgentId(peerKind, peerId) : null;
-
-  if (targetAgentId) {
-    await ensureDynamicAgentListed(targetAgentId);
-    logger.debug("Using dynamic agent", { agentId: targetAgentId, chatType: peerKind, peerId });
-  }
-
-  // ========================================================================
-  // 路由到目标 Agent
-  // ========================================================================
-  const route = core.routing.resolveAgentRoute({
-    cfg: config,
-    channel: "wecom",
-    accountId: account.accountId,
-    peer: {
-      kind: peerKind,
-      id: peerId,
-    },
-  });
-
-  // 使用动态 Agent，覆盖默认路由
-  if (targetAgentId) {
-    route.agentId = targetAgentId;
-    route.sessionKey = `agent:${targetAgentId}:${peerKind}:${peerId}`;
-  }
-
-
-  // Build inbound context
-  const storePath = core.session.resolveStorePath(config.session?.store, {
-    agentId: route.agentId,
-  });
-  const envelopeOptions = core.reply.resolveEnvelopeFormatOptions(config);
-  const previousTimestamp = core.session.readSessionUpdatedAt({
-    storePath,
-    sessionKey: route.sessionKey,
-  });
-
-  // 构建消息头，群聊时显示发送者
-  const senderLabel = isGroupChat ? `[${senderId}]` : senderId;
-  const body = core.reply.formatAgentEnvelope({
-    channel: isGroupChat ? "Enterprise WeChat Group" : "Enterprise WeChat",
-    from: senderLabel,
-    timestamp: Date.now(),
-    previousTimestamp,
-    envelope: envelopeOptions,
-    body: rawBody,
-  });
-
-  const ctxPayload = core.reply.finalizeInboundContext({
-    Body: body,
-    RawBody: rawBody,
-    CommandBody: rawBody,
-    From: `wecom:${senderId}`,
-    To: conversationId,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: isGroupChat ? "group" : "direct",
-    ConversationLabel: isGroupChat ? `群聊 ${chatId}` : senderId,
-    SenderName: senderId,
-    SenderId: senderId,
-    GroupId: isGroupChat ? chatId : undefined,
-    Provider: "wecom",
-    Surface: "wecom",
-    OriginatingChannel: "wecom",
-    OriginatingTo: conversationId,
-    CommandAuthorized: commandAuthorized,
-  });
-
-  // Record session meta
-  void core.session.recordSessionMetaFromInbound({
-    storePath,
-    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-    ctx: ctxPayload,
-  }).catch((err) => {
-    logger.error("WeCom: failed updating session meta", { error: err.message });
-  });
-
-  // Dispatch reply with AI processing
-  await core.reply.dispatchReplyWithBufferedBlockDispatcher({
-    ctx: ctxPayload,
-    cfg: config,
-    dispatcherOptions: {
-      deliver: async (payload, info) => {
-        logger.info("Dispatcher deliver called", {
-          kind: info.kind,
-          hasText: !!(payload.text && payload.text.trim()),
-          textPreview: (payload.text || "").substring(0, 50),
-        });
-
-        await deliverWecomReply({
-          payload,
-          account,
-          responseUrl,
-          senderId: streamKey,  // 使用 streamKey（群聊时是 chatId）
-          streamId,
-        });
-
-        // 如果是最终回复,标记流为完成
-        if (streamId && info.kind === "final") {
-          await streamManager.finishStream(streamId);
-          logger.info("WeCom stream finished", { streamId });
-        }
-      },
-      onError: async (err, info) => {
-        logger.error("WeCom reply failed", { error: err.message, kind: info.kind });
-        // 发生错误时也标记流为完成
-        if (streamId) {
-          await streamManager.finishStream(streamId);
-        }
-      },
-    },
-  });
-
-  // 确保在dispatch完成后标记流为完成（兜底机制）
-  if (streamId) {
-    await streamManager.finishStream(streamId);
-    activeStreams.delete(streamKey);  // 清理活跃流映射
-    logger.info("WeCom stream finished (dispatch complete)", { streamId });
-  }
-}
-
-// =============================================================================
-// Outbound Reply Delivery (Stream-only mode)
-// =============================================================================
-
-async function deliverWecomReply({ payload, account, responseUrl, senderId, streamId }) {
-  const text = payload.text || "";
-
-  logger.debug("deliverWecomReply called", {
-    hasText: !!text.trim(),
-    textPreview: text.substring(0, 50),
-    streamId,
-    senderId,
-  });
-
-  // 处理绝对路径的 MEDIA: 行（OpenClaw 会拒绝它们，所以我们需要手动处理）
-  const mediaRegex = /^MEDIA:\s*(.+)$/gm;
-  const mediaMatches = [];
-  let match;
-  while ((match = mediaRegex.exec(text)) !== null) {
-    const mediaPath = match[1].trim();
-    // 检查是否是绝对路径（以 / 开头）
-    if (mediaPath.startsWith("/")) {
-      mediaMatches.push({
-        fullMatch: match[0],
-        path: mediaPath
-      });
-      logger.debug("Detected absolute path MEDIA line", {
-        streamId,
-        mediaPath,
-        line: match[0]
-      });
-    }
-  }
-
-  // 如果检测到绝对路径的 MEDIA 行，将图片加入队列并从文本中移除
-  let processedText = text;
-  if (mediaMatches.length > 0 && streamId) {
-    for (const media of mediaMatches) {
-      const queued = streamManager.queueImage(streamId, media.path);
-      if (queued) {
-        // 从文本中移除这行
-        processedText = processedText.replace(media.fullMatch, "").trim();
-        logger.info("Queued absolute path image for stream", {
-          streamId,
-          imagePath: media.path
-        });
-      }
-    }
-  }
-
-  // 所有消息都通过流式发送
-  if (!processedText.trim()) {
-    logger.debug("WeCom: empty block after processing, skipping stream update");
-    return;
-  }
-
-  // 辅助函数：追加内容到流（带去重）
-  const appendToStream = (targetStreamId, content) => {
-    const stream = streamManager.getStream(targetStreamId);
-    if (!stream) return false;
-
-    // 去重：检查流内容是否已包含此消息（避免 block + final 重复）
-    if (stream.content.includes(content.trim())) {
-      logger.debug("WeCom: duplicate content, skipping", {
-        streamId: targetStreamId,
-        contentPreview: content.substring(0, 30)
-      });
-      return true;  // 返回 true 表示不需要再发送
-    }
-
-    const separator = stream.content.length > 0 ? "\n\n" : "";
-    streamManager.appendStream(targetStreamId, separator + content);
-    return true;
-  };
-
-  if (!streamId) {
-    // 尝试从 activeStreams 获取
-    const activeStreamId = activeStreams.get(senderId);
-    if (activeStreamId && streamManager.hasStream(activeStreamId)) {
-      appendToStream(activeStreamId, processedText);
-      logger.debug("WeCom stream appended (via activeStreams)", {
-        streamId: activeStreamId,
-        contentLength: processedText.length,
-      });
-      return;
-    }
-    logger.warn("WeCom: no active stream for this message", { senderId });
-    return;
-  }
-
-  if (!streamManager.hasStream(streamId)) {
-    logger.warn("WeCom: stream not found, cannot update", { streamId });
-    return;
-  }
-
-  appendToStream(streamId, processedText);
-  logger.debug("WeCom stream appended", {
-    streamId,
-    contentLength: processedText.length,
-    to: senderId
-  });
-}
-
-// =============================================================================
-// Plugin Registration
-// =============================================================================
+}, 60 * 1000).unref();
 
 const plugin = {
   // Plugin id should match `openclaw.plugin.json` id (and config.plugins.entries key).
@@ -1084,7 +32,7 @@ const plugin = {
 
     // Save runtime for message processing
     setRuntime(api.runtime);
-    _openclawConfig = api.config;
+    setOpenclawConfig(api.config);
 
     // Register channel
     api.registerChannel({ plugin: wecomChannelPlugin });