@evantahler/mcpx 0.15.3 → 0.15.8

package/README.md

@@ -626,6 +626,8 @@ Inspired by [mcp-cli](https://github.com/philschmid/mcp-cli) by Phil Schmid, whi
 
 ## Why mcpx?
 
+mcpx is the client. If you need the server side — auth, governance, and production tools at scale — check out [Arcade](https://arcade.dev).
+
 The full story: [curl for MCP: Why Coding Agents Are Happier Using the CLI](https://arcade.dev/blog/curl-for-mcp)
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evantahler/mcpx",
-  "version": "0.15.3",
+  "version": "0.15.8",
   "description": "A command-line interface for MCP servers. curl for MCP.",
   "type": "module",
   "bin": {

package/src/client/http.ts

@@ -1,25 +1,6 @@
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import type { HttpServerConfig } from "../config/schemas.ts";
-import pkg from "../../package.json";
-import { createDebugFetch } from "./debug-fetch.ts";
+import { buildTransportInit, type TransportDeps } from "./transport-options.ts";
 
-export function createHttpTransport(
-  config: HttpServerConfig,
-  authProvider?: OAuthClientProvider,
-  verbose = false,
-  showSecrets = false,
-): StreamableHTTPClientTransport {
-  const requestInit: RequestInit = {};
-  const userAgent = `${pkg.name}/${pkg.version}`;
-  requestInit.headers = {
-    "User-Agent": userAgent,
-    ...config.headers,
-  };
-
-  return new StreamableHTTPClientTransport(new URL(config.url), {
-    authProvider,
-    requestInit,
-    fetch: verbose ? createDebugFetch(showSecrets) : undefined,
-  });
+export function createHttpTransport(deps: TransportDeps): StreamableHTTPClientTransport {
+  return new StreamableHTTPClientTransport(new URL(deps.config.url), buildTransportInit(deps));
 }

package/src/client/manager.ts

@@ -34,18 +34,19 @@ import { McpOAuthProvider } from "./oauth.ts";
 import { logger } from "../output/logger.ts";
 import { wrapTransportWithTrace } from "./trace.ts";
 
-export interface ToolWithServer {
+interface WithServer {
   server: string;
+}
+
+export interface ToolWithServer extends WithServer {
   tool: Tool;
 }
 
-export interface ResourceWithServer {
-  server: string;
+export interface ResourceWithServer extends WithServer {
   resource: Resource;
 }
 
-export interface PromptWithServer {
-  server: string;
+export interface PromptWithServer extends WithServer {
   prompt: Prompt;
 }
 
@@ -160,12 +161,12 @@ export class ServerManager {
             // ignore close errors
           }
           const provider = this.getOrCreateOAuthProvider(serverName);
-          const rawSseTransport = createSseTransport(
+          const rawSseTransport = createSseTransport({
             config,
-            provider.isComplete() ? provider : undefined,
-            this.verbose,
-            this.showSecrets,
-          );
+            authProvider: provider.isComplete() ? provider : undefined,
+            verbose: this.verbose,
+            showSecrets: this.showSecrets,
+          });
           const sseTransport = this.verbose
             ? wrapTransportWithTrace(rawSseTransport, { json: this.json, serverName })
             : rawSseTransport;
@@ -245,11 +246,21 @@ export class ServerManager {
       const authProvider = provider.isComplete() ? provider : undefined;
 
       if (config.transport === "sse") {
-        return createSseTransport(config, authProvider, this.verbose, this.showSecrets);
+        return createSseTransport({
+          config,
+          authProvider,
+          verbose: this.verbose,
+          showSecrets: this.showSecrets,
+        });
       }
       // Default (including explicit "streamable-http") uses Streamable HTTP.
       // When no transport is set, getClient() will auto-fallback to SSE on failure.
-      return createHttpTransport(config, authProvider, this.verbose, this.showSecrets);
+      return createHttpTransport({
+        config,
+        authProvider,
+        verbose: this.verbose,
+        showSecrets: this.showSecrets,
+      });
     }
     throw new Error("Invalid server config");
   }
@@ -322,20 +333,31 @@ export class ServerManager {
     throw lastError;
   }
 
-  /** List tools for a single server, applying allowedTools/disabledTools filters */
-  async listTools(serverName: string): Promise<Tool[]> {
+  /** Get client, call method with timeout, wrapped in retry logic */
+  private async callWithResilience<T>(
+    serverName: string,
+    label: string,
+    fn: (client: Client) => Promise<T>,
+  ): Promise<T> {
     return this.withRetry(
       async () => {
         const client = await this.getClient(serverName);
-        const result = await this.withTimeout(client.listTools(), `listTools(${serverName})`);
-        const config = this.servers.mcpServers[serverName]!;
-        return filterTools(result.tools, config.allowedTools, config.disabledTools);
+        return this.withTimeout(fn(client), label);
       },
-      `listTools(${serverName})`,
+      label,
       serverName,
     );
   }
 
+  /** List tools for a single server, applying allowedTools/disabledTools filters */
+  async listTools(serverName: string): Promise<Tool[]> {
+    return this.callWithResilience(serverName, `listTools(${serverName})`, async (client) => {
+      const result = await client.listTools();
+      const config = this.servers.mcpServers[serverName]!;
+      return filterTools(result.tools, config.allowedTools, config.disabledTools);
+    });
+  }
+
   /** List tools across all configured servers */
   async getAllTools(): Promise<{ tools: ToolWithServer[]; errors: ServerError[] }> {
     const { items: tools, errors } = await this.gatherFromServers(async (name) => {
@@ -351,16 +373,8 @@ export class ServerManager {
     toolName: string,
     args: Record<string, unknown> = {},
   ): Promise<unknown> {
-    return this.withRetry(
-      async () => {
-        const client = await this.getClient(serverName);
-        return this.withTimeout(
-          client.callTool({ name: toolName, arguments: args }),
-          `callTool(${serverName}/${toolName})`,
-        );
-      },
-      `callTool(${serverName}/${toolName})`,
-      serverName,
+    return this.callWithResilience(serverName, `callTool(${serverName}/${toolName})`, (client) =>
+      client.callTool({ name: toolName, arguments: args }),
     );
   }
 
@@ -382,18 +396,10 @@ export class ServerManager {
 
   /** List resources for a single server */
   async listResources(serverName: string): Promise<Resource[]> {
-    return this.withRetry(
-      async () => {
-        const client = await this.getClient(serverName);
-        const result = await this.withTimeout(
-          client.listResources(),
-          `listResources(${serverName})`,
-        );
-        return result.resources;
-      },
-      `listResources(${serverName})`,
-      serverName,
-    );
+    return this.callWithResilience(serverName, `listResources(${serverName})`, async (client) => {
+      const result = await client.listResources();
+      return result.resources;
+    });
   }
 
   /** List resources across all configured servers (skips servers without resources capability) */
@@ -409,27 +415,17 @@ export class ServerManager {
 
   /** Read a specific resource by URI */
   async readResource(serverName: string, uri: string): Promise<unknown> {
-    return this.withRetry(
-      async () => {
-        const client = await this.getClient(serverName);
-        return this.withTimeout(client.readResource({ uri }), `readResource(${serverName}/${uri})`);
-      },
-      `readResource(${serverName}/${uri})`,
-      serverName,
+    return this.callWithResilience(serverName, `readResource(${serverName}/${uri})`, (client) =>
+      client.readResource({ uri }),
     );
   }
 
   /** List prompts for a single server */
   async listPrompts(serverName: string): Promise<Prompt[]> {
-    return this.withRetry(
-      async () => {
-        const client = await this.getClient(serverName);
-        const result = await this.withTimeout(client.listPrompts(), `listPrompts(${serverName})`);
-        return result.prompts;
-      },
-      `listPrompts(${serverName})`,
-      serverName,
-    );
+    return this.callWithResilience(serverName, `listPrompts(${serverName})`, async (client) => {
+      const result = await client.listPrompts();
+      return result.prompts;
+    });
   }
 
   /** List prompts across all configured servers (skips servers without prompts capability) */
@@ -449,16 +445,8 @@ export class ServerManager {
     name: string,
     args?: Record<string, string>,
   ): Promise<unknown> {
-    return this.withRetry(
-      async () => {
-        const client = await this.getClient(serverName);
-        return this.withTimeout(
-          client.getPrompt({ name, arguments: args }),
-          `getPrompt(${serverName}/${name})`,
-        );
-      },
-      `getPrompt(${serverName}/${name})`,
-      serverName,
+    return this.callWithResilience(serverName, `getPrompt(${serverName}/${name})`, (client) =>
+      client.getPrompt({ name, arguments: args }),
     );
   }
 

package/src/client/sse.ts

@@ -1,17 +1,6 @@
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import type { HttpServerConfig } from "../config/schemas.ts";
-import { createDebugFetch } from "./debug-fetch.ts";
+import { buildTransportInit, type TransportDeps } from "./transport-options.ts";
 
-export function createSseTransport(
-  config: HttpServerConfig,
-  authProvider?: OAuthClientProvider,
-  verbose = false,
-  showSecrets = false,
-): SSEClientTransport {
-  return new SSEClientTransport(new URL(config.url), {
-    authProvider,
-    requestInit: config.headers ? { headers: config.headers } : undefined,
-    fetch: verbose ? createDebugFetch(showSecrets) : undefined,
-  });
+export function createSseTransport(deps: TransportDeps): SSEClientTransport {
+  return new SSEClientTransport(new URL(deps.config.url), buildTransportInit(deps));
 }

package/src/client/transport-options.ts

@@ -0,0 +1,31 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { HttpServerConfig } from "../config/schemas.ts";
+import { createDebugFetch, type FetchLike } from "./debug-fetch.ts";
+import pkg from "../../package.json";
+
+export interface TransportDeps {
+  config: HttpServerConfig;
+  authProvider?: OAuthClientProvider;
+  verbose?: boolean;
+  showSecrets?: boolean;
+}
+
+/** Build shared transport init options (auth, headers, User-Agent, debug fetch) */
+export function buildTransportInit(deps: TransportDeps): {
+  authProvider?: OAuthClientProvider;
+  requestInit: RequestInit;
+  fetch?: FetchLike;
+} {
+  const { config, authProvider, verbose = false, showSecrets = false } = deps;
+  const userAgent = `${pkg.name}/${pkg.version}`;
+  return {
+    authProvider,
+    requestInit: {
+      headers: {
+        "User-Agent": userAgent,
+        ...config.headers,
+      },
+    },
+    fetch: verbose ? createDebugFetch(showSecrets) : undefined,
+  };
+}

package/src/commands/exec.ts

@@ -10,6 +10,7 @@ import {
 import { logger } from "../output/logger.ts";
 import { validateToolInput } from "../validation/schema.ts";
 import { parseJsonArgs, readStdin } from "../lib/input.ts";
+import { DEFAULTS } from "../constants.ts";
 
 export function registerExecCommand(program: Command) {
   program
@@ -17,7 +18,7 @@ export function registerExecCommand(program: Command) {
     .description("execute a tool (omit tool name to list available tools)")
     .option("-f, --file <path>", "read JSON args from a file")
     .option("--no-wait", "return task handle immediately without waiting for completion")
-    .option("--ttl <ms>", "task TTL in milliseconds", "60000")
+    .option("--ttl <ms>", "task TTL in milliseconds", String(DEFAULTS.TASK_TTL_MS))
     .action(
       async (
         server: string,

package/src/commands/index.ts

@@ -4,32 +4,27 @@ import { getContext } from "../context.ts";
 import { buildSearchIndex } from "../search/indexer.ts";
 import { getStaleServers } from "../search/staleness.ts";
 import { saveSearchIndex } from "../config/loader.ts";
-import { formatError } from "../output/formatter.ts";
 import { logger } from "../output/logger.ts";
+import { withCommand } from "./with-command.ts";
 
 /** Run the search index build. Reusable from other commands (e.g. add). */
 export async function runIndex(program: Command): Promise<void> {
-  const { config, manager, formatOptions } = await getContext(program);
-  const spinner = logger.startSpinner("Connecting to servers...", formatOptions);
+  await withCommand(
+    program,
+    { spinnerText: "Connecting to servers...", errorLabel: "Indexing failed" },
+    async ({ config, manager, spinner }) => {
+      const start = performance.now();
+      const index = await buildSearchIndex(manager, (progress) => {
+        spinner.update(`Indexing ${progress.current}/${progress.total}: ${progress.tool}`);
+      });
+      const elapsed = ((performance.now() - start) / 1000).toFixed(1);
 
-  try {
-    const start = performance.now();
-    const index = await buildSearchIndex(manager, (progress) => {
-      spinner.update(`Indexing ${progress.current}/${progress.total}: ${progress.tool}`);
-    });
-    const elapsed = ((performance.now() - start) / 1000).toFixed(1);
-
-    await saveSearchIndex(config.configDir, index);
-    spinner.success(`Indexed ${index.tools.length} tools in ${elapsed}s`);
+      await saveSearchIndex(config.configDir, index);
+      spinner.success(`Indexed ${index.tools.length} tools in ${elapsed}s`);
 
-    logger.info(`Saved to ${config.configDir}/search.json`);
-  } catch (err) {
-    spinner.error("Indexing failed");
-    console.error(formatError(String(err), formatOptions));
-    process.exit(1);
-  } finally {
-    await manager.close();
-  }
+      logger.info(`Saved to ${config.configDir}/search.json`);
+    },
+  )();
 }
 
 export function registerIndexCommand(program: Command) {

package/src/commands/info.ts

@@ -1,63 +1,58 @@
 import type { Command } from "commander";
 import type { Tool, Resource, Prompt } from "../config/schemas.ts";
-import { getContext } from "../context.ts";
 import { formatServerOverview, formatToolSchema, formatError } from "../output/formatter.ts";
-import { logger } from "../output/logger.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(async (server: string, tool: string | undefined) => {
-      const { manager, formatOptions } = await getContext(program);
-      const target = tool ? `${server}/${tool}` : server;
-      const spinner = logger.startSpinner(`Connecting to ${target}...`, formatOptions);
-      try {
-        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 {
-          // Get server info first to check capabilities
-          const serverInfo = await manager.getServerInfo(server);
-          const caps = serverInfo.capabilities as Record<string, unknown> | undefined;
+    .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;
 
-          // Only fetch what the server supports
-          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,
-            ),
-          );
-        }
-      } catch (err) {
-        spinner.error(`Failed to connect to ${target}`);
-        console.error(formatError(String(err), formatOptions));
-        process.exit(1);
-      } finally {
-        await manager.close();
-      }
-    });
+            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,64 +1,59 @@
 import type { Command } from "commander";
-import { getContext } from "../context.ts";
-import { formatUnifiedList, formatError } from "../output/formatter.ts";
+import { formatUnifiedList } from "../output/formatter.ts";
 import type { UnifiedItem } from "../output/formatter.ts";
-import { logger } from "../output/logger.ts";
+import { withCommand } from "./with-command.ts";
 
 export function registerListCommand(program: Command) {
-  program.action(async () => {
-    const { manager, formatOptions } = await getContext(program);
-    const spinner = logger.startSpinner("Connecting to servers...", formatOptions);
-    try {
-      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}`);
+        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("");
         }
-        if (items.length > 0) console.log("");
-      }
 
-      console.log(formatUnifiedList(items, formatOptions));
-    } catch (err) {
-      spinner.error("Failed to list servers");
-      console.error(formatError(String(err), formatOptions));
-      process.exit(1);
-    } finally {
-      await manager.close();
-    }
-  });
+        console.log(formatUnifiedList(items, formatOptions));
+      },
+    ),
+  );
 }

package/src/commands/prompt.ts

@@ -1,26 +1,31 @@
 import type { Command } from "commander";
-import { getContext } from "../context.ts";
 import {
   formatPromptList,
   formatServerPrompts,
   formatPromptMessages,
   formatError,
 } from "../output/formatter.ts";
-import { logger } from "../output/logger.ts";
 import { parseJsonArgs, readStdin } from "../lib/input.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(
-      async (server: string | undefined, name: string | undefined, argsStr: string | undefined) => {
-        const { manager, formatOptions } = await getContext(program);
-        const spinner = logger.startSpinner(
-          server ? `Connecting to ${server}...` : "Connecting to servers...",
-          formatOptions,
-        );
-        try {
+      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;
 
@@ -48,13 +53,7 @@ export function registerPromptCommand(program: Command) {
               console.error(formatError(`${err.server}: ${err.message}`, formatOptions));
             }
           }
-        } catch (err) {
-          spinner.error("Failed");
-          console.error(formatError(String(err), formatOptions));
-          process.exit(1);
-        } finally {
-          await manager.close();
-        }
-      },
+        },
+      ),
     );
 }