ylib-wecom-openclaw-plugin 2026.4.29

package/dist/src/markdown-chunk.js

@@ -0,0 +1,396 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.splitMarkdownIntoSafeChunks = void 0;
+var marked_1 = require("marked");
+var WEIXIN_TEXT_CHUNK_HARD_LIMIT_BYTES = 7 * 1024;
+var WEIXIN_TEXT_CHUNK_SOFT_LIMIT_BYTES = 6656;
+var WEIXIN_TEXT_CHUNK_BACKTRACK_BYTES = 768;
+var DEFAULT_SOFT_RATIO = WEIXIN_TEXT_CHUNK_SOFT_LIMIT_BYTES / WEIXIN_TEXT_CHUNK_HARD_LIMIT_BYTES;
+var DEFAULT_BACKTRACK_BYTES = WEIXIN_TEXT_CHUNK_BACKTRACK_BYTES;
+var PROTECTED_MARKDOWN_TOKEN_TYPES = new Set(["code", "codespan", "link", "image"]);
+function utf8ByteLength(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+function isUtf16Boundary(text, index) {
+    if (index <= 0 || index >= text.length)
+        return true;
+    var prev = text.charCodeAt(index - 1);
+    var curr = text.charCodeAt(index);
+    return !(prev >= 0xd800 && prev <= 0xdbff && curr >= 0xdc00 && curr <= 0xdfff);
+}
+function nextCodepointIndex(text, index) {
+    if (index >= text.length)
+        return text.length;
+    var code = text.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
+        var next = text.charCodeAt(index + 1);
+        if (next >= 0xdc00 && next <= 0xdfff)
+            return index + 2;
+    }
+    return index + 1;
+}
+function endIndexByMaxBytes(text, start, maxBytes) {
+    var i = start;
+    var used = 0;
+    while (i < text.length) {
+        var next = nextCodepointIndex(text, i);
+        var bytes = utf8ByteLength(text.slice(i, next));
+        if (used + bytes > maxBytes)
+            break;
+        used += bytes;
+        i = next;
+    }
+    return i;
+}
+function mergeProtectedRanges(ranges) {
+    if (ranges.length <= 1)
+        return ranges;
+    ranges.sort(function (a, b) { return a.start - b.start || a.end - b.end; });
+    var merged = [ranges[0]];
+    for (var i = 1; i < ranges.length; i++) {
+        var cur = ranges[i];
+        var last = merged[merged.length - 1];
+        if (cur.start <= last.end) {
+            last.end = Math.max(last.end, cur.end);
+        }
+        else {
+            merged.push(cur);
+        }
+    }
+    return merged;
+}
+function collectProtectedRangesByRegex(text) {
+    var patterns = [
+        /```[\s\S]*?```/g,
+        /`[^`\n]+`/g,
+        /!?\[[^\]\n]*\]\((?:\\.|[^)\n])+\)/g,
+        /<https?:\/\/[^>\s]+>/g,
+    ];
+    var ranges = [];
+    for (var _i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
+        var pattern = patterns_1[_i];
+        var match = void 0;
+        while ((match = pattern.exec(text)) !== null) {
+            var start = match.index;
+            var end = start + match[0].length;
+            if (end > start)
+                ranges.push({ start: start, end: end });
+            if (match[0].length === 0)
+                pattern.lastIndex += 1;
+        }
+    }
+    return mergeProtectedRanges(ranges);
+}
+function findRawInBounds(params) {
+    var text = params.text, raw = params.raw, cursor = params.cursor, boundsStart = params.boundsStart, boundsEnd = params.boundsEnd;
+    if (!raw)
+        return -1;
+    var minCursor = Math.max(boundsStart, cursor);
+    var idx = text.indexOf(raw, minCursor);
+    if (idx >= boundsStart && idx + raw.length <= boundsEnd)
+        return idx;
+    var fallbackIdx = text.indexOf(raw, boundsStart);
+    if (fallbackIdx >= boundsStart && fallbackIdx + raw.length <= boundsEnd)
+        return fallbackIdx;
+    return -1;
+}
+function collectTokenChildren(token) {
+    var children = [];
+    var generic = token;
+    if (Array.isArray(generic.tokens))
+        children.push.apply(children, generic.tokens);
+    if (Array.isArray(generic.items)) {
+        for (var _i = 0, _a = generic.items; _i < _a.length; _i++) {
+            var item = _a[_i];
+            if (typeof item.raw === "string") {
+                children.push(item);
+            }
+            else if (Array.isArray(item.tokens)) {
+                children.push.apply(children, item.tokens);
+            }
+        }
+    }
+    if (Array.isArray(generic.header)) {
+        for (var _b = 0, _c = generic.header; _b < _c.length; _b++) {
+            var cell = _c[_b];
+            if (Array.isArray(cell.tokens))
+                children.push.apply(children, cell.tokens);
+        }
+    }
+    if (Array.isArray(generic.rows)) {
+        for (var _d = 0, _e = generic.rows; _d < _e.length; _d++) {
+            var row = _e[_d];
+            for (var _f = 0, row_1 = row; _f < row_1.length; _f++) {
+                var cell = row_1[_f];
+                if (Array.isArray(cell.tokens))
+                    children.push.apply(children, cell.tokens);
+            }
+        }
+    }
+    return children;
+}
+function mapTokensToRanges(params) {
+    var text = params.text, tokens = params.tokens, boundsStart = params.boundsStart, boundsEnd = params.boundsEnd, out = params.out;
+    var cursor = params.cursor;
+    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        var raw = token.raw;
+        if (typeof raw !== "string" || !raw)
+            continue;
+        var start = findRawInBounds({ text: text, raw: raw, cursor: cursor, boundsStart: boundsStart, boundsEnd: boundsEnd });
+        if (start < 0)
+            continue;
+        var end = start + raw.length;
+        if (PROTECTED_MARKDOWN_TOKEN_TYPES.has(token.type)) {
+            out.push({ start: start, end: end });
+        }
+        var children = collectTokenChildren(token);
+        if (children.length > 0) {
+            mapTokensToRanges({
+                text: text,
+                tokens: __spreadArrays(children),
+                cursor: start,
+                boundsStart: start,
+                boundsEnd: end,
+                out: out
+            });
+        }
+        cursor = end;
+    }
+    return cursor;
+}
+function collectProtectedRanges(text) {
+    try {
+        var tokens = marked_1.Lexer.lex(text, { gfm: true, breaks: false });
+        var ranges = [];
+        mapTokensToRanges({
+            text: text,
+            tokens: __spreadArrays(tokens),
+            cursor: 0,
+            boundsStart: 0,
+            boundsEnd: text.length,
+            out: ranges
+        });
+        return mergeProtectedRanges(ranges);
+    }
+    catch (_a) {
+        return collectProtectedRangesByRegex(text);
+    }
+}
+function isInsideProtectedRange(index, ranges) {
+    for (var _i = 0, ranges_1 = ranges; _i < ranges_1.length; _i++) {
+        var r = ranges_1[_i];
+        if (index <= r.start)
+            return false;
+        if (index < r.end)
+            return true;
+    }
+    return false;
+}
+function isStrongBoundary(text, index) {
+    if (index <= 0 || index > text.length)
+        return false;
+    var prev = text[index - 1];
+    var prev2 = index >= 2 ? text[index - 2] : "";
+    if (prev === "\n" && prev2 === "\n")
+        return true;
+    if (prev === "\n")
+        return true;
+    if (/[。！？!?；;，,：:]/.test(prev))
+        return true;
+    if (/\s/.test(prev) && /[。！？!?；;，,]/.test(prev2))
+        return true;
+    return false;
+}
+function isWeakBoundary(text, index) {
+    if (index <= 0 || index > text.length)
+        return false;
+    var prev = text[index - 1];
+    return /[。！？!?；;，,：:\n]/.test(prev);
+}
+function splitTextIntoChunksHeuristic(text, hardLimitBytes) {
+    if (!text)
+        return [""];
+    if (utf8ByteLength(text) <= hardLimitBytes)
+        return [text];
+    var softLimitBytes = Math.max(1, Math.floor(hardLimitBytes * DEFAULT_SOFT_RATIO));
+    var backtrackBytes = Math.min(DEFAULT_BACKTRACK_BYTES, Math.max(64, softLimitBytes - 1));
+    var ranges = collectProtectedRanges(text);
+    var chunks = [];
+    var start = 0;
+    while (start < text.length) {
+        var rest = text.slice(start);
+        if (utf8ByteLength(rest) <= hardLimitBytes) {
+            chunks.push(rest);
+            break;
+        }
+        var softEnd = endIndexByMaxBytes(text, start, softLimitBytes);
+        var hardEnd = endIndexByMaxBytes(text, start, hardLimitBytes);
+        var lowerStart = endIndexByMaxBytes(text, start, Math.max(1, softLimitBytes - backtrackBytes));
+        var cut = -1;
+        for (var i = softEnd; i >= lowerStart; i--) {
+            if (!isUtf16Boundary(text, i))
+                continue;
+            if (isInsideProtectedRange(i, ranges))
+                continue;
+            if (isStrongBoundary(text, i)) {
+                cut = i;
+                break;
+            }
+        }
+        if (cut < 0) {
+            for (var i = softEnd; i >= lowerStart; i--) {
+                if (!isUtf16Boundary(text, i))
+                    continue;
+                if (isInsideProtectedRange(i, ranges))
+                    continue;
+                if (isWeakBoundary(text, i)) {
+                    cut = i;
+                    break;
+                }
+            }
+        }
+        if (cut < 0) {
+            cut = hardEnd;
+            while (cut > start && (!isUtf16Boundary(text, cut) || isInsideProtectedRange(cut, ranges))) {
+                cut--;
+            }
+            if (cut <= start)
+                cut = hardEnd;
+        }
+        var segment = text.slice(start, cut);
+        if (!segment) {
+            var fallback = text.slice(start, hardEnd);
+            chunks.push(fallback);
+            start = hardEnd;
+            continue;
+        }
+        chunks.push(segment);
+        start = cut;
+    }
+    return chunks;
+}
+function collectTopLevelBlocks(text) {
+    var tokens = marked_1.Lexer.lex(text, { gfm: true, breaks: false });
+    var blocks = [];
+    var cursor = 0;
+    for (var _i = 0, tokens_2 = tokens; _i < tokens_2.length; _i++) {
+        var token = tokens_2[_i];
+        var raw = token.raw;
+        if (typeof raw !== "string" || !raw)
+            continue;
+        var start = findRawInBounds({
+            text: text,
+            raw: raw,
+            cursor: cursor,
+            boundsStart: 0,
+            boundsEnd: text.length
+        });
+        if (start < 0)
+            continue;
+        var end = start + raw.length;
+        if (start > cursor) {
+            blocks.push({ start: cursor, end: start, raw: text.slice(cursor, start) });
+        }
+        blocks.push({ start: start, end: end, raw: raw });
+        cursor = end;
+    }
+    if (cursor < text.length) {
+        blocks.push({ start: cursor, end: text.length, raw: text.slice(cursor) });
+    }
+    return blocks;
+}
+function isChunkSafe(chunk) {
+    if (!chunk)
+        return true;
+    try {
+        marked_1.Lexer.lex(chunk, { gfm: true, breaks: false });
+    }
+    catch (_a) {
+        return false;
+    }
+    if (/-\s*[✅❌]?\s*$/.test(chunk))
+        return false;
+    if (/(^|\n)\s*[-*+]\s*$/.test(chunk))
+        return false;
+    if (/(^|\n)\s*\d+\.\s*$/.test(chunk))
+        return false;
+    if (/(^|\n)\s*>\s*$/.test(chunk))
+        return false;
+    if (/(^|\n)\s*#+\s*$/.test(chunk))
+        return false;
+    return true;
+}
+function splitMarkdownIntoSafeChunks(text, hardLimitBytes) {
+    if (!text)
+        return [""];
+    if (hardLimitBytes <= 0)
+        return [text];
+    if (utf8ByteLength(text) <= hardLimitBytes)
+        return [text];
+    var blocks = collectTopLevelBlocks(text);
+    if (!blocks.length)
+        return splitTextIntoChunksHeuristic(text, hardLimitBytes);
+    var softLimitBytes = Math.max(1, Math.floor(hardLimitBytes * DEFAULT_SOFT_RATIO));
+    var chunks = [];
+    var current = "";
+    var flushCurrent = function () {
+        if (!current)
+            return;
+        chunks.push(current);
+        current = "";
+    };
+    for (var _i = 0, blocks_1 = blocks; _i < blocks_1.length; _i++) {
+        var block = blocks_1[_i];
+        var blockText = block.raw;
+        if (!blockText)
+            continue;
+        var blockBytes = utf8ByteLength(blockText);
+        if (blockBytes > hardLimitBytes) {
+            flushCurrent();
+            var subs = splitTextIntoChunksHeuristic(blockText, hardLimitBytes);
+            for (var _a = 0, subs_1 = subs; _a < subs_1.length; _a++) {
+                var s = subs_1[_a];
+                chunks.push(s);
+            }
+            continue;
+        }
+        if (!current) {
+            current = blockText;
+            continue;
+        }
+        var combined = "" + current + blockText;
+        var combinedBytes = utf8ByteLength(combined);
+        if (combinedBytes <= softLimitBytes) {
+            current = combined;
+            continue;
+        }
+        if (combinedBytes <= hardLimitBytes && isChunkSafe(combined)) {
+            current = combined;
+            continue;
+        }
+        flushCurrent();
+        current = blockText;
+    }
+    flushCurrent();
+    if (!chunks.length)
+        return splitTextIntoChunksHeuristic(text, hardLimitBytes);
+    if (chunks.some(function (c) { return utf8ByteLength(c) > hardLimitBytes; })) {
+        return splitTextIntoChunksHeuristic(text, hardLimitBytes);
+    }
+    if (chunks.some(function (c) { return !isChunkSafe(c); })) {
+        return splitTextIntoChunksHeuristic(text, hardLimitBytes);
+    }
+    if (chunks.join("") !== text) {
+        return splitTextIntoChunksHeuristic(text, hardLimitBytes);
+    }
+    return chunks;
+}
+exports.splitMarkdownIntoSafeChunks = splitMarkdownIntoSafeChunks;

package/dist/src/mcp/index.d.ts

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

package/dist/src/mcp/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * MCP 模块统一导出
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+exports.__esModule = true;
+var tool_js_1 = require("./tool.js");
+__createBinding(exports, tool_js_1, "createWeComMcpTool");
+var transport_js_1 = require("./transport.js");
+__createBinding(exports, transport_js_1, "sendJsonRpc");
+__createBinding(exports, transport_js_1, "clearCategoryCache");
+__createBinding(exports, transport_js_1, "clearAccountCache");
+__createBinding(exports, transport_js_1, "resolveCurrentAccountId");
+__createBinding(exports, transport_js_1, "McpRpcError");
+__createBinding(exports, transport_js_1, "McpHttpError");
+__createBinding(exports, transport_js_1, "type");
+var schema_js_1 = require("./schema.js");
+__createBinding(exports, schema_js_1, "cleanSchemaForGemini");
+// 注意：parseSessionKeyChat 已废弃不再导出。
+//   OpenClaw core 构建 sessionKey 时会把 chatId 小写化，
+//   企业微信接口（如 aibot_send_biz_msg）是大小写敏感的，反解结果不可用。
+//   chatId 请通过 state-manager 的 getSessionChatInfo(sessionKey) 获取。

package/dist/src/mcp/interceptors/biz-error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 业务错误码检查拦截器
+ *
+ * 检查 tools/call 返回结果中是否包含需要清理缓存的业务错误码。
+ * MCP Server 可能在正常的 JSON-RPC 响应中返回业务层错误，
+ * 这些错误被包裹在 result.content[].text 中，需要解析后判断。
+ *
+ * 此拦截器对所有 call 调用生效。
+ */
+import type { CallInterceptor } from "./types.js";
+export declare const bizErrorInterceptor: CallInterceptor;

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

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * 业务错误码检查拦截器
+ *
+ * 检查 tools/call 返回结果中是否包含需要清理缓存的业务错误码。
+ * MCP Server 可能在正常的 JSON-RPC 响应中返回业务层错误，
+ * 这些错误被包裹在 result.content[].text 中，需要解析后判断。
+ *
+ * 此拦截器对所有 call 调用生效。
+ */
+exports.__esModule = true;
+exports.bizErrorInterceptor = void 0;
+var transport_js_1 = require("../transport.js");
+// ============================================================================
+// 常量
+// ============================================================================
+/**
+ * 需要触发缓存清理的业务错误码集合
+ *
+ * 这些错误码出现在 MCP 工具调用返回的 content 文本中（业务层面），
+ * 与 JSON-RPC 层面的错误码不同，需要在此处额外检测。
+ *
+ * - 850001/ 851014: 机器人授权过期/ 重置，需清理缓存以便下次重新拉取配置
+ */
+var BIZ_CACHE_CLEAR_ERROR_CODES = new Set([850001, 851014]);
+// ============================================================================
+// 拦截器实现
+// ============================================================================
+exports.bizErrorInterceptor = {
+    name: "biz-error",
+    /** 对所有 call 调用生效 */
+    match: function () { return true; },
+    /** 检查返回结果中的业务错误码，必要时清理缓存 */
+    afterCall: function (ctx, result) {
+        checkBizErrorAndClearCache(result, ctx);
+        // 不修改 result，透传给下一个拦截器
+        return result;
+    }
+};
+// ============================================================================
+// 内部实现
+// ============================================================================
+/**
+ * 检查 tools/call 的返回结果中是否包含需要清理缓存的业务错误码
+ */
+function checkBizErrorAndClearCache(result, ctx) {
+    if (!result || typeof result !== "object")
+        return;
+    var content = result.content;
+    if (!Array.isArray(content))
+        return;
+    for (var _i = 0, content_1 = content; _i < content_1.length; _i++) {
+        var item = content_1[_i];
+        if (item.type !== "text" || !item.text)
+            continue;
+        try {
+            var parsed = JSON.parse(item.text);
+            if (typeof parsed.errcode === "number" && BIZ_CACHE_CLEAR_ERROR_CODES.has(parsed.errcode)) {
+                var accountId = ctx.accountId;
+                if (!accountId) {
+                    console.warn("[mcp] \u68C0\u6D4B\u5230\u4E1A\u52A1\u9519\u8BEF\u7801 " + parsed.errcode + " (category=\"" + ctx.category + "\")\uFF0C\u4F46 ctx.accountId \u4E3A\u7A7A\uFF0C\u8DF3\u8FC7\u7F13\u5B58\u6E05\u7406");
+                    return;
+                }
+                console.log("[mcp] \u68C0\u6D4B\u5230\u4E1A\u52A1\u9519\u8BEF\u7801 " + parsed.errcode + " (accountId=\"" + accountId + "\", category=\"" + ctx.category + "\")\uFF0C\u6E05\u7406\u7F13\u5B58");
+                transport_js_1.clearCategoryCache(accountId, ctx.category);
+                return;
+            }
+        }
+        catch (_a) {
+            // text 不是 JSON 格式，跳过
+        }
+    }
+}

package/dist/src/mcp/interceptors/doc-auth-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 文档授权错误拦截器
+ *
+ * 当 category=doc 的 MCP 调用返回 errcode=851013/851014/851008（文档授权错误）时：
+ * 1. 通过 aibot_send_biz_msg 命令向用户发送授权引导卡片
+ * 2. 拦截 help_message 内容，不将其传递给 LLM
+ * 3. 返回简化响应，告知 LLM 授权卡片已发送、无需再做处理
+ */
+import type { CallInterceptor } from "./types.js";
+export declare const docAuthErrorInterceptor: CallInterceptor;