@loop_ouroboros/mcp-hub-lite 1.2.9 → 1.3.1

package/dist/server/src/api/web/search.d.ts

@@ -1,23 +1,9 @@
 import { FastifyInstance } from 'fastify';
-import type { ServerConfig } from '../../config/config-manager.js';
-/**
- * Filters tools by aggregatedTools configuration.
- * Only includes tools from servers that have aggregatedTools configured
- * AND the tool is in that list.
- */
-export declare function filterByAggregatedTools(tools: Array<{
-    name: string;
-    description?: string;
-    serverName: string;
-}>, getServerConfig: (name: string) => ServerConfig | undefined): Array<{
-    name: string;
-    description?: string;
-    serverName: string;
-}>;
 /**
  * Tool Search API Routes
  *
- * Provides simple string-based search for discovering tools across all connected MCP servers.
+ * Returns aggregated tools from the gateway cache with wrapped inputSchema
+ * (including serverName, toolName, toolArgs, and requestOptions fields).
  * Uses straightforward string matching on tool name and description.
  *
  * @param fastify - The Fastify instance to register routes on

package/dist/server/src/api/web/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EACxE,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,GAC1D,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAQnE;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBA6C7D"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBAoD7D"}

package/dist/server/src/api/web/search.js

@@ -1,25 +1,9 @@
-import { mcpConnectionManager } from '../../services/mcp-connection-manager.js';
-import { hubManager } from '../../services/hub-manager.service.js';
-/**
- * Filters tools by aggregatedTools configuration.
- * Only includes tools from servers that have aggregatedTools configured
- * AND the tool is in that list.
- */
-export function filterByAggregatedTools(tools, getServerConfig) {
-    return tools.filter((tool) => {
-        const serverConfig = getServerConfig(tool.serverName);
-        if (!serverConfig)
-            return false;
-        const aggregatedTools = serverConfig.template?.aggregatedTools;
-        if (!aggregatedTools || aggregatedTools.length === 0)
-            return false;
-        return aggregatedTools.includes(tool.name);
-    });
-}
+import { MCP_HUB_LITE_SERVER } from '../../../shared/models/constants.js';
 /**
  * Tool Search API Routes
  *
- * Provides simple string-based search for discovering tools across all connected MCP servers.
+ * Returns aggregated tools from the gateway cache with wrapped inputSchema
+ * (including serverName, toolName, toolArgs, and requestOptions fields).
  * Uses straightforward string matching on tool name and description.
  *
  * @param fastify - The Fastify instance to register routes on
@@ -29,28 +13,36 @@ export async function webSearchRoutes(fastify) {
     // GET /web/search - Search for tools with simple string matching
     fastify.get('/web/search', async (request) => {
         const { q, limit = 50 } = request.query;
-        const allTools = mcpConnectionManager.getAllTools();
+        // Dynamic import to avoid circular dependency at module init time
+        const { getExternalGatewayTools } = await import('../../services/gateway/tool-list-generator.js');
+        const gatewayTools = getExternalGatewayTools();
         const query = q?.toLowerCase() || '';
         // Filter by search query
-        const queryMatched = allTools.filter((tool) => {
+        const queryMatched = gatewayTools.filter((tool) => {
             if (!query)
                 return true;
+            // Match against tool name (gateway-resolved name)
             const nameMatch = tool.name.toLowerCase().includes(query);
+            // Match against description (contains "[From serverName] original description")
             const descMatch = tool.description?.toLowerCase().includes(query);
             return nameMatch || descMatch;
         });
-        // Filter by aggregatedTools — only include tools from servers that have
-        // aggregatedTools configured AND the tool is in that list
-        const filtered = filterByAggregatedTools(queryMatched, (name) => hubManager.getServerByName(name));
-        const results = filtered.slice(0, limit);
-        return {
-            results: results.map((tool) => ({
+        const mappedResults = queryMatched.map((tool) => {
+            // Extract serverName from description format "[From serverName] ..."
+            const descMatch = tool.description?.match(/^\[From\s+(.+?)\]/);
+            const serverName = descMatch ? descMatch[1] : MCP_HUB_LITE_SERVER;
+            return {
                 name: tool.name,
                 description: tool.description,
-                serverName: tool.serverName
-            })),
+                serverName,
+                inputSchema: tool.inputSchema
+            };
+        });
+        const results = mappedResults.slice(0, limit);
+        return {
+            results,
             pagination: {
-                total: filtered.length,
+                total: mappedResults.length,
                 limit,
                 returned: results.length
             },

package/dist/server/src/api/web/servers.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { hubManager } from '../../services/hub-manager.service.js';
 import { ServerTemplateSchema, ServerInstanceUpdateSchema } from '../../config/config.schema.js';
-import { logger } from '../../utils/logger.js';
+import { logger } from '../../utils/logger/index.js';
 import { LOG_MODULES } from '../../utils/logger/log-modules.js';
 import { stringifyForLogging, getApiDebugSetting } from '../../utils/json-utils.js';
 /**

package/dist/server/src/api/web/sessions.d.ts

@@ -1,29 +1,3 @@
 import { FastifyInstance } from 'fastify';
-/**
- * Session Management API Routes
- *
- * Provides comprehensive session management endpoints for the MCP Hub Lite system's persistent session storage.
- * This module enables administrators and clients to monitor, inspect, and manage active and persisted sessions
- * that maintain client connection state across service restarts.
- *
- * Sessions store critical client context including connection metadata, working directories, project information,
- * and other state that enables seamless reconnection and continuity of operations. The session persistence
- * feature ensures that client connections can be restored even after service interruptions.
- *
- * Key features include:
- * - Listing all persisted sessions with metadata
- * - Detailed session inspection by session ID
- * - Session deletion for cleanup and maintenance
- * - Integration with the MCP session manager for consistency
- *
- * @param fastify - The Fastify instance to register routes on
- * @returns Promise that resolves when all routes are registered
- *
- * @example
- * ```typescript
- * // Register session management routes
- * await webSessionRoutes(app);
- * ```
- */
-export declare function webSessionRoutes(fastify: FastifyInstance): Promise<void>;
+export declare function webSessionsRoutes(fastify: FastifyInstance): Promise<void>;
 //# sourceMappingURL=sessions.d.ts.map

package/dist/server/src/api/web/sessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,eAAe,iBAsF9D"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK1C,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBAU/D"}

package/dist/server/src/api/web/sessions.js

@@ -1,104 +1,15 @@
-import { mcpSessionManager } from '../../services/session/index.js';
-import { logger, LOG_MODULES } from '../../utils/logger.js';
-/**
- * Session Management API Routes
- *
- * Provides comprehensive session management endpoints for the MCP Hub Lite system's persistent session storage.
- * This module enables administrators and clients to monitor, inspect, and manage active and persisted sessions
- * that maintain client connection state across service restarts.
- *
- * Sessions store critical client context including connection metadata, working directories, project information,
- * and other state that enables seamless reconnection and continuity of operations. The session persistence
- * feature ensures that client connections can be restored even after service interruptions.
- *
- * Key features include:
- * - Listing all persisted sessions with metadata
- * - Detailed session inspection by session ID
- * - Session deletion for cleanup and maintenance
- * - Integration with the MCP session manager for consistency
- *
- * @param fastify - The Fastify instance to register routes on
- * @returns Promise that resolves when all routes are registered
- *
- * @example
- * ```typescript
- * // Register session management routes
- * await webSessionRoutes(app);
- * ```
- */
-export async function webSessionRoutes(fastify) {
-    /**
-     * List all persisted sessions
-     */
+import { logger } from '../../utils/logger/index.js';
+import { LOG_MODULES } from '../../utils/logger/log-modules.js';
+import { sessionManager } from '../../services/gateway/session-manager.js';
+export async function webSessionsRoutes(fastify) {
     fastify.get('/web/sessions', async (_request, reply) => {
         try {
-            const sessions = mcpSessionManager.getAllSessionStates();
-            return reply.send({
-                success: true,
-                data: sessions,
-                count: sessions.length
-            });
+            const sessions = sessionManager.getAllSessions();
+            return { sessions };
         }
         catch (error) {
-            logger.error('Failed to get sessions:', error, LOG_MODULES.SESSION_API);
-            return reply.code(500).send({
-                success: false,
-                error: 'Failed to get sessions'
-            });
-        }
-    });
-    /**
-     * Get a specific session by ID
-     */
-    fastify.get('/web/sessions/:sessionId', async (request, reply) => {
-        try {
-            const { sessionId } = request.params;
-            const session = mcpSessionManager.getSessionState(sessionId);
-            if (!session) {
-                return reply.code(404).send({
-                    success: false,
-                    error: 'Session not found'
-                });
-            }
-            return reply.send({
-                success: true,
-                data: session
-            });
-        }
-        catch (error) {
-            logger.error('Failed to get session:', error, LOG_MODULES.SESSION_API);
-            return reply.code(500).send({
-                success: false,
-                error: 'Failed to get session'
-            });
-        }
-    });
-    /**
-     * Delete a session
-     */
-    fastify.delete('/web/sessions/:sessionId', async (request, reply) => {
-        try {
-            const { sessionId } = request.params;
-            logger.info(`Deleting session: ${sessionId}`, LOG_MODULES.SESSION_API);
-            const existed = await mcpSessionManager.deleteSession(sessionId);
-            if (!existed) {
-                return reply.code(404).send({
-                    success: false,
-                    error: 'Session not found'
-                });
-            }
-            logger.info(`Session deleted successfully: ${sessionId}`, LOG_MODULES.SESSION_API);
-            return reply.send({
-                success: true,
-                message: 'Session deleted successfully'
-            });
-        }
-        catch (error) {
-            logger.error('Failed to delete session:', error, LOG_MODULES.SESSION_API);
-            return reply.code(500).send({
-                success: false,
-                error: 'Failed to delete session'
-            });
+            logger.error('Failed to retrieve sessions:', error, LOG_MODULES.GATEWAY);
+            return reply.code(500).send({ error: 'Internal Server Error' });
         }
     });
 }

package/dist/server/src/api/ws/events.js

@@ -27,7 +27,7 @@
 import fastifyWebSocket from '@fastify/websocket';
 import { WebSocketHandler } from './ws-handler.js';
 import { eventBus } from '../../services/event-bus.service.js';
-import { logger, LOG_MODULES } from '../../utils/logger.js';
+import { logger, LOG_MODULES } from '../../utils/logger/index.js';
 export async function webSocketRoutes(fastify) {
     // Register WebSocket plugin
     await fastify.register(fastifyWebSocket);

package/dist/server/src/api/ws/ws-handler.js

@@ -26,7 +26,7 @@
 import { WebSocket } from 'ws';
 import { EventTypes } from '../../services/event-bus.service.js';
 import { logStorage } from '../../services/log-storage.service.js';
-import { logger, LOG_MODULES } from '../../utils/logger.js';
+import { logger, LOG_MODULES } from '../../utils/logger/index.js';
 import { WEB_SOCKET_EVENT_TYPES } from '../../../shared/types/websocket.types.js';
 // Event type mapping
 const eventTypeMap = {

package/dist/server/src/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/app.ts"],"names":[],"mappings":"AAmCA,uDAAuD;AACvD,wBAAgB,kBAAkB;;;;;EAQjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,QAAQ,mWAyJ7B"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/app.ts"],"names":[],"mappings":"AAqCA,uDAAuD;AACvD,wBAAgB,kBAAkB;;;;;EAQjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,QAAQ,mWA6J7B"}

package/dist/server/src/app.js

@@ -5,7 +5,8 @@ import { fileURLToPath } from 'url';
 import { configManager } from './config/config-manager.js';
 import { setJsonPrettyConfigGetter } from './utils/json-utils.js';
 import { isIpAllowed } from './utils/network-security.js';
-import { logger, LOG_MODULES } from './utils/logger.js';
+import { logger, LOG_MODULES } from './utils/logger/index.js';
+import { initGlobalTransport } from './services/gateway/global-transport.js';
 // MCP Protocol Routes
 import { mcpGatewayRoutes } from './api/mcp/gateway.js';
 // Web API Routes
@@ -17,6 +18,7 @@ import { configRoutes } from './api/web/config.js';
 import { webLogRoutes } from './api/web/logs.js';
 import { webHubToolsRoutes } from './api/web/hub-tools.js';
 import { webResourceRoutes } from './api/web/resources.js';
+import { webSessionsRoutes } from './api/web/sessions.js';
 // WebSocket Routes
 import { webSocketRoutes } from './api/ws/events.js';
 // Get __dirname equivalent in ESM
@@ -153,6 +155,8 @@ export async function buildApp() {
         }
         done();
     });
+    // Initialize singleton MCP transport before registering routes
+    await initGlobalTransport();
     // Register API routes first (before static files)
     fastify.register(mcpGatewayRoutes);
     fastify.register(webServerRoutes);
@@ -163,6 +167,7 @@ export async function buildApp() {
     fastify.register(webLogRoutes);
     fastify.register(webHubToolsRoutes);
     fastify.register(webResourceRoutes);
+    fastify.register(webSessionsRoutes);
     fastify.register(webSocketRoutes);
     // Serve static files from dist/client (frontend build output)
     const clientPath = path.join(__dirname, '../../client');

package/dist/server/src/cli/commands/status.js

@@ -136,6 +136,39 @@ function printFormattedStatus(status) {
         // Then display disconnected servers
         displayServerList(disconnectedServers, 'MCP Servers (Disconnected):', red);
     }
+    // Sessions section
+    if (status.sessions !== undefined) {
+        console.log('');
+        console.log(`${yellow}👥 Active MCP Sessions:${reset}`);
+        console.log(`${dim}══════════════════════════════${reset}`);
+        if (status.sessions.length === 0) {
+            console.log(`${dim}  No active sessions${reset}`);
+        }
+        else {
+            let maxSidLen = 'Session ID'.length;
+            let maxClientLen = 'Client'.length;
+            let maxVerLen = 'Version'.length;
+            for (const s of status.sessions) {
+                maxSidLen = Math.max(maxSidLen, (s.sessionId || '').length);
+                maxClientLen = Math.max(maxClientLen, (s.clientName || '').length);
+                const ver = s.protocolVersion || '';
+                maxVerLen = Math.max(maxVerLen, ver.length);
+            }
+            const headerSid = 'Session ID'.padEnd(maxSidLen);
+            const headerClient = 'Client'.padEnd(maxClientLen);
+            const headerVer = 'Version'.padEnd(maxVerLen);
+            console.log(`${cyan}${headerSid}  ${headerClient}  ${headerVer}  SSE${reset}`);
+            console.log(`${dim}${'─'.repeat(maxSidLen + maxClientLen + maxVerLen + 10)}${reset}`);
+            for (const s of status.sessions) {
+                const sid = (s.sessionId || '').padEnd(maxSidLen);
+                const client = (s.clientName || '').padEnd(maxClientLen);
+                const ver = (s.protocolVersion || '').padEnd(maxVerLen);
+                const sse = s.activeSseCount.toString().padStart(3);
+                console.log(`${sid}  ${client}  ${ver}  ${sse}`);
+            }
+            console.log(`${dim}  Total: ${status.sessions.length} active session(s)${reset}`);
+        }
+    }
     // MCP Client Configuration
     console.log('');
     console.log(`${yellow}🔌 MCP Client Configuration:${reset}`);
@@ -145,10 +178,15 @@ function printFormattedStatus(status) {
     console.log(`${dim}{${reset}`);
     console.log(`${dim}  "mcpServers": {${reset}`);
     console.log(`${dim}    "mcp-hub-lite": {${reset}`);
-    console.log(`${dim}      "url": "${cyan}${mcpEndpoint}${dim}"${reset}`);
+    console.log(`${dim}      "url": "${cyan}${mcpEndpoint}${dim}",${reset}`);
+    console.log(`${dim}      "headers": {${reset}`);
+    console.log(`${dim}        "x-mcp-session-mode": "${cyan}stateful${dim}"${reset}`);
+    console.log(`${dim}      }${reset}`);
     console.log(`${dim}    }${reset}`);
     console.log(`${dim}  }${reset}`);
     console.log(`${dim}}${reset}`);
+    console.log('');
+    console.log(`${dim}💡 Use ${cyan}"stateful"${dim} for session persistence / SSE, ${cyan}"stateless"${dim} for per-request mode${reset}`);
     // Quick Commands
     console.log('');
     console.log(`${yellow}💡 Quick Commands:${reset}`);

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

@@ -3,18 +3,18 @@ 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 five actions: list-servers, list-tools, list-tags, get-tool, and call-tool. It wraps
+ * supporting six actions: list-servers, list-tools, list-tags, get-tool, call-tool, and search-tools. 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>]
+ * mcp-hub-lite tool-use <action> [query] [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
  * ```
  *
  * Or via npm:
  * ```
- * npm run tool-use -- <action> [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
+ * npm run tool-use -- <action> [query] [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
  * ```
  *
  * ## Supported Actions
@@ -24,6 +24,7 @@ import { Command } from 'commander';
  * - `list-tags` - List all instance tags for a specific MCP server
  * - `get-tool` - Get complete schema for a specific tool (requires --tool)
  * - `call-tool` - Call a tool on the specified server (requires --tool)
+ * - `search-tools` - Search tools across all connected servers by name or description (requires query)
  *
  * ## Options
  *
@@ -70,6 +71,9 @@ import { Command } from 'commander';
  *
  * # Multi-instance server with tags
  * mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"test"}' --tags '{"env":"prod"}'
+ *
+ * # Search tools across all connected servers
+ * mcp-hub-lite tool-use search-tools "weather"
  * ```
  *
  * ### JSON 合并形式 (JSON Merge):
@@ -83,6 +87,9 @@ import { Command } from 'commander';
  *
  * # Equivalent to
  * mcp-hub-lite tool-use call-tool --server baidu-search --tool search --args '{"query":"天气"}'
+ *
+ * # Search tools (JSON merge form)
+ * mcp-hub-lite tool-use search-tools --args '{"query":"weather"}'
  * ```
  *
  * ## Error Handling

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,eAAO,MAAM,cAAc,SAkNvB,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsGG;AACH,eAAO,MAAM,cAAc,SA2PvB,CAAC"}

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

@@ -4,18 +4,18 @@ 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 five actions: list-servers, list-tools, list-tags, get-tool, and call-tool. It wraps
+ * supporting six actions: list-servers, list-tools, list-tags, get-tool, call-tool, and search-tools. 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>]
+ * mcp-hub-lite tool-use <action> [query] [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
  * ```
  *
  * Or via npm:
  * ```
- * npm run tool-use -- <action> [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
+ * npm run tool-use -- <action> [query] [--server <serverName>] [--tool <toolName>] [--args <json>] [--tags <json>]
  * ```
  *
  * ## Supported Actions
@@ -25,6 +25,7 @@ import { getServerStatus } from '../server.js';
  * - `list-tags` - List all instance tags for a specific MCP server
  * - `get-tool` - Get complete schema for a specific tool (requires --tool)
  * - `call-tool` - Call a tool on the specified server (requires --tool)
+ * - `search-tools` - Search tools across all connected servers by name or description (requires query)
  *
  * ## Options
  *
@@ -71,6 +72,9 @@ import { getServerStatus } from '../server.js';
  *
  * # Multi-instance server with tags
  * mcp-hub-lite tool-use call-tool --tool search --server baidu-search --args '{"query":"test"}' --tags '{"env":"prod"}'
+ *
+ * # Search tools across all connected servers
+ * mcp-hub-lite tool-use search-tools "weather"
  * ```
  *
  * ### JSON 合并形式 (JSON Merge):
@@ -84,6 +88,9 @@ import { getServerStatus } from '../server.js';
  *
  * # Equivalent to
  * mcp-hub-lite tool-use call-tool --server baidu-search --tool search --args '{"query":"天气"}'
+ *
+ * # Search tools (JSON merge form)
+ * mcp-hub-lite tool-use search-tools --args '{"query":"weather"}'
  * ```
  *
  * ## Error Handling
@@ -97,37 +104,44 @@ import { getServerStatus } from '../server.js';
  * @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, list-tags, get-tool, call-tool)')
-    .argument('<action>', 'Action: list-servers, list-tools, list-tags, get-tool, call-tool')
+    .description('Manage MCP server tools via API (list-servers, list-tools, list-tags, get-tool, call-tool, search-tools)')
+    .argument('<action>', 'Action: list-servers, list-tools, list-tags, get-tool, call-tool, search-tools')
+    .argument('[query]', 'Search query (required for search-tools action)')
     .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
-
-  # List instance tags for a server
-  mcp-hub-lite tool-use list-tags --server chrome-devtools
-
-  # 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":"天气"}'
+    .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
+
+  # List instance tags for a server
+  mcp-hub-lite tool-use list-tags --server chrome-devtools
+
+  # 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":"天气"}'
+
+  # Search tools across all connected servers
+  mcp-hub-lite tool-use search-tools "weather"
+
+  # Search tools (JSON merge form)
+  mcp-hub-lite tool-use search-tools --args '{"query":"weather"}'
+
+  # 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) => {
+    .action(async (action, query, options) => {
     try {
         // Check if server is running and get connection info
         const status = await getServerStatus();
@@ -231,6 +245,31 @@ Examples:
                 console.log(JSON.stringify(result, null, 2));
                 break;
             }
+            case 'search-tools': {
+                let searchQuery = query;
+                if (!searchQuery && options.args) {
+                    try {
+                        const parsed = JSON.parse(options.args);
+                        searchQuery = parsed.query || parsed.q || '';
+                    }
+                    catch {
+                        // ignore parse errors, fall through to validation
+                    }
+                }
+                if (!searchQuery || typeof searchQuery !== 'string' || searchQuery.trim().length === 0) {
+                    console.error('Error: query is required for search-tools action');
+                    console.error('Usage: mcp-hub-lite tool-use search-tools <query>');
+                    process.exit(1);
+                }
+                const response = await fetch(`${baseUrl}/web/hub-tools/search?q=${encodeURIComponent(searchQuery.trim())}`, { 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');
@@ -265,7 +304,7 @@ Examples:
             }
             default: {
                 console.error(`Unknown action: ${action}`);
-                console.error('Valid actions: list-servers, list-tools, list-tags, get-tool, call-tool');
+                console.error('Valid actions: list-servers, list-tools, list-tags, get-tool, call-tool, search-tools');
                 process.exit(1);
             }
         }

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

@@ -1,11 +1,3 @@
 import { Command } from 'commander';
-/**
- * CLI command for displaying the use guide in Markdown format.
- *
- * This command outputs the CLI usage guide, similar to how MCP Hub Lite
- * provides a use-guide resource for MCP protocol usage.
- *
- * @returns {Command} The configured use-guide command instance for registration with Commander.js
- */
 export declare const useGuideCommand: Command;
 //# sourceMappingURL=use-guide.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-guide.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/use-guide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmKpC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,SAKxB,CAAC"}
+{"version":3,"file":"use-guide.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/use-guide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6BpC,eAAO,MAAM,eAAe,SAKxB,CAAC"}