lazycodex-ai 5.1.47 → 5.1.51

package/packages/lsp-core/src/request-context.test.ts

@@ -0,0 +1,200 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createStandaloneMcpRequestContext,
+	LspRequestContextUnavailableError,
+	LspRequestContextParseError,
+	parseLspRequestContext,
+	runWithRequestContext,
+	lspRequestContext,
+} from "./request-context.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(homedir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+function tempSystemRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("LspRequestContext", () => {
+	it("#given exact typed context #when parsed #then canonicalizes cwd and preserves typed paths", () => {
+		const root = tempRoot("lsp-context-root-");
+		const projectPath = join(root, ".codex", "lsp-client.json");
+		const userPath = join(homedir(), ".codex", "lsp-client.json");
+		const decisionsPath = join(homedir(), ".codex", "lsp-install-decisions.json");
+		mkdirSync(join(root, ".codex"), { recursive: true });
+
+		const context = parseLspRequestContext({
+			cwd: join(root, "."),
+			projectConfigPaths: [projectPath],
+			userConfigPath: userPath,
+			installDecisionsPath: decisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+
+		expect(context).toEqual({
+			cwd: root,
+			projectConfigPaths: [projectPath],
+			userConfigPath: userPath,
+			installDecisionsPath: decisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+		expect(runWithRequestContext(context, () => lspRequestContext())).toEqual(context);
+	});
+
+	it("#given no active context #when requested #then throws an actionable typed error", () => {
+		expect(() => lspRequestContext()).toThrow(LspRequestContextUnavailableError);
+	});
+
+	it("#given unknown field #when parsed #then rejects before lookup", () => {
+		const root = tempRoot("lsp-context-unknown-");
+		const projectPath = join(root, ".codex", "lsp-client.json");
+
+		expect(() =>
+			parseLspRequestContext({
+				cwd: root,
+				projectConfigPaths: [projectPath],
+				userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+				installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: true },
+				env: {},
+			}),
+		).toThrow(LspRequestContextParseError);
+	});
+
+	it("#given project path outside cwd #when parsed #then rejects before config loading", () => {
+		const root = tempRoot("lsp-context-confined-");
+		const outside = tempRoot("lsp-context-outside-");
+
+		expect(() =>
+			parseLspRequestContext({
+				cwd: root,
+				projectConfigPaths: [join(outside, "lsp-client.json")],
+				userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+				installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: true },
+			}),
+		).toThrow(LspRequestContextParseError);
+	});
+
+	it("#given equivalent macOS var spelling #when parsed #then canonicalizes to one identity", () => {
+		const systemRoot = tempSystemRoot("lsp-context-private-var-");
+		const canonicalRoot = realpathSync(systemRoot);
+		const aliasRoot = canonicalRoot.startsWith("/private/var/") ? canonicalRoot.replace("/private/var/", "/var/") : systemRoot;
+		mkdirSync(join(canonicalRoot, ".codex"), { recursive: true });
+
+		const context = parseLspRequestContext({
+			cwd: aliasRoot,
+			projectConfigPaths: [join(aliasRoot, ".codex", "lsp-client.json")],
+			userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+			installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+			capabilities: { installDecisionTool: true },
+		});
+
+		expect(context.cwd).toBe(canonicalRoot);
+		expect(context.projectConfigPaths).toEqual([join(canonicalRoot, ".codex", "lsp-client.json")]);
+	});
+
+	it("#given missing standard project config inside cwd #when parsed #then accepts and preserves the intended suffix", () => {
+		const root = tempRoot("lsp-context-missing-config-");
+		mkdirSync(join(root, ".codex"), { recursive: true });
+
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [join(root, ".codex", "missing-lsp-client.json")],
+			userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+			installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+			capabilities: { installDecisionTool: true },
+		});
+
+		expect(context.projectConfigPaths).toEqual([join(root, ".codex", "missing-lsp-client.json")]);
+	});
+
+	it("#given symlink project config escaping cwd #when parsed #then rejects the escape", () => {
+		const root = tempRoot("lsp-context-symlink-root-");
+		const outside = tempRoot("lsp-context-symlink-outside-");
+		const outsideConfig = join(outside, "lsp-client.json");
+		writeFileSync(outsideConfig, "{}");
+		const linkedConfig = join(root, "linked-lsp-client.json");
+		symlinkSync(outsideConfig, linkedConfig);
+
+		expect(() =>
+			parseLspRequestContext({
+				cwd: root,
+				projectConfigPaths: [linkedConfig],
+				userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+				installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: true },
+			}),
+		).toThrow(LspRequestContextParseError);
+	});
+
+	it("#given standalone MCP env #when translated #then resolves exact defaults and relative paths", () => {
+		const root = tempRoot("lsp-context-standalone-");
+		const home = tempRoot("lsp-context-home-");
+		const absoluteProjectPath = join(root, ".omo", "lsp-client.json");
+
+		const context = createStandaloneMcpRequestContext({
+			cwd: root,
+			homeDir: home,
+			env: {
+				LSP_TOOLS_MCP_PROJECT_CONFIG: ["relative.json", "", absoluteProjectPath].join(delimiter),
+				LSP_TOOLS_MCP_USER_CONFIG: "user-lsp.json",
+				LSP_TOOLS_MCP_INSTALL_DECISIONS: "decisions.json",
+			},
+		});
+
+		expect(context).toEqual({
+			cwd: root,
+			projectConfigPaths: [join(root, "relative.json"), absoluteProjectPath],
+			userConfigPath: join(home, "user-lsp.json"),
+			installDecisionsPath: join(home, "decisions.json"),
+			capabilities: { installDecisionTool: true },
+		});
+	});
+
+	it("#given an injected LSP cwd #when standalone context is created #then it wins over process cwd without reading global env", () => {
+		const sessionRoot = tempRoot("lsp-context-session-");
+		const processRoot = tempRoot("lsp-context-process-");
+		const home = tempRoot("lsp-context-env-home-");
+
+		const context = createStandaloneMcpRequestContext({
+			env: {
+				LSP_TOOLS_MCP_CWD: sessionRoot,
+			},
+			homeDir: home,
+		});
+
+		expect(context.cwd).toBe(sessionRoot);
+		expect(context.projectConfigPaths).toEqual([join(sessionRoot, ".codex", "lsp-client.json")]);
+		expect(processRoot).not.toBe(context.cwd);
+	});
+
+	it("#given explicit cwd and an injected LSP cwd #when standalone context is created #then explicit cwd wins", () => {
+		const explicitRoot = tempRoot("lsp-context-explicit-");
+		const injectedRoot = tempRoot("lsp-context-injected-");
+
+		const context = createStandaloneMcpRequestContext({
+			cwd: explicitRoot,
+			env: { LSP_TOOLS_MCP_CWD: injectedRoot },
+		});
+
+		expect(context.cwd).toBe(explicitRoot);
+	});
+});

package/packages/lsp-core/src/request-context.ts

@@ -0,0 +1,235 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+export interface LspRequestContext {
+	readonly cwd: string;
+	readonly projectConfigPaths: readonly string[];
+	readonly userConfigPath: string;
+	readonly installDecisionsPath: string;
+	readonly capabilities: {
+		readonly installDecisionTool: boolean;
+	};
+}
+
+export type RequestContext = LspRequestContext;
+
+export interface StandaloneMcpRequestContextInput {
+	readonly cwd?: string;
+	readonly env?: Record<string, string | undefined>;
+	readonly homeDir?: string;
+}
+
+export class LspRequestContextParseError extends Error {
+	override readonly name = "LspRequestContextParseError";
+
+	constructor(
+		readonly code: string,
+		message: string,
+	) {
+		super(message);
+	}
+}
+
+export class LspRequestContextUnavailableError extends Error {
+	override readonly name = "LspRequestContextUnavailableError";
+
+	constructor() {
+		super(
+			"LSP request context is required. Standalone MCP startup must install one with runWithRequestContext(createStandaloneMcpRequestContext()).",
+		);
+	}
+}
+
+const storage = new AsyncLocalStorage<LspRequestContext>();
+const CONTEXT_FIELDS = new Set(["cwd", "projectConfigPaths", "userConfigPath", "installDecisionsPath", "capabilities"]);
+const CAPABILITY_FIELDS = new Set(["installDecisionTool"]);
+
+export function runWithRequestContext<T>(context: LspRequestContext, fn: () => T): T {
+	return storage.run(context, fn);
+}
+
+export function lspRequestContext(): LspRequestContext {
+	const context = storage.getStore();
+	if (!context) throw new LspRequestContextUnavailableError();
+	return context;
+}
+
+export function contextCwd(): string {
+	return lspRequestContext().cwd;
+}
+
+export function contextEnv(key: string): string | undefined {
+	const context = lspRequestContext();
+	if (key === "LSP_TOOLS_MCP_PROJECT_CONFIG") return context.projectConfigPaths.join(delimiter);
+	if (key === "LSP_TOOLS_MCP_USER_CONFIG") return context.userConfigPath;
+	if (key === "LSP_TOOLS_MCP_INSTALL_DECISIONS") return context.installDecisionsPath;
+	return undefined;
+}
+
+export function createStandaloneMcpRequestContext(
+	input: StandaloneMcpRequestContextInput = {},
+): LspRequestContext {
+	const env = input.env ?? process.env;
+	const cwd = canonicalCwd(input.cwd ?? env["LSP_TOOLS_MCP_CWD"] ?? process.cwd());
+	const home = input.homeDir ?? homedir();
+	const projectConfigPaths = translateProjectConfigEnv(env["LSP_TOOLS_MCP_PROJECT_CONFIG"], cwd);
+	const userConfigPath = translateHomeConfigEnv(env["LSP_TOOLS_MCP_USER_CONFIG"], home, ".codex/lsp-client.json");
+	const installDecisionsPath = translateHomeConfigEnv(
+		env["LSP_TOOLS_MCP_INSTALL_DECISIONS"],
+		home,
+		".codex/lsp-install-decisions.json",
+	);
+	return parseLspRequestContext({
+		cwd,
+		projectConfigPaths,
+		userConfigPath,
+		installDecisionsPath,
+		capabilities: { installDecisionTool: true },
+	});
+}
+
+export function parseLspRequestContext(value: unknown): LspRequestContext {
+	if (!isRecord(value)) {
+		throw new LspRequestContextParseError("invalid_context", "LSP request context must be an object.");
+	}
+	rejectUnknownFields(value, CONTEXT_FIELDS, "context");
+
+	const cwd = stringField(value, "cwd");
+	const projectConfigPaths = stringArrayField(value, "projectConfigPaths");
+	const userConfigPath = stringField(value, "userConfigPath");
+	const installDecisionsPath = stringField(value, "installDecisionsPath");
+	const capabilities = capabilitiesField(value["capabilities"]);
+	const canonical = canonicalCwd(cwd);
+
+	for (const path of projectConfigPaths) {
+		requireAbsolutePath(path, "projectConfigPaths");
+		const projectPath = canonicalizeExistingOrNearestAncestor(path);
+		if (!isPathInside(canonical, projectPath)) {
+			throw new LspRequestContextParseError(
+				"project_config_outside_cwd",
+				`Project LSP config path must be inside cwd: ${path}`,
+			);
+		}
+	}
+	requireAbsolutePath(userConfigPath, "userConfigPath");
+	requireAbsolutePath(installDecisionsPath, "installDecisionsPath");
+
+	return {
+		cwd: canonical,
+		projectConfigPaths: projectConfigPaths.map((path) => canonicalizeExistingOrNearestAncestor(path)),
+		userConfigPath,
+		installDecisionsPath,
+		capabilities,
+	};
+}
+
+function translateProjectConfigEnv(value: string | undefined, cwd: string): readonly string[] {
+	if (value === undefined || value.length === 0) return [join(cwd, ".codex", "lsp-client.json")];
+	return value
+		.split(delimiter)
+		.filter((entry) => entry.length > 0)
+		.map((entry) => (isAbsolute(entry) ? entry : join(cwd, entry)));
+}
+
+function translateHomeConfigEnv(value: string | undefined, home: string, fallback: string): string {
+	if (value === undefined || value.length === 0) return join(home, fallback);
+	return isAbsolute(value) ? value : join(home, value);
+}
+
+function canonicalCwd(cwd: string): string {
+	const resolved = resolve(cwd);
+	if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+		throw new LspRequestContextParseError("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
+	}
+	return realpathSync(resolved);
+}
+
+export function canonicalizeExistingOrNearestAncestor(path: string): string {
+	let current = resolve(path);
+	const suffix: string[] = [];
+	while (true) {
+		try {
+			const existing = realpathSync(current);
+			return suffix.length === 0 ? existing : join(existing, ...suffix);
+		} catch (error) {
+			if (!isMissingPathError(error)) throw error;
+			const parent = dirname(current);
+			if (parent === current) throw error;
+			suffix.unshift(basename(current));
+			current = parent;
+		}
+	}
+}
+
+function capabilitiesField(value: unknown): LspRequestContext["capabilities"] {
+	if (!isRecord(value)) {
+		throw new LspRequestContextParseError("invalid_capabilities", "LSP request capabilities must be an object.");
+	}
+	rejectUnknownFields(value, CAPABILITY_FIELDS, "capabilities");
+	const installDecisionTool = value["installDecisionTool"];
+	if (typeof installDecisionTool !== "boolean") {
+		throw new LspRequestContextParseError(
+			"invalid_install_decision_capability",
+			"LSP request capabilities.installDecisionTool must be a boolean.",
+		);
+	}
+	return { installDecisionTool };
+}
+
+function stringField(value: Record<string, unknown>, field: string): string {
+	const fieldValue = value[field];
+	if (typeof fieldValue !== "string" || fieldValue.length === 0) {
+		throw new LspRequestContextParseError("invalid_field", `LSP request context.${field} must be a non-empty string.`);
+	}
+	return fieldValue;
+}
+
+function stringArrayField(value: Record<string, unknown>, field: string): readonly string[] {
+	const fieldValue = value[field];
+	if (!Array.isArray(fieldValue) || !fieldValue.every((item) => typeof item === "string" && item.length > 0)) {
+		throw new LspRequestContextParseError(
+			"invalid_field",
+			`LSP request context.${field} must be a non-empty string array.`,
+		);
+	}
+	return fieldValue;
+}
+
+function requireAbsolutePath(path: string, field: string): void {
+	if (!isAbsolute(path)) {
+		throw new LspRequestContextParseError("relative_path", `LSP request context.${field} must be absolute: ${path}`);
+	}
+}
+
+export function isPathInside(parent: string, child: string): boolean {
+	const childPath = resolve(child);
+	const relativePath = relative(parent, childPath);
+	return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+
+function isMissingPathError(error: unknown): boolean {
+	const code = errorCode(error);
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+
+function rejectUnknownFields(value: Record<string, unknown>, allowed: ReadonlySet<string>, scope: string): void {
+	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+	if (unknown.length > 0) {
+		throw new LspRequestContextParseError(
+			"unknown_field",
+			`Unknown LSP request ${scope} field: ${unknown.join(", ")}`,
+		);
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function errorCode(error: unknown): string | undefined {
+	if (!error || typeof error !== "object" || !("code" in error)) return undefined;
+	const code = Reflect.get(error, "code");
+	return typeof code === "string" ? code : undefined;
+}

package/packages/lsp-core/src/tool-surface.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from "bun:test";
+
+import { handleLspMcpRequest } from "./mcp.js";
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "./request-context.js";
+import { coerceToolArguments, executeLspTool } from "./tools.js";
+
+const expectedToolSurface = [
+	{
+		name: "status",
+		title: "LSP Status",
+		description: "List configured and active LSP servers without starting a new language server.",
+		inputSchema: { type: "object", properties: {}, required: [] },
+	},
+	{
+		name: "diagnostics",
+		title: "LSP Diagnostics",
+		description:
+			"Get errors, warnings, and hints for a source file or directory. In a Bun project, a TypeScript directory is typechecked with `bun check`, plus `bun lint` when the installed Bun has it.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "File or directory path to check." },
+				severity: {
+					type: "string",
+					enum: ["error", "warning", "information", "hint", "all"],
+					description: "Severity filter. Defaults to all.",
+				},
+			},
+			required: ["filePath"],
+		},
+	},
+	{
+		name: "goto_definition",
+		title: "LSP Goto Definition",
+		description: "Find where a symbol is defined.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "Source file containing the symbol." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+			},
+			required: ["filePath", "line", "character"],
+		},
+	},
+	{
+		name: "find_references",
+		title: "LSP Find References",
+		description: "Find references of a symbol across the workspace.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "Source file containing the symbol." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+				includeDeclaration: { type: "boolean", description: "Include the declaration. Defaults to true." },
+			},
+			required: ["filePath", "line", "character"],
+		},
+	},
+	{
+		name: "symbols",
+		title: "LSP Symbols",
+		description: "List document symbols or search workspace symbols.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "File path used as LSP context." },
+				scope: {
+					type: "string",
+					enum: ["document", "workspace"],
+					description: "Use document for file outline or workspace for project-wide search.",
+				},
+				query: { type: "string", description: "Workspace symbol query." },
+				limit: { type: "number", description: "Maximum number of symbols to return." },
+			},
+			required: ["filePath", "scope"],
+		},
+	},
+	{
+		name: "prepare_rename",
+		title: "LSP Prepare Rename",
+		description: "Check whether a symbol can be renamed at a position.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "Source file path." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+			},
+			required: ["filePath", "line", "character"],
+		},
+	},
+	{
+		name: "rename",
+		title: "LSP Rename",
+		description: "Rename a symbol across the workspace and apply the returned workspace edit.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "Source file path." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+				newName: { type: "string", description: "New symbol name." },
+			},
+			required: ["filePath", "line", "character", "newName"],
+		},
+	},
+	{
+		name: "format",
+		title: "LSP Format",
+		description: "Format a source file with its language server and write the returned edits to disk.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "Source file path to format." },
+			},
+			required: ["filePath"],
+		},
+	},
+	{
+		name: "install_decision",
+		title: "LSP Install Decision",
+		description:
+			"Record whether the user allowed or declined installing a missing LSP server. Record 'declined' when the user declines, or has not explicitly asked for LSP installation, to silence future prompts.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				server_id: {
+					type: "string",
+					description: "The LSP server id from the not-installed message (e.g. 'rust').",
+				},
+				decision: {
+					type: "string",
+					enum: ["declined", "allowed"],
+					description: "'declined' silences future prompts; 'allowed' pre-authorizes installation.",
+				},
+			},
+			required: ["server_id", "decision"],
+		},
+	},
+];
+
+describe("LSP core tool surface", () => {
+	test("#given a JSON-RPC tools/list request #when descriptors are returned #then the public nine-tool schemas are pinned", async () => {
+		// given
+		const request = { jsonrpc: "2.0", id: 21, method: "tools/list" };
+
+		// when
+		const response = await handleLspMcpRequest(request);
+
+		// then
+		expect(response?.result?.tools).toEqual(expectedToolSurface);
+	});
+
+	test("#given legacy tool aliases #when executed #then aliases are callable but not listed", async () => {
+		// given / when
+		const result = await runWithRequestContext(createStandaloneMcpRequestContext(), () =>
+			executeLspTool("lsp_diagnostics", { filePath: "module.wat" }),
+		);
+
+		// then
+		expect(result.content[0]?.text).toContain("No LSP server configured for extension: .wat");
+		const listResponse = await handleLspMcpRequest({ jsonrpc: "2.0", id: 23, method: "tools/list" });
+		expect(listResponse?.result?.tools?.map((tool: { name: string }) => tool.name)).not.toContain("lsp_diagnostics");
+	});
+
+	test("#given non-object tool arguments #when coerced #then they produce an empty argument record", () => {
+		// given / when / then
+		expect(coerceToolArguments(null)).toEqual({});
+		expect(coerceToolArguments(["filePath"])).toEqual({});
+	});
+});