@sunnoy/wecom 2.1.0 → 2.2.1

package/wecom/media-uploader.js

@@ -0,0 +1,208 @@
+import { basename } from "node:path";
+import { logger } from "../logger.js";
+import { loadOutboundMediaFromUrl, detectMime, getExtendedMediaLocalRoots } from "./openclaw-compat.js";
+import {
+  IMAGE_MAX_BYTES,
+  VIDEO_MAX_BYTES,
+  VOICE_MAX_BYTES,
+  ABSOLUTE_MAX_BYTES,
+} from "./constants.js";
+
+const VOICE_SUPPORTED_MIMES = new Set(["audio/amr"]);
+
+const MIME_TO_EXT = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/bmp": ".bmp",
+  "image/svg+xml": ".svg",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "video/x-msvideo": ".avi",
+  "video/webm": ".webm",
+  "audio/mpeg": ".mp3",
+  "audio/ogg": ".ogg",
+  "audio/wav": ".wav",
+  "audio/amr": ".amr",
+  "audio/aac": ".aac",
+  "application/pdf": ".pdf",
+  "application/zip": ".zip",
+  "application/msword": ".doc",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+  "application/vnd.ms-excel": ".xls",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+  "text/plain": ".txt",
+};
+
+export function detectWeComMediaType(mimeType) {
+  const mime = String(mimeType ?? "").toLowerCase();
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/") || mime === "application/ogg") return "voice";
+  return "file";
+}
+
+export function mimeToExtension(mime) {
+  return MIME_TO_EXT[mime] || ".bin";
+}
+
+export function extractFileName(mediaUrl, providedFileName, contentType) {
+  if (providedFileName) return providedFileName;
+
+  try {
+    const urlObj = new URL(mediaUrl, "file://");
+    const lastPart = urlObj.pathname.split("/").pop();
+    if (lastPart?.includes(".")) return decodeURIComponent(lastPart);
+  } catch {
+    const lastPart = String(mediaUrl).split("/").pop();
+    if (lastPart?.includes(".")) return lastPart;
+  }
+
+  return `media_${Date.now()}${mimeToExtension(contentType || "application/octet-stream")}`;
+}
+
+export function applyFileSizeLimits(fileSize, detectedType, contentType) {
+  const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+
+  if (fileSize > ABSOLUTE_MAX_BYTES) {
+    return {
+      finalType: detectedType,
+      shouldReject: true,
+      rejectReason: `文件大小 ${fileSizeMB}MB 超过了企业微信允许的最大限制 20MB，无法发送。请尝试压缩文件或减小文件大小。`,
+      downgraded: false,
+    };
+  }
+
+  switch (detectedType) {
+    case "image":
+      if (fileSize > IMAGE_MAX_BYTES) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `图片大小 ${fileSizeMB}MB 超过 10MB 限制，已转为文件格式发送`,
+        };
+      }
+      break;
+    case "video":
+      if (fileSize > VIDEO_MAX_BYTES) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `视频大小 ${fileSizeMB}MB 超过 10MB 限制，已转为文件格式发送`,
+        };
+      }
+      break;
+    case "voice":
+      if (contentType && !VOICE_SUPPORTED_MIMES.has(contentType.toLowerCase())) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `语音格式 ${contentType} 不支持，企微仅支持 AMR 格式，已转为文件格式发送`,
+        };
+      }
+      if (fileSize > VOICE_MAX_BYTES) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `语音大小 ${fileSizeMB}MB 超过 2MB 限制，已转为文件格式发送`,
+        };
+      }
+      break;
+  }
+
+  return { finalType: detectedType, shouldReject: false, downgraded: false };
+}
+
+async function resolveMediaFile(mediaUrl, mediaLocalRoots, includeDefaultMediaLocalRoots = true) {
+  const result = await loadOutboundMediaFromUrl(mediaUrl, {
+    maxBytes: ABSOLUTE_MAX_BYTES,
+    mediaLocalRoots,
+    includeDefaultMediaLocalRoots,
+  });
+
+  if (!result.buffer || result.buffer.length === 0) {
+    throw new Error(`Failed to load media from ${mediaUrl}: empty buffer`);
+  }
+
+  let contentType = result.contentType || "application/octet-stream";
+  if (contentType === "application/octet-stream" || contentType === "text/plain") {
+    const detected = await detectMime(result.buffer);
+    if (detected) contentType = detected;
+  }
+
+  return {
+    buffer: result.buffer,
+    contentType,
+    fileName: extractFileName(mediaUrl, result.fileName, contentType),
+  };
+}
+
+export function buildMediaErrorSummary(mediaUrl, result) {
+  if (result.error?.includes("LocalMediaAccessError")) {
+    return `文件发送失败：没有权限访问路径 ${mediaUrl}\n请在 openclaw.json 的 mediaLocalRoots 中添加该路径的父目录后重启生效。`;
+  }
+  if (result.rejectReason) {
+    return `文件发送失败：${result.rejectReason}`;
+  }
+  return `文件发送失败：无法处理文件 ${mediaUrl}，请稍后再试。`;
+}
+
+export async function uploadAndSendMedia({
+  wsClient,
+  mediaUrl,
+  chatId,
+  mediaLocalRoots,
+  includeDefaultMediaLocalRoots = true,
+  log,
+  errorLog,
+}) {
+  try {
+    log?.(`[wecom] Uploading media: url=${mediaUrl}`);
+    const media = await resolveMediaFile(mediaUrl, mediaLocalRoots, includeDefaultMediaLocalRoots);
+    const detectedType = detectWeComMediaType(media.contentType);
+    const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
+
+    if (sizeCheck.shouldReject) {
+      errorLog?.(`[wecom] Media rejected: ${sizeCheck.rejectReason}`);
+      return {
+        ok: false,
+        rejected: true,
+        rejectReason: sizeCheck.rejectReason,
+        finalType: sizeCheck.finalType,
+      };
+    }
+
+    const finalType = sizeCheck.finalType;
+    const uploadResult = await wsClient.uploadMedia(media.buffer, {
+      type: finalType,
+      filename: media.fileName,
+    });
+    log?.(`[wecom] Media uploaded: media_id=${uploadResult.media_id}, type=${finalType}`);
+
+    const result = await wsClient.sendMediaMessage(chatId, finalType, uploadResult.media_id);
+    const messageId = result?.headers?.req_id ?? `wecom-media-${Date.now()}`;
+    log?.(`[wecom] Media sent via sendMediaMessage: chatId=${chatId}, type=${finalType}`);
+
+    return {
+      ok: true,
+      messageId,
+      finalType,
+      downgraded: sizeCheck.downgraded,
+      downgradeNote: sizeCheck.downgradeNote,
+    };
+  } catch (err) {
+    const errMsg = String(err);
+    errorLog?.(`[wecom] Failed to upload/send media: url=${mediaUrl}, error=${errMsg}`);
+    return { ok: false, error: errMsg };
+  }
+}
+
+export const mediaUploaderTesting = {
+  resolveMediaFile,
+  VOICE_SUPPORTED_MIMES,
+};

package/wecom/openclaw-compat.js

@@ -0,0 +1,302 @@
+import { basename, extname, join, parse, resolve } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { readFile, realpath, stat } from "node:fs/promises";
+
+const sdkReady = import("openclaw/plugin-sdk")
+  .then((sdk) => ({
+    loadOutboundMediaFromUrl:
+      typeof sdk.loadOutboundMediaFromUrl === "function" ? sdk.loadOutboundMediaFromUrl.bind(sdk) : undefined,
+    detectMime: typeof sdk.detectMime === "function" ? sdk.detectMime.bind(sdk) : undefined,
+    getDefaultMediaLocalRoots:
+      typeof sdk.getDefaultMediaLocalRoots === "function" ? sdk.getDefaultMediaLocalRoots.bind(sdk) : undefined,
+  }))
+  .catch(() => ({}));
+
+const MIME_BY_EXT = {
+  ".aac": "audio/aac",
+  ".amr": "audio/amr",
+  ".avi": "video/x-msvideo",
+  ".bmp": "image/bmp",
+  ".csv": "text/csv",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".gz": "application/gzip",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".m4a": "audio/x-m4a",
+  ".md": "text/markdown",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".ogg": "audio/ogg",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".rar": "application/vnd.rar",
+  ".svg": "image/svg+xml",
+  ".tar": "application/x-tar",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".zip": "application/zip",
+  ".7z": "application/x-7z-compressed",
+};
+
+function resolveUserPath(value) {
+  if (!value.startsWith("~")) {
+    return value;
+  }
+  return join(homedir(), value.slice(1));
+}
+
+function normalizeRootEntry(entry) {
+  const value = String(entry ?? "").trim();
+  if (!value) {
+    return null;
+  }
+  return resolve(resolveUserPath(value));
+}
+
+function normalizeMediaReference(mediaUrl) {
+  let value = String(mediaUrl ?? "").trim();
+  if (!value) {
+    return "";
+  }
+  value = value.replace(/^\s*(?:MEDIA|FILE)\s*:\s*/i, "");
+  if (value.startsWith("sandbox:")) {
+    value = value.replace(/^sandbox:\/{0,2}/, "");
+    if (!value.startsWith("/")) {
+      value = `/${value}`;
+    }
+  }
+  return value;
+}
+
+function resolveStateDir() {
+  const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+  if (override) {
+    return resolve(resolveUserPath(override));
+  }
+  if (process.env.VITEST || process.env.NODE_ENV === "test") {
+    return join(tmpdir(), ["openclaw-vitest", String(process.pid)].join("-"));
+  }
+  return join(homedir(), ".openclaw");
+}
+
+async function sniffMimeFromBuffer(buffer) {
+  try {
+    const { fileTypeFromBuffer } = await import("file-type");
+    const type = await fileTypeFromBuffer(buffer);
+    return type?.mime ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function detectMimeFallback(options) {
+  const ext = options.filePath ? extname(options.filePath).toLowerCase() : "";
+  const extMime = ext ? MIME_BY_EXT[ext] : undefined;
+  const sniffed = options.buffer ? await sniffMimeFromBuffer(options.buffer) : undefined;
+  const headerMime = options.headerMime?.split(";")?.[0]?.trim().toLowerCase();
+  const isGeneric = (value) => !value || value === "application/octet-stream" || value === "application/zip";
+
+  if (sniffed && (!isGeneric(sniffed) || !extMime)) {
+    return sniffed;
+  }
+  if (extMime) {
+    return extMime;
+  }
+  if (headerMime && !isGeneric(headerMime)) {
+    return headerMime;
+  }
+  return sniffed || headerMime || undefined;
+}
+
+function hasExplicitMediaRoots(options = {}) {
+  return Boolean(
+    (Array.isArray(options.mediaLocalRoots) && options.mediaLocalRoots.length > 0) ||
+      (Array.isArray(options.accountConfig?.mediaLocalRoots) && options.accountConfig.mediaLocalRoots.length > 0),
+  );
+}
+
+function isLocalMediaAccessError(error) {
+  const message = String(error?.message ?? error ?? "");
+  return /Local media path is not under an allowed directory|LocalMediaAccessError/i.test(message);
+}
+
+function shouldFallbackFromLocalAccessError(error, options) {
+  return isLocalMediaAccessError(error) && !hasExplicitMediaRoots(options);
+}
+
+async function readLocalMediaFile(filePath, { maxBytes } = {}) {
+  const info = await stat(filePath);
+  if (!info.isFile()) {
+    throw new Error(`Local media path is not a file: ${filePath}`);
+  }
+  const buffer = await readFile(filePath);
+  if (maxBytes && buffer.length > maxBytes) {
+    throw new Error(`Local media exceeds max size (${buffer.length} > ${maxBytes})`);
+  }
+  return {
+    buffer,
+    contentType: (await detectMimeFallback({ buffer, filePath })) || "",
+    fileName: basename(filePath) || "file",
+  };
+}
+
+async function fetchRemoteMedia(url, { maxBytes, fetchImpl } = {}) {
+  const response = await (fetchImpl ?? fetch)(url, { redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(`failed to download media: ${response.status}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (maxBytes && buffer.length > maxBytes) {
+    throw new Error(`Media from ${url} exceeds max size (${buffer.length} > ${maxBytes})`);
+  }
+  const disposition = response.headers.get("content-disposition");
+  let fileName = "";
+  if (disposition) {
+    const match = /filename\*?\s*=\s*(?:UTF-8''|")?([^";]+)/i.exec(disposition);
+    if (match?.[1]) {
+      try {
+        fileName = basename(decodeURIComponent(match[1].replace(/["']/g, "").trim()));
+      } catch {
+        fileName = basename(match[1].replace(/["']/g, "").trim());
+      }
+    }
+  }
+  if (!fileName) {
+    try {
+      fileName = basename(new URL(url).pathname) || "file";
+    } catch {
+      fileName = "file";
+    }
+  }
+  const headerMime = response.headers.get("content-type") || "";
+  return {
+    buffer,
+    contentType: (await detectMimeFallback({ buffer, headerMime, filePath: fileName || url })) || headerMime || "",
+    fileName,
+  };
+}
+
+function asLocalPath(mediaRef) {
+  if (!mediaRef) {
+    return "";
+  }
+  if (mediaRef.startsWith("file://")) {
+    return fileURLToPath(mediaRef);
+  }
+  if (mediaRef.startsWith("/") || mediaRef.startsWith("~")) {
+    return resolve(resolveUserPath(mediaRef));
+  }
+  return "";
+}
+
+export async function detectMime(bufferOrOptions) {
+  const sdk = await sdkReady;
+  const options = Buffer.isBuffer(bufferOrOptions) ? { buffer: bufferOrOptions } : bufferOrOptions;
+  if (sdk.detectMime) {
+    try {
+      return await sdk.detectMime(options);
+    } catch {}
+  }
+  return detectMimeFallback(options);
+}
+
+export async function getDefaultMediaLocalRoots() {
+  const sdk = await sdkReady;
+  if (sdk.getDefaultMediaLocalRoots) {
+    try {
+      return await sdk.getDefaultMediaLocalRoots();
+    } catch {}
+  }
+
+  const stateDir = resolveStateDir();
+  return [
+    join(stateDir, "media"),
+    join(stateDir, "agents"),
+    join(stateDir, "workspace"),
+    join(stateDir, "sandboxes"),
+  ];
+}
+
+export async function getExtendedMediaLocalRoots({
+  accountConfig,
+  mediaLocalRoots,
+  includeDefaultMediaLocalRoots = true,
+} = {}) {
+  const defaults = includeDefaultMediaLocalRoots ? await getDefaultMediaLocalRoots() : [];
+  const roots = [
+    ...defaults,
+    ...(Array.isArray(accountConfig?.mediaLocalRoots) ? accountConfig.mediaLocalRoots : []),
+    ...(Array.isArray(mediaLocalRoots) ? mediaLocalRoots : []),
+  ]
+    .map(normalizeRootEntry)
+    .filter(Boolean);
+
+  return [...new Set(roots)];
+}
+
+export async function loadOutboundMediaFromUrl(mediaUrl, options = {}) {
+  const normalized = normalizeMediaReference(mediaUrl);
+  const filePath = asLocalPath(normalized);
+  const localRoots = await getExtendedMediaLocalRoots(options);
+  const sdk = await sdkReady;
+
+  if (filePath) {
+    if (typeof options.runtimeLoadMedia === "function" && localRoots.length > 0) {
+      try {
+        const loaded = await options.runtimeLoadMedia(filePath, { localRoots });
+        return {
+          buffer: loaded.buffer,
+          contentType: loaded.contentType || "",
+          fileName: loaded.fileName || basename(filePath) || "file",
+        };
+      } catch (error) {
+        if (!shouldFallbackFromLocalAccessError(error, options)) {
+          throw error;
+        }
+      }
+    }
+
+    if (sdk.loadOutboundMediaFromUrl) {
+      try {
+        return await sdk.loadOutboundMediaFromUrl(filePath, {
+          maxBytes: options.maxBytes,
+          mediaLocalRoots: localRoots,
+        });
+      } catch (error) {
+        if (!shouldFallbackFromLocalAccessError(error, options)) {
+          throw error;
+        }
+      }
+    }
+
+    return readLocalMediaFile(filePath, options);
+  }
+
+  if (sdk.loadOutboundMediaFromUrl && !options.fetchImpl) {
+    return sdk.loadOutboundMediaFromUrl(normalized, {
+      maxBytes: options.maxBytes,
+      mediaLocalRoots: localRoots,
+    });
+  }
+
+  return fetchRemoteMedia(normalized, options);
+}
+
+export { resolveStateDir };
+
+export const openclawCompatTesting = {
+  normalizeMediaReference,
+};

package/wecom/reqid-store.js

@@ -0,0 +1,146 @@
+import path from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { logger } from "../logger.js";
+import { REQID_TTL_MS, REQID_MAX_SIZE, REQID_FLUSH_DEBOUNCE_MS } from "./constants.js";
+import { resolveStateDir } from "./openclaw-compat.js";
+
+function getStorePath(accountId) {
+  return path.join(resolveStateDir(), "wecomConfig", `reqids-${accountId}.json`);
+}
+
+async function readJsonFile(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+async function writeJsonFileAtomically(filePath, value) {
+  const dir = path.dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  await rename(tempPath, filePath);
+}
+
+export function createPersistentReqIdStore(accountId, options = {}) {
+  const maxSize = options.maxSize ?? REQID_MAX_SIZE;
+  const ttlMs = options.ttlMs ?? REQID_TTL_MS;
+  const debounceMs = options.debounceMs ?? REQID_FLUSH_DEBOUNCE_MS;
+  const storePath = options.storePath ?? getStorePath(accountId);
+  const writeJson = options.writeJsonFileAtomically ?? writeJsonFileAtomically;
+  const cache = new Map();
+  let dirty = false;
+  let dirtyVersion = 0;
+  let flushTimer = null;
+  let flushPromise = null;
+
+  function evictOldest() {
+    if (cache.size <= maxSize) return;
+    const entries = [...cache.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+    const toRemove = entries.length - maxSize;
+    for (let i = 0; i < toRemove; i++) {
+      cache.delete(entries[i][0]);
+    }
+  }
+
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(async () => {
+      flushTimer = null;
+      try {
+        await store.flush();
+      } catch (error) {
+        logger.warn(`[ReqIdStore:${accountId}] Debounced flush failed: ${error.message}`);
+      }
+    }, debounceMs);
+  }
+
+  const store = {
+    set(chatId, reqId) {
+      cache.set(chatId, { reqId, updatedAt: Date.now() });
+      dirty = true;
+      dirtyVersion += 1;
+      evictOldest();
+      scheduleFlush();
+    },
+
+    getSync(chatId) {
+      const entry = cache.get(chatId);
+      if (!entry) return undefined;
+      if (Date.now() - entry.updatedAt > ttlMs) {
+        cache.delete(chatId);
+        return undefined;
+      }
+      return entry.reqId;
+    },
+
+    async warmup() {
+      try {
+        const data = await readJsonFile(storePath);
+        const now = Date.now();
+        for (const [chatId, entry] of Object.entries(data)) {
+          if (entry?.reqId && entry?.updatedAt && now - entry.updatedAt <= ttlMs) {
+            cache.set(chatId, entry);
+          }
+        }
+        evictOldest();
+        logger.info(`[ReqIdStore:${accountId}] Warmed up ${cache.size} entries from ${storePath}`);
+      } catch (error) {
+        logger.warn(`[ReqIdStore:${accountId}] Warmup failed (non-fatal): ${error.message}`);
+      }
+    },
+
+    async flush() {
+      if (flushPromise) {
+        await flushPromise;
+        if (!dirty) return;
+      }
+      if (!dirty) return;
+      const currentFlush = (async () => {
+        const snapshot = Object.fromEntries(cache);
+        const snapshotVersion = dirtyVersion;
+        try {
+          await writeJson(storePath, snapshot);
+          if (dirtyVersion === snapshotVersion) {
+            dirty = false;
+          } else {
+            scheduleFlush();
+          }
+          logger.debug(`[ReqIdStore:${accountId}] Flushed ${cache.size} entries to disk`);
+        } catch (error) {
+          // Keep dirty = true so a subsequent set() or scheduled flush can retry
+          logger.warn(`[ReqIdStore:${accountId}] Flush failed, will retry on next trigger: ${error.message}`);
+          scheduleFlush();
+        }
+      })();
+      flushPromise = currentFlush;
+      try {
+        await currentFlush;
+      } finally {
+        if (flushPromise === currentFlush) {
+          flushPromise = null;
+        }
+      }
+    },
+
+    destroy() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+    },
+
+    get size() {
+      return cache.size;
+    },
+  };
+
+  return store;
+}
+
+export const reqIdStoreTesting = {
+  getStorePath,
+};

package/wecom/target.js

@@ -47,8 +47,9 @@ export function resolveWecomTarget(raw) {
   if (/^(wr|wc)/i.test(clean)) {
     return { chatId: clean };
   }
-  // Pure digits are likely department (party) IDs.
-  if (/^\d+$/.test(clean)) {
+  // Short pure-digit strings (≤6 digits) are department (party) IDs.
+  // Longer digit strings (phone numbers, external IDs) fall through to toUser.
+  if (/^\d{1,6}$/.test(clean)) {
     return { toParty: clean };
   }