@evantahler/mcpx 0.18.3 → 0.18.5

package/src/commands/info.ts

@@ -1,58 +1,56 @@
 import type { Command } from "commander";
-import type { Tool, Resource, Prompt } from "../config/schemas.ts";
-import { formatServerOverview, formatToolSchema, formatError } from "../output/formatter.ts";
+import type { Prompt, Resource, Tool } from "../config/schemas.ts";
+import { formatError, formatServerOverview, formatToolSchema } from "../output/formatter.ts";
 import { withCommand } from "./with-command.ts";
 
 export function registerInfoCommand(program: Command) {
-  program
-    .command("info <server> [tool]")
-    .description("show server overview, or schema for a specific tool")
-    .action(
-      withCommand(
-        program,
-        { spinnerText: "Connecting..." },
-        async ({ manager, formatOptions, spinner }, server: string, tool?: string) => {
-          const target = tool ? `${server}/${tool}` : server;
-          spinner.update(`Connecting to ${target}...`);
+	program
+		.command("info <server> [tool]")
+		.description("show server overview, or schema for a specific tool")
+		.action(
+			withCommand(
+				program,
+				{ spinnerText: "Connecting..." },
+				async ({ manager, formatOptions, spinner }, server: string, tool?: string) => {
+					const target = tool ? `${server}/${tool}` : server;
+					spinner.update(`Connecting to ${target}...`);
 
-          if (tool) {
-            const toolSchema = await manager.getToolSchema(server, tool);
-            spinner.stop();
-            if (!toolSchema) {
-              console.error(
-                formatError(`Tool "${tool}" not found on server "${server}"`, formatOptions),
-              );
-              process.exit(1);
-            }
-            console.log(formatToolSchema(server, toolSchema, formatOptions));
-          } else {
-            const serverInfo = await manager.getServerInfo(server);
-            const caps = serverInfo.capabilities as Record<string, unknown> | undefined;
+					if (tool) {
+						const toolSchema = await manager.getToolSchema(server, tool);
+						spinner.stop();
+						if (!toolSchema) {
+							console.error(formatError(`Tool "${tool}" not found on server "${server}"`, formatOptions));
+							process.exit(1);
+						}
+						console.log(formatToolSchema(server, toolSchema, formatOptions));
+					} else {
+						const serverInfo = await manager.getServerInfo(server);
+						const caps = serverInfo.capabilities as Record<string, unknown> | undefined;
 
-            const fetches: [Promise<Tool[]>, Promise<Resource[]>, Promise<Prompt[]>] = [
-              caps?.tools !== undefined ? manager.listTools(server) : Promise.resolve([]),
-              caps?.resources !== undefined ? manager.listResources(server) : Promise.resolve([]),
-              caps?.prompts !== undefined ? manager.listPrompts(server) : Promise.resolve([]),
-            ];
-            const [tools, resources, prompts] = await Promise.all(fetches);
+						const fetches: [Promise<Tool[]>, Promise<Resource[]>, Promise<Prompt[]>] = [
+							caps?.tools !== undefined ? manager.listTools(server) : Promise.resolve([]),
+							caps?.resources !== undefined ? manager.listResources(server) : Promise.resolve([]),
+							caps?.prompts !== undefined ? manager.listPrompts(server) : Promise.resolve([]),
+						];
+						const [tools, resources, prompts] = await Promise.all(fetches);
 
-            spinner.stop();
-            console.log(
-              formatServerOverview(
-                {
-                  serverName: server,
-                  version: serverInfo.version,
-                  capabilities: caps,
-                  instructions: serverInfo.instructions,
-                  tools,
-                  resourceCount: resources.length,
-                  promptCount: prompts.length,
-                },
-                formatOptions,
-              ),
-            );
-          }
-        },
-      ),
-    );
+						spinner.stop();
+						console.log(
+							formatServerOverview(
+								{
+									serverName: server,
+									version: serverInfo.version,
+									capabilities: caps,
+									instructions: serverInfo.instructions,
+									tools,
+									resourceCount: resources.length,
+									promptCount: prompts.length,
+								},
+								formatOptions,
+							),
+						);
+					}
+				},
+			),
+		);
 }

package/src/commands/list.ts

@@ -1,59 +1,59 @@
 import type { Command } from "commander";
-import { formatUnifiedList } from "../output/formatter.ts";
 import type { UnifiedItem } from "../output/formatter.ts";
+import { formatUnifiedList } from "../output/formatter.ts";
 import { withCommand } from "./with-command.ts";
 
 export function registerListCommand(program: Command) {
-  program.action(
-    withCommand(
-      program,
-      { spinnerText: "Connecting to servers...", errorLabel: "Failed to list servers" },
-      async ({ manager, formatOptions, spinner }) => {
-        const [toolsResult, resourcesResult, promptsResult] = await Promise.all([
-          manager.getAllTools(),
-          manager.getAllResources(),
-          manager.getAllPrompts(),
-        ]);
-        spinner.stop();
+	program.action(
+		withCommand(
+			program,
+			{ spinnerText: "Connecting to servers...", errorLabel: "Failed to list servers" },
+			async ({ manager, formatOptions, spinner }) => {
+				const [toolsResult, resourcesResult, promptsResult] = await Promise.all([
+					manager.getAllTools(),
+					manager.getAllResources(),
+					manager.getAllPrompts(),
+				]);
+				spinner.stop();
 
-        const items: UnifiedItem[] = [
-          ...toolsResult.tools.map((t) => ({
-            server: t.server,
-            type: "tool" as const,
-            name: t.tool.name,
-            description: t.tool.description,
-          })),
-          ...resourcesResult.resources.map((r) => ({
-            server: r.server,
-            type: "resource" as const,
-            name: r.resource.uri,
-            description: r.resource.description,
-          })),
-          ...promptsResult.prompts.map((p) => ({
-            server: p.server,
-            type: "prompt" as const,
-            name: p.prompt.name,
-            description: p.prompt.description,
-          })),
-        ];
+				const items: UnifiedItem[] = [
+					...toolsResult.tools.map((t) => ({
+						server: t.server,
+						type: "tool" as const,
+						name: t.tool.name,
+						description: t.tool.description,
+					})),
+					...resourcesResult.resources.map((r) => ({
+						server: r.server,
+						type: "resource" as const,
+						name: r.resource.uri,
+						description: r.resource.description,
+					})),
+					...promptsResult.prompts.map((p) => ({
+						server: p.server,
+						type: "prompt" as const,
+						name: p.prompt.name,
+						description: p.prompt.description,
+					})),
+				];
 
-        const typeOrder = { tool: 0, resource: 1, prompt: 2 };
-        items.sort((a, b) => {
-          if (a.server !== b.server) return a.server.localeCompare(b.server);
-          if (a.type !== b.type) return typeOrder[a.type] - typeOrder[b.type];
-          return a.name.localeCompare(b.name);
-        });
+				const typeOrder = { tool: 0, resource: 1, prompt: 2 };
+				items.sort((a, b) => {
+					if (a.server !== b.server) return a.server.localeCompare(b.server);
+					if (a.type !== b.type) return typeOrder[a.type] - typeOrder[b.type];
+					return a.name.localeCompare(b.name);
+				});
 
-        const errors = [...toolsResult.errors, ...resourcesResult.errors, ...promptsResult.errors];
-        if (errors.length > 0) {
-          for (const err of errors) {
-            console.error(`"${err.server}": ${err.message}`);
-          }
-          if (items.length > 0) console.log("");
-        }
+				const errors = [...toolsResult.errors, ...resourcesResult.errors, ...promptsResult.errors];
+				if (errors.length > 0) {
+					for (const err of errors) {
+						console.error(`"${err.server}": ${err.message}`);
+					}
+					if (items.length > 0) console.log("");
+				}
 
-        console.log(formatUnifiedList(items, formatOptions));
-      },
-    ),
-  );
+				console.log(formatUnifiedList(items, formatOptions));
+			},
+		),
+	);
 }

package/src/commands/ping.ts

@@ -5,65 +5,62 @@ import { formatError } from "../output/formatter.ts";
 import { logger } from "../output/logger.ts";
 
 interface PingResult {
-  server: string;
-  success: boolean;
-  latencyMs?: number;
-  error?: string;
+	server: string;
+	success: boolean;
+	latencyMs?: number;
+	error?: string;
 }
 
 export function registerPingCommand(program: Command) {
-  program
-    .command("ping [servers...]")
-    .description("Check connectivity to MCP servers")
-    .action(async (servers: string[]) => {
-      const { manager, formatOptions } = await getContext(program);
+	program
+		.command("ping [servers...]")
+		.description("Check connectivity to MCP servers")
+		.action(async (servers: string[]) => {
+			const { manager, formatOptions } = await getContext(program);
 
-      const targetServers = servers.length > 0 ? servers : manager.getServerNames();
+			const targetServers = servers.length > 0 ? servers : manager.getServerNames();
 
-      if (targetServers.length === 0) {
-        console.error(formatError("No servers configured", formatOptions));
-        await manager.close();
-        process.exit(1);
-      }
+			if (targetServers.length === 0) {
+				console.error(formatError("No servers configured", formatOptions));
+				await manager.close();
+				process.exit(1);
+			}
 
-      const spinner = logger.startSpinner(
-        `Pinging ${targetServers.length} server(s)...`,
-        formatOptions,
-      );
+			const spinner = logger.startSpinner(`Pinging ${targetServers.length} server(s)...`, formatOptions);
 
-      const results: PingResult[] = [];
+			const results: PingResult[] = [];
 
-      try {
-        await Promise.all(
-          targetServers.map(async (serverName) => {
-            const start = Date.now();
-            try {
-              await manager.getClient(serverName);
-              results.push({ server: serverName, success: true, latencyMs: Date.now() - start });
-            } catch (err) {
-              results.push({ server: serverName, success: false, error: String(err) });
-            }
-          }),
-        );
+			try {
+				await Promise.all(
+					targetServers.map(async (serverName) => {
+						const start = Date.now();
+						try {
+							await manager.getClient(serverName);
+							results.push({ server: serverName, success: true, latencyMs: Date.now() - start });
+						} catch (err) {
+							results.push({ server: serverName, success: false, error: String(err) });
+						}
+					}),
+				);
 
-        spinner.stop();
+				spinner.stop();
 
-        if (formatOptions.json) {
-          console.log(JSON.stringify(results, null, 2));
-        } else {
-          for (const r of results) {
-            if (r.success) {
-              console.log(`${green("✔")} ${r.server} connected (${r.latencyMs}ms)`);
-            } else {
-              console.log(`${red("✖")} ${r.server} failed: ${r.error}`);
-            }
-          }
-        }
-      } finally {
-        await manager.close();
-      }
+				if (formatOptions.json) {
+					console.log(JSON.stringify(results, null, 2));
+				} else {
+					for (const r of results) {
+						if (r.success) {
+							console.log(`${green("✔")} ${r.server} connected (${r.latencyMs}ms)`);
+						} else {
+							console.log(`${red("✖")} ${r.server} failed: ${r.error}`);
+						}
+					}
+				}
+			} finally {
+				await manager.close();
+			}
 
-      const anyFailed = results.some((r) => !r.success);
-      if (anyFailed) process.exit(1);
-    });
+			const anyFailed = results.some((r) => !r.success);
+			if (anyFailed) process.exit(1);
+		});
 }

package/src/commands/prompt.ts

@@ -1,59 +1,49 @@
 import type { Command } from "commander";
-import {
-  formatPromptList,
-  formatServerPrompts,
-  formatPromptMessages,
-  formatError,
-} from "../output/formatter.ts";
 import { parseJsonArgs, readStdin } from "../lib/input.ts";
+import { formatError, formatPromptList, formatPromptMessages, formatServerPrompts } from "../output/formatter.ts";
 import { withCommand } from "./with-command.ts";
 
 export function registerPromptCommand(program: Command) {
-  program
-    .command("prompt [server] [name] [args]")
-    .description("list prompts for a server, or get a specific prompt")
-    .action(
-      withCommand(
-        program,
-        { spinnerText: "Connecting to servers..." },
-        async (
-          { manager, formatOptions, spinner },
-          server?: string,
-          name?: string,
-          argsStr?: string,
-        ) => {
-          if (server) {
-            spinner.update(`Connecting to ${server}...`);
-          }
+	program
+		.command("prompt [server] [name] [args]")
+		.description("list prompts for a server, or get a specific prompt")
+		.action(
+			withCommand(
+				program,
+				{ spinnerText: "Connecting to servers..." },
+				async ({ manager, formatOptions, spinner }, server?: string, name?: string, argsStr?: string) => {
+					if (server) {
+						spinner.update(`Connecting to ${server}...`);
+					}
 
-          if (server && name) {
-            let args: Record<string, string> | undefined;
+					if (server && name) {
+						let args: Record<string, string> | undefined;
 
-            if (argsStr) {
-              args = parseJsonArgs(argsStr, { coerceToString: true }) as Record<string, string>;
-            } else if (!process.stdin.isTTY) {
-              const stdin = await readStdin();
-              if (stdin.trim()) {
-                args = parseJsonArgs(stdin, { coerceToString: true }) as Record<string, string>;
-              }
-            }
+						if (argsStr) {
+							args = parseJsonArgs(argsStr, { coerceToString: true }) as Record<string, string>;
+						} else if (!process.stdin.isTTY) {
+							const stdin = await readStdin();
+							if (stdin.trim()) {
+								args = parseJsonArgs(stdin, { coerceToString: true }) as Record<string, string>;
+							}
+						}
 
-            const result = await manager.getPrompt(server, name, args);
-            spinner.stop();
-            console.log(formatPromptMessages(server, name, result, formatOptions));
-          } else if (server) {
-            const prompts = await manager.listPrompts(server);
-            spinner.stop();
-            console.log(formatServerPrompts(server, prompts, formatOptions));
-          } else {
-            const { prompts, errors } = await manager.getAllPrompts();
-            spinner.stop();
-            console.log(formatPromptList(prompts, formatOptions));
-            for (const err of errors) {
-              console.error(formatError(`${err.server}: ${err.message}`, formatOptions));
-            }
-          }
-        },
-      ),
-    );
+						const result = await manager.getPrompt(server, name, args);
+						spinner.stop();
+						console.log(formatPromptMessages(server, name, result, formatOptions));
+					} else if (server) {
+						const prompts = await manager.listPrompts(server);
+						spinner.stop();
+						console.log(formatServerPrompts(server, prompts, formatOptions));
+					} else {
+						const { prompts, errors } = await manager.getAllPrompts();
+						spinner.stop();
+						console.log(formatPromptList(prompts, formatOptions));
+						for (const err of errors) {
+							console.error(formatError(`${err.server}: ${err.message}`, formatOptions));
+						}
+					}
+				},
+			),
+		);
 }

package/src/commands/remove.ts

@@ -1,67 +1,65 @@
 import type { Command } from "commander";
 import {
-  loadRawServers,
-  loadRawAuth,
-  loadSearchIndex,
-  saveServers,
-  saveAuth,
-  saveSearchIndex,
+	loadRawAuth,
+	loadRawServers,
+	loadSearchIndex,
+	saveAuth,
+	saveSearchIndex,
+	saveServers,
 } from "../config/loader.ts";
 
 export function registerRemoveCommand(program: Command) {
-  program
-    .command("remove <name>")
-    .description("remove an MCP server from your config")
-    .option("--keep-auth", "keep stored authentication credentials")
-    .option("--dry-run", "show what would be removed without changing files")
-    .action(async (name: string, options: { keepAuth?: boolean; dryRun?: boolean }) => {
-      const configFlag = program.opts().config;
-      const { configDir, servers } = await loadRawServers(configFlag);
+	program
+		.command("remove <name>")
+		.description("remove an MCP server from your config")
+		.option("--keep-auth", "keep stored authentication credentials")
+		.option("--dry-run", "show what would be removed without changing files")
+		.action(async (name: string, options: { keepAuth?: boolean; dryRun?: boolean }) => {
+			const configFlag = program.opts().config;
+			const { configDir, servers } = await loadRawServers(configFlag);
 
-      if (!servers.mcpServers[name]) {
-        console.error(`Unknown server: "${name}"`);
-        process.exit(1);
-      }
+			if (!servers.mcpServers[name]) {
+				console.error(`Unknown server: "${name}"`);
+				process.exit(1);
+			}
 
-      if (options.dryRun) {
-        console.log(`Would remove server "${name}" from ${configDir}/servers.json`);
-        if (!options.keepAuth) {
-          const auth = await loadRawAuth(configDir);
-          if (auth[name]) {
-            console.log(`Would remove auth for "${name}" from ${configDir}/auth.json`);
-          }
-        }
-        const searchIndex = await loadSearchIndex(configDir);
-        const indexedCount = searchIndex.tools.filter((t) => t.server === name).length;
-        if (indexedCount > 0) {
-          console.log(
-            `Would remove ${indexedCount} tool(s) for "${name}" from ${configDir}/search.json`,
-          );
-        }
-        return;
-      }
+			if (options.dryRun) {
+				console.log(`Would remove server "${name}" from ${configDir}/servers.json`);
+				if (!options.keepAuth) {
+					const auth = await loadRawAuth(configDir);
+					if (auth[name]) {
+						console.log(`Would remove auth for "${name}" from ${configDir}/auth.json`);
+					}
+				}
+				const searchIndex = await loadSearchIndex(configDir);
+				const indexedCount = searchIndex.tools.filter((t) => t.server === name).length;
+				if (indexedCount > 0) {
+					console.log(`Would remove ${indexedCount} tool(s) for "${name}" from ${configDir}/search.json`);
+				}
+				return;
+			}
 
-      delete servers.mcpServers[name];
-      await saveServers(configDir, servers);
-      console.log(`Removed server "${name}" from ${configDir}/servers.json`);
+			delete servers.mcpServers[name];
+			await saveServers(configDir, servers);
+			console.log(`Removed server "${name}" from ${configDir}/servers.json`);
 
-      if (!options.keepAuth) {
-        const auth = await loadRawAuth(configDir);
-        if (auth[name]) {
-          delete auth[name];
-          await saveAuth(configDir, auth);
-          console.log(`Removed auth for "${name}" from ${configDir}/auth.json`);
-        }
-      }
+			if (!options.keepAuth) {
+				const auth = await loadRawAuth(configDir);
+				if (auth[name]) {
+					delete auth[name];
+					await saveAuth(configDir, auth);
+					console.log(`Removed auth for "${name}" from ${configDir}/auth.json`);
+				}
+			}
 
-      // Remove tools for this server from the search index
-      const searchIndex = await loadSearchIndex(configDir);
-      const before = searchIndex.tools.length;
-      searchIndex.tools = searchIndex.tools.filter((t) => t.server !== name);
-      const removed = before - searchIndex.tools.length;
-      if (removed > 0) {
-        await saveSearchIndex(configDir, searchIndex);
-        console.log(`Removed ${removed} tool(s) for "${name}" from ${configDir}/search.json`);
-      }
-    });
+			// Remove tools for this server from the search index
+			const searchIndex = await loadSearchIndex(configDir);
+			const before = searchIndex.tools.length;
+			searchIndex.tools = searchIndex.tools.filter((t) => t.server !== name);
+			const removed = before - searchIndex.tools.length;
+			if (removed > 0) {
+				await saveSearchIndex(configDir, searchIndex);
+				console.log(`Removed ${removed} tool(s) for "${name}" from ${configDir}/search.json`);
+			}
+		});
 }

package/src/commands/resource.ts

@@ -1,42 +1,37 @@
 import type { Command } from "commander";
-import {
-  formatResourceList,
-  formatServerResources,
-  formatResourceContents,
-  formatError,
-} from "../output/formatter.ts";
+import { formatError, formatResourceContents, formatResourceList, formatServerResources } from "../output/formatter.ts";
 import { withCommand } from "./with-command.ts";
 
 export function registerResourceCommand(program: Command) {
-  program
-    .command("resource [server] [uri]")
-    .description("list resources for a server, or read a specific resource")
-    .action(
-      withCommand(
-        program,
-        { spinnerText: "Connecting to servers..." },
-        async ({ manager, formatOptions, spinner }, server?: string, uri?: string) => {
-          if (server) {
-            spinner.update(`Connecting to ${server}...`);
-          }
+	program
+		.command("resource [server] [uri]")
+		.description("list resources for a server, or read a specific resource")
+		.action(
+			withCommand(
+				program,
+				{ spinnerText: "Connecting to servers..." },
+				async ({ manager, formatOptions, spinner }, server?: string, uri?: string) => {
+					if (server) {
+						spinner.update(`Connecting to ${server}...`);
+					}
 
-          if (server && uri) {
-            const result = await manager.readResource(server, uri);
-            spinner.stop();
-            console.log(formatResourceContents(server, uri, result, formatOptions));
-          } else if (server) {
-            const resources = await manager.listResources(server);
-            spinner.stop();
-            console.log(formatServerResources(server, resources, formatOptions));
-          } else {
-            const { resources, errors } = await manager.getAllResources();
-            spinner.stop();
-            console.log(formatResourceList(resources, formatOptions));
-            for (const err of errors) {
-              console.error(formatError(`${err.server}: ${err.message}`, formatOptions));
-            }
-          }
-        },
-      ),
-    );
+					if (server && uri) {
+						const result = await manager.readResource(server, uri);
+						spinner.stop();
+						console.log(formatResourceContents(server, uri, result, formatOptions));
+					} else if (server) {
+						const resources = await manager.listResources(server);
+						spinner.stop();
+						console.log(formatServerResources(server, resources, formatOptions));
+					} else {
+						const { resources, errors } = await manager.getAllResources();
+						spinner.stop();
+						console.log(formatResourceList(resources, formatOptions));
+						for (const err of errors) {
+							console.error(formatError(`${err.server}: ${err.message}`, formatOptions));
+						}
+					}
+				},
+			),
+		);
 }