@yanhaidao/wecom 2.4.160 → 2.5.110

package/dist/src/monitor.js

@@ -0,0 +1,84 @@
+import { getWecomRuntime } from "./runtime.js";
+import { handleWecomHttpRequest } from "./transport/http/request-handler.js";
+import { registerAgentWebhookTarget, registerWecomWebhookTarget } from "./transport/http/registry.js";
+import { sendActiveMessage } from "./transport/bot-webhook/active-reply.js";
+import { createBotWebhookRequestHandler } from "./transport/bot-webhook/request-handler.js";
+import { shouldProcessBotInboundMessage, } from "./transport/bot-webhook/message-shape.js";
+import { monitorState } from "./monitor/state.js";
+import { createBotStreamOrchestrator } from "./capability/bot/stream-orchestrator.js";
+const streamStore = monitorState.streamStore;
+function recordWebhookOperationalEvent(target, event) {
+    const accountId = "account" in target ? target.account.accountId : target.agent.accountId;
+    monitorState.operationalEvents.append({
+        accountId,
+        transport: event.transport,
+        category: event.category,
+        summary: event.summary,
+        messageId: event.messageId,
+    });
+    target.auditSink?.(event);
+}
+function recordBotOperationalEvent(target, event) {
+    recordWebhookOperationalEvent(target, {
+        transport: "bot-webhook",
+        ...event,
+    });
+}
+function logVerbose(target, message) {
+    const should = target.core.logging?.shouldLogVerbose?.() ??
+        (() => {
+            try {
+                return getWecomRuntime().logging.shouldLogVerbose();
+            }
+            catch {
+                return false;
+            }
+        })();
+    if (!should)
+        return;
+    target.runtime.log?.(`[wecom] ${message}`);
+}
+function logInfo(target, message) {
+    target.runtime.log?.(`[wecom] ${message}`);
+}
+const botStreamOrchestrator = createBotStreamOrchestrator({
+    streamStore,
+    recordBotOperationalEvent,
+});
+const { flushPending, startAgentForStream } = botStreamOrchestrator;
+monitorState.streamStore.setFlushHandler((pending) => void flushPending(pending));
+const handleBotWebhookRequest = createBotWebhookRequestHandler({
+    streamStore,
+    logInfo,
+    logVerbose,
+    recordBotOperationalEvent,
+    startAgentForStream,
+});
+export { registerAgentWebhookTarget, registerWecomWebhookTarget };
+export { sendActiveMessage, shouldProcessBotInboundMessage };
+/**
+ * **handleWecomWebhookRequest (HTTP 请求入口)**
+ *
+ * 处理来自企业微信的所有 Webhook 请求。
+ * 职责：
+ * 1. 路由分发：优先按 `/plugins/wecom/{bot|agent}/{accountId}` 分流，并兼容历史 `/wecom/*` 路径。
+ * 2. 安全校验：验证企业微信签名 (Signature)。
+ * 3. 消息解密：处理企业微信的加密包。
+ * 4. 响应处理：
+ *    - GET 请求：处理 EchoStr 验证。
+ *    - POST 请求：接收消息，放入 StreamStore，返回流式 First Chunk。
+ */
+export async function handleWecomWebhookRequest(req, res) {
+    return handleWecomHttpRequest({
+        req,
+        res,
+        handleBotWebhookRequest,
+    });
+}
+export async function handleLegacyWecomWebhookRequest(req, res) {
+    return handleWecomHttpRequest({
+        req,
+        res,
+        handleBotWebhookRequest,
+    });
+}

package/dist/src/observability/audit-log.js

@@ -0,0 +1,30 @@
+export class WecomAuditLog {
+    entries = [];
+    append(entry) {
+        this.entries.push(entry);
+        if (this.entries.length > 200) {
+            this.entries.shift();
+        }
+    }
+    list() {
+        return [...this.entries];
+    }
+    appendInbound(entry) {
+        this.append({
+            ...entry,
+            category: "inbound",
+            createdAt: Date.now(),
+        });
+    }
+    appendOperational(entry) {
+        this.append({
+            ...entry,
+            createdAt: Date.now(),
+        });
+    }
+    latestOperationalIssue() {
+        return [...this.entries]
+            .reverse()
+            .find((entry) => entry.category !== "inbound");
+    }
+}

package/dist/src/observability/legacy-operational-event-store.js

@@ -0,0 +1,22 @@
+import { LIMITS } from "../monitor/limits.js";
+export class LegacyOperationalEventStore {
+    events = [];
+    append(event) {
+        this.events.push({
+            ...event,
+            createdAt: Date.now(),
+        });
+        if (this.events.length > 200) {
+            this.events.shift();
+        }
+    }
+    list() {
+        return [...this.events];
+    }
+    prune(now = Date.now()) {
+        const cutoff = now - LIMITS.ACTIVE_REPLY_TTL_MS;
+        while (this.events.length > 0 && this.events[0] && this.events[0].createdAt < cutoff) {
+            this.events.shift();
+        }
+    }
+}

package/dist/src/observability/raw-envelope-log.js

@@ -0,0 +1,24 @@
+function summarizeRawHeaders(raw) {
+    const reqId = typeof raw.headers?.req_id === "string" ? raw.headers.req_id : undefined;
+    const eventId = typeof raw.headers?.event_id === "string" ? raw.headers.event_id : undefined;
+    return [reqId ? `req_id=${reqId}` : undefined, eventId ? `event_id=${eventId}` : undefined]
+        .filter((part) => Boolean(part))
+        .join(" ");
+}
+export function buildRawFrameReferenceSummary(raw) {
+    const parts = [
+        `envelope=${raw.envelopeType}`,
+        raw.command ? `cmd=${raw.command}` : undefined,
+        summarizeRawHeaders(raw),
+    ].filter((part) => Boolean(part));
+    return parts.join(" ");
+}
+export function buildRawEnvelopeSummary(event) {
+    return [
+        `transport=${event.transport}`,
+        `kind=${event.inboundKind}`,
+        `messageId=${event.messageId}`,
+        `peer=${event.conversation.peerKind}:${event.conversation.peerId}`,
+        buildRawFrameReferenceSummary(event.raw),
+    ].join(" ");
+}

package/dist/src/observability/status-registry.js

@@ -0,0 +1,9 @@
+export class WecomStatusRegistry {
+    sessions = new Map();
+    write(snapshot) {
+        this.sessions.set(`${snapshot.accountId}:${snapshot.transport}`, snapshot);
+    }
+    read(accountId) {
+        return Array.from(this.sessions.values()).filter((entry) => entry.accountId === accountId);
+    }
+}

package/dist/src/observability/transport-session-view.js

@@ -0,0 +1,14 @@
+export function summarizeTransportSessions(sessions) {
+    return sessions.map((session) => {
+        const parts = [
+            session.transport,
+            session.running ? "running" : "stopped",
+            session.ownerId ? `owner=${session.ownerId}` : "owner=none",
+        ];
+        if (session.connected != null)
+            parts.push(`connected=${String(session.connected)}`);
+        if (session.authenticated != null)
+            parts.push(`authenticated=${String(session.authenticated)}`);
+        return parts.join(" ");
+    });
+}