ylib-wecom-openclaw-plugin 2026.4.29

package/dist/src/webhook/state.js

@@ -0,0 +1,568 @@
+"use strict";
+/**
+ * Webhook 模式状态管理
+ *
+ * 从 @mocrane/wecom monitor/state.ts 完整迁移。
+ * 包含 StreamStore（流状态存储）、ActiveReplyStore（主动回复地址存储）、MonitorState（全局容器）。
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.monitorState = exports.WebhookMonitorState = exports.ActiveReplyStore = exports.StreamStore = exports.LIMITS = void 0;
+var node_crypto_1 = __importDefault(require("node:crypto"));
+// ============================================================================
+// 常量
+// ============================================================================
+exports.LIMITS = {
+    STREAM_TTL_MS: 10 * 60 * 1000,
+    ACTIVE_REPLY_TTL_MS: 60 * 60 * 1000,
+    DEFAULT_DEBOUNCE_MS: 500,
+    STREAM_MAX_BYTES: 20480,
+    REQUEST_TIMEOUT_MS: 15000
+};
+// ============================================================================
+// StreamStore
+// ============================================================================
+/**
+ * **StreamStore (流状态会话存储)**
+ *
+ * 管理企业微信回调的流式会话状态、消息去重和防抖聚合逻辑。
+ * 负责维护 msgid 到 streamId 的映射，以及临时缓存待处理的 Pending 消息。
+ */
+var StreamStore = /** @class */ (function () {
+    function StreamStore() {
+        this.streams = new Map();
+        this.msgidToStreamId = new Map();
+        this.pendingInbounds = new Map();
+        this.conversationState = new Map();
+        this.streamIdToBatchKey = new Map();
+        this.batchStreamIdToAckStreamIds = new Map();
+    }
+    /**
+     * **setFlushHandler (设置防抖刷新回调)**
+     *
+     * 当防抖计时器结束时调用的处理函数。通常用于触发 Agent 进行消息处理。
+     * @param handler 回调函数，接收聚合后的 PendingInbound 对象
+     */
+    StreamStore.prototype.setFlushHandler = function (handler) {
+        this.onFlush = handler;
+    };
+    /**
+     * **createStream (创建流会话)**
+     *
+     * 初始化一个新的流式会话状态。
+     * @param params.msgid (可选) 企业微信消息 ID，用于后续去重映射
+     * @returns 生成的 streamId (Hex 字符串)
+     */
+    StreamStore.prototype.createStream = function (params) {
+        var streamId = node_crypto_1["default"].randomBytes(16).toString("hex");
+        if (params.msgid) {
+            this.msgidToStreamId.set(String(params.msgid), streamId);
+        }
+        this.streams.set(streamId, {
+            streamId: streamId,
+            msgid: params.msgid,
+            conversationKey: params.conversationKey,
+            batchKey: params.batchKey,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            started: false,
+            finished: false,
+            content: ""
+        });
+        if (params.batchKey) {
+            this.streamIdToBatchKey.set(streamId, params.batchKey);
+        }
+        return streamId;
+    };
+    /**
+     * **getStream (获取流状态)**
+     *
+     * 根据 streamId 获取当前的会话状态。
+     * @param streamId 流会话 ID
+     */
+    StreamStore.prototype.getStream = function (streamId) {
+        return this.streams.get(streamId);
+    };
+    /**
+     * **getStreamByMsgId (通过 msgid 查找流 ID)**
+     *
+     * 用于消息去重：检查该 msgid 是否已经关联由正在进行或已完成的流会话。
+     * @param msgid 企业微信消息 ID
+     */
+    StreamStore.prototype.getStreamByMsgId = function (msgid) {
+        return this.msgidToStreamId.get(String(msgid));
+    };
+    /** 手动设置 msgid → streamId 映射 */
+    StreamStore.prototype.setStreamIdForMsgId = function (msgid, streamId) {
+        var key = String(msgid).trim();
+        var value = String(streamId).trim();
+        if (!key || !value)
+            return;
+        this.msgidToStreamId.set(key, value);
+    };
+    /**
+     * 将“回执流”(ack stream) 关联到某个“批次流”(batch stream)。
+     * 用于：当用户连发多条消息被合并排队时，让后续消息的 stream 最终也能更新为可理解的提示，而不是永久停留在“已合并排队…”。
+     */
+    StreamStore.prototype.addAckStreamForBatch = function (params) {
+        var _a;
+        var batchStreamId = params.batchStreamId.trim();
+        var ackStreamId = params.ackStreamId.trim();
+        if (!batchStreamId || !ackStreamId)
+            return;
+        var list = (_a = this.batchStreamIdToAckStreamIds.get(batchStreamId)) !== null && _a !== void 0 ? _a : [];
+        list.push(ackStreamId);
+        this.batchStreamIdToAckStreamIds.set(batchStreamId, list);
+    };
+    /**
+     * 取出并清空某个批次流关联的所有回执流。
+     */
+    StreamStore.prototype.drainAckStreamsForBatch = function (batchStreamId) {
+        var _a;
+        var key = batchStreamId.trim();
+        if (!key)
+            return [];
+        var list = (_a = this.batchStreamIdToAckStreamIds.get(key)) !== null && _a !== void 0 ? _a : [];
+        this.batchStreamIdToAckStreamIds["delete"](key);
+        return list;
+    };
+    /**
+     * **updateStream (更新流状态)**
+     *
+     * 原子更新流状态，并自动刷新 updatedAt 时间戳。
+     * @param streamId 流会话 ID
+     * @param mutator 状态修改函数
+     */
+    StreamStore.prototype.updateStream = function (streamId, mutator) {
+        var state = this.streams.get(streamId);
+        if (state) {
+            mutator(state);
+            state.updatedAt = Date.now();
+        }
+    };
+    /**
+     * **markStarted (标记流开始)**
+     *
+     * 标记该流会话已经开始处理（通常在 Agent 启动后调用）。
+     */
+    StreamStore.prototype.markStarted = function (streamId) {
+        this.updateStream(streamId, function (s) { s.started = true; });
+    };
+    /**
+     * **markFinished (标记流结束)**
+     *
+     * 标记该流会话已完成，不再接收内容更新。
+     */
+    StreamStore.prototype.markFinished = function (streamId) {
+        this.updateStream(streamId, function (s) { s.finished = true; });
+    };
+    /**
+     * **addPendingMessage (添加待处理消息 / 防抖聚合)**
+     *
+     * 将收到的消息加入待处理队列。如果相同 pendingKey 已存在，则是防抖聚合；否则创建新条目。
+     * 会自动设置或重置防抖定时器。
+     *
+     * @param params 消息参数
+     * @returns { streamId, isNew } isNew=true 表示这是新的一组消息，需初始化 ActiveReply
+     */
+    StreamStore.prototype.addPendingMessage = function (params) {
+        var _this = this;
+        var conversationKey = params.conversationKey, target = params.target, msg = params.msg, msgContent = params.msgContent, nonce = params.nonce, timestamp = params.timestamp, debounceMs = params.debounceMs;
+        var effectiveDebounceMs = debounceMs !== null && debounceMs !== void 0 ? debounceMs : exports.LIMITS.DEFAULT_DEBOUNCE_MS;
+        var state = this.conversationState.get(conversationKey);
+        if (!state) {
+            // 第一批次（active）
+            var batchKey_1 = conversationKey;
+            var streamId_1 = this.createStream({ msgid: msg.msgid, conversationKey: conversationKey, batchKey: batchKey_1 });
+            var pending_1 = {
+                streamId: streamId_1,
+                conversationKey: conversationKey,
+                batchKey: batchKey_1,
+                target: target,
+                msg: msg,
+                contents: [msgContent],
+                msgids: msg.msgid ? [msg.msgid] : [],
+                nonce: nonce,
+                timestamp: timestamp,
+                createdAt: Date.now(),
+                timeout: setTimeout(function () {
+                    _this.requestFlush(batchKey_1);
+                }, effectiveDebounceMs)
+            };
+            this.pendingInbounds.set(batchKey_1, pending_1);
+            this.conversationState.set(conversationKey, { activeBatchKey: batchKey_1, queue: [], nextSeq: 1 });
+            return { streamId: streamId_1, status: "active_new" };
+        }
+        // 合并规则（排队语义）：
+        // - 初始批次（batchKey===conversationKey）不接收合并：避免 1/2 都刷出同一份最终答案。
+        // - 如果 active 批次是“排队批次”（batchKey!=conversationKey）且还没开始处理（started=false），
+        //   则允许把后续消息合并进该 active 批次（典型：1 很快结束，2 变 active 但还没开始跑，3 合并到 2）。
+        var activeBatchKey = state.activeBatchKey;
+        var activeIsInitial = activeBatchKey === conversationKey;
+        var activePending = this.pendingInbounds.get(activeBatchKey);
+        if (activePending && !activeIsInitial) {
+            var activeStream = this.streams.get(activePending.streamId);
+            var activeStarted = Boolean(activeStream === null || activeStream === void 0 ? void 0 : activeStream.started);
+            if (!activeStarted) {
+                activePending.contents.push(msgContent);
+                if (msg.msgid) {
+                    activePending.msgids.push(msg.msgid);
+                    // 注意：不把该 msgid 映射到 active streamId（避免该消息最终也刷出同一份完整答案）
+                }
+                if (activePending.timeout)
+                    clearTimeout(activePending.timeout);
+                activePending.timeout = setTimeout(function () {
+                    _this.requestFlush(activeBatchKey);
+                }, effectiveDebounceMs);
+                return { streamId: activePending.streamId, status: "active_merged" };
+            }
+        }
+        // active 批次已经开始处理；后续消息进入队列批次（queued），并允许在队列批次内做防抖聚合。
+        var queuedBatchKey = state.queue[0];
+        if (queuedBatchKey) {
+            var existingQueued = this.pendingInbounds.get(queuedBatchKey);
+            if (existingQueued) {
+                existingQueued.contents.push(msgContent);
+                if (msg.msgid) {
+                    existingQueued.msgids.push(msg.msgid);
+                    // 注意：不把该 msgid 映射到 queued streamId（避免该消息最终也刷出同一份完整答案）
+                }
+                if (existingQueued.timeout)
+                    clearTimeout(existingQueued.timeout);
+                existingQueued.timeout = setTimeout(function () {
+                    _this.requestFlush(queuedBatchKey);
+                }, effectiveDebounceMs);
+                return { streamId: existingQueued.streamId, status: "queued_merged" };
+            }
+        }
+        // 创建新的 queued 批次（会话只保留 1 个“下一批次”，后续消息继续合并到该批次）
+        var seq = state.nextSeq++;
+        var batchKey = conversationKey + "#q" + seq;
+        state.queue = [batchKey];
+        var streamId = this.createStream({ msgid: msg.msgid, conversationKey: conversationKey, batchKey: batchKey });
+        var pending = {
+            streamId: streamId,
+            conversationKey: conversationKey,
+            batchKey: batchKey,
+            target: target,
+            msg: msg,
+            contents: [msgContent],
+            msgids: msg.msgid ? [msg.msgid] : [],
+            nonce: nonce,
+            timestamp: timestamp,
+            createdAt: Date.now(),
+            timeout: setTimeout(function () {
+                _this.requestFlush(batchKey);
+            }, effectiveDebounceMs)
+        };
+        this.pendingInbounds.set(batchKey, pending);
+        this.conversationState.set(conversationKey, state);
+        return { streamId: streamId, status: "queued_new" };
+    };
+    /**
+     * 请求刷新：如果该批次当前为 active，则立即 flush；否则标记 ready，等待前序批次完成后再 flush。
+     */
+    StreamStore.prototype.requestFlush = function (batchKey) {
+        var pending = this.pendingInbounds.get(batchKey);
+        if (!pending)
+            return;
+        var state = this.conversationState.get(pending.conversationKey);
+        var isActive = (state === null || state === void 0 ? void 0 : state.activeBatchKey) === batchKey;
+        if (!isActive) {
+            if (pending.timeout) {
+                clearTimeout(pending.timeout);
+                pending.timeout = null;
+            }
+            pending.readyToFlush = true;
+            return;
+        }
+        this.flushPending(batchKey);
+    };
+    /**
+     * **flushPending (触发消息处理)**
+     *
+     * 内部方法：防抖时间结束后，将聚合的消息一次性推送给 flushHandler。
+     */
+    StreamStore.prototype.flushPending = function (pendingKey) {
+        var pending = this.pendingInbounds.get(pendingKey);
+        if (!pending)
+            return;
+        this.pendingInbounds["delete"](pendingKey);
+        if (pending.timeout) {
+            clearTimeout(pending.timeout);
+            pending.timeout = null;
+        }
+        pending.readyToFlush = false;
+        if (this.onFlush) {
+            this.onFlush(pending);
+        }
+    };
+    /**
+     * 在一个 stream 完成后推进会话队列：将 queued 批次提升为 active，并在需要时触发 flush。
+     */
+    StreamStore.prototype.onStreamFinished = function (streamId) {
+        var batchKey = this.streamIdToBatchKey.get(streamId);
+        var state = batchKey ? this.streams.get(streamId) : undefined;
+        var conversationKey = state === null || state === void 0 ? void 0 : state.conversationKey;
+        if (!batchKey || !conversationKey)
+            return;
+        var conv = this.conversationState.get(conversationKey);
+        if (!conv)
+            return;
+        if (conv.activeBatchKey !== batchKey)
+            return;
+        var next = conv.queue.shift();
+        if (!next) {
+            // 队列为空：会话已空闲。删除状态，避免后续消息被误判为“排队但永远不触发”。
+            this.conversationState["delete"](conversationKey);
+            return;
+        }
+        conv.activeBatchKey = next;
+        this.conversationState.set(conversationKey, conv);
+        var pending = this.pendingInbounds.get(next);
+        if (!pending)
+            return;
+        if (pending.readyToFlush) {
+            this.flushPending(next);
+        }
+        // 否则等待该批次自己的 debounce timer 到期后 requestFlush(next) 执行
+    };
+    /**
+     * **prune (清理过期状态)**
+     *
+     * 清理过期的流会话、msgid 映射以及残留的 Pending 消息。
+     * @param now 当前时间戳 (毫秒)
+     */
+    StreamStore.prototype.prune = function (now) {
+        if (now === void 0) { now = Date.now(); }
+        var streamCutoff = now - exports.LIMITS.STREAM_TTL_MS;
+        // 清理过期的流会话
+        for (var _i = 0, _a = this.streams.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], id = _b[0], state = _b[1];
+            if (state.updatedAt < streamCutoff) {
+                this.streams["delete"](id);
+                if (state.msgid) {
+                    // 如果 msgid 映射仍指向该 stream，则一并移除
+                    if (this.msgidToStreamId.get(state.msgid) === id) {
+                        this.msgidToStreamId["delete"](state.msgid);
+                    }
+                }
+            }
+        }
+        // 清理悬空的 msgid 映射 (Double check)
+        for (var _c = 0, _d = this.msgidToStreamId.entries(); _c < _d.length; _c++) {
+            var _e = _d[_c], msgid = _e[0], id = _e[1];
+            if (!this.streams.has(id)) {
+                this.msgidToStreamId["delete"](msgid);
+            }
+        }
+        // 清理超时的 Pending 消息 (通常由 timeout 清理，此处作为兜底)
+        for (var _f = 0, _g = this.pendingInbounds.entries(); _f < _g.length; _f++) {
+            var _h = _g[_f], key = _h[0], pending_2 = _h[1];
+            if (now - pending_2.createdAt > exports.LIMITS.STREAM_TTL_MS) {
+                if (pending_2.timeout)
+                    clearTimeout(pending_2.timeout);
+                this.pendingInbounds["delete"](key);
+            }
+        }
+        // 清理 conversationState：active 已不存在且队列为空的会话
+        for (var _j = 0, _k = this.conversationState.entries(); _j < _k.length; _j++) {
+            var _l = _k[_j], convKey = _l[0], conv = _l[1];
+            var activeExists = this.pendingInbounds.has(conv.activeBatchKey) || Array.from(this.streamIdToBatchKey.values()).includes(conv.activeBatchKey);
+            var hasQueue = conv.queue.length > 0;
+            if (!activeExists && !hasQueue) {
+                this.conversationState["delete"](convKey);
+            }
+        }
+    };
+    return StreamStore;
+}());
+exports.StreamStore = StreamStore;
+/**
+ * **ActiveReplyStore (主动回复地址存储)**
+ *
+ * 管理企业微信回调中的 `response_url` (用于被动回复转主动推送) 和 `proxyUrl`。
+ * 支持 'once' (一次性) 或 'multi' (多次) 使用策略。
+ */
+var ActiveReplyStore = /** @class */ (function () {
+    /**
+     * @param policy 使用策略: "once" (默认，销毁式) 或 "multi"
+     */
+    function ActiveReplyStore(policy) {
+        if (policy === void 0) { policy = "once"; }
+        this.policy = policy;
+        this.activeReplies = new Map();
+    }
+    /**
+     * **store (存储回复地址)**
+     *
+     * 关联 streamId 与 response_url。
+     */
+    ActiveReplyStore.prototype.store = function (streamId, responseUrl, proxyUrl) {
+        var url = responseUrl === null || responseUrl === void 0 ? void 0 : responseUrl.trim();
+        if (!url)
+            return;
+        this.activeReplies.set(streamId, { response_url: url, proxyUrl: proxyUrl, createdAt: Date.now() });
+    };
+    /**
+     * **getUrl (获取回复地址)**
+     *
+     * 获取指定 streamId 关联的 response_url。
+     */
+    ActiveReplyStore.prototype.getUrl = function (streamId) {
+        var _a;
+        return (_a = this.activeReplies.get(streamId)) === null || _a === void 0 ? void 0 : _a.response_url;
+    };
+    /**
+     * 获取关联的代理 URL
+     */
+    ActiveReplyStore.prototype.getProxyUrl = function (streamId) {
+        var _a;
+        return (_a = this.activeReplies.get(streamId)) === null || _a === void 0 ? void 0 : _a.proxyUrl;
+    };
+    /**
+     * **use (消耗回复地址)**
+     *
+     * 使用存储的 response_url 执行操作。
+     * - 如果策略是 "once"，第二次调用会抛错。
+     * - 自动更新使用时间 (usedAt)。
+     *
+     * @param streamId 流会话 ID
+     * @param fn 执行函数，接收 { responseUrl, proxyUrl }
+     */
+    ActiveReplyStore.prototype.use = function (streamId, fn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        state = this.activeReplies.get(streamId);
+                        if (!(state === null || state === void 0 ? void 0 : state.response_url)) {
+                            return [2 /*return*/]; // 无 URL 可用，安全跳过
+                        }
+                        if (this.policy === "once" && state.usedAt) {
+                            throw new Error("response_url already used for stream " + streamId + " (Policy: once)");
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, fn({ responseUrl: state.response_url, proxyUrl: state.proxyUrl })];
+                    case 2:
+                        _a.sent();
+                        state.usedAt = Date.now();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        state.lastError = err_1 instanceof Error ? err_1.message : String(err_1);
+                        throw err_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * **prune (清理过期地址)**
+     *
+     * 清理超过 TTL 的 active reply 记录。
+     */
+    ActiveReplyStore.prototype.prune = function (now) {
+        if (now === void 0) { now = Date.now(); }
+        var cutoff = now - exports.LIMITS.ACTIVE_REPLY_TTL_MS;
+        for (var _i = 0, _a = this.activeReplies.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], id = _b[0], state = _b[1];
+            if (state.createdAt < cutoff) {
+                this.activeReplies["delete"](id);
+            }
+        }
+    };
+    return ActiveReplyStore;
+}());
+exports.ActiveReplyStore = ActiveReplyStore;
+/**
+ * **MonitorState (全局监控状态容器)**
+ *
+ * 模块单例，统一管理 StreamStore 和 ActiveReplyStore 实例。
+ * 提供生命周期方法 (startPruning / stopPruning) 以自动清理过期数据。
+ */
+var WebhookMonitorState = /** @class */ (function () {
+    function WebhookMonitorState() {
+        /** 主要的流状态存储 */
+        this.streamStore = new StreamStore();
+        /** 主动回复地址存储 */
+        this.activeReplyStore = new ActiveReplyStore("multi");
+    }
+    /**
+     * **startPruning (启动自动清理)**
+     *
+     * 启动定时器，定期清理过期的流和回复地址。应在插件有活跃 Target 时调用。
+     * @param intervalMs 清理间隔 (默认 60s)
+     */
+    WebhookMonitorState.prototype.startPruning = function (intervalMs) {
+        var _this = this;
+        if (intervalMs === void 0) { intervalMs = 60000; }
+        if (this.pruneInterval)
+            return;
+        this.pruneInterval = setInterval(function () {
+            var now = Date.now();
+            _this.streamStore.prune(now);
+            _this.activeReplyStore.prune(now);
+        }, intervalMs);
+    };
+    /**
+     * **stopPruning (停止自动清理)**
+     *
+     * 停止定时器。应在插件无活跃 Target 时调用以释放资源。
+     */
+    WebhookMonitorState.prototype.stopPruning = function () {
+        if (this.pruneInterval) {
+            clearInterval(this.pruneInterval);
+            this.pruneInterval = undefined;
+        }
+    };
+    return WebhookMonitorState;
+}());
+exports.WebhookMonitorState = WebhookMonitorState;
+/**
+ * **monitorState (全局单例)**
+ *
+ * 导出全局唯一的 MonitorState 实例，供整个应用共享状态。
+ */
+exports.monitorState = new WebhookMonitorState();

package/dist/src/webhook/target.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Webhook Target 管理
+ *
+ * 从 @mocrane/wecom monitor.ts 部分迁移（仅 Webhook Target 相关）。
+ * 维护全局已注册 Target 列表，提供注册/注销/查询功能。
+ *
+ * Target 按路径索引：Map<path, WecomWebhookTarget[]>
+ * 同一路径可能注册多个账号（老路径兼容模式），通过签名验证匹配到正确账号。
+ */
+import type { WecomWebhookTarget } from "./types.js";
+/**
+ * 注册 Webhook Target（多条路径）
+ *
+ * 为每条路径分别注册 Target，返回一个注销函数（一次性注销所有路径）。
+ */
+export declare function registerWecomWebhookTarget(target: WecomWebhookTarget, paths: string[]): () => void;
+/**
+ * 获取全局 Target 注册表
+ *
+ * 返回完整的 Map<path, Target[]>，供 handler.ts 路由匹配使用。
+ */
+export declare function getWebhookTargetsMap(): ReadonlyMap<string, WecomWebhookTarget[]>;
+/**
+ * 获取所有已注册的 Webhook Target（扁平列表）
+ *
+ * 用于无法精确匹配路径时的逐一签名验证场景。
+ */
+export declare function getRegisteredTargets(): WecomWebhookTarget[];
+/**
+ * 判断是否有活跃 Target
+ */
+export declare function hasActiveTargets(): boolean;
+/**
+ * 从 URL 中解析 accountId（多账号路径）
+ *
+ * 支持路径格式：
+ * - /plugins/wecom/bot/{accountId}
+ * - /wecom/bot/{accountId}
+ * - /wecom/{accountId}
+ */
+export declare function parseWebhookPath(url: string): string | undefined;