@yanhaidao/wecom 1.0.0 → 2.0.0

package/src/monitor.webhook.test.ts

@@ -1,29 +1,48 @@
-import { createServer } from "node:http";
-import type { AddressInfo } from "node:net";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Socket } from "node:net";
 
 import { describe, expect, it } from "vitest";
 
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
 
 import type { ResolvedWecomAccount } from "./types.js";
 import { computeWecomMsgSignature, decryptWecomEncrypted, encryptWecomPlaintext } from "./crypto.js";
 import { handleWecomWebhookRequest, registerWecomWebhookTarget } from "./monitor.js";
 
-async function withServer(
-  handler: Parameters<typeof createServer>[0],
-  fn: (baseUrl: string) => Promise<void>,
-) {
-  const server = createServer(handler);
-  await new Promise<void>((resolve) => {
-    server.listen(0, "127.0.0.1", () => resolve());
-  });
-  const address = server.address() as AddressInfo | null;
-  if (!address) throw new Error("missing server address");
-  try {
-    await fn(`http://127.0.0.1:${address.port}`);
-  } finally {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
+function createMockRequest(params: {
+  method: "GET" | "POST";
+  url: string;
+  body?: unknown;
+}): IncomingMessage {
+  const socket = new Socket();
+  const req = new IncomingMessage(socket);
+  req.method = params.method;
+  req.url = params.url;
+  if (params.method === "POST") {
+    req.push(JSON.stringify(params.body ?? {}));
   }
+  req.push(null);
+  return req;
+}
+
+function createMockResponse(): ServerResponse & {
+  _getData: () => string;
+  _getStatusCode: () => number;
+} {
+  const req = new IncomingMessage(new Socket());
+  const res = new ServerResponse(req);
+  let data = "";
+  res.write = (chunk: any) => {
+    data += String(chunk);
+    return true;
+  };
+  res.end = (chunk: any) => {
+    if (chunk) data += String(chunk);
+    return res;
+  };
+  (res as any)._getData = () => data;
+  (res as any)._getStatusCode = () => res.statusCode;
+  return res as any;
 }
 
 describe("handleWecomWebhookRequest", () => {
@@ -44,34 +63,30 @@ describe("handleWecomWebhookRequest", () => {
 
     const unregister = registerWecomWebhookTarget({
       account,
-      config: {} as ClawdbotConfig,
+      config: {} as OpenClawConfig,
       runtime: {},
       core: {} as any,
       path: "/hook",
     });
 
     try {
-      await withServer(async (req, res) => {
-        const handled = await handleWecomWebhookRequest(req, res);
-        if (!handled) {
-          res.statusCode = 404;
-          res.end("not found");
-        }
-      }, async (baseUrl) => {
-        const timestamp = "13500001234";
-        const nonce = "123412323";
-        const echostr = encryptWecomPlaintext({
-          encodingAESKey,
-          receiveId: "",
-          plaintext: "ping",
-        });
-        const msg_signature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt: echostr });
-        const response = await fetch(
-          `${baseUrl}/hook?msg_signature=${encodeURIComponent(msg_signature)}&timestamp=${encodeURIComponent(timestamp)}&nonce=${encodeURIComponent(nonce)}&echostr=${encodeURIComponent(echostr)}`,
-        );
-        expect(response.status).toBe(200);
-        expect(await response.text()).toBe("ping");
+      const timestamp = "13500001234";
+      const nonce = "123412323";
+      const echostr = encryptWecomPlaintext({
+        encodingAESKey,
+        receiveId: "",
+        plaintext: "ping",
       });
+      const msg_signature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt: echostr });
+      const req = createMockRequest({
+        method: "GET",
+        url: `/hook?msg_signature=${encodeURIComponent(msg_signature)}&timestamp=${encodeURIComponent(timestamp)}&nonce=${encodeURIComponent(nonce)}&echostr=${encodeURIComponent(echostr)}`,
+      });
+      const res = createMockResponse();
+      const handled = await handleWecomWebhookRequest(req, res);
+      expect(handled).toBe(true);
+      expect(res._getStatusCode()).toBe(200);
+      expect(res._getData()).toBe("ping");
     } finally {
       unregister();
     }
@@ -91,69 +106,122 @@ describe("handleWecomWebhookRequest", () => {
 
     const unregister = registerWecomWebhookTarget({
       account,
-      config: {} as ClawdbotConfig,
+      config: {} as OpenClawConfig,
       runtime: {},
       core: {} as any,
       path: "/hook",
     });
 
     try {
-      await withServer(async (req, res) => {
-        const handled = await handleWecomWebhookRequest(req, res);
-        if (!handled) {
-          res.statusCode = 404;
-          res.end("not found");
-        }
-      }, async (baseUrl) => {
-        const timestamp = "1700000000";
-        const nonce = "nonce";
-        const plain = JSON.stringify({
-          msgid: "MSGID",
-          aibotid: "AIBOTID",
-          chattype: "single",
-          from: { userid: "USERID" },
-          response_url: "RESPONSEURL",
-          msgtype: "text",
-          text: { content: "hello" },
-        });
-        const encrypt = encryptWecomPlaintext({ encodingAESKey, receiveId: "", plaintext: plain });
-        const msg_signature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt });
-
-        const response = await fetch(
-          `${baseUrl}/hook?msg_signature=${encodeURIComponent(msg_signature)}&timestamp=${encodeURIComponent(timestamp)}&nonce=${encodeURIComponent(nonce)}`,
-          {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ encrypt }),
-          },
-        );
-        expect(response.status).toBe(200);
-        const json = JSON.parse(await response.text()) as any;
-        expect(typeof json.encrypt).toBe("string");
-        expect(typeof json.msgsignature).toBe("string");
-        expect(typeof json.timestamp).toBe("string");
-        expect(typeof json.nonce).toBe("string");
-
-        const replyPlain = decryptWecomEncrypted({
-          encodingAESKey,
-          receiveId: "",
-          encrypt: json.encrypt,
-        });
-        const reply = JSON.parse(replyPlain) as any;
-        expect(reply.msgtype).toBe("stream");
-        expect(reply.stream?.content).toBe("1");
-        expect(reply.stream?.finish).toBe(false);
-        expect(typeof reply.stream?.id).toBe("string");
-        expect(reply.stream?.id.length).toBeGreaterThan(0);
-
-        const expectedSig = computeWecomMsgSignature({
-          token,
-          timestamp: String(json.timestamp),
-          nonce: String(json.nonce),
-          encrypt: String(json.encrypt),
-        });
-        expect(json.msgsignature).toBe(expectedSig);
+      const timestamp = "1700000000";
+      const nonce = "nonce";
+      const plain = JSON.stringify({
+        msgid: "MSGID",
+        aibotid: "AIBOTID",
+        chattype: "single",
+        from: { userid: "USERID" },
+        response_url: "RESPONSEURL",
+        msgtype: "text",
+        text: { content: "hello" },
+      });
+      const encrypt = encryptWecomPlaintext({ encodingAESKey, receiveId: "", plaintext: plain });
+      const msg_signature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt });
+
+      const req = createMockRequest({
+        method: "POST",
+        url: `/hook?msg_signature=${encodeURIComponent(msg_signature)}&timestamp=${encodeURIComponent(timestamp)}&nonce=${encodeURIComponent(nonce)}`,
+        body: { encrypt },
+      });
+      const res = createMockResponse();
+      const handled = await handleWecomWebhookRequest(req, res);
+      expect(handled).toBe(true);
+      expect(res._getStatusCode()).toBe(200);
+
+      const json = JSON.parse(res._getData()) as any;
+      expect(typeof json.encrypt).toBe("string");
+      expect(typeof json.msgsignature).toBe("string");
+      expect(typeof json.timestamp).toBe("string");
+      expect(typeof json.nonce).toBe("string");
+
+      const replyPlain = decryptWecomEncrypted({
+        encodingAESKey,
+        receiveId: "",
+        encrypt: json.encrypt,
+      });
+      const reply = JSON.parse(replyPlain) as any;
+      expect(reply.msgtype).toBe("stream");
+      expect(reply.stream?.content).toBe("1");
+      expect(reply.stream?.finish).toBe(false);
+      expect(typeof reply.stream?.id).toBe("string");
+      expect(reply.stream?.id.length).toBeGreaterThan(0);
+
+      const expectedSig = computeWecomMsgSignature({
+        token,
+        timestamp: String(json.timestamp),
+        nonce: String(json.nonce),
+        encrypt: String(json.encrypt),
+      });
+      expect(json.msgsignature).toBe(expectedSig);
+    } finally {
+      unregister();
+    }
+  });
+
+  it("supports custom streamPlaceholderContent", async () => {
+    const account: ResolvedWecomAccount = {
+      accountId: "default",
+      name: "Test",
+      enabled: true,
+      configured: true,
+      token,
+      encodingAESKey,
+      receiveId: "",
+      config: { webhookPath: "/hook", token, encodingAESKey, streamPlaceholderContent: "正在思考..." },
+    };
+
+    const unregister = registerWecomWebhookTarget({
+      account,
+      config: {} as OpenClawConfig,
+      runtime: {},
+      core: {} as any,
+      path: "/hook",
+    });
+
+    try {
+      const timestamp = "1700000001";
+      const nonce = "nonce2";
+      const plain = JSON.stringify({
+        msgid: "MSGID2",
+        aibotid: "AIBOTID",
+        chattype: "single",
+        from: { userid: "USERID" },
+        response_url: "RESPONSEURL",
+        msgtype: "text",
+        text: { content: "hello" },
+      });
+      const encrypt = encryptWecomPlaintext({ encodingAESKey, receiveId: "", plaintext: plain });
+      const msg_signature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt });
+
+      const req = createMockRequest({
+        method: "POST",
+        url: `/hook?msg_signature=${encodeURIComponent(msg_signature)}&timestamp=${encodeURIComponent(timestamp)}&nonce=${encodeURIComponent(nonce)}`,
+        body: { encrypt },
+      });
+      const res = createMockResponse();
+      const handled = await handleWecomWebhookRequest(req, res);
+      expect(handled).toBe(true);
+      expect(res._getStatusCode()).toBe(200);
+
+      const json = JSON.parse(res._getData()) as any;
+      const replyPlain = decryptWecomEncrypted({
+        encodingAESKey,
+        receiveId: "",
+        encrypt: json.encrypt,
       });
+      const reply = JSON.parse(replyPlain) as any;
+      expect(reply.msgtype).toBe("stream");
+      expect(reply.stream?.content).toBe("正在思考...");
+      expect(reply.stream?.finish).toBe(false);
     } finally {
       unregister();
     }

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "clawdbot/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk";
 
 let runtime: PluginRuntime | null = null;
 
@@ -12,4 +12,3 @@ export function getWecomRuntime(): PluginRuntime {
   }
   return runtime;
 }
-

package/src/types.ts

@@ -12,6 +12,8 @@ export type WecomAccountConfig = {
   encodingAESKey?: string;
   receiveId?: string;
 
+  streamPlaceholderContent?: string;
+
   dm?: WecomDmConfig;
   welcomeText?: string;
 };
@@ -68,10 +70,24 @@ export type WecomInboundEvent = WecomInboundBase & {
   };
 };
 
+export type WecomInboundQuote = {
+  msgtype?: "text" | "image" | "mixed" | "voice" | "file";
+  text?: { content?: string };
+  image?: { url?: string };
+  mixed?: {
+    msg_item?: Array<{
+      msgtype: "text" | "image";
+      text?: { content?: string };
+      image?: { url?: string };
+    }>;
+  };
+  voice?: { content?: string };
+  file?: { url?: string };
+};
+
 export type WecomInboundMessage =
-  | WecomInboundText
+  | (WecomInboundText & { quote?: WecomInboundQuote })
   | WecomInboundVoice
   | WecomInboundStreamRefresh
   | WecomInboundEvent
-  | (WecomInboundBase & Record<string, unknown>);
-
+  | (WecomInboundBase & { quote?: WecomInboundQuote } & Record<string, unknown>);

package/tsconfig.json

@@ -19,4 +19,4 @@
         "node_modules",
         "**/*.test.ts"
     ]
-}
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+import baseConfig from "../../vitest.config.ts";
+
+const baseTest = (baseConfig as { test?: { exclude?: string[] } }).test ?? {};
+const exclude = baseTest.exclude ?? [];
+
+export default defineConfig({
+  ...baseConfig,
+  test: {
+    ...baseTest,
+    include: ["extensions/wecom/src/**/*.test.ts"],
+    exclude,
+  },
+});