@cicctencent/agent-midway 0.1.1

package/dist/connector/mcp-adapter.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPAdapter = void 0;
+class MCPAdapter {
+    constructor() {
+        this.type = 'mcp';
+    }
+    async testConnection(config) {
+        try {
+            const tools = await this.fetchTools(config);
+            return {
+                success: true,
+                message: `MCP 服务器连接成功，发现 ${tools.length} 个工具`,
+                resources: tools.map(t => t.name),
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: 'MCP 服务器连接失败',
+                error: err.message,
+            };
+        }
+    }
+    async discoverTools(config) {
+        return this.fetchTools(config);
+    }
+    async generateManifest(config) {
+        const tools = await this.discoverTools(config);
+        return {
+            tools,
+            metadata: {
+                transport: config.mcpTransport,
+                command: config.command,
+                url: config.url,
+            },
+        };
+    }
+    async generateMCPServerConfigs(config) {
+        const tools = await this.discoverTools(config);
+        return [
+            {
+                name: `mcp-${config.name || 'proxy'}`,
+                transport: config.mcpTransport || 'stdio',
+                command: config.command,
+                args: config.args,
+                env: config.env,
+                url: config.url,
+                tools,
+            },
+        ];
+    }
+    /** 从 MCP 服务器获取工具列表 */
+    async fetchTools(config) {
+        const transport = config.mcpTransport || 'stdio';
+        if (transport === 'stdio') {
+            return this.fetchToolsStdio(config);
+        }
+        return this.fetchToolsHTTP(config);
+    }
+    /** 通过 stdio 连接 MCP 服务器 */
+    async fetchToolsStdio(config) {
+        const { spawn } = require('child_process');
+        return new Promise((resolve, reject) => {
+            const proc = spawn(config.command, config.args || [], {
+                env: { ...process.env, ...(config.env || {}) },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const timeout = setTimeout(() => {
+                proc.kill();
+                reject(new Error('MCP 服务器连接超时'));
+            }, 15000);
+            let buffer = '';
+            proc.stdout.on('data', (data) => {
+                buffer += data.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.result?.tools) {
+                            clearTimeout(timeout);
+                            proc.kill();
+                            resolve(msg.result.tools.map((t) => ({
+                                name: t.name,
+                                description: t.description || '',
+                                inputSchema: t.inputSchema || {
+                                    type: 'object',
+                                    properties: {},
+                                },
+                            })));
+                        }
+                    }
+                    catch {
+                        // 忽略非 JSON 行
+                    }
+                }
+            });
+            proc.stderr.on('data', () => {
+                // 忽略 stderr
+            });
+            proc.on('error', err => {
+                clearTimeout(timeout);
+                reject(new Error(`启动 MCP 服务器失败: ${err.message}`));
+            });
+            proc.on('close', () => {
+                clearTimeout(timeout);
+                // 如果还没 resolve，返回空数组
+                resolve([]);
+            });
+            // 发送 initialize + tools/list 请求
+            const initMsg = JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {},
+                    clientInfo: { name: 'connector-test', version: '1.0' },
+                },
+            });
+            const listMsg = JSON.stringify({
+                jsonrpc: '2.0',
+                id: 2,
+                method: 'tools/list',
+                params: {},
+            });
+            proc.stdin.write(initMsg + '\n');
+            proc.stdin.write(listMsg + '\n');
+        });
+    }
+    /** 通过 HTTP/SSE 连接 MCP 服务器 */
+    async fetchToolsHTTP(config) {
+        const resp = await fetch(`${config.url}/tools`, {
+            method: 'GET',
+            headers: { 'Content-Type': 'application/json' },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!resp.ok) {
+            throw new Error(`HTTP ${resp.status}`);
+        }
+        const data = await resp.json();
+        const tools = data.tools || data;
+        return (Array.isArray(tools) ? tools : []).map((t) => ({
+            name: t.name,
+            description: t.description || '',
+            inputSchema: t.inputSchema || {
+                type: 'object',
+                properties: {},
+            },
+        }));
+    }
+}
+exports.MCPAdapter = MCPAdapter;

package/dist/connector/mq-adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 消息队列适配器
+ *
+ * 支持 RabbitMQ（动态 require amqplib）和 Kafka（动态 require kafkajs）。
+ * testConnection 测试 MQ 连接，discoverTools 生成消息生产/消费工具。
+ */
+import type { DataSourceConfig, DiscoveredTool, ConnectionTestResult, DataSourceAdapter, MCPServerConfig } from './types';
+export declare class MessageQueueAdapter implements DataSourceAdapter {
+    readonly type: "message-queue";
+    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
+    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
+    generateManifest(config: DataSourceConfig): Promise<{
+        tools: DiscoveredTool[];
+        metadata: {
+            mqType: "rabbitmq" | "kafka";
+            host: string;
+            topics: string[];
+        };
+    }>;
+    generateMCPServerConfigs(config: DataSourceConfig): Promise<MCPServerConfig[]>;
+    /** 测试 RabbitMQ 连接 */
+    private testRabbitMQ;
+    /** 测试 Kafka 连接 */
+    private testKafka;
+}

package/dist/connector/mq-adapter.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueueAdapter = void 0;
+class MessageQueueAdapter {
+    constructor() {
+        this.type = 'message-queue';
+    }
+    async testConnection(config) {
+        if (config.mqType === 'kafka') {
+            return this.testKafka(config);
+        }
+        return this.testRabbitMQ(config);
+    }
+    async discoverTools(config) {
+        const topics = config.topics || [];
+        const tools = [];
+        for (const topic of topics) {
+            tools.push({
+                name: `mq_publish_${topic}`,
+                description: `向 ${topic} 发布消息（${config.mqType}）`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        message: {
+                            type: 'string',
+                            description: '消息内容（JSON 字符串）',
+                        },
+                        routingKey: {
+                            type: 'string',
+                            description: '路由键（RabbitMQ）',
+                        },
+                    },
+                    required: ['message'],
+                },
+            });
+            tools.push({
+                name: `mq_consume_${topic}`,
+                description: `从 ${topic} 消费消息（${config.mqType}）`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        maxMessages: {
+                            type: 'number',
+                            description: '最大消费消息数',
+                            default: 10,
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: '超时时间（毫秒）',
+                            default: 5000,
+                        },
+                    },
+                },
+            });
+        }
+        // 通用工具
+        tools.push({
+            name: 'mq_list_topics',
+            description: '列出所有可用的 topic / queue',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        });
+        return tools;
+    }
+    async generateManifest(config) {
+        const tools = await this.discoverTools(config);
+        return {
+            tools,
+            metadata: {
+                mqType: config.mqType,
+                host: config.host,
+                topics: config.topics,
+            },
+        };
+    }
+    async generateMCPServerConfigs(config) {
+        const tools = await this.discoverTools(config);
+        return [
+            {
+                name: `mq-${config.name || 'default'}`,
+                transport: 'stdio',
+                command: 'node',
+                args: ['-e', '/* MCP server for message queue */'],
+                env: {
+                    MQ_TYPE: config.mqType || 'rabbitmq',
+                    MQ_HOST: config.host || '',
+                    MQ_PORT: String(config.port || 5672),
+                    MQ_TOPICS: (config.topics || []).join(','),
+                    MQ_GROUP_ID: config.groupId || '',
+                    MQ_USER: config.username || '',
+                    MQ_PASS: config.password || '',
+                },
+                tools,
+            },
+        ];
+    }
+    /** 测试 RabbitMQ 连接 */
+    async testRabbitMQ(config) {
+        let amqp;
+        try {
+            amqp = require('amqplib');
+        }
+        catch {
+            throw new Error('amqplib 包未安装，请运行 npm install amqplib');
+        }
+        const url = `amqp://${config.username
+            ? config.username + ':' + (config.password || '') + '@'
+            : ''}${config.host}:${config.port || 5672}`;
+        let conn;
+        try {
+            conn = await amqp.connect(url);
+            const channel = await conn.createChannel();
+            const queues = [];
+            for (const topic of config.topics || []) {
+                try {
+                    const q = await channel.assertQueue(topic, {
+                        durable: true,
+                    });
+                    queues.push(q.queue);
+                }
+                catch {
+                    // 忽略单个队列错误
+                }
+            }
+            return {
+                success: true,
+                message: `RabbitMQ 连接成功，确认 ${queues.length} 个队列`,
+                resources: queues,
+            };
+        }
+        finally {
+            if (conn) {
+                await conn.close().catch(() => { });
+            }
+        }
+    }
+    /** 测试 Kafka 连接 */
+    async testKafka(config) {
+        let Kafka;
+        try {
+            Kafka = require('kafkajs').Kafka;
+        }
+        catch {
+            throw new Error('kafkajs 包未安装，请运行 npm install kafkajs');
+        }
+        const kafka = new Kafka({
+            clientId: 'connector-test',
+            brokers: [`${config.host}:${config.port || 9092}`],
+            sasl: config.username && config.password
+                ? {
+                    mechanism: 'plain',
+                    username: config.username,
+                    password: config.password,
+                }
+                : undefined,
+        });
+        const admin = kafka.admin();
+        try {
+            await admin.connect();
+            const topics = await admin.listTopics();
+            const configTopics = config.topics || [];
+            const missing = configTopics.filter(t => !topics.includes(t));
+            for (const t of missing) {
+                await admin.createTopics({
+                    topics: [{ topic: t, numPartitions: 1 }],
+                });
+            }
+            return {
+                success: true,
+                message: `Kafka 连接成功，发现 ${topics.length} 个 topic`,
+                resources: topics,
+            };
+        }
+        finally {
+            await admin.disconnect().catch(() => { });
+        }
+    }
+}
+exports.MessageQueueAdapter = MessageQueueAdapter;

package/dist/connector/types.d.ts

@@ -0,0 +1,205 @@
+/**
+ * 连接器系统类型定义
+ *
+ * 定义数据源类型、配置、适配器接口等核心类型。
+ * 适配器模式：每种数据源实现 DataSourceAdapter 接口，
+ * 由 ConnectorService 统一管理生命周期。
+ */
+/** 数据源类型 */
+export type DataSourceType = 'database' | 'filesystem' | 'message-queue' | 'http-api' | 'mcp' | 'email' | 'calendar';
+/** 数据源连接配置（所有数据源类型的并集） */
+export interface DataSourceConfig {
+    /** 数据源名称 */
+    name: string;
+    /** 数据源类型 */
+    type: DataSourceType;
+    /** 是否启用 */
+    enabled: boolean;
+    /** 数据库类型: mysql / postgres / mongodb */
+    dbType?: 'mysql' | 'postgres' | 'mongodb';
+    /** 数据库主机 */
+    host?: string;
+    /** 数据库端口 */
+    port?: number;
+    /** 数据库名 */
+    database?: string;
+    /** 数据库用户名 */
+    username?: string;
+    /** 数据库密码 */
+    password?: string;
+    /** 额外连接参数 (SSL 等) */
+    extraOptions?: Record<string, any>;
+    /** 根目录路径 */
+    rootPath?: string;
+    /** 允许的扩展名 */
+    allowedExtensions?: string[];
+    /** 是否只读 */
+    readOnly?: boolean;
+    /** HTTP API 模式: manual / openapi */
+    apiMode?: 'manual' | 'openapi';
+    /** OpenAPI spec URL 或内联 JSON */
+    openapiSpec?: string;
+    /** 服务配置列表（多服务实例） */
+    services?: ServiceConfig[];
+    /** 全局请求头 */
+    globalHeaders?: Record<string, string>;
+    /** 全局认证 token */
+    authToken?: string;
+    /** 认证类型: bearer / basic / apikey / none */
+    authType?: 'bearer' | 'basic' | 'apikey' | 'none';
+    /** MCP 传输方式: stdio / sse / streamable-http */
+    mcpTransport?: 'stdio' | 'sse' | 'streamable-http';
+    /** MCP 命令（stdio 模式） */
+    command?: string;
+    /** MCP 参数 */
+    args?: string[];
+    /** MCP 环境变量 */
+    env?: Record<string, string>;
+    /** MCP URL（sse / streamable-http 模式） */
+    url?: string;
+    /** IMAP 主机 */
+    imapHost?: string;
+    /** IMAP 端口 */
+    imapPort?: number;
+    /** SMTP 主机 */
+    smtpHost?: string;
+    /** SMTP 端口 */
+    smtpPort?: number;
+    /** 是否使用 TLS */
+    useTLS?: boolean;
+    /** 邮箱地址 */
+    emailAddress?: string;
+    /** 日历类型: local / caldav */
+    calendarType?: 'local' | 'caldav';
+    /** CalDAV 服务器 URL */
+    caldavUrl?: string;
+    /** 日历名称 */
+    calendarName?: string;
+    /** MQ 类型: rabbitmq / kafka */
+    mqType?: 'rabbitmq' | 'kafka';
+    /** MQ topic / queue 列表 */
+    topics?: string[];
+    /** 消费组 ID（Kafka） */
+    groupId?: string;
+}
+/** HTTP API 服务配置（多服务实例） */
+export interface ServiceConfig {
+    /** 服务名称 */
+    name: string;
+    /** 基础 URL */
+    baseUrl: string;
+    /** 认证 token */
+    authToken?: string;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 端点列表 */
+    endpoints?: EndpointConfig[];
+}
+/** HTTP API 端点定义 */
+export interface EndpointConfig {
+    /** 端点名称 */
+    name: string;
+    /** HTTP 方法 */
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** 路径（相对于 baseUrl） */
+    path: string;
+    /** 描述 */
+    description?: string;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 请求体 JSON Schema */
+    bodySchema?: Record<string, any>;
+    /** 查询参数 JSON Schema */
+    querySchema?: Record<string, any>;
+}
+/** 工具发现结果 */
+export interface DiscoveredTool {
+    /** 工具名称 */
+    name: string;
+    /** 工具描述 */
+    description: string;
+    /** 参数 JSON Schema */
+    inputSchema: Record<string, any>;
+    /** 输出 JSON Schema（可选） */
+    outputSchema?: Record<string, any>;
+}
+/** 连接测试结果 */
+export interface ConnectionTestResult {
+    /** 是否成功 */
+    success: boolean;
+    /** 消息 */
+    message: string;
+    /** 发现的资源（表、文件、端点等） */
+    resources?: string[];
+    /** 错误详情 */
+    error?: string;
+}
+/** MCP 服务器配置（生成的） */
+export interface MCPServerConfig {
+    /** 服务器名称 */
+    name: string;
+    /** 传输方式 */
+    transport: 'stdio' | 'sse' | 'streamable-http';
+    /** 命令（stdio） */
+    command?: string;
+    /** 参数（stdio） */
+    args?: string[];
+    /** 环境变量（stdio） */
+    env?: Record<string, string>;
+    /** URL（sse / streamable-http） */
+    url?: string;
+    /** 工具列表 */
+    tools: DiscoveredTool[];
+}
+/** 数据源适配器接口 */
+export interface DataSourceAdapter {
+    /** 数据源类型 */
+    readonly type: DataSourceType;
+    /** 测试连接 */
+    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
+    /** 发现工具 */
+    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
+    /** 生成清单（包含工具定义和元数据） */
+    generateManifest(config: DataSourceConfig): Promise<{
+        tools: DiscoveredTool[];
+        metadata: Record<string, any>;
+    }>;
+    /** 生成 MCP 服务器配置 */
+    generateMCPServerConfigs(config: DataSourceConfig): Promise<MCPServerConfig[]>;
+}
+/** 数据源类型信息（前端向导展示用） */
+export interface DataSourceTypeInfo {
+    /** 类型标识 */
+    type: DataSourceType;
+    /** 显示名称 */
+    label: string;
+    /** 图标 */
+    icon?: string;
+    /** 描述 */
+    description: string;
+    /** 配置字段定义 */
+    fields: Array<{
+        /** 字段名 */
+        name: string;
+        /** 显示标签 */
+        label: string;
+        /** 字段类型 */
+        fieldType: 'text' | 'password' | 'number' | 'select' | 'boolean' | 'textarea';
+        /** 是否必填 */
+        required: boolean;
+        /** 默认值 */
+        defaultValue?: any;
+        /** 选项（select 类型） */
+        options?: Array<{
+            label: string;
+            value: string;
+        }>;
+        /** 条件显示（依赖其他字段的值） */
+        visibleWhen?: {
+            field: string;
+            equals: any;
+        };
+        /** 占位符 */
+        placeholder?: string;
+    }>;
+}

package/dist/connector/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * 连接器系统类型定义
+ *
+ * 定义数据源类型、配置、适配器接口等核心类型。
+ * 适配器模式：每种数据源实现 DataSourceAdapter 接口，
+ * 由 ConnectorService 统一管理生命周期。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/controller/a2a.controller.d.ts

@@ -0,0 +1,41 @@
+import { BaseController } from '@cicctencent/midwayjs-base';
+import { A2AService } from '../service/a2a.service';
+import type { JsonRpcResponse } from '../service/a2a.service';
+export declare class A2AController extends BaseController {
+    a2aService: A2AService;
+    /**
+     * Agent Card 发现端点
+     * GET /.well-known/agent.json
+     */
+    getAgentCard(): Promise<import("../service/a2a.service").AgentCard>;
+    /**
+     * JSON-RPC 分发入口
+     * POST /a2a
+     * 支持 SSE 流式响应（当 method 为 tasks/sendSubscribe 时）
+     */
+    handleJsonRpc(body: any): Promise<void | JsonRpcResponse>;
+    /**
+     * 发现远程 Agent
+     * POST /api/a2a/discover
+     */
+    discoverAgent(body: {
+        url: string;
+        auth?: string;
+    }): Promise<{
+        ret: number;
+        data: import("../service/a2a.service").AgentCard;
+        msg: string;
+    } | {
+        ret: number;
+        msg: any;
+        data?: undefined;
+    }>;
+    /**
+     * 处理流式 JSON-RPC 请求（SSE）
+     */
+    private handleStreaming;
+    /**
+     * 格式化 SSE 事件
+     */
+    private formatSSEEvent;
+}