oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,19 @@
+import { spawn } from "node:child_process";
+
+export async function defaultRunCommand(command, args, options) {
+	await new Promise((resolvePromise, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			stdio: "inherit",
+		});
+		child.once("error", reject);
+		child.once("exit", (code, signal) => {
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			const suffix = signal ? `signal ${signal}` : `exit code ${code}`;
+			reject(new Error(`${command} ${args.join(" ")} failed in ${options.cwd} with ${suffix}`));
+		});
+	});
+}

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

@@ -0,0 +1,229 @@
+import { copyFile, lstat, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+
+import { escapeRegExp, findTomlSection, removeSetting } from "./toml-editor.mjs";
+
+const LEGACY_AGENT_CONFLICT_KEYS = ["max_threads"];
+const PROJECT_LOCAL_ARTIFACT_PATHS = [
+	".omx",
+	".codex/hooks.json",
+	".codex/agents",
+	".codex/prompts",
+	".codex/skills",
+];
+
+export async function repairNearestProjectLocalCodexArtifacts({ startDirectory, codexHome, now = () => new Date() }) {
+	const project = await findProjectLocalCodexConfigs(startDirectory, codexHome);
+	if (project === null) {
+		return emptyProjectLocalCodexCleanupResult();
+	}
+
+	const artifacts = await collectProjectLocalArtifacts(project.artifactRoots);
+	const configs = [];
+	for (const configPath of project.configPaths) {
+		const original = await readFile(configPath, "utf8");
+		const repair = repairProjectLocalCodexConfigText(original);
+		if (!repair.changed) {
+			configs.push({
+				projectRoot: project.projectRoot,
+				configPath,
+				changed: false,
+				removedKeys: repair.removedKeys,
+			});
+			continue;
+		}
+
+		const backupPath = `${configPath}.backup-${formatBackupTimestamp(now())}`;
+		await copyFile(configPath, backupPath);
+		await writeFile(configPath, `${repair.config.trimEnd()}\n`);
+		configs.push({
+			projectRoot: project.projectRoot,
+			configPath,
+			changed: true,
+			removedKeys: repair.removedKeys,
+			backupPath,
+		});
+	}
+
+	const changedConfigs = configs.filter((config) => config.changed);
+	const nearestChangedConfig = lastValue(changedConfigs);
+	const nearestConfig = lastValue(configs);
+	return {
+		projectRoot: project.projectRoot,
+		configPath: nearestChangedConfig?.configPath ?? nearestConfig?.configPath ?? null,
+		changed: changedConfigs.length > 0,
+		removedKeys: uniqueRemovedKeys(changedConfigs),
+		backupPath: nearestChangedConfig?.backupPath,
+		configs,
+		artifacts,
+	};
+}
+
+export function emptyProjectLocalCodexCleanupResult() {
+	return {
+		projectRoot: null,
+		configPath: null,
+		changed: false,
+		removedKeys: [],
+		configs: [],
+		artifacts: [],
+	};
+}
+
+function uniqueRemovedKeys(configs) {
+	const keys = [];
+	for (const config of configs) {
+		for (const key of config.removedKeys) {
+			if (!keys.includes(key)) keys.push(key);
+		}
+	}
+	return keys;
+}
+
+function lastValue(values) {
+	return values.length > 0 ? (values[values.length - 1] ?? null) : null;
+}
+
+export function repairProjectLocalCodexConfigText(config) {
+	if (!isMultiAgentV2Enabled(config)) return { config, changed: false, removedKeys: [] };
+
+	let nextConfig = config;
+	const removedKeys = [];
+	for (const key of LEGACY_AGENT_CONFLICT_KEYS) {
+		const section = findTomlSection(nextConfig, "agents");
+		if (section === null || !hasSetting(section.text, key)) continue;
+		nextConfig = removeSetting(nextConfig, section, key);
+		removedKeys.push(key);
+	}
+
+	return {
+		config: nextConfig,
+		changed: removedKeys.length > 0,
+		removedKeys,
+	};
+}
+
+async function findProjectLocalCodexConfigs(startDirectory, codexHome) {
+	if (typeof startDirectory !== "string" || startDirectory.includes("\0")) return null;
+
+	const startDirectoryStat = await maybeLstat(startDirectory);
+	if (startDirectoryStat !== null && !startDirectoryStat.isDirectory()) {
+		throw new ProjectLocalCleanupStartDirectoryError(startDirectory);
+	}
+
+	const codexHomeConfigPath = codexHome === undefined ? null : join(resolve(codexHome), "config.toml");
+	let current = resolve(startDirectory);
+	const configPathsFromCwd = [];
+	while (true) {
+		const configPath = join(current, ".codex", "config.toml");
+		if (await isRegularProjectLocalConfig(current, configPath)) {
+			if (codexHomeConfigPath === null || resolve(configPath) !== codexHomeConfigPath) {
+				configPathsFromCwd.push(configPath);
+			}
+		}
+
+		if (await exists(join(current, ".git"))) {
+			return configPathsFromCwd.length === 0
+				? null
+				: {
+						projectRoot: current,
+						configPaths: [...configPathsFromCwd].reverse(),
+						artifactRoots: artifactRootsForConfigPaths(configPathsFromCwd),
+					};
+		}
+
+		const parent = dirname(current);
+		if (parent === current) {
+			const nearestConfigPath = configPathsFromCwd[0];
+			return nearestConfigPath === undefined
+				? null
+				: {
+						projectRoot: dirname(dirname(nearestConfigPath)),
+						configPaths: [nearestConfigPath],
+						artifactRoots: [dirname(dirname(nearestConfigPath))],
+					};
+		}
+		current = parent;
+	}
+}
+
+async function isRegularProjectLocalConfig(directory, configPath) {
+	const codexDirStat = await maybeLstat(join(directory, ".codex"));
+	if (codexDirStat === null || !codexDirStat.isDirectory() || codexDirStat.isSymbolicLink()) return false;
+	const configStat = await maybeLstat(configPath);
+	return configStat !== null && configStat.isFile() && !configStat.isSymbolicLink();
+}
+
+function artifactRootsForConfigPaths(configPaths) {
+	const roots = [];
+	for (const configPath of configPaths) {
+		const root = dirname(dirname(configPath));
+		if (!roots.includes(root)) roots.push(root);
+	}
+	return roots.reverse();
+}
+
+async function collectProjectLocalArtifacts(projectRoots) {
+	const artifacts = [];
+	const seenPaths = new Set();
+	for (const projectRoot of projectRoots) {
+		for (const relativePath of PROJECT_LOCAL_ARTIFACT_PATHS) {
+			const artifactPath = join(projectRoot, relativePath);
+			if (seenPaths.has(artifactPath)) continue;
+			const entryStat = await maybeLstat(artifactPath);
+			if (entryStat === null) continue;
+			seenPaths.add(artifactPath);
+			artifacts.push({
+				relativePath,
+				path: artifactPath,
+				kind: entryStat.isDirectory() ? "directory" : entryStat.isFile() ? "file" : "other",
+			});
+		}
+	}
+	return artifacts;
+}
+
+function isMultiAgentV2Enabled(config) {
+	const featuresSection = findTomlSection(config, "features");
+	if (featuresSection !== null && settingIsBooleanTrue(featuresSection.text, "multi_agent_v2")) return true;
+
+	const multiAgentSection = findTomlSection(config, "features.multi_agent_v2");
+	return multiAgentSection !== null && settingIsBooleanTrue(multiAgentSection.text, "enabled");
+}
+
+function settingIsBooleanTrue(sectionText, key) {
+	return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*true\\s*(?:#.*)?$`, "m").test(sectionText);
+}
+
+function hasSetting(sectionText, key) {
+	return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`, "m").test(sectionText);
+}
+
+function formatBackupTimestamp(date) {
+	return date.toISOString().replace(/[:.]/g, "-");
+}
+
+async function maybeLstat(path) {
+	try {
+		return await lstat(path);
+	} catch (error) {
+		if (nodeErrorCode(error) === "ENOENT") return null;
+		throw error;
+	}
+}
+
+async function exists(path) {
+	return (await maybeLstat(path)) !== null;
+}
+
+function nodeErrorCode(error) {
+	if (!(error instanceof Error) || !("code" in error)) return null;
+	return typeof error.code === "string" ? error.code : null;
+}
+
+class ProjectLocalCleanupStartDirectoryError extends Error {
+	constructor(startDirectory) {
+		super(`Project-local Codex cleanup start path is not a directory: ${startDirectory}`);
+		this.name = "ProjectLocalCleanupStartDirectoryError";
+	}
+}

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

@@ -0,0 +1,14 @@
+import { replaceOrInsertRootSetting } from "./toml-editor.mjs";
+
+const DEFAULT_MODE_REASONING_EFFORT = "high";
+const PLAN_MODE_REASONING_EFFORT = "xhigh";
+
+export function ensureCodexReasoningConfig(config) {
+	let next = replaceOrInsertRootSetting(
+		config,
+		"model_reasoning_effort",
+		JSON.stringify(DEFAULT_MODE_REASONING_EFFORT),
+	);
+	next = replaceOrInsertRootSetting(next, "plan_mode_reasoning_effort", JSON.stringify(PLAN_MODE_REASONING_EFFORT));
+	return next;
+}

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

@@ -0,0 +1,54 @@
+import { cp, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { join, sep } from "node:path";
+
+import { rewriteCachedMcpManifest } from "./cache.mjs";
+
+const INSTALLED_MARKETPLACES_DIR = ".tmp/marketplaces";
+
+export async function writeInstalledMarketplaceSnapshot({ codexHome, marketplace, plugins }) {
+	const marketplaceRoot = installedMarketplaceRoot(codexHome, marketplace.name);
+	await mkdir(marketplaceRoot, { recursive: true });
+	await writeMarketplaceManifest(marketplaceRoot, marketplace);
+
+	const snapshotPlugins = [];
+	for (const plugin of plugins) {
+		snapshotPlugins.push(await writeSnapshotPlugin(marketplaceRoot, plugin));
+	}
+	return snapshotPlugins;
+}
+
+export function installedMarketplaceRoot(codexHome, marketplaceName) {
+	return join(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
+}
+
+async function writeMarketplaceManifest(marketplaceRoot, marketplace) {
+	const manifestDir = join(marketplaceRoot, ".agents", "plugins");
+	await mkdir(manifestDir, { recursive: true });
+	const tempPath = join(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
+	await writeFile(tempPath, `${JSON.stringify(marketplace, null, "\t")}\n`);
+	await rename(tempPath, join(manifestDir, "marketplace.json"));
+}
+
+async function writeSnapshotPlugin(marketplaceRoot, plugin) {
+	const pluginsDir = join(marketplaceRoot, "plugins");
+	await mkdir(pluginsDir, { recursive: true });
+	const targetPath = join(pluginsDir, plugin.name);
+	const tempPath = join(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
+	await rm(tempPath, { recursive: true, force: true });
+	await cp(plugin.sourcePath, tempPath, {
+		recursive: true,
+		filter: (source) => shouldCopyMarketplaceSourcePath(source, plugin.sourcePath),
+	});
+	await rm(targetPath, { recursive: true, force: true });
+	await rename(tempPath, targetPath);
+	await rewriteCachedMcpManifest(targetPath, plugin.sourcePath);
+	return { name: plugin.name, path: targetPath };
+}
+
+function shouldCopyMarketplaceSourcePath(path, root) {
+	const relative = path === root ? "" : path.slice(root.length + sep.length);
+	if (relative === "") return true;
+	const parts = relative.split(sep);
+	if (parts[parts.length - 1] === "package-lock.json") return false;
+	return !parts.some((part) => part === ".git" || part === "node_modules");
+}

package/packages/omo-codex/scripts/install/source-package-build.mjs

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const PACKAGED_INSTALLER_PACKAGE_NAMES = new Set([
+	"@code-yeongyu/lazycodex",
+	"@code-yeongyu/lazycodex-ai",
+	"lazycodex",
+	"lazycodex-ai",
+	"oh-my-opencode",
+	"oh-my-openagent",
+]);
+
+export async function shouldBuildSourcePackages(repoRoot) {
+	if (existsSync(join(repoRoot, "src", "index.ts"))) return true;
+	const packageJsonPath = join(repoRoot, "package.json");
+	if (!existsSync(packageJsonPath)) return true;
+	const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	return !PACKAGED_INSTALLER_PACKAGE_NAMES.has(packageJson?.name);
+}

package/packages/omo-codex/scripts/install/toml-editor.mjs

@@ -0,0 +1,64 @@
+export function findTomlSection(config, header) {
+	const headerLine = `[${header}]`;
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let start = -1;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const trimmed = line.trim();
+		if (start === -1) {
+			if (trimmed === headerLine) start = offset;
+		} else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+			return { start, end: offset, text: config.slice(start, offset) };
+		}
+		offset += line.length;
+	}
+	if (start === -1) return null;
+	return { start, end: config.length, text: config.slice(start) };
+}
+
+export function replaceOrInsertSetting(config, section, key, value) {
+	const linePattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, "m");
+	const replacement = linePattern.test(section.text)
+		? section.text.replace(linePattern, `${key} = ${value}`)
+		: insertSetting(section.text, key, value);
+	return config.slice(0, section.start) + replacement + config.slice(section.end);
+}
+
+export function removeSetting(config, section, key) {
+	const linePattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=.*(?:\\n|$)`, "m");
+	const replacement = section.text.replace(linePattern, "");
+	return config.slice(0, section.start) + replacement + config.slice(section.end);
+}
+
+export function replaceOrInsertRootSetting(config, key, value) {
+	const sectionStart = findFirstTableStart(config);
+	const root = config.slice(0, sectionStart);
+	const suffix = config.slice(sectionStart);
+	const linePattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, "m");
+	const replacement = linePattern.test(root)
+		? root.replace(linePattern, `${key} = ${value}`)
+		: `${root.trimEnd()}${root.trimEnd().length > 0 ? "\n" : ""}${key} = ${value}\n`;
+	if (suffix.length === 0) return replacement;
+	return `${replacement.trimEnd()}\n\n${suffix.trimStart()}`;
+}
+
+export function appendBlock(config, block) {
+	const prefix = config.trimEnd();
+	return `${prefix}${prefix.length > 0 ? "\n\n" : ""}${block.trimEnd()}\n`;
+}
+
+function findFirstTableStart(config) {
+	const match = config.match(/^[[].*$/m);
+	return match?.index ?? config.length;
+}
+
+function insertSetting(sectionText, key, value) {
+	const lines = sectionText.split("\n");
+	lines.splice(1, 0, `${key} = ${value}`);
+	return lines.join("\n");
+}
+
+export function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -0,0 +1,15 @@
+import { constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+
+export async function exists(path) {
+	try {
+		await access(path, fsConstants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, readFile, readlink, rm, symlink, 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";
+
+const legacyCodexPluginMarketplace = ["code", "yeongyu", "codex", "plugins"].join("-");
+
+test(
+	"#given bundled agent roles and stale legacy links #when installing locally #then relinks Codex agents to marketplace snapshot",
+	{ skip: process.platform === "win32" ? "Windows copies agent files instead of symlinking them" : false },
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		for (const agentName of ["explorer", "librarian", "plan"]) {
+			await writeFile(join(agentsRoot, `${agentName}.toml`), `name = "${agentName}"\n`);
+		}
+		await mkdir(join(codexHome, "agents"), { recursive: true });
+		await symlink(
+			join(codexHome, "plugins", "cache", legacyCodexPluginMarketplace, "omo", "0.1.0", "components", "ultrawork", "agents", "explorer.toml"),
+			join(codexHome, "agents", "explorer.toml"),
+		);
+
+		const result = await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		assert.equal(result.installed.length, 1);
+		const snapshotPluginPath = join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo");
+		for (const agentName of ["explorer", "librarian", "plan"]) {
+			const agentPath = join(codexHome, "agents", `${agentName}.toml`);
+			assert.equal((await lstat(agentPath)).isSymbolicLink(), true);
+			assert.equal(await readlink(agentPath), join(snapshotPluginPath, "components", "ultrawork", "agents", `${agentName}.toml`));
+			assert.equal(await readFile(agentPath, "utf8"), `name = "${agentName}"\n`);
+		}
+
+		const installedAgents = JSON.parse(await readFile(join(snapshotPluginPath, ".installed-agents.json"), "utf8"));
+		assert.deepEqual(installedAgents.agents.sort(), [
+			join(codexHome, "agents", "explorer.toml"),
+			join(codexHome, "agents", "librarian.toml"),
+			join(codexHome, "agents", "plan.toml"),
+		]);
+	},
+);
+
+test(
+	"#given local sisyphuslabs install #when plugin cache is pruned #then agent links still resolve through marketplace snapshot",
+	{ skip: process.platform === "win32" ? "Windows copies agent files instead of symlinking them" : false },
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		await writeFile(join(agentsRoot, "explorer.toml"), 'name = "explorer"\n');
+		const snapshotRoot = join(codexHome, ".tmp", "marketplaces", "sisyphuslabs");
+		await mkdir(join(snapshotRoot, ".git"), { recursive: true });
+		await writeFile(join(snapshotRoot, ".git", "config"), "[remote \"origin\"]\n");
+		await writeFile(join(snapshotRoot, ".codex-marketplace-install.json"), '{"source_type":"git"}\n');
+
+		const result = await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		const pluginPath = result.installed[0].path;
+		await rm(pluginPath, { recursive: true, force: true });
+
+		const agentPath = join(codexHome, "agents", "explorer.toml");
+		assert.equal(
+			await readlink(agentPath),
+			join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", "components", "ultrawork", "agents", "explorer.toml"),
+		);
+		assert.equal(await readFile(agentPath, "utf8"), 'name = "explorer"\n');
+		assert.equal(await readFile(join(snapshotRoot, ".git", "config"), "utf8"), "[remote \"origin\"]\n");
+		assert.equal(await readFile(join(snapshotRoot, ".codex-marketplace-install.json"), "utf8"), '{"source_type":"git"}\n');
+	},
+);

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

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { linkCachedPluginBins } from "./install/cache.mjs";
+import { makeTempDir, writeJson } from "./install-test-fixtures.mjs";
+
+test("#given Windows platform #when linking cached plugin bins #then writes command shims", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+
+	await mkdir(pluginRoot, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/alpha",
+		bin: {
+			alpha: "./dist/cli.js",
+		},
+	});
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+
+	const linked = await linkCachedPluginBins({ binDir, pluginRoot, platform: "win32" });
+
+	assert.deepEqual(linked, [{ name: "alpha", path: join(binDir, "alpha.cmd"), target: join(pluginRoot, "dist", "cli.js") }]);
+	const shim = await readFile(join(binDir, "alpha.cmd"), "utf8");
+	assert.match(shim, /@echo off/);
+	assert.match(shim, new RegExp(`node "${join(pluginRoot, "dist", "cli.js").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}" %\\*`));
+});
+
+test("#given existing custom Windows command shim #when linking bins #then rejects without overwriting", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+
+	await mkdir(pluginRoot, { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/alpha",
+		bin: {
+			alpha: "./dist/cli.js",
+		},
+	});
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(join(binDir, "alpha.cmd"), "@echo off\r\necho custom\r\n");
+
+	await assert.rejects(
+		linkCachedPluginBins({ binDir, pluginRoot, platform: "win32" }),
+		/already exists and is not a generated command shim/,
+	);
+	assert.match(await readFile(join(binDir, "alpha.cmd"), "utf8"), /echo custom/);
+});
+
+test("#given managed legacy Codex component symlink #when linking bins #then removes stale symlink and writes OMO bin", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const oldTarget = join(root, "codex-home", "plugins", "cache", "legacy-market", "omo", "0.0.1", "components", "rules", "dist", "cli.js");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "codex-home", "plugins", "cache", "legacy-market", "omo", "0.0.1", "components", "rules", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(oldTarget, "#!/usr/bin/env node\n");
+	await symlink(oldTarget, join(binDir, "codex-rules"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	await assert.rejects(readlink(join(binDir, "codex-rules")));
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
+});
+
+test("#given user-owned legacy Codex symlink #when linking bins #then preserves the user symlink", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const userTarget = join(root, "user-tools", "codex-rules");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "user-tools"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(userTarget, "#!/usr/bin/env node\n");
+	await symlink(userTarget, join(binDir, "codex-rules"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	assert.equal(await readlink(join(binDir, "codex-rules")), userTarget);
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
+});
+
+test("#given user-owned legacy Codex symlink with component-like target #when linking bins #then preserves it", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const userTarget = join(root, "workspace", "components", "rules", "dist", "cli.js");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "workspace", "components", "rules", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(userTarget, "#!/usr/bin/env node\n");
+	await symlink(userTarget, join(binDir, "codex-rules"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	assert.equal(await readlink(join(binDir, "codex-rules")), userTarget);
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
+});

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

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installCachedPlugin } from "./install/cache.mjs";
+import { makeTempDir } from "./install-test-fixtures.mjs";
+
+test("#given source plugin has a stale npm lockfile #when caching plugin #then lockfile is regenerated rather than copied", async () => {
+	// given
+	const root = await makeTempDir();
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(root, "plugin");
+	await mkdir(sourceRoot, { recursive: true });
+	await writeFile(join(sourceRoot, "package.json"), JSON.stringify({ name: "@scope/omo", version: "0.1.0" }));
+	await writeFile(join(sourceRoot, "package-lock.json"), '{"packages":{"components/ulw-loop":{}}}\n');
+
+	// when
+	const installed = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "debug",
+		name: "omo",
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+		runCommand: async () => {},
+	});
+
+	// then
+	await assert.rejects(stat(join(installed.path, "package-lock.json")));
+});