oh-my-opencode 4.8.1 → 4.9.1

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

@@ -14,7 +14,7 @@ test("#given non-Windows platform #when resolving Git Bash #then no preflight is
 		where: () => [],
 	});
 
-	assert.deepEqual(result, { found: true, path: null, source: "not-required" });
+	assert.deepEqual(result, { found: true, path: null, source: "not-required", checkedPaths: [] });
 });
 
 test("#given Windows env override to bash.exe #when the file exists #then env path wins", () => {
@@ -26,7 +26,7 @@ test("#given Windows env override to bash.exe #when the file exists #then env pa
 		where: () => [programFilesGitBash],
 	});
 
-	assert.deepEqual(result, { found: true, path: overridePath, source: "env" });
+	assert.deepEqual(result, { found: true, path: overridePath, source: "env", checkedPaths: [overridePath] });
 });
 
 test("#given Windows standard paths are absent and PATH contains bash #when resolving #then uses where bash candidate", () => {
@@ -38,7 +38,42 @@ test("#given Windows standard paths are absent and PATH contains bash #when reso
 		where: () => ["C:\\Windows\\System32\\bash.exe", pathCandidate],
 	});
 
-	assert.deepEqual(result, { found: true, path: pathCandidate, source: "path" });
+	assert.deepEqual(result, {
+		found: true,
+		path: pathCandidate,
+		source: "path",
+		checkedPaths: [programFilesGitBash, programFilesX86GitBash, "C:\\Windows\\System32\\bash.exe", pathCandidate],
+	});
+});
+
+test("#given PATH bash is only the System32 WSL launcher #when resolving #then launcher is skipped and install guidance returned", () => {
+	const system32Bash = "C:\\Windows\\System32\\bash.exe";
+	const result = resolveGitBash({
+		platform: "win32",
+		env: {},
+		exists: (path) => path === system32Bash,
+		where: () => [system32Bash],
+	});
+
+	assert.equal(result.found, false);
+	assert.deepEqual(result.checkedPaths, [programFilesGitBash, programFilesX86GitBash, system32Bash]);
+	assert.match(result.installHint, /winget install --id Git\.Git -e --source winget/);
+});
+
+test("#given PATH lists the WindowsApps alias before a real Git Bash #when resolving #then alias is skipped and Git Bash wins", () => {
+	const windowsAppsBash = "C:/Users/dev/AppData/Local/Microsoft/WindowsApps/bash.exe";
+	const gitBash = "D:\\Tools\\Git\\bin\\bash.exe";
+	const result = resolveGitBash({
+		platform: "win32",
+		env: {},
+		exists: (path) => path === windowsAppsBash || path === gitBash,
+		where: () => [windowsAppsBash, gitBash],
+	});
+
+	assert.equal(result.found, true);
+	assert.equal(result.path, gitBash);
+	assert.equal(result.source, "path");
+	assert.deepEqual(result.checkedPaths, [programFilesGitBash, programFilesX86GitBash, windowsAppsBash, gitBash]);
 });
 
 test("#given Windows invalid env override #when resolving #then returns guidance without falling through", () => {
@@ -127,7 +162,7 @@ test("#given non-Windows platform #when preparing #then winget is never called",
 	});
 
 	assert.deepEqual(runCalls, []);
-	assert.deepEqual(result, { found: true, path: null, source: "not-required" });
+	assert.deepEqual(result, { found: true, path: null, source: "not-required", checkedPaths: [] });
 });
 
 test("#given Windows without Git Bash and winget fails #when preparing #then original install hint is preserved", async () => {

package/packages/omo-codex/scripts/install/hook-targets.mjs

@@ -0,0 +1,46 @@
+import { readFile } from "node:fs/promises";
+import { join, sep } from "node:path";
+
+import { exists, isRecord } from "./utils.mjs";
+
+const PLUGIN_ROOT_TARGET_PATTERN = /\$\{PLUGIN_ROOT\}\/([^"']+)/g;
+
+export async function findMissingHookCommandTargets(pluginRoot) {
+	const manifestPath = join(pluginRoot, "hooks", "hooks.json");
+	if (!(await exists(manifestPath))) return [];
+
+	const commands = [];
+	collectCommands(JSON.parse(await readFile(manifestPath, "utf8")), commands);
+
+	const missing = [];
+	const seen = new Set();
+	for (const command of commands) {
+		for (const match of command.matchAll(PLUGIN_ROOT_TARGET_PATTERN)) {
+			const target = join(pluginRoot, ...match[1].split("/"));
+			if (seen.has(target)) continue;
+			seen.add(target);
+			if (!(await exists(target))) missing.push(target);
+		}
+	}
+	return missing;
+}
+
+export async function assertHookCommandTargets(pluginRoot) {
+	const missing = await findMissingHookCommandTargets(pluginRoot);
+	if (missing.length === 0) return;
+	const relativeMissing = missing.map((path) => path.split(`${pluginRoot}${sep}`).join("").split(sep).join("/"));
+	throw new Error(
+		`Plugin payload is missing ${missing.length} hook command target(s) referenced by hooks.json: ${relativeMissing.join(", ")}. ` +
+			"The previous plugin cache was left untouched; this payload was not activated.",
+	);
+}
+
+function collectCommands(value, commands) {
+	if (Array.isArray(value)) {
+		for (const entry of value) collectCommands(entry, commands);
+		return;
+	}
+	if (!isRecord(value)) return;
+	if (value.type === "command" && typeof value.command === "string") commands.push(value.command);
+	for (const entry of Object.values(value)) collectCommands(entry, commands);
+}

package/packages/omo-codex/scripts/install/multi-agent-v2-config.mjs

@@ -20,11 +20,21 @@ export function ensureCodexMultiAgentV2Config(config) {
 	if (!section) {
 		return appendBlock(
 			normalizedConfig,
-			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nmax_concurrent_threads_per_session = ${maxThreadsValue}\n`,
+			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nmax_concurrent_threads_per_session = ${maxThreadsValue}\nhide_spawn_agent_metadata = false\n`,
 		);
 	}
 
-	return replaceOrInsertSetting(normalizedConfig, section, "max_concurrent_threads_per_session", maxThreadsValue);
+	// Codex defaults hide_spawn_agent_metadata to true on V2, which strips the
+	// agent_type parameter from spawn_agent and makes the role TOMLs this
+	// installer ships unselectable.
+	const withMaxThreads = replaceOrInsertSetting(
+		normalizedConfig,
+		section,
+		"max_concurrent_threads_per_session",
+		maxThreadsValue,
+	);
+	const updatedSection = findTomlSection(withMaxThreads, CODEX_MULTI_AGENT_V2_HEADER);
+	return replaceOrInsertSetting(withMaxThreads, updatedSection, "hide_spawn_agent_metadata", "false");
 }
 
 function removeFeatureFlagSetting(config, featureName) {

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

@@ -7,6 +7,7 @@ export async function defaultRunCommand(command, args, options) {
 		const child = spawn(invocation.command, invocation.args, {
 			cwd: options.cwd,
 			stdio: "inherit",
+			...(options.env ? { env: options.env } : {}),
 		});
 		child.once("error", reject);
 		child.once("exit", (code, signal) => {

package/packages/omo-codex/scripts/install-bin-links.test.mjs

@@ -1,11 +1,139 @@
 import assert from "node:assert/strict";
-import { lstat, mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { chmod, lstat, mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import test from "node:test";
 
-import { linkCachedPluginBins } from "./install/cache.mjs";
+import { linkCachedPluginBins, linkRootRuntimeBin } from "./install/cache.mjs";
 import { makeTempDir, writeJson } from "./install-test-fixtures.mjs";
 
+async function writeRuntimeWrapperFixture({ withNodeCli = false } = {}) {
+	const root = await makeTempDir();
+	const repoRoot = join(root, "repo");
+	const binDir = join(root, "bin");
+	const codexHome = join(root, "codex");
+	const homeDir = join(root, "home");
+	await mkdir(join(repoRoot, "dist", "cli"), { recursive: true });
+	await writeFile(join(repoRoot, "dist", "cli", "index.js"), "");
+	if (withNodeCli) {
+		await mkdir(join(repoRoot, "dist", "cli-node"), { recursive: true });
+		await writeFile(
+			join(repoRoot, "dist", "cli-node", "index.js"),
+			'console.log("OMO_NODE_OK", process.argv.slice(2).join(" "));\n',
+		);
+	}
+	await mkdir(homeDir, { recursive: true });
+	const link = await linkRootRuntimeBin({ binDir, codexHome, repoRoot, platform: "linux" });
+	return { homeDir, link, repoRoot };
+}
+
+function runtimeWrapperEnv(homeDir) {
+	return { PATH: `${dirname(process.execPath)}:/usr/bin:/bin`, HOME: homeDir };
+}
+
+test("#given bun absent from PATH but present in ~/.bun/bin #when running the omo runtime wrapper #then resolves the bun fallback", async (t) => {
+	if (process.platform === "win32") return t.skip("posix wrapper execution");
+	const { homeDir, link } = await writeRuntimeWrapperFixture();
+	await mkdir(join(homeDir, ".bun", "bin"), { recursive: true });
+	await writeFile(join(homeDir, ".bun", "bin", "bun"), '#!/bin/sh\necho "fake-bun-ran $2"\n');
+	await chmod(join(homeDir, ".bun", "bin", "bun"), 0o755);
+
+	const result = spawnSync(link.path, ["--version"], {
+		encoding: "utf8",
+		env: { PATH: "/usr/bin:/bin", HOME: homeDir },
+	});
+
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(result.stdout, /fake-bun-ran --version/);
+});
+
+test("#given bun absent everywhere #when running the omo runtime wrapper #then fails with an actionable install hint", async (t) => {
+	if (process.platform === "win32") return t.skip("posix wrapper execution");
+	const { homeDir, link } = await writeRuntimeWrapperFixture();
+
+	const result = spawnSync(link.path, ["--version"], {
+		encoding: "utf8",
+		env: { PATH: "/usr/bin:/bin", HOME: homeDir },
+	});
+
+	assert.equal(result.status, 127);
+	assert.match(result.stderr, /bun runtime not found/);
+	assert.match(result.stderr, /https:\/\/bun\.sh/);
+});
+
+test("#given OMO_RUNTIME=node and a node CLI bundle #when running the omo runtime wrapper #then executes the node CLI", async (t) => {
+	if (process.platform === "win32") return t.skip("posix wrapper execution");
+	const { homeDir, link } = await writeRuntimeWrapperFixture({ withNodeCli: true });
+
+	const result = spawnSync(link.path, ["--help"], {
+		encoding: "utf8",
+		env: { ...runtimeWrapperEnv(homeDir), OMO_RUNTIME: "node" },
+	});
+
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(result.stdout, /OMO_NODE_OK --help/);
+});
+
+test("#given bun absent everywhere and a node CLI bundle #when running the omo runtime wrapper #then falls back to node", async (t) => {
+	if (process.platform === "win32") return t.skip("posix wrapper execution");
+	const { homeDir, link } = await writeRuntimeWrapperFixture({ withNodeCli: true });
+
+	const result = spawnSync(link.path, ["--version"], {
+		encoding: "utf8",
+		env: runtimeWrapperEnv(homeDir),
+	});
+
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(result.stdout, /OMO_NODE_OK --version/);
+});
+
+test("#given bun absent and no node CLI bundle #when running the omo runtime wrapper #then the error names both runtimes", async (t) => {
+	if (process.platform === "win32") return t.skip("posix wrapper execution");
+	const { homeDir, link } = await writeRuntimeWrapperFixture();
+
+	const result = spawnSync(link.path, ["--version"], {
+		encoding: "utf8",
+		env: runtimeWrapperEnv(homeDir),
+	});
+
+	assert.equal(result.status, 127);
+	assert.match(result.stderr, /bun runtime not found/);
+	assert.match(result.stderr, /https:\/\/bun\.sh/);
+	assert.match(result.stderr, /dist\/cli-node\/index\.js/);
+	assert.match(result.stderr, /OMO_RUNTIME=node/);
+});
+
+test("#given Windows platform #when writing the omo runtime wrapper #then embeds the node fallback chain", async () => {
+	const root = await makeTempDir();
+	const repoRoot = join(root, "repo");
+	const binDir = join(root, "bin");
+	await mkdir(join(repoRoot, "dist", "cli"), { recursive: true });
+	await writeFile(join(repoRoot, "dist", "cli", "index.js"), "");
+
+	const link = await linkRootRuntimeBin({ binDir, codexHome: join(root, "codex"), repoRoot, platform: "win32" });
+
+	const wrapper = await readFile(link.path, "utf8");
+	assert.match(wrapper, /OMO_RUNTIME/);
+	assert.match(wrapper, /dist[\\/]cli-node[\\/]index\.js/);
+	assert.ok(wrapper.indexOf("OMO_RUNTIME") < wrapper.indexOf("where bun"), "node override must precede bun discovery");
+});
+
+test("#given Windows platform #when writing the omo runtime wrapper #then embeds the bun fallback chain", async () => {
+	const root = await makeTempDir();
+	const repoRoot = join(root, "repo");
+	const binDir = join(root, "bin");
+	await mkdir(join(repoRoot, "dist", "cli"), { recursive: true });
+	await writeFile(join(repoRoot, "dist", "cli", "index.js"), "");
+
+	const link = await linkRootRuntimeBin({ binDir, codexHome: join(root, "codex"), repoRoot, platform: "win32" });
+
+	const wrapper = await readFile(link.path, "utf8");
+	assert.match(wrapper, /where bun/);
+	assert.match(wrapper, /%USERPROFILE%\\\.bun\\bin\\bun\.exe/);
+	assert.match(wrapper, /bun runtime not found/);
+	assert.match(wrapper, /exit \/b 127/);
+});
+
 test("#given Windows platform #when linking cached plugin bins #then writes command shims", async () => {
 	const root = await makeTempDir();
 	const pluginRoot = join(root, "plugin");

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

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { updateCodexConfig } from "./install/config.mjs";
+
+test("#given windows platform with Git Bash enabled #when updating config #then enables git_bash plugin mcp policy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-git-bash-win32-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'[plugins."omo@sisyphuslabs"]',
+			"enabled = true",
+			"",
+			'[plugins."omo@sisyphuslabs".mcp_servers.lsp]',
+			"enabled = true",
+			"",
+			'[hooks.state."omo@sisyphuslabs:hooks/hooks.json:post_tool_use:0:0"]',
+			'trusted_hash = "sha256:keep"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+		platform: "win32",
+		gitBashEnabled: true,
+		trustedHookStates: [{ key: "omo@sisyphuslabs:hooks/hooks.json:post_tool_use:0:0", trustedHash: "sha256:keep" }],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.lsp\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+	assert.match(content, /\[hooks\.state\."omo@sisyphuslabs:hooks\/hooks\.json:post_tool_use:0:0"\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = true/);
+});
+
+test("#given windows platform without Git Bash enabled #when updating config #then disables git_bash plugin mcp policy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-git-bash-win32-disabled-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+		platform: "win32",
+		gitBashEnabled: false,
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = false/);
+});
+
+test("#given non-windows platforms #when updating config #then disables git_bash plugin mcp policy", async () => {
+	for (const platform of ["linux", "darwin"]) {
+		// given
+		const root = await mkdtemp(join(tmpdir(), `omo-codex-config-git-bash-${platform}-`));
+		const configPath = join(root, "config.toml");
+
+		// when
+		await updateCodexConfig({
+			configPath,
+			repoRoot: "/repo/packages/omo-codex",
+			marketplaceName: "sisyphuslabs",
+			marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+			pluginNames: ["omo"],
+			platform,
+		});
+
+		// then
+		const content = await readFile(configPath, "utf8");
+		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = false/);
+	}
+});

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

@@ -184,6 +184,56 @@ test("#given existing MultiAgentV2 table #when script installer updates config #
 	assert.doesNotMatch(config, /max_concurrent_threads_per_session = 4/);
 });
 
+test("#given empty Codex config #when script installer updates config #then exposes spawn_agent agent_type for installed roles", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-roles-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	const v2Section = config.slice(config.indexOf("[features.multi_agent_v2]"));
+	assert.match(v2Section, /hide_spawn_agent_metadata = false/);
+});
+
+test("#given user config hiding spawn_agent metadata #when script installer updates config #then re-exposes agent_type so role TOMLs stay selectable", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-hide-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[features.multi_agent_v2]",
+			"usage_hint_enabled = false",
+			"hide_spawn_agent_metadata = true",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /hide_spawn_agent_metadata = false/);
+	assert.doesNotMatch(config, /hide_spawn_agent_metadata = true/);
+	assert.match(config, /usage_hint_enabled = false/);
+});
+
 test("#given legacy boolean MultiAgentV2 flag and table #when script installer updates config #then normalizes to table config", async () => {
 	// given
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-legacy-"));
@@ -325,47 +375,3 @@ test("#given existing trust and lsp blocks #when updating config #then existing
 	assert.match(content, /\[hooks\.state\."omo@sisyphuslabs:hooks\/hooks\.json:post_tool_use:0:0"\]/);
 	assert.match(content, /trusted_hash = "sha256:keep"/);
 });
-
-test("#given windows platform #when updating config #then enables git_bash plugin mcp policy", async () => {
-	// given
-	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-git-bash-win32-"));
-	const configPath = join(root, "config.toml");
-
-	// when
-	await updateCodexConfig({
-		configPath,
-		repoRoot: "/repo/packages/omo-codex",
-		marketplaceName: "sisyphuslabs",
-		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
-		pluginNames: ["omo"],
-		platform: "win32",
-	});
-
-	// then
-	const content = await readFile(configPath, "utf8");
-	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
-	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = true/);
-});
-
-test("#given non-windows platforms #when updating config #then disables git_bash plugin mcp policy", async () => {
-	for (const platform of ["linux", "darwin"]) {
-		// given
-		const root = await mkdtemp(join(tmpdir(), `omo-codex-config-git-bash-${platform}-`));
-		const configPath = join(root, "config.toml");
-
-		// when
-		await updateCodexConfig({
-			configPath,
-			repoRoot: "/repo/packages/omo-codex",
-			marketplaceName: "sisyphuslabs",
-			marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
-			pluginNames: ["omo"],
-			platform,
-		});
-
-		// then
-		const content = await readFile(configPath, "utf8");
-		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
-		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = false/);
-	}
-});

package/packages/omo-codex/scripts/install-delegated-command.test.mjs

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildDelegatedOmoInvocation, runDelegatedOmoCommand } from "./install/delegated-command.mjs";
+
+test("#given a lazycodex passthrough command #when delegating to omo #then resets OMO_INVOCATION_NAME so the delegate does not re-enter the lazycodex path", async () => {
+	// given
+	const parsed = { kind: "command", command: "doctor", args: [] };
+	let received;
+	const options = {
+		cwd: "/tmp/project",
+		log: () => {},
+		runCommand: async (command, args, runOptions) => {
+			received = { command, args, runOptions };
+		},
+	};
+
+	// when
+	await runDelegatedOmoCommand(parsed, { ...options });
+
+	// then
+	const invocation = buildDelegatedOmoInvocation(parsed);
+	assert.equal(received.command, invocation.command);
+	assert.deepEqual(received.args, invocation.args);
+	assert.equal(received.runOptions.cwd, "/tmp/project");
+	assert.equal(
+		received.runOptions.env?.OMO_INVOCATION_NAME,
+		"omo",
+		"delegated omo command must run with OMO_INVOCATION_NAME=omo to avoid infinite recursion",
+	);
+});
+
+test("#given OMO_INVOCATION_NAME=lazycodex in the parent env #when delegating a cleanup passthrough #then the child env overrides it to omo", async () => {
+	// given
+	const previous = process.env.OMO_INVOCATION_NAME;
+	process.env.OMO_INVOCATION_NAME = "lazycodex";
+	let received;
+	const parsed = { kind: "command", command: "cleanup", args: [] };
+
+	try {
+		// when
+		await runDelegatedOmoCommand(parsed, {
+			cwd: "/tmp/project",
+			log: () => {},
+			runCommand: async (_command, _args, runOptions) => {
+				received = runOptions;
+			},
+		});
+	} finally {
+		if (previous === undefined) delete process.env.OMO_INVOCATION_NAME;
+		else process.env.OMO_INVOCATION_NAME = previous;
+	}
+
+	// then
+	assert.equal(received.env.OMO_INVOCATION_NAME, "omo");
+});
+
+test("#given a dry-run passthrough #when delegating #then logs the invocation without invoking runCommand", async () => {
+	// given
+	const parsed = { kind: "command", command: "doctor", dryRun: true, args: [] };
+	let logged;
+	let ran = false;
+
+	// when
+	await runDelegatedOmoCommand(parsed, {
+		cwd: "/tmp/project",
+		log: (line) => {
+			logged = line;
+		},
+		runCommand: async () => {
+			ran = true;
+		},
+	});
+
+	// then
+	assert.equal(ran, false);
+	assert.match(logged, /npx --yes --package oh-my-openagent omo doctor/);
+});

package/packages/omo-codex/scripts/install-git-bash-mcp-env.test.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { stampGitBashMcpEnv } from "./install/git-bash-mcp-env.mjs";
+
+const MANIFEST = `${JSON.stringify(
+	{
+		mcpServers: {
+			ast_grep: { command: "node", args: ["../../ast-grep-mcp/dist/cli.js", "mcp"] },
+			git_bash: { command: "node", args: ["../../git-bash-mcp/dist/cli.js", "mcp"] },
+		},
+	},
+	null,
+	"\t",
+)}\n`;
+
+async function createPluginRoot() {
+	const pluginRoot = await mkdtemp(join(tmpdir(), "git-bash-mcp-env-"));
+	await writeFile(join(pluginRoot, ".mcp.json"), MANIFEST);
+	return pluginRoot;
+}
+
+test("#given win32 install with OMO_CODEX_GIT_BASH_PATH set #when stamping #then git_bash server env forwards the override", async (t) => {
+	const pluginRoot = await createPluginRoot();
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	const changed = await stampGitBashMcpEnv({
+		pluginRoot,
+		env: { OMO_CODEX_GIT_BASH_PATH: "D:\\Git\\bin\\bash.exe" },
+		platform: "win32",
+	});
+
+	assert.equal(changed, true);
+	const parsed = JSON.parse(await readFile(join(pluginRoot, ".mcp.json"), "utf8"));
+	assert.deepEqual(parsed.mcpServers.git_bash.env, { OMO_CODEX_GIT_BASH_PATH: "D:\\Git\\bin\\bash.exe" });
+	assert.equal(parsed.mcpServers.ast_grep.env, undefined);
+});
+
+test("#given the override is unset #when stamping #then the manifest stays byte-identical", async (t) => {
+	const pluginRoot = await createPluginRoot();
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	const changed = await stampGitBashMcpEnv({ pluginRoot, env: {}, platform: "win32" });
+
+	assert.equal(changed, false);
+	assert.equal(await readFile(join(pluginRoot, ".mcp.json"), "utf8"), MANIFEST);
+});
+
+test("#given a non-Windows install #when stamping #then the manifest stays byte-identical", async (t) => {
+	const pluginRoot = await createPluginRoot();
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	const changed = await stampGitBashMcpEnv({
+		pluginRoot,
+		env: { OMO_CODEX_GIT_BASH_PATH: "D:\\Git\\bin\\bash.exe" },
+		platform: "darwin",
+	});
+
+	assert.equal(changed, false);
+	assert.equal(await readFile(join(pluginRoot, ".mcp.json"), "utf8"), MANIFEST);
+});
+
+test("#given the override already stamped #when stamping again #then nothing changes", async (t) => {
+	const pluginRoot = await createPluginRoot();
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+	const input = { pluginRoot, env: { OMO_CODEX_GIT_BASH_PATH: "D:\\Git\\bin\\bash.exe" }, platform: "win32" };
+
+	await stampGitBashMcpEnv(input);
+	const afterFirst = await readFile(join(pluginRoot, ".mcp.json"), "utf8");
+	const changedAgain = await stampGitBashMcpEnv(input);
+
+	assert.equal(changedAgain, false);
+	assert.equal(await readFile(join(pluginRoot, ".mcp.json"), "utf8"), afterFirst);
+});
+
+test("#given a manifest without a git_bash server #when stamping #then the manifest stays byte-identical", async (t) => {
+	const pluginRoot = await mkdtemp(join(tmpdir(), "git-bash-mcp-env-"));
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+	const manifest = `${JSON.stringify({ mcpServers: { ast_grep: { command: "node" } } }, null, "\t")}\n`;
+	await writeFile(join(pluginRoot, ".mcp.json"), manifest);
+
+	const changed = await stampGitBashMcpEnv({
+		pluginRoot,
+		env: { OMO_CODEX_GIT_BASH_PATH: "D:\\Git\\bin\\bash.exe" },
+		platform: "win32",
+	});
+
+	assert.equal(changed, false);
+	assert.equal(await readFile(join(pluginRoot, ".mcp.json"), "utf8"), manifest);
+});