@sunnoy/wecom 1.3.0 → 1.4.1

package/wecom/inbound-processor.js

@@ -14,14 +14,13 @@ import {
   isHighPriorityCommand,
   isWecomAdmin,
 } from "./commands.js";
-import { SAFETY_NET_IDLE_CLOSE_MS, THINKING_PLACEHOLDER } from "./constants.js";
+import { THINKING_PLACEHOLDER } from "./constants.js";
 import { downloadAndDecryptImage, downloadWecomFile, guessMimeType } from "./media.js";
 import { deliverWecomReply } from "./outbound-delivery.js";
 import {
   dispatchLocks,
   getRuntime,
   messageBuffers,
-  resolveAgentConfig,
   responseUrls,
   streamContext,
   streamMeta,
@@ -148,7 +147,7 @@ export async function processInboundMessage({
   // Apply group mention gating rules.
   let rawBody = rawContent;
   if (isGroupChat) {
-    if (!shouldTriggerGroupResponse(rawContent, config)) {
+    if (!shouldTriggerGroupResponse(rawContent, account.config)) {
       logger.debug("WeCom: group message ignored (no mention)", { chatId, senderId });
       if (streamId) {
         streamManager.replaceIfPlaceholder(streamId, "请@提及我以获取回复。", THINKING_PLACEHOLDER);
@@ -158,7 +157,7 @@ export async function processInboundMessage({
       return;
     }
     // Strip mention markers from the effective prompt.
-    rawBody = extractGroupMessageContent(rawContent, config);
+    rawBody = extractGroupMessageContent(rawContent, account.config);
   }
 
   const commandAuthorized = resolveWecomCommandAuthorized({
@@ -167,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 });
@@ -181,12 +193,12 @@ export async function processInboundMessage({
   // Command allowlist enforcement
   // Admins bypass the allowlist entirely.
   // ========================================================================
-  const senderIsAdmin = isWecomAdmin(senderId, config);
-  const commandCheck = checkCommandAllowlist(rawBody, config);
+  const senderIsAdmin = isWecomAdmin(senderId, account.config);
+  const commandCheck = checkCommandAllowlist(rawBody, account.config);
 
   if (commandCheck.isCommand && !commandCheck.allowed && !senderIsAdmin) {
     // Return block message when command is outside the allowlist.
-    const cmdConfig = getCommandConfig(config);
+    const cmdConfig = getCommandConfig(account.config);
     logger.warn("WeCom: blocked command", {
       command: commandCheck.command,
       from: senderId,
@@ -225,12 +237,12 @@ export async function processInboundMessage({
   // Dynamic agent routing
   // Admins also use dynamic agents; admin flag only affects command allowlist.
   // ========================================================================
-  const dynamicConfig = getDynamicAgentConfig(config);
+  const dynamicConfig = getDynamicAgentConfig(account.config);
 
   // Compute deterministic agent target for this conversation.
   const targetAgentId =
-    dynamicConfig.enabled && shouldUseDynamicAgent({ chatType: peerKind, config })
-      ? generateAgentId(peerKind, peerId)
+    dynamicConfig.enabled && shouldUseDynamicAgent({ chatType: peerKind, config: account.config })
+      ? generateAgentId(peerKind, peerId, account.accountId)
       : null;
 
   if (targetAgentId) {
@@ -395,9 +407,41 @@ export async function processInboundMessage({
     });
 
   const runDispatch = async () => {
+    // --- Stream close coordination ---
+    // dispatchReplyWithBufferedBlockDispatcher may return before the LLM
+    // actually processes the message (e.g. when the session lane is busy and
+    // the message is queued).  We therefore track two signals:
+    //   1. dispatchDone  – the await on the dispatcher has resolved.
+    //   2. hadDelivery   – at least one deliver callback has fired.
+    // We only schedule a stream-close timer when BOTH are true, and we
+    // reset the timer on every new delivery so the stream stays open while
+    // content keeps arriving.
+    let dispatchDone = false;
+    let hadDelivery = false;
+    let closeTimer = null;
+
+    const scheduleStreamClose = () => {
+      if (closeTimer) clearTimeout(closeTimer);
+      closeTimer = setTimeout(async () => {
+        const s = streamManager.getStream(streamId);
+        if (s && !s.finished) {
+          logger.info("WeCom: finishing stream after dispatch complete", { streamId });
+          try {
+            await streamManager.finishStream(streamId);
+          } catch (err) {
+            logger.error("WeCom: failed to finish stream post-dispatch", {
+              streamId,
+              error: err.message,
+            });
+          }
+          unregisterActiveStream(streamKey, streamId);
+        }
+      }, 3000); // 3s grace after last delivery
+    };
+
     // Dispatch reply with AI processing.
     // Wrap in streamContext so outbound adapters resolve the correct stream.
-    await streamContext.run({ streamId, streamKey }, async () => {
+    await streamContext.run({ streamId, streamKey, agentId: route.agentId, accountId: account.accountId }, async () => {
       await core.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg: config,
@@ -408,44 +452,40 @@ export async function processInboundMessage({
         },
         dispatcherOptions: {
           deliver: async (payload, info) => {
+            hadDelivery = true;
+
             logger.info("Dispatcher deliver called", {
               kind: info.kind,
               hasText: !!(payload.text && payload.text.trim()),
+              hasMediaUrl: !!(payload.mediaUrl || (payload.mediaUrls && payload.mediaUrls.length)),
               textPreview: (payload.text || "").substring(0, 50),
             });
 
-            await deliverWecomReply({
-              payload,
-              senderId: streamKey,
-              streamId,
-            });
+            try {
+              await deliverWecomReply({
+                payload,
+                senderId: streamKey,
+                streamId,
+                agentId: route.agentId,
+              });
+            } catch (deliverErr) {
+              logger.error("WeCom: deliverWecomReply threw, continuing to finalize stream", {
+                streamId,
+                error: deliverErr.message,
+              });
+            }
 
             // Mark stream meta when main response is done.
-            // Actual stream finish is deferred to stream refresh handler,
-            // which is driven by WeCom client polling.
-            if (streamId && info.kind === "final") {
+            if (streamId && (info.kind === "final" || info.kind === "block")) {
               streamMeta.set(streamId, {
                 mainResponseDone: true,
                 doneAt: Date.now(),
               });
-              logger.info("WeCom main response complete, keeping stream open for late messages", { streamId });
-
-              // When Agent API is configured, late messages can be delivered
-              // via the Agent channel — no need to keep the stream open long.
-              const agentConfig = resolveAgentConfig();
-              if (agentConfig) {
-                setTimeout(async () => {
-                  const s = streamManager.getStream(streamId);
-                  if (s && !s.finished) {
-                    logger.info("WeCom: closing stream early (Agent API available for late messages)", { streamId });
-                    try {
-                      await streamManager.finishStream(streamId);
-                    } catch (err) {
-                      logger.error("WeCom: failed to close stream early", { streamId, error: err.message });
-                    }
-                  }
-                }, 3000);
-              }
+            }
+
+            // Schedule / reset stream close timer if dispatch already returned.
+            if (streamId && dispatchDone) {
+              scheduleStreamClose();
             }
           },
           onError: async (err, info) => {
@@ -456,36 +496,21 @@ export async function processInboundMessage({
       });
     });
 
-    // Safety net: ensure stream finishes after dispatch.
-    // Note: Stream closing is now handled by stream refresh handler via WeCom polling.
-    // This safety net only cleans up if refresh handler never fires (edge case).
+    // Dispatch returned.
+    dispatchDone = true;
+
     if (streamId) {
       const stream = streamManager.getStream(streamId);
       if (!stream || stream.finished) {
         unregisterActiveStream(streamKey, streamId);
-      } else {
-        // Stream is still open; refresh handler will close it when idle.
-        // Add a safety timeout to prevent leaks if refresh never fires.
-        setTimeout(async () => {
-          const checkStream = streamManager.getStream(streamId);
-          if (checkStream && !checkStream.finished) {
-            const idleMs = Date.now() - checkStream.updatedAt;
-            // Extreme fallback only: refresh handler should normally close earlier.
-            if (idleMs > SAFETY_NET_IDLE_CLOSE_MS) {
-              logger.warn("WeCom safety net: closing idle stream", { streamId, idleMs });
-              try {
-                await streamManager.finishStream(streamId);
-                unregisterActiveStream(streamKey, streamId);
-              } catch (err) {
-                logger.error("WeCom safety net: failed to close stream", {
-                  streamId,
-                  error: err.message,
-                });
-              }
-            }
-          }
-        }, 35000); // 35s total timeout
+      } else if (hadDelivery) {
+        // Normal case: content was already delivered, close after grace period.
+        scheduleStreamClose();
       }
+      // If !hadDelivery, the message was queued and is not yet processed.
+      // The deliver callback will fire later and schedule the close (since
+      // dispatchDone is now true).  The existing stream GC handles the edge
+      // case where no delivery ever arrives.
     }
   };
 

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 };
 }