@oh-my-pi/pi-coding-agent 1.340.0 → 2.0.1337

package/src/core/tools/lsp/client.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { applyWorkspaceEdit } from "./edits.js";
+import { applyWorkspaceEdit } from "./edits";
 import type {
 	Diagnostic,
 	LspClient,
@@ -8,29 +8,43 @@ import type {
 	LspJsonRpcResponse,
 	ServerConfig,
 	WorkspaceEdit,
-} from "./types.js";
-import { detectLanguageId, fileToUri } from "./utils.js";
+} from "./types";
+import { detectLanguageId, fileToUri } from "./utils";
 
 // =============================================================================
 // Client State
 // =============================================================================
 
 const clients = new Map<string, LspClient>();
+const clientLocks = new Map<string, Promise<LspClient>>();
+const fileOperationLocks = new Map<string, Promise<void>>();
 
-// Idle timeout: shutdown clients after 5 minutes of inactivity
-const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+// Idle timeout configuration (disabled by default)
+let idleTimeoutMs: number | null = null;
+let idleCheckInterval: Timer | null = null;
 const IDLE_CHECK_INTERVAL_MS = 60 * 1000;
 
-// Background task to shutdown idle clients
-let idleCheckInterval: Timer | null = null;
+/**
+ * Configure the idle timeout for LSP clients.
+ * @param ms - Timeout in milliseconds, or null/undefined to disable
+ */
+export function setIdleTimeout(ms: number | null | undefined): void {
+	idleTimeoutMs = ms ?? null;
+
+	if (idleTimeoutMs && idleTimeoutMs > 0) {
+		startIdleChecker();
+	} else {
+		stopIdleChecker();
+	}
+}
 
 function startIdleChecker(): void {
 	if (idleCheckInterval) return;
 	idleCheckInterval = setInterval(() => {
+		if (!idleTimeoutMs) return;
 		const now = Date.now();
 		for (const [key, client] of Array.from(clients.entries())) {
-			if (now - client.lastActivity > IDLE_TIMEOUT_MS) {
-				console.log(`[LSP] Shutting down idle client: ${key}`);
+			if (now - client.lastActivity > idleTimeoutMs) {
 				shutdownClient(key);
 			}
 		}
@@ -98,6 +112,12 @@ const CLIENT_CAPABILITIES = {
 				properties: ["edit"],
 			},
 		},
+		formatting: {
+			dynamicRegistration: false,
+		},
+		rangeFormatting: {
+			dynamicRegistration: false,
+		},
 		publishDiagnostics: {
 			relatedInformation: true,
 			versionSupport: false,
@@ -215,13 +235,17 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			const { done, value } = await reader.read();
 			if (done) break;
 
-			client.messageBuffer = concatBuffers(client.messageBuffer, value);
+			// Atomically update buffer before processing
+			const currentBuffer = concatBuffers(client.messageBuffer, value);
+			client.messageBuffer = currentBuffer;
 
 			// Process all complete messages in buffer
-			let parsed = parseMessage(client.messageBuffer);
+			// Use local variable to avoid race with concurrent buffer updates
+			let workingBuffer = currentBuffer;
+			let parsed = parseMessage(workingBuffer);
 			while (parsed) {
 				const { message, remaining } = parsed;
-				client.messageBuffer = remaining;
+				workingBuffer = remaining;
 
 				// Route message
 				if ("id" in message && message.id !== undefined) {
@@ -245,8 +269,11 @@ async function startMessageReader(client: LspClient): Promise<void> {
 					}
 				}
 
-				parsed = parseMessage(client.messageBuffer);
+				parsed = parseMessage(workingBuffer);
 			}
+
+			// Atomically commit processed buffer
+			client.messageBuffer = workingBuffer;
 		}
 	} catch (err) {
 		// Connection closed or error - reject all pending requests
@@ -350,77 +377,88 @@ async function sendResponse(
 export async function getOrCreateClient(config: ServerConfig, cwd: string): Promise<LspClient> {
 	const key = `${config.command}:${cwd}`;
 
-	if (clients.has(key)) {
-		const client = clients.get(key)!;
-		client.lastActivity = Date.now();
-		return client;
+	// Check if client already exists
+	const existingClient = clients.get(key);
+	if (existingClient) {
+		existingClient.lastActivity = Date.now();
+		return existingClient;
 	}
 
-	const args = config.args ?? [];
-	const proc = Bun.spawn([config.command, ...args], {
-		cwd,
-		stdin: "pipe",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-
-	const client: LspClient = {
-		name: key,
-		cwd,
-		process: proc,
-		config,
-		requestId: 0,
-		diagnostics: new Map(),
-		openFiles: new Map(),
-		pendingRequests: new Map(),
-		messageBuffer: new Uint8Array(0),
-		isReading: false,
-		lastActivity: Date.now(),
-	};
-	clients.set(key, client);
+	// Check if another coroutine is already creating this client
+	const existingLock = clientLocks.get(key);
+	if (existingLock) {
+		return existingLock;
+	}
 
-	// Start idle checker if not already running
-	startIdleChecker();
+	// Create new client with lock
+	const clientPromise = (async () => {
+		const args = config.args ?? [];
+		const command = config.resolvedCommand ?? config.command;
+		const proc = Bun.spawn([command, ...args], {
+			cwd,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
 
-	// Register crash recovery - remove client on process exit
-	proc.exited.then(() => {
-		console.log(`[LSP] Process exited: ${key}`);
-		clients.delete(key);
-		if (clients.size === 0) {
-			stopIdleChecker();
-		}
-	});
+		const client: LspClient = {
+			name: key,
+			cwd,
+			process: proc,
+			config,
+			requestId: 0,
+			diagnostics: new Map(),
+			openFiles: new Map(),
+			pendingRequests: new Map(),
+			messageBuffer: new Uint8Array(0),
+			isReading: false,
+			lastActivity: Date.now(),
+		};
+		clients.set(key, client);
+
+		// Register crash recovery - remove client on process exit
+		proc.exited.then(() => {
+			clients.delete(key);
+			clientLocks.delete(key);
+		});
 
-	// Start background message reader
-	startMessageReader(client);
+		// Start background message reader
+		startMessageReader(client);
+
+		try {
+			// Send initialize request
+			const initResult = (await sendRequest(client, "initialize", {
+				processId: process.pid,
+				rootUri: fileToUri(cwd),
+				rootPath: cwd,
+				capabilities: CLIENT_CAPABILITIES,
+				initializationOptions: config.initOptions ?? {},
+				workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
+			})) as { capabilities?: unknown };
+
+			if (!initResult) {
+				throw new Error("Failed to initialize LSP: no response");
+			}
 
-	try {
-		// Send initialize request
-		const initResult = (await sendRequest(client, "initialize", {
-			processId: process.pid,
-			rootUri: fileToUri(cwd),
-			rootPath: cwd,
-			capabilities: CLIENT_CAPABILITIES,
-			initializationOptions: config.initOptions ?? {},
-			workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
-		})) as { capabilities?: unknown };
-
-		if (!initResult) {
-			throw new Error("Failed to initialize LSP: no response");
-		}
+			client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
 
-		client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
+			// Send initialized notification
+			await sendNotification(client, "initialized", {});
 
-		// Send initialized notification
-		await sendNotification(client, "initialized", {});
+			return client;
+		} catch (err) {
+			// Clean up on initialization failure
+			clients.delete(key);
+			clientLocks.delete(key);
+			proc.kill();
+			throw err;
+		} finally {
+			clientLocks.delete(key);
+		}
+	})();
 
-		return client;
-	} catch (err) {
-		// Clean up on initialization failure
-		clients.delete(key);
-		proc.kill();
-		throw err;
-	}
+	clientLocks.set(key, clientPromise);
+	return clientPromise;
 }
 
 /**
@@ -429,24 +467,49 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
  */
 export async function ensureFileOpen(client: LspClient, filePath: string): Promise<void> {
 	const uri = fileToUri(filePath);
+	const lockKey = `${client.name}:${uri}`;
+
+	// Check if file is already open
 	if (client.openFiles.has(uri)) {
 		return;
 	}
 
-	const content = fs.readFileSync(filePath, "utf-8");
-	const languageId = detectLanguageId(filePath);
+	// Check if another operation is already opening this file
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
+		return;
+	}
 
-	await sendNotification(client, "textDocument/didOpen", {
-		textDocument: {
-			uri,
-			languageId,
-			version: 1,
-			text: content,
-		},
-	});
+	// Lock and open file
+	const openPromise = (async () => {
+		// Double-check after acquiring lock
+		if (client.openFiles.has(uri)) {
+			return;
+		}
 
-	client.openFiles.set(uri, { version: 1, languageId });
-	client.lastActivity = Date.now();
+		const content = fs.readFileSync(filePath, "utf-8");
+		const languageId = detectLanguageId(filePath);
+
+		await sendNotification(client, "textDocument/didOpen", {
+			textDocument: {
+				uri,
+				languageId,
+				version: 1,
+				text: content,
+			},
+		});
+
+		client.openFiles.set(uri, { version: 1, languageId });
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, openPromise);
+	try {
+		await openPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
 }
 
 /**
@@ -455,27 +518,45 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
  */
 export async function refreshFile(client: LspClient, filePath: string): Promise<void> {
 	const uri = fileToUri(filePath);
-	const info = client.openFiles.get(uri);
+	const lockKey = `${client.name}:${uri}`;
 
-	if (!info) {
-		await ensureFileOpen(client, filePath);
-		return;
+	// Check if another operation is in progress
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
 	}
 
-	const content = fs.readFileSync(filePath, "utf-8");
-	info.version++;
+	// Lock and refresh file
+	const refreshPromise = (async () => {
+		const info = client.openFiles.get(uri);
 
-	await sendNotification(client, "textDocument/didChange", {
-		textDocument: { uri, version: info.version },
-		contentChanges: [{ text: content }],
-	});
+		if (!info) {
+			await ensureFileOpen(client, filePath);
+			return;
+		}
 
-	await sendNotification(client, "textDocument/didSave", {
-		textDocument: { uri },
-		text: content,
-	});
+		const content = fs.readFileSync(filePath, "utf-8");
+		const version = ++info.version;
 
-	client.lastActivity = Date.now();
+		await sendNotification(client, "textDocument/didChange", {
+			textDocument: { uri, version },
+			contentChanges: [{ text: content }],
+		});
+
+		await sendNotification(client, "textDocument/didSave", {
+			textDocument: { uri },
+			text: content,
+		});
+
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, refreshPromise);
+	try {
+		await refreshPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
 }
 
 /**
@@ -497,10 +578,6 @@ export function shutdownClient(key: string): void {
 	// Kill process
 	client.process.kill();
 	clients.delete(key);
-
-	if (clients.size === 0) {
-		stopIdleChecker();
-	}
 }
 
 // =============================================================================
@@ -511,7 +588,9 @@ export function shutdownClient(key: string): void {
  * Send an LSP request and wait for response.
  */
 export async function sendRequest(client: LspClient, method: string, params: unknown): Promise<unknown> {
+	// Atomically increment and capture request ID
 	const id = ++client.requestId;
+
 	const request: LspJsonRpcRequest = {
 		jsonrpc: "2.0",
 		id,
@@ -570,8 +649,6 @@ export async function sendNotification(client: LspClient, method: string, params
  * Shutdown all LSP clients.
  */
 export function shutdownAll(): void {
-	stopIdleChecker();
-
 	for (const client of Array.from(clients.values())) {
 		// Reject all pending requests
 		for (const pending of Array.from(client.pendingRequests.values())) {
@@ -587,6 +664,25 @@ export function shutdownAll(): void {
 	clients.clear();
 }
 
+/** Status of an LSP server */
+export interface LspServerStatus {
+	name: string;
+	status: "connecting" | "ready" | "error";
+	fileTypes: string[];
+	error?: string;
+}
+
+/**
+ * Get status of all active LSP clients.
+ */
+export function getActiveClients(): LspServerStatus[] {
+	return Array.from(clients.values()).map((client) => ({
+		name: client.config.command,
+		status: "ready" as const,
+		fileTypes: client.config.fileTypes,
+	}));
+}
+
 // =============================================================================
 // Process Cleanup
 // =============================================================================