@toolplex/client 0.1.1

package/dist/mcp-server/toolplexServer.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { ClientContext } from './clientContext.js';
+import Registry from './registry.js';
+import { PRE_INITIALIZATION_PROMPTS } from './staticPrompts.js';
+import { createToolDefinitions } from './tools.js';
+import { handleInitialize } from './toolHandlers/initHandler.js';
+import { handleSearchTool } from './toolHandlers/searchHandler.js';
+import { handleInstallServer } from './toolHandlers/installServerHandler.js';
+import { handleListTools } from './toolHandlers/listToolsHandler.js';
+import { handleListServers } from './toolHandlers/listServersHandler.js';
+import { handleCallTool } from './toolHandlers/callToolHandler.js';
+import { handleUninstallServer } from './toolHandlers/uninstallServerHandler.js';
+import { handleSavePlaybook } from './toolHandlers/savePlaybookHandler.js';
+import { handleLogPlaybookUsage } from './toolHandlers/logPlaybookUsageHandler.js';
+import { handleLookupEntityTool } from './toolHandlers/lookupEntityHandler.js';
+import { handleSubmitFeedback } from './toolHandlers/submitFeedbackHandler.js';
+import { handleGetServerConfig } from './toolHandlers/getServerConfigHandler.js';
+import { StdioServerManagerClient } from '../shared/stdioServerManagerClient.js';
+import { FileLogger } from '../shared/fileLogger.js';
+import { CallToolParamsSchema, InitializeToolplexParamsSchema, InstallParamsSchema, ListToolsParamsSchema, SearchParamsSchema, UninstallParamsSchema, SavePlaybookParamsSchema, LogPlaybookUsageParamsSchema, LookupEntityParamsSchema, SubmitFeedbackParamsSchema, GetServerConfigParamsSchema, } from '../shared/mcpServerTypes.js';
+import { version as clientVersion } from '../version.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const logger = FileLogger;
+export async function serve(config) {
+    const clientContext = new ClientContext();
+    clientContext.dev = config.dev;
+    clientContext.apiKey = config.apiKey;
+    clientContext.clientMode = config.clientMode;
+    clientContext.clientVersion = clientVersion;
+    await Registry.init(clientContext);
+    await logger.info(`Starting Toolplex server in ${config.dev ? 'development' : 'production'} mode`);
+    const server = new Server({
+        name: 'toolplex-server',
+        version: clientContext.clientVersion,
+    }, {
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+    });
+    // Initialize server manager clients
+    await logger.info('Initializing server manager clients');
+    const serverManagerClients = {
+        node: new StdioServerManagerClient('node', [path.join(__dirname, '..', 'server-manager', 'index.js')], { LOG_LEVEL: config.logLevel }),
+    };
+    // Start all server manager clients
+    await logger.info('Starting server manager clients');
+    await Promise.all(Object.values(serverManagerClients).map((client) => client.start()));
+    await logger.info('All server manager clients started successfully');
+    Registry.setServerManagerClients(serverManagerClients);
+    // List tools handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        await logger.debug('Handling list tools request');
+        return {
+            tools: createToolDefinitions(),
+        };
+    });
+    // Call tool handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: params } = request.params;
+        await logger.info(`Handling tool call request for tool: ${name}`);
+        let result;
+        if (!Registry.getToolDefinitionsCache().isInitialized()) {
+            result = {
+                role: 'system',
+                content: [
+                    {
+                        type: 'text',
+                        text: PRE_INITIALIZATION_PROMPTS.tools_initialization_error,
+                    },
+                ],
+            };
+            return result;
+        }
+        if (!clientContext.isInitialized() && name !== 'initialize_toolplex') {
+            result = {
+                role: 'system',
+                content: [
+                    {
+                        type: 'text',
+                        text: PRE_INITIALIZATION_PROMPTS.enforce_init_toolplex.replace('{TOOL_NAME}', name),
+                    },
+                ],
+            };
+            return result;
+        }
+        try {
+            switch (name) {
+                case 'initialize_toolplex': {
+                    await logger.debug('Handling initialize_toolplex request');
+                    const parsed = InitializeToolplexParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid initialize_toolplex params: ${parsed.error}`);
+                    clientContext.llmContext = parsed.data.llm_context;
+                    result = await handleInitialize(parsed.data);
+                    break;
+                }
+                case 'search': {
+                    await logger.debug('Handling search request');
+                    const parsed = SearchParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid search params: ${parsed.error}`);
+                    result = await handleSearchTool(parsed.data);
+                    break;
+                }
+                case 'install': {
+                    await logger.debug('Handling install request');
+                    const parsed = InstallParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid install params: ${parsed.error}`);
+                    result = await handleInstallServer(parsed.data);
+                    server.sendToolListChanged();
+                    break;
+                }
+                case 'list_tools': {
+                    await logger.debug('Handling list_tools request');
+                    const parsed = ListToolsParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid list_toolplex_tools params: ${parsed.error}`);
+                    result = await handleListTools(parsed.data);
+                    break;
+                }
+                case 'list_servers': {
+                    await logger.debug('Handling list_toolplex_tools request');
+                    result = await handleListServers();
+                    break;
+                }
+                case 'call_tool': {
+                    await logger.debug('Handling call_tool request');
+                    const parsed = CallToolParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid call_tool params: ${parsed.error}`);
+                    result = await handleCallTool(parsed.data);
+                    break;
+                }
+                case 'uninstall': {
+                    await logger.debug('Handling uninstall request');
+                    const parsed = UninstallParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid uninstall params: ${parsed.error}`);
+                    result = await handleUninstallServer(parsed.data);
+                    break;
+                }
+                case 'save_playbook': {
+                    await logger.debug('Handling save_playbook request');
+                    const parsed = SavePlaybookParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid save_playbook params: ${parsed.error}`);
+                    if (!clientContext.isInitialized())
+                        throw new Error(`ToolPlex is not initialized`);
+                    result = await handleSavePlaybook(parsed.data);
+                    break;
+                }
+                case 'log_playbook_usage': {
+                    await logger.debug('Handling log_playbook_usage request');
+                    const parsed = LogPlaybookUsageParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid log_playbook_usage params: ${parsed.error}`);
+                    if (!clientContext.isInitialized())
+                        throw new Error(`ToolPlex is not initialized`);
+                    result = await handleLogPlaybookUsage(parsed.data);
+                    break;
+                }
+                case 'lookup_entity': {
+                    await logger.debug('Handling lookup_entity request');
+                    const parsed = LookupEntityParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid lookup_entity params: ${parsed.error}`);
+                    result = await handleLookupEntityTool(parsed.data);
+                    break;
+                }
+                case 'submit_feedback': {
+                    await logger.debug('Handling submit_feedback request');
+                    const parsed = SubmitFeedbackParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid submit_feedback params: ${parsed.error}`);
+                    if (!clientContext.isInitialized())
+                        throw new Error(`ToolPlex is not initialized`);
+                    result = await handleSubmitFeedback(parsed.data);
+                    break;
+                }
+                // Add get_server_config tool handler
+                case 'get_server_config': {
+                    await logger.debug('Handling get_server_config request');
+                    const parsed = GetServerConfigParamsSchema.safeParse(params);
+                    if (!parsed.success)
+                        throw new Error(`Invalid get_server_config params: ${parsed.error}`);
+                    result = await handleGetServerConfig(parsed.data);
+                    break;
+                }
+                default:
+                    await logger.warn(`Unknown tool requested: ${name}`);
+                    result = {
+                        role: 'system',
+                        content: [
+                            {
+                                type: 'text',
+                                text: PRE_INITIALIZATION_PROMPTS.unknown_tool.replace('{TOOL_NAME}', name),
+                            },
+                        ],
+                    };
+            }
+        }
+        catch (error) {
+            let errorMessage = 'Unknown error occurred';
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            await logger.error(`Error calling ToolPlex: ${errorMessage}`);
+            result = {
+                role: 'system',
+                content: [
+                    {
+                        type: 'text',
+                        text: PRE_INITIALIZATION_PROMPTS.unexpected_error.replace('{ERROR}', errorMessage),
+                    },
+                ],
+            };
+        }
+        return result;
+    });
+    const transport = new StdioServerTransport();
+    await logger.info('Connecting server transport');
+    await server.connect(transport);
+    await logger.info('Server transport connected successfully');
+    // Clean up on process exit
+    process.on('exit', async () => {
+        await logger.info('Process exit - stopping server manager clients');
+        await logger.flush();
+        Object.values(serverManagerClients).forEach((client) => client.stop());
+    });
+    process.on('SIGINT', async () => {
+        await logger.warn('SIGINT received - stopping server manager clients');
+        await logger.flush();
+        Object.values(serverManagerClients).forEach((client) => client.stop());
+        process.exit();
+    });
+    process.on('SIGTERM', async () => {
+        await logger.warn('SIGTERM received - stopping server manager clients');
+        await logger.flush();
+        Object.values(serverManagerClients).forEach((client) => client.stop());
+        process.exit();
+    });
+}

package/dist/mcp-server/tools.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare function createToolDefinitions(): Tool[];

package/dist/mcp-server/tools.js

@@ -0,0 +1,13 @@
+import Registry from './registry.js';
+export function createToolDefinitions() {
+    const toolDefinitionsCache = Registry.getToolDefinitionsCache();
+    if (!toolDefinitionsCache.isInitialized()) {
+        return [
+            {
+                name: 'initialize_toolplex',
+                inputSchema: { type: 'object', properties: {}, required: [] },
+            },
+        ];
+    }
+    return toolDefinitionsCache.getTools();
+}

package/dist/mcp-server/utils/initServerManagers.d.ts

@@ -0,0 +1,6 @@
+import { StdioServerManagerClient } from '../../shared/stdioServerManagerClient.js';
+import { InitializeResult } from '../../shared/serverManagerTypes.js';
+export declare function initServerManagersOnly(serverManagerClients: Record<string, StdioServerManagerClient>): Promise<{
+    succeeded: InitializeResult['succeeded'];
+    failures: InitializeResult['failures'];
+}>;

package/dist/mcp-server/utils/initServerManagers.js

@@ -0,0 +1,31 @@
+import { InitializeResultSchema } from '../../shared/serverManagerTypes.js';
+import { FileLogger } from '../../shared/fileLogger.js';
+const logger = FileLogger;
+export async function initServerManagersOnly(serverManagerClients) {
+    await logger.info('Pre-warming server manager clients');
+    const initPromises = Object.entries(serverManagerClients).map(async ([runtime, client]) => {
+        try {
+            const response = await client.sendRequest('initialize', {});
+            if ('error' in response)
+                throw new Error(response.error.message);
+            const parsed = InitializeResultSchema.safeParse(response);
+            if (!parsed.success)
+                throw new Error(parsed.error.message);
+            return { runtime, result: parsed.data };
+        }
+        catch (err) {
+            await logger.error(`Warmup error for ${runtime}: ${err}`);
+            return { runtime, result: { succeeded: [], failures: {} } };
+        }
+    });
+    const results = await Promise.all(initPromises);
+    const allSucceeded = [];
+    const allFailures = {};
+    for (const { runtime, result } of results) {
+        allSucceeded.push(...(result.succeeded || []));
+        Object.assign(allFailures, result.failures || {});
+        await logger.debug(`Warmup result for ${runtime}: ${JSON.stringify(result)}`);
+    }
+    await logger.debug(`Warmup completed: ${allSucceeded.length} successes, ${Object.keys(allFailures).length} failures`);
+    return { succeeded: allSucceeded, failures: allFailures };
+}

package/dist/mcp-server/utils/resultAnnotators.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Annotate a server object with "(installed)" in the server_name or set installed: true,
+ * if the server is installed according to the provided serversCache.
+ *
+ * This is used in both searchHandler and lookupEntityHandler.
+ *
+ * @param server - The server object to annotate (should have server_id and optionally server_name)
+ * @param serversCache - The ServersCache instance with isInstalled(server_id) method
+ * @returns The annotated server object (may be the same object if not installed)
+ */
+export declare function annotateInstalledServer(server: any, serversCache: {
+    isInstalled: (id: string) => boolean;
+}): any;
+/**
+ * Annotate an array of server objects with installed status.
+ *
+ * @param servers - Array of server objects
+ * @param serversCache - The ServersCache instance
+ * @returns Annotated array of server objects
+ */
+export declare function annotateInstalledServers(servers: any[], serversCache: {
+    isInstalled: (id: string) => boolean;
+}): any[];

package/dist/mcp-server/utils/resultAnnotators.js

@@ -0,0 +1,50 @@
+/**
+ * Annotate a server object with "(installed)" in the server_name or set installed: true,
+ * if the server is installed according to the provided serversCache.
+ *
+ * This is used in both searchHandler and lookupEntityHandler.
+ *
+ * @param server - The server object to annotate (should have server_id and optionally server_name)
+ * @param serversCache - The ServersCache instance with isInstalled(server_id) method
+ * @returns The annotated server object (may be the same object if not installed)
+ */
+export function annotateInstalledServer(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+server, serversCache
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!server || typeof server !== 'object' || !server.server_id) {
+        return server;
+    }
+    if (serversCache.isInstalled(server.server_id)) {
+        if (server.server_name) {
+            return {
+                ...server,
+                server_name: `${server.server_name} (installed)`,
+            };
+        }
+        else {
+            return {
+                ...server,
+                installed: true,
+            };
+        }
+    }
+    return server;
+}
+/**
+ * Annotate an array of server objects with installed status.
+ *
+ * @param servers - Array of server objects
+ * @param serversCache - The ServersCache instance
+ * @returns Annotated array of server objects
+ */
+export function annotateInstalledServers(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+servers, serversCache
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!Array.isArray(servers))
+        return [];
+    return servers.map((server) => annotateInstalledServer(server, serversCache));
+}

package/dist/mcp-server/utils/runtimeCheck.d.ts

@@ -0,0 +1,4 @@
+export declare class RuntimeCheck {
+    static validateCommandOrThrow(rawCommand: string): void;
+    static extractCommandName(command: string): string;
+}

package/dist/mcp-server/utils/runtimeCheck.js

@@ -0,0 +1,30 @@
+import { getEnhancedPath } from '../../shared/enhancedPath.js';
+import which from 'which';
+const INSTALL_HINTS = {
+    uvx: 'Install uvx: https://docs.astral.sh/uv/getting-started/installation/',
+    uv: 'Install uv: https://docs.astral.sh/uv/getting-started/installation/',
+    python: 'Install Python: https://www.python.org/downloads/. Or check if you have `python3` installed.',
+    python3: 'Install Python: https://www.python.org/downloads/. Or check if you have `python` installed.',
+    node: 'Install Node.js: https://nodejs.org/en/download/',
+    npx: 'Install npx (comes with Node.js): https://nodejs.org/en/download/',
+};
+export class RuntimeCheck {
+    static validateCommandOrThrow(rawCommand) {
+        const command = this.extractCommandName(rawCommand);
+        const enhancedPath = getEnhancedPath();
+        const resolved = which.sync(command, {
+            path: enhancedPath,
+            nothrow: true,
+        });
+        if (!resolved) {
+            const hint = INSTALL_HINTS[command];
+            if (hint) {
+                throw new Error(`Missing required command: '${command}'.\n👉 ${hint}`);
+            }
+            throw new Error(`Command '${command}' not found in enhanced PATH. Please install it manually or check your config.`);
+        }
+    }
+    static extractCommandName(command) {
+        return command.trim().split(/\s+/)[0];
+    }
+}

package/dist/server-manager/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server-manager/index.js

@@ -0,0 +1,8 @@
+import { ServerManagerProtocol } from './stdioServer.js';
+import { FileLogger } from '../shared/fileLogger.js';
+FileLogger.initialize('server-manager');
+const protocol = new ServerManagerProtocol();
+protocol.start().catch((error) => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});

package/dist/server-manager/serverManager.d.ts

@@ -0,0 +1,37 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ServerConfig } from '../shared/mcpServerTypes.js';
+import { InitializeResult } from '../shared/serverManagerTypes.js';
+export declare class ServerManager {
+    private sessions;
+    private tools;
+    private serverNames;
+    private configPath;
+    private config;
+    private installationPromises;
+    private configLock;
+    constructor();
+    private loadConfig;
+    private saveConfig;
+    initialize(): Promise<InitializeResult>;
+    getServerName(serverId: string): Promise<string>;
+    connectWithHandshakeTimeout(client: Client, transport: SSEClientTransport | StdioClientTransport, ms?: number): Promise<{
+        tools?: Tool[];
+    }>;
+    install(serverId: string, serverName: string, description: string, config: ServerConfig): Promise<void>;
+    private performInstall;
+    callTool(serverId: string, toolName: string, arguments_: Record<string, any>, timeout?: number): Promise<any>;
+    uninstall(serverId: string): Promise<void>;
+    removeServer(serverId: string): Promise<void>;
+    listServers(): Promise<Array<{
+        server_id: string;
+        server_name: string;
+        tool_count: number;
+        description: string;
+    }>>;
+    listTools(serverId: string): Promise<Tool[]>;
+    getServerConfig(serverId: string): Promise<ServerConfig>;
+    cleanup(): Promise<void>;
+}