@yanhaidao/wecom 2.4.120 → 2.5.110

package/{src/shared/xml-parser.ts → dist/src/shared/xml-parser.js}

@@ -2,10 +2,7 @@
  * WeCom XML 解析器
  * 用于 Agent 模式解析 XML 格式消息
  */
-
 import { XMLParser } from "fast-xml-parser";
-import type { WecomAgentInboundMessage } from "../types/index.js";
-
 const xmlParser = new XMLParser({
     ignoreAttributes: false,
     trimValues: true,
@@ -13,109 +10,113 @@ const xmlParser = new XMLParser({
     parseTagValue: false,
     parseAttributeValue: false,
 });
-
 /**
  * 解析 XML 字符串为消息对象
  */
-export function parseXml(xml: string): WecomAgentInboundMessage {
+export function parseXml(xml) {
     const obj = xmlParser.parse(xml);
     const root = obj?.xml ?? obj;
     return root ?? {};
 }
-
 /**
  * 从 XML 中提取消息类型
  */
-export function extractMsgType(msg: WecomAgentInboundMessage): string {
+export function extractMsgType(msg) {
     return String(msg.MsgType ?? "").toLowerCase();
 }
-
 /**
  * 从 XML 中提取发送者 ID
  */
-export function extractFromUser(msg: WecomAgentInboundMessage): string {
+export function extractFromUser(msg) {
     return String(msg.FromUserName ?? "");
 }
-
 /**
  * 从 XML 中提取文件名（主要用于 file 消息）
  */
-export function extractFileName(msg: WecomAgentInboundMessage): string | undefined {
-    const raw = (msg as any).FileName ?? (msg as any).Filename ?? (msg as any).fileName ?? (msg as any).filename;
-    if (raw == null) return undefined;
-    if (typeof raw === "string") return raw.trim() || undefined;
-    if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint") return String(raw);
+export function extractFileName(msg) {
+    const raw = msg.FileName ?? msg.Filename ?? msg.fileName ?? msg.filename;
+    if (raw == null)
+        return undefined;
+    if (typeof raw === "string")
+        return raw.trim() || undefined;
+    if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint")
+        return String(raw);
     if (Array.isArray(raw)) {
         const merged = raw.map((v) => (v == null ? "" : String(v))).join("\n").trim();
         return merged || undefined;
     }
     if (typeof raw === "object") {
-        const obj = raw as Record<string, unknown>;
+        const obj = raw;
         const text = (typeof obj["#text"] === "string" ? obj["#text"] :
             typeof obj["_text"] === "string" ? obj["_text"] :
                 typeof obj["text"] === "string" ? obj["text"] : undefined);
-        if (text && text.trim()) return text.trim();
+        if (text && text.trim())
+            return text.trim();
     }
     const s = String(raw);
     return s.trim() || undefined;
 }
-
 /**
  * 从 XML 中提取接收者 ID (CorpID)
  */
-export function extractToUser(msg: WecomAgentInboundMessage): string {
+export function extractToUser(msg) {
     return String(msg.ToUserName ?? "");
 }
-
 /**
  * 从 XML 中提取群聊 ID
  */
-export function extractChatId(msg: WecomAgentInboundMessage): string | undefined {
+export function extractChatId(msg) {
     return msg.ChatId ? String(msg.ChatId) : undefined;
 }
-
 /**
  * 从 XML 中提取 AgentID（兼容 AgentID/agentid 等大小写）
  */
-export function extractAgentId(msg: WecomAgentInboundMessage): string | number | undefined {
-    const raw =
-        (msg as any).AgentID ??
-        (msg as any).AgentId ??
-        (msg as any).agentid ??
-        (msg as any).agentId;
-    if (raw == null) return undefined;
-    if (typeof raw === "string") return raw.trim() || undefined;
-    if (typeof raw === "number") return raw;
+export function extractAgentId(msg) {
+    const raw = msg.AgentID ??
+        msg.AgentId ??
+        msg.agentid ??
+        msg.agentId;
+    if (raw == null)
+        return undefined;
+    if (typeof raw === "string")
+        return raw.trim() || undefined;
+    if (typeof raw === "number")
+        return raw;
     const asString = String(raw).trim();
     return asString || undefined;
 }
-
 /**
  * 从 XML 中提取消息内容
  */
-export function extractContent(msg: WecomAgentInboundMessage): string {
+export function extractContent(msg) {
     const msgType = extractMsgType(msg);
-
-    const asText = (value: unknown): string => {
-        if (value == null) return "";
-        if (typeof value === "string") return value;
-        if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
-        if (Array.isArray(value)) return value.map(asText).filter(Boolean).join("\n");
+    const asText = (value) => {
+        if (value == null)
+            return "";
+        if (typeof value === "string")
+            return value;
+        if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+            return String(value);
+        if (Array.isArray(value))
+            return value.map(asText).filter(Boolean).join("\n");
         if (typeof value === "object") {
-            const obj = value as Record<string, unknown>;
+            const obj = value;
             // fast-xml-parser 在某些情况下（例如带属性）会把文本放在 "#text"
-            if (typeof obj["#text"] === "string") return obj["#text"];
-            if (typeof obj["_text"] === "string") return obj["_text"];
-            if (typeof obj["text"] === "string") return obj["text"];
+            if (typeof obj["#text"] === "string")
+                return obj["#text"];
+            if (typeof obj["_text"] === "string")
+                return obj["_text"];
+            if (typeof obj["text"] === "string")
+                return obj["text"];
             try {
                 return JSON.stringify(obj);
-            } catch {
+            }
+            catch {
                 return String(value);
             }
         }
         return String(value);
     };
-
     switch (msgType) {
         case "text":
             return asText(msg.Content);
@@ -138,30 +139,34 @@ export function extractContent(msg: WecomAgentInboundMessage): string {
             return `[${msgType || "未知消息类型"}]`;
     }
 }
-
 /**
  * 从 XML 中提取媒体 ID (Image, Voice, Video)
  * 根据官方文档，MediaId 在 Agent 回调中直接位于根节点
  */
-export function extractMediaId(msg: WecomAgentInboundMessage): string | undefined {
-    const raw = (msg as any).MediaId ?? (msg as any).MediaID ?? (msg as any).mediaid ?? (msg as any).mediaId;
-    if (raw == null) return undefined;
-    if (typeof raw === "string") return raw.trim() || undefined;
-    if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint") return String(raw);
+export function extractMediaId(msg) {
+    const raw = msg.MediaId ?? msg.MediaID ?? msg.mediaid ?? msg.mediaId;
+    if (raw == null)
+        return undefined;
+    if (typeof raw === "string")
+        return raw.trim() || undefined;
+    if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint")
+        return String(raw);
     if (Array.isArray(raw)) {
         const merged = raw.map((v) => (v == null ? "" : String(v))).join("\n").trim();
         return merged || undefined;
     }
     if (typeof raw === "object") {
-        const obj = raw as Record<string, unknown>;
+        const obj = raw;
         const text = (typeof obj["#text"] === "string" ? obj["#text"] :
             typeof obj["_text"] === "string" ? obj["_text"] :
                 typeof obj["text"] === "string" ? obj["text"] : undefined);
-        if (text && text.trim()) return text.trim();
+        if (text && text.trim())
+            return text.trim();
         try {
             const s = JSON.stringify(obj);
             return s.trim() || undefined;
-        } catch {
+        }
+        catch {
             const s = String(raw);
             return s.trim() || undefined;
         }
@@ -169,29 +174,33 @@ export function extractMediaId(msg: WecomAgentInboundMessage): string | undefine
     const s = String(raw);
     return s.trim() || undefined;
 }
-
 /**
  * 从 XML 中提取 MsgId（用于去重）
  */
-export function extractMsgId(msg: WecomAgentInboundMessage): string | undefined {
-    const raw = (msg as any).MsgId ?? (msg as any).MsgID ?? (msg as any).msgid ?? (msg as any).msgId;
-    if (raw == null) return undefined;
-    if (typeof raw === "string") return raw.trim() || undefined;
-    if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint") return String(raw);
+export function extractMsgId(msg) {
+    const raw = msg.MsgId ?? msg.MsgID ?? msg.msgid ?? msg.msgId;
+    if (raw == null)
+        return undefined;
+    if (typeof raw === "string")
+        return raw.trim() || undefined;
+    if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint")
+        return String(raw);
     if (Array.isArray(raw)) {
         const merged = raw.map((v) => (v == null ? "" : String(v))).join("\n").trim();
         return merged || undefined;
     }
     if (typeof raw === "object") {
-        const obj = raw as Record<string, unknown>;
+        const obj = raw;
         const text = (typeof obj["#text"] === "string" ? obj["#text"] :
             typeof obj["_text"] === "string" ? obj["_text"] :
                 typeof obj["text"] === "string" ? obj["text"] : undefined);
-        if (text && text.trim()) return text.trim();
+        if (text && text.trim())
+            return text.trim();
         try {
             const s = JSON.stringify(obj);
             return s.trim() || undefined;
-        } catch {
+        }
+        catch {
             const s = String(raw);
             return s.trim() || undefined;
         }

package/dist/src/store/active-reply-store.js

@@ -0,0 +1,41 @@
+import { LIMITS } from "../monitor/limits.js";
+export class ActiveReplyStore {
+    policy;
+    activeReplies = new Map();
+    constructor(policy = "once") {
+        this.policy = policy;
+    }
+    store(streamId, responseUrl, proxyUrl) {
+        const url = responseUrl?.trim();
+        if (!url)
+            return;
+        this.activeReplies.set(streamId, { response_url: url, proxyUrl, createdAt: Date.now() });
+    }
+    getUrl(streamId) {
+        return this.activeReplies.get(streamId)?.response_url;
+    }
+    async use(streamId, fn) {
+        const state = this.activeReplies.get(streamId);
+        if (!state?.response_url)
+            return;
+        if (this.policy === "once" && state.usedAt) {
+            throw new Error(`response_url already used for stream ${streamId} (Policy: once)`);
+        }
+        try {
+            await fn({ responseUrl: state.response_url, proxyUrl: state.proxyUrl });
+            state.usedAt = Date.now();
+        }
+        catch (err) {
+            state.lastError = err instanceof Error ? err.message : String(err);
+            throw err;
+        }
+    }
+    prune(now = Date.now()) {
+        const cutoff = now - LIMITS.ACTIVE_REPLY_TTL_MS;
+        for (const [id, state] of this.activeReplies.entries()) {
+            if (state.createdAt < cutoff) {
+                this.activeReplies.delete(id);
+            }
+        }
+    }
+}

package/dist/src/store/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/src/store/memory-store.js

@@ -0,0 +1,33 @@
+import { buildDedupKey } from "../domain/policies.js";
+export class InMemoryRuntimeStore {
+    seen = new Set();
+    replyContexts = new Map();
+    transportSessions = new Map();
+    deliveryTasks = new Map();
+    markInboundSeen(event) {
+        const key = buildDedupKey(event);
+        if (this.seen.has(key)) {
+            return false;
+        }
+        this.seen.add(key);
+        return true;
+    }
+    readReplyContext(messageId) {
+        return this.replyContexts.get(messageId);
+    }
+    writeReplyContext(messageId, context) {
+        this.replyContexts.set(messageId, context);
+    }
+    readTransportSession(accountId, transport) {
+        return this.transportSessions.get(`${accountId}:${transport}`);
+    }
+    writeTransportSession(snapshot) {
+        this.transportSessions.set(`${snapshot.accountId}:${snapshot.transport}`, snapshot);
+    }
+    writeDeliveryTask(task) {
+        this.deliveryTasks.set(task.messageId, task);
+    }
+    readDeliveryTask(messageId) {
+        return this.deliveryTasks.get(messageId);
+    }
+}

package/dist/src/store/stream-batch-store.js

@@ -0,0 +1,319 @@
+import crypto from "node:crypto";
+import { LIMITS } from "../monitor/limits.js";
+export class StreamStore {
+    streams = new Map();
+    msgidToStreamId = new Map();
+    pendingInbounds = new Map();
+    conversationState = new Map();
+    streamIdToBatchKey = new Map();
+    batchKeyToStreamIds = new Map();
+    batchStreamIdToAckStreamIds = new Map();
+    onFlush;
+    setFlushHandler(handler) {
+        this.onFlush = handler;
+    }
+    linkStreamToBatch(streamId, batchKey) {
+        const key = String(batchKey ?? "").trim();
+        if (!key)
+            return;
+        this.streamIdToBatchKey.set(streamId, key);
+        const linked = this.batchKeyToStreamIds.get(key) ?? new Set();
+        linked.add(streamId);
+        this.batchKeyToStreamIds.set(key, linked);
+    }
+    unlinkStreamFromBatch(streamId, batchKey) {
+        const key = String(batchKey ?? this.streamIdToBatchKey.get(streamId) ?? "").trim();
+        this.streamIdToBatchKey.delete(streamId);
+        if (!key)
+            return;
+        const linked = this.batchKeyToStreamIds.get(key);
+        if (!linked)
+            return;
+        linked.delete(streamId);
+        if (linked.size === 0) {
+            this.batchKeyToStreamIds.delete(key);
+        }
+        else {
+            this.batchKeyToStreamIds.set(key, linked);
+        }
+    }
+    hasLiveBatchKey(batchKey) {
+        const key = batchKey.trim();
+        if (!key)
+            return false;
+        return this.pendingInbounds.has(key) || (this.batchKeyToStreamIds.get(key)?.size ?? 0) > 0;
+    }
+    clearPendingTimer(pending) {
+        if (!pending?.timeout)
+            return;
+        clearTimeout(pending.timeout);
+        pending.timeout = null;
+    }
+    removePendingBatch(batchKey) {
+        const pending = this.pendingInbounds.get(batchKey);
+        if (!pending)
+            return undefined;
+        this.pendingInbounds.delete(batchKey);
+        this.clearPendingTimer(pending);
+        pending.readyToFlush = false;
+        return pending;
+    }
+    removeStreamRecord(streamId, state) {
+        const current = state ?? this.streams.get(streamId);
+        if (!current)
+            return;
+        this.streams.delete(streamId);
+        this.unlinkStreamFromBatch(streamId, current.batchKey);
+        if (current.msgid && this.msgidToStreamId.get(current.msgid) === streamId) {
+            this.msgidToStreamId.delete(current.msgid);
+        }
+    }
+    pruneAckStreamMappings() {
+        for (const [batchStreamId, ackIds] of this.batchStreamIdToAckStreamIds.entries()) {
+            if (!this.streams.has(batchStreamId)) {
+                this.batchStreamIdToAckStreamIds.delete(batchStreamId);
+                continue;
+            }
+            const nextAckIds = ackIds.filter((ackId) => this.streams.has(ackId));
+            if (nextAckIds.length === 0) {
+                this.batchStreamIdToAckStreamIds.delete(batchStreamId);
+                continue;
+            }
+            this.batchStreamIdToAckStreamIds.set(batchStreamId, nextAckIds);
+        }
+    }
+    pruneConversationState() {
+        for (const [convKey, conv] of this.conversationState.entries()) {
+            conv.queue = conv.queue.filter((batchKey) => this.pendingInbounds.has(batchKey));
+            if (!this.hasLiveBatchKey(conv.activeBatchKey)) {
+                const next = conv.queue.shift();
+                if (!next) {
+                    this.conversationState.delete(convKey);
+                    continue;
+                }
+                conv.activeBatchKey = next;
+            }
+            this.conversationState.set(convKey, conv);
+        }
+    }
+    createStream(params) {
+        const streamId = crypto.randomBytes(16).toString("hex");
+        if (params.msgid) {
+            this.msgidToStreamId.set(String(params.msgid), streamId);
+        }
+        this.streams.set(streamId, {
+            streamId,
+            msgid: params.msgid,
+            conversationKey: params.conversationKey,
+            batchKey: params.batchKey,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            started: false,
+            finished: false,
+            content: "",
+        });
+        this.linkStreamToBatch(streamId, params.batchKey);
+        return streamId;
+    }
+    getStream(streamId) {
+        return this.streams.get(streamId);
+    }
+    getStreamByMsgId(msgid) {
+        return this.msgidToStreamId.get(String(msgid));
+    }
+    setStreamIdForMsgId(msgid, streamId) {
+        const key = String(msgid).trim();
+        const value = String(streamId).trim();
+        if (!key || !value)
+            return;
+        this.msgidToStreamId.set(key, value);
+    }
+    addAckStreamForBatch(params) {
+        const batchStreamId = params.batchStreamId.trim();
+        const ackStreamId = params.ackStreamId.trim();
+        if (!batchStreamId || !ackStreamId)
+            return;
+        const list = this.batchStreamIdToAckStreamIds.get(batchStreamId) ?? [];
+        list.push(ackStreamId);
+        this.batchStreamIdToAckStreamIds.set(batchStreamId, list);
+    }
+    drainAckStreamsForBatch(batchStreamId) {
+        const key = batchStreamId.trim();
+        if (!key)
+            return [];
+        const list = this.batchStreamIdToAckStreamIds.get(key) ?? [];
+        this.batchStreamIdToAckStreamIds.delete(key);
+        return list;
+    }
+    updateStream(streamId, mutator) {
+        const state = this.streams.get(streamId);
+        if (state) {
+            mutator(state);
+            state.updatedAt = Date.now();
+        }
+    }
+    markStarted(streamId) {
+        this.updateStream(streamId, (s) => {
+            s.started = true;
+        });
+    }
+    markFinished(streamId) {
+        this.updateStream(streamId, (s) => {
+            s.finished = true;
+        });
+    }
+    addPendingMessage(params) {
+        const { conversationKey, target, msg, msgContent, nonce, timestamp, debounceMs } = params;
+        const effectiveDebounceMs = debounceMs ?? LIMITS.DEFAULT_DEBOUNCE_MS;
+        const state = this.conversationState.get(conversationKey);
+        if (!state) {
+            const batchKey = conversationKey;
+            const streamId = this.createStream({ msgid: msg.msgid, conversationKey, batchKey });
+            const pending = {
+                streamId,
+                conversationKey,
+                batchKey,
+                target,
+                msg,
+                contents: [msgContent],
+                msgids: msg.msgid ? [msg.msgid] : [],
+                nonce,
+                timestamp,
+                createdAt: Date.now(),
+                timeout: setTimeout(() => {
+                    this.requestFlush(batchKey);
+                }, effectiveDebounceMs),
+            };
+            this.pendingInbounds.set(batchKey, pending);
+            this.conversationState.set(conversationKey, { activeBatchKey: batchKey, queue: [], nextSeq: 1 });
+            return { streamId, status: "active_new" };
+        }
+        const activeBatchKey = state.activeBatchKey;
+        const activeIsInitial = activeBatchKey === conversationKey;
+        const activePending = this.pendingInbounds.get(activeBatchKey);
+        if (activePending && !activeIsInitial) {
+            const activeStream = this.streams.get(activePending.streamId);
+            const activeStarted = Boolean(activeStream?.started);
+            if (!activeStarted) {
+                activePending.contents.push(msgContent);
+                if (msg.msgid) {
+                    activePending.msgids.push(msg.msgid);
+                }
+                if (activePending.timeout)
+                    clearTimeout(activePending.timeout);
+                activePending.timeout = setTimeout(() => {
+                    this.requestFlush(activeBatchKey);
+                }, effectiveDebounceMs);
+                return { streamId: activePending.streamId, status: "active_merged" };
+            }
+        }
+        const queuedBatchKey = state.queue[0];
+        if (queuedBatchKey) {
+            const existingQueued = this.pendingInbounds.get(queuedBatchKey);
+            if (existingQueued) {
+                existingQueued.contents.push(msgContent);
+                if (msg.msgid) {
+                    existingQueued.msgids.push(msg.msgid);
+                }
+                if (existingQueued.timeout)
+                    clearTimeout(existingQueued.timeout);
+                existingQueued.timeout = setTimeout(() => {
+                    this.requestFlush(queuedBatchKey);
+                }, effectiveDebounceMs);
+                return { streamId: existingQueued.streamId, status: "queued_merged" };
+            }
+        }
+        const seq = state.nextSeq++;
+        const batchKey = `${conversationKey}#q${seq}`;
+        state.queue = [batchKey];
+        const streamId = this.createStream({ msgid: msg.msgid, conversationKey, batchKey });
+        const pending = {
+            streamId,
+            conversationKey,
+            batchKey,
+            target,
+            msg,
+            contents: [msgContent],
+            msgids: msg.msgid ? [msg.msgid] : [],
+            nonce,
+            timestamp,
+            createdAt: Date.now(),
+            timeout: setTimeout(() => {
+                this.requestFlush(batchKey);
+            }, effectiveDebounceMs),
+        };
+        this.pendingInbounds.set(batchKey, pending);
+        this.conversationState.set(conversationKey, state);
+        return { streamId, status: "queued_new" };
+    }
+    requestFlush(batchKey) {
+        const pending = this.pendingInbounds.get(batchKey);
+        if (!pending)
+            return;
+        const state = this.conversationState.get(pending.conversationKey);
+        const isActive = state?.activeBatchKey === batchKey;
+        if (!isActive) {
+            if (pending.timeout) {
+                clearTimeout(pending.timeout);
+                pending.timeout = null;
+            }
+            pending.readyToFlush = true;
+            return;
+        }
+        this.flushPending(batchKey);
+    }
+    flushPending(pendingKey) {
+        const pending = this.removePendingBatch(pendingKey);
+        if (!pending)
+            return;
+        if (this.onFlush) {
+            this.onFlush(pending);
+        }
+    }
+    onStreamFinished(streamId) {
+        const batchKey = this.streamIdToBatchKey.get(streamId);
+        const state = batchKey ? this.streams.get(streamId) : undefined;
+        const conversationKey = state?.conversationKey;
+        if (!batchKey || !conversationKey)
+            return;
+        this.unlinkStreamFromBatch(streamId, batchKey);
+        const conv = this.conversationState.get(conversationKey);
+        if (!conv)
+            return;
+        if (conv.activeBatchKey !== batchKey)
+            return;
+        const next = conv.queue.shift();
+        if (!next) {
+            this.conversationState.delete(conversationKey);
+            return;
+        }
+        conv.activeBatchKey = next;
+        this.conversationState.set(conversationKey, conv);
+        const pending = this.pendingInbounds.get(next);
+        if (!pending)
+            return;
+        if (pending.readyToFlush) {
+            this.flushPending(next);
+        }
+    }
+    prune(now = Date.now()) {
+        const streamCutoff = now - LIMITS.STREAM_TTL_MS;
+        for (const [id, state] of this.streams.entries()) {
+            if (state.updatedAt < streamCutoff) {
+                this.removeStreamRecord(id, state);
+            }
+        }
+        for (const [msgid, id] of this.msgidToStreamId.entries()) {
+            if (!this.streams.has(id)) {
+                this.msgidToStreamId.delete(msgid);
+            }
+        }
+        for (const [key, pending] of this.pendingInbounds.entries()) {
+            if (now - pending.createdAt > LIMITS.STREAM_TTL_MS) {
+                this.removePendingBatch(key);
+            }
+        }
+        this.pruneAckStreamMappings();
+        this.pruneConversationState();
+    }
+}