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

package/src/live/visualizer.ts

@@ -0,0 +1,234 @@
+import { type Component, matchesKey, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { type ThemeColor, theme } from "../modes/theme/theme";
+
+/** Distinct states of a realtime call connection. */
+export type LivePhase = "connecting" | "listening" | "working" | "speaking" | "muted" | "error";
+
+/** A transcribed turn in the realtime call. */
+export interface LiveTranscript {
+	role: "user" | "assistant";
+	text: string;
+}
+
+/** Configuration callbacks for user interactions in the visualizer. */
+export interface LiveVisualizerOptions {
+	onStop(): void;
+	onToggleMute(): void;
+}
+
+/** A compact, fixed-height terminal component for displaying a realtime call. */
+export class LiveVisualizer implements Component {
+	readonly wantsKeyRelease = false;
+
+	readonly #options: LiveVisualizerOptions;
+
+	#phase: LivePhase = "connecting";
+	#inputLevel = 0;
+	#outputLevel = 0;
+	#transcript: LiveTranscript | undefined;
+	#frame = 0;
+
+	#cache:
+		| {
+				width: number;
+				phase: LivePhase;
+				inputLevel: number;
+				outputLevel: number;
+				transcriptRole: string | undefined;
+				transcriptText: string | undefined;
+				frame: number;
+				lines: readonly string[];
+		  }
+		| undefined;
+
+	constructor(options: LiveVisualizerOptions) {
+		this.#options = options;
+	}
+
+	/** Updates the current call phase. */
+	setPhase(phase: LivePhase): void {
+		if (this.#phase !== phase) {
+			this.#phase = phase;
+			this.invalidate();
+		}
+	}
+
+	/** Updates the current input and output volume levels (0..1). */
+	setLevels(input: number, output: number): void {
+		if (this.#inputLevel !== input || this.#outputLevel !== output) {
+			this.#inputLevel = input;
+			this.#outputLevel = output;
+			this.invalidate();
+		}
+	}
+
+	/** Updates the latest transcript fragment. */
+	setTranscript(transcript: LiveTranscript | undefined): void {
+		if (this.#transcript?.role !== transcript?.role || this.#transcript?.text !== transcript?.text) {
+			this.#transcript = transcript ? { ...transcript } : undefined;
+			this.invalidate();
+		}
+	}
+
+	/** Updates the animation frame for spinners and waveforms. */
+	setFrame(frame: number): void {
+		if (this.#frame !== frame) {
+			this.#frame = frame;
+			this.invalidate();
+		}
+	}
+
+	/** Processes user keypresses. */
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape")) {
+			this.#options.onStop();
+		} else if (matchesKey(data, "space")) {
+			this.#options.onToggleMute();
+		}
+	}
+
+	/** Clears the render cache. */
+	invalidate(): void {
+		this.#cache = undefined;
+	}
+
+	/** Renders the visualizer into a fixed array of rows at the given width. */
+	render(width: number): readonly string[] {
+		if (
+			this.#cache &&
+			this.#cache.width === width &&
+			this.#cache.phase === this.#phase &&
+			this.#cache.inputLevel === this.#inputLevel &&
+			this.#cache.outputLevel === this.#outputLevel &&
+			this.#cache.frame === this.#frame &&
+			this.#cache.transcriptRole === this.#transcript?.role &&
+			this.#cache.transcriptText === this.#transcript?.text
+		) {
+			return this.#cache.lines;
+		}
+
+		const lines = this.#renderLines(width);
+
+		this.#cache = {
+			width,
+			phase: this.#phase,
+			inputLevel: this.#inputLevel,
+			outputLevel: this.#outputLevel,
+			frame: this.#frame,
+			transcriptRole: this.#transcript?.role,
+			transcriptText: this.#transcript?.text,
+			lines,
+		};
+
+		return lines;
+	}
+
+	#renderLines(maxWidth: number): readonly string[] {
+		const w = Math.max(2, Math.min(maxWidth, 120));
+		const innerW = w - 2;
+
+		const topBorder = theme.fg("border", `┌${"─".repeat(innerW)}${w > 1 ? "┐" : ""}`);
+
+		const maxWaveW = Math.min(40, Math.max(0, w - 4));
+		const sideW = Math.max(0, Math.floor((maxWaveW - 3) / 2));
+
+		const inWave = this.#generateWaveform(this.#inputLevel, sideW, true);
+		const outWave = this.#generateWaveform(this.#outputLevel, sideW, false);
+
+		const inColor: ThemeColor = this.#phase === "muted" ? "dim" : "success";
+		const outColor: ThemeColor = this.#phase === "error" ? "error" : "accent";
+
+		const waveContent = truncateToWidth(
+			theme.fg(inColor, inWave) + theme.fg("dim", " │ ") + theme.fg(outColor, outWave),
+			innerW,
+		);
+		const waveLen = visibleWidth(waveContent);
+
+		const wavePadL = Math.floor((innerW - waveLen) / 2);
+		const wavePadR = innerW - waveLen - wavePadL;
+		const row1 =
+			theme.fg("border", "│") +
+			" ".repeat(Math.max(0, wavePadL)) +
+			waveContent +
+			" ".repeat(Math.max(0, wavePadR)) +
+			(w > 1 ? theme.fg("border", "│") : "");
+
+		const phaseColors: Record<LivePhase, ThemeColor> = {
+			connecting: "dim",
+			listening: "success",
+			working: "warning",
+			speaking: "accent",
+			muted: "dim",
+			error: "error",
+		};
+
+		const spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+		let phaseIcon: string;
+		if (this.#phase === "working") {
+			phaseIcon = spinners[this.#frame % spinners.length];
+		} else {
+			const staticIcons: Record<LivePhase, string> = {
+				connecting: "○",
+				listening: "●",
+				working: "○",
+				speaking: "»",
+				muted: "×",
+				error: "!",
+			};
+			phaseIcon = staticIcons[this.#phase];
+		}
+
+		const phaseText = truncateToWidth(` ${phaseIcon} ${this.#phase.toUpperCase()} `, innerW);
+		const coloredPhase = theme.fg(phaseColors[this.#phase], phaseText);
+
+		const pLen = visibleWidth(coloredPhase);
+		const pPadL = Math.floor((innerW - pLen) / 2);
+		const pPadR = innerW - pLen - pPadL;
+		const row2 =
+			theme.fg("border", "│") +
+			" ".repeat(Math.max(0, pPadL)) +
+			coloredPhase +
+			" ".repeat(Math.max(0, pPadR)) +
+			(w > 1 ? theme.fg("border", "│") : "");
+
+		const row3 = theme.fg("border", "│") + " ".repeat(Math.max(0, innerW)) + (w > 1 ? theme.fg("border", "│") : "");
+
+		let transcriptText = "";
+		if (this.#transcript) {
+			const cleanText = sanitizeText(this.#transcript.text).replace(/[\r\n\t]+/g, " ");
+			const roleStr = this.#transcript.role === "user" ? "User: " : "Assistant: ";
+			transcriptText = theme.fg("dim", roleStr + cleanText);
+		}
+		const row4Content = truncateToWidth(`  ${transcriptText}`, Math.max(0, innerW - 2)) || "";
+		const r4Pad = Math.max(0, innerW - visibleWidth(row4Content));
+		const row4 = theme.fg("border", "│") + row4Content + " ".repeat(r4Pad) + (w > 1 ? theme.fg("border", "│") : "");
+
+		const footerContent = truncateToWidth(" space mute · esc end ", innerW);
+		const dashCount = Math.max(0, innerW - visibleWidth(footerContent));
+		let bottomBorder: string;
+		if (innerW >= visibleWidth(footerContent) + 2) {
+			bottomBorder =
+				theme.fg("border", "└─") +
+				theme.fg("dim", footerContent) +
+				theme.fg("border", "─".repeat(dashCount - 2) + (w > 1 ? "┘" : ""));
+		} else {
+			bottomBorder = theme.fg("border", `└${"─".repeat(Math.max(0, innerW))}${w > 1 ? "┘" : ""}`);
+		}
+
+		return [topBorder, row1, row2, row3, row4, bottomBorder];
+	}
+
+	#generateWaveform(level: number, width: number, reverse: boolean): string {
+		const chars = [" ", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+		let out = "";
+		for (let i = 0; i < width; i++) {
+			const dist = reverse ? width - 1 - i : i;
+			const decay = Math.max(0, 1 - (dist / width) * 1.5);
+			const val = level * decay * (0.5 + 0.5 * Math.sin(this.#frame * 0.5 + dist * 0.8));
+			const charIdx = Math.max(0, Math.min(chars.length - 1, Math.floor(val * chars.length)));
+			out += chars[charIdx];
+		}
+		return out;
+	}
+}

package/src/lsp/client.ts

@@ -364,7 +364,15 @@ async function startMessageReader(client: LspClient): Promise<void> {
 						if (pending) {
 							client.pendingRequests.delete(message.id);
 							if ("error" in message && message.error) {
-								pending.reject(new Error(`LSP error: ${message.error.message}`));
+								// Include the JSON-RPC error code: `isMethodNotFoundError` matches
+								// `-32601` by substring, so method-not-found is recognized even when
+								// the server's message text is nonstandard (e.g. "Unknown request").
+								const code = message.error.code;
+								pending.reject(
+									new Error(
+										`LSP error${typeof code === "number" ? ` ${code}` : ""}: ${message.error.message}`,
+									),
+								);
 							} else {
 								pending.resolve(message.result);
 							}
@@ -846,6 +854,29 @@ export async function getOrCreateClient(
 	return clientPromise;
 }
 
+/** Return an active or already-starting client without starting a language server. */
+export async function getActiveOrPendingClient(
+	config: ServerConfig,
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<LspClient | undefined> {
+	throwIfAborted(signal);
+	const client = clients.get(`${config.command}:${cwd}`);
+	if (client) {
+		client.lastActivity = Date.now();
+		return client;
+	}
+
+	const pending = clientLocks.get(`${config.command}:${cwd}`);
+	if (!pending) return undefined;
+	try {
+		return await untilAborted(signal, pending);
+	} catch {
+		throwIfAborted(signal);
+		return undefined;
+	}
+}
+
 /**
  * Ensure a file is opened in the LSP client.
  * Sends didOpen notification if the file is not already tracked.
@@ -1158,9 +1189,19 @@ async function waitForExit(client: LspClient, timeoutMs: number): Promise<boolea
 }
 
 /**
- * Shutdown a specific client instance using the LSP shutdown/exit handshake.
+ * Tear down a specific client instance using the LSP shutdown/exit handshake.
+ *
+ * Removes the client from the registry by identity first (never evicting a
+ * newer client already republished under the same key), then performs a bounded
+ * graceful shutdown, force-killing and awaiting confirmed process exit.
+ *
+ * @returns `true` once the process is confirmed exited, `false` if it outlived
+ * the shutdown budget — callers reporting a restart must treat `false` as a
+ * failed teardown, not a completed restart.
  */
-async function shutdownClientInstance(client: LspClient): Promise<void> {
+export async function shutdownClientInstance(client: LspClient): Promise<boolean> {
+	if (clients.get(client.name) === client) clients.delete(client.name);
+
 	const err = new Error("LSP client shutdown");
 	for (const pending of Array.from(client.pendingRequests.values())) {
 		pending.reject(err);
@@ -1173,21 +1214,23 @@ async function shutdownClientInstance(client: LspClient): Promise<void> {
 	);
 	if (shutdownCompleted) {
 		await sendNotification(client, "exit", undefined).catch(() => {});
-		if (await waitForExit(client, EXIT_TIMEOUT_MS)) return;
+		if (await waitForExit(client, EXIT_TIMEOUT_MS)) return true;
 	}
 
 	client.proc.kill();
-	await waitForExit(client, EXIT_TIMEOUT_MS);
+	return await waitForExit(client, EXIT_TIMEOUT_MS);
 }
 
 /**
  * Shutdown a specific client by key.
+ *
+ * @returns `true` when the client is gone (already absent or confirmed exited),
+ * `false` if a live process outlived the shutdown budget.
  */
-export async function shutdownClient(key: string): Promise<void> {
+export async function shutdownClient(key: string): Promise<boolean> {
 	const client = clients.get(key);
-	if (!client) return;
-	clients.delete(key);
-	await shutdownClientInstance(client);
+	if (!client) return true;
+	return await shutdownClientInstance(client);
 }
 
 // =============================================================================

package/src/lsp/clients/biome-client.ts

@@ -2,7 +2,7 @@
  * Biome CLI-based linter client.
  * Uses Biome's CLI with JSON output instead of LSP (which has stale diagnostics issues).
  */
-import path from "node:path";
+import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "../../lsp/types";
 
@@ -141,14 +141,13 @@ export class BiomeClient implements LinterClient {
 	) {}
 
 	async format(filePath: string, content: string): Promise<string> {
-		// Write content to file first
+		// Keep the standalone LinterClient contract: callers supply the content to
+		// format, regardless of what is currently on disk.
 		await Bun.write(filePath, content);
 
-		// Run biome format --write
 		const result = await runBiome(["format", "--write", filePath], this.cwd, this.config.resolvedCommand);
 
 		if (result.success) {
-			// Read back formatted content
 			return await Bun.file(filePath).text();
 		}
 

package/src/lsp/index.ts

@@ -20,6 +20,7 @@ import {
 	ensureFileOpen,
 	FileChangeType,
 	getActiveClients,
+	getActiveOrPendingClient,
 	getOrCreateClient,
 	type LspServerStatus,
 	notifySaved,
@@ -28,6 +29,7 @@ import {
 	sendNotification,
 	sendRequest,
 	setIdleTimeout,
+	shutdownClientInstance,
 	supportsDocumentDiagnostics,
 	syncContent,
 	WARMUP_TIMEOUT_MS,
@@ -211,6 +213,7 @@ async function syncFileContent(
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
 	signal?: AbortSignal,
+	createMissing = true,
 ): Promise<void> {
 	throwIfAborted(signal);
 	await Promise.allSettled(
@@ -219,11 +222,15 @@ async function syncFileContent(
 			if (serverConfig.createClient) {
 				return;
 			}
-			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
+			const client = createMissing
+				? await getOrCreateClient(serverConfig, cwd, undefined, signal)
+				: await getActiveOrPendingClient(serverConfig, cwd, signal);
+			if (!client) return;
 			throwIfAborted(signal);
 			await syncContent(client, absolutePath, content, signal);
 		}),
 	);
+	throwIfAborted(signal);
 }
 
 /**
@@ -239,6 +246,7 @@ async function notifyFileSaved(
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
 	signal?: AbortSignal,
+	createMissing = true,
 ): Promise<void> {
 	throwIfAborted(signal);
 	await Promise.allSettled(
@@ -247,10 +255,14 @@ async function notifyFileSaved(
 			if (serverConfig.createClient) {
 				return;
 			}
-			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
+			const client = createMissing
+				? await getOrCreateClient(serverConfig, cwd, undefined, signal)
+				: await getActiveOrPendingClient(serverConfig, cwd, signal);
+			if (!client) return;
 			await notifySaved(client, absolutePath, signal);
 		}),
 	);
+	throwIfAborted(signal);
 }
 
 // Cache config per cwd to avoid repeated file I/O
@@ -496,12 +508,18 @@ function isMethodNotFoundError(err: unknown): boolean {
 }
 
 async function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string> {
-	// rust-analyzer exposes a real reload request.
+	throwIfAborted(signal);
+	// rust-analyzer exposes a real reload request. Every other server rejects it
+	// with method-not-found — that alone justifies the generic fallback. A caller
+	// cancel or tool timeout must propagate, never be mistaken for an unsupported
+	// method and swallowed into a bogus "Restarted" (issue #6369).
 	try {
 		await sendRequest(client, "rust-analyzer/reloadWorkspace", null, signal);
 		return `Reloaded ${serverName}`;
-	} catch {
-		// Method not supported — fall through.
+	} catch (err) {
+		throwIfAborted(signal);
+		if (!isMethodNotFoundError(err)) throw err;
+		// Method not supported — fall through to the generic reload.
 	}
 	// workspace/didChangeConfiguration is a notification per spec; sending it
 	// as a request hangs until the tool deadline on servers that route it to
@@ -510,7 +528,15 @@ async function reloadServer(client: LspClient, serverName: string, signal?: Abor
 		await sendNotification(client, "workspace/didChangeConfiguration", { settings: {} }, signal);
 		return `Reloaded ${serverName}`;
 	} catch {
-		client.proc.kill();
+		throwIfAborted(signal);
+		// The reload notification could not be delivered — the connection is
+		// wedged or the process already died. Tear the client down (removing it
+		// from the registry by identity and awaiting confirmed process exit) so
+		// the next request cold-starts a fresh client. A kill that never confirms
+		// exit is not a restart: surface the teardown failure truthfully.
+		if (!(await shutdownClientInstance(client))) {
+			throw new Error(`Failed to restart ${serverName}: server process did not exit after kill`);
+		}
 		return `Restarted ${serverName}`;
 	}
 }
@@ -1333,7 +1359,8 @@ async function runLspWritethrough(
 	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
 	// Bound client creation by the writethrough budget: a hung/broken server
 	// must not add its full init wait (30s default) to every edit.
-	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers, 5_000, signal) : undefined;
+	const minVersionsPromise = enableDiagnostics ? captureDiagnosticVersions(cwd, servers, 5_000, signal) : undefined;
+	let minVersions = useCustomFormatter ? undefined : await minVersionsPromise;
 	let expectedDocumentVersions: ServerVersionMap | undefined;
 
 	let formatter: FileFormatResult | undefined;
@@ -1353,13 +1380,19 @@ async function runLspWritethrough(
 		operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 		await untilAborted(operationSignal, async () => {
 			if (useCustomFormatter) {
-				// Custom linters (e.g. Biome CLI) require on-disk input.
+				// Custom linters operate on on-disk input; the shared pre-write also
+				// supports implementations that inspect the file before formatting.
 				await writeContent(content);
-				finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+				const [formattedContent, capturedVersions] = await Promise.all([
+					formatContent(dst, content, cwd, customLinterServers, operationSignal),
+					minVersionsPromise,
+				]);
+				finalContent = formattedContent;
+				minVersions = capturedVersions;
 				formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
 				await writeContent(finalContent);
 				await notifyWriteCommitted(operationSignal);
-				await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
+				await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal, enableDiagnostics);
 			} else {
 				// 1. Sync original content to LSP servers
 				await syncFileContent(dst, content, cwd, lspServers, operationSignal);
@@ -1385,7 +1418,7 @@ async function runLspWritethrough(
 			}
 
 			// 5. Notify saved to LSP servers
-			await notifyFileSaved(dst, cwd, lspServers, operationSignal);
+			await notifyFileSaved(dst, cwd, lspServers, operationSignal, !useCustomFormatter || enableDiagnostics);
 		});
 		synced = true;
 	} catch {

package/src/main.ts

@@ -134,6 +134,7 @@ async function checkForNewVersion(currentVersion: string): Promise<string | unde
 // embedders need project-level opt-outs for reminder/prelude prompt injection.
 const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"task.isolation.mode",
+	"task.isolation.apply",
 	"task.isolation.merge",
 	"task.isolation.commits",
 	"task.eager",
@@ -390,7 +391,9 @@ export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSess
 			authStorage: args.authStorage,
 			modelRegistry: args.modelRegistry,
 			agentId,
-			hasUI: false,
+			// Preserve reserve-policy confirmation until ACP capabilities are known
+			// without enabling AskTool or other UI-only session behavior.
+			deferUsageReserveConfirmation: true,
 			enableMCP: false,
 			titleSystemPrompt,
 		});
@@ -833,6 +836,11 @@ export async function buildSessionOptions(
 		cwd: parsed.cwd ?? getProjectDir(),
 		autoApprove: parsed.autoApprove ?? false,
 	};
+	const cliDirs = parsed.addDir ?? [];
+	const settingsDirs = activeSettings.get("workspace.additionalDirectories");
+	if (cliDirs.length > 0 || settingsDirs.length > 0) {
+		options.additionalDirectories = [...new Set([...cliDirs, ...settingsDirs])];
+	}
 	if (parsed.maxTime !== undefined) {
 		options.deadline = Date.now() + parsed.maxTime * 1000;
 	}

package/src/mcp/config-writer.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { addMCPServer, readDisabledServers, readMCPConfigFile, setServerDisabled } from "./config-writer";
+
+describe("config-writer concurrent mutations", () => {
+	let dir: string;
+	let filePath: string;
+
+	beforeEach(async () => {
+		dir = await fs.mkdtemp(path.join(os.tmpdir(), "omp-mcp-config-"));
+		filePath = path.join(dir, "mcp.json");
+	});
+
+	afterEach(async () => {
+		await fs.rm(dir, { recursive: true, force: true });
+	});
+
+	it("preserves both servers when two adds race the same file", async () => {
+		await Promise.all([
+			addMCPServer(filePath, "alpha", { type: "stdio", command: "a" }),
+			addMCPServer(filePath, "bravo", { type: "stdio", command: "b" }),
+		]);
+
+		const config = await readMCPConfigFile(filePath);
+		expect(Object.keys(config.mcpServers ?? {}).sort()).toEqual(["alpha", "bravo"]);
+	});
+
+	it("preserves both denylist edits when disable calls race", async () => {
+		await Promise.all([setServerDisabled(filePath, "alpha", true), setServerDisabled(filePath, "bravo", true)]);
+
+		expect((await readDisabledServers(filePath)).sort()).toEqual(["alpha", "bravo"]);
+	});
+
+	it("writes into a directory that does not exist yet", async () => {
+		const nestedPath = path.join(dir, "nested", "deep", "mcp.json");
+		await addMCPServer(nestedPath, "alpha", { type: "stdio", command: "a" });
+
+		const config = await readMCPConfigFile(nestedPath);
+		expect(Object.keys(config.mcpServers ?? {})).toEqual(["alpha"]);
+	});
+});