@cicctencent/agent-midway 0.1.1

package/dist/channel/dingtalk.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DingTalkAdapter = void 0;
+class DingTalkAdapter {
+    constructor() {
+        this.type = 'dingtalk';
+        this.config = {
+            type: 'dingtalk',
+            name: '钉钉',
+            enabled: false,
+        };
+    }
+    async init(config) {
+        this.config = { ...config };
+    }
+    /** 获取钉钉 access_token */
+    async getAccessToken(config) {
+        const response = await fetch(`https://oapi.dingtalk.com/gettoken?appkey=${config.appId}&appsecret=${config.appSecret}`);
+        const data = (await response.json());
+        if (data.errcode !== 0) {
+            throw new Error(`Failed to get dingtalk token: ${data.errmsg || 'unknown error'}`);
+        }
+        return data.access_token;
+    }
+    async sendMessage(config, receiveId, message) {
+        const token = await this.getAccessToken(config);
+        const response = await fetch('https://oapi.dingtalk.com/v1.0/robot/oToMessages/batchSend', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-acs-dingtalk-access-token': token,
+            },
+            body: JSON.stringify({
+                robotCode: config.appId,
+                userIds: [receiveId],
+                msgKey: 'sampleText',
+                msgParam: JSON.stringify({ content: message }),
+            }),
+        });
+        const data = (await response.json());
+        return !data.processingInstanceId === undefined ? true : response.ok;
+    }
+    async receiveMessage(body, _headers) {
+        // 钉钉机器人消息回调格式
+        const text = body?.text?.content;
+        if (!text)
+            return null;
+        return {
+            sessionId: body?.conversationId || body?.conversationId || '',
+            message: text.trim(),
+            senderId: body?.senderStaffId || body?.senderId || '',
+            senderName: body?.senderNick || body?.senderNick || '',
+            raw: body,
+        };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    verifySignature(body, headers, config) {
+        // 钉钉签名验证
+        const signature = headers?.['sign'];
+        if (!signature || !config.token)
+            return true;
+        // TODO: 实现完整的签名验证逻辑
+        return true;
+    }
+}
+exports.DingTalkAdapter = DingTalkAdapter;

package/dist/channel/feishu.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 飞书渠道适配器
+ *
+ * 发送消息：调用 https://open.feishu.cn/open-apis/im/v1/messages
+ * 接收消息：解析事件回调，支持 URL 验证挑战
+ */
+import type { ChannelAdapter, ChannelConfig, ChannelType, ReceivedMessage } from './types';
+export declare class FeishuAdapter implements ChannelAdapter {
+    readonly type: ChannelType;
+    private config;
+    init(config: ChannelConfig): Promise<void>;
+    /** 获取 tenant_access_token */
+    private getAccessToken;
+    sendMessage(config: ChannelConfig, receiveId: string, message: string): Promise<boolean>;
+    receiveMessage(body: any, _headers?: any): Promise<ReceivedMessage | null>;
+    getConfig(): ChannelConfig;
+    verifySignature(body: any, headers: any, _config: ChannelConfig): boolean;
+    /** URL 验证挑战 */
+    verifyChallenge(body: any, _config: ChannelConfig): any | null;
+}

package/dist/channel/feishu.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeishuAdapter = void 0;
+class FeishuAdapter {
+    constructor() {
+        this.type = 'feishu';
+        this.config = {
+            type: 'feishu',
+            name: '飞书',
+            enabled: false,
+        };
+    }
+    async init(config) {
+        this.config = { ...config };
+    }
+    /** 获取 tenant_access_token */
+    async getAccessToken(config) {
+        const response = await fetch('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                app_id: config.appId,
+                app_secret: config.appSecret,
+            }),
+        });
+        const data = (await response.json());
+        if (!data.tenant_access_token) {
+            throw new Error(`Failed to get feishu token: ${data.msg || 'unknown error'}`);
+        }
+        return data.tenant_access_token;
+    }
+    async sendMessage(config, receiveId, message) {
+        const token = await this.getAccessToken(config);
+        const receiveIdType = config.receiveIdType || 'open_id';
+        const response = await fetch(`https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=${receiveIdType}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                receive_id: receiveId,
+                msg_type: 'text',
+                content: JSON.stringify({ text: message }),
+            }),
+        });
+        const data = (await response.json());
+        return data.code === 0;
+    }
+    async receiveMessage(body, _headers) {
+        // 飞书事件回调格式
+        const event = body?.event || body;
+        if (!event)
+            return null;
+        const message = event?.message;
+        const sender = event?.sender;
+        if (!message)
+            return null;
+        // 解析消息内容
+        let text = '';
+        try {
+            const content = JSON.parse(message.content || '{}');
+            text = content.text || content.content || '';
+        }
+        catch {
+            text = message.content || '';
+        }
+        return {
+            sessionId: message.chat_id || message.thread_id || '',
+            message: text,
+            senderId: sender?.sender_id?.open_id || '',
+            senderName: sender?.sender_id?.name || '',
+            raw: body,
+        };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    verifySignature(body, headers, _config) {
+        // 飞书签名验证（简化版）
+        // 实际生产中应使用 EncryptKey 验证 X-Lark-Signature
+        const signature = headers?.['x-lark-signature'];
+        if (!signature)
+            return true; // 未配置签名时放行
+        // TODO: 实现完整的签名验证逻辑
+        return true;
+    }
+    /** URL 验证挑战 */
+    verifyChallenge(body, _config) {
+        if (body?.type === 'url_verification' && body?.challenge) {
+            return { challenge: body.challenge };
+        }
+        return null;
+    }
+}
+exports.FeishuAdapter = FeishuAdapter;

package/dist/channel/index.d.ts

@@ -0,0 +1,46 @@
+import type { ChannelAdapter, ChannelConfig, ChannelStatus, ChannelType, ReceivedMessage } from './types';
+import { FeishuAdapter } from './feishu';
+import { DingTalkAdapter } from './dingtalk';
+import { WeComAdapter } from './wecom';
+export declare class ChannelManager {
+    private static instance;
+    /** 适配器注册表 */
+    private adapters;
+    /** 渠道配置 */
+    private configs;
+    /** 渠道状态 */
+    private statuses;
+    /** 是否已初始化 */
+    private initialized;
+    private constructor();
+    static getInstance(): ChannelManager;
+    /** 初始化：注册适配器并加载配置 */
+    init(): Promise<void>;
+    /** 注册适配器 */
+    registerAdapter(adapter: ChannelAdapter): void;
+    /** 加载配置文件 */
+    private loadConfigs;
+    /** 保存配置文件 */
+    private saveConfigs;
+    /** 获取所有渠道状态 */
+    getStatuses(): ChannelStatus[];
+    /** 获取渠道配置（脱敏） */
+    getConfig(type: ChannelType): ChannelConfig | null;
+    /** 更新渠道配置 */
+    updateConfig(type: ChannelType, updates: Partial<ChannelConfig>): Promise<ChannelConfig>;
+    /** 路由 webhook 请求 */
+    routeWebhook(type: ChannelType, body: any, headers?: any): Promise<{
+        response: any;
+        message: ReceivedMessage | null;
+    }>;
+    /** 发送消息 */
+    sendMessage(type: ChannelType, receiveId: string, message: string): Promise<boolean>;
+    /** 脱敏配置（隐藏敏感字段） */
+    private maskConfig;
+}
+/** 导出单例 */
+export declare const channelManager: ChannelManager;
+/** 导出适配器类 */
+export { FeishuAdapter, DingTalkAdapter, WeComAdapter };
+/** 导出类型 */
+export type { ChannelAdapter, ChannelConfig, ChannelStatus, ChannelType, ReceivedMessage, } from './types';

package/dist/channel/index.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeComAdapter = exports.DingTalkAdapter = exports.FeishuAdapter = exports.channelManager = exports.ChannelManager = void 0;
+/**
+ * ChannelManager — IM 渠道管理器
+ *
+ * 单例类，负责：
+ * - 注册和管理渠道适配器（飞书、钉钉、企业微信）
+ * - 读写渠道配置（data/channels.json）
+ * - 路由 webhook 请求到对应适配器
+ * - 发送消息
+ * - 查询渠道状态
+ */
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const feishu_1 = require("./feishu");
+Object.defineProperty(exports, "FeishuAdapter", { enumerable: true, get: function () { return feishu_1.FeishuAdapter; } });
+const dingtalk_1 = require("./dingtalk");
+Object.defineProperty(exports, "DingTalkAdapter", { enumerable: true, get: function () { return dingtalk_1.DingTalkAdapter; } });
+const wecom_1 = require("./wecom");
+Object.defineProperty(exports, "WeComAdapter", { enumerable: true, get: function () { return wecom_1.WeComAdapter; } });
+/** 配置文件路径 */
+const CONFIG_FILE = path.join(process.cwd(), 'data', 'channels.json');
+/** 默认渠道配置 */
+const DEFAULT_CONFIGS = {
+    feishu: {
+        type: 'feishu',
+        name: '飞书',
+        enabled: false,
+        webhookUrl: '',
+        token: '',
+        appId: '',
+        appSecret: '',
+        receiveIdType: 'open_id',
+    },
+    dingtalk: {
+        type: 'dingtalk',
+        name: '钉钉',
+        enabled: false,
+        webhookUrl: '',
+        token: '',
+        appId: '',
+        appSecret: '',
+    },
+    wecom: {
+        type: 'wecom',
+        name: '企业微信',
+        enabled: false,
+        webhookUrl: '',
+        token: '',
+        appId: '',
+        appSecret: '',
+        wecomAgentId: '',
+    },
+};
+class ChannelManager {
+    constructor() {
+        /** 适配器注册表 */
+        this.adapters = new Map();
+        /** 渠道配置 */
+        this.configs = {};
+        /** 渠道状态 */
+        this.statuses = new Map();
+        /** 是否已初始化 */
+        this.initialized = false;
+    }
+    static getInstance() {
+        if (!ChannelManager.instance) {
+            ChannelManager.instance = new ChannelManager();
+        }
+        return ChannelManager.instance;
+    }
+    /** 初始化：注册适配器并加载配置 */
+    async init() {
+        if (this.initialized)
+            return;
+        // 注册适配器
+        this.registerAdapter(new feishu_1.FeishuAdapter());
+        this.registerAdapter(new dingtalk_1.DingTalkAdapter());
+        this.registerAdapter(new wecom_1.WeComAdapter());
+        // 加载配置
+        await this.loadConfigs();
+        // 初始化已启用的适配器
+        for (const [type, adapter] of this.adapters) {
+            const config = this.configs[type];
+            if (config && config.enabled) {
+                try {
+                    await adapter.init(config);
+                    this.statuses.set(type, {
+                        type,
+                        name: config.name,
+                        enabled: true,
+                        initialized: true,
+                        lastActiveAt: Date.now(),
+                    });
+                }
+                catch (error) {
+                    this.statuses.set(type, {
+                        type,
+                        name: config.name,
+                        enabled: true,
+                        initialized: false,
+                        error: error.message,
+                    });
+                }
+            }
+            else {
+                this.statuses.set(type, {
+                    type,
+                    name: config?.name || type,
+                    enabled: false,
+                    initialized: false,
+                });
+            }
+        }
+        this.initialized = true;
+    }
+    /** 注册适配器 */
+    registerAdapter(adapter) {
+        this.adapters.set(adapter.type, adapter);
+    }
+    /** 加载配置文件 */
+    async loadConfigs() {
+        try {
+            const content = await fs.readFile(CONFIG_FILE, 'utf-8');
+            this.configs = JSON.parse(content);
+        }
+        catch {
+            // 文件不存在时使用默认配置
+            this.configs = { ...DEFAULT_CONFIGS };
+            await this.saveConfigs();
+        }
+        // 确保所有渠道类型都有配置
+        for (const type of this.adapters.keys()) {
+            if (!this.configs[type]) {
+                this.configs[type] = { ...DEFAULT_CONFIGS[type] };
+            }
+        }
+    }
+    /** 保存配置文件 */
+    async saveConfigs() {
+        const dir = path.dirname(CONFIG_FILE);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(CONFIG_FILE, JSON.stringify(this.configs, null, 2), 'utf-8');
+    }
+    /** 获取所有渠道状态 */
+    getStatuses() {
+        const result = [];
+        for (const [, status] of this.statuses) {
+            result.push(status);
+        }
+        return result;
+    }
+    /** 获取渠道配置（脱敏） */
+    getConfig(type) {
+        const config = this.configs[type];
+        if (!config)
+            return null;
+        return this.maskConfig(config);
+    }
+    /** 更新渠道配置 */
+    async updateConfig(type, updates) {
+        const current = this.configs[type] || DEFAULT_CONFIGS[type];
+        const newConfig = {
+            ...current,
+            ...updates,
+            type, // 确保 type 不被覆盖
+        };
+        this.configs[type] = newConfig;
+        await this.saveConfigs();
+        // 如果启用，重新初始化适配器
+        if (newConfig.enabled) {
+            const adapter = this.adapters.get(type);
+            if (adapter) {
+                try {
+                    await adapter.init(newConfig);
+                    this.statuses.set(type, {
+                        type,
+                        name: newConfig.name,
+                        enabled: true,
+                        initialized: true,
+                        lastActiveAt: Date.now(),
+                    });
+                }
+                catch (error) {
+                    this.statuses.set(type, {
+                        type,
+                        name: newConfig.name,
+                        enabled: true,
+                        initialized: false,
+                        error: error.message,
+                    });
+                }
+            }
+        }
+        else {
+            this.statuses.set(type, {
+                type,
+                name: newConfig.name,
+                enabled: false,
+                initialized: false,
+            });
+        }
+        return this.maskConfig(newConfig);
+    }
+    /** 路由 webhook 请求 */
+    async routeWebhook(type, body, headers) {
+        const adapter = this.adapters.get(type);
+        const config = this.configs[type];
+        if (!adapter || !config) {
+            return {
+                response: { error: 'Channel not found' },
+                message: null,
+            };
+        }
+        // 验证签名
+        if (!adapter.verifySignature(body, headers, config)) {
+            return {
+                response: { error: 'Signature verification failed' },
+                message: null,
+            };
+        }
+        // 检查验证挑战（飞书 URL 验证等）
+        if (adapter.verifyChallenge) {
+            const challenge = adapter.verifyChallenge(body, config);
+            if (challenge !== null) {
+                return { response: challenge, message: null };
+            }
+        }
+        // 解析消息
+        const message = await adapter.receiveMessage(body, headers);
+        // 更新状态
+        const status = this.statuses.get(type);
+        if (status) {
+            status.lastActiveAt = Date.now();
+        }
+        // 返回成功响应（IM 平台要求快速响应）
+        return {
+            response: { success: true },
+            message,
+        };
+    }
+    /** 发送消息 */
+    async sendMessage(type, receiveId, message) {
+        const adapter = this.adapters.get(type);
+        const config = this.configs[type];
+        if (!adapter || !config || !config.enabled) {
+            throw new Error(`Channel ${type} is not available or not enabled`);
+        }
+        const success = await adapter.sendMessage(config, receiveId, message);
+        // 更新状态
+        const status = this.statuses.get(type);
+        if (status) {
+            status.lastActiveAt = Date.now();
+            if (!success) {
+                status.error = 'Failed to send message';
+            }
+            else {
+                status.error = undefined;
+            }
+        }
+        return success;
+    }
+    /** 脱敏配置（隐藏敏感字段） */
+    maskConfig(config) {
+        const masked = { ...config };
+        if (masked.appSecret) {
+            masked.appSecret = '***';
+        }
+        if (masked.token) {
+            masked.token = '***';
+        }
+        return masked;
+    }
+}
+exports.ChannelManager = ChannelManager;
+/** 导出单例 */
+exports.channelManager = ChannelManager.getInstance();

package/dist/channel/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * IM 渠道类型定义
+ *
+ * 定义渠道适配器接口和通用类型，支持飞书、钉钉、企业微信等 IM 平台。
+ */
+/** 渠道类型 */
+export type ChannelType = 'feishu' | 'dingtalk' | 'wecom';
+/** 渠道配置 */
+export interface ChannelConfig {
+    /** 渠道类型 */
+    type: ChannelType;
+    /** 渠道名称 */
+    name: string;
+    /** 是否启用 */
+    enabled: boolean;
+    /** Webhook URL（接收消息的端点） */
+    webhookUrl?: string;
+    /** 验证 Token */
+    token?: string;
+    /** 应用 ID */
+    appId?: string;
+    /** 应用密钥 */
+    appSecret?: string;
+    /** 接收者 ID 类型 */
+    receiveIdType?: string;
+    /** 飞书 Agent ID */
+    agentId?: string;
+    /** 企业微信 Agent ID */
+    wecomAgentId?: string;
+    /** 额外配置 */
+    extra?: Record<string, any>;
+}
+/** 解析后的消息 */
+export interface ReceivedMessage {
+    /** 会话 ID（用于关联上下文） */
+    sessionId: string;
+    /** 消息文本内容 */
+    message: string;
+    /** 发送者 ID */
+    senderId: string;
+    /** 发送者名称 */
+    senderName: string;
+    /** 原始消息体 */
+    raw: any;
+}
+/** 渠道状态 */
+export interface ChannelStatus {
+    /** 渠道类型 */
+    type: ChannelType;
+    /** 渠道名称 */
+    name: string;
+    /** 是否启用 */
+    enabled: boolean;
+    /** 是否已初始化 */
+    initialized: boolean;
+    /** 最后活跃时间 */
+    lastActiveAt?: number;
+    /** 错误信息 */
+    error?: string;
+}
+/** 渠道适配器接口 */
+export interface ChannelAdapter {
+    /** 渠道类型 */
+    readonly type: ChannelType;
+    /** 初始化适配器 */
+    init(config: ChannelConfig): Promise<void>;
+    /** 发送消息 */
+    sendMessage(config: ChannelConfig, receiveId: string, message: string): Promise<boolean>;
+    /** 接收并解析消息 */
+    receiveMessage(body: any, headers?: any): Promise<ReceivedMessage | null>;
+    /** 获取配置（脱敏后） */
+    getConfig(): ChannelConfig;
+    /** 验证签名 */
+    verifySignature(body: any, headers: any, config: ChannelConfig): boolean;
+    /** Webhook 验证挑战（飞书 URL 验证等） */
+    verifyChallenge?(body: any, config: ChannelConfig): any | null;
+}

package/dist/channel/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * IM 渠道类型定义
+ *
+ * 定义渠道适配器接口和通用类型，支持飞书、钉钉、企业微信等 IM 平台。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/channel/wecom.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 企业微信渠道适配器
+ *
+ * 发送消息：调用 https://qyapi.weixin.qq.com/cgi-bin/message/send
+ * 接收消息：支持 JSON 和 XML 格式
+ */
+import type { ChannelAdapter, ChannelConfig, ChannelType, ReceivedMessage } from './types';
+export declare class WeComAdapter implements ChannelAdapter {
+    readonly type: ChannelType;
+    private config;
+    init(config: ChannelConfig): Promise<void>;
+    /** 获取企业微信 access_token */
+    private getAccessToken;
+    sendMessage(config: ChannelConfig, receiveId: string, message: string): Promise<boolean>;
+    receiveMessage(body: any, headers?: any): Promise<ReceivedMessage | null>;
+    getConfig(): ChannelConfig;
+    verifySignature(body: any, headers: any, config: ChannelConfig): boolean;
+    /** URL 验证挑战 */
+    verifyChallenge(body: any, _config: ChannelConfig): any | null;
+    /** 简单 XML 解析（企业微信回调） */
+    private parseXml;
+}