@vibe-kit/grok-cli/dist/mcp/client.js

An open-source AI agent that brings the power of Grok directly into your terminal.

"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 (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MCPManager = void 0;
const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
const events_1 = require("events");
const transports_js_1 = require("./transports.js");
class MCPManager extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.clients = new Map();
        this.transports = new Map();
        this.tools = new Map();
    }
    async addServer(config) {
        try {
            // Handle legacy stdio-only configuration
            let transportConfig = config.transport;
            if (!transportConfig && config.command) {
                transportConfig = {
                    type: 'stdio',
                    command: config.command,
                    args: config.args,
                    env: config.env
                };
            }
            if (!transportConfig) {
                throw new Error('Transport configuration is required');
            }
            // Create transport
            const transport = (0, transports_js_1.createTransport)(transportConfig);
            this.transports.set(config.name, transport);
            // Create client
            const client = new index_js_1.Client({
                name: "grok-cli",
                version: "1.0.0"
            }, {
                capabilities: {
                    tools: {}
                }
            });
            this.clients.set(config.name, client);
            // Connect
            const sdkTransport = await transport.connect();
            await client.connect(sdkTransport);
            // List available tools
            const toolsResult = await client.listTools();
            // Register tools
            for (const tool of toolsResult.tools) {
                const mcpTool = {
                    name: `mcp__${config.name}__${tool.name}`,
                    description: tool.description || `Tool from ${config.name} server`,
                    inputSchema: tool.inputSchema,
                    serverName: config.name
                };
                this.tools.set(mcpTool.name, mcpTool);
            }
            this.emit('serverAdded', config.name, toolsResult.tools.length);
        }
        catch (error) {
            this.emit('serverError', config.name, error);
            throw error;
        }
    }
    async removeServer(serverName) {
        // Remove tools
        for (const [toolName, tool] of this.tools.entries()) {
            if (tool.serverName === serverName) {
                this.tools.delete(toolName);
            }
        }
        // Disconnect client
        const client = this.clients.get(serverName);
        if (client) {
            await client.close();
            this.clients.delete(serverName);
        }
        // Close transport
        const transport = this.transports.get(serverName);
        if (transport) {
            await transport.disconnect();
            this.transports.delete(serverName);
        }
        this.emit('serverRemoved', serverName);
    }
    async callTool(toolName, arguments_) {
        const tool = this.tools.get(toolName);
        if (!tool) {
            throw new Error(`Tool ${toolName} not found`);
        }
        const client = this.clients.get(tool.serverName);
        if (!client) {
            throw new Error(`Server ${tool.serverName} not connected`);
        }
        // Extract the original tool name (remove mcp__servername__ prefix)
        const originalToolName = toolName.replace(`mcp__${tool.serverName}__`, '');
        return await client.callTool({
            name: originalToolName,
            arguments: arguments_
        });
    }
    getTools() {
        return Array.from(this.tools.values());
    }
    getServers() {
        return Array.from(this.clients.keys());
    }
    async shutdown() {
        const serverNames = Array.from(this.clients.keys());
        await Promise.all(serverNames.map(name => this.removeServer(name)));
    }
    getTransportType(serverName) {
        const transport = this.transports.get(serverName);
        return transport?.getType();
    }
    async ensureServersInitialized() {
        if (this.clients.size > 0) {
            return; // Already initialized
        }
        const { loadMCPConfig } = await Promise.resolve().then(() => __importStar(require('../mcp/config')));
        const config = loadMCPConfig();
        for (const serverConfig of config.servers) {
            try {
                await this.addServer(serverConfig);
            }
            catch (error) {
                console.warn(`Failed to initialize MCP server ${serverConfig.name}:`, error);
            }
        }
    }
}
exports.MCPManager = MCPManager;
//# sourceMappingURL=client.js.map