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

package/src/modes/controllers/live-command-controller.ts

@@ -0,0 +1,178 @@
+import { logger } from "@oh-my-pi/pi-utils";
+import { LiveSessionController } from "../../live/controller";
+import { LiveVisualizer } from "../../live/visualizer";
+import { vocalizer } from "../../tts/vocalizer";
+import type { CustomEditor } from "../components/custom-editor";
+import type { InteractiveModeContext } from "../types";
+
+const ANIMATION_INTERVAL_MS = 80;
+
+function errorFrom(cause: unknown): Error {
+	return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+/** Owns the editor-replacing visualizer and realtime session lifecycle for `/live`. */
+export class LiveCommandController {
+	readonly #ctx: InteractiveModeContext;
+
+	#session: LiveSessionController | undefined;
+	#settling: Promise<void> | undefined;
+	#visualizer: LiveVisualizer | undefined;
+	#detachedEditor: CustomEditor | undefined;
+	#animationInterval: NodeJS.Timeout | undefined;
+	#previousShowHardwareCursor: boolean | undefined;
+	#previousUseTerminalCursor: boolean | undefined;
+	#resumeVocalizer: (() => void) | undefined;
+
+	constructor(ctx: InteractiveModeContext) {
+		this.#ctx = ctx;
+	}
+
+	/** Whether a live session is connected, connecting, or closing. */
+	get active(): boolean {
+		return this.#session !== undefined || this.#settling !== undefined;
+	}
+
+	/** Start live mode, or stop the currently active session. */
+	async handleCommand(): Promise<void> {
+		if (this.#session) {
+			await this.stop();
+			return;
+		}
+		if (this.#settling) await this.#settling;
+		await this.#start();
+	}
+
+	/** Stop the active live session and restore the editor. */
+	async stop(): Promise<void> {
+		const session = this.#session;
+		if (!session) {
+			if (this.#settling) await this.#settling;
+			return;
+		}
+		try {
+			await session.stop();
+		} catch (cause) {
+			this.#finish(session, errorFrom(cause));
+		} finally {
+			this.#finish(session);
+		}
+	}
+
+	/** Release UI resources during synchronous InteractiveMode teardown. */
+	dispose(): void {
+		const session = this.#session;
+		if (session) {
+			this.#finish(session);
+			void session.stop().catch(cause => {
+				logger.debug("Live session teardown failed", { error: errorFrom(cause).message });
+			});
+		} else {
+			this.#restoreEditor();
+		}
+	}
+
+	async #start(): Promise<void> {
+		const visualizer = new LiveVisualizer({
+			onStop: () => {
+				void this.stop().catch(cause => this.#ctx.showError(errorFrom(cause).message));
+			},
+			onToggleMute: () => this.#session?.toggleMute(),
+		});
+		this.#mountVisualizer(visualizer);
+
+		let session: LiveSessionController;
+		session = new LiveSessionController({
+			session: this.#ctx.session,
+			extractAssistantText: message => this.#ctx.extractAssistantText(message),
+			callbacks: {
+				onPhase: phase => {
+					if (this.#visualizer !== visualizer) return;
+					visualizer.setPhase(phase);
+					this.#ctx.ui.requestComponentRender(visualizer);
+				},
+				onLevels: (input, output) => {
+					if (this.#visualizer !== visualizer) return;
+					visualizer.setLevels(input, output);
+					this.#ctx.ui.requestComponentRender(visualizer);
+				},
+				onTranscript: transcript => {
+					if (this.#visualizer !== visualizer) return;
+					visualizer.setTranscript(transcript);
+					this.#ctx.ui.requestComponentRender(visualizer);
+				},
+				onTerminal: error => this.#finish(session, error),
+			},
+		});
+		this.#session = session;
+
+		try {
+			await session.start();
+		} catch (cause) {
+			if (this.#session === session) {
+				await session.stop();
+				this.#finish(session, errorFrom(cause));
+			}
+		}
+	}
+
+	#mountVisualizer(visualizer: LiveVisualizer): void {
+		this.#visualizer = visualizer;
+		this.#detachedEditor = this.#ctx.editor;
+		this.#previousShowHardwareCursor = this.#ctx.ui.getShowHardwareCursor();
+		this.#previousUseTerminalCursor = this.#ctx.editor.getUseTerminalCursor();
+		this.#ctx.ui.setShowHardwareCursor(false);
+		this.#ctx.editor.setUseTerminalCursor(false);
+		this.#ctx.editorContainer.clear();
+		this.#ctx.editorContainer.addChild(visualizer);
+		this.#ctx.ui.setFocus(visualizer);
+		this.#resumeVocalizer = vocalizer.suspend();
+		let frame = 0;
+		this.#animationInterval = setInterval(() => {
+			if (this.#visualizer !== visualizer) return;
+			frame += 1;
+			visualizer.setFrame(frame);
+			this.#ctx.ui.requestComponentRender(visualizer);
+		}, ANIMATION_INTERVAL_MS);
+		this.#ctx.ui.requestRender();
+	}
+
+	#finish(session: LiveSessionController, error?: Error): void {
+		if (this.#session !== session) return;
+		this.#session = undefined;
+		this.#restoreEditor();
+		if (error) this.#ctx.showError(error.message);
+		const settling = session.stop().catch(cause => {
+			logger.debug("Live session cleanup failed", { error: errorFrom(cause).message });
+		});
+		this.#settling = settling;
+		void settling.finally(() => {
+			if (this.#settling === settling) this.#settling = undefined;
+		});
+	}
+
+	#restoreEditor(): void {
+		if (this.#animationInterval) {
+			clearInterval(this.#animationInterval);
+			this.#animationInterval = undefined;
+		}
+		this.#resumeVocalizer?.();
+		this.#resumeVocalizer = undefined;
+		const editor = this.#detachedEditor;
+		this.#detachedEditor = undefined;
+		this.#visualizer = undefined;
+		if (!editor) return;
+		this.#ctx.editorContainer.clear();
+		this.#ctx.editorContainer.addChild(editor);
+		if (this.#previousShowHardwareCursor !== undefined) {
+			this.#ctx.ui.setShowHardwareCursor(this.#previousShowHardwareCursor);
+		}
+		if (this.#previousUseTerminalCursor !== undefined) {
+			editor.setUseTerminalCursor(this.#previousUseTerminalCursor);
+		}
+		this.#previousShowHardwareCursor = undefined;
+		this.#previousUseTerminalCursor = undefined;
+		this.#ctx.ui.setFocus(editor);
+		this.#ctx.ui.requestRender();
+	}
+}

package/src/modes/controllers/mcp-command-controller.ts

@@ -38,6 +38,7 @@ import {
 	getSmitheryApiKey,
 	getSmitheryLoginUrl,
 	pollSmitheryCliAuthSession,
+	type SmitheryCliPollResponse,
 	saveSmitheryApiKey,
 } from "../../mcp/smithery-auth";
 import { SmitheryConnectError } from "../../mcp/smithery-connect";
@@ -47,10 +48,11 @@ import {
 	searchSmitheryRegistry,
 	toConfigName,
 } from "../../mcp/smithery-registry";
-import type { MCPAuthConfig, MCPServerConfig, MCPServerConnection } from "../../mcp/types";
+import type { MCPAuthChallenge, MCPAuthConfig, MCPServerConfig, MCPServerConnection } from "../../mcp/types";
 import { shortenPath } from "../../tools/render-utils";
 import { urlHyperlinkAlways } from "../../tui";
 import { copyToClipboard } from "../../utils/clipboard";
+import { isTimeoutError } from "../../utils/fetch-timeout";
 import { openPath } from "../../utils/open";
 import { ChatBlock } from "../components/chat-block";
 import { MCPAddWizard } from "../components/mcp-add-wizard";
@@ -1042,7 +1044,10 @@ export class MCPCommandController {
 		return next;
 	}
 
-	async #resolveOAuthEndpointsFromServer(config: MCPServerConfig): Promise<OAuthEndpoints> {
+	async #resolveOAuthEndpointsFromServer(
+		config: MCPServerConfig,
+		authChallenge?: MCPAuthChallenge,
+	): Promise<OAuthEndpoints> {
 		// Stdio servers manage credentials inside the child process; OMP's OAuth
 		// flow only applies to http/sse transports. Without this guard the
 		// unauthenticated preflight below spawns the child, which happily reuses
@@ -1068,13 +1073,20 @@ export class MCPCommandController {
 			connectionError = error as Error;
 		}
 
-		// Server connected fine without auth — reauth is not needed
-		if (connectionSucceeded) {
+		// Server connected fine without auth — reauth is not needed. A tool-level
+		// challenge overrides this: servers may allow the anonymous handshake yet
+		// protect individual tool calls with `_meta["mcp/www_authenticate"]`.
+		if (connectionSucceeded && !authChallenge) {
 			throw new Error("Server connection succeeded without OAuth; reauthorization is not required.");
 		}
 
-		// Analyze the connection error to extract OAuth endpoints
-		const authResult = analyzeAuthError(connectionError!, "url" in config ? config.url : undefined);
+		// Tool calls can carry richer RFC 6750/RFC 9728 hints than the original
+		// connection error. Feed those hints through the same analyzer so
+		// resource_metadata and scope reach protected-resource discovery.
+		const authError = authChallenge
+			? new Error(`${connectionError?.message ?? "HTTP 401"}\n${authChallenge.wwwAuthenticate.join("\n")}`)
+			: connectionError!;
+		const authResult = analyzeAuthError(authError, "url" in config ? config.url : undefined);
 		let oauth = authResult.authType === "oauth" ? (authResult.oauth ?? null) : null;
 
 		if (!oauth && (config.type === "http" || config.type === "sse") && config.url) {
@@ -1678,21 +1690,29 @@ export class MCPCommandController {
 		}
 	}
 
-	async #handleReauth(name: string | undefined): Promise<void> {
+	/** Reauthorize a server after a tool-level OAuth challenge. */
+	async handleMCPAuthChallenge(name: string, challenge: MCPAuthChallenge): Promise<MCPServerConfig | undefined> {
+		return this.#handleReauth(name, { silent: true, reload: false, authChallenge: challenge });
+	}
+
+	async #handleReauth(
+		name: string | undefined,
+		options: { silent?: boolean; reload?: boolean; authChallenge?: MCPAuthChallenge } = {},
+	): Promise<MCPServerConfig | undefined> {
 		if (!name) {
-			this.ctx.showError("Server name required. Usage: /mcp reauth <name>");
+			if (!options.silent) this.ctx.showError("Server name required. Usage: /mcp reauth <name>");
 			return;
 		}
 
 		try {
 			const found = await this.#resolveServerForAuth(name);
 			if (!found) {
-				this.ctx.showError(`Server "${name}" not found.`);
+				if (!options.silent) this.ctx.showError(`Server "${name}" not found.`);
 				return;
 			}
 
 			if (found.config.enabled === false) {
-				this.ctx.showError(`Server "${name}" is disabled. Run /mcp enable ${name} first.`);
+				if (!options.silent) this.ctx.showError(`Server "${name}" is disabled. Run /mcp enable ${name} first.`);
 				return;
 			}
 
@@ -1705,7 +1725,7 @@ export class MCPCommandController {
 			// happened yet if the server turns out not to need (or support) OAuth.
 			// Use the same env-expanded config shape runtime discovery passes to
 			// MCPManager; the raw file value may contain `${...}` placeholders.
-			const oauth = await this.#resolveOAuthEndpointsFromServer(runtimeBaseConfig);
+			const oauth = await this.#resolveOAuthEndpointsFromServer(runtimeBaseConfig, options.authChallenge);
 			const serverUrl =
 				runtimeBaseConfig.type === "http" || runtimeBaseConfig.type === "sse" ? runtimeBaseConfig.url : undefined;
 			// A user-supplied client secret may live in either block (the wizard
@@ -1719,7 +1739,9 @@ export class MCPCommandController {
 			const userClientSecret = found.config.oauth?.clientSecret ?? currentAuth?.clientSecret;
 			const flowClientSecret = userClientSecret ?? storedClientSecret ?? "";
 
-			this.#showMessage(["", theme.fg("muted", `Reauthorizing "${name}"...`), ""].join("\n"));
+			if (!options.silent) {
+				this.#showMessage(["", theme.fg("muted", `Reauthorizing "${name}"...`), ""].join("\n"));
+			}
 
 			const currentAuthResource = currentAuth?.resource ? expandEnvVarsDeep(currentAuth.resource) : undefined;
 			const oauthResource =
@@ -1755,39 +1777,49 @@ export class MCPCommandController {
 			// Definition-only entries resolve through the url-keyed binding alone;
 			// skip the write-back so a committed project mcp.json stays clean.
 			const urlKeyedId = serverUrl ? mcpOAuthCredentialId(serverUrl) : undefined;
-			if (currentAuth || oauthResult.credentialId !== urlKeyedId) {
-				const updated = this.#persistOAuthResult(baseConfig, oauthResult, {
-					tokenUrl: oauth.tokenUrl,
-					clientId: oauth.clientId,
-					userClientSecret,
-					resource: oauthResource,
-					stripSameOriginResource: oauthResourceIsFallback,
-				});
-				await updateMCPServer(found.filePath, name, updated);
-			}
-			await this.#reloadMCP();
-			const state = await this.#waitForServerConnectionWithAnimation(name);
+			const shouldPersist = currentAuth || oauthResult.credentialId !== urlKeyedId;
+			const updatedConfig = shouldPersist
+				? this.#persistOAuthResult(baseConfig, oauthResult, {
+						tokenUrl: oauth.tokenUrl,
+						clientId: oauth.clientId,
+						userClientSecret,
+						resource: oauthResource,
+						stripSameOriginResource: oauthResourceIsFallback,
+					})
+				: baseConfig;
+			if (shouldPersist) {
+				await updateMCPServer(found.filePath, name, updatedConfig);
+			}
+			if (options.reload !== false) {
+				await this.#reloadMCP();
+				const state = await this.#waitForServerConnectionWithAnimation(name);
 
-			const lines = [
-				"",
-				theme.fg("success", `✓ Reauthorized "${name}" (${found.scope} config)`),
-				"",
-				`  Status: ${
-					state === "connected"
-						? theme.fg("success", "connected")
-						: state === "connecting"
-							? theme.fg("muted", "connecting")
-							: theme.fg("warning", "not connected")
-				}`,
-				"",
-			];
-			this.#showMessage(lines.join("\n"));
+				const lines = [
+					"",
+					theme.fg("success", `✓ Reauthorized "${name}" (${found.scope} config)`),
+					"",
+					`  Status: ${
+						state === "connected"
+							? theme.fg("success", "connected")
+							: state === "connecting"
+								? theme.fg("muted", "connecting")
+								: theme.fg("warning", "not connected")
+					}`,
+					"",
+				];
+				this.#showMessage(lines.join("\n"));
+			}
+			return updatedConfig;
 		} catch (error) {
 			if (error instanceof MCPOAuthCancelledError) {
-				this.ctx.showStatus(`Reauthorization cancelled for "${name}"`);
+				if (!options.silent) this.ctx.showStatus(`Reauthorization cancelled for "${name}"`);
 				return;
 			}
-			this.ctx.showError(`Failed to reauthorize server: ${error instanceof Error ? error.message : String(error)}`);
+			if (!options.silent) {
+				this.ctx.showError(
+					`Failed to reauthorize server: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
 		}
 	}
 
@@ -2091,7 +2123,14 @@ export class MCPCommandController {
 			if (Date.now() - startedAt >= timeoutMs) {
 				throw new Error("Smithery authorization timed out after 5 minutes.");
 			}
-			const response = await pollSmitheryCliAuthSession(sessionId, signal);
+			let response: SmitheryCliPollResponse;
+			try {
+				response = await pollSmitheryCliAuthSession(sessionId, signal);
+			} catch (error) {
+				// A single hung/slow poll aborts with TimeoutError; retry until the deadline.
+				if (isTimeoutError(error)) continue;
+				throw error;
+			}
 			if (response.status === "success" && response.apiKey) {
 				return response.apiKey;
 			}

package/src/modes/controllers/omfg-controller.ts

@@ -192,56 +192,60 @@ export class OmfgController {
 
 	async #saveCandidate(request: OmfgRequest, candidate: OmfgCandidate): Promise<SaveCandidateResult> {
 		if (this.#shouldStop(request)) return { kind: "aborted" };
-		request.component.setStatus("saving", "Choose where to save or amend the TTSR rule…");
-		const location = await this.ctx.showHookSelector("Save TTSR rule where?", [
-			PROJECT_OPTION,
-			GLOBAL_OPTION,
-			AMEND_OPTION,
-		]);
-		if (!this.#isActiveRequest(request)) return { kind: "aborted" };
-		if (!location) {
-			request.component.markAborted();
-			this.#closeActiveRequest({ abort: false });
-			return { kind: "aborted" };
-		}
 
-		if (location === AMEND_OPTION) {
-			request.component.setStatus("confirming", "Describe how to amend the rule…");
-			const amendment = await this.ctx.showHookInput(
-				"Amend TTSR rule",
-				"e.g. Make it specific to Ruby string eval in tool:write(*.rb)",
-			);
+		for (;;) {
+			request.component.setStatus("saving", "Choose where to save or amend the TTSR rule…");
+			const location = await this.ctx.showHookSelector("Save TTSR rule where?", [
+				PROJECT_OPTION,
+				GLOBAL_OPTION,
+				AMEND_OPTION,
+			]);
 			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
-			const feedback = amendment?.trim();
-			if (!feedback) {
+			if (!location) {
 				request.component.markAborted();
 				this.#closeActiveRequest({ abort: false });
 				return { kind: "aborted" };
 			}
-			return { kind: "amend", feedback };
-		}
 
-		const target = this.#resolveTarget(location, candidate.rule.name);
-		if (await Bun.file(target.filePath).exists()) {
-			const shouldOverwrite = await this.ctx.showHookConfirm(
-				"Overwrite TTSR rule?",
-				`${shortenPath(target.filePath)} already exists. Overwrite it?`,
-			);
-			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
-			if (!shouldOverwrite) {
-				request.component.markRejected();
-				return { kind: "rejected" };
+			if (location === AMEND_OPTION) {
+				request.component.setStatus("confirming", "Describe how to amend the rule…");
+				const amendment = await this.ctx.showHookInput(
+					"Amend TTSR rule",
+					"e.g. Make it specific to Ruby string eval in tool:write(*.rb)",
+				);
+				if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+				const feedback = amendment?.trim();
+				if (!feedback) continue;
+				return { kind: "amend", feedback };
 			}
-		}
 
-		request.component.setStatus("saving", `Saving ${candidate.rule.name}…`);
-		await Bun.write(target.filePath, candidate.fileContent);
-		if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+			const target = this.#resolveTarget(location, candidate.rule.name);
+			if (await Bun.file(target.filePath).exists()) {
+				const shouldOverwrite = await this.ctx.showHookConfirm(
+					"Overwrite TTSR rule?",
+					`${shortenPath(target.filePath)} already exists. Overwrite it?`,
+				);
+				if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+				if (!shouldOverwrite) {
+					request.component.markRejected();
+					return { kind: "rejected" };
+				}
+			}
 
-		const savedRule = buildOmfgRuleForPath(candidate.rule.name, candidate.fileContent, target.filePath, target.level);
-		this.#registerLive(savedRule);
-		request.component.markSaved(shortenPath(target.filePath));
-		return { kind: "saved" };
+			request.component.setStatus("saving", `Saving ${candidate.rule.name}…`);
+			await Bun.write(target.filePath, candidate.fileContent);
+			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+
+			const savedRule = buildOmfgRuleForPath(
+				candidate.rule.name,
+				candidate.fileContent,
+				target.filePath,
+				target.level,
+			);
+			this.#registerLive(savedRule);
+			request.component.markSaved(shortenPath(target.filePath));
+			return { kind: "saved" };
+		}
 	}
 
 	#resolveTarget(location: string, ruleName: string): { filePath: string; level: OmfgRuleSourceLevel } {

package/src/modes/controllers/selector-controller.ts

@@ -57,12 +57,10 @@ import {
 	parseConfiguredThinkingLevel,
 } from "../../thinking";
 import {
-	isImageProviderPreference,
 	isSearchProviderId,
-	isSearchProviderPreference,
 	setExcludedSearchProviders,
-	setPreferredImageProvider,
-	setPreferredSearchProvider,
+	setImageProviderOrder,
+	setSearchProviderOrder,
 	type ToolSession,
 } from "../../tools";
 import { AskTool, type AskToolDetails, type AskToolInput } from "../../tools/ask";
@@ -439,6 +437,16 @@ export class SelectorController {
 					this.ctx.showError(`Failed to apply personality: ${err}`);
 				});
 				break;
+			case "tools.xdevDocs":
+				void this.ctx.session.refreshBaseSystemPrompt().catch(err => {
+					this.ctx.showError(`Failed to apply xd:// prompt docs setting: ${err}`);
+				});
+				break;
+			case "memory.backend":
+				void this.ctx.session.applyMemoryBackend().catch(err => {
+					this.ctx.showError(`Failed to apply memory backend: ${err}`);
+				});
+				break;
 
 			case "autocompleteMaxVisible":
 				this.ctx.editor.setAutocompleteMaxVisible(typeof value === "number" ? value : Number(value));
@@ -609,9 +617,9 @@ export class SelectorController {
 			}
 
 			// Provider settings - update runtime preferences
-			case "providers.webSearch":
-				if (typeof value === "string" && isSearchProviderPreference(value)) {
-					setPreferredSearchProvider(value);
+			case "providers.webSearchOrder":
+				if (Array.isArray(value)) {
+					setSearchProviderOrder(value.filter(isSearchProviderId));
 				}
 				break;
 			case "providers.webSearchExclude":
@@ -619,9 +627,9 @@ export class SelectorController {
 					setExcludedSearchProviders(value.filter(isSearchProviderId));
 				}
 				break;
-			case "providers.image":
-				if (isImageProviderPreference(value)) {
-					setPreferredImageProvider(value);
+			case "providers.imageOrder":
+				if (Array.isArray(value)) {
+					setImageProviderOrder(value.filter((entry): entry is string => typeof entry === "string"));
 				}
 				break;
 

package/src/modes/controllers/session-focus-controller.ts

@@ -12,6 +12,7 @@
 import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
 import { AgentRegistry, MAIN_AGENT_ID, type RegistryEvent } from "../../registry/agent-registry";
 import type { AgentSession } from "../../session/agent-session";
+import { setTerminalTitleState } from "../../utils/title-generator";
 import type { InteractiveModeContext } from "../types";
 
 export class SessionFocusController {
@@ -104,8 +105,12 @@ export class SessionFocusController {
 		});
 		this.ctx.statusLine.setSession(target, this.#focusedAgentId);
 		this.ctx.renderInitialMessages({ clearTerminalHistory: true });
-		// Mid-turn attach: no agent_start will arrive; arm the loader/turn state manually.
+		// Sync the run-state title to the attached target: a streaming target has no
+		// agent_start incoming, so arm the loader/working title manually; an idle
+		// target would otherwise inherit the previous session's stuck spinner, so
+		// reset it to idle (agent_end teardown already ran via clearTransientSessionUi).
 		if (target.isStreaming) await this.ctx.eventController.handleEvent({ type: "agent_start" });
+		else setTerminalTitleState("idle");
 		this.ctx.updateEditorBorderColor();
 		this.ctx.ui.requestRender();
 	}