@sunnoy/wecom 2.0.2 → 2.2.0

package/wecom/callback-media.js

@@ -0,0 +1,76 @@
+/**
+ * WeCom self-built app callback media downloader.
+ *
+ * Downloads inbound media (image/voice/file) from WeCom via the
+ * Agent API `/cgi-bin/media/get` endpoint using the access token
+ * obtained from the self-built app credentials.
+ */
+
+import path from "node:path";
+import { logger } from "../logger.js";
+import { getAccessToken } from "./agent-api.js";
+import { wecomFetch } from "./http.js";
+import { AGENT_API_ENDPOINTS, CALLBACK_MEDIA_DOWNLOAD_TIMEOUT_MS } from "./constants.js";
+
+/**
+ * Download a WeCom media file (image / voice / file) by MediaId via the
+ * self-built app access token and save it through the core media runtime.
+ *
+ * @param {object} params
+ * @param {object} params.agent   - { corpId, corpSecret, agentId }
+ * @param {string} params.mediaId - WeCom MediaId
+ * @param {"image"|"voice"|"file"} params.type - media type hint
+ * @param {object} params.runtime - OpenClaw runtime (for saveMediaBuffer)
+ * @param {object} params.config  - OpenClaw config (for mediaMaxMb)
+ * @returns {Promise<{ path: string, contentType: string }>}
+ */
+export async function downloadCallbackMedia({ agent, mediaId, type, runtime, config }) {
+  const token = await getAccessToken(agent);
+  const url = `${AGENT_API_ENDPOINTS.DOWNLOAD_MEDIA}?access_token=${encodeURIComponent(token)}&media_id=${encodeURIComponent(mediaId)}`;
+
+  const mediaMaxMb = config?.agents?.defaults?.mediaMaxMb ?? 5;
+  const maxBytes = mediaMaxMb * 1024 * 1024;
+
+  let response;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), CALLBACK_MEDIA_DOWNLOAD_TIMEOUT_MS);
+  try {
+    response = await wecomFetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+
+  if (!response.ok) {
+    throw new Error(`WeCom media download failed: HTTP ${response.status} for mediaId=${mediaId}`);
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const contentType =
+    response.headers.get("content-type") ||
+    (type === "image" ? "image/jpeg" : "application/octet-stream");
+
+  // Try to extract the filename from Content-Disposition
+  const disposition = response.headers.get("content-disposition") ?? "";
+  const filenameMatch = disposition.match(/filename[*\s]*=\s*(?:UTF-8''|")?([^";]+)/i);
+  const filename =
+    filenameMatch?.[1]?.trim() ||
+    (type === "image" ? `${mediaId}.jpg` : type === "voice" ? `${mediaId}.amr` : mediaId);
+
+  // Save via core media runtime when available
+  if (typeof runtime?.media?.saveMediaBuffer === "function") {
+    const saved = await runtime.media.saveMediaBuffer(buffer, contentType, "inbound", maxBytes, filename);
+    return { path: saved.path, contentType: saved.contentType };
+  }
+
+  // Fallback: write to OS temp dir
+  const { tmpdir } = await import("node:os");
+  const { writeFile } = await import("node:fs/promises");
+  const ext = path.extname(filename) || (type === "image" ? ".jpg" : ".bin");
+  const tempPath = path.join(
+    tmpdir(),
+    `wecom-cb-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`,
+  );
+  await writeFile(tempPath, buffer);
+  logger.debug(`[CB] Media saved to temp path: ${tempPath}`);
+  return { path: tempPath, contentType };
+}

package/wecom/channel-plugin.js

@@ -1,6 +1,5 @@
 import crypto from "node:crypto";
 import { basename } from "node:path";
-import { readFile } from "node:fs/promises";
 import {
   buildBaseAccountStatusSnapshot,
   buildBaseChannelStatusSummary,
@@ -23,9 +22,10 @@ import { agentSendMedia, agentSendText, agentUploadMedia } from "./agent-api.js"
 import { setConfigProxyUrl, wecomFetch } from "./http.js";
 import { wecomOnboardingAdapter } from "./onboarding.js";
 import { getAccountTelemetry, recordOutboundActivity } from "./runtime-telemetry.js";
-import { getRuntime, setOpenclawConfig } from "./state.js";
+import { getOpenclawConfig, getRuntime, setOpenclawConfig } from "./state.js";
 import { resolveWecomTarget } from "./target.js";
 import { webhookSendFile, webhookSendImage, webhookSendMarkdown, webhookUploadFile } from "./webhook-bot.js";
+import { loadOutboundMediaFromUrl as loadOutboundMediaFromUrlCompat } from "./openclaw-compat.js";
 import {
   CHANNEL_ID,
   DEFAULT_ACCOUNT_ID,
@@ -34,7 +34,10 @@ import {
   getWebhookBotSendUrl,
   setApiBaseUrl,
 } from "./constants.js";
+import { uploadAndSendMedia } from "./media-uploader.js";
+import { getExtendedMediaLocalRoots } from "./openclaw-compat.js";
 import { sendWsMessage, startWsMonitor } from "./ws-monitor.js";
+import { getWsClient } from "./ws-state.js";
 
 function normalizePairingEntry(entry) {
   return String(entry ?? "")
@@ -79,40 +82,32 @@ function normalizeMediaPath(mediaUrl) {
   return value;
 }
 
-async function loadMediaPayload(mediaUrl, { mediaLocalRoots } = {}) {
+async function loadMediaPayload(mediaUrl, { accountConfig, mediaLocalRoots } = {}) {
   const normalized = normalizeMediaPath(mediaUrl);
-  if (normalized.startsWith("/")) {
-    // Prefer core's loadWebMedia with sandbox enforcement when available.
-    const runtime = getRuntime();
-    if (typeof runtime?.media?.loadWebMedia === "function" && Array.isArray(mediaLocalRoots) && mediaLocalRoots.length > 0) {
-      const loaded = await runtime.media.loadWebMedia(normalized, { localRoots: mediaLocalRoots });
-      return {
-        buffer: loaded.buffer,
-        filename: loaded.fileName || basename(normalized) || "file",
-        contentType: loaded.contentType || "",
-      };
-    }
-    const buffer = await readFile(normalized);
-    return {
-      buffer,
-      filename: basename(normalized) || "file",
-      contentType: "",
-    };
-  }
+  let runtime = null;
+  try {
+    runtime = getRuntime();
+  } catch {}
+
+  const loaded = await loadOutboundMediaFromUrlCompat(normalized, {
+    accountConfig,
+    fetchImpl: wecomFetch,
+    mediaLocalRoots,
+    runtimeLoadMedia:
+      typeof runtime?.media?.loadWebMedia === "function"
+        ? (path, options) => runtime.media.loadWebMedia(path, options)
+        : undefined,
+  });
 
-  const response = await wecomFetch(normalized);
-  if (!response.ok) {
-    throw new Error(`failed to download media: ${response.status}`);
-  }
   return {
-    buffer: Buffer.from(await response.arrayBuffer()),
-    filename: basename(new URL(normalized).pathname) || "file",
-    contentType: response.headers.get("content-type") || "",
+    buffer: loaded.buffer,
+    filename: loaded.fileName || basename(normalized) || "file",
+    contentType: loaded.contentType || "",
   };
 }
 
-async function loadResolvedMedia(mediaUrl, { mediaLocalRoots } = {}) {
-  const media = await loadMediaPayload(mediaUrl, { mediaLocalRoots });
+async function loadResolvedMedia(mediaUrl, { accountConfig, mediaLocalRoots } = {}) {
+  const media = await loadMediaPayload(mediaUrl, { accountConfig, mediaLocalRoots });
   return {
     ...media,
     mediaType: resolveAgentMediaType(media.filename, media.contentType),
@@ -134,45 +129,6 @@ export function resolveAgentMediaTypeFromFilename(filename) {
   return resolveAgentMediaType(filename, "");
 }
 
-function resolveWsNoticeTarget(target, rawTo) {
-  if (target?.webhook || target?.toParty || target?.toTag) {
-    return null;
-  }
-  const fallback = String(rawTo ?? "").trim();
-  return target?.chatId || target?.toUser || fallback || null;
-}
-
-function buildUnsupportedMediaNotice({ text, mediaType, deliveredViaAgent }) {
-  let notice;
-  if (mediaType === "file") {
-    notice = deliveredViaAgent
-      ? "由于当前企业微信bot不支持给用户发送文件，文件通过自建应用发送。"
-      : "由于当前企业微信bot不支持给用户发送文件，且当前未配置自建应用发送渠道。";
-  } else if (mediaType === "image") {
-    notice = deliveredViaAgent
-      ? "由于当前企业微信bot不支持直接发送图片，图片通过自建应用发送。"
-      : "由于当前企业微信bot不支持直接发送图片，且当前未配置自建应用发送渠道。";
-  } else {
-    notice = deliveredViaAgent
-      ? "由于当前企业微信bot不支持直接发送媒体，媒体通过自建应用发送。"
-      : "由于当前企业微信bot不支持直接发送媒体，且当前未配置自建应用发送渠道。";
-  }
-
-  return [text, notice].filter(Boolean).join("\n\n");
-}
-
-async function sendUnsupportedMediaNoticeViaWs({ to, text, mediaType, accountId }) {
-  return sendWsMessage({
-    to,
-    content: buildUnsupportedMediaNotice({
-      text,
-      mediaType,
-      deliveredViaAgent: true,
-    }),
-    accountId,
-  });
-}
-
 function resolveOutboundAccountId(cfg, accountId) {
   return accountId || resolveDefaultAccountId(cfg);
 }
@@ -199,7 +155,8 @@ async function sendViaWebhook({ cfg, accountId, webhookName, text, mediaUrl, pre
     return { channel: CHANNEL_ID, messageId: `wecom-webhook-${Date.now()}` };
   }
 
-  const { buffer, filename, mediaType } = preparedMedia ?? (await loadResolvedMedia(mediaUrl));
+  const { buffer, filename, mediaType } =
+    preparedMedia ?? (await loadResolvedMedia(mediaUrl, { accountConfig: account?.config }));
 
   if (text) {
     await webhookSendMarkdown({ url, content: text });
@@ -237,7 +194,8 @@ async function sendViaAgent({ cfg, accountId, target, text, mediaUrl, preparedMe
     return { channel: CHANNEL_ID, messageId: `wecom-agent-${Date.now()}` };
   }
 
-  const { buffer, filename, mediaType } = preparedMedia ?? (await loadResolvedMedia(mediaUrl));
+  const { buffer, filename, mediaType } =
+    preparedMedia ?? (await loadResolvedMedia(mediaUrl, { accountConfig: resolveAccount(cfg, accountId)?.config }));
   const mediaId = await agentUploadMedia({
     agent,
     type: mediaType,
@@ -308,6 +266,24 @@ export const wecomChannelPlugin = {
         allowFrom: { type: "array", items: { type: "string" } },
         groupPolicy: { enum: ["open", "allowlist", "disabled"] },
         groupAllowFrom: { type: "array", items: { type: "string" } },
+        deliveryMode: { enum: ["direct", "gateway"] },
+        mediaLocalRoots: { type: "array", items: { type: "string" } },
+        agent: {
+          type: "object",
+          additionalProperties: true,
+          properties: {
+            replyFormat: { enum: ["text", "markdown"] },
+            callback: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                token: { type: "string" },
+                encodingAESKey: { type: "string" },
+                path: { type: "string" },
+              },
+            },
+          },
+        },
       },
     },
     uiHints: {
@@ -316,6 +292,10 @@ export const wecomChannelPlugin = {
       websocketUrl: { label: "WebSocket URL", placeholder: DEFAULT_WS_URL },
       welcomeMessage: { label: "Welcome Message" },
       "agent.corpSecret": { sensitive: true, label: "Application Secret" },
+      "agent.replyFormat": { label: "Reply Format", placeholder: "text" },
+      "agent.callback.token": { label: "Callback Token" },
+      "agent.callback.encodingAESKey": { label: "Callback Encoding AES Key", sensitive: true },
+      "agent.callback.path": { label: "Callback Path", placeholder: "/api/channels/wecom/callback" },
     },
   },
   config: {
@@ -324,7 +304,8 @@ export const wecomChannelPlugin = {
     defaultAccountId: (cfg) => resolveDefaultAccountId(cfg),
     setAccountEnabled: ({ cfg, accountId, enabled }) => updateAccountConfig(cfg, accountId, { enabled }),
     deleteAccount: ({ cfg, accountId }) => deleteAccountConfig(cfg, accountId),
-    isConfigured: (account) => Boolean(account.botId && account.secret),
+    isConfigured: (account) =>
+      Boolean((account.botId && account.secret) || account.callbackConfigured),
     describeAccount,
     resolveAllowFrom: ({ cfg, accountId }) => resolveAllowFromForAccount(cfg, accountId),
     formatAllowFrom: ({ allowFrom }) => normalizeAllowFromEntries(allowFrom.map((entry) => String(entry))),
@@ -360,7 +341,29 @@ export const wecomChannelPlugin = {
   messaging: {
     normalizeTarget: (target) => {
       const trimmed = String(target ?? "").trim();
-      return trimmed || undefined;
+      if (!trimmed) {
+        return undefined;
+      }
+      const resolved = resolveWecomTarget(trimmed);
+      if (!resolved) {
+        return undefined;
+      }
+      if (resolved.webhook) {
+        return `webhook:${resolved.webhook}`;
+      }
+      if (resolved.toParty) {
+        return `party:${resolved.toParty}`;
+      }
+      if (resolved.toTag) {
+        return `tag:${resolved.toTag}`;
+      }
+      if (resolved.chatId) {
+        return `chat:${resolved.chatId}`;
+      }
+      if (resolved.toUser) {
+        return `user:${resolved.toUser}`;
+      }
+      return trimmed;
     },
     targetResolver: {
       looksLikeId: (value) => Boolean(String(value ?? "").trim()),
@@ -373,7 +376,14 @@ export const wecomChannelPlugin = {
     listGroups: async () => [],
   },
   outbound: {
-    deliveryMode: "direct",
+    get deliveryMode() {
+      try {
+        const cfg = getOpenclawConfig();
+        const mode = cfg?.channels?.wecom?.deliveryMode;
+        if (mode === "direct" || mode === "gateway") return mode;
+      } catch {}
+      return "gateway";
+    },
     chunker: (text, limit) => resolveRuntimeTextChunker(text, limit),
     textChunkLimit: TEXT_CHUNK_LIMIT,
     sendText: async ({ cfg, to, text, accountId }) => {
@@ -416,10 +426,11 @@ export const wecomChannelPlugin = {
       setOpenclawConfig(cfg);
       const account = applyNetworkConfig(cfg, resolvedAccountId);
       const target = resolveWecomTarget(to) ?? {};
-      const wsNoticeTarget = resolveWsNoticeTarget(target, to);
 
       if (target.webhook) {
-        const preparedMedia = mediaUrl ? await loadResolvedMedia(mediaUrl, { mediaLocalRoots }) : undefined;
+        const preparedMedia = mediaUrl
+          ? await loadResolvedMedia(mediaUrl, { accountConfig: account?.config, mediaLocalRoots })
+          : undefined;
         return sendViaWebhook({
           cfg,
           accountId: resolvedAccountId,
@@ -430,14 +441,6 @@ export const wecomChannelPlugin = {
         });
       }
 
-      const agentTarget =
-        target.toParty || target.toTag
-          ? target
-          : target.chatId
-            ? { chatId: target.chatId }
-            : { toUser: target.toUser || String(to).replace(/^wecom:/i, "") };
-      const preparedMedia = await loadResolvedMedia(mediaUrl, { mediaLocalRoots });
-
       if (target.toParty || target.toTag) {
         if (!account?.agentCredentials) {
           throw new Error("Agent API is required for party/tag media delivery");
@@ -445,61 +448,63 @@ export const wecomChannelPlugin = {
         return sendViaAgent({
           cfg,
           accountId: resolvedAccountId,
-          target: agentTarget,
+          target,
           text,
           mediaUrl,
-          preparedMedia,
+          preparedMedia: await loadResolvedMedia(mediaUrl, { accountConfig: account?.config, mediaLocalRoots }),
         });
       }
 
-      if (account?.agentCredentials) {
-        const agentResult = await sendViaAgent({
-          cfg,
-          accountId: resolvedAccountId,
-          target: agentTarget,
-          text: wsNoticeTarget ? undefined : text,
-          mediaUrl,
-          preparedMedia,
-        });
+      const chatId = target.chatId || target.toUser || String(to).replace(/^wecom:/i, "");
+      const wsClient = getWsClient(resolvedAccountId);
 
-        if (wsNoticeTarget) {
+      let textAlreadySent = false;
+      if (wsClient?.isConnected && mediaUrl) {
+        if (text) {
           try {
-            await sendUnsupportedMediaNoticeViaWs({
-              to: wsNoticeTarget,
-              text,
-              mediaType: preparedMedia.mediaType,
-              accountId: resolvedAccountId,
-            });
-          } catch (error) {
-            logger.warn(`[wecom] WS media notice failed, falling back to Agent text delivery: ${error.message}`);
-            if (text) {
-              await sendViaAgent({
-                cfg,
-                accountId: resolvedAccountId,
-                target: agentTarget,
-                text,
-              });
-            }
+            await sendWsMessage({ to: chatId, content: text, accountId: resolvedAccountId });
+            textAlreadySent = true;
+          } catch (textErr) {
+            logger.warn(`[wecom] WS text send failed before media upload: ${textErr.message}`);
           }
         }
 
-        return agentResult;
+        const extendedRoots = await getExtendedMediaLocalRoots({
+          accountConfig: account?.config,
+          mediaLocalRoots,
+        });
+        const result = await uploadAndSendMedia({
+          wsClient,
+          mediaUrl,
+          chatId,
+          mediaLocalRoots: extendedRoots,
+          log: (...args) => logger.info(...args),
+          errorLog: (...args) => logger.error(...args),
+        });
+
+        if (result.ok) {
+          recordOutboundActivity({ accountId: resolvedAccountId });
+          return { channel: CHANNEL_ID, messageId: result.messageId, chatId };
+        }
+        logger.warn(`[wecom] WS media upload failed, falling back: ${result.error || result.rejectReason}`);
       }
 
-      if (wsNoticeTarget) {
-        logger.warn("[wecom] Agent API is not configured for unsupported WS media; sending notice only");
-        return sendWsMessage({
-          to: wsNoticeTarget,
-          content: buildUnsupportedMediaNotice({
-            text,
-            mediaType: preparedMedia.mediaType,
-            deliveredViaAgent: false,
-          }),
+      const agentTarget = target.chatId
+        ? { chatId: target.chatId }
+        : { toUser: target.toUser || String(to).replace(/^wecom:/i, "") };
+
+      if (account?.agentCredentials) {
+        return sendViaAgent({
+          cfg,
           accountId: resolvedAccountId,
+          target: agentTarget,
+          text: textAlreadySent ? undefined : text,
+          mediaUrl,
+          preparedMedia: await loadResolvedMedia(mediaUrl, { accountConfig: account?.config, mediaLocalRoots }),
         });
       }
 
-      throw new Error("Agent API is not configured for unsupported WeCom media delivery");
+      throw new Error("No media delivery channel available: WS upload failed and Agent API is not configured");
     },
   },
   status: {
@@ -628,6 +633,4 @@ export const wecomChannelPlugin = {
   },
 };
 
-export const wecomChannelPluginTesting = {
-  buildUnsupportedMediaNotice,
-};
+export const wecomChannelPluginTesting = {};

package/wecom/constants.js

@@ -26,11 +26,87 @@ export const REQID_FLUSH_DEBOUNCE_MS = 1_000;
 export const PENDING_REPLY_TTL_MS = 5 * 60 * 1000;
 export const PENDING_REPLY_MAX_SIZE = 50;
 
+export const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+export const VIDEO_MAX_BYTES = 10 * 1024 * 1024;
+export const VOICE_MAX_BYTES = 2 * 1024 * 1024;
+export const FILE_MAX_BYTES = 20 * 1024 * 1024;
+export const ABSOLUTE_MAX_BYTES = FILE_MAX_BYTES;
+
 export const DEFAULT_MEDIA_MAX_MB = 5;
 export const TEXT_CHUNK_LIMIT = 4000;
-export const DEFAULT_WELCOME_MESSAGE = ["你好，我是 AI 助手。", "", "可用命令：", "/new", "/compact", "/help", "/status"].join(
-  "\n",
-);
+export const DEFAULT_WELCOME_MESSAGES = [
+  [
+    "新的一天，元气满满！🌞",
+    "",
+    "你可以通过斜杠指令管理会话：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+  [
+    "终于唤醒我啦，我已经准备就绪！😄",
+    "",
+    "试试这些常用指令：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+  [
+    "欢迎回来，准备开始今天的工作吧！✨",
+    "",
+    "会话管理指令：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+  [
+    "嗨，我已经在线！🤖",
+    "",
+    "你可以先试试这些命令：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+  [
+    "今天也一起高效开工吧！🚀",
+    "",
+    "先来看看这些指令：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+  [
+    "叮咚，你的数字助手已就位！🎉",
+    "",
+    "常用操作给你备好了：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+  [
+    "灵感加载完成，随时可以开聊！💡",
+    "",
+    "你可以这样开始：",
+    "/new 新建对话",
+    "/compact 压缩对话",
+    "/help 帮助",
+    "/status 查看状态",
+    "/reasoning stream 打开思考动画",
+  ].join("\n"),
+];
+export const DEFAULT_WELCOME_MESSAGE = DEFAULT_WELCOME_MESSAGES[0];
 
 export const MEDIA_CACHE_DIR = join(process.env.HOME || "/tmp", ".openclaw", "media", "wecom");
 
@@ -90,6 +166,11 @@ export const TOKEN_REFRESH_BUFFER_MS = 60 * 1000;
 export const AGENT_API_REQUEST_TIMEOUT_MS = 15 * 1000;
 export const MAX_REQUEST_BODY_SIZE = 1024 * 1024;
 
+// Callback (self-built app HTTP inbound) constants
+export const CALLBACK_INBOUND_MAX_BODY_BYTES = 1 * 1024 * 1024;
+export const CALLBACK_MEDIA_DOWNLOAD_TIMEOUT_MS = 30_000;
+export const CALLBACK_TIMESTAMP_TOLERANCE_S = 300;
+
 export function getWebhookBotSendUrl() {
   return `${resolveApiBaseUrl()}/cgi-bin/webhook/send`;
 }