@loop_ouroboros/mcp-hub-lite 1.1.1 → 1.2.0

package/dist/server/src/cli/commands/mcp-tool-use.js

@@ -0,0 +1,174 @@
+import { Command } from 'commander';
+import { getServerStatus } from '../server.js';
+/**
+ * CLI command for dynamic MCP server tool operations via API.
+ *
+ * This command provides a simplified CLI interface for interacting with MCP server tools,
+ * supporting four actions: list-servers, list-tools, get-tool, and call-tool. It wraps
+ * the HTTP API endpoints and requires the MCP Hub Lite server to be running.
+ *
+ * ## Command Format
+ *
+ * ```
+ * mcp-tool-use <serverName> <action> [toolName] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * Or via npm:
+ * ```
+ * npm run tool-use <serverName> <action> [toolName] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * ## Supported Actions
+ *
+ * - `list-servers` - List all connected MCP servers
+ * - `list-tools` - List all tools from the specified server
+ * - `get-tool <toolName>` - Get complete schema for a specific tool
+ * - `call-tool <toolName>` - Call a tool on the specified server
+ *
+ * ## Options
+ *
+ * - `--args <json>` - JSON string of tool arguments (for call-tool action)
+ * - `--tags <json>` - JSON object of instance selection tags (call-tool only, for multi-instance servers)
+ *
+ * ## Usage Examples
+ *
+ * ```bash
+ * # List all connected servers
+ * mcp-hub-lite mcp-tool-use mcp-hub-lite list-servers
+ *
+ * # List all tools from a specific server
+ * mcp-hub-lite mcp-tool-use mcp-hub-lite list-tools
+ *
+ * # Get tool schema
+ * mcp-hub-lite mcp-tool-use mcp-hub-lite get-tool list_tools
+ *
+ * # Call a tool with arguments
+ * mcp-hub-lite mcp-tool-use mcp-hub-lite call-tool list_tools --args '{"serverName":"mcp-hub-lite"}'
+ *
+ * # Call a tool with tags for multi-instance selection
+ * mcp-hub-lite mcp-tool-use baidu-search call-tool search --args '{"query":"天气"}' --tags '{"env":"prod"}'
+ * ```
+ *
+ * ## Error Handling
+ *
+ * - Exits with code 1 if the server is not running
+ * - Exits with code 1 if action is unknown
+ * - Exits with code 1 if toolName is required but not provided
+ * - Exits with code 1 if JSON parsing fails for --args or --tags
+ * - Exits with code 1 if the underlying API call fails
+ *
+ * @returns {Command} The configured mcp-tool-use command instance for registration with Commander.js
+ */
+export const mcpToolUseCommand = new Command('tool-use')
+    .description('Manage MCP server tools via API (list-servers, list-tools, get-tool, call-tool)')
+    .argument('<serverName>', 'Server name to target (use "mcp-hub-lite" for system tools)')
+    .argument('<action>', 'Action: list-servers, list-tools, get-tool, call-tool')
+    .argument('[toolName]', 'Tool name (required for get-tool and call-tool actions)')
+    .option('--args <json>', 'JSON string of tool arguments (call-tool only)')
+    .option('--tags <json>', 'JSON object of instance selection tags (call-tool only, for multi-instance servers)')
+    .action(async (serverName, action, toolName, options) => {
+    try {
+        // Check if server is running and get connection info
+        const status = await getServerStatus();
+        if (!status.running) {
+            console.error('Error: MCP Hub Lite server is not running.');
+            console.error('Start the server with: mcp-hub-lite start');
+            process.exit(1);
+        }
+        const baseUrl = `http://${status.host}:${status.port}`;
+        switch (action) {
+            case 'list-servers': {
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers`, {
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) {
+                    throw new Error(`API error: ${response.status} ${response.statusText}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'list-tools': {
+                const tagsParam = options.tags ? `?tags=${encodeURIComponent(options.tags)}` : '';
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${serverName}/tools${tagsParam}`, {
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'get-tool': {
+                if (!toolName) {
+                    console.error('Error: toolName is required for get-tool action');
+                    process.exit(1);
+                }
+                const tagsParam = options.tags ? `?tags=${encodeURIComponent(options.tags)}` : '';
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${serverName}/tools/${toolName}${tagsParam}`, { headers: { Accept: 'application/json' } });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'call-tool': {
+                if (!toolName) {
+                    console.error('Error: toolName is required for call-tool action');
+                    process.exit(1);
+                }
+                // Parse tool arguments
+                let toolArgs = {};
+                if (options.args) {
+                    try {
+                        toolArgs = JSON.parse(options.args);
+                    }
+                    catch {
+                        console.error('Error: Invalid JSON in --args option');
+                        process.exit(1);
+                    }
+                }
+                // Parse tags for instance selection (call-tool only)
+                let requestOptions;
+                if (options.tags) {
+                    try {
+                        requestOptions = { tags: JSON.parse(options.tags) };
+                    }
+                    catch {
+                        console.error('Error: Invalid JSON in --tags option');
+                        process.exit(1);
+                    }
+                }
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${serverName}/tools/${toolName}/call`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json'
+                    },
+                    body: JSON.stringify({ toolArgs, requestOptions })
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            default: {
+                console.error(`Unknown action: ${action}`);
+                console.error('Valid actions: list-servers, list-tools, get-tool, call-tool');
+                process.exit(1);
+            }
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});

package/dist/server/src/cli/commands/tool-use.d.ts

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+/**
+ * CLI command for dynamic MCP server tool operations via API.
+ *
+ * This command provides a simplified CLI interface for interacting with MCP server tools,
+ * supporting four actions: list-servers, list-tools, get-tool, and call-tool. It wraps
+ * the HTTP API endpoints and requires the MCP Hub Lite server to be running.
+ *
+ * ## Command Format
+ *
+ * ```
+ * mcp-hub-lite tool-use <action> [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * Or via npm:
+ * ```
+ * npm run tool-use -- <action> [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * ## Supported Actions
+ *
+ * - `list-servers` - List all connected MCP servers
+ * - `list-tools` - List all tools from the specified server
+ * - `get-tool` - Get complete schema for a specific tool (requires --tool)
+ * - `call-tool` - Call a tool on the specified server (requires --tool)
+ *
+ * ## Options
+ *
+ * - `--server <serverName>` - Server name to target (use "mcp-hub-lite" for system tools)
+ * - `--tool <toolName>` - Tool name (required for get-tool and call-tool actions)
+ * - `--args <json>` - JSON string of tool arguments, or combined JSON with server/tool/args fields
+ * - `--tags <json>` - JSON object of instance selection tags (call-tool only, for multi-instance servers)
+ *
+ * ## JSON Merge Logic
+ *
+ * When `--args` contains `server`, `tool`, or `args` fields, they are extracted and merged:
+ * - `server` field → effective server name
+ * - `tool` field → effective tool name
+ * - `args` field → tool arguments
+ * - Other fields → treated as tool arguments
+ *
+ * This allows passing all parameters in a single JSON object via --args.
+ *
+ * ## Usage Examples
+ *
+ * ###分散参数形式 (Separate Arguments):
+ *
+ * ```bash
+ * # List all connected servers
+ * mcp-hub-lite tool-use list-servers
+ *
+ * # List system tools
+ * mcp-hub-lite tool-use list-tools --server mcp-hub-lite
+ *
+ * # List third-party server tools
+ * mcp-hub-lite tool-use list-tools --server baidu-search
+ *
+ * # Get system tool schema
+ * mcp-hub-lite tool-use get-tool --tool list_tools --server mcp-hub-lite
+ *
+ * # Call system tool
+ * mcp-hub-lite tool-use call-tool --tool list_tools --server mcp-hub-lite --args '{}'
+ *
+ * # Call third-party server tool
+ * mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"天气"}'
+ *
+ * # Multi-instance server with tags
+ * mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"test"}' --tags '{"env":"prod"}'
+ * ```
+ *
+ * ### JSON 合并形式 (JSON Merge):
+ *
+ * ```bash
+ * # All parameters in one JSON
+ * mcp-hub-lite tool-use call-tool --args '{"server":"baidu-search","tool":"search","query":"天气"}'
+ *
+ * # System tool example
+ * mcp-hub-lite tool-use call-tool --args '{"server":"mcp-hub-lite","tool":"list_tools"}'
+ *
+ * # Equivalent to
+ * mcp-hub-lite tool-use call-tool --server baidu-search --tool search --args '{"query":"天气"}'
+ * ```
+ *
+ * ## Error Handling
+ *
+ * - Exits with code 1 if the server is not running
+ * - Exits with code 1 if action is unknown
+ * - Exits with code 1 if toolName is required but not provided
+ * - Exits with code 1 if JSON parsing fails for --args or --tags
+ * - Exits with code 1 if the underlying API call fails
+ *
+ * @returns {Command} The configured mcp-tool-use command instance for registration with Commander.js
+ */
+export declare const toolUseCommand: Command;
+//# sourceMappingURL=tool-use.d.ts.map

package/dist/server/src/cli/commands/tool-use.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-use.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/tool-use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,eAAO,MAAM,cAAc,SAwLvB,CAAC"}

package/dist/server/src/cli/commands/tool-use.js

@@ -0,0 +1,255 @@
+import { Command } from 'commander';
+import { getServerStatus } from '../server.js';
+/**
+ * CLI command for dynamic MCP server tool operations via API.
+ *
+ * This command provides a simplified CLI interface for interacting with MCP server tools,
+ * supporting four actions: list-servers, list-tools, get-tool, and call-tool. It wraps
+ * the HTTP API endpoints and requires the MCP Hub Lite server to be running.
+ *
+ * ## Command Format
+ *
+ * ```
+ * mcp-hub-lite tool-use <action> [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * Or via npm:
+ * ```
+ * npm run tool-use -- <action> [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * ## Supported Actions
+ *
+ * - `list-servers` - List all connected MCP servers
+ * - `list-tools` - List all tools from the specified server
+ * - `get-tool` - Get complete schema for a specific tool (requires --tool)
+ * - `call-tool` - Call a tool on the specified server (requires --tool)
+ *
+ * ## Options
+ *
+ * - `--server <serverName>` - Server name to target (use "mcp-hub-lite" for system tools)
+ * - `--tool <toolName>` - Tool name (required for get-tool and call-tool actions)
+ * - `--args <json>` - JSON string of tool arguments, or combined JSON with server/tool/args fields
+ * - `--tags <json>` - JSON object of instance selection tags (call-tool only, for multi-instance servers)
+ *
+ * ## JSON Merge Logic
+ *
+ * When `--args` contains `server`, `tool`, or `args` fields, they are extracted and merged:
+ * - `server` field → effective server name
+ * - `tool` field → effective tool name
+ * - `args` field → tool arguments
+ * - Other fields → treated as tool arguments
+ *
+ * This allows passing all parameters in a single JSON object via --args.
+ *
+ * ## Usage Examples
+ *
+ * ###分散参数形式 (Separate Arguments):
+ *
+ * ```bash
+ * # List all connected servers
+ * mcp-hub-lite tool-use list-servers
+ *
+ * # List system tools
+ * mcp-hub-lite tool-use list-tools --server mcp-hub-lite
+ *
+ * # List third-party server tools
+ * mcp-hub-lite tool-use list-tools --server baidu-search
+ *
+ * # Get system tool schema
+ * mcp-hub-lite tool-use get-tool --tool list_tools --server mcp-hub-lite
+ *
+ * # Call system tool
+ * mcp-hub-lite tool-use call-tool --tool list_tools --server mcp-hub-lite --args '{}'
+ *
+ * # Call third-party server tool
+ * mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"天气"}'
+ *
+ * # Multi-instance server with tags
+ * mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"test"}' --tags '{"env":"prod"}'
+ * ```
+ *
+ * ### JSON 合并形式 (JSON Merge):
+ *
+ * ```bash
+ * # All parameters in one JSON
+ * mcp-hub-lite tool-use call-tool --args '{"server":"baidu-search","tool":"search","query":"天气"}'
+ *
+ * # System tool example
+ * mcp-hub-lite tool-use call-tool --args '{"server":"mcp-hub-lite","tool":"list_tools"}'
+ *
+ * # Equivalent to
+ * mcp-hub-lite tool-use call-tool --server baidu-search --tool search --args '{"query":"天气"}'
+ * ```
+ *
+ * ## Error Handling
+ *
+ * - Exits with code 1 if the server is not running
+ * - Exits with code 1 if action is unknown
+ * - Exits with code 1 if toolName is required but not provided
+ * - Exits with code 1 if JSON parsing fails for --args or --tags
+ * - Exits with code 1 if the underlying API call fails
+ *
+ * @returns {Command} The configured mcp-tool-use command instance for registration with Commander.js
+ */
+export const toolUseCommand = new Command('tool-use')
+    .description('Manage MCP server tools via API (list-servers, list-tools, get-tool, call-tool)')
+    .argument('<action>', 'Action: list-servers, list-tools, get-tool, call-tool')
+    .option('--server <serverName>', 'Server name to target (omit or empty for system tools)')
+    .option('--tool <toolName>', 'Tool name (required for get-tool and call-tool actions)')
+    .option('--args <json>', 'JSON string of tool arguments, or combined JSON with server/tool/args fields')
+    .option('--tags <json>', 'JSON object of instance selection tags (call-tool only, for multi-instance servers)')
+    .addHelpText('after', `
+
+Examples:
+  # List all connected servers
+  mcp-hub-lite tool-use list-servers
+
+  # List mcp-hub-lite system tools (default)
+  mcp-hub-lite tool-use list-tools
+
+  # List third-party server tools
+  mcp-hub-lite tool-use list-tools --server baidu-search
+
+  # Get system tool schema
+  mcp-hub-lite tool-use get-tool --tool list_tools
+
+  # Call third-party server tool
+  mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"天气"}'
+
+  # JSON merge form (all params in one JSON)
+  mcp-hub-lite tool-use call-tool --args '{"server":"baidu-search","tool":"search","query":"天气"}'
+`)
+    .action(async (action, options) => {
+    try {
+        // Check if server is running and get connection info
+        const status = await getServerStatus();
+        if (!status.running) {
+            console.error('Error: MCP Hub Lite server is not running.');
+            console.error('Start the server with: mcp-hub-lite start');
+            process.exit(1);
+        }
+        // Parse JSON merge logic: extract server, tool, and args from --args if present
+        let toolArgs = {};
+        // When --server is not provided, default to mcp-hub-lite (system tools)
+        const defaultServer = 'mcp-hub-lite';
+        let effectiveServer = options.server || defaultServer;
+        let effectiveTool = options.tool ?? '';
+        if (options.args) {
+            try {
+                const parsedArgs = JSON.parse(options.args);
+                // Extract server and tool from JSON if present
+                if (parsedArgs.server !== undefined) {
+                    effectiveServer = parsedArgs.server;
+                }
+                if (parsedArgs.tool !== undefined) {
+                    effectiveTool = parsedArgs.tool;
+                }
+                // Extract args if present, otherwise treat other fields as tool args
+                if (parsedArgs.args !== undefined) {
+                    toolArgs = parsedArgs.args;
+                }
+                else {
+                    // Other fields (excluding server and tool) are treated as tool args
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { server: _server, tool: _tool, ...rest } = parsedArgs;
+                    toolArgs = rest;
+                }
+            }
+            catch {
+                // If JSON parsing fails, treat the entire content as tool args
+                try {
+                    toolArgs = JSON.parse(options.args);
+                }
+                catch {
+                    console.error('Error: Invalid JSON in --args option');
+                    process.exit(1);
+                }
+            }
+        }
+        const baseUrl = `http://${status.host}:${status.port}`;
+        switch (action) {
+            case 'list-servers': {
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers`, {
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) {
+                    throw new Error(`API error: ${response.status} ${response.statusText}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'list-tools': {
+                const tagsParam = options.tags ? `?tags=${encodeURIComponent(options.tags)}` : '';
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${effectiveServer}/tools${tagsParam}`, {
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'get-tool': {
+                if (!effectiveTool) {
+                    console.error('Error: toolName is required for get-tool action');
+                    process.exit(1);
+                }
+                const tagsParam = options.tags ? `?tags=${encodeURIComponent(options.tags)}` : '';
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${effectiveServer}/tools/${effectiveTool}${tagsParam}`, { headers: { Accept: 'application/json' } });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'call-tool': {
+                if (!effectiveTool) {
+                    console.error('Error: toolName is required for call-tool action');
+                    process.exit(1);
+                }
+                // Parse tags for instance selection (call-tool only)
+                let requestOptions;
+                if (options.tags) {
+                    try {
+                        requestOptions = { tags: JSON.parse(options.tags) };
+                    }
+                    catch {
+                        console.error('Error: Invalid JSON in --tags option');
+                        process.exit(1);
+                    }
+                }
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${effectiveServer}/tools/${effectiveTool}/call`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json'
+                    },
+                    body: JSON.stringify({ toolArgs, requestOptions })
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            default: {
+                console.error(`Unknown action: ${action}`);
+                console.error('Valid actions: list-servers, list-tools, get-tool, call-tool');
+                process.exit(1);
+            }
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});

package/dist/server/src/cli/index.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * MCP Hub Lite CLI Entry Point
- * Implements 6 core commands: start, stop, status, ui, list, restart
+ * Implements 7 core commands: start, stop, status, ui, list, restart, tool-use
  */
 import { Command } from 'commander';
 /**
@@ -11,13 +11,14 @@ import { Command } from 'commander';
  * then registers all available commands to provide a complete command-line interface
  * for managing the MCP Hub Lite service.
  *
- * The CLI provides six core commands:
+ * The CLI provides seven core commands:
  * - start: Launches the MCP Hub Lite service in daemon or foreground mode
  * - stop: Gracefully terminates the running service instance
  * - status: Displays current service status including PID, port, host, and server count
  * - ui: Opens the web-based user interface in the default browser
  * - list: Shows all configured MCP servers in a tabular format
  * - restart: Stops and restarts the service with the same configuration
+ * - tool-use: Manage MCP server tools via API (list-servers, list-tools, get-tool, call-tool)
  *
  * Usage examples:
  * ```bash
@@ -57,6 +58,7 @@ import { Command } from 'commander';
  * @see {@link uiCommand} - Implementation of the ui command
  * @see {@link listCommand} - Implementation of the list command
  * @see {@link restartCommand} - Implementation of the restart command
+ * @see {@link toolUseCommand} - Implementation of the tool-use command
  */
 export declare function createCli(): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/server/src/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAiBnC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8CpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAkBnC"}

package/dist/server/src/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * MCP Hub Lite CLI Entry Point
- * Implements 6 core commands: start, stop, status, ui, list, restart
+ * Implements 7 core commands: start, stop, status, ui, list, restart, tool-use
  */
 import { Command } from 'commander';
 import { argv } from 'node:process';
@@ -13,6 +13,35 @@ import { statusCommand } from './commands/status.js';
 import { uiCommand } from './commands/ui.js';
 import { listCommand } from './commands/list.js';
 import { restartCommand } from './commands/restart.js';
+import { toolUseCommand } from './commands/tool-use.js';
+/**
+ * Check if the CLI is being executed directly (vs imported as module)
+ * Handles Windows/npm symlink path resolution issues by comparing package paths
+ */
+function isCliEntry() {
+    if (!argv[1]) {
+        return false;
+    }
+    const currentUrl = import.meta.url;
+    const argvUrl = pathToFileURL(argv[1]).href;
+    // Extract pathname and normalize for comparison
+    const normalizePath = (url) => {
+        // Convert file:// URL to pathname and normalize separators
+        const urlObj = new URL(url);
+        return urlObj.pathname.replace(/\//g, '/');
+    };
+    const currentPath = normalizePath(currentUrl);
+    const argvPath = normalizePath(argvUrl);
+    // Extract package path suffix for comparison
+    // Both paths contain mcp-hub-lite/dist, extract that common suffix
+    const getPackagePath = (path) => {
+        const match = path.match(/mcp-hub-lite[\/\\]dist/);
+        return match ? match[0] : null;
+    };
+    const currentPackagePath = getPackagePath(currentPath);
+    const argvPackagePath = getPackagePath(argvPath);
+    return currentPackagePath !== null && currentPackagePath === argvPackagePath;
+}
 /**
  * Creates and configures the CLI application using Commander.js
  *
@@ -20,13 +49,14 @@ import { restartCommand } from './commands/restart.js';
  * then registers all available commands to provide a complete command-line interface
  * for managing the MCP Hub Lite service.
  *
- * The CLI provides six core commands:
+ * The CLI provides seven core commands:
  * - start: Launches the MCP Hub Lite service in daemon or foreground mode
  * - stop: Gracefully terminates the running service instance
  * - status: Displays current service status including PID, port, host, and server count
  * - ui: Opens the web-based user interface in the default browser
  * - list: Shows all configured MCP servers in a tabular format
  * - restart: Stops and restarts the service with the same configuration
+ * - tool-use: Manage MCP server tools via API (list-servers, list-tools, get-tool, call-tool)
  *
  * Usage examples:
  * ```bash
@@ -66,6 +96,7 @@ import { restartCommand } from './commands/restart.js';
  * @see {@link uiCommand} - Implementation of the ui command
  * @see {@link listCommand} - Implementation of the list command
  * @see {@link restartCommand} - Implementation of the restart command
+ * @see {@link toolUseCommand} - Implementation of the tool-use command
  */
 export function createCli() {
     const program = new Command();
@@ -80,10 +111,11 @@ export function createCli() {
     program.addCommand(uiCommand);
     program.addCommand(listCommand);
     program.addCommand(restartCommand);
+    program.addCommand(toolUseCommand);
     return program;
 }
 // Execute the CLI if this file is run directly
-if (argv[1] && pathToFileURL(argv[1]).href === import.meta.url) {
+if (isCliEntry()) {
     const cli = createCli();
     cli.parse();
 }

package/dist/server/src/config/config-loader.js

@@ -27,7 +27,7 @@ import { reassignServerInstanceIndexes } from './server-config-manager.js';
 export function loadConfig(configPath, autoMigrate = true) {
     try {
         if (fs.existsSync(configPath)) {
-            logger.info(`Loading configuration from: ${configPath}`, LOG_MODULES.CONFIG_MANAGER);
+            logger.debug(`Loading configuration from: ${configPath}`, LOG_MODULES.CONFIG_MANAGER);
             const content = fs.readFileSync(configPath, 'utf-8');
             let config = JSON.parse(content);
             // Check if automatic migration is enabled and config is legacy v1.0

package/dist/server/src/config/config-manager.js

@@ -46,7 +46,7 @@ export class ConfigManager {
             configPath ||
                 process.env.MCP_HUB_CONFIG_PATH ||
                 path.join(os.homedir(), '.mcp-hub-lite', 'config', '.mcp-hub.json');
-        logger.info(`Using config file: ${this.configPath}`, LOG_MODULES.CONFIG_MANAGER);
+        logger.debug(`Using config file: ${this.configPath}`, LOG_MODULES.CONFIG_MANAGER);
         this.config = loadConfig(this.configPath, true);
     }
     /**