@cicctencent/agent-midway 0.1.1

package/dist/connector/http-adapter.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPAPIAdapter = void 0;
+class HTTPAPIAdapter {
+    constructor() {
+        this.type = 'http-api';
+    }
+    async testConnection(config) {
+        const services = config.services || [];
+        if (services.length === 0) {
+            return {
+                success: false,
+                message: '未配置任何服务',
+            };
+        }
+        const results = [];
+        for (const svc of services) {
+            try {
+                const resp = await fetch(svc.baseUrl, {
+                    method: 'GET',
+                    headers: this.buildHeaders(config, svc),
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (resp.ok) {
+                    results.push(`${svc.name}: OK (${resp.status})`);
+                }
+                else {
+                    results.push(`${svc.name}: HTTP ${resp.status}`);
+                }
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    message: `服务 ${svc.name} 连接失败`,
+                    error: err.message,
+                };
+            }
+        }
+        return {
+            success: true,
+            message: `连接成功，${results.length} 个服务可达`,
+            resources: results,
+        };
+    }
+    async discoverTools(config) {
+        const endpoints = await this.collectEndpoints(config);
+        const tools = [];
+        for (const ep of endpoints) {
+            const toolName = this.sanitizeToolName(ep.name);
+            const properties = {};
+            if (ep.querySchema?.properties) {
+                for (const [key, val] of Object.entries(ep.querySchema.properties)) {
+                    properties[key] = {
+                        ...val,
+                        description: val.description || `Query param: ${key}`,
+                    };
+                }
+            }
+            if (ep.bodySchema?.properties) {
+                for (const [key, val] of Object.entries(ep.bodySchema.properties)) {
+                    properties[key] = {
+                        ...val,
+                        description: val.description || `Body param: ${key}`,
+                    };
+                }
+            }
+            tools.push({
+                name: toolName,
+                description: ep.description || `${ep.method} ${ep.path}`,
+                inputSchema: {
+                    type: 'object',
+                    properties,
+                    required: [
+                        ...(ep.querySchema?.required || []),
+                        ...(ep.bodySchema?.required || []),
+                    ],
+                },
+            });
+        }
+        return tools;
+    }
+    async generateManifest(config) {
+        const tools = await this.discoverTools(config);
+        return {
+            tools,
+            metadata: {
+                apiMode: config.apiMode,
+                serviceCount: config.services?.length || 0,
+                endpointCount: tools.length,
+            },
+        };
+    }
+    async generateMCPServerConfigs(config) {
+        const tools = await this.discoverTools(config);
+        const services = config.services || [];
+        return services.map(svc => ({
+            name: `http-${svc.name}`,
+            transport: 'streamable-http',
+            url: svc.baseUrl,
+            tools: tools.filter(t => svc.endpoints?.some(ep => this.sanitizeToolName(ep.name) === t.name)),
+        }));
+    }
+    /** 收集所有端点 */
+    async collectEndpoints(config) {
+        if (config.apiMode === 'openapi' && config.openapiSpec) {
+            return this.parseOpenAPI(config);
+        }
+        const endpoints = [];
+        for (const svc of config.services || []) {
+            for (const ep of svc.endpoints || []) {
+                endpoints.push({ ...ep, service: svc.name });
+            }
+        }
+        return endpoints;
+    }
+    /** 解析 OpenAPI spec */
+    async parseOpenAPI(config) {
+        let spec;
+        if (config.openapiSpec.startsWith('http://') ||
+            config.openapiSpec.startsWith('https://')) {
+            const resp = await fetch(config.openapiSpec);
+            spec = await resp.json();
+        }
+        else {
+            spec = JSON.parse(config.openapiSpec);
+        }
+        const endpoints = [];
+        const basePath = spec.basePath || '';
+        const title = spec.info?.title || 'openapi-service';
+        for (const [routePath, methods] of Object.entries(spec.paths || {})) {
+            for (const [method, detail] of Object.entries(methods)) {
+                const upperMethod = method.toUpperCase();
+                if (!['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(upperMethod)) {
+                    continue;
+                }
+                const d = detail;
+                endpoints.push({
+                    name: d.operationId ||
+                        `${upperMethod.toLowerCase()}_${routePath.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                    method: upperMethod,
+                    path: basePath + routePath,
+                    description: d.summary || d.description || '',
+                    service: title,
+                });
+            }
+        }
+        return endpoints;
+    }
+    /** 构建请求头 */
+    buildHeaders(config, svc) {
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(config.globalHeaders || {}),
+            ...(svc?.headers || {}),
+        };
+        const token = svc?.authToken || config.authToken;
+        if (token) {
+            switch (config.authType) {
+                case 'bearer':
+                    headers['Authorization'] = `Bearer ${token}`;
+                    break;
+                case 'basic':
+                    headers['Authorization'] = `Basic ${Buffer.from(token).toString('base64')}`;
+                    break;
+                case 'apikey':
+                    headers['X-API-Key'] = token;
+                    break;
+            }
+        }
+        return headers;
+    }
+    /** 将端点名转为合法工具名 */
+    sanitizeToolName(name) {
+        return name
+            .replace(/[^a-zA-Z0-9_]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '')
+            .toLowerCase();
+    }
+}
+exports.HTTPAPIAdapter = HTTPAPIAdapter;

package/dist/connector/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 连接器适配器注册表
+ *
+ * 注册所有 7 种数据源适配器，提供统一的查询接口。
+ */
+import type { DataSourceType, DataSourceAdapter, DataSourceTypeInfo } from './types';
+import { DatabaseAdapter } from './db-adapter';
+import { HTTPAPIAdapter } from './http-adapter';
+import { FileSystemAdapter } from './fs-adapter';
+import { EmailAdapter } from './email-adapter';
+import { CalendarAdapter } from './calendar-adapter';
+import { MCPAdapter } from './mcp-adapter';
+import { MessageQueueAdapter } from './mq-adapter';
+/** 获取指定类型的适配器 */
+export declare function getAdapter(type: DataSourceType): DataSourceAdapter;
+/** 列出所有适配器类型 */
+export declare function listAdapterTypes(): DataSourceType[];
+/** 列出所有数据源类型（同 listAdapterTypes） */
+export declare function listDataSourceTypes(): DataSourceType[];
+/** 获取所有数据源类型信息（前端向导展示用） */
+export declare function getDataSourceTypeInfos(): DataSourceTypeInfo[];
+/** 获取指定类型的信息 */
+export declare function getDataSourceTypeInfo(type: DataSourceType): DataSourceTypeInfo;
+export { DatabaseAdapter, HTTPAPIAdapter, FileSystemAdapter, EmailAdapter, CalendarAdapter, MCPAdapter, MessageQueueAdapter, };

package/dist/connector/index.js

@@ -0,0 +1,454 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueueAdapter = exports.MCPAdapter = exports.CalendarAdapter = exports.EmailAdapter = exports.FileSystemAdapter = exports.HTTPAPIAdapter = exports.DatabaseAdapter = void 0;
+exports.getAdapter = getAdapter;
+exports.listAdapterTypes = listAdapterTypes;
+exports.listDataSourceTypes = listDataSourceTypes;
+exports.getDataSourceTypeInfos = getDataSourceTypeInfos;
+exports.getDataSourceTypeInfo = getDataSourceTypeInfo;
+const db_adapter_1 = require("./db-adapter");
+Object.defineProperty(exports, "DatabaseAdapter", { enumerable: true, get: function () { return db_adapter_1.DatabaseAdapter; } });
+const http_adapter_1 = require("./http-adapter");
+Object.defineProperty(exports, "HTTPAPIAdapter", { enumerable: true, get: function () { return http_adapter_1.HTTPAPIAdapter; } });
+const fs_adapter_1 = require("./fs-adapter");
+Object.defineProperty(exports, "FileSystemAdapter", { enumerable: true, get: function () { return fs_adapter_1.FileSystemAdapter; } });
+const email_adapter_1 = require("./email-adapter");
+Object.defineProperty(exports, "EmailAdapter", { enumerable: true, get: function () { return email_adapter_1.EmailAdapter; } });
+const calendar_adapter_1 = require("./calendar-adapter");
+Object.defineProperty(exports, "CalendarAdapter", { enumerable: true, get: function () { return calendar_adapter_1.CalendarAdapter; } });
+const mcp_adapter_1 = require("./mcp-adapter");
+Object.defineProperty(exports, "MCPAdapter", { enumerable: true, get: function () { return mcp_adapter_1.MCPAdapter; } });
+const mq_adapter_1 = require("./mq-adapter");
+Object.defineProperty(exports, "MessageQueueAdapter", { enumerable: true, get: function () { return mq_adapter_1.MessageQueueAdapter; } });
+// ===================== 适配器注册表 =====================
+const adapters = new Map();
+/** 注册所有内置适配器 */
+function registerAdapters() {
+    adapters.set('database', new db_adapter_1.DatabaseAdapter());
+    adapters.set('http-api', new http_adapter_1.HTTPAPIAdapter());
+    adapters.set('filesystem', new fs_adapter_1.FileSystemAdapter());
+    adapters.set('email', new email_adapter_1.EmailAdapter());
+    adapters.set('calendar', new calendar_adapter_1.CalendarAdapter());
+    adapters.set('mcp', new mcp_adapter_1.MCPAdapter());
+    adapters.set('message-queue', new mq_adapter_1.MessageQueueAdapter());
+}
+// 初始化注册
+registerAdapters();
+/** 获取指定类型的适配器 */
+function getAdapter(type) {
+    const adapter = adapters.get(type);
+    if (!adapter) {
+        throw new Error(`不支持的数据源类型: ${type}`);
+    }
+    return adapter;
+}
+/** 列出所有适配器类型 */
+function listAdapterTypes() {
+    return Array.from(adapters.keys());
+}
+/** 列出所有数据源类型（同 listAdapterTypes） */
+function listDataSourceTypes() {
+    return listAdapterTypes();
+}
+// ===================== 前端向导展示信息 =====================
+/** 数据源类型信息（前端向导展示用） */
+const typeInfos = {
+    database: {
+        type: 'database',
+        label: '数据库',
+        icon: 'database',
+        description: '连接 MySQL / PostgreSQL / MongoDB 数据库，自动发现表并生成查询工具',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-database',
+            },
+            {
+                name: 'dbType',
+                label: '数据库类型',
+                fieldType: 'select',
+                required: true,
+                defaultValue: 'mysql',
+                options: [
+                    { label: 'MySQL', value: 'mysql' },
+                    { label: 'PostgreSQL', value: 'postgres' },
+                    { label: 'MongoDB', value: 'mongodb' },
+                ],
+            },
+            {
+                name: 'host',
+                label: '主机地址',
+                fieldType: 'text',
+                required: true,
+                defaultValue: 'localhost',
+                placeholder: '127.0.0.1',
+            },
+            {
+                name: 'port',
+                label: '端口',
+                fieldType: 'number',
+                required: true,
+                defaultValue: 3306,
+                visibleWhen: { field: 'dbType', equals: 'mysql' },
+            },
+            {
+                name: 'database',
+                label: '数据库名',
+                fieldType: 'text',
+                required: true,
+            },
+            {
+                name: 'username',
+                label: '用户名',
+                fieldType: 'text',
+                required: true,
+            },
+            {
+                name: 'password',
+                label: '密码',
+                fieldType: 'password',
+                required: true,
+            },
+        ],
+    },
+    filesystem: {
+        type: 'filesystem',
+        label: '文件系统',
+        icon: 'folder',
+        description: '连接本地文件系统，生成文件读写、搜索等工具',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-files',
+            },
+            {
+                name: 'rootPath',
+                label: '根目录路径',
+                fieldType: 'text',
+                required: true,
+                placeholder: '/data/files',
+            },
+            {
+                name: 'readOnly',
+                label: '只读模式',
+                fieldType: 'boolean',
+                required: false,
+                defaultValue: true,
+            },
+            {
+                name: 'allowedExtensions',
+                label: '允许的扩展名',
+                fieldType: 'textarea',
+                required: false,
+                placeholder: '.txt,.json,.csv',
+            },
+        ],
+    },
+    'http-api': {
+        type: 'http-api',
+        label: 'HTTP API',
+        icon: 'api',
+        description: '连接 HTTP REST API，支持手动定义端点或从 OpenAPI spec 自动发现',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-api',
+            },
+            {
+                name: 'apiMode',
+                label: 'API 模式',
+                fieldType: 'select',
+                required: true,
+                defaultValue: 'manual',
+                options: [
+                    { label: '手动定义', value: 'manual' },
+                    { label: 'OpenAPI Spec', value: 'openapi' },
+                ],
+            },
+            {
+                name: 'openapiSpec',
+                label: 'OpenAPI Spec URL',
+                fieldType: 'text',
+                required: false,
+                placeholder: 'https://api.example.com/openapi.json',
+                visibleWhen: { field: 'apiMode', equals: 'openapi' },
+            },
+            {
+                name: 'authType',
+                label: '认证类型',
+                fieldType: 'select',
+                required: false,
+                defaultValue: 'none',
+                options: [
+                    { label: '无', value: 'none' },
+                    { label: 'Bearer Token', value: 'bearer' },
+                    { label: 'Basic Auth', value: 'basic' },
+                    { label: 'API Key', value: 'apikey' },
+                ],
+            },
+            {
+                name: 'authToken',
+                label: '认证 Token',
+                fieldType: 'password',
+                required: false,
+            },
+        ],
+    },
+    mcp: {
+        type: 'mcp',
+        label: 'MCP 服务器',
+        icon: 'server',
+        description: '连接 MCP (Model Context Protocol) 服务器，发现并代理其工具',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-mcp',
+            },
+            {
+                name: 'mcpTransport',
+                label: '传输方式',
+                fieldType: 'select',
+                required: true,
+                defaultValue: 'stdio',
+                options: [
+                    { label: 'Stdio', value: 'stdio' },
+                    { label: 'SSE', value: 'sse' },
+                    { label: 'Streamable HTTP', value: 'streamable-http' },
+                ],
+            },
+            {
+                name: 'command',
+                label: '命令',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'node',
+                visibleWhen: { field: 'mcpTransport', equals: 'stdio' },
+            },
+            {
+                name: 'args',
+                label: '参数',
+                fieldType: 'textarea',
+                required: false,
+                placeholder: '["server.js"]',
+                visibleWhen: { field: 'mcpTransport', equals: 'stdio' },
+            },
+            {
+                name: 'url',
+                label: 'URL',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'http://localhost:3001',
+                visibleWhen: { field: 'mcpTransport', equals: 'sse' },
+            },
+        ],
+    },
+    email: {
+        type: 'email',
+        label: '邮箱',
+        icon: 'mail',
+        description: '连接 IMAP + SMTP 邮箱，生成邮件收发和搜索工具',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-email',
+            },
+            {
+                name: 'emailAddress',
+                label: '邮箱地址',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'user@example.com',
+            },
+            {
+                name: 'password',
+                label: '密码 / 应用专用密码',
+                fieldType: 'password',
+                required: true,
+            },
+            {
+                name: 'imapHost',
+                label: 'IMAP 主机',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'imap.example.com',
+            },
+            {
+                name: 'imapPort',
+                label: 'IMAP 端口',
+                fieldType: 'number',
+                required: true,
+                defaultValue: 993,
+            },
+            {
+                name: 'smtpHost',
+                label: 'SMTP 主机',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'smtp.example.com',
+            },
+            {
+                name: 'smtpPort',
+                label: 'SMTP 端口',
+                fieldType: 'number',
+                required: true,
+                defaultValue: 465,
+            },
+            {
+                name: 'useTLS',
+                label: '使用 TLS',
+                fieldType: 'boolean',
+                required: false,
+                defaultValue: true,
+            },
+        ],
+    },
+    calendar: {
+        type: 'calendar',
+        label: '日历',
+        icon: 'calendar',
+        description: '连接本地或 CalDAV 日历，生成事件管理工具',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-calendar',
+            },
+            {
+                name: 'calendarType',
+                label: '日历类型',
+                fieldType: 'select',
+                required: true,
+                defaultValue: 'local',
+                options: [
+                    { label: '本地', value: 'local' },
+                    { label: 'CalDAV', value: 'caldav' },
+                ],
+            },
+            {
+                name: 'calendarName',
+                label: '日历名称',
+                fieldType: 'text',
+                required: false,
+                defaultValue: 'default',
+            },
+            {
+                name: 'caldavUrl',
+                label: 'CalDAV URL',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'https://caldav.example.com',
+                visibleWhen: { field: 'calendarType', equals: 'caldav' },
+            },
+            {
+                name: 'emailAddress',
+                label: '用户名',
+                fieldType: 'text',
+                required: false,
+                visibleWhen: { field: 'calendarType', equals: 'caldav' },
+            },
+            {
+                name: 'password',
+                label: '密码',
+                fieldType: 'password',
+                required: false,
+                visibleWhen: { field: 'calendarType', equals: 'caldav' },
+            },
+        ],
+    },
+    'message-queue': {
+        type: 'message-queue',
+        label: '消息队列',
+        icon: 'message',
+        description: '连接 RabbitMQ 或 Kafka 消息队列，生成消息生产/消费工具',
+        fields: [
+            {
+                name: 'name',
+                label: '数据源名称',
+                fieldType: 'text',
+                required: true,
+                placeholder: 'my-mq',
+            },
+            {
+                name: 'mqType',
+                label: 'MQ 类型',
+                fieldType: 'select',
+                required: true,
+                defaultValue: 'rabbitmq',
+                options: [
+                    { label: 'RabbitMQ', value: 'rabbitmq' },
+                    { label: 'Kafka', value: 'kafka' },
+                ],
+            },
+            {
+                name: 'host',
+                label: '主机地址',
+                fieldType: 'text',
+                required: true,
+                defaultValue: 'localhost',
+            },
+            {
+                name: 'port',
+                label: '端口',
+                fieldType: 'number',
+                required: true,
+                defaultValue: 5672,
+                visibleWhen: { field: 'mqType', equals: 'rabbitmq' },
+            },
+            {
+                name: 'username',
+                label: '用户名',
+                fieldType: 'text',
+                required: false,
+            },
+            {
+                name: 'password',
+                label: '密码',
+                fieldType: 'password',
+                required: false,
+            },
+            {
+                name: 'topics',
+                label: 'Topic / Queue 列表',
+                fieldType: 'textarea',
+                required: false,
+                placeholder: '["queue1", "queue2"]',
+            },
+            {
+                name: 'groupId',
+                label: '消费组 ID',
+                fieldType: 'text',
+                required: false,
+                visibleWhen: { field: 'mqType', equals: 'kafka' },
+            },
+        ],
+    },
+};
+/** 获取所有数据源类型信息（前端向导展示用） */
+function getDataSourceTypeInfos() {
+    return Object.values(typeInfos);
+}
+/** 获取指定类型的信息 */
+function getDataSourceTypeInfo(type) {
+    const info = typeInfos[type];
+    if (!info) {
+        throw new Error(`不支持的数据源类型: ${type}`);
+    }
+    return info;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * MCP 服务器适配器
+ *
+ * 连接外部 MCP 服务器，发现其暴露的工具。
+ * testConnection 尝试连接 MCP 服务器，discoverTools 获取工具列表。
+ */
+import type { DataSourceConfig, DiscoveredTool, ConnectionTestResult, DataSourceAdapter, MCPServerConfig } from './types';
+export declare class MCPAdapter implements DataSourceAdapter {
+    readonly type: "mcp";
+    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
+    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
+    generateManifest(config: DataSourceConfig): Promise<{
+        tools: DiscoveredTool[];
+        metadata: {
+            transport: "stdio" | "sse" | "streamable-http";
+            command: string;
+            url: string;
+        };
+    }>;
+    generateMCPServerConfigs(config: DataSourceConfig): Promise<MCPServerConfig[]>;
+    /** 从 MCP 服务器获取工具列表 */
+    private fetchTools;
+    /** 通过 stdio 连接 MCP 服务器 */
+    private fetchToolsStdio;
+    /** 通过 HTTP/SSE 连接 MCP 服务器 */
+    private fetchToolsHTTP;
+}