@oh-my-pi/pi-coding-agent 17.0.8 → 17.1.0

package/src/mcp/config-writer.ts

@@ -3,10 +3,12 @@
  *
  * Utilities for reading/writing .omp/mcp.json files at user or project level.
  */
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { invalidate as invalidateFsCache } from "../capability/fs";
+import { withFileLock } from "../config/file-lock";
 
 import { validateServerConfig } from "./config";
 import { MCP_CONFIG_SCHEMA_URL, type MCPConfigFile, type MCPServerConfig } from "./types";
@@ -18,6 +20,20 @@ function withSchema(config: MCPConfigFile): MCPConfigFile {
 	};
 }
 
+/**
+ * Serialize a read-modify-write against one config file.
+ *
+ * Wraps {@link withFileLock} but first ensures the config's parent directory
+ * exists, because the lock directory (`${filePath}.lock`) is created with a
+ * non-recursive `mkdir` — without this the very first write (before the config
+ * file or its parent exists) would fail to acquire the lock with ENOENT.
+ */
+function withConfigLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+	return fs.promises
+		.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 })
+		.then(() => withFileLock(filePath, fn));
+}
+
 /**
  * Read an MCP config file.
  * Returns empty config if file doesn't exist.
@@ -45,13 +61,20 @@ export async function writeMCPConfigFile(filePath: string, config: MCPConfigFile
 	const dir = path.dirname(filePath);
 	await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
 
-	// Write to temp file first (atomic write)
-	const tmpPath = `${filePath}.tmp`;
+	// Write to a per-writer temp file, then atomically rename into place. The
+	// temp name is unique (pid + random) so two concurrent writers to the same
+	// config never share one `.tmp` path and rename each other's file out from
+	// under them (which surfaced as ENOENT or a clobbered final file).
+	const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
 	const content = JSON.stringify(withSchema(config), null, 2);
-	await fs.promises.writeFile(tmpPath, content, { encoding: "utf-8", mode: 0o600 });
-
-	// Rename to final path (atomic on most systems)
-	await fs.promises.rename(tmpPath, filePath);
+	try {
+		await fs.promises.writeFile(tmpPath, content, { encoding: "utf-8", mode: 0o600 });
+		// Rename to final path (atomic on most systems)
+		await fs.promises.rename(tmpPath, filePath);
+	} catch (error) {
+		await fs.promises.rm(tmpPath, { force: true }).catch(() => {});
+		throw error;
+	}
 	// Invalidate the capability fs cache so subsequent reads see the new content
 	invalidateFsCache(filePath);
 }
@@ -97,25 +120,26 @@ export async function addMCPServer(filePath: string, name: string, config: MCPSe
 		throw new Error(`Invalid server config: ${errors.join("; ")}`);
 	}
 
-	// Read existing config
-	const existing = await readMCPConfigFile(filePath);
+	// Serialize the read-modify-write under a per-file lock so a concurrent
+	// mutation cannot overwrite this one (lost update). The lock also guards
+	// against cross-process writers sharing the same config file.
+	await withConfigLock(filePath, async () => {
+		const existing = await readMCPConfigFile(filePath);
 
-	// Check for duplicate name
-	if (existing.mcpServers?.[name]) {
-		throw new Error(`Server "${name}" already exists in ${filePath}`);
-	}
-
-	// Add server
-	const updated: MCPConfigFile = {
-		...existing,
-		mcpServers: {
-			...existing.mcpServers,
-			[name]: config,
-		},
-	};
+		// Check for duplicate name
+		if (existing.mcpServers?.[name]) {
+			throw new Error(`Server "${name}" already exists in ${filePath}`);
+		}
 
-	// Write back
-	await writeMCPConfigFile(filePath, updated);
+		const updated: MCPConfigFile = {
+			...existing,
+			mcpServers: {
+				...existing.mcpServers,
+				[name]: config,
+			},
+		};
+		await writeMCPConfigFile(filePath, updated);
+	});
 }
 
 /**
@@ -137,20 +161,19 @@ export async function updateMCPServer(filePath: string, name: string, config: MC
 		throw new Error(`Invalid server config: ${errors.join("; ")}`);
 	}
 
-	// Read existing config
-	const existing = await readMCPConfigFile(filePath);
-
-	// Update server
-	const updated: MCPConfigFile = {
-		...existing,
-		mcpServers: {
-			...existing.mcpServers,
-			[name]: config,
-		},
-	};
-
-	// Write back
-	await writeMCPConfigFile(filePath, updated);
+	// Serialize the read-modify-write (see addMCPServer).
+	await withConfigLock(filePath, async () => {
+		const existing = await readMCPConfigFile(filePath);
+
+		const updated: MCPConfigFile = {
+			...existing,
+			mcpServers: {
+				...existing.mcpServers,
+				[name]: config,
+			},
+		};
+		await writeMCPConfigFile(filePath, updated);
+	});
 }
 
 /**
@@ -159,23 +182,21 @@ export async function updateMCPServer(filePath: string, name: string, config: MC
  * @throws Error if server doesn't exist
  */
 export async function removeMCPServer(filePath: string, name: string): Promise<void> {
-	// Read existing config
-	const existing = await readMCPConfigFile(filePath);
-
-	// Check if server exists
-	if (!existing.mcpServers?.[name]) {
-		throw new Error(`Server "${name}" not found in ${filePath}`);
-	}
+	// Serialize the read-modify-write (see addMCPServer).
+	await withConfigLock(filePath, async () => {
+		const existing = await readMCPConfigFile(filePath);
 
-	// Remove server
-	const { [name]: _removed, ...remaining } = existing.mcpServers;
-	const updated: MCPConfigFile = {
-		...existing,
-		mcpServers: remaining,
-	};
+		if (!existing.mcpServers?.[name]) {
+			throw new Error(`Server "${name}" not found in ${filePath}`);
+		}
 
-	// Write back
-	await writeMCPConfigFile(filePath, updated);
+		const { [name]: _removed, ...remaining } = existing.mcpServers;
+		const updated: MCPConfigFile = {
+			...existing,
+			mcpServers: remaining,
+		};
+		await writeMCPConfigFile(filePath, updated);
+	});
 }
 
 /**
@@ -207,25 +228,28 @@ export async function readDisabledServers(filePath: string): Promise<string[]> {
  * Add or remove a server name from the disabled servers list.
  */
 export async function setServerDisabled(filePath: string, name: string, disabled: boolean): Promise<void> {
-	const config = await readMCPConfigFile(filePath);
-	const current = new Set(config.disabledServers ?? []);
+	// Serialize the read-modify-write (see addMCPServer).
+	await withConfigLock(filePath, async () => {
+		const config = await readMCPConfigFile(filePath);
+		const current = new Set(config.disabledServers ?? []);
 
-	if (disabled) {
-		current.add(name);
-	} else {
-		current.delete(name);
-	}
+		if (disabled) {
+			current.add(name);
+		} else {
+			current.delete(name);
+		}
 
-	const updated: MCPConfigFile = {
-		...config,
-		disabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
-	};
+		const updated: MCPConfigFile = {
+			...config,
+			disabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
+		};
 
-	if (!updated.disabledServers) {
-		delete updated.disabledServers;
-	}
+		if (!updated.disabledServers) {
+			delete updated.disabledServers;
+		}
 
-	await writeMCPConfigFile(filePath, updated);
+		await writeMCPConfigFile(filePath, updated);
+	});
 }
 
 /**
@@ -243,25 +267,28 @@ export async function readEnabledServers(filePath: string): Promise<string[]> {
  * NOT override the `disabledServers` denylist.
  */
 export async function setServerForceEnabled(filePath: string, name: string, force: boolean): Promise<void> {
-	const config = await readMCPConfigFile(filePath);
-	const current = new Set(config.enabledServers ?? []);
+	// Serialize the read-modify-write (see addMCPServer).
+	await withConfigLock(filePath, async () => {
+		const config = await readMCPConfigFile(filePath);
+		const current = new Set(config.enabledServers ?? []);
 
-	if (force) {
-		current.add(name);
-	} else {
-		current.delete(name);
-	}
+		if (force) {
+			current.add(name);
+		} else {
+			current.delete(name);
+		}
 
-	const updated: MCPConfigFile = {
-		...config,
-		enabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
-	};
+		const updated: MCPConfigFile = {
+			...config,
+			enabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
+		};
 
-	if (!updated.enabledServers) {
-		delete updated.enabledServers;
-	}
+		if (!updated.enabledServers) {
+			delete updated.enabledServers;
+		}
 
-	await writeMCPConfigFile(filePath, updated);
+		await writeMCPConfigFile(filePath, updated);
+	});
 }
 
 /** Paths and target state for toggling one MCP server across known config files. */

package/src/mcp/manager.ts

@@ -38,6 +38,7 @@ import type { MCPToolDetails } from "./tool-bridge";
 import { DeferredMCPTool, MCPTool } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
 import type {
+	MCPAuthChallenge,
 	MCPGetPromptResult,
 	MCPPrompt,
 	MCPRequestOptions,
@@ -160,6 +161,9 @@ export interface MCPDiscoverOptions {
 	onStatus?: (event: McpConnectionStatusEvent) => void;
 }
 
+/** Handles an MCP `WWW-Authenticate` challenge and returns refreshed config. */
+export type MCPAuthHandler = (serverName: string, challenge: MCPAuthChallenge) => Promise<MCPServerConfig | undefined>;
+
 /**
  * MCP Server Manager.
  *
@@ -189,6 +193,7 @@ export class MCPManager {
 	#pendingToolLoads = new Map<string, Promise<ToolLoadResult>>();
 	#sources = new Map<string, SourceMeta>();
 	#authStorage: AuthStorage | null = null;
+	#authHandler?: MCPAuthHandler;
 	#onNotification?: (serverName: string, method: string, params: unknown) => void;
 	#onToolsChanged?: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void;
 	#onResourcesChanged?: (serverName: string, uri: string) => void;
@@ -201,7 +206,7 @@ export class MCPManager {
 	/** Preserved configs for reconnection after connection loss. */
 	#serverConfigs = new Map<string, MCPServerConfig>();
 	/**
-	 * Timestamps of recent `reconnectServer` invocations per server, used by the
+	 * Timestamps of recent reconnectServer invocations per server, used by the
 	 * crash-storm circuit breaker (see {@link RECONNECT_BURST_LIMIT}).
 	 */
 	#reconnectHistory = new Map<string, number[]>();
@@ -312,6 +317,11 @@ export class MCPManager {
 		this.#authStorage = authStorage;
 	}
 
+	/** Set the callback used to complete OAuth after a tool-level auth challenge. */
+	setAuthHandler(handler: MCPAuthHandler | undefined): void {
+		this.#authHandler = handler;
+	}
+
 	/**
 	 * Discover and connect to all MCP servers from .mcp.json files.
 	 * Returns tools and any connection errors.
@@ -474,7 +484,8 @@ export class MCPManager {
 				.then(async ({ connection, serverTools }) => {
 					if (this.#pendingToolLoads.get(name) !== toolsPromise) return;
 					this.#pendingToolLoads.delete(name);
-					const reconnect = () => this.reconnectServer(name);
+					const reconnect = (options?: { authChallenge?: MCPAuthChallenge }) =>
+						this.reconnectServer(name, options);
 					const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
 					this.#replaceServerTools(name, customTools);
 					this.#onToolsChanged?.(this.#tools);
@@ -810,13 +821,15 @@ export class MCPManager {
 	 * the same server share one reconnection attempt. Returns the new
 	 * connection, or `null` if reconnection failed or the per-server crash
 	 * burst limit (see {@link RECONNECT_BURST_LIMIT}) is exceeded.
-	 *
 	 * @param options.manual - When `true`, resets the crash-burst window so a
 	 *   user-driven retry (e.g. `/mcp reconnect`) is never blocked by an
 	 *   earlier storm. Defaults to `false`; the transport `onClose` callback
 	 *   and the per-tool-call retry path in `tool-bridge` MUST NOT set it.
 	 */
-	async reconnectServer(name: string, options?: { manual?: boolean }): Promise<MCPServerConnection | null> {
+	async reconnectServer(
+		name: string,
+		options?: { manual?: boolean; authChallenge?: MCPAuthChallenge },
+	): Promise<MCPServerConnection | null> {
 		if (options?.manual) {
 			this.#reconnectHistory.delete(name);
 		}
@@ -828,7 +841,7 @@ export class MCPManager {
 			return null;
 		}
 
-		const attempt = this.#doReconnect(name);
+		const attempt = this.#doReconnect(name, options?.authChallenge);
 		this.#pendingReconnections.set(name, attempt);
 		return attempt.finally(() => this.#pendingReconnections.delete(name));
 	}
@@ -873,12 +886,30 @@ export class MCPManager {
 		return false;
 	}
 
-	async #doReconnect(name: string): Promise<MCPServerConnection | null> {
+	async #doReconnect(name: string, authChallenge?: MCPAuthChallenge): Promise<MCPServerConnection | null> {
 		const oldConnection = this.#connections.get(name);
-		const config = oldConnection?.config ?? this.#serverConfigs.get(name);
+		let config = oldConnection?.config ?? this.#serverConfigs.get(name);
 		const source = this.#sources.get(name) ?? oldConnection?._source;
 		if (!config) return null;
 
+		if (authChallenge) {
+			if (!this.#authHandler) {
+				logger.error("MCP auth challenge cannot be handled; no auth handler is configured", {
+					path: `mcp:${name}`,
+				});
+				return null;
+			}
+			try {
+				const refreshedConfig = await this.#authHandler(name, authChallenge);
+				if (!refreshedConfig) return null;
+				config = refreshedConfig;
+				this.#serverConfigs.set(name, config);
+			} catch (error) {
+				logger.error("MCP auth challenge handling failed", { path: `mcp:${name}`, error });
+				return null;
+			}
+		}
+
 		logger.debug("MCP reconnecting", { path: `mcp:${name}` });
 
 		// Close the old transport without removing tools or notifying consumers.
@@ -987,7 +1018,7 @@ export class MCPManager {
 		};
 		try {
 			const serverTools = await listTools(connection);
-			const reconnect = () => this.reconnectServer(name);
+			const reconnect = (options?: { authChallenge?: MCPAuthChallenge }) => this.reconnectServer(name, options);
 			const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
 			void this.toolCache?.set(name, config, serverTools);
 			this.#replaceServerTools(name, customTools);

package/src/mcp/oauth-discovery.ts

@@ -6,6 +6,10 @@
  */
 import * as AIError from "@oh-my-pi/pi-ai/error";
 import type { FetchImpl } from "@oh-my-pi/pi-ai/types";
+import { withTimeoutSignal } from "../utils/fetch-timeout";
+
+/** Per-request abort deadline for each OAuth discovery metadata fetch. */
+const DISCOVERY_FETCH_TIMEOUT_MS = 10_000;
 
 export interface OAuthEndpoints {
 	authorizationUrl: string;
@@ -346,7 +350,7 @@ function readMetadataScopes(metadata: Record<string, unknown>): string | undefin
  */
 export async function fetchResourceMetadataScopes(
 	resourceMetadataUrl: string,
-	opts?: { fetch?: FetchImpl },
+	opts?: { fetch?: FetchImpl; signal?: AbortSignal },
 ): Promise<string | undefined> {
 	const fetchImpl: FetchImpl = opts?.fetch ?? fetch;
 	try {
@@ -354,6 +358,7 @@ export async function fetchResourceMetadataScopes(
 			method: "GET",
 			headers: { Accept: "application/json" },
 			redirect: "follow",
+			signal: withTimeoutSignal(DISCOVERY_FETCH_TIMEOUT_MS, opts?.signal),
 		});
 		if (!resp.ok) return undefined;
 		const meta = (await resp.json()) as Record<string, unknown>;
@@ -371,7 +376,7 @@ export async function discoverOAuthEndpoints(
 	serverUrl: string,
 	authServerUrl?: string,
 	resourceMetadataUrl?: string,
-	opts?: { fetch?: FetchImpl; protectedResource?: string; protectedScopes?: string },
+	opts?: { fetch?: FetchImpl; protectedResource?: string; protectedScopes?: string; signal?: AbortSignal },
 ): Promise<OAuthEndpoints | null> {
 	const fetchImpl: FetchImpl = opts?.fetch ?? fetch;
 	const wellKnownPaths = [
@@ -402,6 +407,7 @@ export async function discoverOAuthEndpoints(
 				method: "GET",
 				headers: { Accept: "application/json" },
 				redirect: "follow",
+				signal: withTimeoutSignal(DISCOVERY_FETCH_TIMEOUT_MS, opts?.signal),
 			});
 			if (metaResp.ok) {
 				const meta = (await metaResp.json()) as Record<string, unknown>;
@@ -486,6 +492,7 @@ export async function discoverOAuthEndpoints(
 						method: "GET",
 						headers: { Accept: "application/json" },
 						redirect: "follow",
+						signal: withTimeoutSignal(DISCOVERY_FETCH_TIMEOUT_MS, opts?.signal),
 					});
 
 					if (response.ok) {
@@ -521,6 +528,7 @@ export async function discoverOAuthEndpoints(
 									fetch: fetchImpl,
 									protectedResource: discoveredProtectedResource,
 									protectedScopes: readMetadataScopes(metadata) ?? protectedScopes,
+									signal: opts?.signal,
 								});
 								if (discovered) return discovered;
 							}

package/src/mcp/render.ts

@@ -4,9 +4,10 @@
  * Provides structured display of MCP tool calls and results,
  * showing args and output in JSON tree format similar to task tool.
  */
-import type { Component } from "@oh-my-pi/pi-tui";
+import { type Component, Markdown } from "@oh-my-pi/pi-tui";
+import { settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
+import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 import {
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
@@ -48,6 +49,61 @@ export function renderMCPCall(args: Record<string, unknown>, theme: Theme, label
 	);
 }
 
+/** Render an MCP status/args prefix followed by Markdown-aware text output. */
+function renderMarkdownMCPResult(
+	result: { details?: MCPToolDetails; isError?: boolean },
+	trimmedOutput: string,
+	truncationWarning: string | null,
+	options: RenderResultOptions,
+	theme: Theme,
+	args?: Record<string, unknown>,
+): Component {
+	const markdown = new Markdown(trimmedOutput, 0, 0, getMarkdownTheme(), {
+		color: text => theme.fg("toolOutput", text),
+	});
+	return {
+		render(contentWidth: number): readonly string[] {
+			const lines: string[] = [];
+			const isError = result.isError ?? result.details?.isError ?? false;
+			const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
+			lines.push(
+				renderStatusLine(
+					isError ? { icon: "error", title } : { iconOverride: theme.styledSymbol("tool.mcp", "accent"), title },
+					theme,
+				),
+			);
+
+			if (options.expanded && args && Object.keys(args).length > 0) {
+				lines.push(theme.fg("dim", "Args"));
+				const tree = renderJsonTreeLines(
+					args,
+					theme,
+					JSON_TREE_MAX_DEPTH_EXPANDED,
+					JSON_TREE_MAX_LINES_EXPANDED,
+					JSON_TREE_SCALAR_LEN_EXPANDED,
+				);
+				lines.push(...tree.lines);
+				if (tree.truncated) lines.push(theme.fg("dim", "…"));
+				lines.push("");
+			}
+
+			const rendered = markdown.render(Math.max(1, contentWidth));
+			const maxOutputLines = options.expanded ? 12 : 4;
+			lines.push(...rendered.slice(0, maxOutputLines));
+			if (rendered.length > maxOutputLines) {
+				lines.push(
+					`${theme.fg("dim", `… ${rendered.length - maxOutputLines} more lines`)} ${formatExpandHint(theme, options.expanded, true)}`,
+				);
+			} else if (!options.expanded) {
+				lines.push(formatExpandHint(theme, options.expanded, true));
+			}
+			if (truncationWarning) lines.push(truncationWarning);
+			return lines;
+		},
+		invalidate(): void {},
+	};
+}
+
 /**
  * Render MCP tool result.
  */
@@ -58,6 +114,24 @@ export function renderMCPResult(
 	args?: Record<string, unknown>,
 ): Component {
 	const { expanded } = options;
+	const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+	const trimmedOutput = stripOutputNotice(textContent, result.details?.meta).trimEnd();
+	const truncationWarning = result.details?.meta?.truncation
+		? formatStyledTruncationWarning(result.details.meta, theme)
+		: null;
+	let parsedOutput: unknown;
+	let isJsonOutput = false;
+	if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
+		try {
+			parsedOutput = JSON.parse(trimmedOutput);
+			isJsonOutput = true;
+		} catch {
+			// Non-JSON text beginning with a bracket is still eligible for Markdown.
+		}
+	}
+	if (trimmedOutput && settings.get("mcp.renderMarkdownResults") && !isJsonOutput) {
+		return renderMarkdownMCPResult(result, trimmedOutput, truncationWarning, options, theme, args);
+	}
 	return new WidthAwareText(
 		contentWidth => {
 			const lines: string[] = [];
@@ -86,46 +160,31 @@ export function renderMCPResult(
 				lines.push(""); // Blank line before output
 			}
 
-			// Output section
-			const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-			// Strip the LLM-facing spill notice before parsing/rendering: a spilled
-			// result appends `[Showing… artifact://N]` to the body, which would break
-			// JSON detection and bury the recovery link. Surface it as a styled warning
-			// instead, mirroring the built-in read/bash/ssh/browser renderers.
-			const trimmedOutput = stripOutputNotice(textContent, result.details?.meta).trimEnd();
-			const truncationWarning = result.details?.meta?.truncation
-				? formatStyledTruncationWarning(result.details.meta, theme)
-				: null;
+			// Output section. The body and spill metadata are normalized before
+			// component selection so the opt-in Markdown path can use its own renderer.
 
 			if (!trimmedOutput) {
 				lines.push(theme.fg("dim", "(no output)"));
 				return lines.join("\n");
 			}
 
-			// Try to parse as JSON for structured display
-			if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
-				try {
-					const parsed = JSON.parse(trimmedOutput);
-					const maxDepth = expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
-					const maxLines = expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
-					const maxScalarLen = expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
-					const tree = renderJsonTreeLines(parsed, theme, maxDepth, maxLines, maxScalarLen);
-
-					if (tree.lines.length > 0) {
-						for (const line of tree.lines) {
-							lines.push(line);
-						}
-						// Always show expand hint when collapsed (expanded view shows longer values and deeper nesting)
-						if (!expanded) {
-							lines.push(formatExpandHint(theme, expanded, true));
-						} else if (tree.truncated) {
-							lines.push(theme.fg("dim", "…"));
-						}
-						if (truncationWarning) lines.push(truncationWarning);
-						return lines.join("\n");
+			// Preserve the existing structured JSON renderer regardless of the
+			// Markdown preference; JSON trees remain more useful than styled source.
+			if (isJsonOutput) {
+				const maxDepth = expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+				const maxLines = expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+				const maxScalarLen = expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+				const tree = renderJsonTreeLines(parsedOutput, theme, maxDepth, maxLines, maxScalarLen);
+
+				if (tree.lines.length > 0) {
+					lines.push(...tree.lines);
+					if (!expanded) {
+						lines.push(formatExpandHint(theme, expanded, true));
+					} else if (tree.truncated) {
+						lines.push(theme.fg("dim", "…"));
 					}
-				} catch {
-					// Fall through to raw output
+					if (truncationWarning) lines.push(truncationWarning);
+					return lines.join("\n");
 				}
 			}
 

package/src/mcp/smithery-auth.test.ts

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it, vi } from "bun:test";
+import { pollSmitheryCliAuthSession } from "./smithery-auth";
+
+type FetchInput = string | URL | Request;
+type FetchInit = RequestInit | BunFetchRequestInit;
+
+describe("pollSmitheryCliAuthSession fetch cancellation", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("bounds each poll request with a timeout abort signal even without a caller signal", async () => {
+		const signals: AbortSignal[] = [];
+		const fetchStub = Object.assign(
+			async (_input: FetchInput, init?: FetchInit) => {
+				if (init?.signal instanceof AbortSignal) signals.push(init.signal);
+				return Response.json({ status: "pending" });
+			},
+			{ preconnect: globalThis.fetch.preconnect },
+		);
+		vi.spyOn(globalThis, "fetch").mockImplementation(fetchStub);
+
+		const result = await pollSmitheryCliAuthSession("sess-123");
+
+		expect(result.status).toBe("pending");
+		expect(signals).toHaveLength(1);
+		expect(signals[0]?.aborted).toBe(false);
+	});
+});

package/src/mcp/smithery-auth.ts

@@ -7,13 +7,14 @@ import { withTimeoutSignal } from "../utils/fetch-timeout";
 const SMITHERY_AUTH_FILENAME = "smithery.json";
 const SMITHERY_URL = process.env.SMITHERY_URL || "https://smithery.ai";
 const SMITHERY_AUTH_TIMEOUT_MS = 10_000;
+const SMITHERY_POLL_TIMEOUT_MS = 30_000;
 
 type SmitheryCliAuthSession = {
 	sessionId: string;
 	authUrl: string;
 };
 
-type SmitheryCliPollResponse = {
+export type SmitheryCliPollResponse = {
 	status: "pending" | "success" | "error";
 	apiKey?: string;
 	message?: string;
@@ -53,7 +54,7 @@ export async function pollSmitheryCliAuthSession(
 	signal?: AbortSignal,
 ): Promise<SmitheryCliPollResponse> {
 	const response = await fetch(`${SMITHERY_URL}/api/auth/cli/poll/${sessionId}`, {
-		signal,
+		signal: withTimeoutSignal(SMITHERY_POLL_TIMEOUT_MS, signal),
 	});
 	if (!response.ok) {
 		if (response.status === 404 || response.status === 410) {