giga-code
Version:
A personal AI CLI assistant powered by Grok for local development.
193 lines • 7.41 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.McpManager = void 0;
const mcp_client_1 = require("./mcp-client");
const http_mcp_manager_1 = require("./http-mcp-manager");
const added_mcp_servers_1 = require("../utils/added-mcp-servers");
class McpManager {
constructor() {
this.clients = new Map();
this.httpManager = http_mcp_manager_1.HttpMcpManager.getInstance();
}
static getInstance() {
if (!McpManager.instance) {
McpManager.instance = new McpManager();
}
return McpManager.instance;
}
async initializeAllServers() {
const servers = (0, added_mcp_servers_1.getEnabledMcpServers)(); // Only connect to enabled servers
// Start HTTP servers first
await this.httpManager.startAllHttpServers();
// Connect to all servers, but don't fail if some connections fail
const connectionPromises = servers.map(server => this.connectToServer(server));
const results = await Promise.allSettled(connectionPromises);
results.forEach((result, index) => {
if (result.status === 'rejected') {
}
});
}
async connectToServer(server) {
if (!server.enabled) {
throw new Error(`Server ${server.name} is disabled`);
}
const existingClient = this.clients.get(server.name);
if (existingClient && existingClient.isConnectedToServer()) {
return existingClient;
}
let client;
if (server.type === 'http') {
// For HTTP servers, get the client from HTTP manager
const httpClient = this.httpManager.getHttpClient(server.name);
if (httpClient && httpClient.isConnectedToServer()) {
this.clients.set(server.name, httpClient);
return httpClient;
}
// Start HTTP server if not already running
client = await this.httpManager.startHttpServer(server);
}
else {
// Process-based server
client = new mcp_client_1.McpClient(server);
await client.connect();
}
this.clients.set(server.name, client);
return client;
}
async disconnectFromServer(serverName) {
const client = this.clients.get(serverName);
if (client) {
await client.disconnect();
this.clients.delete(serverName);
// Also stop HTTP server if it's an HTTP server
if (this.httpManager.isServerRunning(serverName)) {
await this.httpManager.stopHttpServer(serverName);
}
}
}
async disconnectAll() {
const disconnectPromises = Array.from(this.clients.keys()).map(serverName => this.disconnectFromServer(serverName));
await Promise.all(disconnectPromises);
// Stop all HTTP servers
await this.httpManager.stopAllHttpServers();
}
getAllTools() {
const tools = [];
for (const [serverName, client] of this.clients) {
if (client.isConnectedToServer()) {
const serverTools = client.getTools();
serverTools.forEach(tool => {
tools.push({
...tool,
serverName,
});
});
}
}
return tools;
}
getToolsByServer(serverName) {
const client = this.clients.get(serverName);
if (client && client.isConnectedToServer()) {
return client.getTools();
}
return [];
}
async callTool(serverName, toolName, arguments_) {
const client = this.clients.get(serverName);
if (!client) {
return {
content: [{
type: 'text',
text: `MCP server '${serverName}' not found or not connected`,
}],
isError: true,
};
}
if (!client.isConnectedToServer()) {
return {
content: [{
type: 'text',
text: `MCP server '${serverName}' is not connected`,
}],
isError: true,
};
}
return await client.callTool(toolName, arguments_);
}
findToolByName(toolName) {
const allTools = this.getAllTools();
return allTools.find(tool => tool.name === toolName) || null;
}
getConnectedServers() {
const connectedServers = [];
for (const [serverName, client] of this.clients) {
if (client.isConnectedToServer()) {
connectedServers.push(serverName);
}
}
return connectedServers;
}
getServerInfo(serverName) {
const client = this.clients.get(serverName);
if (client && client.isConnectedToServer()) {
return client.getServerInfo();
}
return null;
}
isServerConnected(serverName) {
const client = this.clients.get(serverName);
return client ? client.isConnectedToServer() : false;
}
async refreshConnections() {
// Reload servers from storage and get enabled ones
const enabledServers = (0, added_mcp_servers_1.getEnabledMcpServers)();
const allServers = (0, added_mcp_servers_1.loadAddedMcpServers)();
const currentServers = new Set(this.clients.keys());
// Connect to enabled servers that aren't connected
const enabledServerNames = new Set(enabledServers.map(s => s.name));
const newServers = enabledServers.filter(server => !currentServers.has(server.name));
// Start HTTP servers first
await this.httpManager.startAllHttpServers();
// Connect to new enabled servers
const connectionPromises = newServers.map(server => this.connectToServer(server));
const results = await Promise.allSettled(connectionPromises);
results.forEach((result, index) => {
if (result.status === 'rejected') {
}
});
// Disconnect from servers that are disabled or no longer in the configuration
for (const serverName of currentServers) {
if (!enabledServerNames.has(serverName)) {
await this.disconnectFromServer(serverName);
}
}
}
async setServerEnabled(serverName, enabled) {
const success = (0, added_mcp_servers_1.setMcpServerEnabled)(serverName, enabled);
if (success) {
if (enabled) {
// Connect to the server if it's now enabled
const server = (0, added_mcp_servers_1.loadAddedMcpServers)().find(s => s.name === serverName);
if (server) {
try {
await this.connectToServer(server);
}
catch (error) {
}
}
}
else {
// Disconnect from the server if it's now disabled
await this.disconnectFromServer(serverName);
}
}
return success;
}
getEnabledServers() {
return (0, added_mcp_servers_1.getEnabledMcpServers)();
}
}
exports.McpManager = McpManager;
McpManager.instance = null;
//# sourceMappingURL=mcp-manager.js.map