@sunnoy/wecom 2.0.2 → 2.2.0

package/wecom/mcp-config.js

@@ -0,0 +1,146 @@
+import os from "node:os";
+import path from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { generateReqId } from "@wecom/aibot-node-sdk";
+import { logger } from "../logger.js";
+
+const MCP_GET_CONFIG_CMD = "aibot_get_mcp_config";
+const MCP_CONFIG_FETCH_TIMEOUT_MS = 15_000;
+const MCP_CONFIG_KEY = "doc";
+const DEFAULT_MCP_TRANSPORT = "streamable-http";
+
+let mcpConfigWriteQueue = Promise.resolve();
+
+function withTimeout(promise, timeoutMs, message) {
+  if (!timeoutMs || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return promise;
+  }
+
+  let timer = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message ?? `Timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+
+  promise.catch(() => {});
+
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+}
+
+function getWecomConfigPath() {
+  return path.join(os.homedir(), ".openclaw", "wecomConfig", "config.json");
+}
+
+function resolveMcpTransport(body = {}) {
+  const candidate = String(
+    body.transport_type ??
+      body.transportType ??
+      body.config_type ??
+      body.configType ??
+      body.type ??
+      "",
+  )
+    .trim()
+    .toLowerCase();
+
+  return candidate || DEFAULT_MCP_TRANSPORT;
+}
+
+async function readJsonFile(filePath, fallback = {}) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return fallback;
+    }
+    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 async function fetchMcpConfig(wsClient) {
+  if (!wsClient || typeof wsClient.reply !== "function") {
+    throw new Error("WS client does not support MCP config requests");
+  }
+
+  const reqId = generateReqId("mcp_config");
+  const response = await withTimeout(
+    wsClient.reply({ headers: { req_id: reqId } }, { biz_type: MCP_CONFIG_KEY }, MCP_GET_CONFIG_CMD),
+    MCP_CONFIG_FETCH_TIMEOUT_MS,
+    `MCP config fetch timed out after ${MCP_CONFIG_FETCH_TIMEOUT_MS}ms`,
+  );
+
+  if (response?.errcode && response.errcode !== 0) {
+    throw new Error(`MCP config request failed: errcode=${response.errcode}, errmsg=${response.errmsg ?? "unknown"}`);
+  }
+
+  const body = response?.body;
+  if (!body?.url) {
+    throw new Error("MCP config response missing required 'url' field");
+  }
+
+  return {
+    key: MCP_CONFIG_KEY,
+    type: resolveMcpTransport(body),
+    url: body.url,
+    isAuthed: body.is_authed,
+  };
+}
+
+export async function saveMcpConfig(config, runtime) {
+  const configPath = getWecomConfigPath();
+
+  const saveTask = mcpConfigWriteQueue.then(async () => {
+    const current = await readJsonFile(configPath, {});
+    if (!current.mcpConfig || typeof current.mcpConfig !== "object") {
+      current.mcpConfig = {};
+    }
+
+    current.mcpConfig[config.key || MCP_CONFIG_KEY] = {
+      type: config.type,
+      url: config.url,
+    };
+
+    await writeJsonFileAtomically(configPath, current);
+    runtime?.log?.(`[WeCom] MCP config saved to ${configPath}`);
+  });
+
+  mcpConfigWriteQueue = saveTask.catch(() => {});
+  return saveTask;
+}
+
+export async function fetchAndSaveMcpConfig(wsClient, accountId, runtime) {
+  try {
+    runtime?.log?.(`[${accountId}] Fetching MCP config...`);
+    const config = await fetchMcpConfig(wsClient);
+    runtime?.log?.(
+      `[${accountId}] MCP config fetched: url=${config.url}, type=${config.type}, is_authed=${config.isAuthed ?? "N/A"}`,
+    );
+    await saveMcpConfig(config, runtime);
+  } catch (error) {
+    if (typeof wsClient?.reply !== "function") {
+      logger.debug?.(`[${accountId}] Skipping MCP config fetch because WS client has no reply() support`);
+      return;
+    }
+    runtime?.error?.(`[${accountId}] Failed to fetch/save MCP config: ${String(error)}`);
+  }
+}
+
+export const mcpConfigTesting = {
+  getWecomConfigPath,
+  resolveMcpTransport,
+  resetWriteQueue() {
+    mcpConfigWriteQueue = Promise.resolve();
+  },
+};

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