@mocrane/wecom 2026.3.8-4 → 2026.3.12

package/src/agent/handler.ts

@@ -18,7 +18,7 @@ import {
     extractFileName,
     extractAgentId,
 } from "../shared/xml-parser.js";
-import { sendText, downloadMedia } from "./api-client.js";
+import { sendText, downloadMedia, uploadMedia, sendMedia as sendAgentMedia } from "./api-client.js";
 import { getWecomRuntime } from "../runtime.js";
 import type { WecomAgentInboundMessage } from "../types/index.js";
 import { buildWecomUnauthorizedCommandPrompt, resolveWecomCommandAuthorization } from "../shared/command-auth.js";
@@ -518,7 +518,9 @@ async function processAgentMessage(params: {
         CommandBody: finalContent,
         Attachments: attachments.length > 0 ? attachments : undefined,
         From: isGroup ? `wecom:group:${peerId}` : `wecom:${fromUser}`,
-        To: `wecom:${peerId}`,
+        // 使用 wecom-agent: 前缀标记 Agent 会话，确保 outbound 路由不会混入 Bot WS 发送路径。
+        // resolveWecomTarget 已支持剥离 wecom-agent: 前缀（target.ts L41），解析结果不变。
+        To: `wecom-agent:${fromUser}`,
         SessionKey: route.sessionKey,
         AccountId: route.accountId,
         ChatType: isGroup ? "group" : "direct",
@@ -553,18 +555,107 @@ async function processAgentMessage(params: {
         ctx: ctxPayload,
         cfg: config,
         dispatcherOptions: {
-            deliver: async (payload: { text?: string }, info: { kind: string }) => {
-                const text = payload.text ?? "";
-                if (!text) return;
-
-                try {
-                    // 统一策略：Agent 模式在群聊场景默认只私信触发者（避免 wr/wc chatId 86008）
-                    await sendText({ agent, toUser: fromUser, chatId: undefined, text });
-                    log?.(`[wecom-agent] reply delivered (${info.kind}) to ${fromUser}`);
-                } catch (err: unknown) {
-                    const message = err instanceof Error ? `${err.message}${err.cause ? ` (cause: ${String(err.cause)})` : ""}` : String(err);
-                    error?.(`[wecom-agent] reply failed: ${message}`);
-                }            },
+            deliver: async (payload: { text?: string; mediaUrls?: string[]; mediaUrl?: string }, info: { kind: string }) => {
+                let text = payload.text ?? "";
+
+                // ── 1. 解析 MEDIA: 指令（兜底处理核心 splitMediaFromOutput 未覆盖的边界情况）──
+                const mediaDirectivePaths: string[] = [];
+                const mediaDirectiveRe = /^MEDIA:\s*`?([^\n`]+?)`?\s*$/gm;
+                let _mdMatch: RegExpExecArray | null;
+                while ((_mdMatch = mediaDirectiveRe.exec(text)) !== null) {
+                    let p = (_mdMatch[1] ?? "").trim();
+                    if (!p) continue;
+                    if (p.startsWith("~/") || p === "~") {
+                        const home = process.env.HOME || "/root";
+                        p = p.replace(/^~/, home);
+                    }
+                    if (!mediaDirectivePaths.includes(p)) mediaDirectivePaths.push(p);
+                }
+                // 从回复文本中移除 MEDIA: 指令行
+                if (mediaDirectivePaths.length > 0) {
+                    text = text.replace(/^MEDIA:\s*`?[^\n`]+?`?\s*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+                }
+
+                // ── 2. 合并所有媒体 URL ──
+                const mediaUrls = Array.from(new Set([
+                    ...(payload.mediaUrls || []),
+                    ...(payload.mediaUrl ? [payload.mediaUrl] : []),
+                    ...mediaDirectivePaths,
+                ]));
+
+                // ── 3. 发送文本部分 ──
+                if (text.trim()) {
+                    try {
+                        await sendText({ agent, toUser: fromUser, chatId: undefined, text });
+                        log?.(`[wecom-agent] reply delivered (${info.kind}) to ${fromUser} (textLen=${text.length})`);
+                    } catch (err: unknown) {
+                        const message = err instanceof Error ? `${err.message}${err.cause ? ` (cause: ${String(err.cause)})` : ""}` : String(err);
+                        error?.(`[wecom-agent] reply failed: ${message}`);
+                    }
+                }
+
+                // ── 4. 逐个发送媒体文件（通过 Agent API 上传 + 发送）──
+                for (const mediaPath of mediaUrls) {
+                    try {
+                        const isRemoteUrl = /^https?:\/\//i.test(mediaPath);
+                        let buf: Buffer;
+                        let contentType: string;
+                        let filename: string;
+
+                        if (isRemoteUrl) {
+                            const res = await fetch(mediaPath, { signal: AbortSignal.timeout(30_000) });
+                            if (!res.ok) throw new Error(`download failed: ${res.status}`);
+                            buf = Buffer.from(await res.arrayBuffer());
+                            contentType = res.headers.get("content-type") || "application/octet-stream";
+                            filename = new URL(mediaPath).pathname.split("/").pop() || "media";
+                        } else {
+                            const fs = await import("node:fs/promises");
+                            const pathModule = await import("node:path");
+                            buf = await fs.readFile(mediaPath);
+                            filename = pathModule.basename(mediaPath);
+                            const ext = pathModule.extname(mediaPath).slice(1).toLowerCase();
+                            const MIME_MAP: Record<string, string> = {
+                                jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif",
+                                webp: "image/webp", mp3: "audio/mpeg", wav: "audio/wav", amr: "audio/amr",
+                                mp4: "video/mp4", mov: "video/quicktime", 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",
+                                txt: "text/plain", csv: "text/csv", json: "application/json", zip: "application/zip",
+                            };
+                            contentType = MIME_MAP[ext] ?? "application/octet-stream";
+                        }
+
+                        // 确定企微媒体类型
+                        let mediaType: "image" | "voice" | "video" | "file" = "file";
+                        if (contentType.startsWith("image/")) mediaType = "image";
+                        else if (contentType.startsWith("audio/")) mediaType = "voice";
+                        else if (contentType.startsWith("video/")) mediaType = "video";
+
+                        log?.(`[wecom-agent] uploading media: ${filename} (${mediaType}, ${contentType}, ${buf.length} bytes)`);
+
+                        const mediaId = await uploadMedia({ agent, type: mediaType, buffer: buf, filename });
+
+                        await sendAgentMedia({
+                            agent,
+                            toUser: fromUser,
+                            mediaId,
+                            mediaType,
+                            ...(mediaType === "video" ? { title: filename, description: "" } : {}),
+                        });
+
+                        log?.(`[wecom-agent] media sent (${info.kind}) to ${fromUser}: ${filename} (${mediaType})`);
+                    } catch (err: unknown) {
+                        const message = err instanceof Error ? `${err.message}${err.cause ? ` (cause: ${String(err.cause)})` : ""}` : String(err);
+                        error?.(`[wecom-agent] media send failed: ${mediaPath}: ${message}`);
+                        // 降级：发文本通知用户
+                        try {
+                            await sendText({ agent, toUser: fromUser, chatId: undefined, text: `⚠️ 文件发送失败: ${mediaPath.split("/").pop() || mediaPath}\n${message}` });
+                        } catch { /* ignore */ }
+                    }
+                }
+
+                // 如果既没有文本也没有媒体，不做任何事（防止空回复）
+            },
             onError: (err: unknown, info: { kind: string }) => {
                 error?.(`[wecom-agent] ${info.kind} reply error: ${String(err)}`);
             },

package/src/channel.ts

@@ -3,10 +3,11 @@ import type {
   ChannelPlugin,
   OpenClawConfig,
 } from "openclaw/plugin-sdk";
+
 import {
   deleteAccountFromConfigSection,
   setAccountEnabledInConfigSection,
-} from "openclaw/plugin-sdk";
+} from "./compat/plugin-sdk-shim.js";
 
 import {
   DEFAULT_ACCOUNT_ID,
@@ -39,10 +40,12 @@ function normalizeWecomMessagingTarget(raw: string): string | undefined {
   return trimmed.replace(/^(wecom-agent|wecom|wechatwork|wework|qywx):/i, "").trim() || undefined;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- onboarding 在 >=3.22 中已重命名为 setupWizard，
+// 但我们仍设置旧字段以兼容 <3.22 版本的 OpenClaw。
 export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
   id: "wecom",
   meta,
-  onboarding: wecomOnboardingAdapter,
+  onboarding: wecomOnboardingAdapter as any,
   setup: {
     resolveAccountId: ({ cfg, accountId }) => {
       return accountId?.trim() || resolveDefaultWecomAccountId(cfg as OpenClawConfig) || DEFAULT_ACCOUNT_ID;
@@ -111,14 +114,14 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         accountId,
         enabled,
         allowTopLevel: true,
-      }),
+      }) as OpenClawConfig,
     deleteAccount: ({ cfg, accountId }) =>
       deleteAccountFromConfigSection({
         cfg: cfg as OpenClawConfig,
         sectionKey: "wecom",
         accountId,
         clearBaseFields: ["bot", "agent"],
-      }),
+      }) as OpenClawConfig,
     isConfigured: (account, cfg) => {
       if (!account.configured) {
         return false;

package/src/compat/plugin-sdk-shim.ts

@@ -0,0 +1,152 @@
+/**
+ * OpenClaw Plugin SDK 兼容 Shim
+ *
+ * 为 OpenClaw >= 2026.3.11 提供稳定导出。
+ * 所有关键函数在 v2026.3.11+ 的主入口都直接可用。
+ */
+
+// ─── 类型重导出 ───
+export type { OpenClawConfig } from "openclaw/plugin-sdk";
+export type { PluginRuntime } from "openclaw/plugin-sdk";
+export type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export type { ChannelPlugin, ChannelConfigSchema } from "openclaw/plugin-sdk";
+export type { ChannelAccountSnapshot } from "openclaw/plugin-sdk";
+export type { ChannelGatewayContext } from "openclaw/plugin-sdk";
+export type { WizardPrompter } from "openclaw/plugin-sdk";
+export type {
+  ChannelOutboundAdapter,
+  ChannelOutboundContext,
+} from "openclaw/plugin-sdk";
+
+// ─── 直接导出主入口的稳定函数 ───
+export {
+  emptyPluginConfigSchema,
+  deleteAccountFromConfigSection,
+  setAccountEnabledInConfigSection,
+  promptAccountId,
+} from "openclaw/plugin-sdk";
+
+// ─── 常量 ───
+export const DEFAULT_ACCOUNT_ID = "default";
+
+// ─── 安全动态导入 ───
+async function tryImport<T>(specifier: string): Promise<T | undefined> {
+  try {
+    return await import(specifier) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+// ────────────────────────────────────────────────────
+// readJsonFileWithFallback / writeJsonFileAtomically / withFileLock
+// (仅 mcp-config.ts 需要，函数本身为 async)
+// ────────────────────────────────────────────────────
+type FileLockFn = <T>(
+  filePath: string,
+  options: unknown,
+  fn: () => Promise<T>,
+) => Promise<T>;
+
+type ReadJsonFn = <T>(
+  filePath: string,
+  fallback: T,
+) => Promise<{ value: T; exists: boolean }>;
+
+type WriteJsonFn = (filePath: string, value: unknown) => Promise<void>;
+
+export type FileIoHelpers = {
+  withFileLock: FileLockFn;
+  readJsonFileWithFallback: ReadJsonFn;
+  writeJsonFileAtomically: WriteJsonFn;
+};
+
+let _fileIo: FileIoHelpers | undefined;
+
+export async function resolveFileIoHelpers(): Promise<FileIoHelpers> {
+  if (_fileIo) return _fileIo;
+
+  const jsonStore = await tryImport<Partial<FileIoHelpers>>("openclaw/plugin-sdk/json-store");
+  const msteams = await tryImport<{ withFileLock?: FileLockFn }>("openclaw/plugin-sdk/msteams");
+
+  const readFn = jsonStore?.readJsonFileWithFallback;
+  const writeFn = jsonStore?.writeJsonFileAtomically;
+  const lockFn = msteams?.withFileLock;
+
+  if (readFn && writeFn && lockFn) {
+    _fileIo = { readJsonFileWithFallback: readFn, writeJsonFileAtomically: writeFn, withFileLock: lockFn };
+    return _fileIo;
+  }
+
+  // ── Node.js 原生回退实现 ──
+  const fs = await import("node:fs/promises");
+  const nodePath = await import("node:path");
+
+  const fallbackRead: ReadJsonFn = async <T>(filePath: string, fallback: T) => {
+    try {
+      const raw = await fs.readFile(filePath, "utf-8");
+      return { value: JSON.parse(raw) as T, exists: true };
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return { value: fallback, exists: false };
+      }
+      return { value: fallback, exists: false };
+    }
+  };
+
+  const fallbackWrite: WriteJsonFn = async (filePath: string, value: unknown) => {
+    const dir = nodePath.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    const content = JSON.stringify(value, null, 2) + "\n";
+    const tmpPath = `${filePath}.tmp.${process.pid}`;
+    await fs.writeFile(tmpPath, content, { mode: 0o600 });
+    await fs.rename(tmpPath, filePath);
+  };
+
+  const fallbackLock: FileLockFn = async <T>(
+    _filePath: string,
+    _options: unknown,
+    fn: () => Promise<T>,
+  ): Promise<T> => fn();
+
+  _fileIo = {
+    readJsonFileWithFallback: readFn ?? fallbackRead,
+    writeJsonFileAtomically: writeFn ?? fallbackWrite,
+    withFileLock: lockFn ?? fallbackLock,
+  };
+  return _fileIo;
+}
+
+// ────────────────────────────────────────────────────
+// resolvePromptAccountId (仅 onboarding.ts 需要，异步调用)
+// ────────────────────────────────────────────────────
+type PromptAccountIdFn = (params: {
+  cfg: unknown;
+  prompter: unknown;
+  label: string;
+  currentId: string;
+  listAccountIds: (cfg: unknown) => string[];
+  defaultAccountId: string;
+}) => Promise<string>;
+
+let _promptAccountId: PromptAccountIdFn | undefined;
+
+export async function resolvePromptAccountId(): Promise<PromptAccountIdFn> {
+  if (_promptAccountId) return _promptAccountId;
+
+  for (const subpath of [
+    "openclaw/plugin-sdk/matrix",
+    "openclaw/plugin-sdk/channel-setup",
+    "openclaw/plugin-sdk/setup",
+  ]) {
+    const mod = await tryImport<{ promptAccountId?: PromptAccountIdFn }>(subpath);
+    if (mod?.promptAccountId) {
+      _promptAccountId = mod.promptAccountId;
+      return _promptAccountId;
+    }
+  }
+
+  // 兜底实现
+  _promptAccountId = async (params) => params.currentId || params.defaultAccountId;
+  return _promptAccountId;
+}

package/src/mcp/index.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP 模块统一导出
+ */
+
+export { createWeComMcpTool } from "./tool.js";
+export { sendJsonRpc, clearCategoryCache, McpRpcError, McpHttpError, type McpToolInfo } from "./transport.js";
+export { cleanSchemaForGemini } from "./schema.js";

package/src/mcp/schema.ts

@@ -0,0 +1,108 @@
+/**
+ * MCP Schema 清洗模块
+ *
+ * 负责内联 $ref/$defs 引用并移除 Gemini 不支持的 JSON Schema 关键词，
+ * 防止 Gemini 模型解析 function response 时报 400 错误。
+ */
+
+/** Gemini 不支持的 JSON Schema 关键词 */
+const GEMINI_UNSUPPORTED_KEYWORDS = new Set([
+  "patternProperties", "additionalProperties", "$schema", "$id", "$ref", "$defs",
+  "definitions", "examples", "minLength", "maxLength", "minimum", "maximum",
+  "multipleOf", "pattern", "format", "minItems", "maxItems", "uniqueItems",
+  "minProperties", "maxProperties",
+]);
+
+/**
+ * 清洗 JSON Schema，内联 $ref 引用并移除 Gemini 不支持的关键词，
+ * 防止 Gemini 模型解析 function response 时报 400 错误。
+ */
+export function cleanSchemaForGemini(schema: unknown): unknown {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
+
+  const obj = schema as Record<string, unknown>;
+
+  // 收集 $defs/definitions 用于后续 $ref 内联解析
+  const defs: Record<string, unknown> = {
+    ...(obj.$defs && typeof obj.$defs === "object" ? obj.$defs as Record<string, unknown> : {}),
+    ...(obj.definitions && typeof obj.definitions === "object" ? obj.definitions as Record<string, unknown> : {}),
+  };
+
+  return cleanWithDefs(obj, defs, new Set());
+}
+
+function cleanWithDefs(
+  schema: unknown,
+  defs: Record<string, unknown>,
+  refStack: Set<string>,
+): unknown {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map((item) => cleanWithDefs(item, defs, refStack));
+
+  const obj = schema as Record<string, unknown>;
+
+  // 合并当前层级的 $defs/definitions 到 defs 中
+  if (obj.$defs && typeof obj.$defs === "object") {
+    Object.assign(defs, obj.$defs as Record<string, unknown>);
+  }
+  if (obj.definitions && typeof obj.definitions === "object") {
+    Object.assign(defs, obj.definitions as Record<string, unknown>);
+  }
+
+  // 处理 $ref 引用：尝试内联解析
+  if (typeof obj.$ref === "string") {
+    const ref = obj.$ref;
+    if (refStack.has(ref)) return {}; // 防止循环引用
+
+    const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+    if (match && match[1] && defs[match[1]]) {
+      const nextStack = new Set(refStack);
+      nextStack.add(ref);
+      return cleanWithDefs(defs[match[1]], defs, nextStack);
+    }
+    return {}; // 无法解析的 $ref，返回空对象
+  }
+
+  const cleaned: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (GEMINI_UNSUPPORTED_KEYWORDS.has(key)) continue;
+
+    if (key === "const") {
+      cleaned.enum = [value];
+      continue;
+    }
+
+    if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+      cleaned[key] = Object.fromEntries(
+        Object.entries(value as Record<string, unknown>).map(([k, v]) => [
+          k, cleanWithDefs(v, defs, refStack),
+        ]),
+      );
+    } else if (key === "items" && value) {
+      cleaned[key] = Array.isArray(value)
+        ? value.map((item) => cleanWithDefs(item, defs, refStack))
+        : cleanWithDefs(value, defs, refStack);
+    } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+      // 过滤掉 null 类型的变体
+      const nonNull = value.filter((v) => {
+        if (!v || typeof v !== "object") return true;
+        const r = v as Record<string, unknown>;
+        return r.type !== "null";
+      });
+      if (nonNull.length === 1) {
+        // 只剩一个变体时直接内联
+        const single = cleanWithDefs(nonNull[0], defs, refStack);
+        if (single && typeof single === "object" && !Array.isArray(single)) {
+          Object.assign(cleaned, single as Record<string, unknown>);
+        }
+      } else {
+        cleaned[key] = nonNull.map((v) => cleanWithDefs(v, defs, refStack));
+      }
+    } else {
+      cleaned[key] = value;
+    }
+  }
+
+  return cleaned;
+}