@evantahler/mcpx 0.15.4 → 0.15.9

package/.claude/skills/mcpx.md

@@ -29,12 +29,15 @@ mcpx exec <server> <tool> '<json args>'
 mcpx exec <server> <tool> -f params.json
 ```
 
+Output is JSON when piped. Use `--json` to force JSON output in any context — prefer this when you need to parse results programmatically.
+
 ## Rules
 
 - Always search before executing — don't assume tool names exist
 - Always inspect the schema before executing — validate you have the right arguments
 - Use `mcpx search -k` for exact name matching
 - Pipe results through `jq` when you need to extract specific fields
+- Use `--json` when parsing output programmatically (automatic when piped, but explicit is safer)
 - Use `-v` for verbose debugging (HTTP details + JSON-RPC protocol messages) if an exec fails unexpectedly
 - Use `-l debug` to see all server log messages, or `-l error` for errors only
 
@@ -58,16 +61,22 @@ mcpx exec github search_repositories '{"query":"mcp"}' \
 # Read args from stdin
 echo '{"path":"./README.md"}' | mcpx exec filesystem read_file
 
-# Pipe from a file
-cat params.json | mcpx exec server tool
-
 # Read args from a file with --file flag
 mcpx exec filesystem read_file -f params.json
 ```
 
-## 4. Long-running tools (Tasks)
+## Troubleshooting
+
+- **"Not authenticated" / 401 error** → Run `mcpx auth <server>` to start the OAuth flow
+- **Exec timeout** → Use `-v` to see where it stalls; set `MCP_TIMEOUT=<seconds>` to increase the timeout (default: 1800)
+- **Search returns no results** → Try `mcpx search -k "*keyword*"` for glob matching, or `mcpx index` to rebuild the search index
+- **Missing or stale tools** → Run `mcpx index` to rebuild; any command that connects to a server also auto-updates the index
+- **Server won't connect** → Run `mcpx ping <server>` to check connectivity; use `-v` for protocol-level details
+- **Auth token expired** → Run `mcpx auth <server> -r` to force a token refresh
+
+## Long-running tools (Tasks)
 
-Some tools support async execution via MCP Tasks. mcpx auto-detects this and uses task-augmented execution when available.
+Some tools support async execution via MCP Tasks. mcpx auto-detects this.
 
 ```bash
 # Default: waits for the task to complete, showing progress
@@ -76,90 +85,121 @@ mcpx exec my-server long_running_tool '{"input": "data"}'
 # Return immediately with a task handle (for scripting/polling)
 mcpx exec my-server long_running_tool '{"input": "data"}' --no-wait
 
-# Check task status
+# Check task status / retrieve result / cancel
 mcpx task get my-server <taskId>
-
-# Retrieve the result once complete
 mcpx task result my-server <taskId>
-
-# List all tasks on a server
-mcpx task list my-server
-
-# Cancel a running task
 mcpx task cancel my-server <taskId>
+mcpx task list my-server
 ```
 
-For tools that don't support tasks, `exec` works exactly as before.
-
-## 5. Elicitation (Server-Requested Input)
-
-Some servers request user input mid-operation (e.g., confirmations, auth flows). mcpx handles this automatically:
-
-```bash
-# Interactive — prompts appear in the terminal
-mcpx exec my-server deploy_tool '{"target": "staging"}'
-# Server requests input: Confirm deployment
-#   *Confirm [y/n]: y
-
-# Non-interactive — decline all elicitation (for scripts/CI)
-mcpx exec my-server deploy_tool '{"target": "staging"}' --no-interactive
+## Elicitation (Server-Requested Input)
 
-# JSON mode — read/write elicitation as JSON via stdin/stdout
-echo '{"action":"accept","content":{"confirm":true}}' | \
-  mcpx exec my-server deploy_tool '{"target": "staging"}' --json
-```
+Some servers request user input mid-operation. mcpx handles this automatically in interactive mode. Use `-N` / `--no-interactive` to decline all elicitation (for scripts/CI), or `--json` to handle elicitation programmatically via stdin/stdout.
 
 ## Authentication
 
-Some HTTP servers require OAuth. If you see an "Not authenticated" error:
-
 ```bash
-mcpx auth <server>        # authenticate via browser
-mcpx auth <server> -s     # check token status and TTL
-mcpx auth <server> -r     # force token refresh
-mcpx deauth <server>      # remove stored auth
+mcpx auth <server>             # authenticate via browser
+mcpx auth <server> -s          # check token status and TTL
+mcpx auth <server> -r          # force token refresh
+mcpx auth <server> --no-index  # authenticate without rebuilding search index
+mcpx deauth <server>           # remove stored auth
 ```
 
 ## Available commands
 
 | Command                                | Purpose                           |
 | -------------------------------------- | --------------------------------- |
-| `mcpx`                               | List all servers and tools        |
-| `mcpx servers`                       | List servers (name, type, detail) |
-| `mcpx -d`                            | List with descriptions            |
-| `mcpx info <server>`                 | Server overview (version, capabilities, tools) |
-| `mcpx info <server> <tool>`          | Show tool schema                  |
-| `mcpx exec <server>`                 | List tools for a server           |
-| `mcpx exec <server> <tool> '<json>'` | Execute a tool                    |
-| `mcpx exec <server> <tool> -f file`  | Execute with args from file       |
-| `mcpx search "<query>"`              | Search tools (keyword + semantic) |
-| `mcpx search -k "<pattern>"`         | Keyword/glob search only          |
-| `mcpx search -q "<query>"`           | Semantic search only              |
-| `mcpx search -n <number> "<query>"`  | Limit number of results (default: 10) |
-| `mcpx index`                         | Build/rebuild search index        |
-| `mcpx index -i`                      | Show index status                 |
-| `mcpx auth <server>`                 | Authenticate with OAuth           |
-| `mcpx auth <server> -s`              | Check token status and TTL        |
+| `mcpx`                                | List all servers and tools        |
+| `mcpx servers`                        | List servers (name, type, detail) |
+| `mcpx -d`                             | List with descriptions            |
+| `mcpx info <server>`                  | Server overview (version, capabilities, tools) |
+| `mcpx info <server> <tool>`           | Show tool schema                  |
+| `mcpx exec <server>`                  | List tools for a server           |
+| `mcpx exec <server> <tool> '<json>'`  | Execute a tool                    |
+| `mcpx exec <server> <tool> -f file`   | Execute with args from file       |
+| `mcpx search "<query>"`               | Search tools (keyword + semantic) |
+| `mcpx search -k "<pattern>"`          | Keyword/glob search only          |
+| `mcpx search -q "<query>"`            | Semantic search only              |
+| `mcpx search -n <number> "<query>"`   | Limit number of results (default: 10) |
+| `mcpx index`                          | Build/rebuild search index        |
+| `mcpx index -i`                       | Show index status                 |
+| `mcpx auth <server>`                  | Authenticate with OAuth           |
+| `mcpx auth <server> -s`               | Check token status and TTL        |
 | `mcpx auth <server> -r`              | Force token refresh               |
-| `mcpx deauth <server>`               | Remove stored authentication      |
-| `mcpx ping`                          | Check connectivity to all servers |
-| `mcpx ping <server> [server2...]`    | Check specific server(s)          |
-| `mcpx add <name> --command <cmd>`    | Add a stdio MCP server            |
-| `mcpx add <name> --url <url>`        | Add an HTTP MCP server            |
-| `mcpx add <name> --url <url> --transport sse` | Add a legacy SSE server  |
-| `mcpx remove <name>`                 | Remove an MCP server              |
-| `mcpx skill install --claude`        | Install mcpx skill for Claude   |
-| `mcpx skill install --cursor`        | Install mcpx rule for Cursor    |
-| `mcpx resource`                     | List all resources across servers |
-| `mcpx resource <server>`            | List resources for a server       |
-| `mcpx resource <server> <uri>`      | Read a specific resource          |
-| `mcpx prompt`                       | List all prompts across servers   |
-| `mcpx prompt <server>`              | List prompts for a server         |
-| `mcpx prompt <server> <name> '<json>'` | Get a specific prompt          |
-| `mcpx exec <server> <tool> --no-wait` | Execute as async task, return handle |
-| `mcpx exec <server> <tool> --ttl <ms>` | Set task TTL (default: 60000) |
-| `mcpx -N exec <server> <tool> ...`  | Decline elicitation (non-interactive) |
-| `mcpx task list <server>`            | List tasks on a server          |
-| `mcpx task get <server> <taskId>`    | Get task status                 |
-| `mcpx task result <server> <taskId>` | Retrieve completed task result  |
-| `mcpx task cancel <server> <taskId>` | Cancel a running task           |
+| `mcpx auth <server> --no-index`       | Authenticate without rebuilding index |
+| `mcpx deauth <server>`                | Remove stored authentication      |
+| `mcpx ping`                           | Check connectivity to all servers |
+| `mcpx ping <server> [server2...]`     | Check specific server(s)          |
+| `mcpx add <name> --command <cmd>`     | Add a stdio MCP server            |
+| `mcpx add <name> --url <url>`         | Add an HTTP MCP server            |
+| `mcpx remove <name>`                  | Remove an MCP server              |
+| `mcpx skill install --claude`         | Install mcpx skill for Claude     |
+| `mcpx skill install --cursor`         | Install mcpx rule for Cursor      |
+| `mcpx resource`                       | List all resources across servers |
+| `mcpx resource <server>`              | List resources for a server       |
+| `mcpx resource <server> <uri>`        | Read a specific resource          |
+| `mcpx prompt`                         | List all prompts across servers   |
+| `mcpx prompt <server>`                | List prompts for a server         |
+| `mcpx prompt <server> <name> '<json>'` | Get a specific prompt            |
+| `mcpx task list <server>`             | List tasks on a server            |
+| `mcpx task get <server> <taskId>`     | Get task status                   |
+| `mcpx task result <server> <taskId>`  | Retrieve completed task result    |
+| `mcpx task cancel <server> <taskId>`  | Cancel a running task             |
+
+## Global flags
+
+| Flag                      | Purpose                                                  |
+| ------------------------- | -------------------------------------------------------- |
+| `-j, --json`              | Force JSON output (default when piped)                   |
+| `-v, --verbose`           | Show HTTP details and JSON-RPC protocol messages         |
+| `-d, --with-descriptions` | Include tool descriptions in list output                 |
+| `-c, --config <path>`     | Specify config file location                             |
+| `-N, --no-interactive`    | Decline server elicitation requests (for scripted usage) |
+| `-S, --show-secrets`      | Show full auth tokens in verbose output (unmasked)       |
+| `-l, --log-level <level>` | Minimum server log level to display (default: `warning`) |
+
+## `add` options
+
+| Flag                       | Purpose                                |
+| -------------------------- | -------------------------------------- |
+| `--command <cmd>`          | Command to run (stdio server)          |
+| `--args <a1,a2,...>`       | Comma-separated arguments              |
+| `--env <KEY=VAL,...>`      | Comma-separated environment variables  |
+| `--cwd <dir>`              | Working directory for the command      |
+| `--url <url>`              | Server URL (HTTP server)               |
+| `--header <Key:Value>`     | HTTP header (repeatable)               |
+| `--transport <type>`       | Transport: `sse` or `streamable-http`  |
+| `--allowed-tools <t1,t2>`  | Comma-separated allowed tool patterns  |
+| `--disabled-tools <t1,t2>` | Comma-separated disabled tool patterns |
+| `-f, --force`              | Overwrite if server already exists     |
+| `--no-auth`                | Skip automatic OAuth after adding      |
+| `--no-index`               | Skip rebuilding the search index       |
+
+## `remove` options
+
+| Flag          | Purpose                                          |
+| ------------- | ------------------------------------------------ |
+| `--keep-auth` | Don't remove stored auth credentials             |
+| `--dry-run`   | Show what would be removed without changing files |
+
+## `skill install` options
+
+| Flag        | Purpose                                    |
+| ----------- | ------------------------------------------ |
+| `--claude`  | Install skill for Claude Code              |
+| `--cursor`  | Install rule for Cursor                    |
+| `--global`  | Install to global location (`~/`)          |
+| `--project` | Install to project location (default)      |
+| `-f, --force` | Overwrite if file already exists         |
+
+## Environment variables
+
+| Variable          | Purpose                     | Default    |
+| ----------------- | --------------------------- | ---------- |
+| `MCP_CONFIG_PATH` | Config directory path       | `~/.mcpx/` |
+| `MCP_TIMEOUT`     | Request timeout (seconds)   | `1800`     |
+| `MCP_CONCURRENCY` | Parallel server connections | `5`        |
+| `MCP_MAX_RETRIES` | Retry attempts              | `3`        |
+| `MCP_STRICT_ENV`  | Error on missing `${VAR}`   | `true`     |
+| `MCP_DEBUG`       | Enable debug output         | `false`    |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evantahler/mcpx",
-  "version": "0.15.4",
+  "version": "0.15.9",
   "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) {