@wecom/wecom-openclaw-plugin 2026.3.30 → 2026.3.31-beta.1

package/dist/src/group-policy.js

@@ -0,0 +1,126 @@
+/**
+ * 企业微信群组访问控制模块
+ *
+ * 负责群组策略检查（groupPolicy、群组白名单、群内发送者白名单）
+ */
+import { CHANNEL_ID } from "./const.js";
+// ============================================================================
+// 内部辅助函数
+// ============================================================================
+/**
+ * 解析企业微信群组配置
+ */
+function resolveWeComGroupConfig(params) {
+    const groups = params.cfg?.groups ?? {};
+    const wildcard = groups["*"];
+    const groupId = params.groupId?.trim();
+    if (!groupId) {
+        return undefined;
+    }
+    const direct = groups[groupId];
+    if (direct) {
+        return direct;
+    }
+    const lowered = groupId.toLowerCase();
+    const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
+    if (matchKey) {
+        return groups[matchKey];
+    }
+    return wildcard;
+}
+/**
+ * 检查群组是否在允许列表中
+ */
+function isWeComGroupAllowed(params) {
+    const { groupPolicy } = params;
+    if (groupPolicy === "disabled") {
+        return false;
+    }
+    if (groupPolicy === "open") {
+        return true;
+    }
+    // allowlist 模式：检查群组是否在允许列表中
+    const normalizedAllowFrom = params.allowFrom.map((entry) => String(entry).replace(new RegExp(`^${CHANNEL_ID}:`, "i"), "").trim());
+    if (normalizedAllowFrom.includes("*")) {
+        return true;
+    }
+    const normalizedGroupId = params.groupId.trim();
+    return normalizedAllowFrom.some((entry) => entry === normalizedGroupId || entry.toLowerCase() === normalizedGroupId.toLowerCase());
+}
+/**
+ * 检查群组内发送者是否在允许列表中
+ */
+function isGroupSenderAllowed(params) {
+    const { senderId, groupId, wecomConfig } = params;
+    const groupConfig = resolveWeComGroupConfig({
+        cfg: wecomConfig,
+        groupId,
+    });
+    const perGroupSenderAllowFrom = (groupConfig?.allowFrom ?? []).map((v) => String(v));
+    if (perGroupSenderAllowFrom.length === 0) {
+        return true;
+    }
+    if (perGroupSenderAllowFrom.includes("*")) {
+        return true;
+    }
+    return perGroupSenderAllowFrom.some((entry) => {
+        const normalized = entry.replace(new RegExp(`^${CHANNEL_ID}:`, "i"), "").trim();
+        return normalized === senderId || normalized === `user:${senderId}`;
+    });
+}
+// ============================================================================
+// 公开 API
+// ============================================================================
+/**
+ * 检查群组策略访问控制
+ * @returns 检查结果，包含是否允许继续处理
+ */
+export function checkGroupPolicy(params) {
+    const { chatId, senderId, account, config, runtime } = params;
+    const wecomConfig = (config.channels?.[CHANNEL_ID] ?? {});
+    const defaultGroupPolicy = config.channels?.[CHANNEL_ID]?.groupPolicy;
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "open";
+    // const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy({
+    //   providerConfigPresent: config.channels?.[CHANNEL_ID] !== undefined,
+    //   groupPolicy: wecomConfig.groupPolicy,
+    //   defaultGroupPolicy,
+    // });
+    // warnMissingProviderGroupPolicyFallbackOnce({
+    //   providerMissingFallbackApplied,
+    //   providerKey: CHANNEL_ID,
+    //   accountId: account.accountId,
+    //   log: (msg) => runtime.log?.(msg),
+    // });
+    const groupAllowFrom = wecomConfig.groupAllowFrom ?? [];
+    const groupAllowed = isWeComGroupAllowed({
+        groupPolicy,
+        allowFrom: groupAllowFrom,
+        groupId: chatId,
+    });
+    if (!groupAllowed) {
+        runtime.log?.(`[WeCom] Group ${chatId} not allowed (groupPolicy=${groupPolicy})`);
+        return { allowed: false };
+    }
+    const senderAllowed = isGroupSenderAllowed({
+        senderId,
+        groupId: chatId,
+        wecomConfig,
+    });
+    if (!senderAllowed) {
+        runtime.log?.(`[WeCom] Sender ${senderId} not in group ${chatId} sender allowlist`);
+        return { allowed: false };
+    }
+    return { allowed: true };
+}
+/**
+ * 检查发送者是否在允许列表中（通用）
+ */
+export function isSenderAllowed(senderId, allowFrom) {
+    if (allowFrom.includes("*")) {
+        return true;
+    }
+    return allowFrom.some((entry) => {
+        const normalized = entry.replace(new RegExp(`^${CHANNEL_ID}:`, "i"), "").trim();
+        return normalized === senderId || normalized === `user:${senderId}`;
+    });
+}

package/dist/src/http.d.ts

@@ -0,0 +1,26 @@
+/**
+ * **WecomHttpOptions (HTTP 选项)**
+ *
+ * @property proxyUrl 代理服务器地址
+ * @property timeoutMs 请求超时时间 (毫秒)
+ * @property signal AbortSignal 信号
+ */
+export type WecomHttpOptions = {
+    proxyUrl?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+/**
+ * **wecomFetch (统一 HTTP 请求)**
+ *
+ * 基于 `undici` 的 fetch 封装，自动处理 ProxyAgent 和 Timeout。
+ * 所有对企业微信 API 的调用都应经过此函数。
+ */
+export declare function wecomFetch(input: string | URL, init?: RequestInit, opts?: WecomHttpOptions): Promise<Response>;
+/**
+ * **readResponseBodyAsBuffer (读取响应 Body)**
+ *
+ * 将 Response Body 读取为 Buffer，支持最大字节限制以防止内存溢出。
+ * 适用于下载媒体文件等场景。
+ */
+export declare function readResponseBodyAsBuffer(res: Response, maxBytes?: number): Promise<Buffer>;

package/dist/src/http.js

@@ -0,0 +1,93 @@
+import { ProxyAgent, fetch as undiciFetch } from "undici";
+const proxyDispatchers = new Map();
+/**
+ * **getProxyDispatcher (获取代理 Dispatcher)**
+ *
+ * 缓存并复用 ProxyAgent，避免重复创建连接池。
+ */
+function getProxyDispatcher(proxyUrl) {
+    const existing = proxyDispatchers.get(proxyUrl);
+    if (existing)
+        return existing;
+    const created = new ProxyAgent(proxyUrl);
+    proxyDispatchers.set(proxyUrl, created);
+    return created;
+}
+function mergeAbortSignal(params) {
+    const signals = [];
+    if (params.signal)
+        signals.push(params.signal);
+    if (params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0) {
+        signals.push(AbortSignal.timeout(params.timeoutMs));
+    }
+    if (!signals.length)
+        return undefined;
+    if (signals.length === 1)
+        return signals[0];
+    return AbortSignal.any(signals);
+}
+/**
+ * **wecomFetch (统一 HTTP 请求)**
+ *
+ * 基于 `undici` 的 fetch 封装，自动处理 ProxyAgent 和 Timeout。
+ * 所有对企业微信 API 的调用都应经过此函数。
+ */
+export async function wecomFetch(input, init, opts) {
+    const proxyUrl = opts?.proxyUrl?.trim() ?? "";
+    const dispatcher = proxyUrl ? getProxyDispatcher(proxyUrl) : undefined;
+    const initSignal = init?.signal ?? undefined;
+    const signal = mergeAbortSignal({ signal: opts?.signal ?? initSignal, timeoutMs: opts?.timeoutMs });
+    const headers = new Headers(init?.headers ?? {});
+    if (!headers.has("User-Agent")) {
+        headers.set("User-Agent", "OpenClaw/2.0 (WeCom-Agent)");
+    }
+    const nextInit = {
+        ...(init ?? {}),
+        ...(signal ? { signal } : {}),
+        ...(dispatcher ? { dispatcher } : {}),
+        headers,
+    };
+    try {
+        return await undiciFetch(input, nextInit);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "TypeError" && err.message === "fetch failed") {
+            const cause = err.cause;
+            console.error(`[wecom-http] fetch failed: ${input} (proxy: ${proxyUrl || "none"})${cause ? ` - cause: ${String(cause)}` : ""}`);
+        }
+        throw err;
+    }
+}
+/**
+ * **readResponseBodyAsBuffer (读取响应 Body)**
+ *
+ * 将 Response Body 读取为 Buffer，支持最大字节限制以防止内存溢出。
+ * 适用于下载媒体文件等场景。
+ */
+export async function readResponseBodyAsBuffer(res, maxBytes) {
+    if (!res.body)
+        return Buffer.alloc(0);
+    const limit = maxBytes && Number.isFinite(maxBytes) && maxBytes > 0 ? maxBytes : undefined;
+    const chunks = [];
+    let total = 0;
+    const reader = res.body.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        total += value.byteLength;
+        if (limit && total > limit) {
+            try {
+                await reader.cancel("body too large");
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`response body too large (>${limit} bytes)`);
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks.map((c) => Buffer.from(c)));
+}

package/dist/src/interface.d.ts

@@ -29,8 +29,6 @@ export interface MessageState {
     hasMediaFailed?: boolean;
     /** 媒体发送失败时的纯文本错误摘要（用于替换 thinking 流展示给用户） */
     mediaErrorSummary?: string;
-    /** deliver 回调是否被调用过（用于区分"核心无回复"和"核心回复了空内容"） */
-    deliverCalled?: boolean;
     /** 流式回复是否已过期（errcode 846608，>6分钟），需降级为主动发送 */
     streamExpired?: boolean;
     /** 是否已成功发送过模板卡片 */

package/dist/src/interface.js

@@ -0,0 +1,4 @@
+/**
+ * 企业微信渠道类型定义
+ */
+export {};

package/dist/src/mcp/index.js

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

package/dist/src/mcp/interceptors/biz-error.js

@@ -0,0 +1,64 @@
+/**
+ * 业务错误码检查拦截器
+ *
+ * 检查 tools/call 返回结果中是否包含需要清理缓存的业务错误码。
+ * MCP Server 可能在正常的 JSON-RPC 响应中返回业务层错误，
+ * 这些错误被包裹在 result.content[].text 中，需要解析后判断。
+ *
+ * 此拦截器对所有 call 调用生效。
+ */
+import { clearCategoryCache } from "../transport.js";
+// ============================================================================
+// 常量
+// ============================================================================
+/**
+ * 需要触发缓存清理的业务错误码集合
+ *
+ * 这些错误码出现在 MCP 工具调用返回的 content 文本中（业务层面），
+ * 与 JSON-RPC 层面的错误码不同，需要在此处额外检测。
+ *
+ * - 850002: 机器人未被授权使用对应能力，需清理缓存以便下次重新拉取配置
+ */
+const BIZ_CACHE_CLEAR_ERROR_CODES = new Set([850002]);
+// ============================================================================
+// 拦截器实现
+// ============================================================================
+export const bizErrorInterceptor = {
+    name: "biz-error",
+    /** 对所有 call 调用生效 */
+    match: () => true,
+    /** 检查返回结果中的业务错误码，必要时清理缓存 */
+    afterCall(ctx, result) {
+        checkBizErrorAndClearCache(result, ctx.category);
+        // 不修改 result，透传给下一个拦截器
+        return result;
+    },
+};
+// ============================================================================
+// 内部实现
+// ============================================================================
+/**
+ * 检查 tools/call 的返回结果中是否包含需要清理缓存的业务错误码
+ */
+function checkBizErrorAndClearCache(result, category) {
+    if (!result || typeof result !== "object")
+        return;
+    const { content } = result;
+    if (!Array.isArray(content))
+        return;
+    for (const item of content) {
+        if (item.type !== "text" || !item.text)
+            continue;
+        try {
+            const parsed = JSON.parse(item.text);
+            if (typeof parsed.errcode === "number" && BIZ_CACHE_CLEAR_ERROR_CODES.has(parsed.errcode)) {
+                console.log(`[mcp] 检测到业务错误码 ${parsed.errcode} (category="${category}")，清理缓存`);
+                clearCategoryCache(category);
+                return;
+            }
+        }
+        catch {
+            // text 不是 JSON 格式，跳过
+        }
+    }
+}

package/dist/src/mcp/interceptors/index.js

@@ -0,0 +1,66 @@
+/**
+ * MCP call 拦截器注册表与调度入口
+ *
+ * 所有 call 拦截器在此注册，按注册顺序执行。
+ * 新增拦截器只需：
+ *   1. 在 interceptors/ 目录下新建文件，实现 CallInterceptor 接口
+ *   2. 在下方 interceptors 数组中注册
+ *
+ * tool.ts 的 handleCall 无需任何改动。
+ */
+import { bizErrorInterceptor } from "./biz-error.js";
+import { mediaInterceptor } from "./msg-media.js";
+import { smartpageCreateInterceptor } from "./smartpage-create.js";
+import { smartpageExportInterceptor } from "./smartpage-export.js";
+// ============================================================================
+// 拦截器注册表（按注册顺序执行）
+// ============================================================================
+const interceptors = [
+    bizErrorInterceptor, // 业务错误码检查（所有 call 生效）
+    mediaInterceptor, // get_msg_media base64 拦截
+    smartpageCreateInterceptor, // smartpage_create 本地文件读取
+    smartpageExportInterceptor, // smartpage_get_export_result content → 本地文件
+];
+/**
+ * 收集匹配的 beforeCall 配置，合并后返回
+ *
+ * 合并策略：
+ * - timeoutMs: 取所有拦截器返回值中的最大值
+ * - args: 后注册的拦截器覆盖前者（一般同一调用只有一个拦截器会返回 args）
+ */
+export async function resolveBeforeCall(ctx) {
+    let mergedTimeoutMs;
+    let mergedArgs;
+    for (const interceptor of interceptors) {
+        if (!interceptor.match(ctx) || !interceptor.beforeCall)
+            continue;
+        const opts = await interceptor.beforeCall(ctx);
+        if (opts?.timeoutMs !== undefined) {
+            mergedTimeoutMs = mergedTimeoutMs === undefined
+                ? opts.timeoutMs
+                : Math.max(mergedTimeoutMs, opts.timeoutMs);
+        }
+        if (opts?.args !== undefined) {
+            mergedArgs = opts.args;
+        }
+    }
+    return {
+        options: mergedTimeoutMs !== undefined ? { timeoutMs: mergedTimeoutMs } : undefined,
+        args: mergedArgs,
+    };
+}
+/**
+ * 依次执行匹配的 afterCall 拦截器，管道式传递 result
+ *
+ * 前一个拦截器的返回值作为下一个拦截器的输入。
+ * 拦截器若不需要修改 result，应原样返回。
+ */
+export async function runAfterCall(ctx, result) {
+    let current = result;
+    for (const interceptor of interceptors) {
+        if (!interceptor.match(ctx) || !interceptor.afterCall)
+            continue;
+        current = await interceptor.afterCall(ctx, current);
+    }
+    return current;
+}

package/dist/src/mcp/interceptors/msg-media.js

@@ -0,0 +1,133 @@
+/**
+ * get_msg_media 响应拦截器
+ *
+ * 核心逻辑：
+ * 1. beforeCall: 设置延长的超时时间（120s），因为 base64 数据可达 ~27MB
+ * 2. afterCall: 从 MCP result 的 content[].text 中提取 base64_data，
+ *    解码为 Buffer 并通过 saveMediaBuffer 保存到本地媒体目录，
+ *    替换响应中的 base64_data 为 local_path，避免大模型被 base64 数据消耗 token
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { MEDIA_DOWNLOAD_TIMEOUT_MS } from "../transport.js";
+import { getWeComRuntime } from "../../runtime.js";
+import { detectMime } from "../../openclaw-compat.js";
+// ============================================================================
+// 拦截器实现
+// ============================================================================
+export const mediaInterceptor = {
+    name: "media",
+    /** 仅对 get_msg_media 方法生效 */
+    match: (ctx) => ctx.method === "get_msg_media",
+    /** 设置延长的超时时间 */
+    beforeCall() {
+        return { timeoutMs: MEDIA_DOWNLOAD_TIMEOUT_MS };
+    },
+    /** 拦截响应：base64 → 本地文件 */
+    async afterCall(ctx, result) {
+        return interceptMediaResponse(result);
+    },
+};
+// ============================================================================
+// 内部实现
+// ============================================================================
+/**
+ * 拦截 get_msg_media 的 MCP 响应
+ *
+ * 1. 从 MCP result 的 content[].text 中提取业务 JSON
+ * 2. 提取 media_item.base64_data，解码为 Buffer
+ * 3. 通过 openclaw SDK 的 saveMediaBuffer 保存到本地媒体目录
+ * 4. 替换响应：移除 base64_data，加入 local_path
+ *
+ * 这样大模型只看到轻量的文件路径信息，不会被 base64 数据消耗 token。
+ */
+async function interceptMediaResponse(result) {
+    const t0 = performance.now();
+    // 1. 提取 MCP result 中的 content 数组
+    const content = result?.content;
+    if (!Array.isArray(content))
+        return result;
+    const textItem = content.find((c) => c.type === "text" && typeof c.text === "string");
+    if (!textItem)
+        return result;
+    // 2. 解析业务 JSON
+    let bizData;
+    try {
+        bizData = JSON.parse(textItem.text);
+    }
+    catch {
+        // 非 JSON 格式，原样返回
+        return result;
+    }
+    // 3. 校验业务响应：errcode !== 0 或无 media_item 时原样返回
+    if (bizData.errcode !== 0)
+        return result;
+    const mediaItem = bizData.media_item;
+    if (!mediaItem || typeof mediaItem.base64_data !== "string")
+        return result;
+    const base64Data = mediaItem.base64_data;
+    const mediaName = mediaItem.name;
+    const mediaType = mediaItem.type;
+    const mediaId = mediaItem.media_id;
+    const tParsed = performance.now();
+    // 4. 解码 base64 → Buffer
+    const buffer = Buffer.from(base64Data, "base64");
+    const tDecoded = performance.now();
+    // 5. 检测 contentType，并通过 saveMediaBuffer 保存到本地媒体目录
+    const contentType = await detectMime({ buffer, filePath: mediaName }) ?? "application/octet-stream";
+    const tMimeDetected = performance.now();
+    // 企业微信聊天记录附件可达 20MB（文件消息上限），
+    // 而 saveMediaBuffer 默认 maxBytes 为 5MB（针对 outbound 场景），
+    // 此处显式放宽到 20MB 以支持大文件下载。
+    const INBOUND_MAX_BYTES = 20 * 1024 * 1024; // 20MB
+    const core = getWeComRuntime();
+    const saved = await core.channel.media.saveMediaBuffer(buffer, contentType, "inbound", INBOUND_MAX_BYTES, // maxBytes: 放宽到 20MB，匹配企业微信文件消息上限
+    mediaName);
+    // 5.1 补偿：核心库 EXT_BY_MIME 可能缺少某些格式映射（如 audio/amr），
+    //     导致保存的文件没有后缀。此处检测并修复。
+    const MIME_EXT_PATCH = {
+        "audio/amr": ".amr",
+    };
+    const patchExt = MIME_EXT_PATCH[contentType];
+    if (patchExt && !path.extname(saved.path)) {
+        const newPath = saved.path + patchExt;
+        try {
+            await fs.rename(saved.path, newPath);
+            saved.path = newPath;
+        }
+        catch {
+            // rename 失败不影响主流程，文件仍可用
+        }
+    }
+    const tSaved = performance.now();
+    // 6. 构造精简响应，移除 base64_data，加入本地路径
+    const newBizData = {
+        errcode: 0,
+        errmsg: "ok",
+        media_item: {
+            media_id: mediaId,
+            name: mediaName ?? saved.path.split("/").pop(),
+            type: mediaType,
+            local_path: saved.path,
+            size: buffer.length,
+            content_type: saved.contentType,
+        },
+    };
+    const tEnd = performance.now();
+    // 耗时日志：各环节耗时（ms）
+    console.log(`[mcp] get_msg_media 拦截成功: media_id=${mediaId ?? "unknown"}, ` +
+        `type=${mediaType ?? "unknown"}, size=${buffer.length}, saved=${saved.path}\n` +
+        `  ⏱ 耗时明细 (总 ${(tEnd - t0).toFixed(1)}ms):\n` +
+        `    解析响应 JSON:   ${(tParsed - t0).toFixed(1)}ms\n` +
+        `    base64 解码:     ${(tDecoded - tParsed).toFixed(1)}ms  (${(base64Data.length / 1024).toFixed(0)}KB base64 → ${(buffer.length / 1024).toFixed(0)}KB buffer)\n` +
+        `    MIME 检测:       ${(tMimeDetected - tDecoded).toFixed(1)}ms  (${contentType})\n` +
+        `    saveMediaBuffer: ${(tSaved - tMimeDetected).toFixed(1)}ms\n` +
+        `    构造响应:        ${(tEnd - tSaved).toFixed(1)}ms`);
+    // 7. 返回修改后的 MCP result 结构
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(newBizData),
+            }],
+    };
+}

package/dist/src/mcp/interceptors/smartpage-create.js

@@ -0,0 +1,132 @@
+/**
+ * smartpage_create 请求拦截器
+ *
+ * 核心逻辑：
+ * smartpage_create 的 pages 数组中，每个 page 可能包含 page_filepath 字段
+ * （指向本地 markdown 文件），用于避免在命令行传递大段文本内容。
+ * 本拦截器在 beforeCall 阶段遍历 pages 数组，逐个读取 page_filepath
+ * 指向的本地文件内容，填入 page_content 字段，并移除 page_filepath。
+ *
+ * 入参约定：
+ *   wecom_mcp call doc smartpage_create '{
+ *     "title": "主页标题",
+ *     "pages": [
+ *       {"page_title": "页面1", "page_filepath": "/tmp/page1.md", "content_type": "markdown"},
+ *       {"page_title": "页面2", "page_filepath": "/tmp/page2.md", "content_type": "markdown"}
+ *     ]
+ *   }'
+ *
+ * 拦截器行为：
+ *   1. 检测 args.pages 数组
+ *   2. 校验文件大小：单文件不超过 10MB，所有文件总计不超过 20MB
+ *   3. 遍历每个 page，若存在 page_filepath 则读取本地文件内容
+ *   4. 将文件内容填入 page_content 字段，移除 page_filepath
+ *   5. 返回修改后的完整 args
+ *
+ * 传给 MCP Server 的格式：
+ *   { "title": "...", "pages": [{"page_title": "...", "page_content": "...", "content_type": "..."}] }
+ */
+import * as fs from "node:fs/promises";
+// ============================================================================
+// 常量
+// ============================================================================
+/** 单个 page_filepath 文件大小上限：10MB */
+const MAX_SINGLE_FILE_SIZE = 10 * 1024 * 1024;
+/** 所有 page_filepath 文件总大小上限：20MB */
+const MAX_TOTAL_FILE_SIZE = 20 * 1024 * 1024;
+// ============================================================================
+// 内部辅助函数
+// ============================================================================
+/**
+ * 校验所有 page_filepath 的文件大小
+ *
+ * 使用 fs.stat 在读取文件内容之前检查大小，避免超大文件被加载到内存。
+ * - 单文件 > 10MB → 报错
+ * - 所有文件累计 > 20MB → 报错
+ */
+async function validateFileSize(pages) {
+    let totalSize = 0;
+    for (let i = 0; i < pages.length; i++) {
+        const filePath = pages[i].page_filepath;
+        if (typeof filePath !== "string" || !filePath)
+            continue;
+        let stat;
+        try {
+            stat = await fs.stat(filePath);
+        }
+        catch (err) {
+            // stat 失败不在这里处理，留给后续 readFile 阶段抛出更详细的错误
+            continue;
+        }
+        if (stat.size > MAX_SINGLE_FILE_SIZE) {
+            console.error(`[mcp] smartpage_create: pages[${i}] 文件 "${filePath}" ` +
+                `大小 ${(stat.size / 1024 / 1024).toFixed(1)}MB 超过单文件上限 10MB`);
+            throw new Error("内容大小超出限制，无法创建");
+        }
+        totalSize += stat.size;
+        if (totalSize > MAX_TOTAL_FILE_SIZE) {
+            console.error(`[mcp] smartpage_create: 累计文件大小 ${(totalSize / 1024 / 1024).toFixed(1)}MB ` +
+                `超过总上限 20MB（在 pages[${i}] "${filePath}" 处超出）`);
+            throw new Error("内容大小超出限制，无法创建");
+        }
+    }
+    if (totalSize > 0) {
+        console.log(`[mcp] smartpage_create: 文件大小校验通过，总计 ${(totalSize / 1024 / 1024).toFixed(2)}MB`);
+    }
+}
+/** 异步解析 pages 中的 page_filepath，返回 BeforeCallOptions */
+async function resolvePages(ctx, pages) {
+    console.log(`[mcp] smartpage_create: 开始解析 ${pages.length} 个 page 的 page_filepath`);
+    // 阶段 1：文件大小校验（stat 阶段，不读内容）
+    await validateFileSize(pages);
+    // 阶段 2：读取文件内容
+    const resolvedPages = await Promise.all(pages.map(async (page, index) => {
+        const filePath = page.page_filepath;
+        if (typeof filePath !== "string" || !filePath) {
+            // 该 page 没有 page_filepath，保留原样（可能已有 page_content）
+            return page;
+        }
+        let fileContent;
+        try {
+            fileContent = await fs.readFile(filePath, "utf-8");
+        }
+        catch (err) {
+            throw new Error(`smartpage_create: pages[${index}] 无法读取文件 "${filePath}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+        console.log(`[mcp] smartpage_create: pages[${index}] 读取成功 "${filePath}" (${fileContent.length} chars)`);
+        // 构造新的 page 对象：填入 page_content，移除 page_filepath
+        const { page_filepath: _, ...rest } = page;
+        return { ...rest, page_content: fileContent };
+    }));
+    console.log(`[mcp] smartpage_create: 所有 page_filepath 解析完成`);
+    // 返回修改后的完整 args
+    return {
+        args: {
+            ...ctx.args,
+            pages: resolvedPages,
+        },
+    };
+}
+// ============================================================================
+// 拦截器实现
+// ============================================================================
+export const smartpageCreateInterceptor = {
+    name: "smartpage-create",
+    /** 仅对 doc 品类的 smartpage_create 方法生效 */
+    match: (ctx) => ctx.category === "doc" && ctx.method === "smartpage_create",
+    /** 遍历 pages 数组，逐个读取 page_filepath 填入 page_content */
+    beforeCall(ctx) {
+        const pages = ctx.args.pages;
+        if (!Array.isArray(pages) || pages.length === 0) {
+            // 没有 pages 数组，不做拦截
+            return undefined;
+        }
+        // 检查是否有任何 page 包含 page_filepath
+        const hasFilePath = pages.some((p) => typeof p.page_filepath === "string" && p.page_filepath);
+        if (!hasFilePath) {
+            // 所有 page 都没有 page_filepath（可能直接传了 page_content），不做拦截
+            return undefined;
+        }
+        return resolvePages(ctx, pages);
+    },
+};