@evantahler/mcpx 0.20.0 → 0.21.0

package/package.json

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

package/src/cli.ts

@@ -21,6 +21,7 @@ import { registerServersCommand } from "./commands/servers.ts";
 import { registerSkillCommand } from "./commands/skill.ts";
 import { registerTaskCommand } from "./commands/task.ts";
 import { registerUpgradeCommand } from "./commands/upgrade.ts";
+import { logger } from "./output/logger.ts";
 import { maybeCheckForUpdate } from "./update/background.ts";
 
 program
@@ -96,5 +97,5 @@ program.parse();
 // Print update notice after command output completes
 process.on("beforeExit", async () => {
 	const notice = await updateNotice;
-	if (notice) process.stderr.write(notice);
+	if (notice) logger.writeRaw(notice);
 });

package/src/client/browser.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { logger } from "../output/logger.ts";
 
 /**
  * Open a URL in the default browser (macOS/Windows/Linux).
@@ -12,11 +13,11 @@ export function openBrowser(url: string): Promise<void> {
 	try {
 		const parsed = new URL(url);
 		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-			process.stderr.write(`Refusing to open non-HTTP URL: ${url}\n`);
+			logger.error(`Refusing to open non-HTTP URL: ${url}`);
 			return Promise.resolve();
 		}
 	} catch {
-		process.stderr.write(`Invalid URL: ${url}\n`);
+		logger.error(`Invalid URL: ${url}`);
 		return Promise.resolve();
 	}
 
@@ -37,7 +38,7 @@ export function openBrowser(url: string): Promise<void> {
 	return new Promise((resolve) => {
 		execFile(cmd, args, (err) => {
 			if (err) {
-				process.stderr.write(`Could not open browser. Please visit:\n  ${url}\n`);
+				logger.warn(`Could not open browser. Please visit:\n  ${url}`);
 			}
 			resolve();
 		});

package/src/client/elicitation.ts

@@ -7,6 +7,7 @@ import type {
 	PrimitiveSchemaDefinition,
 } from "@modelcontextprotocol/sdk/types.js";
 import ansis from "ansis";
+import { logger } from "../output/logger.ts";
 import { validateElicitationResponse } from "../validation/schema.ts";
 import { openBrowser } from "./browser.ts";
 
@@ -74,7 +75,7 @@ async function handleFormInteractive(params: ElicitRequestFormParams): Promise<E
 	const question = (prompt: string): Promise<string> => new Promise((resolve) => rl.question(prompt, resolve));
 
 	try {
-		process.stderr.write(`\n${ansis.bold("Server requests input:")} ${params.message}\n`);
+		logger.writeRaw(`\n${ansis.bold("Server requests input:")} ${params.message}\n`);
 
 		const schema = params.requestedSchema;
 		const properties = schema.properties ?? {};
@@ -86,7 +87,7 @@ async function handleFormInteractive(params: ElicitRequestFormParams): Promise<E
 			const value = await promptField(key, fieldSchema, isRequired, question);
 			if (value === undefined) {
 				if (isRequired) {
-					process.stderr.write(ansis.yellow("Cancelled.\n"));
+					logger.writeRaw(ansis.yellow("Cancelled.\n"));
 					return { action: "cancel" };
 				}
 				continue;
@@ -98,7 +99,7 @@ async function handleFormInteractive(params: ElicitRequestFormParams): Promise<E
 		const validation = validateElicitationResponse(schema as unknown as Record<string, unknown>, content);
 		if (!validation.valid) {
 			const msgs = validation.errors.map((e) => `  ${e.path}: ${e.message}`).join("\n");
-			process.stderr.write(ansis.red(`Validation failed:\n${msgs}\n`));
+			logger.writeRaw(ansis.red(`Validation failed:\n${msgs}\n`));
 			return { action: "cancel" };
 		}
 
@@ -121,7 +122,7 @@ async function promptField(
 
 	// Show description if present
 	if (desc) {
-		process.stderr.write(ansis.dim(`  ${desc}\n`));
+		logger.writeRaw(ansis.dim(`  ${desc}\n`));
 	}
 
 	// Enum (single-select)
@@ -178,7 +179,7 @@ async function promptNumber(
 	if (!answer) return undefined;
 	const num = Number(answer);
 	if (Number.isNaN(num)) {
-		process.stderr.write(ansis.red(`  Invalid number: ${answer}\n`));
+		logger.writeRaw(ansis.red(`  Invalid number: ${answer}\n`));
 		return undefined;
 	}
 	return num;
@@ -206,10 +207,10 @@ async function promptEnum(
 ): Promise<string | undefined> {
 	const values = (schema as { enum: string[] }).enum;
 	const def = (schema as { default?: string }).default;
-	process.stderr.write(`  ${marker}${label}:\n`);
+	logger.writeRaw(`  ${marker}${label}:\n`);
 	values.forEach((v, i) => {
 		const defMark = v === def ? ansis.dim(" (default)") : "";
-		process.stderr.write(`    [${i + 1}] ${v}${defMark}\n`);
+		logger.writeRaw(`    [${i + 1}] ${v}${defMark}\n`);
 	});
 	const answer = await question("  > ");
 	if (!answer && def !== undefined) return def;
@@ -228,10 +229,10 @@ async function promptOneOfEnum(
 ): Promise<string | undefined> {
 	const options = (schema as { oneOf: { const: string; title: string }[] }).oneOf;
 	const def = (schema as { default?: string }).default;
-	process.stderr.write(`  ${marker}${label}:\n`);
+	logger.writeRaw(`  ${marker}${label}:\n`);
 	options.forEach((opt, i) => {
 		const defMark = opt.const === def ? ansis.dim(" (default)") : "";
-		process.stderr.write(`    [${i + 1}] ${opt.title} (${opt.const})${defMark}\n`);
+		logger.writeRaw(`    [${i + 1}] ${opt.title} (${opt.const})${defMark}\n`);
 	});
 	const answer = await question("  > ");
 	if (!answer && def !== undefined) return def;
@@ -264,10 +265,10 @@ async function promptMultiSelect(
 		return undefined;
 	}
 
-	process.stderr.write(`  ${marker}${label} (select multiple, comma-separated):\n`);
+	logger.writeRaw(`  ${marker}${label} (select multiple, comma-separated):\n`);
 	values.forEach((v, i) => {
 		const display = titles ? `${titles[i]} (${v})` : v;
-		process.stderr.write(`    [${i + 1}] ${display}\n`);
+		logger.writeRaw(`    [${i + 1}] ${display}\n`);
 	});
 	const answer = await question("  > ");
 	if (!answer && def !== undefined) return def;
@@ -282,16 +283,35 @@ async function promptMultiSelect(
 // URL mode
 // ---------------------------------------------------------------------------
 
-async function handleUrlElicitation(
+export async function handleUrlElicitation(
 	params: ElicitRequestURLParams,
 	options: ElicitationOptions,
 ): Promise<ElicitResult> {
 	if (options.json) {
 		return handleUrlJson(params);
 	}
+	if (options.noInteractive) {
+		printUrlElicitation(params);
+		return { action: "decline" };
+	}
 	return handleUrlInteractive(params);
 }
 
+function printUrlElicitation(params: ElicitRequestURLParams): void {
+	const domain = (() => {
+		try {
+			return new URL(params.url).hostname;
+		} catch {
+			return "unknown";
+		}
+	})();
+
+	logger.writeRaw(`\n${ansis.bold("Server requests URL interaction:")}\n`);
+	logger.writeRaw(`  ${params.message}\n`);
+	logger.writeRaw(`  ${ansis.yellow("Domain:")} ${domain}\n`);
+	logger.writeRaw(`  ${ansis.yellow("URL:")} ${params.url}\n`);
+}
+
 async function handleUrlJson(params: ElicitRequestURLParams): Promise<ElicitResult> {
 	const request = {
 		type: "elicitation",
@@ -312,32 +332,70 @@ async function handleUrlJson(params: ElicitRequestURLParams): Promise<ElicitResu
 }
 
 async function handleUrlInteractive(params: ElicitRequestURLParams): Promise<ElicitResult> {
-	const rl = createInterface({ input: process.stdin, output: process.stderr });
-	const question = (prompt: string): Promise<string> => new Promise((resolve) => rl.question(prompt, resolve));
-
-	try {
-		const domain = (() => {
-			try {
-				return new URL(params.url).hostname;
-			} catch {
-				return "unknown";
-			}
-		})();
+	printUrlElicitation(params);
 
-		process.stderr.write(`\n${ansis.bold("Server requests URL interaction:")}\n`);
-		process.stderr.write(`  ${params.message}\n`);
-		process.stderr.write(`  ${ansis.yellow("Domain:")} ${domain}\n`);
-		process.stderr.write(`  ${ansis.yellow("URL:")} ${params.url}\n`);
+	const yes = await promptYesNo(`  Open in browser? [y/n]: `);
+	if (yes) {
+		await openBrowser(params.url);
+		return { action: "accept" };
+	}
+	return { action: "decline" };
+}
 
-		const answer = await question(`  Open in browser? [y/n]: `);
-		if (["y", "yes"].includes(answer.toLowerCase())) {
-			await openBrowser(params.url);
-			return { action: "accept" };
-		}
-		return { action: "decline" };
-	} finally {
-		rl.close();
+/**
+ * Prompt for a yes/no answer.
+ * On a TTY, accepts a single keypress (y/Y/n/N/Enter/Esc) without requiring Enter.
+ * Off a TTY, falls back to line-buffered input so piped tests still work.
+ */
+function promptYesNo(prompt: string): Promise<boolean> {
+	logger.writeRaw(prompt);
+	const stdin = process.stdin;
+
+	if (!stdin.isTTY) {
+		return new Promise((resolve) => {
+			const rl = createInterface({ input: stdin });
+			rl.once("line", (line) => {
+				rl.close();
+				const ch = line.trim().toLowerCase();
+				resolve(ch === "y" || ch === "yes");
+			});
+			rl.once("close", () => resolve(false));
+		});
 	}
+
+	return new Promise((resolve) => {
+		stdin.setRawMode(true);
+		stdin.resume();
+
+		const cleanup = () => {
+			stdin.removeListener("data", onData);
+			stdin.setRawMode(false);
+			stdin.pause();
+		};
+
+		const onData = (data: Buffer) => {
+			const key = data.toString();
+			// Ctrl+C
+			if (key === "\u0003") {
+				cleanup();
+				logger.writeRaw("\n");
+				process.exit(130);
+			}
+			const ch = key.toLowerCase();
+			if (ch === "y") {
+				cleanup();
+				logger.writeRaw("y\n");
+				resolve(true);
+			} else if (ch === "n" || key === "\u001b") {
+				cleanup();
+				logger.writeRaw("n\n");
+				resolve(false);
+			}
+			// Ignore other keys
+		};
+
+		stdin.on("data", onData);
+	});
 }
 
 // ---------------------------------------------------------------------------

package/src/client/manager.ts

@@ -13,6 +13,7 @@ import {
 	CallToolResultSchema,
 	ElicitRequestSchema,
 	LoggingMessageNotificationSchema,
+	UrlElicitationRequiredError,
 } from "@modelcontextprotocol/sdk/types.js";
 import picomatch from "picomatch";
 import pkg from "../../package.json";
@@ -305,6 +306,8 @@ export class ServerManager {
 				return await fn();
 			} catch (err) {
 				lastError = err instanceof Error ? err : new Error(String(err));
+				// Don't retry auth challenges — the user needs to authorize first
+				if (err instanceof UrlElicitationRequiredError) throw lastError;
 				if (attempt < this.maxRetries && serverName) {
 					// Clear cached client so next attempt reconnects fresh
 					try {

package/src/commands/exec.ts

@@ -1,4 +1,6 @@
+import { UrlElicitationRequiredError } from "@modelcontextprotocol/sdk/types.js";
 import type { Command } from "commander";
+import { handleUrlElicitation } from "../client/elicitation.ts";
 import type { ServerManager } from "../client/manager.ts";
 import { DEFAULTS } from "../constants.ts";
 import { getContext } from "../context.ts";
@@ -108,7 +110,7 @@ export function registerExecCommand(program: Command) {
 				trailing: string[],
 				options: { file?: string; wait: boolean; ttl: string },
 			) => {
-				const { manager, formatOptions } = await getContext(program);
+				const { manager, formatOptions, noInteractive } = await getContext(program);
 
 				let resolved: ResolvedArgs;
 				try {
@@ -252,11 +254,22 @@ export function registerExecCommand(program: Command) {
 					} else {
 						// Standard synchronous tool call
 						const spinner = logger.startSpinner(`Executing ${server}/${tool}...`, formatOptions);
-						const result = await manager.callTool(server, tool, args);
-						spinner.stop();
+						let result: unknown;
+						try {
+							result = await manager.callTool(server, tool, args);
+						} finally {
+							spinner.stop();
+						}
 						console.log(formatCallResult(result, formatOptions));
 					}
 				} catch (err) {
+					if (err instanceof UrlElicitationRequiredError) {
+						const elicitOptions = { noInteractive, json: !!formatOptions.json };
+						for (const elicitation of err.elicitations) {
+							await handleUrlElicitation(elicitation, elicitOptions);
+						}
+						process.exit(1);
+					}
 					console.error(formatError(String(err), formatOptions));
 					process.exit(1);
 				} finally {

package/src/config/loader.ts

@@ -1,6 +1,7 @@
 import { chmod } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DEFAULT_CONFIG_DIR, ENV } from "../constants.ts";
+import { logger } from "../output/logger.ts";
 import { interpolateEnv } from "./env.ts";
 import {
 	type AuthFile,
@@ -64,7 +65,7 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Confi
 		const cwd = process.cwd();
 		if (await hasServersFile(cwd)) {
 			configDir = cwd;
-			process.stderr.write(`Note: using servers.json from current directory (${cwd})\n`);
+			logger.info(`Note: using servers.json from current directory (${cwd})`);
 		}
 	}
 

package/src/context.ts

@@ -10,6 +10,7 @@ export interface AppContext {
 	config: Config;
 	manager: ServerManager;
 	formatOptions: FormatOptions;
+	noInteractive: boolean;
 }
 
 /** Build the app context from the root commander program options */
@@ -67,5 +68,5 @@ export async function getContext(program: Command): Promise<AppContext> {
 
 	logger.configure(formatOptions);
 
-	return { config, manager, formatOptions };
+	return { config, manager, formatOptions, noInteractive };
 }

package/src/output/formatter.ts

@@ -363,16 +363,25 @@ function formatCallResultAsMarkdown(result: unknown): string {
 			mimeType?: string;
 			uri?: string;
 		}>;
+		structuredContent?: unknown;
+		_meta?: unknown;
 		isError?: boolean;
 	};
 
-	if (!r.content || !Array.isArray(r.content) || r.content.length === 0) {
+	const hasContent = Array.isArray(r.content) && r.content.length > 0;
+	const hasStructured = r.structuredContent !== undefined && r.structuredContent !== null;
+	const hasMeta =
+		r._meta !== undefined &&
+		r._meta !== null &&
+		!(typeof r._meta === "object" && Object.keys(r._meta as object).length === 0);
+
+	if (!hasContent && !hasStructured && !hasMeta) {
 		return renderMarkdownToAnsi(jsonToMarkdown(result));
 	}
 
 	const parts: string[] = [];
 
-	for (const block of r.content) {
+	for (const block of r.content ?? []) {
 		switch (block.type) {
 			case "text":
 				if (block.text !== undefined) {
@@ -390,15 +399,31 @@ function formatCallResultAsMarkdown(result: unknown): string {
 					`[image: ${block.mimeType ?? "unknown type"}, ${block.data ? Math.ceil((block.data.length * 3) / 4) : 0} bytes]`,
 				);
 				break;
+			case "audio":
+				parts.push(
+					`[audio: ${block.mimeType ?? "unknown type"}, ${block.data ? Math.ceil((block.data.length * 3) / 4) : 0} bytes]`,
+				);
+				break;
 			case "resource":
 				parts.push(`[resource: ${block.uri ?? "unknown"}]`);
 				break;
+			case "resource_link":
+				parts.push(`[resource_link: ${block.uri ?? "unknown"}]`);
+				break;
 			default:
-				parts.push(`[${block.type}]`);
+				parts.push(`[${block.type}]\n\n\`\`\`json\n${JSON.stringify(block, null, 2)}\n\`\`\``);
 				break;
 		}
 	}
 
+	if (hasStructured) {
+		parts.push(`**Structured Content:**\n\n${jsonToMarkdown(r.structuredContent)}`);
+	}
+
+	if (hasMeta) {
+		parts.push(`**Meta:**\n\n${jsonToMarkdown(r._meta)}`);
+	}
+
 	let output = parts.join("\n\n");
 	if (r.isError) {
 		output = `**error:** ${output}`;