@juspay/neurolink 9.42.0 → 9.43.0

package/dist/cli/commands/mcp.d.ts

@@ -163,4 +163,10 @@ export declare class MCPCommandFactory {
      * Execute annotate command
      */
     private static executeAnnotate;
+    private static getMCPStatusWithTimeout;
+    private static listToolAnnotations;
+    private static collectToolAnnotations;
+    private static findToolForAnnotation;
+    private static buildAnnotationsFromArgs;
+    private static printAnnotationUpdate;
 }

package/dist/cli/commands/mcp.js

@@ -115,6 +115,7 @@ const POPULAR_MCP_SERVERS = {
         description: "Bitbucket repository management and development workflows",
     },
 };
+const MCP_STATUS_TIMEOUT_MS = 30_000;
 /**
  * MCP CLI command factory
  */
@@ -565,7 +566,7 @@ export class MCPCommandFactory {
                 ? null
                 : ora("Testing MCP server connections...").start();
             const sdk = new NeuroLink();
-            await sdk.getMCPStatus();
+            await this.getMCPStatusWithTimeout(sdk, Number(argv.timeout) || MCP_STATUS_TIMEOUT_MS);
             let serversToTest = await sdk.listMCPServers();
             if (targetServer) {
                 serversToTest = serversToTest.filter((s) => s.name === targetServer);
@@ -655,7 +656,7 @@ export class MCPCommandFactory {
                 }
             }
             const sdk = new NeuroLink();
-            await sdk.getMCPStatus();
+            await this.getMCPStatusWithTimeout(sdk);
             // Check if server exists and is connected
             const allServers = await sdk.listMCPServers();
             const server = allServers.find((s) => s.name === serverName);
@@ -764,7 +765,7 @@ export class MCPCommandFactory {
                 process.exit(1);
             }
             const sdk = new NeuroLink();
-            await sdk.getMCPStatus();
+            await this.getMCPStatusWithTimeout(sdk);
             const allServers = await sdk.listMCPServers();
             const server = allServers.find((s) => s.name === serverName);
             if (!server) {
@@ -2234,154 +2235,28 @@ ${tools.length > 0 ? tools.map((t) => `- **${t}**: TODO: Add description`).join(
         try {
             const sdk = new NeuroLink();
             const servers = await sdk.listMCPServers();
-            // List mode - show all tools with annotations
             if (argv.list) {
-                const spinner = argv.quiet
-                    ? null
-                    : ora("Loading tool annotations...").start();
-                const allTools = [];
-                for (const server of servers) {
-                    if (server.status !== "connected") {
-                        continue;
-                    }
-                    for (const tool of server.tools || []) {
-                        const existing = tool
-                            .annotations;
-                        const annotations = existing ??
-                            inferAnnotations({
-                                name: tool.name,
-                                description: tool.description,
-                            });
-                        allTools.push({
-                            serverName: server.name,
-                            serverId: server.id,
-                            toolName: tool.name,
-                            description: tool.description,
-                            annotations,
-                        });
-                    }
-                }
-                if (spinner) {
-                    spinner.succeed(`Found ${allTools.length} tools`);
-                }
-                if (argv.format === "json") {
-                    logger.always(JSON.stringify(allTools, null, 2));
-                    return;
-                }
-                logger.always(chalk.bold("\n Tool Annotations:\n"));
-                // Group by server
-                const byServer = allTools.reduce((acc, tool) => {
-                    if (!acc[tool.serverId]) {
-                        acc[tool.serverId] = {
-                            serverName: tool.serverName,
-                            tools: [],
-                        };
-                    }
-                    acc[tool.serverId].tools.push(tool);
-                    return acc;
-                }, {});
-                for (const [serverId, { serverName, tools }] of Object.entries(byServer)) {
-                    logger.always(chalk.cyan.bold(`\n${serverName} (${serverId}):`));
-                    for (const tool of tools) {
-                        const annotationStr = getAnnotationSummary(tool.annotations);
-                        logger.always(`  ${chalk.yellow(tool.toolName)} ${chalk.gray(annotationStr)}`);
-                        if (argv.detailed) {
-                            logger.always(`    ${chalk.gray(tool.description)}`);
-                        }
-                    }
-                }
-                logger.always();
+                await this.listToolAnnotations(servers, argv);
                 return;
             }
-            // Annotate specific tool
             const toolName = argv.tool;
             if (!toolName) {
                 logger.error(chalk.red("Tool name is required. Use --tool <name> or --list to see all tools."));
                 process.exit(1);
             }
-            // Find the tool
-            let foundTool = null;
             const serverId = argv.server;
-            for (const server of servers) {
-                if (serverId && server.id !== serverId) {
-                    continue;
-                }
-                for (const tool of server.tools || []) {
-                    if (tool.name === toolName) {
-                        foundTool = {
-                            name: tool.name,
-                            description: tool.description,
-                            serverId: server.id,
-                            serverName: server.name,
-                        };
-                        break;
-                    }
-                }
-                if (foundTool) {
-                    break;
-                }
+            const foundTool = this.findToolForAnnotation(servers, toolName, serverId);
+            if (foundTool === "ambiguous") {
+                logger.error(chalk.red(`Tool '${toolName}' exists on multiple servers. Use --server <id> to specify which server to annotate.`));
+                logger.always(chalk.yellow("Use 'neurolink mcp annotate --list' to see available tools and their server IDs."));
+                process.exit(1);
             }
             if (!foundTool) {
                 logger.error(chalk.red(`Tool '${toolName}' not found.${serverId ? ` Server: ${serverId}` : ""}`));
                 logger.always(chalk.yellow("Use 'neurolink mcp annotate --list' to see available tools."));
                 process.exit(1);
             }
-            // Build annotations from options
-            let annotations = {};
-            // Parse JSON annotations if provided
-            if (argv.annotations) {
-                try {
-                    const parsed = JSON.parse(argv.annotations);
-                    annotations = { ...annotations, ...parsed };
-                }
-                catch {
-                    logger.error(chalk.red("Invalid JSON in --annotations"));
-                    process.exit(1);
-                }
-            }
-            // Apply individual annotation flags
-            if (argv["read-only"] !== undefined) {
-                annotations.readOnlyHint = argv["read-only"];
-            }
-            if (argv.destructive !== undefined) {
-                annotations.destructiveHint = argv.destructive;
-            }
-            if (argv.idempotent !== undefined) {
-                annotations.idempotentHint = argv.idempotent;
-            }
-            if (argv["requires-confirmation"] !== undefined) {
-                annotations.requiresConfirmation = argv["requires-confirmation"];
-            }
-            if (argv.tags) {
-                annotations.tags = argv.tags;
-            }
-            if (argv["estimated-duration"] !== undefined) {
-                annotations.estimatedDuration = argv["estimated-duration"];
-            }
-            if (argv["rate-limit"] !== undefined) {
-                annotations.rateLimitHint = argv["rate-limit"];
-            }
-            if (argv.cost !== undefined) {
-                annotations.costHint = argv.cost;
-            }
-            if (argv.complexity) {
-                annotations.complexity = argv.complexity;
-            }
-            if (argv["security-level"]) {
-                annotations.securityLevel = argv["security-level"];
-            }
-            if (argv.audit !== undefined) {
-                annotations.auditRequired = argv.audit;
-            }
-            // Infer annotations if requested
-            if (argv.infer) {
-                const inferred = inferAnnotations({
-                    name: foundTool.name,
-                    description: foundTool.description,
-                });
-                annotations = mergeAnnotations(inferred, annotations);
-            }
-            // Validate annotations
+            const annotations = this.buildAnnotationsFromArgs(argv, foundTool);
             const errors = validateAnnotations(annotations);
             if (errors.length > 0) {
                 logger.error(chalk.red("Annotation validation errors:"));
@@ -2396,63 +2271,204 @@ ${tools.length > 0 ? tools.map((t) => `- **${t}**: TODO: Add description`).join(
                 logger.always(JSON.stringify(annotations, null, 2));
                 return;
             }
-            // Display the annotations
-            logger.always(chalk.bold("\n Tool Annotation Update:\n"));
-            logger.always(`  Server: ${chalk.cyan(foundTool.serverName)} (${foundTool.serverId})`);
-            logger.always(`  Tool: ${chalk.yellow(foundTool.name)}`);
-            logger.always(`  Description: ${chalk.gray(foundTool.description)}`);
-            logger.always();
-            logger.always(chalk.bold("  Annotations:"));
-            if (annotations.readOnlyHint !== undefined) {
-                logger.always(`    readOnlyHint: ${annotations.readOnlyHint ? chalk.green("true") : chalk.red("false")}`);
-            }
-            if (annotations.destructiveHint !== undefined) {
-                logger.always(`    destructiveHint: ${annotations.destructiveHint ? chalk.red("true") : chalk.green("false")}`);
-            }
-            if (annotations.idempotentHint !== undefined) {
-                logger.always(`    idempotentHint: ${annotations.idempotentHint ? chalk.green("true") : chalk.gray("false")}`);
-            }
-            if (annotations.requiresConfirmation !== undefined) {
-                logger.always(`    requiresConfirmation: ${annotations.requiresConfirmation ? chalk.yellow("true") : chalk.gray("false")}`);
-            }
-            if (annotations.tags?.length) {
-                logger.always(`    tags: ${chalk.blue(annotations.tags.join(", "))}`);
+            this.printAnnotationUpdate(foundTool, annotations);
+        }
+        catch (error) {
+            logger.error(chalk.red(`Annotate command failed: ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+    }
+    static async getMCPStatusWithTimeout(sdk, timeoutMs = MCP_STATUS_TIMEOUT_MS) {
+        return withTimeout(sdk.getMCPStatus(), timeoutMs, ErrorFactory.toolTimeout("mcpStatus", timeoutMs));
+    }
+    static async listToolAnnotations(servers, argv) {
+        const spinner = argv.quiet
+            ? null
+            : ora("Loading tool annotations...").start();
+        const allTools = this.collectToolAnnotations(servers);
+        if (spinner) {
+            spinner.succeed(`Found ${allTools.length} tools`);
+        }
+        if (argv.format === "json") {
+            logger.always(JSON.stringify(allTools, null, 2));
+            return;
+        }
+        logger.always(chalk.bold("\n Tool Annotations:\n"));
+        const byServer = allTools.reduce((acc, tool) => {
+            if (!acc[tool.serverId]) {
+                acc[tool.serverId] = {
+                    serverName: tool.serverName,
+                    tools: [],
+                };
             }
-            if (annotations.estimatedDuration !== undefined) {
-                logger.always(`    estimatedDuration: ${annotations.estimatedDuration}ms`);
+            acc[tool.serverId].tools.push(tool);
+            return acc;
+        }, {});
+        for (const [serverId, { serverName, tools }] of Object.entries(byServer)) {
+            logger.always(chalk.cyan.bold(`\n${serverName} (${serverId}):`));
+            for (const tool of tools) {
+                logger.always(`  ${chalk.yellow(tool.toolName)} ${chalk.gray(getAnnotationSummary(tool.annotations))}`);
+                if (argv.detailed) {
+                    logger.always(`    ${chalk.gray(tool.description)}`);
+                }
             }
-            if (annotations.rateLimitHint !== undefined) {
-                logger.always(`    rateLimitHint: ${annotations.rateLimitHint} calls/min`);
+        }
+        logger.always();
+    }
+    static collectToolAnnotations(servers) {
+        const allTools = [];
+        for (const server of servers) {
+            if (server.status !== "connected") {
+                continue;
             }
-            if (annotations.costHint !== undefined) {
-                logger.always(`    costHint: ${annotations.costHint}`);
+            for (const tool of server.tools || []) {
+                const existing = tool
+                    .annotations;
+                allTools.push({
+                    serverName: server.name,
+                    serverId: server.id,
+                    toolName: tool.name,
+                    description: tool.description,
+                    annotations: existing ??
+                        inferAnnotations({
+                            name: tool.name,
+                            description: tool.description,
+                        }),
+                });
             }
-            if (annotations.complexity) {
-                logger.always(`    complexity: ${chalk.cyan(annotations.complexity)}`);
+        }
+        return allTools;
+    }
+    static findToolForAnnotation(servers, toolName, serverId) {
+        const matches = [];
+        for (const server of servers) {
+            if (serverId && server.id !== serverId) {
+                continue;
+            }
+            for (const tool of server.tools || []) {
+                if (tool.name === toolName) {
+                    matches.push({
+                        name: tool.name,
+                        description: tool.description,
+                        serverId: server.id,
+                        serverName: server.name,
+                    });
+                }
             }
-            if (annotations.securityLevel) {
-                const secColor = annotations.securityLevel === "restricted"
-                    ? chalk.red
-                    : annotations.securityLevel === "internal"
-                        ? chalk.yellow
-                        : chalk.green;
-                logger.always(`    securityLevel: ${secColor(annotations.securityLevel)}`);
+        }
+        if (matches.length === 0) {
+            return null;
+        }
+        if (matches.length > 1) {
+            return "ambiguous";
+        }
+        return matches[0] ?? null;
+    }
+    static buildAnnotationsFromArgs(argv, foundTool) {
+        let annotations = {};
+        if (argv.annotations) {
+            try {
+                annotations = {
+                    ...annotations,
+                    ...JSON.parse(argv.annotations),
+                };
             }
-            if (annotations.auditRequired !== undefined) {
-                logger.always(`    auditRequired: ${annotations.auditRequired ? chalk.yellow("true") : chalk.gray("false")}`);
+            catch {
+                logger.error(chalk.red("Invalid JSON in --annotations"));
+                process.exit(1);
             }
-            logger.always();
-            logger.always(chalk.gray("  Summary: ") + getAnnotationSummary(annotations));
-            logger.always();
-            // Note: In a full implementation, this would persist the annotations
-            // to a configuration file or database. For now, we just display them.
-            logger.always(chalk.blue("Note: Annotations displayed above. To persist annotations, add them to your MCP server configuration."));
-            logger.always(chalk.gray(`Example: Add to your server's tool definition or use environment-specific annotation overrides.`));
         }
-        catch (error) {
-            logger.error(chalk.red(`Annotate command failed: ${error instanceof Error ? error.message : String(error)}`));
-            process.exit(1);
+        if (argv["read-only"] !== undefined) {
+            annotations.readOnlyHint = argv["read-only"];
+        }
+        if (argv.destructive !== undefined) {
+            annotations.destructiveHint = argv.destructive;
+        }
+        if (argv.idempotent !== undefined) {
+            annotations.idempotentHint = argv.idempotent;
+        }
+        if (argv["requires-confirmation"] !== undefined) {
+            annotations.requiresConfirmation = argv["requires-confirmation"];
+        }
+        if (argv.tags) {
+            annotations.tags = argv.tags;
+        }
+        if (argv["estimated-duration"] !== undefined) {
+            annotations.estimatedDuration = argv["estimated-duration"];
+        }
+        if (argv["rate-limit"] !== undefined) {
+            annotations.rateLimitHint = argv["rate-limit"];
+        }
+        if (argv.cost !== undefined) {
+            annotations.costHint = argv.cost;
+        }
+        if (argv.complexity) {
+            annotations.complexity = argv.complexity;
+        }
+        if (argv["security-level"]) {
+            annotations.securityLevel = argv["security-level"];
+        }
+        if (argv.audit !== undefined) {
+            annotations.auditRequired = argv.audit;
+        }
+        if (argv.infer) {
+            annotations = mergeAnnotations(inferAnnotations({
+                name: foundTool.name,
+                description: foundTool.description,
+            }), annotations);
+        }
+        return annotations;
+    }
+    static printAnnotationUpdate(foundTool, annotations) {
+        logger.always(chalk.bold("\n Tool Annotation Update:\n"));
+        logger.always(`  Server: ${chalk.cyan(foundTool.serverName)} (${foundTool.serverId})`);
+        logger.always(`  Tool: ${chalk.yellow(foundTool.name)}`);
+        logger.always(`  Description: ${chalk.gray(foundTool.description)}`);
+        logger.always();
+        logger.always(chalk.bold("  Annotations:"));
+        if (annotations.readOnlyHint !== undefined) {
+            logger.always(`    readOnlyHint: ${annotations.readOnlyHint ? chalk.green("true") : chalk.red("false")}`);
+        }
+        if (annotations.destructiveHint !== undefined) {
+            logger.always(`    destructiveHint: ${annotations.destructiveHint ? chalk.red("true") : chalk.green("false")}`);
+        }
+        if (annotations.idempotentHint !== undefined) {
+            logger.always(`    idempotentHint: ${annotations.idempotentHint ? chalk.green("true") : chalk.gray("false")}`);
+        }
+        if (annotations.requiresConfirmation !== undefined) {
+            logger.always(`    requiresConfirmation: ${annotations.requiresConfirmation ? chalk.yellow("true") : chalk.gray("false")}`);
+        }
+        if (annotations.tags?.length) {
+            logger.always(`    tags: ${chalk.blue(annotations.tags.join(", "))}`);
+        }
+        if (annotations.estimatedDuration !== undefined) {
+            logger.always(`    estimatedDuration: ${annotations.estimatedDuration}ms`);
+        }
+        if (annotations.rateLimitHint !== undefined) {
+            logger.always(`    rateLimitHint: ${annotations.rateLimitHint} calls/min`);
+        }
+        if (annotations.costHint !== undefined) {
+            logger.always(`    costHint: ${annotations.costHint}`);
+        }
+        if (annotations.complexity) {
+            logger.always(`    complexity: ${chalk.cyan(annotations.complexity)}`);
+        }
+        if (annotations.securityLevel) {
+            const secColor = annotations.securityLevel === "restricted"
+                ? chalk.red
+                : annotations.securityLevel === "internal"
+                    ? chalk.yellow
+                    : chalk.green;
+            logger.always(`    securityLevel: ${secColor(annotations.securityLevel)}`);
+        }
+        if (annotations.auditRequired !== undefined) {
+            logger.always(`    auditRequired: ${annotations.auditRequired ? chalk.yellow("true") : chalk.gray("false")}`);
         }
+        logger.always();
+        logger.always(chalk.gray("  Summary: ") + getAnnotationSummary(annotations));
+        logger.always();
+        logger.always(chalk.blue("Note: Annotations displayed above. To persist annotations, add them to your MCP server configuration."));
+        logger.always(chalk.gray("Example: Add to your server's tool definition or use environment-specific annotation overrides."));
     }
 }
 //# sourceMappingURL=mcp.js.map