@nextclaw/channel-runtime 0.1.5 → 0.1.7

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

@@ -204,6 +204,25 @@ declare class TelegramChannel extends BaseChannel<Config["channels"]["telegram"]
     private stopTyping;
 }
 
+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"]> {
     name: string;
     private ws;
@@ -256,6 +275,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 +301,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

@@ -363,9 +363,8 @@ var DiscordChannel = class extends BaseChannel {
           ...attachmentIssues.length ? { attachment_issues: attachmentIssues } : {}
         }
       });
-    } catch (err) {
+    } finally {
       this.stopTyping(channelId);
-      throw err;
     }
   }
   resolveProxyAgent() {
@@ -2549,9 +2548,8 @@ Just send me a text message to chat!`;
         is_bot: sender.isBot,
         is_group: message.chat.type !== "private"
       });
-    } catch (err) {
+    } finally {
       this.stopTyping(chatId);
-      throw err;
     }
   }
   async dispatchToBus(senderId, chatId, content, attachments, metadata) {
@@ -2670,6 +2668,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 {
@@ -2820,6 +3085,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,
@@ -2859,6 +3129,7 @@ export {
   QQChannel,
   SlackChannel,
   TelegramChannel,
+  WeComChannel,
   WhatsAppChannel,
   listBuiltinChannelRuntimes,
   resolveBuiltinChannelRuntime

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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.21",
     "@slack/socket-mode": "^1.3.3",
     "@slack/web-api": "^7.6.0",
     "dingtalk-stream": "^2.1.4",