@nextclaw/channel-runtime 0.1.6 → 0.1.8

package/README.md

@@ -7,3 +7,4 @@ This package is consumed by channel plugin packages such as:
 - `@nextclaw/channel-plugin-telegram`
 - `@nextclaw/channel-plugin-discord`
 - `@nextclaw/channel-plugin-email`
+- `@nextclaw/channel-plugin-wecom`

package/dist/index.d.ts

@@ -64,6 +64,9 @@ declare class DiscordChannel extends BaseChannel<Config["channels"]["discord"]>
     send(msg: OutboundMessage): Promise<void>;
     private handleIncoming;
     private resolveProxyAgent;
+    private resolveAccountId;
+    private isAllowedByPolicy;
+    private resolveMentionState;
     private resolveInboundAttachment;
     private startTyping;
     private stopTyping;
@@ -192,6 +195,8 @@ declare class TelegramChannel extends BaseChannel<Config["channels"]["telegram"]
     private sessionManager?;
     name: string;
     private bot;
+    private botUserId;
+    private botUsername;
     private readonly typingController;
     private transcriber;
     constructor(config: Config["channels"]["telegram"], bus: MessageBus, groqApiKey?: string, sessionManager?: SessionManager | undefined);
@@ -202,6 +207,28 @@ declare class TelegramChannel extends BaseChannel<Config["channels"]["telegram"]
     private dispatchToBus;
     private startTyping;
     private stopTyping;
+    private resolveAccountId;
+    private isAllowedByPolicy;
+    private resolveMentionState;
+}
+
+declare class WeComChannel extends BaseChannel<Config["channels"]["wecom"]> {
+    name: string;
+    private server;
+    private accessToken;
+    private tokenExpiry;
+    private processedIds;
+    private processedSet;
+    constructor(config: Config["channels"]["wecom"], bus: MessageBus);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(msg: OutboundMessage): Promise<void>;
+    private handleCallbackRequest;
+    private handleVerificationRequest;
+    private handleInboundMessageRequest;
+    private verifySignature;
+    private getAccessToken;
+    private isDuplicate;
 }
 
 declare class WhatsAppChannel extends BaseChannel<Config["channels"]["whatsapp"]> {
@@ -256,6 +283,11 @@ declare const BUILTIN_CHANNEL_RUNTIMES: {
         readonly isEnabled: (config: Config) => boolean;
         readonly createChannel: (context: BuiltinChannelCreateContext) => DingTalkChannel;
     };
+    readonly wecom: {
+        readonly id: "wecom";
+        readonly isEnabled: (config: Config) => boolean;
+        readonly createChannel: (context: BuiltinChannelCreateContext) => WeComChannel;
+    };
     readonly email: {
         readonly id: "email";
         readonly isEnabled: (config: Config) => boolean;
@@ -277,4 +309,4 @@ declare const BUILTIN_CHANNEL_PLUGIN_IDS: BuiltinChannelId[];
 declare function listBuiltinChannelRuntimes(): BuiltinChannelRuntime[];
 declare function resolveBuiltinChannelRuntime(channelId: string): BuiltinChannelRuntime;
 
-export { BUILTIN_CHANNEL_PLUGIN_IDS, type BuiltinChannelId, type BuiltinChannelRuntime, DingTalkChannel, DiscordChannel, EmailChannel, FeishuChannel, MochatChannel, QQChannel, SlackChannel, TelegramChannel, WhatsAppChannel, listBuiltinChannelRuntimes, resolveBuiltinChannelRuntime };
+export { BUILTIN_CHANNEL_PLUGIN_IDS, type BuiltinChannelId, type BuiltinChannelRuntime, DingTalkChannel, DiscordChannel, EmailChannel, FeishuChannel, MochatChannel, QQChannel, SlackChannel, TelegramChannel, WeComChannel, WhatsAppChannel, listBuiltinChannelRuntimes, resolveBuiltinChannelRuntime };

package/dist/index.js

@@ -316,7 +316,12 @@ var DiscordChannel = class extends BaseChannel {
     }
     const senderId = message.author.id;
     const channelId = message.channelId;
-    if (!this.isAllowed(senderId)) {
+    const isGroup = Boolean(message.guildId);
+    if (!this.isAllowedByPolicy({ senderId, channelId, isGroup })) {
+      return;
+    }
+    const mentionState = this.resolveMentionState({ message, selfUserId, channelId, isGroup });
+    if (mentionState.requireMention && !mentionState.wasMentioned) {
       return;
     }
     const contentParts = [];
@@ -358,8 +363,16 @@ var DiscordChannel = class extends BaseChannel {
         attachments,
         metadata: {
           message_id: message.id,
+          channel_id: channelId,
           guild_id: message.guildId,
           reply_to: replyTo,
+          account_id: this.resolveAccountId(),
+          accountId: this.resolveAccountId(),
+          is_group: isGroup,
+          peer_kind: isGroup ? "channel" : "direct",
+          peer_id: isGroup ? channelId : senderId,
+          was_mentioned: mentionState.wasMentioned,
+          require_mention: mentionState.requireMention,
           ...attachmentIssues.length ? { attachment_issues: attachmentIssues } : {}
         }
       });
@@ -378,6 +391,62 @@ var DiscordChannel = class extends BaseChannel {
       return null;
     }
   }
+  resolveAccountId() {
+    const accountId = this.config.accountId?.trim();
+    return accountId || "default";
+  }
+  isAllowedByPolicy(params) {
+    if (!params.isGroup) {
+      if (this.config.dmPolicy === "disabled") {
+        return false;
+      }
+      const allowFrom = this.config.allowFrom ?? [];
+      if (this.config.dmPolicy === "allowlist" || this.config.dmPolicy === "pairing") {
+        return this.isAllowed(params.senderId);
+      }
+      if (allowFrom.includes("*")) {
+        return true;
+      }
+      return allowFrom.length === 0 ? true : this.isAllowed(params.senderId);
+    }
+    if (this.config.groupPolicy === "disabled") {
+      return false;
+    }
+    if (this.config.groupPolicy === "allowlist") {
+      const allowFrom = this.config.groupAllowFrom ?? [];
+      return allowFrom.includes("*") || allowFrom.includes(params.channelId);
+    }
+    return true;
+  }
+  resolveMentionState(params) {
+    if (!params.isGroup) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const groups = this.config.groups ?? {};
+    const groupRule = groups[params.channelId] ?? groups["*"];
+    const requireMention = groupRule?.requireMention ?? this.config.requireMention ?? false;
+    if (!requireMention) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const patterns = [
+      ...this.config.mentionPatterns ?? [],
+      ...groupRule?.mentionPatterns ?? []
+    ].map((pattern) => pattern.trim()).filter(Boolean);
+    const content = params.message.content ?? "";
+    const wasMentionedByUserRef = Boolean(params.selfUserId) && params.message.mentions.users.has(params.selfUserId ?? "");
+    const wasMentionedByText = Boolean(params.selfUserId) && (content.includes(`<@${params.selfUserId}>`) || content.includes(`<@!${params.selfUserId}>`));
+    const wasMentionedByPattern = patterns.some((pattern) => {
+      try {
+        return new RegExp(pattern, "i").test(content);
+      } catch {
+        return content.toLowerCase().includes(pattern.toLowerCase());
+      }
+    });
+    return {
+      wasMentioned: wasMentionedByUserRef || wasMentionedByText || wasMentionedByPattern,
+      requireMention
+    };
+  }
   async resolveInboundAttachment(params) {
     const { attachment, mediaDir, maxBytes, proxy } = params;
     const id = attachment.id;
@@ -2395,6 +2464,8 @@ var TelegramChannel = class extends BaseChannel {
   }
   name = "telegram";
   bot = null;
+  botUserId = null;
+  botUsername = null;
   typingController;
   transcriber;
   async start() {
@@ -2407,6 +2478,14 @@ var TelegramChannel = class extends BaseChannel {
       options.request = { proxy: this.config.proxy };
     }
     this.bot = new TelegramBot(this.config.token, options);
+    try {
+      const me = await this.bot.getMe();
+      this.botUserId = me.id;
+      this.botUsername = me.username ?? null;
+    } catch {
+      this.botUserId = null;
+      this.botUsername = null;
+    }
     this.bot.onText(/^\/start$/, async (msg) => {
       await this.bot?.sendMessage(
         msg.chat.id,
@@ -2432,12 +2511,31 @@ Just send me a text message to chat!`;
         await this.bot?.sendMessage(msg.chat.id, "\u26A0\uFE0F Session management is not available.");
         return;
       }
-      const sessionKey = `${this.name}:${chatId}`;
-      const session = this.sessionManager.getOrCreate(sessionKey);
-      const count = session.messages.length;
-      this.sessionManager.clear(session);
-      this.sessionManager.save(session);
-      await this.bot?.sendMessage(msg.chat.id, `\u{1F504} Conversation history cleared (${count} messages).`);
+      const accountId = this.resolveAccountId();
+      const candidates = this.sessionManager.listSessions().filter((entry) => {
+        const metadata = entry.metadata ?? {};
+        const lastChannel = typeof metadata.last_channel === "string" ? metadata.last_channel : "";
+        const lastTo = typeof metadata.last_to === "string" ? metadata.last_to : "";
+        const lastAccountId = typeof metadata.last_account_id === "string" ? metadata.last_account_id : typeof metadata.last_accountId === "string" ? metadata.last_accountId : "default";
+        return lastChannel === this.name && lastTo === chatId && lastAccountId === accountId;
+      }).map((entry) => String(entry.key ?? "")).filter(Boolean);
+      let totalCleared = 0;
+      for (const key of candidates) {
+        const session = this.sessionManager.getIfExists(key);
+        if (!session) {
+          continue;
+        }
+        totalCleared += session.messages.length;
+        this.sessionManager.clear(session);
+        this.sessionManager.save(session);
+      }
+      if (candidates.length === 0) {
+        const legacySession = this.sessionManager.getOrCreate(`${this.name}:${chatId}`);
+        totalCleared = legacySession.messages.length;
+        this.sessionManager.clear(legacySession);
+        this.sessionManager.save(legacySession);
+      }
+      await this.bot?.sendMessage(msg.chat.id, `\u{1F504} Conversation history cleared (${totalCleared} messages).`);
     });
     this.bot.on("message", async (msg) => {
       if (!msg.text && !msg.caption && !msg.photo && !msg.voice && !msg.audio && !msg.document) {
@@ -2498,6 +2596,14 @@ Just send me a text message to chat!`;
       return;
     }
     const chatId = String(message.chat.id);
+    const isGroup = message.chat.type !== "private";
+    if (!this.isAllowedByPolicy({ senderId: String(sender.id), chatId, isGroup })) {
+      return;
+    }
+    const mentionState = this.resolveMentionState({ message, chatId, isGroup });
+    if (mentionState.requireMention && !mentionState.wasMentioned) {
+      return;
+    }
     let senderId = String(sender.id);
     if (sender.username) {
       senderId = `${senderId}|${sender.username}`;
@@ -2546,7 +2652,13 @@ Just send me a text message to chat!`;
         first_name: sender.firstName,
         sender_type: sender.type,
         is_bot: sender.isBot,
-        is_group: message.chat.type !== "private"
+        is_group: isGroup,
+        account_id: this.resolveAccountId(),
+        accountId: this.resolveAccountId(),
+        peer_kind: isGroup ? "group" : "direct",
+        peer_id: isGroup ? chatId : String(sender.id),
+        was_mentioned: mentionState.wasMentioned,
+        require_mention: mentionState.requireMention
       });
     } finally {
       this.stopTyping(chatId);
@@ -2561,6 +2673,63 @@ Just send me a text message to chat!`;
   stopTyping(chatId) {
     this.typingController.stop(chatId);
   }
+  resolveAccountId() {
+    const accountId = this.config.accountId?.trim();
+    return accountId || "default";
+  }
+  isAllowedByPolicy(params) {
+    if (!params.isGroup) {
+      if (this.config.dmPolicy === "disabled") {
+        return false;
+      }
+      const allowFrom = this.config.allowFrom ?? [];
+      if (this.config.dmPolicy === "allowlist" || this.config.dmPolicy === "pairing") {
+        return this.isAllowed(params.senderId);
+      }
+      if (allowFrom.includes("*")) {
+        return true;
+      }
+      return allowFrom.length === 0 ? true : this.isAllowed(params.senderId);
+    }
+    if (this.config.groupPolicy === "disabled") {
+      return false;
+    }
+    if (this.config.groupPolicy === "allowlist") {
+      const allowFrom = this.config.groupAllowFrom ?? [];
+      return allowFrom.includes("*") || allowFrom.includes(params.chatId);
+    }
+    return true;
+  }
+  resolveMentionState(params) {
+    if (!params.isGroup) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const groups = this.config.groups ?? {};
+    const groupRule = groups[params.chatId] ?? groups["*"];
+    const requireMention = groupRule?.requireMention ?? this.config.requireMention ?? false;
+    if (!requireMention) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const content = `${params.message.text ?? ""}
+${params.message.caption ?? ""}`.trim();
+    const patterns = [
+      ...this.config.mentionPatterns ?? [],
+      ...groupRule?.mentionPatterns ?? []
+    ].map((pattern) => pattern.trim()).filter(Boolean);
+    const usernameMentioned = this.botUsername ? content.includes(`@${this.botUsername}`) : false;
+    const replyToBot = Boolean(this.botUserId) && Boolean(params.message.reply_to_message?.from) && params.message.reply_to_message?.from?.id === this.botUserId;
+    const patternMentioned = patterns.some((pattern) => {
+      try {
+        return new RegExp(pattern, "i").test(content);
+      } catch {
+        return content.toLowerCase().includes(pattern.toLowerCase());
+      }
+    });
+    return {
+      wasMentioned: usernameMentioned || replyToBot || patternMentioned,
+      requireMention
+    };
+  }
 };
 function resolveSender(message) {
   if (message.from) {
@@ -2668,6 +2837,273 @@ function markdownToTelegramHtml(text) {
   return text;
 }
 
+// src/channels/wecom.ts
+import { createHash } from "crypto";
+import { createServer } from "http";
+import { fetch as fetch5 } from "undici";
+var MSG_TYPE_FALLBACK = {
+  image: "[image]",
+  voice: "[voice]",
+  video: "[video]",
+  file: "[file]",
+  location: "[location]",
+  event: "[event]"
+};
+var TOKEN_EXPIRY_BUFFER_MS = 6e4;
+var WeComChannel = class extends BaseChannel {
+  name = "wecom";
+  server = null;
+  accessToken = null;
+  tokenExpiry = 0;
+  processedIds = [];
+  processedSet = /* @__PURE__ */ new Set();
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.corpId || !this.config.agentId || !this.config.secret || !this.config.token) {
+      throw new Error("WeCom corpId/agentId/secret/token not configured");
+    }
+    this.running = true;
+    await new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => {
+        void this.handleCallbackRequest(req, res);
+      });
+      this.server.once("error", reject);
+      this.server.listen(this.config.callbackPort, () => {
+        this.server?.off("error", reject);
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.running = false;
+    if (!this.server) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.server?.close(() => resolve());
+    });
+    this.server = null;
+  }
+  async send(msg) {
+    const receiver = msg.chatId?.trim();
+    if (!receiver) {
+      return;
+    }
+    const content = normalizeOutboundContent(msg);
+    if (!content) {
+      return;
+    }
+    const accessToken = await this.getAccessToken();
+    const sendUrl = `https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=${encodeURIComponent(accessToken)}`;
+    const agentIdNumber = Number(this.config.agentId);
+    const payload = {
+      touser: receiver,
+      msgtype: "text",
+      agentid: Number.isFinite(agentIdNumber) ? agentIdNumber : this.config.agentId,
+      text: {
+        content
+      },
+      safe: 0
+    };
+    const response = await fetch5(sendUrl, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`WeCom send failed: HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    const errcode = Number(body.errcode ?? -1);
+    if (!Number.isFinite(errcode) || errcode !== 0) {
+      const errmsg = typeof body.errmsg === "string" ? body.errmsg : "unknown error";
+      throw new Error(`WeCom send failed: ${errcode} ${errmsg}`);
+    }
+  }
+  async handleCallbackRequest(req, res) {
+    const callbackPath = normalizeCallbackPath(this.config.callbackPath);
+    const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+    if (requestUrl.pathname !== callbackPath) {
+      res.statusCode = 404;
+      res.end("not found");
+      return;
+    }
+    const method = (req.method ?? "GET").toUpperCase();
+    if (method === "GET") {
+      this.handleVerificationRequest(requestUrl, res);
+      return;
+    }
+    if (method === "POST") {
+      await this.handleInboundMessageRequest(req, requestUrl, res);
+      return;
+    }
+    res.statusCode = 405;
+    res.end("method not allowed");
+  }
+  handleVerificationRequest(requestUrl, res) {
+    const timestamp = requestUrl.searchParams.get("timestamp") ?? "";
+    const nonce = requestUrl.searchParams.get("nonce") ?? "";
+    const echostr = requestUrl.searchParams.get("echostr") ?? "";
+    const signature = requestUrl.searchParams.get("msg_signature") ?? requestUrl.searchParams.get("signature") ?? "";
+    if (!timestamp || !nonce || !echostr || !signature) {
+      res.statusCode = 400;
+      res.end("invalid verification payload");
+      return;
+    }
+    if (!this.verifySignature(timestamp, nonce, signature)) {
+      res.statusCode = 401;
+      res.end("signature mismatch");
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("content-type", "text/plain; charset=utf-8");
+    res.end(echostr);
+  }
+  async handleInboundMessageRequest(req, requestUrl, res) {
+    const timestamp = requestUrl.searchParams.get("timestamp") ?? "";
+    const nonce = requestUrl.searchParams.get("nonce") ?? "";
+    const signature = requestUrl.searchParams.get("msg_signature") ?? requestUrl.searchParams.get("signature") ?? "";
+    if (!timestamp || !nonce || !signature || !this.verifySignature(timestamp, nonce, signature)) {
+      res.statusCode = 401;
+      res.end("signature mismatch");
+      return;
+    }
+    const rawBody = await readBody(req);
+    if (!rawBody.trim()) {
+      respondSuccess(res);
+      return;
+    }
+    if (extractXmlField(rawBody, "Encrypt")) {
+      respondSuccess(res);
+      return;
+    }
+    const senderId = extractXmlField(rawBody, "FromUserName");
+    if (!senderId || !this.isAllowed(senderId)) {
+      respondSuccess(res);
+      return;
+    }
+    const msgType = extractXmlField(rawBody, "MsgType") || "text";
+    const msgId = extractXmlField(rawBody, "MsgId") || buildSyntheticMessageId(rawBody, senderId, msgType);
+    if (this.isDuplicate(msgId)) {
+      respondSuccess(res);
+      return;
+    }
+    const content = extractXmlField(rawBody, "Content")?.trim() || MSG_TYPE_FALLBACK[msgType.toLowerCase()] || "[unsupported message]";
+    await this.handleMessage({
+      senderId,
+      chatId: senderId,
+      content,
+      attachments: [],
+      metadata: {
+        message_id: msgId,
+        wecom: {
+          msgType,
+          toUserName: extractXmlField(rawBody, "ToUserName"),
+          agentId: extractXmlField(rawBody, "AgentID"),
+          createTime: extractXmlField(rawBody, "CreateTime")
+        }
+      }
+    });
+    respondSuccess(res);
+  }
+  verifySignature(timestamp, nonce, signature) {
+    const expected = createHash("sha1").update([this.config.token, timestamp, nonce].sort().join("")).digest("hex");
+    return expected === signature;
+  }
+  async getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return this.accessToken;
+    }
+    const tokenUrl = `https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=${encodeURIComponent(this.config.corpId)}&corpsecret=${encodeURIComponent(this.config.secret)}`;
+    const response = await fetch5(tokenUrl, { method: "GET" });
+    if (!response.ok) {
+      throw new Error(`WeCom gettoken failed: HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    const errcode = Number(body.errcode ?? -1);
+    if (!Number.isFinite(errcode) || errcode !== 0) {
+      const errmsg = typeof body.errmsg === "string" ? body.errmsg : "unknown error";
+      throw new Error(`WeCom gettoken failed: ${errcode} ${errmsg}`);
+    }
+    const accessToken = typeof body.access_token === "string" ? body.access_token : "";
+    const expiresIn = Number(body.expires_in ?? 7200);
+    if (!accessToken) {
+      throw new Error("WeCom gettoken failed: missing access_token");
+    }
+    this.accessToken = accessToken;
+    this.tokenExpiry = Date.now() + Math.max(0, expiresIn * 1e3 - TOKEN_EXPIRY_BUFFER_MS);
+    return accessToken;
+  }
+  isDuplicate(messageId) {
+    if (this.processedSet.has(messageId)) {
+      return true;
+    }
+    this.processedSet.add(messageId);
+    this.processedIds.push(messageId);
+    if (this.processedIds.length > 1e3) {
+      const removed = this.processedIds.splice(0, 500);
+      for (const id of removed) {
+        this.processedSet.delete(id);
+      }
+    }
+    return false;
+  }
+};
+function normalizeCallbackPath(path) {
+  if (!path) {
+    return "/wecom/callback";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function respondSuccess(res) {
+  res.statusCode = 200;
+  res.setHeader("content-type", "text/plain; charset=utf-8");
+  res.end("success");
+}
+function buildSyntheticMessageId(rawBody, senderId, msgType) {
+  return createHash("sha1").update(`${senderId}:${msgType}:${rawBody}`).digest("hex");
+}
+function extractXmlField(xml, field) {
+  const cdataPattern = new RegExp(`<${field}><!\\[CDATA\\[(.*?)\\]\\]><\\/${field}>`, "s");
+  const cdataMatch = xml.match(cdataPattern);
+  if (cdataMatch?.[1]) {
+    return cdataMatch[1].trim();
+  }
+  const textPattern = new RegExp(`<${field}>(.*?)<\\/${field}>`, "s");
+  const textMatch = xml.match(textPattern);
+  return textMatch?.[1]?.trim() ?? "";
+}
+async function readBody(req) {
+  const chunks = [];
+  return await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("error", reject);
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+  });
+}
+function normalizeOutboundContent(msg) {
+  const segments = [];
+  if (typeof msg.content === "string" && msg.content.trim()) {
+    segments.push(msg.content.trim());
+  }
+  if (Array.isArray(msg.media)) {
+    for (const item of msg.media) {
+      if (typeof item === "string" && item.trim()) {
+        segments.push(item.trim());
+      }
+    }
+  }
+  return segments.join("\n").trim();
+}
+
 // src/channels/whatsapp.ts
 import WebSocket from "ws";
 var WhatsAppChannel = class extends BaseChannel {
@@ -2818,6 +3254,11 @@ var BUILTIN_CHANNEL_RUNTIMES = {
     isEnabled: (config) => config.channels.dingtalk.enabled,
     createChannel: (context) => new DingTalkChannel(context.config.channels.dingtalk, context.bus)
   },
+  wecom: {
+    id: "wecom",
+    isEnabled: (config) => config.channels.wecom.enabled,
+    createChannel: (context) => new WeComChannel(context.config.channels.wecom, context.bus)
+  },
   email: {
     id: "email",
     isEnabled: (config) => config.channels.email.enabled,
@@ -2857,6 +3298,7 @@ export {
   QQChannel,
   SlackChannel,
   TelegramChannel,
+  WeComChannel,
   WhatsAppChannel,
   listBuiltinChannelRuntimes,
   resolveBuiltinChannelRuntime

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",
@@ -15,7 +15,7 @@
   ],
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.58.0",
-    "@nextclaw/core": "^0.6.20",
+    "@nextclaw/core": "^0.6.22",
     "@slack/socket-mode": "^1.3.3",
     "@slack/web-api": "^7.6.0",
     "dingtalk-stream": "^2.1.4",