@sunnoy/wecom 1.9.0 → 2.0.0

package/wecom/media.js

@@ -1,192 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { WecomCrypto } from "../crypto.js";
-import { logger } from "../logger.js";
-import { MEDIA_CACHE_DIR } from "./constants.js";
-import { wecomFetch } from "./http.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 (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 }>}
- */
-export async function downloadAndDecryptImage(imageUrl, encodingAesKey, token) {
-  if (!existsSync(MEDIA_CACHE_DIR)) {
-    mkdirSync(MEDIA_CACHE_DIR, { recursive: true });
-  }
-
-  logger.info("Downloading image", { url: imageUrl.substring(0, 80) });
-  const response = await wecomFetch(imageUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to download image: ${response.status}`);
-  }
-  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, finalBuffer);
-
-  const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : "image/jpeg";
-  logger.info("Image saved", { path: localPath, size: finalBuffer.length, mimeType });
-  return { localPath, mimeType };
-}
-
-// ── File helpers ────────────────────────────────────────────────────────────
-
-/**
- * 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 }>}
- */
-export async function downloadWecomFile(fileUrl, fileName, encodingAesKey, token) {
-  if (!existsSync(MEDIA_CACHE_DIR)) {
-    mkdirSync(MEDIA_CACHE_DIR, { recursive: true });
-  }
-
-  logger.info("Downloading file", { url: fileUrl.substring(0, 80), name: fileName });
-  const response = await wecomFetch(fileUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to download file: ${response.status}`);
-  }
-  const rawBuffer = Buffer.from(await response.arrayBuffer());
-
-  // Try to extract filename from Content-Disposition header if not provided
-  let effectiveFileName = fileName;
-  if (!effectiveFileName) {
-    const contentDisposition = response.headers.get("content-disposition");
-    if (contentDisposition) {
-      // Match: filename="xxx.pdf" or filename*=UTF-8''xxx.pdf
-      const filenameMatch = contentDisposition.match(/filename\*?=(?:UTF-8'')?["']?([^"';\n]+)["']?/i);
-      if (filenameMatch && filenameMatch[1]) {
-        effectiveFileName = decodeURIComponent(filenameMatch[1]);
-        logger.info("Extracted filename from Content-Disposition", { name: effectiveFileName });
-      }
-    }
-  }
-
-  // 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, finalBuffer);
-
-  logger.info("File saved", { path: localPath, size: finalBuffer.length });
-  return { localPath, effectiveFileName: effectiveFileName || fileName };
-}
-
-/**
- * Guess MIME type from file extension.
- */
-export function guessMimeType(fileName) {
-  const ext = (fileName || "").split(".").pop()?.toLowerCase() || "";
-  const mimeMap = {
-    pdf: "application/pdf",
-    doc: "application/msword",
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    xls: "application/vnd.ms-excel",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ppt: "application/vnd.ms-powerpoint",
-    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    txt: "text/plain",
-    csv: "text/csv",
-    zip: "application/zip",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    mp4: "video/mp4",
-    mp3: "audio/mpeg",
-  };
-  return mimeMap[ext] || "application/octet-stream";
-}

package/wecom/outbound-delivery.js

@@ -1,435 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { basename, isAbsolute, relative, resolve, sep } from "node:path";
-import { logger } from "../logger.js";
-import { streamManager } from "../stream-manager.js";
-import { agentSendText, agentUploadMedia, agentSendMedia } from "./agent-api.js";
-import { parseResponseUrlResult } from "./response-url.js";
-import { resolveAgentConfig, responseUrls, streamContext } from "./state.js";
-import { resolveActiveStream } from "./stream-utils.js";
-import { resolveAgentWorkspaceDirLocal } from "./workspace-template.js";
-import { THINKING_PLACEHOLDER } from "./constants.js";
-import { wecomFetch } from "./http.js";
-
-// WeCom upload API rejects files smaller than 5 bytes (error 40006).
-const WECOM_MIN_FILE_SIZE = 5;
-
-/**
- * Resolve sandbox /workspace/… paths to the host-side equivalent.
- * Inside the sandbox container, /workspace is mounted from
- * ~/.openclaw/workspace-{agentId} on the host.  Any path starting with
- * /workspace/ is transparently rewritten when an agentId is available.
- */
-export function resolveWorkspaceHostPathSafe({ workspaceDir, workspacePath }) {
-  const relativePath = String(workspacePath || "").replace(/^\/workspace\/?/, "");
-  if (!relativePath) {
-    return null;
-  }
-
-  const hostPath = resolve(workspaceDir, relativePath);
-  const rel = relative(workspaceDir, hostPath);
-  const escapesWorkspace = rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
-  if (escapesWorkspace) {
-    return null;
-  }
-  return hostPath;
-}
-
-function resolveHostPath(filePath, effectiveAgentId) {
-  if (effectiveAgentId && filePath.startsWith("/workspace/")) {
-    const workspaceDir = resolveAgentWorkspaceDirLocal(effectiveAgentId);
-    const hostPath = resolveWorkspaceHostPathSafe({
-      workspaceDir,
-      workspacePath: filePath,
-    });
-    if (!hostPath) {
-      logger.warn("Rejected unsafe /workspace/ path outside workspace", {
-        sandbox: filePath,
-        workspaceDir,
-        agentId: effectiveAgentId,
-      });
-      return null;
-    }
-    logger.debug("Resolved sandbox path to host path", { sandbox: filePath, host: hostPath });
-    return hostPath;
-  }
-  return filePath;
-}
-
-/**
- * Upload a local file and send via Agent DM.
- * If the file is smaller than WECOM_MIN_FILE_SIZE (WeCom rejects tiny files),
- * read the content and send as a text message instead.
- * Returns a user-facing hint string.
- */
-async function uploadAndSendFile({ hostPath, filename, agent, senderId, streamId }) {
-  const fileBuf = await readFile(hostPath);
-  if (fileBuf.length < WECOM_MIN_FILE_SIZE) {
-    // File too small for WeCom upload — send content inline as text.
-    const content = fileBuf.toString("utf-8");
-    await agentSendText({
-      agent,
-      toUser: senderId,
-      text: `📄 ${filename}:\n${content}`,
-    });
-    logger.info("Sent tiny file as text via Agent DM", {
-      streamId,
-      filename,
-      size: fileBuf.length,
-    });
-    return `📎 文件「${filename}」内容已通过私信发送给您`;
-  }
-
-  const uploadedId = await agentUploadMedia({
-    agent,
-    type: "file",
-    buffer: fileBuf,
-    filename,
-  });
-  await agentSendMedia({
-    agent,
-    toUser: senderId,
-    mediaId: uploadedId,
-    mediaType: "file",
-  });
-  logger.info("Sent file via Agent DM", { streamId, filename, size: fileBuf.length });
-  return `📎 文件「${filename}」已通过私信发送给您`;
-}
-
-export async function deliverWecomReply({ payload, senderId, streamId, agentId }) {
-  const text = payload.text || "";
-  // Resolve effective agentId from parameter or async context.
-  const effectiveAgentId = agentId || streamContext.getStore()?.agentId;
-
-  logger.debug("deliverWecomReply called", {
-    hasText: !!text.trim(),
-    textPreview: text.substring(0, 50),
-    streamId,
-    senderId,
-    agentId: effectiveAgentId,
-  });
-
-  // Handle absolute-path MEDIA lines manually; OpenClaw rejects these paths upstream.
-  // Match only line-start MEDIA directives to align with upstream OpenClaw.
-  const mediaRegex = /^MEDIA:\s*(.+?)$/gm;
-  const mediaMatches = [];
-  let match;
-  while ((match = mediaRegex.exec(text)) !== null) {
-    const mediaPath = match[1].trim();
-    // Only intercept absolute filesystem paths.
-    if (mediaPath.startsWith("/")) {
-      mediaMatches.push({
-        fullMatch: match[0],
-        path: mediaPath,
-      });
-      logger.debug("Detected absolute path MEDIA line", {
-        streamId,
-        mediaPath,
-        line: match[0],
-      });
-    }
-  }
-
-  // Queue absolute-path images; send non-image files via Agent DM.
-  const mediaImageExts = new Set(["jpg", "jpeg", "png", "gif", "bmp"]);
-  let processedText = text;
-  if (mediaMatches.length > 0 && streamId) {
-    for (const media of mediaMatches) {
-      // Resolve /workspace/ sandbox paths to host-side paths.
-      const resolvedMediaPath = resolveHostPath(media.path, effectiveAgentId);
-      if (!resolvedMediaPath) {
-        processedText = processedText
-          .replace(media.fullMatch, "⚠️ 检测到不安全的 /workspace/ 路径，已拒绝发送")
-          .trim();
-        continue;
-      }
-      const mediaExt = resolvedMediaPath.split(".").pop()?.toLowerCase() || "";
-      if (mediaImageExts.has(mediaExt)) {
-        // Image: queue for delivery when stream finishes.
-        const queued = streamManager.queueImage(streamId, resolvedMediaPath);
-        if (queued) {
-          processedText = processedText.replace(media.fullMatch, "").trim();
-          logger.info("Queued absolute path image for stream", {
-            streamId,
-            imagePath: resolvedMediaPath,
-          });
-        }
-      } else {
-        // Non-image file: WeCom Bot stream API does not support files.
-        // Send via Agent DM and replace the MEDIA line with a hint.
-        const mediaFilename = basename(resolvedMediaPath);
-        const agentCfgMedia = resolveAgentConfig();
-        if (agentCfgMedia && senderId) {
-          try {
-            const hint = await uploadAndSendFile({
-              hostPath: resolvedMediaPath,
-              filename: mediaFilename,
-              agent: agentCfgMedia,
-              senderId,
-              streamId,
-            });
-            processedText = processedText
-              .replace(media.fullMatch, hint)
-              .trim();
-            logger.info("Sent non-image file via Agent DM (MEDIA line)", {
-              streamId,
-              filename: mediaFilename,
-              senderId,
-            });
-          } catch (mediaErr) {
-            processedText = processedText
-              .replace(media.fullMatch, `⚠️ 文件发送失败（${mediaFilename}）：${mediaErr.message}`)
-              .trim();
-            logger.error("Failed to send non-image file via Agent DM (MEDIA line)", {
-              streamId,
-              filename: mediaFilename,
-              error: mediaErr.message,
-            });
-          }
-        } else {
-          // No agent configured or no sender — just strip the MEDIA line.
-          processedText = processedText
-            .replace(media.fullMatch, `⚠️ 无法发送文件 ${mediaFilename}（未配置 Agent API）`)
-            .trim();
-        }
-      }
-    }
-  }
-
-  // Handle payload.mediaUrl / payload.mediaUrls from OpenClaw core dispatcher.
-  // These are local file paths or remote URLs that the LLM wants to deliver as media.
-  const payloadMediaUrls = payload.mediaUrls || (payload.mediaUrl ? [payload.mediaUrl] : []);
-  if (payloadMediaUrls.length > 0) {
-    const payloadImageExts = new Set(["jpg", "jpeg", "png", "gif", "bmp", "webp"]);
-    for (const mediaPath of payloadMediaUrls) {
-      // Normalize sandbox: prefix
-      let absPath = mediaPath;
-      if (absPath.startsWith("sandbox:")) {
-        absPath = absPath.replace(/^sandbox:\/{0,2}/, "");
-        if (!absPath.startsWith("/")) absPath = "/" + absPath;
-      }
-      // Resolve /workspace/ sandbox paths to host-side paths.
-      absPath = resolveHostPath(absPath, effectiveAgentId);
-      if (!absPath) {
-        const unsafeHint = "⚠️ 检测到不安全的 /workspace/ 路径，已拒绝发送";
-        if (streamId && streamManager.hasStream(streamId)) {
-          streamManager.appendStream(streamId, `\n\n${unsafeHint}`);
-        } else {
-          processedText = processedText ? `${processedText}\n\n${unsafeHint}` : unsafeHint;
-        }
-        continue;
-      }
-
-      const isLocal = absPath.startsWith("/");
-      const mediaFilename = isLocal ? basename(absPath) : (basename(new URL(mediaPath).pathname) || "file");
-      const ext = mediaFilename.split(".").pop()?.toLowerCase() || "";
-
-      if (isLocal && payloadImageExts.has(ext) && streamId) {
-        // Image: queue for delivery via stream msg_item when stream finishes.
-        const queued = streamManager.queueImage(streamId, absPath);
-        if (queued) {
-          logger.info("Queued payload image for stream", { streamId, imagePath: absPath });
-        }
-      } else {
-        // Non-image file (or image without active stream): send via Agent DM.
-        const agentCfgPayload = resolveAgentConfig();
-        if (agentCfgPayload && senderId) {
-          try {
-            let fileBuf;
-            if (isLocal) {
-              fileBuf = await readFile(absPath);
-            } else {
-              const res = await wecomFetch(mediaPath);
-              if (!res.ok) throw new Error(`download failed: ${res.status}`);
-              fileBuf = Buffer.from(await res.arrayBuffer());
-            }
-
-            // Determine upload type based on content type
-            let uploadType = "file";
-            if (payloadImageExts.has(ext)) uploadType = "image";
-
-            // Check minimum file size for WeCom upload.
-            if (fileBuf.length < WECOM_MIN_FILE_SIZE) {
-              const content = fileBuf.toString("utf-8");
-              await agentSendText({
-                agent: agentCfgPayload,
-                toUser: senderId,
-                text: `📄 ${mediaFilename}:\n${content}`,
-              });
-              logger.info("Sent tiny payload media as text via Agent DM", {
-                streamId,
-                filename: mediaFilename,
-                size: fileBuf.length,
-              });
-            } else {
-              const uploadedId = await agentUploadMedia({
-                agent: agentCfgPayload,
-                type: uploadType,
-                buffer: fileBuf,
-                filename: mediaFilename,
-              });
-              await agentSendMedia({
-                agent: agentCfgPayload,
-                toUser: senderId,
-                mediaId: uploadedId,
-                mediaType: uploadType,
-              });
-            }
-
-            // Add hint in stream text
-            const hint = `📎 文件已通过私信发送给您：${mediaFilename}`;
-            if (streamId && streamManager.hasStream(streamId)) {
-              streamManager.appendStream(streamId, `\n\n${hint}`);
-            } else {
-              processedText = processedText ? `${processedText}\n\n${hint}` : hint;
-            }
-            logger.info("Sent payload media via Agent DM", {
-              streamId,
-              filename: mediaFilename,
-              senderId,
-            });
-          } catch (payloadMediaErr) {
-            logger.error("Failed to send payload media via Agent DM", {
-              streamId,
-              mediaPath: mediaPath.substring(0, 80),
-              error: payloadMediaErr.message,
-            });
-            const errHint = `⚠️ 文件发送失败（${mediaFilename}）：${payloadMediaErr.message}`;
-            if (streamId && streamManager.hasStream(streamId)) {
-              streamManager.appendStream(streamId, `\n\n${errHint}`);
-            } else {
-              processedText = processedText ? `${processedText}\n\n${errHint}` : errHint;
-            }
-          }
-        } else {
-          const noAgentHint = `⚠️ 无法发送文件 ${mediaFilename}（未配置 Agent API）`;
-          if (streamId && streamManager.hasStream(streamId)) {
-            streamManager.appendStream(streamId, `\n\n${noAgentHint}`);
-          } else {
-            processedText = processedText ? `${processedText}\n\n${noAgentHint}` : noAgentHint;
-          }
-        }
-      }
-    }
-  }
-
-  // All outbound content is sent via stream updates.
-  if (!processedText.trim()) {
-    logger.debug("WeCom: empty block after processing, skipping stream update");
-    return;
-  }
-
-  // Helper: append content with duplicate suppression and placeholder awareness.
-  const appendToStream = (targetStreamId, content) => {
-    const stream = streamManager.getStream(targetStreamId);
-    if (!stream) {
-      return false;
-    }
-
-    // If stream still has the placeholder, replace it entirely.
-    if (stream.content.trim() === THINKING_PLACEHOLDER.trim()) {
-      streamManager.replaceIfPlaceholder(targetStreamId, content, THINKING_PLACEHOLDER);
-      return true;
-    }
-
-    // Skip duplicate chunks (for example, block + final overlap).
-    if (stream.content.includes(content.trim())) {
-      logger.debug("WeCom: duplicate content, skipping", {
-        streamId: targetStreamId,
-        contentPreview: content.substring(0, 30),
-      });
-      return true;
-    }
-
-    const separator = stream.content.length > 0 ? "\n\n" : "";
-    streamManager.appendStream(targetStreamId, separator + content);
-    return true;
-  };
-
-  if (!streamId) {
-    // Try async context first, then fallback to active stream map.
-    const ctx = streamContext.getStore();
-    const contextStreamId = ctx?.streamId;
-    const activeStreamId = contextStreamId ?? resolveActiveStream(senderId);
-
-    if (activeStreamId && streamManager.hasStream(activeStreamId)) {
-      appendToStream(activeStreamId, processedText);
-      logger.debug("WeCom stream appended (via context/activeStreams)", {
-        streamId: activeStreamId,
-        source: contextStreamId ? "asyncContext" : "activeStreams",
-        contentLength: processedText.length,
-      });
-      return;
-    }
-    logger.warn("WeCom: no active stream for this message", { senderId });
-    return;
-  }
-
-  if (!streamManager.hasStream(streamId)) {
-    logger.warn("WeCom: stream not found, attempting response_url fallback", { streamId, senderId });
-
-    // Layer 2: Fallback via response_url (stream closed, but response_url may still be valid)
-    const saved = responseUrls.get(senderId);
-    if (saved && !saved.used && Date.now() < saved.expiresAt) {
-      try {
-        const response = await wecomFetch(saved.url, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ msgtype: "markdown", markdown: { content: processedText } }),
-        });
-        const responseBody = await response.text().catch(() => "");
-        const result = parseResponseUrlResult(response, responseBody);
-        if (!result.accepted) {
-          logger.error("WeCom: response_url fallback rejected (deliverWecomReply)", {
-            senderId,
-            status: response.status,
-            statusText: response.statusText,
-            errcode: result.errcode,
-            errmsg: result.errmsg,
-            bodyPreview: result.bodyPreview,
-          });
-        } else {
-          saved.used = true;
-          logger.info("WeCom: sent via response_url fallback (deliverWecomReply)", {
-            senderId,
-            status: response.status,
-            errcode: result.errcode,
-            contentPreview: processedText.substring(0, 50),
-          });
-          return;
-        }
-      } catch (err) {
-        logger.error("WeCom: response_url fallback failed", {
-          senderId,
-          error: err.message,
-        });
-      }
-    }
-
-    // Layer 3: Agent API fallback (stream closed + response_url unavailable)
-    const agentConfig = resolveAgentConfig();
-    if (agentConfig) {
-      try {
-        await agentSendText({ agent: agentConfig, toUser: senderId, text: processedText });
-        logger.info("WeCom: sent via Agent API fallback (deliverWecomReply)", {
-          senderId,
-          contentPreview: processedText.substring(0, 50),
-        });
-        return;
-      } catch (err) {
-        logger.error("WeCom: Agent API fallback failed", { senderId, error: err.message });
-      }
-    }
-    logger.warn("WeCom: unable to deliver message (all layers exhausted)", {
-      senderId,
-      contentPreview: processedText.substring(0, 50),
-    });
-    return;
-  }
-
-  appendToStream(streamId, processedText);
-  logger.debug("WeCom stream appended", {
-    streamId,
-    contentLength: processedText.length,
-    to: senderId,
-  });
-}

package/wecom/response-url.js

@@ -1,33 +0,0 @@
-import { RESPONSE_URL_ERROR_BODY_PREVIEW_MAX } from "./constants.js";
-
-export function normalizeWecomErrcode(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
-    return Number.parseInt(value.trim(), 10);
-  }
-  return null;
-}
-
-export function parseResponseUrlResult(response, responseBody) {
-  const bodyText = typeof responseBody === "string" ? responseBody.trim() : "";
-  let parsed = null;
-  if (bodyText) {
-    try {
-      parsed = JSON.parse(bodyText);
-    } catch {
-      parsed = null;
-    }
-  }
-  const errcode = normalizeWecomErrcode(parsed?.errcode);
-  const errmsg = typeof parsed?.errmsg === "string" ? parsed.errmsg : "";
-  // WeCom response_url should return JSON with errcode=0 when accepted.
-  const accepted = response.ok && errcode === 0;
-  return {
-    accepted,
-    errcode,
-    errmsg,
-    bodyPreview: bodyText.substring(0, RESPONSE_URL_ERROR_BODY_PREVIEW_MAX),
-  };
-}