@sunnoy/wecom 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sunnoy/wecom",
-    "version": "1.4.0",
+    "version": "1.5.0",
     "description": "Enterprise WeChat AI Bot channel plugin for OpenClaw",
     "type": "module",
     "main": "index.js",

package/wecom/channel-plugin.js

@@ -8,11 +8,18 @@ import { listAccountIds, resolveAccount, detectAccountConflicts } from "./accoun
 import { DEFAULT_ACCOUNT_ID, THINKING_PLACEHOLDER } from "./constants.js";
 import { parseResponseUrlResult } from "./response-url.js";
 import { messageBuffers, resolveAgentConfig, resolveWebhookUrl, responseUrls, streamContext } from "./state.js";
-import { resolveActiveStream } from "./stream-utils.js";
+import { resolveRecoverableStream, unregisterActiveStream } from "./stream-utils.js";
 import { resolveWecomTarget } from "./target.js";
 import { webhookSendImage, webhookSendText, webhookUploadFile, webhookSendFile } from "./webhook-bot.js";
 import { registerWebhookTarget } from "./webhook-targets.js";
 
+const AGENT_IMAGE_EXTS = new Set(["jpg", "jpeg", "png", "gif", "bmp"]);
+
+export function resolveAgentMediaTypeFromFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  return AGENT_IMAGE_EXTS.has(ext) ? "image" : "file";
+}
+
 export const wecomChannelPlugin = {
   id: "wecom",
   meta: {
@@ -259,7 +266,7 @@ export const wecomChannelPlugin = {
 
       // Prefer stream from async context (correct for concurrent processing).
       const ctx = streamContext.getStore();
-      const streamId = ctx?.streamId ?? resolveActiveStream(userId);
+      const streamId = ctx?.streamId ?? resolveRecoverableStream(userId);
 
       // Layer 1: Active stream (normal path)
       if (streamId && streamManager.hasStream(streamId) && !streamManager.getStream(streamId)?.finished) {
@@ -377,7 +384,7 @@ export const wecomChannelPlugin = {
 
       // Prefer stream from async context (correct for concurrent processing).
       const ctx = streamContext.getStore();
-      const streamId = ctx?.streamId ?? resolveActiveStream(userId);
+      const streamId = ctx?.streamId ?? resolveRecoverableStream(userId);
 
       if (streamId && streamManager.hasStream(streamId)) {
         // Check if mediaUrl is a local path (sandbox: prefix or absolute path)
@@ -575,6 +582,7 @@ export const wecomChannelPlugin = {
       if (agentConfig) {
         try {
           const agentTarget = (target && !target.webhook) ? target : resolveWecomTarget(to) || { toUser: userId };
+          let deliveredFilename = "file";
 
           // Determine if mediaUrl is a local file path.
           let absolutePath = mediaUrl;
@@ -587,9 +595,11 @@ export const wecomChannelPlugin = {
             // Upload local file then send via Agent API.
             const buffer = await readFile(absolutePath);
             const filename = basename(absolutePath);
+            deliveredFilename = filename;
+            const uploadType = resolveAgentMediaTypeFromFilename(filename);
             const mediaId = await agentUploadMedia({
               agent: agentConfig,
-              type: "image",
+              type: uploadType,
               buffer,
               filename,
             });
@@ -597,16 +607,25 @@ export const wecomChannelPlugin = {
               agent: agentConfig,
               ...agentTarget,
               mediaId,
-              mediaType: "image",
+              mediaType: uploadType,
             });
           } else {
             // For external URLs, download first then upload.
             const res = await fetch(mediaUrl);
+            if (!res.ok) {
+              throw new Error(`download media failed: ${res.status}`);
+            }
             const buffer = Buffer.from(await res.arrayBuffer());
-            const filename = basename(new URL(mediaUrl).pathname) || "image.png";
+            const filename = basename(new URL(mediaUrl).pathname) || "file";
+            deliveredFilename = filename;
+            let uploadType = resolveAgentMediaTypeFromFilename(filename);
+            const contentType = res.headers.get("content-type") || "";
+            if (uploadType === "file" && contentType.toLowerCase().startsWith("image/")) {
+              uploadType = "image";
+            }
             const mediaId = await agentUploadMedia({
               agent: agentConfig,
-              type: "image",
+              type: uploadType,
               buffer,
               filename,
             });
@@ -614,7 +633,7 @@ export const wecomChannelPlugin = {
               agent: agentConfig,
               ...agentTarget,
               mediaId,
-              mediaType: "image",
+              mediaType: uploadType,
             });
           }
 
@@ -623,6 +642,30 @@ export const wecomChannelPlugin = {
             await agentSendText({ agent: agentConfig, ...agentTarget, text });
           }
 
+          // Best-effort stream recovery: when async context is missing and the
+          // active stream mapping was already cleaned, still clear "thinking..."
+          // in the most recent stream for this user.
+          const recoverStreamId = resolveRecoverableStream(userId);
+          if (recoverStreamId && streamManager.hasStream(recoverStreamId)) {
+            const recoverStream = streamManager.getStream(recoverStreamId);
+            if (recoverStream && !recoverStream.finished) {
+              const deliveryHint = text
+                ? `${text}\n\n📎 文件已通过私信发送给您：${deliveredFilename}`
+                : `📎 文件已通过私信发送给您：${deliveredFilename}`;
+              streamManager.replaceIfPlaceholder(
+                recoverStreamId,
+                deliveryHint,
+                THINKING_PLACEHOLDER,
+              );
+              await streamManager.finishStream(recoverStreamId);
+              unregisterActiveStream(userId, recoverStreamId);
+              logger.info("WeCom: recovered and finished stream after media fallback", {
+                userId,
+                streamId: recoverStreamId,
+              });
+            }
+          }
+
           logger.info("WeCom: sent media via Agent API fallback (sendMedia)", {
             userId,
             to,

package/wecom/inbound-processor.js

@@ -166,6 +166,19 @@ export async function processInboundMessage({
     senderId,
   });
 
+  // ── Quoted message context ────────────────────────────────────────
+  // When the user replies to (quotes) a previous message, prepend the
+  // quoted content so the LLM sees the full conversational context.
+  const quote = message.quote;
+  if (quote && quote.content) {
+    const quoteLabel = quote.msgType === "image" ? "[引用图片]" : `> ${quote.content}`;
+    rawBody = `${quoteLabel}\n\n${rawBody}`;
+    logger.debug("WeCom: prepended quoted message context", {
+      quoteType: quote.msgType,
+      quotePreview: quote.content.substring(0, 60),
+    });
+  }
+
   // Skip empty messages, but allow image/mixed/file messages.
   if (!rawBody.trim() && !imageUrl && imageUrls.length === 0 && !fileUrl) {
     logger.debug("WeCom: empty message, skipping", { msgType });

package/wecom/media.js

@@ -4,66 +4,134 @@ import { WecomCrypto } from "../crypto.js";
 import { logger } from "../logger.js";
 import { MEDIA_CACHE_DIR } from "./constants.js";
 
+// ── Magic-byte signatures for common file formats ───────────────────────────
+const MAGIC_SIGNATURES = [
+  { magic: [0xff, 0xd8, 0xff], ext: "jpg" },                // JPEG
+  { magic: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a], ext: "png" }, // PNG
+  { magic: [0x47, 0x49, 0x46, 0x38], ext: "gif" },          // GIF
+  { magic: [0x25, 0x50, 0x44, 0x46], ext: "pdf" },          // %PDF
+  { magic: [0x50, 0x4b, 0x03, 0x04], ext: "zip" },          // PK (ZIP / DOCX / XLSX / PPTX)
+  { magic: [0x50, 0x4b, 0x05, 0x06], ext: "zip" },          // PK (empty ZIP)
+  { magic: [0xd0, 0xcf, 0x11, 0xe0], ext: "doc" },          // OLE2 (DOC / XLS / PPT)
+  { magic: [0x52, 0x61, 0x72, 0x21], ext: "rar" },          // Rar!
+  { magic: [0x1f, 0x8b], ext: "gz" },                       // gzip
+  { magic: [0x42, 0x4d], ext: "bmp" },                      // BMP
+  { magic: [0x49, 0x44, 0x33], ext: "mp3" },                // ID3 (MP3)
+  { magic: [0x00, 0x00, 0x00], ext: "mp4" },                // ftyp box (loose)
+  { magic: [0x52, 0x49, 0x46, 0x46], ext: "wav" },          // RIFF (WAV / AVI)
+];
+
+/**
+ * Check whether a buffer looks like a recognisable (plain) file by inspecting
+ * its leading magic bytes.  Returns the matched extension or `null`.
+ */
+function detectMagic(buf) {
+  if (!buf || buf.length < 4) return null;
+  for (const sig of MAGIC_SIGNATURES) {
+    if (buf.length >= sig.magic.length && sig.magic.every((b, i) => buf[i] === b)) {
+      return sig.ext;
+    }
+  }
+  return null;
+}
+
+/**
+ * Conditionally decrypt a buffer.
+ *
+ * WeCom encrypts media with AES-256-CBC in Agent mode, but in some Bot (AI
+ * 机器人) configurations the file URL returns an **unencrypted** payload.
+ * Blindly decrypting an already-plain file corrupts it (#44).
+ *
+ * Strategy:
+ *   1. If raw bytes already match a known file signature → skip decrypt.
+ *   2. Otherwise attempt AES-256-CBC decryption.
+ *   3. If decryption throws or the result has no recognisable signature,
+ *      fall back to the original bytes (best-effort).
+ */
+function smartDecrypt(rawBuffer, encodingAesKey, token) {
+  const plainExt = detectMagic(rawBuffer);
+  if (plainExt) {
+    logger.info("Media is already plain (skip decrypt)", { magic: plainExt, size: rawBuffer.length });
+    return { buffer: rawBuffer, decrypted: false };
+  }
+
+  try {
+    const crypto = new WecomCrypto(token, encodingAesKey);
+    const dec = crypto.decryptMedia(rawBuffer);
+    logger.info("Media decrypted", { inputSize: rawBuffer.length, outputSize: dec.length });
+    return { buffer: dec, decrypted: true };
+  } catch (e) {
+    logger.warn("Decrypt failed, using raw bytes", { error: e.message, size: rawBuffer.length });
+    return { buffer: rawBuffer, decrypted: false };
+  }
+}
+
+// ── Image helpers ───────────────────────────────────────────────────────────
+
+function detectImageExt(buf) {
+  if (buf[0] === 0x89 && buf[1] === 0x50) return "png";
+  if (buf[0] === 0x47 && buf[1] === 0x49) return "gif";
+  return "jpg";
+}
+
 /**
- * Download and decrypt a WeCom encrypted image.
- * @param {string} imageUrl - Encrypted image URL from WeCom
+ * Download and (conditionally) decrypt a WeCom image.
+ * @param {string} imageUrl - Image URL from WeCom callback
  * @param {string} encodingAesKey - AES key
  * @param {string} token - Token
- * @returns {Promise<{ localPath: string, mimeType: string }>} Local path and mime type
+ * @returns {Promise<{ localPath: string, mimeType: string }>}
  */
 export async function downloadAndDecryptImage(imageUrl, encodingAesKey, token) {
   if (!existsSync(MEDIA_CACHE_DIR)) {
     mkdirSync(MEDIA_CACHE_DIR, { recursive: true });
   }
 
-  logger.info("Downloading encrypted image", { url: imageUrl.substring(0, 80) });
+  logger.info("Downloading image", { url: imageUrl.substring(0, 80) });
   const response = await fetch(imageUrl);
   if (!response.ok) {
     throw new Error(`Failed to download image: ${response.status}`);
   }
-  const encryptedBuffer = Buffer.from(await response.arrayBuffer());
-  logger.debug("Downloaded encrypted image", { size: encryptedBuffer.length });
-
-  const wecomCrypto = new WecomCrypto(token, encodingAesKey);
-  const decryptedBuffer = wecomCrypto.decryptMedia(encryptedBuffer);
-
-  // Detect image type via magic bytes.
-  let ext = "jpg";
-  if (decryptedBuffer[0] === 0x89 && decryptedBuffer[1] === 0x50) {
-    ext = "png";
-  } else if (decryptedBuffer[0] === 0x47 && decryptedBuffer[1] === 0x49) {
-    ext = "gif";
-  }
+  const rawBuffer = Buffer.from(await response.arrayBuffer());
+  logger.debug("Downloaded image bytes", { size: rawBuffer.length });
 
+  const { buffer: finalBuffer } = smartDecrypt(rawBuffer, encodingAesKey, token);
+
+  const ext = detectImageExt(finalBuffer);
   const filename = `wecom_${Date.now()}_${Math.random().toString(36).substring(2, 8)}.${ext}`;
   const localPath = join(MEDIA_CACHE_DIR, filename);
-  writeFileSync(localPath, decryptedBuffer);
+  writeFileSync(localPath, finalBuffer);
 
   const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : "image/jpeg";
-  logger.info("Image decrypted and saved", { path: localPath, size: decryptedBuffer.length, mimeType });
+  logger.info("Image saved", { path: localPath, size: finalBuffer.length, mimeType });
   return { localPath, mimeType };
 }
 
+// ── File helpers ────────────────────────────────────────────────────────────
+
 /**
- * Download and decrypt a file from WeCom.
- * Note: WeCom encrypts ALL media files (not just images) with AES-256-CBC.
+ * Download and (conditionally) decrypt a file from WeCom.
+ *
+ * In Agent mode WeCom encrypts all media with AES-256-CBC; in Bot mode the
+ * file URL may return plain bytes.  This function auto-detects the case and
+ * only decrypts when necessary, preventing file corruption (#44).
+ *
  * @param {string} fileUrl - File download URL
  * @param {string} fileName - Original file name
  * @param {string} encodingAesKey - AES key for decryption
  * @param {string} token - Token for decryption
- * @returns {Promise<{ localPath: string, effectiveFileName: string }>} Local path and resolved filename
+ * @returns {Promise<{ localPath: string, effectiveFileName: string }>}
  */
 export async function downloadWecomFile(fileUrl, fileName, encodingAesKey, token) {
   if (!existsSync(MEDIA_CACHE_DIR)) {
     mkdirSync(MEDIA_CACHE_DIR, { recursive: true });
   }
 
-  logger.info("Downloading encrypted file", { url: fileUrl.substring(0, 80), name: fileName });
+  logger.info("Downloading file", { url: fileUrl.substring(0, 80), name: fileName });
   const response = await fetch(fileUrl);
   if (!response.ok) {
     throw new Error(`Failed to download file: ${response.status}`);
   }
-  const encryptedBuffer = Buffer.from(await response.arrayBuffer());
+  const rawBuffer = Buffer.from(await response.arrayBuffer());
 
   // Try to extract filename from Content-Disposition header if not provided
   let effectiveFileName = fileName;
@@ -79,15 +147,20 @@ export async function downloadWecomFile(fileUrl, fileName, encodingAesKey, token
     }
   }
 
-  // Decrypt the file (WeCom encrypts all media the same way as images)
-  const wecomCrypto = new WecomCrypto(token, encodingAesKey);
-  const decryptedBuffer = wecomCrypto.decryptMedia(encryptedBuffer);
+  // Smart decrypt: only decrypt if the raw bytes are not already a valid file.
+  const { buffer: finalBuffer, decrypted } = smartDecrypt(rawBuffer, encodingAesKey, token);
+  logger.info("File processed", {
+    name: effectiveFileName,
+    rawSize: rawBuffer.length,
+    finalSize: finalBuffer.length,
+    wasDecrypted: decrypted,
+  });
 
   const safeName = (effectiveFileName || `file_${Date.now()}`).replace(/[/\\:*?"<>|]/g, "_");
   const localPath = join(MEDIA_CACHE_DIR, `${Date.now()}_${safeName}`);
-  writeFileSync(localPath, decryptedBuffer);
+  writeFileSync(localPath, finalBuffer);
 
-  logger.info("File decrypted and saved", { path: localPath, size: decryptedBuffer.length });
+  logger.info("File saved", { path: localPath, size: finalBuffer.length });
   return { localPath, effectiveFileName: effectiveFileName || fileName };
 }
 

package/wecom/state.js

@@ -14,6 +14,7 @@ export const messageBuffers = new Map();
 export const webhookTargets = new Map();
 export const activeStreams = new Map();
 export const activeStreamHistory = new Map();
+export const lastStreamByKey = new Map();
 export const streamMeta = new Map();
 export const responseUrls = new Map();
 export const streamContext = new AsyncLocalStorage();

package/wecom/stream-utils.js

@@ -1,7 +1,7 @@
 import { logger } from "../logger.js";
 import { streamManager } from "../stream-manager.js";
 import { THINKING_PLACEHOLDER } from "./constants.js";
-import { activeStreamHistory, activeStreams, messageBuffers } from "./state.js";
+import { activeStreamHistory, activeStreams, lastStreamByKey, messageBuffers } from "./state.js";
 
 export function getMessageStreamKey(message) {
   if (!message || typeof message !== "object") {
@@ -25,6 +25,7 @@ export function registerActiveStream(streamKey, streamId) {
   deduped.push(streamId);
   activeStreamHistory.set(streamKey, deduped);
   activeStreams.set(streamKey, streamId);
+  lastStreamByKey.set(streamKey, streamId);
 }
 
 export function unregisterActiveStream(streamKey, streamId) {
@@ -72,9 +73,33 @@ export function resolveActiveStream(streamKey) {
   activeStreamHistory.set(streamKey, remaining);
   const latest = remaining[remaining.length - 1];
   activeStreams.set(streamKey, latest);
+  lastStreamByKey.set(streamKey, latest);
   return latest;
 }
 
+/**
+ * Resolve a usable stream id for a sender/group.
+ * Prefer active history; if that is temporarily empty, fall back to the latest
+ * known stream id for the same key (when it still exists).
+ */
+export function resolveRecoverableStream(streamKey) {
+  const activeId = resolveActiveStream(streamKey);
+  if (activeId) {
+    return activeId;
+  }
+  if (!streamKey) {
+    return null;
+  }
+  const recentId = lastStreamByKey.get(streamKey);
+  if (!recentId) {
+    return null;
+  }
+  if (!streamManager.hasStream(recentId)) {
+    return null;
+  }
+  return recentId;
+}
+
 export function clearBufferedMessagesForStream(streamKey, reason) {
   const buffer = messageBuffers.get(streamKey);
   if (!buffer) {