@evantahler/mcpcli 0.5.1 → 0.6.4

package/.claude/skills/mcpcli.md

@@ -87,7 +87,15 @@ mcpcli deauth <server>      # remove stored auth
 | `mcpcli auth <server> -s`              | Check token status and TTL        |
 | `mcpcli auth <server> -r`              | Force token refresh               |
 | `mcpcli deauth <server>`               | Remove stored authentication      |
+| `mcpcli ping`                          | Check connectivity to all servers |
+| `mcpcli ping <server> [server2...]`    | Check specific server(s)          |
 | `mcpcli add <name> --command <cmd>`    | Add a stdio MCP server            |
 | `mcpcli add <name> --url <url>`        | Add an HTTP MCP server            |
 | `mcpcli remove <name>`                 | Remove an MCP server              |
 | `mcpcli skill install --claude`        | Install mcpcli skill for Claude   |
+| `mcpcli resource`                     | List all resources across servers |
+| `mcpcli resource <server>`            | List resources for a server       |
+| `mcpcli resource <server> <uri>`      | Read a specific resource          |
+| `mcpcli prompt`                       | List all prompts across servers   |
+| `mcpcli prompt <server>`              | List prompts for a server         |
+| `mcpcli prompt <server> <name> '<json>'` | Get a specific prompt          |

package/README.md

@@ -49,26 +49,34 @@ mcpcli search -q "manage pull requests"
 
 ## Commands
 
-| Command                              | Description                                  |
-| ------------------------------------ | -------------------------------------------- |
-| `mcpcli`                             | List all configured servers and tools        |
-| `mcpcli info <server>`               | Show tools for a server                      |
-| `mcpcli info <server> <tool>`        | Show tool schema                             |
-| `mcpcli search <query>`              | Search tools (keyword + semantic)            |
-| `mcpcli search -k <pattern>`         | Keyword/glob search only                     |
-| `mcpcli search -q <query>`           | Semantic search only                         |
-| `mcpcli index`                       | Build/rebuild the search index               |
-| `mcpcli index -i`                    | Show index status                            |
-| `mcpcli exec <server> <tool> [json]` | Validate inputs locally, then execute tool   |
-| `mcpcli exec <server>`               | List available tools for a server            |
-| `mcpcli auth <server>`               | Authenticate with an HTTP MCP server (OAuth) |
-| `mcpcli auth <server> -s`            | Check auth status and token TTL              |
-| `mcpcli auth <server> -r`            | Force token refresh                          |
-| `mcpcli deauth <server>`             | Remove stored authentication for a server    |
-| `mcpcli add <name> --command <cmd>`  | Add a stdio MCP server to your config        |
-| `mcpcli add <name> --url <url>`      | Add an HTTP MCP server to your config        |
-| `mcpcli remove <name>`               | Remove an MCP server from your config        |
-| `mcpcli skill install --claude`      | Install the mcpcli skill for Claude Code     |
+| Command                                | Description                                  |
+| -------------------------------------- | -------------------------------------------- |
+| `mcpcli`                               | List all configured servers and tools        |
+| `mcpcli info <server>`                 | Show tools for a server                      |
+| `mcpcli info <server> <tool>`          | Show tool schema                             |
+| `mcpcli search <query>`                | Search tools (keyword + semantic)            |
+| `mcpcli search -k <pattern>`           | Keyword/glob search only                     |
+| `mcpcli search -q <query>`             | Semantic search only                         |
+| `mcpcli index`                         | Build/rebuild the search index               |
+| `mcpcli index -i`                      | Show index status                            |
+| `mcpcli exec <server> <tool> [json]`   | Validate inputs locally, then execute tool   |
+| `mcpcli exec <server>`                 | List available tools for a server            |
+| `mcpcli auth <server>`                 | Authenticate with an HTTP MCP server (OAuth) |
+| `mcpcli auth <server> -s`              | Check auth status and token TTL              |
+| `mcpcli auth <server> -r`              | Force token refresh                          |
+| `mcpcli deauth <server>`               | Remove stored authentication for a server    |
+| `mcpcli add <name> --command <cmd>`    | Add a stdio MCP server to your config        |
+| `mcpcli add <name> --url <url>`        | Add an HTTP MCP server to your config        |
+| `mcpcli remove <name>`                 | Remove an MCP server from your config        |
+| `mcpcli ping`                          | Check connectivity to all configured servers |
+| `mcpcli ping <server> [server2...]`    | Check connectivity to specific server(s)     |
+| `mcpcli skill install --claude`        | Install the mcpcli skill for Claude Code     |
+| `mcpcli resource`                      | List all resources across all servers        |
+| `mcpcli resource <server>`             | List resources for a server                  |
+| `mcpcli resource <server> <uri>`       | Read a specific resource                     |
+| `mcpcli prompt`                        | List all prompts across all servers          |
+| `mcpcli prompt <server>`               | List prompts for a server                    |
+| `mcpcli prompt <server> <name> [json]` | Get a specific prompt                        |
 
 ## Options
 

package/package.json

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

package/src/cli.ts

@@ -10,6 +10,9 @@ import { registerIndexCommand } from "./commands/index.ts";
 import { registerAddCommand } from "./commands/add.ts";
 import { registerRemoveCommand } from "./commands/remove.ts";
 import { registerSkillCommand } from "./commands/skill.ts";
+import { registerPingCommand } from "./commands/ping.ts";
+import { registerResourceCommand } from "./commands/resource.ts";
+import { registerPromptCommand } from "./commands/prompt.ts";
 
 declare const BUILD_VERSION: string | undefined;
 
@@ -35,5 +38,8 @@ registerIndexCommand(program);
 registerAddCommand(program);
 registerRemoveCommand(program);
 registerSkillCommand(program);
+registerPingCommand(program);
+registerResourceCommand(program);
+registerPromptCommand(program);
 
 program.parse();

package/src/client/manager.ts

@@ -1,7 +1,14 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import picomatch from "picomatch";
-import type { Tool, ServerConfig, ServersFile, AuthFile } from "../config/schemas.ts";
+import type {
+  Tool,
+  Resource,
+  Prompt,
+  ServerConfig,
+  ServersFile,
+  AuthFile,
+} from "../config/schemas.ts";
 import { isStdioServer, isHttpServer } from "../config/schemas.ts";
 import { createStdioTransport } from "./stdio.ts";
 import { createHttpTransport } from "./http.ts";
@@ -12,6 +19,16 @@ export interface ToolWithServer {
   tool: Tool;
 }
 
+export interface ResourceWithServer {
+  server: string;
+  resource: Resource;
+}
+
+export interface PromptWithServer {
+  server: string;
+  prompt: Prompt;
+}
+
 export interface ServerError {
   server: string;
   message: string;
@@ -30,6 +47,7 @@ export interface ServerManagerOptions {
 
 export class ServerManager {
   private clients = new Map<string, Client>();
+  private connecting = new Map<string, Promise<Client>>();
   private transports = new Map<string, Transport>();
   private oauthProviders = new Map<string, McpOAuthProvider>();
   private servers: ServersFile;
@@ -57,32 +75,45 @@ export class ServerManager {
     const existing = this.clients.get(serverName);
     if (existing) return existing;
 
+    // If a connection is already in flight, wait for it instead of opening a second one
+    const inflight = this.connecting.get(serverName);
+    if (inflight) return inflight;
+
     const config = this.servers.mcpServers[serverName];
     if (!config) {
       throw new Error(`Unknown server: "${serverName}"`);
     }
 
-    // Auto-refresh expired OAuth tokens before connecting to HTTP servers
-    if (isHttpServer(config)) {
-      const provider = this.getOrCreateOAuthProvider(serverName);
-      if (!provider.isComplete()) {
-        throw new Error(`Not authenticated with "${serverName}". Run: mcpcli auth ${serverName}`);
-      }
-      try {
-        await provider.refreshIfNeeded(config.url);
-      } catch {
-        // If refresh fails, continue — the transport will send the existing token
+    const connectPromise = (async () => {
+      // Auto-refresh expired OAuth tokens before connecting to HTTP servers
+      if (isHttpServer(config)) {
+        const provider = this.getOrCreateOAuthProvider(serverName);
+        if (!provider.isComplete()) {
+          throw new Error(`Not authenticated with "${serverName}". Run: mcpcli auth ${serverName}`);
+        }
+        try {
+          await provider.refreshIfNeeded(config.url);
+        } catch {
+          // If refresh fails, continue — the transport will send the existing token
+        }
       }
-    }
 
-    const transport = this.createTransport(serverName, config);
-    this.transports.set(serverName, transport);
+      const transport = this.createTransport(serverName, config);
+      this.transports.set(serverName, transport);
 
-    const client = new Client({ name: "mcpcli", version: "0.1.0" });
-    await this.withTimeout(client.connect(transport), `connect(${serverName})`);
-    this.clients.set(serverName, client);
+      const client = new Client({ name: "mcpcli", version: "0.1.0" });
+      await this.withTimeout(client.connect(transport), `connect(${serverName})`);
+      this.clients.set(serverName, client);
+      this.connecting.delete(serverName);
+
+      return client;
+    })().catch((err) => {
+      this.connecting.delete(serverName);
+      throw err;
+    });
 
-    return client;
+    this.connecting.set(serverName, connectPromise);
+    return connectPromise;
   }
 
   private getOrCreateOAuthProvider(serverName: string): McpOAuthProvider {
@@ -150,6 +181,7 @@ export class ServerManager {
             // ignore close errors
           }
           this.clients.delete(serverName);
+          this.connecting.delete(serverName);
           this.transports.delete(serverName);
         }
       }
@@ -228,6 +260,128 @@ export class ServerManager {
     return tools.find((t) => t.name === toolName);
   }
 
+  /** 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,
+    );
+  }
+
+  /** List resources across all configured servers */
+  async getAllResources(): Promise<{ resources: ResourceWithServer[]; errors: ServerError[] }> {
+    const serverNames = Object.keys(this.servers.mcpServers);
+    const resources: ResourceWithServer[] = [];
+    const errors: ServerError[] = [];
+
+    for (let i = 0; i < serverNames.length; i += this.concurrency) {
+      const batch = serverNames.slice(i, i + this.concurrency);
+      const batchResults = await Promise.allSettled(
+        batch.map(async (name) => {
+          const serverResources = await this.listResources(name);
+          return serverResources.map((resource) => ({ server: name, resource }));
+        }),
+      );
+
+      for (let j = 0; j < batchResults.length; j++) {
+        const result = batchResults[j]!;
+        if (result.status === "fulfilled") {
+          resources.push(...result.value);
+        } else {
+          const name = batch[j]!;
+          const message =
+            result.reason instanceof Error ? result.reason.message : String(result.reason);
+          errors.push({ server: name, message });
+        }
+      }
+    }
+
+    return { resources, errors };
+  }
+
+  /** 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,
+    );
+  }
+
+  /** 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,
+    );
+  }
+
+  /** List prompts across all configured servers */
+  async getAllPrompts(): Promise<{ prompts: PromptWithServer[]; errors: ServerError[] }> {
+    const serverNames = Object.keys(this.servers.mcpServers);
+    const prompts: PromptWithServer[] = [];
+    const errors: ServerError[] = [];
+
+    for (let i = 0; i < serverNames.length; i += this.concurrency) {
+      const batch = serverNames.slice(i, i + this.concurrency);
+      const batchResults = await Promise.allSettled(
+        batch.map(async (name) => {
+          const serverPrompts = await this.listPrompts(name);
+          return serverPrompts.map((prompt) => ({ server: name, prompt }));
+        }),
+      );
+
+      for (let j = 0; j < batchResults.length; j++) {
+        const result = batchResults[j]!;
+        if (result.status === "fulfilled") {
+          prompts.push(...result.value);
+        } else {
+          const name = batch[j]!;
+          const message =
+            result.reason instanceof Error ? result.reason.message : String(result.reason);
+          errors.push({ server: name, message });
+        }
+      }
+    }
+
+    return { prompts, errors };
+  }
+
+  /** Get a specific prompt by name, optionally with arguments */
+  async getPrompt(
+    serverName: string,
+    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,
+    );
+  }
+
   /** Get all server names */
   getServerNames(): string[] {
     return Object.keys(this.servers.mcpServers);
@@ -245,6 +399,7 @@ export class ServerManager {
       this.transports.delete(name);
     });
     await Promise.allSettled(closePromises);
+    this.connecting.clear();
   }
 }
 

package/src/client/oauth.ts

@@ -248,6 +248,23 @@ export function startCallbackServer(): {
   return { server, authCodePromise };
 }
 
+/** Resolve the canonical resource URL for an HTTP MCP server.
+ * Some servers advertise a canonical URL in their OAuth protected resource metadata
+ * that may differ from the URL provided by the user (e.g. hf.co → huggingface.co).
+ * Returns the canonical URL if found, or the original URL otherwise. */
+export async function resolveResourceUrl(serverUrl: string): Promise<string> {
+  try {
+    const info = await discoverOAuthServerInfo(serverUrl);
+    const canonical = info.resourceMetadata?.resource;
+    if (canonical && canonical !== serverUrl) {
+      return canonical;
+    }
+  } catch {
+    // OAuth discovery not available — use original URL
+  }
+  return serverUrl;
+}
+
 /** Probe for OAuth support and run the auth flow if the server supports it.
  * Returns true if auth ran, false if server doesn't support OAuth (silent skip). */
 export async function tryOAuthIfSupported(

package/src/commands/add.ts

@@ -1,7 +1,7 @@
 import type { Command } from "commander";
 import type { ServerConfig } from "../config/schemas.ts";
 import { loadRawAuth, loadRawServers, saveServers } from "../config/loader.ts";
-import { tryOAuthIfSupported } from "../client/oauth.ts";
+import { tryOAuthIfSupported, resolveResourceUrl } from "../client/oauth.ts";
 import { runIndex } from "./index.ts";
 
 export function registerAddCommand(program: Command) {
@@ -72,6 +72,20 @@ export function registerAddCommand(program: Command) {
           config.disabledTools = options.disabledTools.split(",").map((t) => t.trim());
         }
 
+        // For HTTP servers, resolve the canonical resource URL before saving.
+        // Some servers (e.g. hf.co → huggingface.co) advertise a different canonical
+        // URL in their OAuth protected resource metadata, and the SDK enforces that the
+        // stored URL matches this canonical URL during the OAuth token flow.
+        let effectiveUrl = options.url!;
+        if (hasUrl && options.auth !== false) {
+          const canonical = await resolveResourceUrl(effectiveUrl);
+          if (canonical !== effectiveUrl) {
+            (config as { url: string }).url = canonical;
+            effectiveUrl = canonical;
+            console.log(`Resolved canonical URL: ${canonical}`);
+          }
+        }
+
         servers.mcpServers[name] = config;
         await saveServers(configDir, servers);
         console.log(`Added server "${name}" to ${configDir}/servers.json`);
@@ -85,7 +99,7 @@ export function registerAddCommand(program: Command) {
             showSecrets: false,
           };
           try {
-            await tryOAuthIfSupported(name, options.url!, configDir, auth, formatOptions);
+            await tryOAuthIfSupported(name, effectiveUrl, configDir, auth, formatOptions);
           } catch {
             console.error(`Warning: OAuth authentication failed. Run: mcpcli auth ${name}`);
           }

package/src/commands/list.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 import { getContext } from "../context.ts";
-import { formatToolList, formatError } from "../output/formatter.ts";
+import { formatUnifiedList, formatError } from "../output/formatter.ts";
+import type { UnifiedItem } from "../output/formatter.ts";
 import { logger } from "../output/logger.ts";
 
 export function registerListCommand(program: Command) {
@@ -8,19 +9,52 @@ export function registerListCommand(program: Command) {
     const { manager, formatOptions } = await getContext(program);
     const spinner = logger.startSpinner("Connecting to servers...", formatOptions);
     try {
-      const { tools, errors } = await manager.getAllTools();
+      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 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 (tools.length > 0) console.log("");
+        if (items.length > 0) console.log("");
       }
 
-      console.log(formatToolList(tools, formatOptions));
+      console.log(formatUnifiedList(items, formatOptions));
     } catch (err) {
-      spinner.error("Failed to list tools");
+      spinner.error("Failed to list servers");
       console.error(formatError(String(err), formatOptions));
       process.exit(1);
     } finally {

package/src/commands/ping.ts

@@ -0,0 +1,69 @@
+import { green, red } from "ansis";
+import type { Command } from "commander";
+import { getContext } from "../context.ts";
+import { formatError } from "../output/formatter.ts";
+import { logger } from "../output/logger.ts";
+
+interface PingResult {
+  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);
+
+      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);
+      }
+
+      const spinner = logger.startSpinner(
+        `Pinging ${targetServers.length} server(s)...`,
+        formatOptions,
+      );
+
+      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) });
+            }
+          }),
+        );
+
+        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();
+      }
+
+      const anyFailed = results.some((r) => !r.success);
+      if (anyFailed) process.exit(1);
+    });
+}

package/src/commands/prompt.ts

@@ -0,0 +1,85 @@
+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";
+
+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 {
+          if (server && name) {
+            let args: Record<string, string> | undefined;
+
+            if (argsStr) {
+              args = parseJsonArgs(argsStr);
+            } else if (!process.stdin.isTTY) {
+              const stdin = await readStdin();
+              if (stdin.trim()) {
+                args = parseJsonArgs(stdin);
+              }
+            }
+
+            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));
+            }
+          }
+        } catch (err) {
+          spinner.error("Failed");
+          console.error(formatError(String(err), formatOptions));
+          process.exit(1);
+        } finally {
+          await manager.close();
+        }
+      },
+    );
+}
+
+function parseJsonArgs(str: string): Record<string, string> {
+  try {
+    const parsed = JSON.parse(str);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Prompt arguments must be a JSON object");
+    }
+    // Coerce all values to strings (MCP prompt args are Record<string, string>)
+    return Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error(`Invalid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: string[] = [];
+  const reader = process.stdin;
+  reader.setEncoding("utf-8");
+  for await (const chunk of reader) {
+    chunks.push(chunk as string);
+  }
+  return chunks.join("");
+}

package/src/commands/resource.ts

@@ -0,0 +1,46 @@
+import type { Command } from "commander";
+import { getContext } from "../context.ts";
+import {
+  formatResourceList,
+  formatServerResources,
+  formatResourceContents,
+  formatError,
+} from "../output/formatter.ts";
+import { logger } from "../output/logger.ts";
+
+export function registerResourceCommand(program: Command) {
+  program
+    .command("resource [server] [uri]")
+    .description("list resources for a server, or read a specific resource")
+    .action(async (server: string | undefined, uri: string | undefined) => {
+      const { manager, formatOptions } = await getContext(program);
+      const spinner = logger.startSpinner(
+        server ? `Connecting to ${server}...` : "Connecting to servers...",
+        formatOptions,
+      );
+      try {
+        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));
+          }
+        }
+      } catch (err) {
+        spinner.error("Failed");
+        console.error(formatError(String(err), formatOptions));
+        process.exit(1);
+      } finally {
+        await manager.close();
+      }
+    });
+}

package/src/config/schemas.ts

@@ -1,4 +1,4 @@
-import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { Tool, Resource, Prompt } from "@modelcontextprotocol/sdk/types.js";
 import type {
   OAuthTokens,
   OAuthClientInformation,
@@ -6,7 +6,14 @@ import type {
 } from "@modelcontextprotocol/sdk/shared/auth.js";
 
 // Re-export SDK types we use throughout the codebase
-export type { Tool, OAuthTokens, OAuthClientInformation, OAuthClientInformationMixed };
+export type {
+  Tool,
+  Resource,
+  Prompt,
+  OAuthTokens,
+  OAuthClientInformation,
+  OAuthClientInformationMixed,
+};
 
 // --- Server config (our format, not MCP spec) ---
 

package/src/output/formatter.ts

@@ -1,6 +1,6 @@
 import { bold, cyan, dim, green, red, yellow } from "ansis";
-import type { Tool } from "../config/schemas.ts";
-import type { ToolWithServer } from "../client/manager.ts";
+import type { Tool, Resource, Prompt } from "../config/schemas.ts";
+import type { ToolWithServer, ResourceWithServer, PromptWithServer } from "../client/manager.ts";
 import type { ValidationError } from "../validation/schema.ts";
 import type { SearchResult } from "../search/index.ts";
 
@@ -11,6 +11,13 @@ export interface FormatOptions {
   showSecrets?: boolean;
 }
 
+export interface UnifiedItem {
+  server: string;
+  type: "tool" | "resource" | "prompt";
+  name: string;
+  description?: string;
+}
+
 /** Check if stdout is a TTY (interactive terminal) */
 export function isInteractive(options: FormatOptions): boolean {
   if (options.json) return false;
@@ -307,6 +314,273 @@ export function formatSearchResults(results: SearchResult[], options: FormatOpti
     .join("\n");
 }
 
+/** Format a list of resources with server names */
+export function formatResourceList(
+  resources: ResourceWithServer[],
+  options: FormatOptions,
+): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(
+      resources.map((r) => ({
+        server: r.server,
+        uri: r.resource.uri,
+        name: r.resource.name,
+        ...(options.withDescriptions ? { description: r.resource.description ?? "" } : {}),
+      })),
+      null,
+      2,
+    );
+  }
+
+  if (resources.length === 0) {
+    return dim("No resources found");
+  }
+
+  const maxServer = Math.max(...resources.map((r) => r.server.length));
+  const maxUri = Math.max(...resources.map((r) => r.resource.uri.length));
+
+  return resources
+    .map((r) => {
+      const server = cyan(r.server.padEnd(maxServer));
+      const uri = bold(r.resource.uri.padEnd(maxUri));
+      if (options.withDescriptions && r.resource.description) {
+        return `${server}  ${uri}  ${dim(r.resource.description)}`;
+      }
+      return `${server}  ${uri}`;
+    })
+    .join("\n");
+}
+
+/** Format resources for a single server */
+export function formatServerResources(
+  serverName: string,
+  resources: Resource[],
+  options: FormatOptions,
+): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(
+      {
+        server: serverName,
+        resources: resources.map((r) => ({
+          uri: r.uri,
+          name: r.name,
+          description: r.description ?? "",
+          mimeType: r.mimeType ?? "",
+        })),
+      },
+      null,
+      2,
+    );
+  }
+
+  if (resources.length === 0) {
+    return dim(`No resources found for ${serverName}`);
+  }
+
+  const header = cyan.bold(serverName);
+  const maxUri = Math.max(...resources.map((r) => r.uri.length));
+
+  const lines = resources.map((r) => {
+    const uri = `  ${bold(r.uri.padEnd(maxUri))}`;
+    if (r.description) {
+      return `${uri}  ${dim(r.description)}`;
+    }
+    return uri;
+  });
+
+  return [header, ...lines].join("\n");
+}
+
+/** Format resource contents */
+export function formatResourceContents(
+  serverName: string,
+  uri: string,
+  result: unknown,
+  options: FormatOptions,
+): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(
+      { server: serverName, uri, contents: (result as { contents: unknown })?.contents ?? result },
+      null,
+      2,
+    );
+  }
+
+  const contents =
+    (result as { contents?: Array<{ text?: string; blob?: string; mimeType?: string }> })
+      ?.contents ?? [];
+  const lines: string[] = [];
+  lines.push(`${cyan(serverName)}/${bold(uri)}`);
+  lines.push("");
+
+  if (contents.length === 0) {
+    lines.push(dim("(empty)"));
+  } else {
+    for (const item of contents) {
+      if (item.text !== undefined) {
+        lines.push(item.text);
+      } else if (item.blob !== undefined) {
+        lines.push(dim(`<binary blob, ${item.blob.length} bytes base64>`));
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/** Format a list of prompts with server names */
+export function formatPromptList(prompts: PromptWithServer[], options: FormatOptions): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(
+      prompts.map((p) => ({
+        server: p.server,
+        name: p.prompt.name,
+        ...(options.withDescriptions ? { description: p.prompt.description ?? "" } : {}),
+      })),
+      null,
+      2,
+    );
+  }
+
+  if (prompts.length === 0) {
+    return dim("No prompts found");
+  }
+
+  const maxServer = Math.max(...prompts.map((p) => p.server.length));
+  const maxName = Math.max(...prompts.map((p) => p.prompt.name.length));
+
+  return prompts
+    .map((p) => {
+      const server = cyan(p.server.padEnd(maxServer));
+      const name = bold(p.prompt.name.padEnd(maxName));
+      if (options.withDescriptions && p.prompt.description) {
+        return `${server}  ${name}  ${dim(p.prompt.description)}`;
+      }
+      return `${server}  ${name}`;
+    })
+    .join("\n");
+}
+
+/** Format prompts for a single server */
+export function formatServerPrompts(
+  serverName: string,
+  prompts: Prompt[],
+  options: FormatOptions,
+): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(
+      {
+        server: serverName,
+        prompts: prompts.map((p) => ({
+          name: p.name,
+          description: p.description ?? "",
+          arguments: p.arguments ?? [],
+        })),
+      },
+      null,
+      2,
+    );
+  }
+
+  if (prompts.length === 0) {
+    return dim(`No prompts found for ${serverName}`);
+  }
+
+  const header = cyan.bold(serverName);
+  const maxName = Math.max(...prompts.map((p) => p.name.length));
+
+  const lines = prompts.map((p) => {
+    const name = `  ${bold(p.name.padEnd(maxName))}`;
+    const args =
+      p.arguments && p.arguments.length > 0
+        ? `  ${dim(`(${p.arguments.map((a) => (a.required ? a.name : `[${a.name}]`)).join(", ")})`)}`
+        : "";
+    if (p.description) {
+      return `${name}${args}  ${dim(p.description)}`;
+    }
+    return `${name}${args}`;
+  });
+
+  return [header, ...lines].join("\n");
+}
+
+/** Format prompt messages */
+export function formatPromptMessages(
+  serverName: string,
+  name: string,
+  result: unknown,
+  options: FormatOptions,
+): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify({ server: serverName, prompt: name, ...(result as object) }, null, 2);
+  }
+
+  const r = result as {
+    description?: string;
+    messages?: Array<{ role: string; content: { type: string; text?: string } }>;
+  };
+  const lines: string[] = [];
+  lines.push(`${cyan(serverName)}/${bold(name)}`);
+
+  if (r.description) {
+    lines.push(dim(r.description));
+  }
+
+  lines.push("");
+
+  for (const msg of r.messages ?? []) {
+    lines.push(`${bold(msg.role)}:`);
+    if (msg.content.text !== undefined) {
+      lines.push(`  ${msg.content.text}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/** Format a unified list of tools, resources, and prompts across servers */
+export function formatUnifiedList(items: UnifiedItem[], options: FormatOptions): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(
+      items.map((i) => ({
+        server: i.server,
+        type: i.type,
+        name: i.name,
+        ...(options.withDescriptions ? { description: i.description ?? "" } : {}),
+      })),
+      null,
+      2,
+    );
+  }
+
+  if (items.length === 0) {
+    return dim("No tools, resources, or prompts found");
+  }
+
+  const maxServer = Math.max(...items.map((i) => i.server.length));
+  const maxType = 8; // "resource" is the longest at 8 chars
+  const maxName = Math.max(...items.map((i) => i.name.length));
+
+  const typeLabel = (t: UnifiedItem["type"]) => {
+    const padded = t.padEnd(maxType);
+    if (t === "tool") return green(padded);
+    if (t === "resource") return cyan(padded);
+    return yellow(padded);
+  };
+
+  return items
+    .map((i) => {
+      const server = cyan(i.server.padEnd(maxServer));
+      const type = typeLabel(i.type);
+      const name = bold(i.name.padEnd(maxName));
+      if (options.withDescriptions && i.description) {
+        return `${server}  ${type}  ${name}  ${dim(i.description)}`;
+      }
+      return `${server}  ${type}  ${name}`;
+    })
+    .join("\n");
+}
+
 /** Format an error message */
 export function formatError(message: string, options: FormatOptions): string {
   if (!isInteractive(options)) {