@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/src/live/visualizer.ts

@@ -0,0 +1,214 @@
+import {
+	type Component,
+	matchesKey,
+	replaceTabs,
+	sliceWithWidth,
+	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";
+/** Configuration callbacks for user interactions in the visualizer. */
+export interface LiveVisualizerOptions {
+	onStop(): void;
+	onToggleMute(): void;
+}
+
+function normalizeTranscript(text: string): string {
+	return replaceTabs(sanitizeText(text)).replace(/\s+/g, " ").trim();
+}
+
+function truncateFromStart(text: string, width: number): string {
+	if (width <= 0) return "";
+	const textWidth = visibleWidth(text);
+	if (textWidth <= width) return text;
+	if (width === 1) return "…";
+	return `…${sliceWithWidth(text, textWidth - width + 1, width - 1, true).text}`;
+}
+
+/** 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;
+	#displayLevel = 0;
+	#frame = 0;
+	#userTranscript = "";
+
+	#cache:
+		| {
+				width: number;
+				phase: LivePhase;
+				displayLevel: number;
+				frame: number;
+				userTranscript: string;
+				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 microphone volume level (0..1). */
+	setInputLevel(level: number): void {
+		const next = Number.isFinite(level) ? Math.min(1, Math.max(0, level)) : 0;
+		if (this.#inputLevel === next) return;
+		this.#inputLevel = next;
+		if (next > this.#displayLevel) this.#displayLevel = next;
+		this.invalidate();
+	}
+
+	/** Advances the spectrum animation and its peak decay. */
+	setFrame(frame: number): void {
+		const nextLevel = Math.max(this.#inputLevel, this.#displayLevel * 0.84);
+		if (this.#frame !== frame || this.#displayLevel !== nextLevel) {
+			this.#frame = frame;
+			this.#displayLevel = nextLevel;
+			this.invalidate();
+		}
+	}
+
+	/** Updates the user's streaming voice transcript. */
+	setTranscript(text: string): void {
+		const normalized = normalizeTranscript(text);
+		if (this.#userTranscript === normalized) return;
+		this.#userTranscript = normalized;
+		this.invalidate();
+	}
+
+	/** Clears the user's voice transcript row. */
+	clearTranscript(): void {
+		if (!this.#userTranscript) return;
+		this.#userTranscript = "";
+		this.invalidate();
+	}
+
+	/** Processes user keypresses. */
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.#options.onStop();
+		} else if (matchesKey(data, "space")) {
+			this.#options.onToggleMute();
+		}
+	}
+
+	/** Clears the render cache. */
+	invalidate(): void {
+		this.#cache = undefined;
+	}
+
+	/** Renders the microphone spectrum into a compact fixed-height panel. */
+	render(width: number): readonly string[] {
+		if (
+			this.#cache &&
+			this.#cache.width === width &&
+			this.#cache.phase === this.#phase &&
+			this.#cache.displayLevel === this.#displayLevel &&
+			this.#cache.frame === this.#frame &&
+			this.#cache.userTranscript === this.#userTranscript
+		) {
+			return this.#cache.lines;
+		}
+
+		const lines = this.#renderLines(width);
+		this.#cache = {
+			width,
+			phase: this.#phase,
+			displayLevel: this.#displayLevel,
+			frame: this.#frame,
+			userTranscript: this.#userTranscript,
+			lines,
+		};
+		return lines;
+	}
+
+	#renderLines(maxWidth: number): readonly string[] {
+		const width = Math.max(2, maxWidth);
+		const innerWidth = width - 2;
+		const border = (content: string): string =>
+			theme.fg("border", "│") + content + (width > 1 ? theme.fg("border", "│") : "");
+		const top = theme.fg("border", `┌${"─".repeat(innerWidth)}${width > 1 ? "┐" : ""}`);
+		const spectrumColor: ThemeColor = this.#phase === "muted" ? "dim" : this.#phase === "error" ? "error" : "success";
+		const spectrum = this.#generateSpectrum(innerWidth, 2);
+		const spectrumRows = spectrum.map(row => border(theme.fg(spectrumColor, row)));
+		const transcript = this.#renderTranscript(this.#userTranscript, innerWidth, border);
+		return [top, ...spectrumRows, transcript, this.#renderFooter(width, innerWidth)];
+	}
+
+	#renderTranscript(transcript: string, innerWidth: number, border: (content: string) => string): string {
+		const content = truncateFromStart(transcript, innerWidth);
+		const padding = " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
+		return border(theme.fg("accent", content) + padding);
+	}
+
+	#renderFooter(width: number, innerWidth: number): string {
+		const spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+		const staticIcons: Record<LivePhase, string> = {
+			connecting: "○",
+			listening: "●",
+			working: "○",
+			speaking: "»",
+			muted: "×",
+			error: "!",
+		};
+		const icon = this.#phase === "working" ? spinners[this.#frame % spinners.length] : staticIcons[this.#phase];
+		const phaseColors: Record<LivePhase, ThemeColor> = {
+			connecting: "dim",
+			listening: "success",
+			working: "warning",
+			speaking: "accent",
+			muted: "dim",
+			error: "error",
+		};
+		const status = `${icon} ${this.#phase}`;
+		const fullLabel = ` ${status} · space mute · esc end `;
+		const shortLabel = ` ${status} `;
+		const label =
+			innerWidth >= visibleWidth(fullLabel) + 1
+				? fullLabel
+				: innerWidth >= visibleWidth(shortLabel) + 1
+					? shortLabel
+					: "";
+		if (!label) {
+			return theme.fg("border", `└${"─".repeat(innerWidth)}${width > 1 ? "┘" : ""}`);
+		}
+		const remaining = Math.max(0, innerWidth - visibleWidth(label) - 1);
+		return (
+			theme.fg("border", "└─") +
+			theme.fg(phaseColors[this.#phase], truncateToWidth(label, innerWidth - 1)) +
+			theme.fg("border", `${"─".repeat(remaining)}${width > 1 ? "┘" : ""}`)
+		);
+	}
+
+	#generateSpectrum(width: number, rows: number): string[] {
+		const blocks = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+		const output = Array.from({ length: rows }, () => "");
+		const energy = this.#phase === "muted" ? 0 : Math.min(1, Math.sqrt(this.#displayLevel * 5));
+		const maxHeight = rows * (blocks.length - 1);
+		for (let column = 0; column < width; column += 1) {
+			const carrier = 0.5 + 0.5 * Math.sin(this.#frame * 0.43 + column * 0.71);
+			const shimmer = 0.5 + 0.5 * Math.sin(this.#frame * 0.19 - column * 1.17);
+			const height = Math.round(energy * (0.3 + carrier * 0.5 + shimmer * 0.2) * maxHeight);
+			for (let row = 0; row < rows; row += 1) {
+				const units = Math.max(0, Math.min(blocks.length - 1, height - (rows - row - 1) * 8));
+				output[row] += blocks[units];
+			}
+		}
+		return output;
+	}
+}

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);
 							}
@@ -1181,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);
@@ -1196,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/index.ts

@@ -29,6 +29,7 @@ import {
 	sendNotification,
 	sendRequest,
 	setIdleTimeout,
+	shutdownClientInstance,
 	supportsDocumentDiagnostics,
 	syncContent,
 	WARMUP_TIMEOUT_MS,
@@ -507,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
@@ -521,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}`;
 	}
 }

package/src/main.ts

@@ -391,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,
 		});
@@ -834,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"]);
+	});
+});

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. */