oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { resolveDefaultRepoRoot } from "./install-local.mjs";
+
+test("#given published lazycodex bin runs outside the package #when resolving default repo root #then uses installer location", () => {
+	// given
+	const scriptsDir = dirname(fileURLToPath(import.meta.url));
+
+	// when
+	const repoRoot = resolveDefaultRepoRoot();
+
+	// then
+	assert.equal(repoRoot, join(scriptsDir, "..", "..", ".."));
+});
+
+test("#given lazycodex version flag #when running the Node installer entrypoint #then prints the package version", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const manifestPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--version"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, `lazycodex-ai ${manifest.version}`);
+});
+
+test("#given lazycodex runs through an npm bin symlink #when running the Node installer entrypoint #then it still executes main", { skip: process.platform === "win32" }, () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const manifestPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	const tempDir = mkdtempSync(join(tmpdir(), "lazycodex-bin-"));
+	const binPath = join(tempDir, "lazycodex-ai");
+
+	try {
+		symlinkSync(scriptPath, binPath);
+
+		// when
+		const output = execFileSync(process.execPath, [binPath, "--version"], {
+			encoding: "utf8",
+		}).trim();
+
+		// then
+		assert.equal(output, `lazycodex-ai ${manifest.version}`);
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});
+
+test("#given dry-run install flags #when running the Node installer entrypoint #then prints delegated codex install command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "install", "--no-tui", "--codex-autonomous"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo install --platform=codex --no-tui --codex-autonomous");
+});
+
+test("#given dry-run doctor #when running the Node installer entrypoint #then prints delegated doctor command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--dry-run", "doctor"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo doctor");
+});
+
+test("#given dry-run cleanup #when running the Node installer entrypoint #then prints delegated codex cleanup command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "cleanup", "--project", "/tmp/lazycodex-qa"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo cleanup --platform=codex --project /tmp/lazycodex-qa");
+});
+
+test("#given the invoking argv path disappears #when importing the Node installer module #then the entrypoint guard does not throw", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const tempDir = mkdtempSync(join(tmpdir(), "lazycodex-import-"));
+	const missingArgvPath = join(tempDir, "missing-entrypoint.mjs");
+	const probePath = join(tempDir, "probe.mjs");
+
+	try {
+		writeFileSync(
+			probePath,
+			[
+				`process.argv[1] = ${JSON.stringify(missingArgvPath)};`,
+				`await import(${JSON.stringify(pathToFileURL(scriptPath).href)});`,
+			].join("\n"),
+		);
+
+		// when
+		const output = execFileSync(process.execPath, [probePath], {
+			encoding: "utf8",
+		}).trim();
+
+		// then
+		assert.equal(output, "");
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});

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

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+	installCachedPlugin,
+	linkCachedPluginBins,
+	pruneMarketplaceCache,
+	pruneMarketplacePluginCaches,
+} 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";
+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 { 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];
+
+export function resolveCodexInstallerBinDir(options = {}) {
+	const homeDir = resolve(options.homeDir ?? homedir());
+	const env = options.env ?? process.env;
+	const explicitBinDir = nonEmptyEnvValue(env, "CODEX_LOCAL_BIN_DIR");
+	if (explicitBinDir !== undefined) return explicitBinDir;
+
+	const codexHome = resolve(options.codexHome ?? nonEmptyEnvValue(env, "CODEX_HOME") ?? join(homeDir, ".codex"));
+	const defaultCodexHome = resolve(join(homeDir, ".codex"));
+	return codexHome === defaultCodexHome ? join(homeDir, ".local", "bin") : join(codexHome, "bin");
+}
+
+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 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 = manifest.version ?? "local";
+		validatePathSegment(version, "plugin version");
+
+		log(`Building ${entry.name}@${version}`);
+		const plugin = await installCachedPlugin({
+			buildSource,
+			codexHome,
+			marketplaceName: marketplace.name,
+			name: entry.name,
+			runCommand,
+			sourcePath,
+			version,
+		});
+		const binLinks = await linkCachedPluginBins({ binDir, pluginRoot: plugin.path, platform });
+		for (const link of binLinks) {
+			log(`Linked ${link.name} -> ${link.target}`);
+		}
+		pluginSources.push({ name: entry.name, sourcePath });
+		installed.push(plugin);
+	}
+
+	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 });
+		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 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,
+		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, 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) {
+	return fileName.endsWith(".toml") ? fileName.slice(0, -".toml".length) : fileName;
+}
+
+async function agentSourceRootsForInstall({ codexHome, marketplace, installed, pluginSources }) {
+	if (marketplace.name !== "sisyphuslabs") {
+		return new Map(installed.map((plugin) => [plugin.name, plugin.path]));
+	}
+	const snapshotPlugins = await writeInstalledMarketplaceSnapshot({
+		codexHome,
+		marketplace,
+		plugins: pluginSources,
+	});
+	return new Map(snapshotPlugins.map((plugin) => [plugin.name, plugin.path]));
+}
+
+async function writeCachedMarketplaceManifest({ marketplaceName, marketplaceRoot, plugins }) {
+	const marketplaceDir = join(marketplaceRoot, ".agents", "plugins");
+	await mkdir(marketplaceDir, { recursive: true });
+	await writeFile(
+		join(marketplaceDir, "marketplace.json"),
+		`${JSON.stringify(
+			{
+				name: marketplaceName,
+				plugins: plugins.map((plugin) => ({
+					name: plugin.name,
+					source: { source: "local", path: `./${plugin.name}/${plugin.version}` },
+				})),
+			},
+			null,
+			"\t",
+		)}\n`,
+	);
+}
+
+function nonEmptyEnvValue(env, key) {
+	const value = env[key];
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	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 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}.`);
+}
+
+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;
+	});
+}