lazycodex-ai 5.1.47 → 5.1.51

package/packages/lsp-core/src/lsp/client-wrapper.test.ts

@@ -0,0 +1,213 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
+import type { LspClient } from "./client.js";
+import { findWorkspaceRoot, resolveReadablePathInsideContext, withLspClient } from "./client-wrapper.js";
+import { LspInvalidPathError } from "./errors.js";
+import { LspManager } from "./manager.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("LSP workspace root collapse in monorepos", () => {
+	it("#given a git repository containing four package.json packages #when resolving workspace roots for files in each package #then all collapse to the repository root", () => {
+		const root = tempRoot("lsp-client-wrapper-monorepo-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		const packageDirs = ["alpha", "beta", "gamma", "delta"].map((name) => join(root, "packages", name));
+		for (const packageDir of packageDirs) {
+			mkdirSync(join(packageDir, "src"), { recursive: true });
+			writeFileSync(join(packageDir, "package.json"), "{}\n");
+			writeFileSync(join(packageDir, "src", "file.ts"), "export const value = 1;\n");
+		}
+		const context = createStandaloneMcpRequestContext({ cwd: root });
+
+		const roots = packageDirs.map((packageDir) =>
+			runWithRequestContext(context, () => findWorkspaceRoot(join(packageDir, "src", "file.ts"))),
+		);
+
+		expect(new Set(roots).size).toBe(1);
+		expect(roots[0]).toBe(realpathSync(root));
+	});
+
+	it("#given nested package.json markers without any .git #when resolving workspace #then keeps the nearest package root", () => {
+		const root = tempRoot("lsp-client-wrapper-nested-");
+		const nested = join(root, "parent", "nested");
+		mkdirSync(join(nested, "src"), { recursive: true });
+		writeFileSync(join(root, "parent", "package.json"), "{}\n");
+		writeFileSync(join(nested, "package.json"), "{}\n");
+		writeFileSync(join(nested, "src", "file.ts"), "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(join(nested, "src", "file.ts")),
+		);
+
+		expect(workspace).toBe(realpathSync(nested));
+	});
+
+	it("#given four monorepo package files under one .git root #when acquiring clients #then one client serves the whole repository", async () => {
+		const root = tempRoot("lsp-client-wrapper-oneclient-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		const userConfig = join(root, "user-lsp.json");
+		writeFileSync(
+			userConfig,
+			JSON.stringify({ lsp: { monorepoProbe: { command: [process.execPath], extensions: [".monoroot"] } } }),
+		);
+		const filePaths = ["alpha", "beta", "gamma", "delta"].map((name) => {
+			const packageDir = join(root, "packages", name);
+			mkdirSync(join(packageDir, "src"), { recursive: true });
+			writeFileSync(join(packageDir, "package.json"), "{}\n");
+			const filePath = join(packageDir, "src", "probe.monoroot");
+			writeFileSync(filePath, "const value = 1;\n");
+			return filePath;
+		});
+		const factoryRoots: string[] = [];
+		const manager = new LspManager({
+			clientFactory: (workspaceRoot) => {
+				factoryRoots.push(workspaceRoot);
+				return new StubLspClient() as unknown as LspClient;
+			},
+		});
+
+		try {
+			const context = createStandaloneMcpRequestContext({
+			cwd: root,
+			env: { LSP_TOOLS_MCP_USER_CONFIG: userConfig },
+		});
+			await Promise.all(
+				filePaths.map((filePath) =>
+					runWithRequestContext(context, () =>
+						withLspClient(filePath, async () => undefined, "diagnostics", { manager }),
+				),
+			),
+			);
+
+			expect(factoryRoots).toEqual([realpathSync(root)]);
+			expect(manager.clientCount()).toBe(1);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});
+
+class StubLspClient {
+	async start(): Promise<void> {}
+
+	async initialize(): Promise<void> {}
+
+	isAlive(): boolean {
+		return true;
+	}
+
+	command(): string[] {
+		return [process.execPath];
+	}
+
+	async stop(): Promise<void> {}
+}
+
+describe("LSP client path confinement", () => {
+	it("#given a relative file inside context cwd #when resolving workspace #then marker search stays inside cwd", () => {
+		const root = tempRoot("lsp-client-wrapper-root-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		mkdirSync(join(root, "src"), { recursive: true });
+		writeFileSync(join(root, "src", "file.ts"), "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot("src/file.ts"),
+		);
+
+		expect(workspace).toBe(realpathSync(root));
+	});
+
+	it("#given an absolute file outside context cwd #when resolving #then infers the file's own project root", () => {
+		const root = tempRoot("lsp-client-wrapper-cwd-");
+		const outside = tempRoot("lsp-client-wrapper-outside-");
+		mkdirSync(join(outside, ".git"), { recursive: true });
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(join(outside, "file.ts")),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
+	});
+
+	it("#given a symlink inside cwd that points outside #when resolving read path #then keeps lexical path and cwd root", () => {
+		const root = tempRoot("lsp-client-wrapper-symlink-root-");
+		const outside = tempRoot("lsp-client-wrapper-symlink-outside-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		mkdirSync(join(outside, ".git"), { recursive: true });
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+		symlinkSync(outside, join(root, "linked"));
+
+		const result = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () => ({
+			filePath: resolveReadablePathInsideContext("linked/file.ts"),
+			workspaceRoot: findWorkspaceRoot("linked/file.ts"),
+		}));
+
+		expect(result.filePath).toBe(join(realpathSync(root), "linked", "file.ts"));
+		expect(result.workspaceRoot).toBe(realpathSync(root));
+	});
+
+	it("#given an absolute macOS alias path through an outside symlink #when resolving read path #then preserves the lexical suffix", () => {
+		const root = tempRoot("lsp-client-wrapper-alias-root-");
+		const outside = tempRoot("lsp-client-wrapper-alias-outside-");
+		mkdirSync(join(root, ".git"), { recursive: true });
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+		symlinkSync(outside, join(root, "linked"));
+
+		const result = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			resolveReadablePathInsideContext(join(root, "linked", "file.ts")),
+		);
+
+		expect(result).toBe(join(realpathSync(root), "linked", "file.ts"));
+	});
+
+	it("#given missing parent directories without markers #when resolving workspace #then uses an existing directory", () => {
+		const root = tempRoot("lsp-client-wrapper-missing-root-");
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot("missing/deep/file.ts"),
+		);
+
+		expect(workspace).toBe(realpathSync(root));
+	});
+
+	it("#given a symlink inside cwd that points outside #when starting rename #then rejects before client acquisition", async () => {
+		const root = tempRoot("lsp-client-wrapper-rename-root-");
+		const outside = tempRoot("lsp-client-wrapper-rename-outside-");
+		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
+		symlinkSync(outside, join(root, "linked"));
+		let clientFactoryCalls = 0;
+		const manager = new LspManager({
+			clientFactory: () => {
+				clientFactoryCalls += 1;
+				throw new Error("client acquisition must not start");
+			},
+		});
+
+		try {
+			await expect(
+				runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+					withLspClient("linked/file.ts", async () => undefined, "rename", { manager }),
+				),
+			).rejects.toThrow(LspInvalidPathError);
+			expect(clientFactoryCalls).toBe(0);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});

package/packages/lsp-core/src/lsp/client-wrapper.ts

@@ -0,0 +1,290 @@
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import {
+	canonicalizeExistingOrNearestAncestor,
+	contextCwd,
+	isPathInside,
+	lspRequestContext,
+} from "../request-context.js";
+import type { LspClient } from "./client.js";
+import { effectiveExtension } from "./effective-extension.js";
+import {
+	isLspDeadConnectionError,
+	LspInvalidPathError,
+	LspRequestTimeoutError,
+	LspServerInitializingError,
+	LspServerLookupError,
+} from "./errors.js";
+import { getLspManager, type LspManager } from "./manager.js";
+import { findWorkspaceRootOutsideContext } from "./outside-context-workspace.js";
+import { LSP_LOCAL_INSTALL_HINTS } from "./server-definitions.js";
+import { loadInstallDecision } from "./server-install-state.js";
+import { findServerForExtension } from "./server-resolution.js";
+import type { ServerLookupResult } from "./types.js";
+import { GIT_WORKSPACE_MARKER, PROJECT_WORKSPACE_MARKERS } from "./workspace-markers.js";
+
+export function isDirectoryPath(filePath: string): boolean {
+	try {
+		return statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Resolves the workspace root for a file inside the request cwd.
+ *
+ * A `.git`-containing ancestor always wins over nearer package markers, so all packages of a
+ * monorepo share one workspace root (one resident client per repository instead of one per
+ * package, which multiplies language-server processes by the package count). The nearest
+ * package-marked directory is remembered while walking and used only when no `.git` ancestor
+ * exists within the request cwd.
+ */
+export function findWorkspaceRoot(filePath: string): string {
+	const cwd = contextCwd();
+	const abs = resolveReadablePathInsideContext(filePath);
+	let dir = abs;
+
+	if (!isDirectoryPath(dir)) {
+		dir = dirname(dir);
+	}
+
+	if (!isPathInside(cwd, abs)) return findWorkspaceRootOutsideContext(dir);
+
+	const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
+	let nearestPackageRoot: string | undefined;
+	while (isPathInside(cwd, dir)) {
+		const canonicalDir = existingDirectoryInsideContext(dir, cwd);
+		if (canonicalDir !== undefined) {
+			if (existsSync(join(dir, GIT_WORKSPACE_MARKER))) {
+				return canonicalDir;
+			}
+			if (nearestPackageRoot === undefined && hasProjectWorkspaceMarker(dir)) {
+				nearestPackageRoot = canonicalDir;
+			}
+		}
+		if (dir === cwd) break;
+		dir = dirname(dir);
+	}
+
+	return nearestPackageRoot ?? fallbackRoot;
+}
+
+function hasProjectWorkspaceMarker(directory: string): boolean {
+	return PROJECT_WORKSPACE_MARKERS.some((marker) => existsSync(join(directory, marker)));
+}
+
+export function resolveReadablePathInsideContext(filePath: string): string {
+	const cwd = contextCwd();
+	const abs = resolve(cwd, filePath);
+	if (isPathInside(cwd, abs)) return abs;
+
+	const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
+	if (rebased !== undefined) return rebased;
+
+	return canonicalizeExistingOrNearestAncestor(abs);
+}
+
+export function resolvePathInsideContext(filePath: string): string {
+	const cwd = contextCwd();
+	const abs = resolveReadablePathInsideContext(filePath);
+	const canonical = canonicalizeExistingOrNearestAncestor(abs);
+	if (!isPathInside(cwd, canonical)) {
+		throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+	}
+	return canonical;
+}
+
+function rebaseThroughCanonicalAncestor(path: string, cwd: string): string | undefined {
+	let current = path;
+	const suffix: string[] = [];
+	while (true) {
+		if (existsSync(current)) {
+			const canonical = realpathSync(current);
+			if (isPathInside(cwd, canonical)) return suffix.length === 0 ? canonical : join(canonical, ...suffix);
+		}
+		const parent = dirname(current);
+		if (parent === current) return undefined;
+		suffix.unshift(basename(current));
+		current = parent;
+	}
+}
+
+function existingDirectoryInsideContext(directory: string, cwd: string): string | undefined {
+	if (!existsSync(directory)) return undefined;
+	const canonical = realpathSync(directory);
+	if (!statSync(canonical).isDirectory()) return undefined;
+	return isPathInside(cwd, canonical) ? canonical : undefined;
+}
+
+function nearestExistingDirectoryInsideContext(directory: string, cwd: string): string | undefined {
+	let current = directory;
+	while (isPathInside(cwd, current)) {
+		const canonical = existingDirectoryInsideContext(current, cwd);
+		if (canonical !== undefined) return canonical;
+		if (current === cwd) return undefined;
+		current = dirname(current);
+	}
+	return undefined;
+}
+
+export function formatServerLookupError(result: Exclude<ServerLookupResult, { status: "found" }>): string {
+	if (result.status === "not_installed") {
+		return formatNotInstalled(result);
+	}
+	const context = lspRequestContext();
+	const firstProjectConfigPath = context.projectConfigPaths[0] ?? "<project lsp config>";
+
+	return [
+		`No LSP server configured for extension: ${result.extension}`,
+		"",
+		`Available servers: ${result.availableServers.slice(0, 10).join(", ")}${
+			result.availableServers.length > 10 ? "..." : ""
+		}`,
+		"",
+		`Configure a custom server in '${firstProjectConfigPath}' or '${context.userConfigPath}':`,
+		"  {",
+		'    "lsp": {',
+		'      "my-server": {',
+		'        "command": ["my-lsp", "--stdio"],',
+		`        "extensions": ["${result.extension}"]`,
+		"      }",
+		"    }",
+		"  }",
+	].join("\n");
+}
+
+/**
+ * Builds the install guidance, offering the repo-local install first.
+ *
+ * A repo-local install is resolvable without touching the global environment, so it is the
+ * recommended route whenever the server ships as a project dependency.
+ */
+function formatInstallOptions(serverId: string, installHint: string): string[] {
+	const localHint = LSP_LOCAL_INSTALL_HINTS[serverId];
+	if (localHint === undefined) {
+		return ["To install, run:", `  ${installHint}`];
+	}
+	return [
+		"To install in THIS repository (preferred, no global install needed):",
+		`  ${localHint}`,
+		"",
+		"Or install it globally:",
+		`  ${installHint}`,
+	];
+}
+
+function formatNotInstalled(result: Extract<ServerLookupResult, { status: "not_installed" }>): string {
+	const { server, installHint } = result;
+	const extensions = server.extensions.join(", ");
+	const decision = loadInstallDecision(server.id)?.decision;
+	const context = lspRequestContext();
+
+	if (decision === "declined") {
+		return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation: proceed without LSP.`;
+	}
+
+	const header = [
+		`LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
+		"",
+		`Command not found: ${server.command[0]}`,
+		"",
+	];
+	const installOptions = formatInstallOptions(server.id, installHint);
+
+	if (decision === "allowed") {
+		return [
+			...header,
+			"The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
+			...installOptions.slice(1),
+		].join("\n");
+	}
+
+	if (!context.capabilities.installDecisionTool) {
+		return [
+			...header,
+			...installOptions,
+			"",
+			"ACTION REQUIRED: ASK THE USER whether to install this LSP server.",
+			"Install-decision recording is unavailable in this harness; proceed without LSP if the user declines.",
+		].join("\n");
+	}
+
+	return [
+		...header,
+		...installOptions,
+		"",
+		"ACTION REQUIRED: ASK THE USER whether to install this LSP server.",
+		"- If the user agrees: run the install command above, then retry this tool.",
+		"- If the user declines, OR has NOT explicitly asked for LSP installation:",
+		`    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
+		`    which writes to ${context.installDecisionsPath},`,
+		"    then ignore this message and proceed WITHOUT LSP.",
+	].join("\n");
+}
+
+export interface WithLspClientOptions {
+	signal?: AbortSignal;
+	manager?: LspManager;
+}
+
+const READ_ONLY_TOOLS = new Set([
+	"diagnostics",
+	"definition",
+	"references",
+	"documentSymbols",
+	"workspaceSymbols",
+	"prepareRename",
+]);
+
+export async function withLspClient<T>(
+	filePath: string,
+	fn: (client: LspClient, workspaceRoot: string, resolvedFilePath: string) => Promise<T>,
+	toolName: string,
+	options: WithLspClientOptions = {},
+): Promise<T> {
+	const absPath = READ_ONLY_TOOLS.has(toolName)
+		? resolveReadablePathInsideContext(filePath)
+		: resolvePathInsideContext(filePath);
+
+	if (isDirectoryPath(absPath)) {
+		throw new LspInvalidPathError(
+			"Directory paths are not supported by this LSP tool. " +
+				"Use lsp.diagnostics with a directory path for directory diagnostics.",
+		);
+	}
+
+	const ext = effectiveExtension(absPath);
+	const result = findServerForExtension(ext);
+	if (result.status !== "found") {
+		throw new LspServerLookupError(formatServerLookupError(result), result);
+	}
+
+	const server = result.server;
+	const root = findWorkspaceRoot(absPath);
+	const manager = options.manager ?? getLspManager();
+
+	const acquireAndCall = async (allowRetry: boolean): Promise<T> => {
+		const client = await manager.getClient(root, server, options.signal);
+
+		try {
+			return await fn(client, root, absPath);
+		} catch (err) {
+			if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
+				manager.invalidateClient(root, server.id, client);
+				return acquireAndCall(false);
+			}
+
+			if (err instanceof LspRequestTimeoutError) {
+				if (manager.isServerInitializing(root, server.id)) {
+					throw new LspServerInitializingError(err);
+				}
+			}
+			throw err;
+		} finally {
+			manager.releaseClient(root, server.id);
+		}
+	};
+
+	return acquireAndCall(true);
+}