oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/scripts/install-generated-bundle.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const scriptsDir = dirname(fileURLToPath(import.meta.url));
+const entrypointPath = join(scriptsDir, "install-local.mjs");
+
+test("#given the stable installer entrypoint #when inspecting imports #then it delegates to generated output", async () => {
+	// given
+	const entrypoint = await readFile(entrypointPath, "utf8");
+
+	// when
+	const importsForkModules = entrypoint.includes("./install/");
+	const importsGeneratedBundle = entrypoint.includes("./install-dist/install-local.mjs");
+
+	// then
+	assert.equal(importsForkModules, false);
+	assert.equal(importsGeneratedBundle, true);
+});
+
+test("#given generated installer output #when importing install-local #then public installer API comes from the bundle", async () => {
+	// given
+	const module = await import("./install-local.mjs");
+
+	// when
+	const exportedNames = ["installMarketplaceLocally", "resolveCodexInstallerBinDir", "resolveDefaultRepoRoot"];
+
+	// then
+	for (const name of exportedNames) {
+		assert.equal(typeof module[name], "function", `${name} must be exported`);
+	}
+});
+
+test("#given generated installer output #when importing direct bundle #then compatibility helper APIs are exported", async () => {
+	// given
+	const module = await import(`./install-dist/install-local.mjs?helpers=${Date.now()}`);
+
+	// when
+	const exportedNames = [
+		"installCachedPlugin",
+		"linkCachedPluginBins",
+		"linkRootRuntimeBin",
+		"readCodexModelCatalog",
+		"repairNearestProjectLocalCodexArtifacts",
+		"stampGitBashMcpEnv",
+		"updateCodexConfig",
+	];
+
+	// then
+	for (const name of exportedNames) {
+		assert.equal(typeof module[name], "function", `${name} must be exported`);
+	}
+});

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

@@ -4,12 +4,11 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 
-import { stampGitBashMcpEnv } from "./install/git-bash-mcp-env.mjs";
+import { stampGitBashMcpEnv } from "./install-dist/install-local.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"] },
 		},
 	},
@@ -36,7 +35,7 @@ test("#given win32 install with OMO_CODEX_GIT_BASH_PATH set #when stamping #then
 	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);
+	assert.equal(Object.hasOwn(parsed.mcpServers, "ast_grep"), false);
 });
 
 test("#given the override is unset #when stamping #then the manifest stays byte-identical", async (t) => {
@@ -79,7 +78,7 @@ test("#given the override already stamped #when stamping again #then nothing cha
 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`;
+	const manifest = `${JSON.stringify({ mcpServers: { codegraph: { command: "node" } } }, null, "\t")}\n`;
 	await writeFile(join(pluginRoot, ".mcp.json"), manifest);
 
 	const changed = await stampGitBashMcpEnv({

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

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
 
-import { assertHookCommandTargets, findMissingHookCommandTargets } from "./install/hook-targets.mjs";
+import { assertHookCommandTargets, findMissingHookCommandTargets } from "./install-dist/install-local.mjs";
 
 const HOOKS_MANIFEST = {
 	hooks: {

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

@@ -1,248 +1,42 @@
 #!/usr/bin/env node
-import { realpathSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { existsSync, realpathSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import {
-	installCachedPlugin,
-	linkCachedPluginBins,
-	linkRootRuntimeBin,
-	pruneMarketplaceCache,
-	pruneMarketplacePluginCaches,
-} from "./install/cache.mjs";
-import { agentSourceRootsForInstall } from "./install/agent-source-roots.mjs";
-import { capturePreservedAgentReasoning, capturePreservedAgentServiceTier, linkCachedPluginAgents } from "./install/agents.mjs";
-import { writeCachedMarketplaceManifest } from "./install/cached-marketplace-manifest.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 {
-	readMarketplace,
-	readPluginManifest,
-	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 {
-	readDistributionManifest,
-	resolveLazyCodexPluginVersion,
-	stampLazyCodexPluginVersion,
-	writeLazyCodexInstallSnapshot,
-} from "./install/lazycodex-version-stamp.mjs";
-import { shouldBuildSourcePackages } from "./install/source-package-build.mjs";
-import { runLazyCodexManualUpdate } from "../plugin/scripts/auto-update.mjs";
-export { nonEmptyEnvValue, resolveCodexInstallerBinDir } from "./install/bin-dir.mjs";
-import { nonEmptyEnvValue, resolveCodexInstallerBinDir } from "./install/bin-dir.mjs";
+const entrypointPath = fileURLToPath(import.meta.url);
+const scriptsDir = dirname(entrypointPath);
+const generatedEntrypointPath = join(scriptsDir, "install-dist", "install-local.mjs");
 
-export async function installMarketplaceLocally(options = {}) {
-	const repoRoot = resolve(options.repoRoot ?? process.cwd());
-	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"),
-	});
-	const distributionManifest = await readDistributionManifest(repoRoot);
-	const installed = [];
-	const pluginSources = [];
-	const agentConfigs = new Map();
-
-	for (const entry of marketplace.plugins) {
-		const sourcePath = resolvePluginSource(codexPackageRoot, entry, { pathOverride: "./plugin" });
-		const manifest = await readPluginManifest(sourcePath);
-		if (manifest.name !== entry.name) {
-			throw new Error(
-				`plugin manifest name ${JSON.stringify(manifest.name)} does not match marketplace name ${JSON.stringify(entry.name)}`,
-			);
-		}
-		const version = resolveLazyCodexPluginVersion({ manifestVersion: manifest.version, marketplaceName: marketplace.name, pluginName: entry.name, distributionManifest });
-		validatePathSegment(version, "plugin version");
+function resolveDefaultRepoRoot() {
+	return resolve(scriptsDir, "..", "..", "..");
+}
 
-		log(`Building ${entry.name}@${version}`);
-		const plugin = await installCachedPlugin({
-			buildSource,
-			codexHome,
-			marketplaceName: marketplace.name,
-			name: entry.name,
-			runCommand,
-			sourcePath,
-			version,
-		});
-		if (marketplace.name === "sisyphuslabs" && plugin.name === "omo") {
-			await stampLazyCodexPluginVersion({ pluginRoot: plugin.path, version });
-			await writeLazyCodexInstallSnapshot({ pluginRoot: plugin.path, distributionManifest });
-		}
-		const binLinks = await linkCachedPluginBins({ binDir, pluginRoot: plugin.path, platform });
-		for (const link of binLinks) {
-			log(`Linked ${link.name} -> ${link.target}`);
-		}
-		if (marketplace.name === "sisyphuslabs" && plugin.name === "omo") {
-			const runtimeLink = await linkRootRuntimeBin({ binDir, codexHome, repoRoot, platform });
-			if (runtimeLink !== null) log(`Linked ${runtimeLink.name} -> ${runtimeLink.target}`);
-			else
-				log(
-					`Warning: skipped the omo runtime wrapper because ${join(repoRoot, "dist", "cli", "index.js")} is missing; omo sparkshell/ulw-loop commands will be unavailable until a package shipping dist/cli is installed`,
-				);
-		}
-		pluginSources.push({ name: entry.name, sourcePath });
-		installed.push(plugin);
-	}
+function ensureGeneratedInstaller() {
+	if (existsSync(generatedEntrypointPath)) return;
 
-	const preservedReasoning = await capturePreservedAgentReasoning({ codexHome });
-	const preservedServiceTier = await capturePreservedAgentServiceTier({ codexHome });
-	const agentSourceRoots = await agentSourceRootsForInstall({ codexHome, marketplace, installed, pluginSources });
-	for (const plugin of installed) {
-		const pluginRoot = agentSourceRoots.get(plugin.name) ?? plugin.path;
-		const agentLinks = await linkCachedPluginAgents({ codexHome, pluginRoot, platform, preservedReasoning, preservedServiceTier });
-		for (const link of agentLinks) {
-			log(`Linked agent ${link.name} -> ${link.target}`);
-			const agentName = agentNameFromToml(link.name);
-			agentConfigs.set(agentName, { name: agentName, configFile: `./agents/${link.name}` });
-		}
+	const repoRoot = resolveDefaultRepoRoot();
+	const sourceEntrypoint = join(repoRoot, "packages", "omo-codex", "src", "install", "install-local-cli.ts");
+	const buildScript = join(repoRoot, "script", "build-codex-install.ts");
+	if (!existsSync(sourceEntrypoint) || !existsSync(buildScript)) {
+		throw new Error(`Missing generated Codex installer bundle: ${generatedEntrypointPath}`);
 	}
 
-	const pluginNames = marketplace.plugins.map((plugin) => plugin.name);
-	const trustedHookStates = (
-		await Promise.all(
-			installed.map((plugin) =>
-				trustedHookStatesForPlugin({
-					marketplaceName: marketplace.name,
-					pluginName: plugin.name,
-					pluginRoot: plugin.path,
-				}),
-			),
-		)
-	).flat();
-	await pruneMarketplaceCache({ codexHome, marketplaceName: marketplace.name, keepPluginNames: pluginNames });
-	for (const legacyMarketplaceName of legacyCacheMarketplaces(marketplace.name)) {
-		await pruneMarketplacePluginCaches({ codexHome, marketplaceName: legacyMarketplaceName, pluginNames });
-	}
-	const marketplaceRoot = join(codexHome, "plugins", "cache", marketplace.name);
-	await writeCachedMarketplaceManifest({
-		marketplaceName: marketplace.name,
-		marketplaceRoot,
-		plugins: installed,
-	});
-	await updateCodexConfig({
-		configPath: join(codexHome, "config.toml"),
-		repoRoot: codexPackageRoot,
-		marketplaceName: marketplace.name,
-		marketplaceSource: { sourceType: "local", source: marketplaceRoot },
-		pluginNames,
-		platform,
-		gitBashEnabled: platform === "win32" && gitBashResolution.found,
-		trustedHookStates,
-		agentConfigs: [...agentConfigs.values()].sort((left, right) => left.name.localeCompare(right.name)),
-		autonomousPermissions: options.autonomousPermissions !== false,
+	const result = spawnSync("bun", ["run", "build:codex-install"], {
+		cwd: repoRoot,
+		stdio: "inherit",
+		shell: false,
 	});
-	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, 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();
+	if (result.status !== 0) {
+		throw new Error(`bun run build:codex-install failed with exit code ${result.status ?? "unknown"}`);
 	}
 }
 
-function formatUnknownError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function agentNameFromToml(fileName) {
-	return fileName.endsWith(".toml") ? fileName.slice(0, -".toml".length) : fileName;
-}
-
-function legacyCacheMarketplaces(marketplaceName) {
-	return marketplaceName === "sisyphuslabs" ? ["lazycodex", ["code", "yeongyu", "codex", "plugins"].join("-")] : [];
-}
-
-export function resolveDefaultRepoRoot() {
-	return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-}
-
-async function main() {
-	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;
-	}
-	if (parsed.kind === "update") {
-		if (parsed.repoRoot) {
-			if (parsed.dryRun) {
-				console.log(`node ${fileURLToPath(import.meta.url)} install --repo-root=${parsed.repoRoot}`);
-				return;
-			}
-			const result = await installMarketplaceLocally({
-				repoRoot: resolve(parsed.repoRoot),
-				autonomousPermissions: true,
-			});
-			console.log(`Installed ${result.installed.length} plugin(s) from ${result.marketplaceName}.`);
-			return;
-		}
-		const exitCode = await runLazyCodexManualUpdate({ env: process.env, dryRun: parsed.dryRun, log: console.log });
-		process.exitCode = exitCode;
-		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}.`);
+async function loadGeneratedInstaller() {
+	ensureGeneratedInstaller();
+	await mkdir(dirname(generatedEntrypointPath), { recursive: true });
+	return import(new URL("./install-dist/install-local.mjs", import.meta.url).href);
 }
 
 function resolveEntrypointPath(path) {
@@ -256,12 +50,35 @@ function resolveEntrypointPath(path) {
 
 function isEntrypointInvocation(invokedPath) {
 	if (!invokedPath) return false;
-	return resolveEntrypointPath(invokedPath) === resolveEntrypointPath(fileURLToPath(import.meta.url));
+	return resolveEntrypointPath(invokedPath) === resolveEntrypointPath(entrypointPath);
 }
 
+const generatedInstaller = await loadGeneratedInstaller();
+
+export const installMarketplaceLocally = generatedInstaller.installMarketplaceLocally;
+export const resolveCodexInstallerBinDir = generatedInstaller.resolveCodexInstallerBinDir;
+export const PASSTHROUGH_COMMANDS = generatedInstaller.PASSTHROUGH_COMMANDS;
+export const buildDelegatedOmoInvocation = generatedInstaller.buildDelegatedOmoInvocation;
+export const formatLazyCodexInstallHelp = generatedInstaller.formatLazyCodexInstallHelp;
+export const parseLazyCodexInstallCliArgs = generatedInstaller.parseLazyCodexInstallCliArgs;
+export const runDelegatedOmoCommand = generatedInstaller.runDelegatedOmoCommand;
+export { resolveDefaultRepoRoot };
+
 if (isEntrypointInvocation(process.argv[1] ?? "")) {
-	main().catch((error) => {
-		console.error(error instanceof Error ? error.message : error);
-		process.exitCode = 1;
-	});
+	generatedInstaller
+		.runLazyCodexInstallLocalCli({
+			argv: process.argv.slice(2),
+			defaultRepoRoot: resolveDefaultRepoRoot(),
+			entrypointPath,
+			cwd: process.cwd(),
+			env: process.env,
+			log: console.log,
+		})
+		.then((exitCode) => {
+			process.exitCode = exitCode;
+		})
+		.catch((error) => {
+			console.error(error instanceof Error ? error.message : error);
+			process.exitCode = 1;
+		});
 }

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

@@ -18,6 +18,10 @@ function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+function toPosixPath(value) {
+	return value.replaceAll("\\", "/");
+}
+
 test("#given default CODEX_HOME #when resolving local installer bin dir without override #then preserves user local bin precedence", () => {
 	const homeDir = join(tmpdir(), "omo-codex-home-default");
 	const codexHome = join(homeDir, ".codex");
@@ -60,7 +64,10 @@ test("#given custom CODEX_HOME and PATH without omo #when installing locally wit
 	assert.equal(result.installed.length, 1);
 	const wrapper = await readFile(join(codexHome, "bin", "omo"), "utf8");
 	assert.match(wrapper, /OMO_GENERATED_RUNTIME_WRAPPER/);
-	assert.match(wrapper, new RegExp(escapeRegExp(escapePosixDoubleQuoted(join(repoRoot, "dist", "cli", "index.js")))));
+	assert.match(
+		wrapper,
+		new RegExp(escapeRegExp(escapePosixDoubleQuoted(toPosixPath(join(repoRoot, "dist", "cli", "index.js"))))),
+	);
 	assert.match(wrapper, /CODEX_HOME/);
 	assert.match(wrapper, /OMO_SPARKSHELL_APP_SERVER_SOCKET/);
 	assert.match(wrapper, /omo-ulw-loop/);

package/packages/omo-codex/scripts/install-marketplace-cache.test.mjs

@@ -77,7 +77,7 @@ test("#given local marketplace #when installing #then copies versioned plugins a
 	assert.equal((await stat(join(alphaCacheRoot, "dist", "cli.js"))).isFile(), true);
 	assert.equal(await readlink(join(binDir, "alpha")), join(alphaCacheRoot, "dist", "cli.js"));
 	const alphaMcp = JSON.parse(await readFile(join(alphaCacheRoot, ".mcp.json"), "utf8"));
-	const sharedMcpCli = join(alphaCacheRoot, "mcp", "shared", "dist", "cli.js");
+	const sharedMcpCli = join(codexPackageRoot, "shared-lsp", "dist", "cli.js");
 	assert.deepEqual(alphaMcp.mcpServers.alpha.args, [join(alphaCacheRoot, "dist", "cli.js"), "mcp"]);
 	assert.deepEqual(alphaMcp.mcpServers.shared.args, [sharedMcpCli, "mcp"]);
 	assert.equal((await stat(sharedMcpCli)).isFile(), true);
@@ -152,11 +152,11 @@ test("#given sisyphuslabs marketplace #when installing #then registers the local
 	);
 	assert.deepEqual(marketplace.plugins, [{ name: "omo", source: { source: "local", path: "./omo/0.1.0" } }]);
 	const cachedMcp = JSON.parse(await readFile(join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "0.1.0", ".mcp.json"), "utf8"));
-	assert.equal(cachedMcp.mcpServers.lsp.args[0], join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "0.1.0", "mcp", "lsp", "dist", "cli.js"));
+	assert.equal(cachedMcp.mcpServers.lsp.args[0], join(repoRoot, "packages", "lsp-tools-mcp", "dist", "cli.js"));
 	assert.equal((await stat(cachedMcp.mcpServers.lsp.args[0])).isFile(), true);
 	const snapshotPluginRoot = join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo");
 	const snapshotMcp = JSON.parse(await readFile(join(snapshotPluginRoot, ".mcp.json"), "utf8"));
-	assert.equal(snapshotMcp.mcpServers.lsp.args[0], join(snapshotPluginRoot, "mcp", "lsp", "dist", "cli.js"));
+	assert.equal(snapshotMcp.mcpServers.lsp.args[0], join(repoRoot, "packages", "lsp-tools-mcp", "dist", "cli.js"));
 	assert.equal((await stat(snapshotMcp.mcpServers.lsp.args[0])).isFile(), true);
 	await assert.rejects(stat(join(codexHome, "plugins", "cache", legacyCodexPluginMarketplace, "omo")), /code: 'ENOENT'|ENOENT/);
 });