oh-my-opencode 4.5.12 → 4.6.0

package/packages/omo-codex/scripts/install-local-git-bash-preflight.test.mjs

@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installMarketplaceLocally } from "./install-local.mjs";
+
+const windowsGitBashPath = "C:\\Program Files\\Git\\bin\\bash.exe";
+const lspCliPath = join(process.cwd(), "packages", "lsp-tools-mcp", "dist", "cli.js");
+
+async function withBundledLspRuntimeForTest(run) {
+	try {
+		await stat(lspCliPath);
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		await mkdir(join(process.cwd(), "packages", "lsp-tools-mcp", "dist"), { recursive: true });
+		await writeFile(lspCliPath, "#!/usr/bin/env node\n");
+	}
+
+	return run();
+}
+
+test("#given Windows without Git Bash and auto install skip env #when installing local marketplace #then rejects before marketplace or config mutation", async () => {
+	const repoRoot = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-missing-repo-"));
+	const codexHome = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-missing-home-"));
+	const commands = [];
+
+	await assert.rejects(
+		installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "win32",
+			env: { OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL: "1" },
+			gitBashResolver: () => ({
+				found: false,
+				checkedPaths: [windowsGitBashPath],
+				installHint: [
+					"Git Bash is required.",
+					"winget install --id Git.Git -e --source winget",
+					"OMO_CODEX_GIT_BASH_PATH=C:\\path\\to\\bash.exe",
+					"rerun `npx lazycodex-ai install`",
+				].join("\n"),
+			}),
+			runCommand: async (command, args, options) => {
+				commands.push([command, ...args, options.cwd].join(" "));
+			},
+			log: () => {},
+		}),
+		/winget install --id Git\.Git -e --source winget/,
+	);
+	assert.deepEqual(commands, []);
+	await assert.rejects(stat(join(codexHome, "config.toml")), /ENOENT/);
+});
+
+test("#given Windows without Git Bash #when winget succeeds and resolver recovers #then install continues", async () => {
+	const runCalls = [];
+	const resolutions = [
+		{ found: false, checkedPaths: [windowsGitBashPath], installHint: "install hint before winget" },
+		{ found: true, path: windowsGitBashPath, source: "program-files" },
+	];
+	let resolveCallCount = 0;
+
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-auto-home-")),
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-auto-bin-")),
+		platform: "win32",
+		gitBashResolver: () => resolutions[resolveCallCount++] ?? resolutions[resolutions.length - 1],
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+		log: () => {},
+	}));
+
+	assert.equal(resolveCallCount, 2);
+	assert.match(runCalls.join("\n"), /^winget install --id Git\.Git -e --source winget /m);
+	assert.equal(result.gitBashPath, windowsGitBashPath);
+});
+
+test("#given non-Windows install #when running installer #then winget is never called", async () => {
+	const runCalls = [];
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-no-winget-home-")),
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-no-winget-bin-")),
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, null);
+	assert.equal(runCalls.some((command) => command.startsWith("winget ")), false);
+});
+
+test("#given Windows env override resolves Git Bash #when installing local marketplace #then install continues", async () => {
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-home-")),
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-bin-")),
+		platform: "win32",
+		gitBashResolver: () => ({ found: true, path: windowsGitBashPath, source: "env" }),
+		runCommand: async () => {},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, windowsGitBashPath);
+	assert.equal(result.installed.length, 1);
+});
+
+test("#given Windows env override in installer options #when no custom resolver is provided #then default resolver uses it", async () => {
+	const codexHome = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-env-home-"));
+	const gitBashPath = join(await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-env-")), "bash.exe");
+	await writeFile(gitBashPath, "");
+
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome,
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-env-bin-")),
+		platform: "win32",
+		env: { OMO_CODEX_GIT_BASH_PATH: gitBashPath },
+		runCommand: async () => {},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, gitBashPath);
+});
+
+test("#given non-Windows local install #when resolver would fail #then installer keeps existing behavior", async () => {
+	const codexHome = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-linux-home-"));
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome,
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-linux-bin-")),
+		platform: "linux",
+		gitBashResolver: () => ({ found: false, checkedPaths: [windowsGitBashPath], installHint: "should not be used" }),
+		runCommand: async () => {},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, null);
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /\[marketplaces\.sisyphuslabs\]/);
+});

package/packages/omo-codex/scripts/install-local.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { mkdir, writeFile } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -12,6 +13,10 @@ import {
 } from "./install/cache.mjs";
 import { linkCachedPluginAgents } from "./install/agents.mjs";
 import { updateCodexConfig } from "./install/config.mjs";
+import {
+	emptyProjectLocalCodexCleanupResult,
+	repairNearestProjectLocalCodexArtifacts,
+} from "./install/project-local-cleanup.mjs";
 import { trustedHookStatesForPlugin } from "./install/hook-trust.mjs";
 import { defaultRunCommand } from "./install/process.mjs";
 import { writeInstalledMarketplaceSnapshot } from "./install/snapshot.mjs";
@@ -21,6 +26,10 @@ import {
 	resolvePluginSource,
 	validatePathSegment,
 } from "./install/marketplace.mjs";
+import { prepareGitBashForInstall, resolveGitBashForCurrentProcess } from "./install/git-bash.mjs";
+import { formatLazyCodexInstallHelp, parseLazyCodexInstallCliArgs } from "./install/cli-args.mjs";
+import { runDelegatedOmoCommand } from "./install/delegated-command.mjs";
+import { shouldBuildSourcePackages } from "./install/source-package-build.mjs";
 
 const LEGACY_CODEX_PLUGIN_MARKETPLACE = ["code", "yeongyu", "codex", "plugins"].join("-");
 const SISYPHUS_LEGACY_CACHE_MARKETPLACES = ["lazycodex", LEGACY_CODEX_PLUGIN_MARKETPLACE];
@@ -41,10 +50,24 @@ export async function installMarketplaceLocally(options = {}) {
 	const env = options.env ?? process.env;
 	const homeDir = resolve(options.homeDir ?? homedir());
 	const codexHome = resolve(options.codexHome ?? nonEmptyEnvValue(env, "CODEX_HOME") ?? join(homeDir, ".codex"));
+	const projectDirectory = resolve(options.projectDirectory ?? nonEmptyEnvValue(env, "OMO_CODEX_PROJECT") ?? process.cwd());
 	const binDir = resolve(options.binDir ?? resolveCodexInstallerBinDir({ codexHome, env, homeDir }));
 	const platform = options.platform ?? process.platform;
 	const runCommand = options.runCommand ?? defaultRunCommand;
 	const log = options.log ?? console.log;
+	const buildSource = await shouldBuildSourcePackages(repoRoot);
+	const gitBashResolution = await prepareGitBashForInstall({
+		platform,
+		env,
+		cwd: repoRoot,
+		runCommand,
+		resolveGitBash: platform === "win32"
+			? (options.gitBashResolver ?? (() => resolveGitBashForCurrentProcess({ platform, env })))
+			: undefined,
+	});
+	if (!gitBashResolution.found) {
+		throw new Error(gitBashResolution.installHint);
+	}
 	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
 	const marketplace = await readMarketplace(repoRoot, {
 		marketplacePath: join(codexPackageRoot, "marketplace.json"),
@@ -66,6 +89,7 @@ export async function installMarketplaceLocally(options = {}) {
 
 		log(`Building ${entry.name}@${version}`);
 		const plugin = await installCachedPlugin({
+			buildSource,
 			codexHome,
 			marketplaceName: marketplace.name,
 			name: entry.name,
@@ -120,15 +144,38 @@ export async function installMarketplaceLocally(options = {}) {
 		marketplaceName: marketplace.name,
 		marketplaceSource: { sourceType: "local", source: marketplaceRoot },
 		pluginNames,
+		platform,
 		trustedHookStates,
 		agentConfigs: [...agentConfigs.values()].sort((left, right) => left.name.localeCompare(right.name)),
+		autonomousPermissions: options.autonomousPermissions === true,
 	});
+	const projectCleanup = await repairProjectLocalCodexArtifactsBestEffort({ startDirectory: projectDirectory, codexHome, log });
+	for (const configCleanup of projectCleanup.configs) {
+		if (!configCleanup.changed) continue;
+		log(`Repaired project Codex config ${configCleanup.configPath} (backup: ${configCleanup.backupPath})`);
+	}
+	for (const artifact of projectCleanup.artifacts) {
+		log(`Found project-local legacy artifact ${artifact.path}; left in place`);
+	}
 
 	for (const plugin of installed) {
 		log(`Installed ${plugin.name}@${marketplace.name} -> ${plugin.path}`);
 	}
 
-	return { marketplaceName: marketplace.name, installed };
+	return { marketplaceName: marketplace.name, installed, gitBashPath: gitBashResolution.path, projectCleanup };
+}
+
+async function repairProjectLocalCodexArtifactsBestEffort({ startDirectory, codexHome, log }) {
+	try {
+		return await repairNearestProjectLocalCodexArtifacts({ startDirectory, codexHome });
+	} catch (error) {
+		log(`Skipped project-local Codex cleanup: ${formatUnknownError(error)}`);
+		return emptyProjectLocalCodexCleanupResult();
+	}
+}
+
+function formatUnknownError(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 
 function agentNameFromToml(fileName) {
@@ -170,21 +217,57 @@ function nonEmptyEnvValue(env, key) {
 	const value = env[key];
 	if (typeof value !== "string") return undefined;
 	const trimmed = value.trim();
-	return trimmed.length === 0 ? undefined : value;
+	return trimmed.length === 0 ? undefined : trimmed;
 }
 
 function legacyCacheMarketplaces(marketplaceName) {
 	return marketplaceName === "sisyphuslabs" ? SISYPHUS_LEGACY_CACHE_MARKETPLACES : [];
 }
 
+export function resolveDefaultRepoRoot() {
+	return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+
 async function main() {
-	const repoRoot = process.argv[2] ? resolve(process.argv[2]) : process.cwd();
-	const result = await installMarketplaceLocally({ repoRoot });
+	const parsed = parseLazyCodexInstallCliArgs(process.argv.slice(2));
+	if (parsed.kind === "help") {
+		console.log(formatLazyCodexInstallHelp());
+		return;
+	}
+	if (parsed.kind === "version") {
+		const packageJson = JSON.parse(await readFile(join(resolveDefaultRepoRoot(), "package.json"), "utf8"));
+		const version = typeof packageJson.version === "string" ? packageJson.version : "unknown";
+		console.log(`lazycodex-ai ${version}`);
+		return;
+	}
+	if (parsed.kind === "command") {
+		await runDelegatedOmoCommand(parsed, { cwd: process.cwd(), log: console.log, runCommand: defaultRunCommand });
+		return;
+	}
+
+	const repoRoot = parsed.repoRoot ? resolve(parsed.repoRoot) : resolveDefaultRepoRoot();
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		autonomousPermissions: parsed.autonomousPermissions,
+	});
 	console.log(`Installed ${result.installed.length} plugin(s) from ${result.marketplaceName}.`);
 }
 
-const invokedPath = process.argv[1] ? resolve(process.argv[1]) : "";
-if (invokedPath === fileURLToPath(import.meta.url)) {
+function resolveEntrypointPath(path) {
+	try {
+		return realpathSync(resolve(path));
+	} catch (error) {
+		if (error instanceof Error) return resolve(path);
+		throw error;
+	}
+}
+
+function isEntrypointInvocation(invokedPath) {
+	if (!invokedPath) return false;
+	return resolveEntrypointPath(invokedPath) === resolveEntrypointPath(fileURLToPath(import.meta.url));
+}
+
+if (isEntrypointInvocation(process.argv[1] ?? "")) {
 	main().catch((error) => {
 		console.error(error instanceof Error ? error.message : error);
 		process.exitCode = 1;

package/packages/omo-codex/scripts/install-local.test.mjs

@@ -67,6 +67,21 @@ test("#given explicit CODEX_LOCAL_BIN_DIR #when resolving local installer bin di
 	);
 });
 
+test("#given CODEX_LOCAL_BIN_DIR with surrounding whitespace #when resolving local installer bin dir #then trims the env value before use", () => {
+	const homeDir = join(tmpdir(), "omo-codex-home-trim");
+	const codexHome = join(tmpdir(), "omo-codex-install-trim");
+	const explicitBinDir = join(tmpdir(), "omo-codex-trim-bin");
+
+	assert.equal(
+		resolveCodexInstallerBinDir({
+			codexHome,
+			env: { CODEX_LOCAL_BIN_DIR: `  ${explicitBinDir}  ` },
+			homeDir,
+		}),
+		explicitBinDir,
+	);
+});
+
 test("#given omo plugin source #when inspecting identity #then uses sisyphuslabs omo metadata", async () => {
 	const pluginRoot = join(scriptDir, "..", "plugin");
 

package/packages/omo-codex/scripts/install-mcp-runtime.test.mjs

@@ -12,6 +12,7 @@ test("#given external MCP package runtime #when installing cached plugin #then r
 	const codexHome = await makeTempDir();
 	const sourceRoot = join(repoRoot, "packages", "omo-codex", "plugin");
 	const astGrepPackageRoot = join(repoRoot, "packages", "ast-grep-mcp");
+	const gitBashPackageRoot = join(repoRoot, "packages", "git-bash-mcp");
 	const lspPackageRoot = join(repoRoot, "packages", "lsp-tools-mcp");
 
 	await writeJson(join(astGrepPackageRoot, "package.json"), {
@@ -26,6 +27,12 @@ test("#given external MCP package runtime #when installing cached plugin #then r
 		type: "module",
 		bin: { "omo-lsp": "./dist/cli.js" },
 	});
+	await writeJson(join(gitBashPackageRoot, "package.json"), {
+		name: "@example/git-bash-mcp",
+		version: "0.1.0",
+		type: "module",
+		bin: { "omo-git-bash": "./dist/cli.js" },
+	});
 	await writeJson(join(sourceRoot, "package.json"), {
 		name: "@example/omo",
 		version: "0.1.0",
@@ -37,6 +44,11 @@ test("#given external MCP package runtime #when installing cached plugin #then r
 				args: ["../../ast-grep-mcp/dist/cli.js", "mcp"],
 				cwd: ".",
 			},
+			git_bash: {
+				command: "node",
+				args: ["../../git-bash-mcp/dist/cli.js", "mcp"],
+				cwd: ".",
+			},
 			lsp: {
 				command: "node",
 				args: ["../../lsp-tools-mcp/dist/cli.js", "mcp"],
@@ -45,6 +57,7 @@ test("#given external MCP package runtime #when installing cached plugin #then r
 		},
 	});
 	await writeJson(join(astGrepPackageRoot, "dist", "cli.js"), { executable: true });
+	await writeJson(join(gitBashPackageRoot, "dist", "cli.js"), { executable: true });
 	await writeJson(join(lspPackageRoot, "dist", "cli.js"), { executable: true });
 	await writeJson(join(lspPackageRoot, "dist", "lsp", "manager.js"), { copied: true });
 
@@ -59,13 +72,17 @@ test("#given external MCP package runtime #when installing cached plugin #then r
 
 	const cachedMcp = JSON.parse(await readFile(join(result.path, ".mcp.json"), "utf8"));
 	const copiedAstGrepCli = join(result.path, "mcp", "ast_grep", "dist", "cli.js");
+	const copiedGitBashCli = join(result.path, "mcp", "git_bash", "dist", "cli.js");
 	const copiedCli = join(result.path, "mcp", "lsp", "dist", "cli.js");
 
 	assert.deepEqual(cachedMcp.mcpServers.ast_grep.args, [copiedAstGrepCli, "mcp"]);
+	assert.deepEqual(cachedMcp.mcpServers.git_bash.args, [copiedGitBashCli, "mcp"]);
 	assert.deepEqual(cachedMcp.mcpServers.lsp.args, [copiedCli, "mcp"]);
 	assert.equal(Object.hasOwn(cachedMcp.mcpServers.ast_grep, "cwd"), false);
+	assert.equal(Object.hasOwn(cachedMcp.mcpServers.git_bash, "cwd"), false);
 	assert.equal(Object.hasOwn(cachedMcp.mcpServers.lsp, "cwd"), false);
 	assert.equal((await stat(copiedAstGrepCli)).isFile(), true);
+	assert.equal((await stat(copiedGitBashCli)).isFile(), true);
 	assert.equal((await stat(copiedCli)).isFile(), true);
 	assert.equal((await stat(join(result.path, "mcp", "lsp", "dist", "lsp", "manager.js"))).isFile(), true);
 });
@@ -171,3 +188,46 @@ test("#given structurally valid external MCP package without mcp suffix #when in
 	assert.deepEqual(cachedMcp.mcpServers.language_tools.args, [copiedCli, "mcp", join(sourceRoot, "..", "local-config.json")]);
 	assert.equal((await stat(copiedCli)).isFile(), true);
 });
+
+test("#given packaged external MCP runtime has only dist files #when installing cached plugin #then runtime is copied into the plugin cache", async () => {
+	// given
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const sourceRoot = join(repoRoot, "packages", "omo-codex", "plugin");
+	const lspPackageRoot = join(repoRoot, "packages", "lsp-tools-mcp");
+
+	await writeJson(join(sourceRoot, "package.json"), {
+		name: "@example/omo",
+		version: "0.1.0",
+	});
+	await writeJson(join(sourceRoot, ".mcp.json"), {
+		mcpServers: {
+			lsp: {
+				command: "node",
+				args: ["../../lsp-tools-mcp/dist/cli.js", "mcp"],
+				cwd: ".",
+			},
+		},
+	});
+	await writeJson(join(lspPackageRoot, "dist", "cli.js"), { executable: true });
+	await writeJson(join(lspPackageRoot, "dist", "lsp", "manager.js"), { copied: true });
+
+	// when
+	const result = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "sisyphuslabs",
+		name: "omo",
+		runCommand: async () => {},
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+	});
+
+	// then
+	const cachedMcp = JSON.parse(await readFile(join(result.path, ".mcp.json"), "utf8"));
+	const copiedCli = join(result.path, "mcp", "lsp", "dist", "cli.js");
+	assert.deepEqual(cachedMcp.mcpServers.lsp.args, [copiedCli, "mcp"]);
+	assert.equal(Object.hasOwn(cachedMcp.mcpServers.lsp, "cwd"), false);
+	assert.equal((await stat(copiedCli)).isFile(), true);
+	assert.equal((await stat(join(result.path, "mcp", "lsp", "dist", "lsp", "manager.js"))).isFile(), true);
+	assert.notEqual(cachedMcp.mcpServers.lsp.args[0], join(lspPackageRoot, "dist", "cli.js"));
+});

package/packages/omo-codex/scripts/install-packaged-local.test.mjs

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installMarketplaceLocally } from "./install-local.mjs";
+import { makeTempDir, writeJson, writePluginAt } from "./install-test-fixtures.mjs";
+
+test("#given packaged lazycodex adapter #when installing locally #then uses bundled artifacts without source builds", async () => {
+	// given
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const lspRuntimeRoot = join(repoRoot, "packages", "lsp-tools-mcp");
+
+	await writeJson(join(repoRoot, "package.json"), {
+		name: "lazycodex-ai",
+		version: "0.1.2",
+	});
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "sisyphuslabs",
+		plugins: [{ name: "omo", source: "./plugins/omo" }],
+	});
+	await writePluginAt(pluginRoot, "omo", "0.1.0");
+	await writeJson(join(pluginRoot, ".mcp.json"), {
+		mcpServers: {
+			lsp: {
+				command: "node",
+				args: ["../../lsp-tools-mcp/dist/cli.js", "mcp"],
+				cwd: ".",
+			},
+		},
+	});
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\nconsole.log('prebuilt')\n");
+	await writeJson(join(lspRuntimeRoot, "dist", "cli.js"), { executable: true });
+
+	const commands = [];
+
+	// when
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			commands.push([command, args.join(" "), options.cwd]);
+		},
+		log: () => {},
+	});
+
+	// then
+	const pluginCacheRoot = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "0.1.0");
+	const cachedMcp = JSON.parse(await readFile(join(pluginCacheRoot, ".mcp.json"), "utf8"));
+	const cachedLspCli = join(pluginCacheRoot, "mcp", "lsp", "dist", "cli.js");
+
+	assert.deepEqual(result.installed.map((plugin) => `${plugin.name}@${plugin.version}`), ["omo@0.1.0"]);
+	assert.deepEqual(
+		commands.map(([command, args, cwd]) => [command, args, cwd]),
+		[["npm", "install --omit=dev", pluginCacheRoot]],
+	);
+	assert.deepEqual(cachedMcp.mcpServers.lsp.args, [cachedLspCli, "mcp"]);
+	assert.equal((await stat(cachedLspCli)).isFile(), true);
+	assert.notEqual(cachedMcp.mcpServers.lsp.args[0], join(lspRuntimeRoot, "dist", "cli.js"));
+});