@cicctencent/agent-midway 0.1.1

package/dist/connector/db-adapter.js

@@ -0,0 +1,193 @@
+"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.DatabaseAdapter = void 0;
+class DatabaseAdapter {
+    constructor() {
+        this.type = 'database';
+    }
+    async testConnection(config) {
+        try {
+            const tables = await this.listTables(config);
+            return {
+                success: true,
+                message: `连接成功，发现 ${tables.length} 张表`,
+                resources: tables,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: '连接失败',
+                error: err.message,
+            };
+        }
+    }
+    async discoverTools(config) {
+        const tables = await this.listTables(config);
+        const tools = [];
+        for (const table of tables) {
+            tools.push({
+                name: `db_${table}_query`,
+                description: `查询 ${table} 表数据，支持 WHERE 条件、LIMIT 限制`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        where: {
+                            type: 'string',
+                            description: 'WHERE 条件（不含 WHERE 关键字）',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: '返回行数限制',
+                            default: 100,
+                        },
+                        offset: {
+                            type: 'number',
+                            description: '偏移量',
+                            default: 0,
+                        },
+                    },
+                },
+            });
+            tools.push({
+                name: `db_${table}_describe`,
+                description: `获取 ${table} 表结构信息（列名、类型等）`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            });
+        }
+        return tools;
+    }
+    async generateManifest(config) {
+        const tools = await this.discoverTools(config);
+        return {
+            tools,
+            metadata: {
+                dbType: config.dbType,
+                database: config.database,
+                host: config.host,
+                tableCount: tools.length / 2,
+            },
+        };
+    }
+    async generateMCPServerConfigs(config) {
+        const tools = await this.discoverTools(config);
+        return [
+            {
+                name: `db-${config.name || config.database}`,
+                transport: 'stdio',
+                command: 'node',
+                args: ['-e', `/* MCP server for ${config.database} */`],
+                env: {
+                    DB_TYPE: config.dbType || 'mysql',
+                    DB_HOST: config.host || '',
+                    DB_PORT: String(config.port || 3306),
+                    DB_NAME: config.database || '',
+                    DB_USER: config.username || '',
+                    DB_PASS: config.password || '',
+                },
+                tools,
+            },
+        ];
+    }
+    /** 列出所有表 */
+    async listTables(config) {
+        if (config.dbType === 'mongodb') {
+            return this.listMongoCollections(config);
+        }
+        return this.listSQLTables(config);
+    }
+    /** 列出 SQL 表（MySQL / PostgreSQL） */
+    async listSQLTables(config) {
+        const { DataSource } = await Promise.resolve().then(() => __importStar(require('typeorm')));
+        const dbType = config.dbType === 'postgres' ? 'postgres' : 'mysql';
+        const ds = new DataSource({
+            type: dbType,
+            host: config.host,
+            port: config.port,
+            username: config.username,
+            password: config.password,
+            database: config.database,
+            extra: config.extraOptions,
+            synchronize: false,
+            entities: [],
+        });
+        try {
+            await ds.initialize();
+            const query = dbType === 'postgres'
+                ? "SELECT tablename FROM pg_tables WHERE schemaname = 'public'"
+                : 'SHOW TABLES';
+            const result = await ds.query(query);
+            return result.map((row) => dbType === 'postgres' ? row.tablename : Object.values(row)[0]);
+        }
+        finally {
+            if (ds.isInitialized) {
+                await ds.destroy();
+            }
+        }
+    }
+    /** 列出 MongoDB 集合 */
+    async listMongoCollections(config) {
+        let MongoClient;
+        try {
+            MongoClient = require('mongodb').MongoClient;
+        }
+        catch {
+            throw new Error('mongodb 包未安装，请运行 npm install mongodb');
+        }
+        const url = `mongodb://${config.host}:${config.port || 27017}`;
+        const client = new MongoClient(url, {
+            auth: config.username && config.password
+                ? {
+                    username: config.username,
+                    password: config.password,
+                }
+                : undefined,
+        });
+        try {
+            await client.connect();
+            const db = client.db(config.database);
+            const collections = await db.listCollections().toArray();
+            return collections.map((c) => c.name);
+        }
+        finally {
+            await client.close();
+        }
+    }
+}
+exports.DatabaseAdapter = DatabaseAdapter;

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

@@ -0,0 +1,23 @@
+/**
+ * 邮箱适配器
+ *
+ * 支持 IMAP（收信）+ SMTP（发信），使用动态 require 加载 imapflow。
+ * testConnection 测试 IMAP/SMTP 连接，discoverTools 生成邮件相关工具。
+ */
+import type { DataSourceConfig, DiscoveredTool, ConnectionTestResult, DataSourceAdapter, MCPServerConfig } from './types';
+export declare class EmailAdapter implements DataSourceAdapter {
+    readonly type: "email";
+    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
+    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
+    generateManifest(config: DataSourceConfig): Promise<{
+        tools: DiscoveredTool[];
+        metadata: {
+            emailAddress: string;
+            imapHost: string;
+            smtpHost: string;
+        };
+    }>;
+    generateMCPServerConfigs(config: DataSourceConfig): Promise<MCPServerConfig[]>;
+    /** 动态加载 imapflow */
+    private loadImapFlow;
+}

package/dist/connector/email-adapter.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailAdapter = void 0;
+class EmailAdapter {
+    constructor() {
+        this.type = 'email';
+    }
+    async testConnection(config) {
+        try {
+            const ImapFlow = await this.loadImapFlow();
+            const client = new ImapFlow({
+                host: config.imapHost,
+                port: config.imapPort || 993,
+                secure: config.useTLS !== false,
+                auth: {
+                    user: config.emailAddress,
+                    pass: config.password,
+                },
+                logger: false,
+            });
+            try {
+                await client.connect();
+                const lock = await client.getMailboxLock('INBOX');
+                try {
+                    const count = await client.status('INBOX', {
+                        messages: true,
+                    });
+                    return {
+                        success: true,
+                        message: `IMAP 连接成功，收件箱有 ${count.messages || 0} 封邮件`,
+                        resources: ['INBOX'],
+                    };
+                }
+                finally {
+                    lock.release();
+                }
+            }
+            finally {
+                await client.logout().catch(() => { });
+            }
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: '邮箱连接失败',
+                error: err.message,
+            };
+        }
+    }
+    async discoverTools(config) {
+        return [
+            {
+                name: 'email_list',
+                description: `列出邮箱 ${config.emailAddress} 的邮件`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        mailbox: {
+                            type: 'string',
+                            description: '邮箱文件夹',
+                            default: 'INBOX',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: '返回邮件数',
+                            default: 20,
+                        },
+                        search: {
+                            type: 'object',
+                            description: '搜索条件（from, subject, since 等）',
+                            properties: {
+                                from: { type: 'string' },
+                                subject: { type: 'string' },
+                                since: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'email_read',
+                description: '读取指定邮件内容',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uid: {
+                            type: 'number',
+                            description: '邮件 UID',
+                        },
+                        mailbox: {
+                            type: 'string',
+                            default: 'INBOX',
+                        },
+                    },
+                    required: ['uid'],
+                },
+            },
+            {
+                name: 'email_send',
+                description: `通过 SMTP 发送邮件（发件人: ${config.emailAddress}）`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        to: {
+                            type: 'string',
+                            description: '收件人地址（多个用逗号分隔）',
+                        },
+                        subject: {
+                            type: 'string',
+                            description: '邮件主题',
+                        },
+                        body: {
+                            type: 'string',
+                            description: '邮件正文',
+                        },
+                        html: {
+                            type: 'boolean',
+                            description: '是否为 HTML 格式',
+                            default: false,
+                        },
+                    },
+                    required: ['to', 'subject', 'body'],
+                },
+            },
+            {
+                name: 'email_search',
+                description: '搜索邮件',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: '搜索关键词',
+                        },
+                        mailbox: {
+                            type: 'string',
+                            default: 'INBOX',
+                        },
+                        limit: {
+                            type: 'number',
+                            default: 20,
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+        ];
+    }
+    async generateManifest(config) {
+        const tools = await this.discoverTools(config);
+        return {
+            tools,
+            metadata: {
+                emailAddress: config.emailAddress,
+                imapHost: config.imapHost,
+                smtpHost: config.smtpHost,
+            },
+        };
+    }
+    async generateMCPServerConfigs(config) {
+        const tools = await this.discoverTools(config);
+        return [
+            {
+                name: `email-${config.emailAddress || 'default'}`,
+                transport: 'stdio',
+                command: 'node',
+                args: ['-e', '/* MCP server for email */'],
+                env: {
+                    IMAP_HOST: config.imapHost || '',
+                    IMAP_PORT: String(config.imapPort || 993),
+                    SMTP_HOST: config.smtpHost || '',
+                    SMTP_PORT: String(config.smtpPort || 465),
+                    EMAIL_ADDRESS: config.emailAddress || '',
+                    EMAIL_PASSWORD: config.password || '',
+                    USE_TLS: String(config.useTLS ?? true),
+                },
+                tools,
+            },
+        ];
+    }
+    /** 动态加载 imapflow */
+    async loadImapFlow() {
+        try {
+            const mod = require('imapflow');
+            return mod.ImapFlow || mod.default || mod;
+        }
+        catch {
+            throw new Error('imapflow 包未安装，请运行 npm install imapflow');
+        }
+    }
+}
+exports.EmailAdapter = EmailAdapter;

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

@@ -0,0 +1,15 @@
+import type { DataSourceConfig, DiscoveredTool, ConnectionTestResult, DataSourceAdapter, MCPServerConfig } from './types';
+export declare class FileSystemAdapter implements DataSourceAdapter {
+    readonly type: "filesystem";
+    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
+    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
+    generateManifest(config: DataSourceConfig): Promise<{
+        tools: DiscoveredTool[];
+        metadata: {
+            rootPath: string;
+            readOnly: boolean;
+            allowedExtensions: string[];
+        };
+    }>;
+    generateMCPServerConfigs(config: DataSourceConfig): Promise<MCPServerConfig[]>;
+}

package/dist/connector/fs-adapter.js

@@ -0,0 +1,199 @@
+"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.FileSystemAdapter = void 0;
+/**
+ * 文件系统适配器
+ *
+ * 生成 list_directory / read_file / search_files / file_info / write_file 工具。
+ * testConnection 检查根目录是否可访问。
+ */
+const fs = __importStar(require("fs/promises"));
+class FileSystemAdapter {
+    constructor() {
+        this.type = 'filesystem';
+    }
+    async testConnection(config) {
+        const rootPath = config.rootPath;
+        if (!rootPath) {
+            return {
+                success: false,
+                message: '未配置根目录路径',
+            };
+        }
+        try {
+            const stat = await fs.stat(rootPath);
+            if (!stat.isDirectory()) {
+                return {
+                    success: false,
+                    message: `${rootPath} 不是目录`,
+                };
+            }
+            const entries = await fs.readdir(rootPath);
+            return {
+                success: true,
+                message: `连接成功，根目录包含 ${entries.length} 个条目`,
+                resources: entries.slice(0, 50),
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: '无法访问根目录',
+                error: err.message,
+            };
+        }
+    }
+    async discoverTools(config) {
+        const readOnly = config.readOnly !== false;
+        const tools = [
+            {
+                name: 'list_directory',
+                description: `列出指定目录下的文件和子目录（根目录: ${config.rootPath}）`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        dirPath: {
+                            type: 'string',
+                            description: '相对于根目录的路径，默认为根目录',
+                            default: '.',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'read_file',
+                description: '读取文件内容',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        filePath: {
+                            type: 'string',
+                            description: '相对于根目录的文件路径',
+                        },
+                        encoding: {
+                            type: 'string',
+                            description: '文件编码',
+                            default: 'utf-8',
+                        },
+                    },
+                    required: ['filePath'],
+                },
+            },
+            {
+                name: 'search_files',
+                description: '按名称模式搜索文件',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: '文件名匹配模式（支持 * 通配符）',
+                        },
+                        dirPath: {
+                            type: 'string',
+                            description: '搜索起始目录（相对于根目录）',
+                            default: '.',
+                        },
+                    },
+                    required: ['pattern'],
+                },
+            },
+            {
+                name: 'file_info',
+                description: '获取文件或目录的元信息',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        filePath: {
+                            type: 'string',
+                            description: '相对于根目录的路径',
+                        },
+                    },
+                    required: ['filePath'],
+                },
+            },
+        ];
+        if (!readOnly) {
+            tools.push({
+                name: 'write_file',
+                description: '写入内容到文件',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        filePath: {
+                            type: 'string',
+                            description: '相对于根目录的文件路径',
+                        },
+                        content: {
+                            type: 'string',
+                            description: '文件内容',
+                        },
+                    },
+                    required: ['filePath', 'content'],
+                },
+            });
+        }
+        return tools;
+    }
+    async generateManifest(config) {
+        const tools = await this.discoverTools(config);
+        return {
+            tools,
+            metadata: {
+                rootPath: config.rootPath,
+                readOnly: config.readOnly,
+                allowedExtensions: config.allowedExtensions,
+            },
+        };
+    }
+    async generateMCPServerConfigs(config) {
+        const tools = await this.discoverTools(config);
+        return [
+            {
+                name: `fs-${config.name || 'default'}`,
+                transport: 'stdio',
+                command: 'node',
+                args: ['-e', '/* MCP server for filesystem */'],
+                env: {
+                    FS_ROOT: config.rootPath || '',
+                    FS_READ_ONLY: String(config.readOnly ?? true),
+                },
+                tools,
+            },
+        ];
+    }
+}
+exports.FileSystemAdapter = FileSystemAdapter;

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

@@ -0,0 +1,29 @@
+/**
+ * HTTP API 适配器
+ *
+ * 支持 manual（手动定义端点）和 openapi（从 OpenAPI spec 解析）两种模式。
+ * testConnection 尝试请求 baseUrl，discoverTools 将端点转为工具定义。
+ */
+import type { DataSourceConfig, DiscoveredTool, ConnectionTestResult, DataSourceAdapter, MCPServerConfig } from './types';
+export declare class HTTPAPIAdapter implements DataSourceAdapter {
+    readonly type: "http-api";
+    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
+    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
+    generateManifest(config: DataSourceConfig): Promise<{
+        tools: DiscoveredTool[];
+        metadata: {
+            apiMode: "manual" | "openapi";
+            serviceCount: number;
+            endpointCount: number;
+        };
+    }>;
+    generateMCPServerConfigs(config: DataSourceConfig): Promise<MCPServerConfig[]>;
+    /** 收集所有端点 */
+    private collectEndpoints;
+    /** 解析 OpenAPI spec */
+    private parseOpenAPI;
+    /** 构建请求头 */
+    private buildHeaders;
+    /** 将端点名转为合法工具名 */
+    private sanitizeToolName;
+}