@yanhaidao/wecom 1.0.1 → 2.0.0

package/src/monitor.integration.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { handleWecomWebhookRequest, registerWecomWebhookTarget } from "./monitor.js";
+import { encryptWecomPlaintext, computeWecomMsgSignature, WECOM_PKCS7_BLOCK_SIZE } from "./crypto.js";
+import * as runtime from "./runtime.js";
+import axios from "axios";
+import crypto from "node:crypto";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Socket } from "node:net";
+
+vi.mock("axios");
+
+// Helpers to simulate HTTP request
+function createMockRequest(bodyObj: any, query: URLSearchParams): IncomingMessage {
+    const socket = new Socket();
+    const req = new IncomingMessage(socket);
+    req.method = "POST";
+    req.url = `/wecom?${query.toString()}`;
+    req.push(JSON.stringify(bodyObj));
+    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 += chunk; return true; };
+    res.end = (chunk: any) => { if (chunk) data += chunk; return res; };
+    (res as any)._getData = () => data;
+    (res as any)._getStatusCode = () => res.statusCode;
+    return res as any;
+}
+
+// PKCS7 Pad Helper for manual encryption
+function pkcs7Pad(buf: Buffer, blockSize: number): Buffer {
+    const mod = buf.length % blockSize;
+    const pad = mod === 0 ? blockSize : blockSize - mod;
+    const padByte = Buffer.from([pad]);
+    return Buffer.concat([buf, Buffer.alloc(pad, padByte[0]!)]);
+}
+
+	describe("Monitor Integration: Inbound Image", () => {
+	    const token = "MY_TOKEN";
+	    const encodingAESKey = "jWmYm7qr5nMoCAstdRmNjt3p7vsH8HkK+qiJqQ0aaaa="; // 32 bytes key
+	    const receiveId = "MY_CORPID";
+	    let unregisterTarget: (() => void) | null = null;
+
+    // Mock Core Runtime
+    const mockDeliver = vi.fn();
+    const mockCore = {
+        channel: {
+            routing: { resolveAgentRoute: () => ({ agentId: "agent-1", sessionKey: "sess-1", accountId: "acc-1" }) },
+            session: {
+                resolveStorePath: () => "store/path",
+                readSessionUpdatedAt: () => 0,
+                recordInboundSession: vi.fn(),
+            },
+            reply: {
+                formatAgentEnvelope: () => "formatted-body",
+                finalizeInboundContext: (ctx: any) => ctx,
+                resolveEnvelopeFormatOptions: () => ({}),
+                dispatchReplyWithBufferedBlockDispatcher: async (opts: any) => {
+                    // Simulate Agent processing by calling deliver immediately or later
+                    // For this test, verifying the Inbound Body is enough.
+                    // The delivery payload is what the AGENT sees.
+                    // But wait, dispatchReply... is for OUTBOUND streaming replies.
+                    // startAgentForStream calls it. 
+                    // We really want to spy on what `rawBody` was passed to startAgentForStream context.
+
+                    // Actually `recordInboundSession` receives `ctx` which contains `RawBody`.
+                    return;
+                },
+            },
+            text: { resolveMarkdownTableMode: () => "off", convertMarkdownTables: (t: string) => t },
+        },
+        logging: { shouldLogVerbose: () => true },
+    };
+
+	    beforeEach(() => {
+	        vi.spyOn(runtime, "getWecomRuntime").mockReturnValue(mockCore as any);
+
+	        unregisterTarget?.();
+	        unregisterTarget = registerWecomWebhookTarget({
+	            account: {
+	                accountId: "test-acc",
+	                name: "Test",
+	                enabled: true,
+                configured: true,
+                token,
+                encodingAESKey,
+                receiveId,
+                config: {} as any
+            },
+            config: {} as any,
+	            runtime: { log: console.log, error: console.error },
+	            core: mockCore as any,
+	            path: "/wecom"
+	        });
+	    });
+
+	    afterEach(() => {
+	        unregisterTarget?.();
+	        unregisterTarget = null;
+	        vi.restoreAllMocks();
+	    });
+
+    it("should decrypt inbound image and pass base64 to agent", async () => {
+        // 1. Prepare Encrypted Media (The "File" on WeCom Server)
+        // We pretend this is the media data returned by axios
+        const fileContent = Buffer.from("fake-image-data");
+        const aesKey = Buffer.from(encodingAESKey + "=", "base64");
+        const iv = aesKey.subarray(0, 16);
+
+        // Encrypt content (WeCom does this)
+        const cipher = crypto.createCipheriv("aes-256-cbc", aesKey, iv);
+        cipher.setAutoPadding(false);
+        const encryptedMedia = Buffer.concat([cipher.update(pkcs7Pad(fileContent, WECOM_PKCS7_BLOCK_SIZE)), cipher.final()]);
+
+        // Mock Axios to return this encrypted media
+        (axios.get as any).mockResolvedValue({ data: encryptedMedia });
+
+        // 2. Prepare Inbound Message (The Webhook JSON)
+        const imageUrl = "http://wecom.server/media/123";
+        const inboundMsg = {
+            msgtype: "image",
+            image: { url: imageUrl },
+            from: { userid: "yanhaidao" }
+        };
+
+        // 3. Encrypt the *Inbound Message* Payload (The Envelope)
+        const timestamp = String(Math.floor(Date.now() / 1000));
+        const nonce = "123456";
+        const encrypt = encryptWecomPlaintext({
+            encodingAESKey,
+            receiveId,
+            plaintext: JSON.stringify(inboundMsg)
+        });
+        const msgSignature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt });
+
+        const query = new URLSearchParams({
+            msg_signature: msgSignature,
+            timestamp,
+            nonce
+        });
+
+        const bodyObj = {
+            touser: receiveId,
+            agentid: "10001",
+            encrypt, // Standard WeCom POST body structure
+        };
+
+        // 4. Send Request
+        const req = createMockRequest(bodyObj, query);
+        const res = createMockResponse();
+
+        await handleWecomWebhookRequest(req, res);
+
+        // 5. Verify
+        // Check recordInboundSession was called with correct RawBody
+        const recordCall = (mockCore.channel.session.recordInboundSession as any).mock.calls[0][0];
+        const rawBody = recordCall.ctx.RawBody;
+
+        // Expect: [image] data:image/jpeg;base64,...
+        expect(rawBody).toContain("[image] data:image/jpeg;base64,");
+        const base64Part = rawBody.split("base64,")[1];
+        const decoded = Buffer.from(base64Part, "base64");
+
+        expect(decoded.toString()).toBe("fake-image-data");
+        expect(axios.get).toHaveBeenCalledWith(imageUrl, expect.anything());
+    });
+});

package/src/monitor.ts

@@ -1,11 +1,13 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import crypto from "node:crypto";
 
-import type { ClawdbotConfig, PluginRuntime } from "clawdbot/plugin-sdk";
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
 
-import type { ResolvedWecomAccount, WecomInboundMessage } from "./types.js";
+import type { ResolvedWecomAccount, WecomInboundMessage, WecomInboundQuote } from "./types.js";
 import { decryptWecomEncrypted, encryptWecomPlaintext, verifyWecomSignature, computeWecomMsgSignature } from "./crypto.js";
 import { getWecomRuntime } from "./runtime.js";
+import { decryptWecomMedia } from "./media.js";
+import axios from "axios";
 
 export type WecomRuntimeEnv = {
   log?: (message: string) => void;
@@ -14,7 +16,7 @@ export type WecomRuntimeEnv = {
 
 type WecomWebhookTarget = {
   account: ResolvedWecomAccount;
-  config: ClawdbotConfig;
+  config: OpenClawConfig;
   runtime: WecomRuntimeEnv;
   core: PluginRuntime;
   path: string;
@@ -24,12 +26,14 @@ type WecomWebhookTarget = {
 type StreamState = {
   streamId: string;
   msgid?: string;
+  response_url?: string;
   createdAt: number;
   updatedAt: number;
   started: boolean;
   finished: boolean;
   error?: string;
   content: string;
+  image?: { base64: string; md5: string };
 };
 
 const webhookTargets = new Map<string, WecomWebhookTarget[]>();
@@ -151,14 +155,18 @@ function resolveSignatureParam(params: URLSearchParams): string {
   );
 }
 
-function buildStreamPlaceholderReply(streamId: string): { msgtype: "stream"; stream: { id: string; finish: boolean; content: string } } {
+function buildStreamPlaceholderReply(params: {
+  streamId: string;
+  placeholderContent?: string;
+}): { msgtype: "stream"; stream: { id: string; finish: boolean; content: string } } {
+  const content = params.placeholderContent?.trim() || "1";
   return {
     msgtype: "stream",
     stream: {
-      id: streamId,
+      id: params.streamId,
       finish: false,
       // Spec: "第一次回复内容为 1" works as a minimal placeholder.
-      content: "1",
+      content,
     },
   };
 }
@@ -171,6 +179,12 @@ function buildStreamReplyFromState(state: StreamState): { msgtype: "stream"; str
       id: state.streamId,
       finish: state.finished,
       content,
+      ...(state.finished && state.image ? {
+        msg_item: [{
+          msgtype: "image",
+          image: { base64: state.image.base64, md5: state.image.md5 }
+        }]
+      } : {})
     },
   };
 }
@@ -195,6 +209,26 @@ function parseWecomPlainMessage(raw: string): WecomInboundMessage {
   return parsed as WecomInboundMessage;
 }
 
+async function processInboundMessage(target: WecomWebhookTarget, msg: WecomInboundMessage): Promise<string> {
+  const msgtype = String(msg.msgtype ?? "").toLowerCase();
+
+  if (msgtype === "image") {
+    const url = String((msg as any).image?.url ?? "").trim();
+    const aesKey = target.account.encodingAESKey;
+    if (url && aesKey) {
+      try {
+        const buf = await decryptWecomMedia(url, aesKey);
+        const base64 = buf.toString("base64");
+        return `[image] data:image/jpeg;base64,${base64}`;
+      } catch (err) {
+        target.runtime.error?.(`Failed to decrypt inbound image: ${String(err)}`);
+        return `[image] (decryption failed)`;
+      }
+    }
+  }
+  return buildInboundBody(msg);
+}
+
 async function waitForStreamContent(streamId: string, maxWaitMs: number): Promise<void> {
   if (maxWaitMs <= 0) return;
   const startedAt = Date.now();
@@ -202,7 +236,8 @@ async function waitForStreamContent(streamId: string, maxWaitMs: number): Promis
     const tick = () => {
       const state = streams.get(streamId);
       if (!state) return resolve();
-      if (state.error || state.finished || state.content.trim()) return resolve();
+      if (state.error || state.finished) return resolve();
+      if (state.content.trim()) return resolve();
       if (Date.now() - startedAt >= maxWaitMs) return resolve();
       setTimeout(tick, 25);
     };
@@ -224,7 +259,7 @@ async function startAgentForStream(params: {
   const userid = msg.from?.userid?.trim() || "unknown";
   const chatType = msg.chattype === "group" ? "group" : "direct";
   const chatId = msg.chattype === "group" ? (msg.chatid?.trim() || "unknown") : userid;
-  const rawBody = buildInboundBody(msg);
+  const rawBody = await processInboundMessage(target, msg);
 
   const route = core.channel.routing.resolveAgentRoute({
     cfg: config,
@@ -291,9 +326,41 @@ async function startAgentForStream(params: {
     cfg: config,
     dispatcherOptions: {
       deliver: async (payload) => {
-        const text = core.channel.text.convertMarkdownTables(payload.text ?? "", tableMode);
+        let text = payload.text ?? "";
+
+        // Protect <think> tags from table conversion
+        const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
+        const thinks: string[] = [];
+        text = text.replace(thinkRegex, (match: string) => {
+          thinks.push(match);
+          return `__THINK_PLACEHOLDER_${thinks.length - 1}__`;
+        });
+
+        text = core.channel.text.convertMarkdownTables(text, tableMode);
+
+        // Restore <think> tags
+        thinks.forEach((think, i) => {
+          text = text.replace(`__THINK_PLACEHOLDER_${i}__`, think);
+        });
+
         const current = streams.get(streamId);
         if (!current) return;
+
+        // Detect Markdown image: ![alt](url)
+        const imgMatch = text.match(/!\[.*?\]\((https?:\/\/.*?)\)/);
+        if (imgMatch && imgMatch[1]) {
+          try {
+            const imgUrl = imgMatch[1];
+            const resp = await axios.get(imgUrl, { responseType: "arraybuffer", timeout: 10000 });
+            const buf = Buffer.from(resp.data);
+            const base64 = buf.toString("base64");
+            const md5 = crypto.createHash("md5").update(buf).digest("hex");
+            current.image = { base64, md5 };
+          } catch (err) {
+            target.runtime.error?.(`Failed to download outbound image: ${String(err)}`);
+          }
+        }
+
         const nextText = current.content
           ? `${current.content}\n\n${text}`.trim()
           : text.trim();
@@ -314,20 +381,45 @@ async function startAgentForStream(params: {
   }
 }
 
+function formatQuote(quote: WecomInboundQuote): string {
+  const type = quote.msgtype ?? "";
+  if (type === "text") {
+    return quote.text?.content || "";
+  }
+  if (type === "image") {
+    return `[引用: 图片] ${quote.image?.url || ""}`;
+  }
+  if (type === "mixed" && quote.mixed?.msg_item) {
+    const items = quote.mixed.msg_item.map((item) => {
+      if (item.msgtype === "text") return item.text?.content;
+      if (item.msgtype === "image") return `[图片] ${item.image?.url || ""}`;
+      return "";
+    }).filter(Boolean).join(" ");
+    return `[引用: 图文] ${items}`;
+  }
+  if (type === "voice") {
+    return `[引用: 语音] ${quote.voice?.content || ""}`;
+  }
+  if (type === "file") {
+    return `[引用: 文件] ${quote.file?.url || ""}`;
+  }
+  return "";
+}
+
 function buildInboundBody(msg: WecomInboundMessage): string {
+  let body = "";
   const msgtype = String(msg.msgtype ?? "").toLowerCase();
+
   if (msgtype === "text") {
     const content = (msg as any).text?.content;
-    return typeof content === "string" ? content : "";
-  }
-  if (msgtype === "voice") {
+    body = typeof content === "string" ? content : "";
+  } else if (msgtype === "voice") {
     const content = (msg as any).voice?.content;
-    return typeof content === "string" ? content : "[voice]";
-  }
-  if (msgtype === "mixed") {
+    body = typeof content === "string" ? content : "[voice]";
+  } else if (msgtype === "mixed") {
     const items = (msg as any).mixed?.msg_item;
     if (Array.isArray(items)) {
-      return items
+      body = items
         .map((item: any) => {
           const t = String(item?.msgtype ?? "").toLowerCase();
           if (t === "text") return String(item?.text?.content ?? "");
@@ -336,26 +428,34 @@ function buildInboundBody(msg: WecomInboundMessage): string {
         })
         .filter((part: string) => Boolean(part && part.trim()))
         .join("\n");
+    } else {
+      body = "[mixed]";
     }
-    return "[mixed]";
-  }
-  if (msgtype === "image") {
+  } else if (msgtype === "image") {
     const url = String((msg as any).image?.url ?? "").trim();
-    return url ? `[image] ${url}` : "[image]";
-  }
-  if (msgtype === "file") {
+    body = url ? `[image] ${url}` : "[image]";
+  } else if (msgtype === "file") {
     const url = String((msg as any).file?.url ?? "").trim();
-    return url ? `[file] ${url}` : "[file]";
-  }
-  if (msgtype === "event") {
+    body = url ? `[file] ${url}` : "[file]";
+  } else if (msgtype === "event") {
     const eventtype = String((msg as any).event?.eventtype ?? "").trim();
-    return eventtype ? `[event] ${eventtype}` : "[event]";
-  }
-  if (msgtype === "stream") {
+    body = eventtype ? `[event] ${eventtype}` : "[event]";
+  } else if (msgtype === "stream") {
     const id = String((msg as any).stream?.id ?? "").trim();
-    return id ? `[stream_refresh] ${id}` : "[stream_refresh]";
+    body = id ? `[stream_refresh] ${id}` : "[stream_refresh]";
+  } else {
+    body = msgtype ? `[${msgtype}]` : "";
+  }
+
+  // Append quote if available
+  const quote = (msg as any).quote;
+  if (quote) {
+    const quoteText = formatQuote(quote).trim();
+    if (quoteText) {
+      body += `\n\n> ${quoteText}`;
+    }
   }
-  return msgtype ? `[${msgtype}]` : "";
+  return body;
 }
 
 export function registerWecomWebhookTarget(target: WecomWebhookTarget): () => void {
@@ -543,7 +643,10 @@ export async function handleWecomWebhookRequest(
   // Dedupe: if we already created a stream for this msgid, return placeholder again.
   if (msgid && msgidToStreamId.has(msgid)) {
     const streamId = msgidToStreamId.get(msgid) ?? "";
-    const reply = buildStreamPlaceholderReply(streamId);
+    const reply = buildStreamPlaceholderReply({
+      streamId,
+      placeholderContent: target.account.config.streamPlaceholderContent,
+    });
     jsonOk(res, buildEncryptedJsonReply({
       account: target.account,
       plaintextJson: reply,
@@ -586,6 +689,7 @@ export async function handleWecomWebhookRequest(
   streams.set(streamId, {
     streamId,
     msgid,
+    response_url: msg.response_url,
     createdAt: Date.now(),
     updatedAt: Date.now(),
     started: false,
@@ -633,7 +737,10 @@ export async function handleWecomWebhookRequest(
   const state = streams.get(streamId);
   const initialReply = state && (state.content.trim() || state.error)
     ? buildStreamReplyFromState(state)
-    : buildStreamPlaceholderReply(streamId);
+    : buildStreamPlaceholderReply({
+      streamId,
+      placeholderContent: target.account.config.streamPlaceholderContent,
+    });
   jsonOk(res, buildEncryptedJsonReply({
     account: target.account,
     plaintextJson: initialReply,
@@ -644,3 +751,17 @@ export async function handleWecomWebhookRequest(
   logVerbose(target, `accepted msgtype=${msgtype || "unknown"} msgid=${msgid || "none"} streamId=${streamId}`);
   return true;
 }
+
+export async function sendActiveMessage(streamId: string, content: string): Promise<void> {
+  const state = streams.get(streamId);
+  if (!state || !state.response_url) {
+    throw new Error(`Active message failed: No response_url for stream ${streamId}`);
+  }
+
+  // WeCom Webhook Reply Format
+  // Note: Only works if response_url is valid and within time limit.
+  await axios.post(state.response_url, {
+    msgtype: "text",
+    text: { content },
+  });
+}