@wwlocal/aibot-plugin-node 20260409.20.0

package/dist/cjs/src/adapters/webhook-adapter.js

@@ -0,0 +1,260 @@
+'use strict';
+
+var baseAdapter = require('./base-adapter.js');
+
+/**
+ * Webhook 适配器
+ *
+ * 适用于：企业自建的非标准 HTTP API
+ *
+ * 核心机制：通过配置定义请求和响应的字段映射模板，无需编写代码
+ *
+ * 支持的模板变量：
+ * - {{text}} - 用户消息文本
+ * - {{user}} - 用户 ID
+ * - {{chatId}} - 聊天 ID
+ * - {{chatType}} - 聊天类型（single/group）
+ */
+/**
+ * Webhook 适配器
+ */
+class WebhookAdapter extends baseAdapter.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = "webhook";
+        this.displayName = "Custom Webhook";
+    }
+    /**
+     * 获取 Webhook 配置选项
+     */
+    getOptions(endpoint) {
+        return endpoint.providerOptions || {};
+    }
+    /**
+     * 转发请求到 Webhook API
+     */
+    async forward(request, endpoint, callbacks) {
+        const { text, abortSignal, runtime, context } = request;
+        const { deliver, onReplyStart, onError } = callbacks;
+        const options = this.getOptions(endpoint);
+        this.log(runtime, `Forwarding to Webhook: url=${endpoint.url}`);
+        // 构建模板变量
+        const variables = {
+            text,
+            user: context?.userId || "",
+            chatId: context?.chatId || "",
+            chatType: context?.chatType || "",
+        };
+        // 构建请求体
+        const requestBody = this.buildRequestBody(options.requestTemplate, variables);
+        // 构建请求头
+        const headers = this.buildHeaders(endpoint);
+        // 超时控制
+        const timeoutMs = endpoint.timeoutMs || 300000;
+        const { controller, timeoutId } = this.createTimeoutController(timeoutMs, abortSignal);
+        const method = options.method || "POST";
+        try {
+            const response = await this.fetchWithErrorHandling(endpoint.url, {
+                method,
+                headers,
+                body: method !== "GET" ? JSON.stringify(requestBody) : undefined,
+                signal: controller.signal,
+            }, runtime);
+            let finalText;
+            // 检查是否为流式响应
+            const contentType = response.headers.get("content-type") || "";
+            const isStreaming = contentType.includes("text/event-stream") && options.streamEventField;
+            if (isStreaming) {
+                // 流式响应
+                finalText = await this.handleStreamResponse({
+                    response,
+                    options,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                });
+            }
+            else {
+                // 非流式响应
+                finalText = await this.handleNonStreamResponse({
+                    response,
+                    options,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                });
+            }
+            // 最终 deliver
+            if (finalText) {
+                try {
+                    await deliver({ text: finalText }, { kind: "final" });
+                }
+                catch (e) {
+                    onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "final" });
+                }
+            }
+            this.log(runtime, `Response complete: textLength=${finalText.length}`);
+            return finalText;
+        }
+        catch (err) {
+            if (err?.name === "AbortError") {
+                const error = new Error(`Request timed out after ${timeoutMs}ms`);
+                this.logError(runtime, error.message);
+                onError?.(error, { kind: "timeout" });
+                throw error;
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * 构建请求体（应用模板变量替换）
+     */
+    buildRequestBody(template, variables) {
+        if (!template) {
+            // 默认请求体
+            return { message: variables.text };
+        }
+        return this.applyTemplate(template, variables);
+    }
+    /**
+     * 递归应用模板变量替换
+     */
+    applyTemplate(obj, variables) {
+        if (typeof obj === "string") {
+            // 字符串替换
+            return obj.replace(/\{\{(\w+)\}\}/g, (_, key) => variables[key] || "");
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.applyTemplate(item, variables));
+        }
+        if (obj && typeof obj === "object") {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.applyTemplate(value, variables);
+            }
+            return result;
+        }
+        return obj;
+    }
+    /**
+     * 从对象中按路径获取值
+     *
+     * @param obj 源对象
+     * @param path 字段路径（如 "data.reply.text"）
+     */
+    getValueByPath(obj, path) {
+        const keys = path.split(".");
+        let current = obj;
+        for (const key of keys) {
+            if (current == null || typeof current !== "object") {
+                return undefined;
+            }
+            current = current[key];
+        }
+        return current;
+    }
+    /**
+     * 处理流式响应
+     */
+    async handleStreamResponse(params) {
+        const { response, options, deliver, onReplyStart, onError, runtime } = params;
+        const body = response.body;
+        if (!body) {
+            throw new Error("Response has no body for streaming");
+        }
+        const reader = body.getReader();
+        let accumulatedText = "";
+        let replyStarted = false;
+        const streamEndMarker = options.streamEndMarker || "[DONE]";
+        const streamEventField = options.streamEventField || "content";
+        try {
+            for await (const { data } of this.readSSEStream(reader, runtime)) {
+                // 检查结束标记
+                if (data === streamEndMarker) {
+                    this.log(runtime, `SSE stream end marker: ${streamEndMarker}`);
+                    break;
+                }
+                // 解析 JSON
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    // 非 JSON，尝试直接作为文本
+                    if (data) {
+                        accumulatedText += data;
+                        continue;
+                    }
+                    this.log(runtime, `Failed to parse SSE JSON: ${data.slice(0, 200)}`);
+                    continue;
+                }
+                // 提取文本内容
+                const content = this.getValueByPath(parsed, streamEventField);
+                if (content && typeof content === "string") {
+                    if (!replyStarted) {
+                        replyStarted = true;
+                        try {
+                            await onReplyStart?.();
+                        }
+                        catch (e) {
+                            this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                        }
+                    }
+                    accumulatedText += content;
+                    try {
+                        await deliver({ text: accumulatedText }, { kind: "block" });
+                    }
+                    catch (e) {
+                        onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logError(runtime, `SSE stream error: ${String(err)}`);
+            onError?.(err instanceof Error ? err : new Error(String(err)), { kind: "stream" });
+        }
+        return accumulatedText;
+    }
+    /**
+     * 处理非流式响应
+     */
+    async handleNonStreamResponse(params) {
+        const { response, options, deliver, onReplyStart, onError, runtime } = params;
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch (err) {
+            const error = new Error(`Failed to parse Webhook response JSON: ${String(err)}`);
+            onError?.(error, { kind: "parse" });
+            throw error;
+        }
+        // 提取响应文本
+        const responseTextField = options.responseTextField || "result";
+        const content = this.getValueByPath(data, responseTextField);
+        const text = typeof content === "string" ? content : String(content || "");
+        if (text) {
+            try {
+                await onReplyStart?.();
+            }
+            catch (e) {
+                this.logError(runtime, `onReplyStart error: ${String(e)}`);
+            }
+            try {
+                await deliver({ text }, { kind: "block" });
+            }
+            catch (e) {
+                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+            }
+        }
+        return text;
+    }
+}
+
+exports.WebhookAdapter = WebhookAdapter;

package/dist/cjs/src/agent-forwarder.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var index = require('./adapters/index.js');
+var conversationManager = require('./conversation-manager.js');
+
+/**
+ * 智能体转发器（适配器调度层）
+ *
+ * 核心模块，负责：
+ * 1. 根据端点配置解析对应的适配器
+ * 2. 读取对话历史，注入到适配器请求中
+ * 3. 调用适配器执行转发
+ * 4. AI 回复后，将用户消息和 AI 回复保存到对话历史
+ * 5. 通过 deliver 回调驱动 monitor 的流式回复逻辑
+ *
+ * v1.1.0 重构：从 OpenAI 专用转发器改为可插拔适配器调度层
+ * v1.1.1 新增：多轮对话上下文记忆
+ */
+// ============================================================================
+// 公开 API
+// ============================================================================
+/**
+ * 将企微消息转发到外部智能体
+ *
+ * 完整流程：
+ * 1. 根据 endpoint.provider 解析适配器
+ * 2. 读取对话历史（如果 maxHistoryRounds > 0）
+ * 3. 构建适配器请求（含对话历史）
+ * 4. 调用 adapter.forward() 执行转发
+ * 5. 通过 deliver 回调驱动 monitor 的流式回复
+ * 6. AI 回复完成后，保存本轮对话到历史
+ */
+async function forwardToAgent(options) {
+    const { text, mediaPaths, quoteContent, agent, deliver, onReplyStart, onError, abortSignal, runtime, context } = options;
+    // 解析适配器
+    const adapter = index.resolveAdapter(agent);
+    runtime?.log?.(`[wecom][agent] Forwarding to agent: endpoint=${agent.name}, provider=${adapter.name}, url=${agent.url}`);
+    // 对话历史管理
+    const maxRounds = agent.maxHistoryRounds ?? 20; // 默认 20 轮
+    const chatId = context?.chatId;
+    let historyMessages;
+    // 构建会话隔离 key：accountId + agentName + chatId
+    // 防止多账号/多 endpoint 共用同一 chatId 时历史消息串联
+    const accountId = context?.accountId || "default";
+    const conversationKey = chatId ? `${accountId}:${agent.name}:${chatId}` : undefined;
+    if (maxRounds > 0 && conversationKey) {
+        const conversationManager$1 = conversationManager.getConversationManager({ maxRounds });
+        historyMessages = conversationManager$1.getHistory(conversationKey);
+        if (historyMessages.length > 0) {
+            runtime?.log?.(`[wecom][agent] Injecting ${historyMessages.length} history messages for chat=${chatId}, key=${conversationKey}`);
+        }
+        // 先记录用户消息（在转发之前）
+        conversationManager$1.addUserMessage(conversationKey, text);
+    }
+    // 构建适配器请求
+    const request = {
+        text,
+        mediaPaths,
+        quoteContent,
+        abortSignal,
+        runtime,
+        context,
+        historyMessages: historyMessages && historyMessages.length > 0 ? historyMessages : undefined,
+    };
+    // 构建回调集
+    const callbacks = {
+        deliver,
+        onReplyStart,
+        onError,
+    };
+    // 调用适配器执行转发
+    const replyText = await adapter.forward(request, agent, callbacks);
+    // 保存 AI 回复到对话历史
+    if (maxRounds > 0 && conversationKey && replyText) {
+        const conversationManager$1 = conversationManager.getConversationManager();
+        // 去除 <think>...</think> 标签后保存（避免思维链污染历史）
+        const cleanReply = replyText.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+        if (cleanReply) {
+            conversationManager$1.addAssistantMessage(conversationKey, cleanReply);
+            runtime?.log?.(`[wecom][agent] Saved assistant reply to history for chat=${chatId}, key=${conversationKey}, historySize=${conversationManager$1.getHistory(conversationKey).length}`);
+        }
+    }
+}
+
+exports.adapterRegistry = index.adapterRegistry;
+exports.resolveAdapter = index.resolveAdapter;
+exports.forwardToAgent = forwardToAgent;

package/dist/cjs/src/ca-cert.js

@@ -0,0 +1,162 @@
+'use strict';
+
+var tls = require('tls');
+var fs = require('fs');
+var path = require('path');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var tls__namespace = /*#__PURE__*/_interopNamespaceDefault(tls);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+/**
+ * 自签名 CA 证书运行时注入模块
+ *
+ * 背景：
+ *   NODE_EXTRA_CA_CERTS 环境变量只在 Node.js 进程启动时读取一次，
+ *   但用户配置 caCert 可能在运行时加载，此时进程已在运行，
+ *   所以不能依赖 NODE_EXTRA_CA_CERTS。
+ *
+ * 原理：
+ *   Node.js 所有 TLS 连接最终都会调用 tls.createSecureContext()，
+ *   我们在这一层做拦截（monkey-patch），将自签名 CA 证书追加到
+ *   每次创建的 TLS 上下文中，从而覆盖全部网络出口。
+ *
+ * 安全性说明：
+ *   - 仅追加 CA 证书，不禁用证书验证
+ *   - 不覆盖系统默认 CA 列表，只在默认列表基础上追加
+ *   - patch 是幂等的，多次调用只生效一次
+ *   - 调用 removeCaCertPatch() 可还原到原始状态
+ *
+ * 副作用：
+ *   patch 是进程全局的，会影响同一进程中所有 TLS 连接。
+ */
+/**
+ * 获取可写的 tls 模块引用。
+ */
+function getMutableTls() {
+    if (!Object.isSealed(tls__namespace)) {
+        return tls__namespace;
+    }
+    try {
+        const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('src/ca-cert.js', document.baseURI).href)));
+        return require$1("tls");
+    }
+    catch (e) {
+        throw new Error(`[ca-cert] 无法获取可写的 tls 模块引用。` +
+            `ESM namespace 是 sealed 的，且 createRequire 失败: ${e.message}`);
+    }
+}
+const _mutableTls = getMutableTls();
+// 保存原始的 createSecureContext 引用，用于还原
+const _originalCreateSecureContext = _mutableTls.createSecureContext;
+// 当前注入的 CA 证书内容（用于幂等性判断和日志）
+let _injectedCaCertContent = null;
+// 是否已经安装了 patch
+let _patched = false;
+// ============================================================================
+// 证书路径工具函数
+// ============================================================================
+/**
+ * 校验证书文件是否存在且为有效 PEM 格式
+ *
+ * @param certPath - 证书文件的绝对路径
+ * @returns 校验结果
+ */
+function validateCaCertFile(certPath) {
+    const fullPath = path__namespace.resolve(certPath);
+    // 检查文件是否存在
+    if (!fs__namespace.existsSync(fullPath)) {
+        return { ok: false, error: `证书文件不存在: ${fullPath}`, fullPath };
+    }
+    // 读取文件内容
+    let content;
+    try {
+        content = fs__namespace.readFileSync(fullPath, "utf-8").trim();
+    }
+    catch (err) {
+        return { ok: false, error: `读取证书文件失败: ${err.message}`, fullPath };
+    }
+    // PEM 格式校验
+    if (!content.includes("-----BEGIN CERTIFICATE-----")) {
+        return { ok: false, error: `证书格式无效（非 PEM 格式），请确认文件内容正确: ${fullPath}`, fullPath };
+    }
+    return { ok: true, content, fullPath };
+}
+// ============================================================================
+// CA 证书注入
+// ============================================================================
+/**
+ * 将自签名 CA 证书注入到 Node.js 全局 TLS 层
+ *
+ * @param certPath - 证书文件的绝对路径（PEM 格式）
+ * @param logger - 可选的日志函数
+ * @returns true 表示注入成功，false 表示跳过或失败
+ */
+function injectCaCert(certPath, logger) {
+    // 1. 校验证书文件
+    const result = validateCaCertFile(certPath);
+    if (!result.ok) {
+        logger?.(`[ca-cert] ${result.error}`);
+        return false;
+    }
+    const { content: caCertContent, fullPath: caCertPath } = result;
+    // 2. 幂等性检查：如果已经注入了相同的证书，跳过
+    if (_patched && _injectedCaCertContent === caCertContent) {
+        logger?.(`[ca-cert] CA 证书已注入，跳过重复操作: ${caCertPath}`);
+        return true;
+    }
+    // 3. 如果之前已安装过不同的证书，先还原再重新安装
+    if (_patched) {
+        removeCaCertPatch(logger);
+    }
+    // 4. 安装 monkey-patch
+    _mutableTls.createSecureContext = function patchedCreateSecureContext(options) {
+        const context = _originalCreateSecureContext.call(this, options);
+        try {
+            context.context.addCACert(caCertContent);
+        }
+        catch (e) {
+            logger?.(`[ca-cert] 警告: addCACert 失败: ${e.message}`);
+        }
+        return context;
+    };
+    _patched = true;
+    _injectedCaCertContent = caCertContent;
+    logger?.(`[ca-cert] CA 证书注入成功: ${caCertPath}`);
+    return true;
+}
+/**
+ * 移除 CA 证书的 monkey-patch，还原到 Node.js 原始行为
+ */
+function removeCaCertPatch(logger) {
+    if (!_patched) {
+        return;
+    }
+    _mutableTls.createSecureContext = _originalCreateSecureContext;
+    _patched = false;
+    _injectedCaCertContent = null;
+    logger?.("[ca-cert] CA 证书 patch 已移除，TLS 已还原为默认行为");
+}
+
+exports.injectCaCert = injectCaCert;
+exports.removeCaCertPatch = removeCaCertPatch;
+exports.validateCaCertFile = validateCaCertFile;

package/dist/cjs/src/config.js

@@ -0,0 +1,169 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var index = require('./adapters/index.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+/**
+ * 插件配置加载模块
+ *
+ * 从 JSON 配置文件加载插件配置，校验必填字段，提供合理默认值
+ */
+// ============================================================================
+// 默认值
+// ============================================================================
+const DEFAULT_PORT = 3000;
+const DEFAULT_DATA_DIR = "./data";
+const DEFAULT_AGENT_TIMEOUT_MS = 300000; // 5 分钟
+// ============================================================================
+// 配置加载
+// ============================================================================
+/**
+ * 从 JSON 文件加载插件配置
+ *
+ * @param configPath - 配置文件路径
+ * @returns 解析后的配置
+ */
+function loadConfig(configPath) {
+    const resolvedPath = path__namespace.resolve(configPath);
+    if (!fs__namespace.existsSync(resolvedPath)) {
+        throw new Error(`配置文件不存在: ${resolvedPath}`);
+    }
+    let raw;
+    try {
+        raw = fs__namespace.readFileSync(resolvedPath, "utf-8");
+    }
+    catch (err) {
+        throw new Error(`读取配置文件失败: ${err.message}`);
+    }
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`解析配置文件 JSON 失败: ${err.message}`);
+    }
+    // 校验必填字段
+    validateConfig(config);
+    // 应用默认值
+    config.port = config.port ?? DEFAULT_PORT;
+    config.dataDir = config.dataDir ?? DEFAULT_DATA_DIR;
+    // 确保数据目录存在
+    const dataDir = path__namespace.resolve(config.dataDir);
+    if (!fs__namespace.existsSync(dataDir)) {
+        fs__namespace.mkdirSync(dataDir, { recursive: true });
+    }
+    return config;
+}
+/**
+ * 校验配置必填字段
+ */
+function validateConfig(config) {
+    if (!config.agents || !Array.isArray(config.agents) || config.agents.length === 0) {
+        throw new Error("配置错误: agents 列表不能为空，至少需要配置一个智能体端点");
+    }
+    // 获取已注册的适配器列表
+    const registeredProviders = index.adapterRegistry.list().map((a) => a.name);
+    for (let i = 0; i < config.agents.length; i++) {
+        const agent = config.agents[i];
+        if (!agent.name) {
+            throw new Error(`配置错误: agents[${i}].name 不能为空`);
+        }
+        if (!agent.url) {
+            throw new Error(`配置错误: agents[${i}].url 不能为空`);
+        }
+        // 校验 provider 字段（如果配置了）
+        if (agent.provider && !registeredProviders.includes(agent.provider)) {
+            throw new Error(`配置错误: agents[${i}].provider "${agent.provider}" 不是有效的适配器类型。` +
+                `可用的适配器: ${registeredProviders.join(", ")}`);
+        }
+    }
+    if (!config.accounts || !Array.isArray(config.accounts) || config.accounts.length === 0) {
+        throw new Error("配置错误: accounts 列表不能为空，至少需要配置一个企微账号");
+    }
+    for (let i = 0; i < config.accounts.length; i++) {
+        const account = config.accounts[i];
+        if (!account.websocketUrl) {
+            throw new Error(`配置错误: accounts[${i}].websocketUrl 不能为空`);
+        }
+        if (!account.botId) {
+            throw new Error(`配置错误: accounts[${i}].botId 不能为空`);
+        }
+        if (!account.secret) {
+            throw new Error(`配置错误: accounts[${i}].secret 不能为空`);
+        }
+    }
+}
+/**
+ * 解析账号配置，填充默认值，关联智能体端点
+ */
+function resolveAccount(account, config) {
+    const accountId = account.accountId || account.botId;
+    // 查找智能体端点
+    let agent;
+    if (account.agentName) {
+        const found = config.agents.find((a) => a.name === account.agentName);
+        if (!found) {
+            throw new Error(`账号 ${accountId} 配置的智能体 "${account.agentName}" 未在 agents 列表中找到`);
+        }
+        agent = found;
+    }
+    else {
+        // 默认使用第一个智能体端点
+        agent = config.agents[0];
+    }
+    // 应用默认值
+    return {
+        accountId,
+        name: account.name || accountId,
+        enabled: account.enabled !== false,
+        websocketUrl: account.websocketUrl,
+        botId: account.botId,
+        secret: account.secret,
+        caCert: account.caCert,
+        sendThinkingMessage: account.sendThinkingMessage !== false,
+        dmPolicy: account.dmPolicy || "open",
+        allowFrom: account.allowFrom || [],
+        groupPolicy: account.groupPolicy || "open",
+        groupAllowFrom: account.groupAllowFrom || [],
+        groups: account.groups || {},
+        mediaLocalRoots: account.mediaLocalRoots || [],
+        agent: {
+            ...agent,
+            stream: agent.stream !== false,
+            timeoutMs: agent.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS,
+        },
+    };
+}
+/**
+ * 解析所有启用的账号配置
+ */
+function resolveAllAccounts(config) {
+    return config.accounts
+        .filter((a) => a.enabled !== false)
+        .map((a) => resolveAccount(a, config));
+}
+
+exports.loadConfig = loadConfig;
+exports.resolveAccount = resolveAccount;
+exports.resolveAllAccounts = resolveAllAccounts;