oh-my-opencode 4.7.4 → 4.8.0

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

@@ -0,0 +1,239 @@
+import { chmod, lstat, mkdir, readFile, readdir, readlink, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+
+import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
+import { removeLegacyCodexComponentBins } from "./legacy-bins.mjs";
+
+const RESERVED_NESTED_BIN_NAMES = new Set(["omo", "lazycodex", "lazycodex-ai", "oh-my-opencode", "oh-my-openagent"]);
+const RUNTIME_WRAPPER_MARKER = "OMO_GENERATED_RUNTIME_WRAPPER";
+
+export async function linkCachedPluginBins({ binDir, pluginRoot, platform = process.platform }) {
+	const binLinks = await discoverPackageBins(pluginRoot);
+	await mkdir(binDir, { recursive: true });
+	await removeLegacyCodexComponentBins(binDir, platform);
+	const linked = [];
+	for (const link of binLinks) {
+		const linkPath = await linkCachedPluginBin(binDir, link, platform);
+		linked.push({ name: link.name, path: linkPath, target: link.target });
+	}
+	return linked;
+}
+
+export async function linkRootRuntimeBin({ binDir, codexHome, repoRoot, platform = process.platform }) {
+	const cliPath = join(repoRoot, "dist", "cli", "index.js");
+	if (!(await isFile(cliPath))) return null;
+
+	await mkdir(binDir, { recursive: true });
+	if (platform === "win32") {
+		const linkPath = join(binDir, "omo.cmd");
+		await replaceRuntimeWrapper(linkPath, windowsRuntimeWrapper(cliPath, codexHome, binDir));
+		return { name: "omo", path: linkPath, target: cliPath };
+	}
+
+	const linkPath = join(binDir, "omo");
+	await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(cliPath, codexHome, binDir));
+	await chmod(linkPath, 0o755);
+	return { name: "omo", path: linkPath, target: cliPath };
+}
+
+async function linkCachedPluginBin(binDir, link, platform) {
+	if (platform === "win32") {
+		const linkPath = join(binDir, `${link.name}.cmd`);
+		await replaceCommandShim(linkPath, link.target);
+		return linkPath;
+	}
+
+	const linkPath = join(binDir, link.name);
+	await replaceSymlink(linkPath, link.target);
+	return linkPath;
+}
+
+async function isFile(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function discoverPackageBins(root) {
+	const links = [];
+	await collectPackageBins(root, root, links);
+	return links;
+}
+
+async function collectPackageBins(directory, root, links) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	const packageJsonPath = join(directory, "package.json");
+	if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
+		await appendPackageBinLinks(packageJsonPath, directory, root, links);
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+		const childPath = join(directory, entry.name);
+		if (!isPathInside(childPath, root)) continue;
+		await collectPackageBins(childPath, root, links);
+	}
+}
+
+async function appendPackageBinLinks(packageJsonPath, packageRoot, root, links) {
+	const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	if (!isRecord(packageJson)) return;
+	const bin = packageJson.bin;
+	if (typeof bin === "string" && typeof packageJson.name === "string") {
+		const name = basename(packageJson.name);
+		if (!isReservedNestedBinName(name, packageRoot, root)) {
+			links.push(createPackageBinLink(name, bin, packageRoot));
+		}
+		return;
+	}
+	if (!isRecord(bin)) return;
+	for (const [name, target] of Object.entries(bin)) {
+		if (typeof target !== "string") continue;
+		if (isReservedNestedBinName(name, packageRoot, root)) continue;
+		links.push(createPackageBinLink(name, target, packageRoot));
+	}
+}
+
+function createPackageBinLink(name, target, packageRoot) {
+	assertSafeBinName(name);
+	if (target.includes("\0")) {
+		throw new Error(`package bin target for ${name} contains a NUL byte`);
+	}
+	const resolvedTarget = resolve(packageRoot, target);
+	if (!isPathInside(resolvedTarget, packageRoot)) {
+		throw new Error(`package bin target for ${name} escapes package root`);
+	}
+	return { name, target: resolvedTarget };
+}
+
+function assertSafeBinName(name) {
+	if (
+		name.length === 0 ||
+		name === "." ||
+		name === ".." ||
+		name.includes("\0") ||
+		name.includes("/") ||
+		name.includes("\\")
+	) {
+		throw new Error(`invalid package bin name: ${name}`);
+	}
+}
+
+function isReservedNestedBinName(name, packageRoot, root) {
+	return packageRoot !== root && RESERVED_NESTED_BIN_NAMES.has(name);
+}
+
+async function replaceSymlink(linkPath, targetPath) {
+	if (await existingNonSymlink(linkPath)) {
+		throw new Error(`${linkPath} already exists and is not a symlink`);
+	}
+	await rm(linkPath, { force: true });
+	await symlink(targetPath, linkPath);
+}
+
+async function replaceCommandShim(linkPath, targetPath) {
+	if (await existingNonShim(linkPath)) {
+		throw new Error(`${linkPath} already exists and is not a command shim`);
+	}
+	await writeFile(linkPath, `@echo off\r\n${COMMAND_SHIM_MARKER}\r\nnode "${targetPath}" %*\r\n`);
+}
+
+async function replaceRuntimeWrapper(linkPath, content) {
+	if (await existingNonRuntimeWrapper(linkPath)) {
+		throw new Error(`${linkPath} already exists and is not a generated OMO runtime wrapper`);
+	}
+	await rm(linkPath, { force: true });
+	await writeFile(linkPath, content);
+}
+
+async function existingNonRuntimeWrapper(path) {
+	try {
+		const stat = await lstat(path);
+		if (stat.isSymbolicLink()) return false;
+		if (!stat.isFile()) return true;
+		const content = await readFile(path, "utf8");
+		return !content.includes(RUNTIME_WRAPPER_MARKER);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+function posixRuntimeWrapper(cliPath, codexHome, binDir) {
+	const ulwLoopBin = join(binDir, "omo-ulw-loop");
+	return [
+		"#!/bin/sh",
+		`# ${RUNTIME_WRAPPER_MARKER}`,
+		`export CODEX_HOME="\${CODEX_HOME:-${escapePosixDoubleQuoted(codexHome)}}"`,
+		'export OMO_SPARKSHELL_APP_SERVER_SOCKET="${OMO_SPARKSHELL_APP_SERVER_SOCKET:-$CODEX_HOME/app-server-control/app-server-control.sock}"',
+		'BUN_BINARY="${BUN_BINARY:-bun}"',
+		'if [ "$1" = "ulw-loop" ] && [ -x "' + escapePosixDoubleQuoted(ulwLoopBin) + '" ]; then',
+		"  shift",
+		'  exec "' + escapePosixDoubleQuoted(ulwLoopBin) + '" "$@"',
+		"fi",
+		`exec "$BUN_BINARY" "${escapePosixDoubleQuoted(cliPath)}" "$@"`,
+		"",
+	].join("\n");
+}
+
+function windowsRuntimeWrapper(cliPath, codexHome, binDir) {
+	const ulwLoopBin = join(binDir, "omo-ulw-loop.cmd");
+	return [
+		"@echo off",
+		`rem ${RUNTIME_WRAPPER_MARKER}`,
+		`if not defined CODEX_HOME set "CODEX_HOME=${codexHome}"`,
+		'if not defined OMO_SPARKSHELL_APP_SERVER_SOCKET set "OMO_SPARKSHELL_APP_SERVER_SOCKET=%CODEX_HOME%\\app-server-control\\app-server-control.sock"',
+		`if "%~1"=="ulw-loop" if exist "${ulwLoopBin}" (`,
+		"  shift /1",
+		`  "${ulwLoopBin}" %*`,
+		"  exit /b %ERRORLEVEL%",
+		")",
+		`if defined BUN_BINARY ("%BUN_BINARY%" "${cliPath}" %*) else bun "${cliPath}" %*`,
+		"",
+	].join("\r\n");
+}
+
+function escapePosixDoubleQuoted(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("$", "\\$").replaceAll("`", "\\`");
+}
+
+async function existingNonShim(path) {
+	try {
+		const stat = await lstat(path);
+		if (!stat.isFile()) return true;
+		const content = await readFile(path, "utf8");
+		if (content.includes(COMMAND_SHIM_MARKER)) return false;
+		throw new Error(`${path} already exists and is not a generated command shim`);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function existingNonSymlink(path) {
+	try {
+		const stat = await lstat(path);
+		if (!stat.isSymbolicLink()) return true;
+		await readlink(path);
+		return false;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isPathInside(candidatePath, rootPath) {
+	const pathFromRoot = relative(rootPath, candidatePath);
+	return pathFromRoot === "" || (!pathFromRoot.startsWith("..") && !pathFromRoot.startsWith(`..\\`) && !isDriveRelative(pathFromRoot));
+}
+
+function isDriveRelative(path) {
+	return /^[a-zA-Z]:/.test(path);
+}

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

@@ -1,22 +1,31 @@
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { cp, lstat, mkdir, readFile, readdir, readlink, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 
 import { createCachedMcpRuntimeArgRewriter } from "./mcp-runtime-cache.mjs";
 import { exists, isRecord } from "./utils.mjs";
-import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
-import { removeLegacyCodexComponentBins } from "./legacy-bins.mjs";
+export { linkCachedPluginBins, linkRootRuntimeBin } from "./bin-links.mjs";
 
-export async function installCachedPlugin({ buildSource = true, codexHome, marketplaceName, name, runCommand, sourcePath, version }) {
+export async function installCachedPlugin({ buildSource = true, codexHome, marketplaceName, name, renameDirectory = rename, runCommand, sourcePath, version }) {
 	if (buildSource) {
 		await maybeRunNpmInstall(sourcePath, runCommand);
 		await maybeRunNpmBuild(sourcePath, runCommand);
 	}
 
 	const targetPath = join(codexHome, "plugins", "cache", marketplaceName, name, version);
-	await replaceDirectory(sourcePath, targetPath, shouldCopyPluginPath);
-	await rewriteCachedPackageLocalFileDependencies(targetPath, sourcePath);
-	await maybeRunNpmInstall(targetPath, runCommand, ["install", "--omit=dev"]);
-	await rewriteCachedMcpManifest(targetPath, sourcePath);
+	const tempPath = createTempSiblingPath(targetPath);
+	await rm(tempPath, { recursive: true, force: true });
+	try {
+		await copyDirectory(sourcePath, tempPath, shouldCopyPluginPath);
+		await rewriteCachedPackageLocalFileDependencies(tempPath, sourcePath);
+		await maybeRunNpmInstall(tempPath, runCommand, ["ci", "--omit=dev"]);
+		await rewriteCachedMcpManifest(tempPath, sourcePath);
+		await rewriteCachedManifestRoot(tempPath, tempPath, targetPath);
+		await promoteDirectory(tempPath, targetPath, renameDirectory);
+	} catch (error) {
+		await rm(tempPath, { recursive: true, force: true });
+		throw error;
+	}
 	return { name, version, path: targetPath };
 }
 
@@ -42,30 +51,6 @@ export async function pruneMarketplacePluginCaches({ codexHome, marketplaceName,
 	}
 }
 
-export async function linkCachedPluginBins({ binDir, pluginRoot, platform = process.platform }) {
-	const binLinks = await discoverPackageBins(pluginRoot);
-	await mkdir(binDir, { recursive: true });
-	await removeLegacyCodexComponentBins(binDir, platform);
-	const linked = [];
-	for (const link of binLinks) {
-		const linkPath = await linkCachedPluginBin(binDir, link, platform);
-		linked.push({ name: link.name, path: linkPath, target: link.target });
-	}
-	return linked;
-}
-
-async function linkCachedPluginBin(binDir, link, platform) {
-	if (platform === "win32") {
-		const linkPath = join(binDir, `${link.name}.cmd`);
-		await replaceCommandShim(linkPath, link.target);
-		return linkPath;
-	}
-
-	const linkPath = join(binDir, link.name);
-	await replaceSymlink(linkPath, link.target);
-	return linkPath;
-}
-
 async function maybeRunNpmInstall(cwd, runCommand, args = ["install"]) {
 	if (!(await exists(join(cwd, "package.json")))) return;
 	await runCommand("npm", args, { cwd });
@@ -78,99 +63,49 @@ async function maybeRunNpmBuild(cwd, runCommand) {
 	await runCommand("npm", ["run", "build"], { cwd });
 }
 
-async function replaceDirectory(sourcePath, targetPath, filter) {
-	await mkdir(dirname(targetPath), { recursive: true });
-	const tempPath = join(dirname(targetPath), `.tmp-${basename(targetPath)}-${process.pid}-${Date.now()}`);
-	await rm(tempPath, { recursive: true, force: true });
-	await cp(sourcePath, tempPath, {
-		recursive: true,
-		filter: (source) => filter(source, sourcePath),
-	});
-	await rm(targetPath, { recursive: true, force: true });
-	await rename(tempPath, targetPath);
-}
-
-async function discoverPackageBins(root) {
-	const links = [];
-	await collectPackageBins(root, root, links);
-	return links;
-}
-
-async function collectPackageBins(directory, root, links) {
-	const entries = await readdir(directory, { withFileTypes: true });
-	const packageJsonPath = join(directory, "package.json");
-	if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
-		await appendPackageBinLinks(packageJsonPath, directory, links);
-	}
-	for (const entry of entries) {
-		if (!entry.isDirectory()) continue;
-		if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
-		const childPath = join(directory, entry.name);
-		if (!childPath.startsWith(root)) continue;
-		await collectPackageBins(childPath, root, links);
-	}
-}
-
-async function appendPackageBinLinks(packageJsonPath, packageRoot, links) {
-	const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-	if (!isRecord(packageJson)) return;
-	const bin = packageJson.bin;
-	if (typeof bin === "string" && typeof packageJson.name === "string") {
-		links.push({ name: basename(packageJson.name), target: join(packageRoot, bin) });
-		return;
-	}
-	if (!isRecord(bin)) return;
-	for (const [name, target] of Object.entries(bin)) {
-		if (typeof target !== "string") continue;
-		links.push({ name, target: join(packageRoot, target) });
-	}
+function createTempSiblingPath(targetPath) {
+	return join(dirname(targetPath), `.tmp-${basename(targetPath)}-${process.pid}-${Date.now()}`);
 }
 
-async function replaceSymlink(linkPath, targetPath) {
-	if (await existingNonSymlink(linkPath)) {
-		throw new Error(`${linkPath} already exists and is not a symlink`);
-	}
-	await rm(linkPath, { force: true });
-	await symlink(targetPath, linkPath);
+function createBackupSiblingPath(targetPath) {
+	return join(dirname(targetPath), `.backup-${basename(targetPath)}-${process.pid}-${Date.now()}`);
 }
 
-async function replaceCommandShim(linkPath, targetPath) {
-	if (await existingNonShim(linkPath)) {
-		throw new Error(`${linkPath} already exists and is not a command shim`);
-	}
-	await writeFile(linkPath, `@echo off\r\n${COMMAND_SHIM_MARKER}\r\nnode "${targetPath}" %*\r\n`);
+async function copyDirectory(sourcePath, targetPath, filter) {
+	await mkdir(dirname(targetPath), { recursive: true });
+	await cp(sourcePath, targetPath, {
+		recursive: true,
+		filter: (source) => filter(source, sourcePath),
+	});
 }
 
-async function existingNonShim(path) {
+async function promoteDirectory(tempPath, targetPath, renameDirectory) {
+	const backupPath = createBackupSiblingPath(targetPath);
+	await rm(backupPath, { recursive: true, force: true });
+	let backupMoved = false;
 	try {
-		const stat = await lstat(path);
-		if (!stat.isFile()) return true;
-		const content = await readFile(path, "utf8");
-		if (content.includes(COMMAND_SHIM_MARKER)) return false;
-		throw new Error(`${path} already exists and is not a generated command shim`);
+		if (await exists(targetPath)) {
+			await renameDirectory(targetPath, backupPath);
+			backupMoved = true;
+		}
+		await renameDirectory(tempPath, targetPath);
 	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		if (backupMoved) await restoreBackupDirectory(backupPath, targetPath, renameDirectory);
 		throw error;
 	}
+	if (backupMoved) await rm(backupPath, { recursive: true, force: true });
 }
 
-async function existingNonSymlink(path) {
-	try {
-		const stat = await lstat(path);
-		if (!stat.isSymbolicLink()) return true;
-		await readlink(path);
-		return false;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
-		throw error;
-	}
+async function restoreBackupDirectory(backupPath, targetPath, renameDirectory) {
+	if (!(await exists(backupPath))) return;
+	await rm(targetPath, { recursive: true, force: true });
+	await renameDirectory(backupPath, targetPath);
 }
 
 function shouldCopyPluginPath(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");
 }
 
@@ -200,9 +135,34 @@ export async function rewriteCachedMcpManifest(pluginRoot, sourceRoot = pluginRo
 	if (changed) await writeFile(manifestPath, `${JSON.stringify(parsed, null, "\t")}\n`);
 }
 
+async function rewriteCachedManifestRoot(pluginRoot, fromRoot, toRoot) {
+	const manifestPath = join(pluginRoot, ".mcp.json");
+	if (!(await exists(manifestPath))) return;
+	const raw = await readFile(manifestPath, "utf8");
+	const parsed = JSON.parse(raw);
+	if (!isRecord(parsed) || !isRecord(parsed.mcpServers)) return;
+	let changed = false;
+	for (const server of Object.values(parsed.mcpServers)) {
+		if (!isRecord(server) || !Array.isArray(server.args)) continue;
+		const nextArgs = server.args.map((arg) => {
+			if (typeof arg !== "string") return arg;
+			if (arg === fromRoot) return toRoot;
+			const prefix = `${fromRoot}${sep}`;
+			if (!arg.startsWith(prefix)) return arg;
+			return `${toRoot}${arg.slice(fromRoot.length)}`;
+		});
+		if (nextArgs.some((value, index) => value !== server.args[index])) {
+			server.args = nextArgs;
+			changed = true;
+		}
+	}
+	if (changed) await writeFile(manifestPath, `${JSON.stringify(parsed, null, "\t")}\n`);
+}
+
 async function rewriteCachedPackageLocalFileDependencies(pluginRoot, sourceRoot) {
 	const packageJsonPaths = [];
 	await collectPackageJsonPaths(pluginRoot, pluginRoot, packageJsonPaths);
+	const packageLock = await readPackageLock(pluginRoot);
 	for (const packageJsonPath of packageJsonPaths) {
 		const raw = await readFile(packageJsonPath, "utf8");
 		const parsed = JSON.parse(raw);
@@ -219,12 +179,96 @@ async function rewriteCachedPackageLocalFileDependencies(pluginRoot, sourceRoot)
 				if (filePath.length === 0 || isAbsolute(filePath)) continue;
 				const targetPath = resolve(packageDir, filePath);
 				if (isPathInside(targetPath, pluginRoot)) continue;
-				dependencies[name] = `file:${resolve(sourcePackageDir, filePath)}`;
+				const sourceTargetPath = resolve(sourcePackageDir, filePath);
+				dependencies[name] = `file:${sourceTargetPath}`;
+				rewritePackageLockFileDependency({
+					dependencyName: name,
+					field,
+					packageDir,
+					packageLock,
+					pluginRoot,
+					sourceTargetPath,
+					targetPath,
+				});
 				changed = true;
 			}
 		}
 		if (changed) await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, "\t")}\n`);
 	}
+	if (packageLock.changed) await writeFile(packageLock.path, `${JSON.stringify(packageLock.value, null, "\t")}\n`);
+}
+
+async function readPackageLock(pluginRoot) {
+	const path = join(pluginRoot, "package-lock.json");
+	try {
+		const parsed = JSON.parse(await readFile(path, "utf8"));
+		return { path, value: isRecord(parsed) ? parsed : null, changed: false };
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+			return { path, value: null, changed: false };
+		}
+		throw error;
+	}
+}
+
+function rewritePackageLockFileDependency({
+	dependencyName,
+	field,
+	packageDir,
+	packageLock,
+	pluginRoot,
+	sourceTargetPath,
+	targetPath,
+}) {
+	const packages = getPackageLockPackages(packageLock.value);
+	if (!packages) return;
+
+	const lockRoot = canonicalizeExistingPath(pluginRoot);
+	const packageKey = toPackageLockPath(relative(pluginRoot, packageDir));
+	const oldTargetKey = toPackageLockPath(relative(pluginRoot, targetPath));
+	const newTargetKey = toPackageLockPath(relative(lockRoot, sourceTargetPath));
+	const newSpecifier = `file:${sourceTargetPath}`;
+
+	const packageEntry = packages[packageKey];
+	if (isRecord(packageEntry)) {
+		const dependencyRecord = packageEntry[field];
+		if (isRecord(dependencyRecord) && dependencyRecord[dependencyName] !== newSpecifier) {
+			dependencyRecord[dependencyName] = newSpecifier;
+			packageLock.changed = true;
+		}
+	}
+
+	if (oldTargetKey !== newTargetKey && isRecord(packages[oldTargetKey])) {
+		packages[newTargetKey] = packages[oldTargetKey];
+		delete packages[oldTargetKey];
+		packageLock.changed = true;
+	}
+
+	const nodeModulesKey = `node_modules/${dependencyName}`;
+	const nodeModulesEntry = packages[nodeModulesKey];
+	if (isRecord(nodeModulesEntry) && nodeModulesEntry.resolved !== newTargetKey) {
+		nodeModulesEntry.resolved = newTargetKey;
+		packageLock.changed = true;
+	}
+}
+
+function getPackageLockPackages(packageLock) {
+	if (!packageLock) return null;
+	const packages = packageLock.packages;
+	return isRecord(packages) ? packages : null;
+}
+
+function toPackageLockPath(path) {
+	return path.split(sep).join("/");
+}
+
+function canonicalizeExistingPath(path) {
+	try {
+		return realpathSync(path);
+	} catch (error) {
+		if (error instanceof Error) return path;
+		throw error;
+	}
 }
 
 async function collectPackageJsonPaths(directory, root, paths) {

package/packages/omo-codex/scripts/install/cached-marketplace-manifest.mjs

@@ -0,0 +1,21 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export 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`,
+	);
+}

package/packages/omo-codex/scripts/install/cli-args.mjs

@@ -1,5 +1,5 @@
 const CODEX_ONLY_ERROR = "lazycodex-ai installs the Codex Light edition only. Use the omo installer for OpenCode or both-platform installs.";
-const PASSTHROUGH_COMMANDS = new Set(["doctor", "cleanup", "get-local-version", "boulder", "refresh-model-capabilities", "run", "ulw-loop"]);
+export const PASSTHROUGH_COMMANDS = new Set(["doctor", "cleanup", "get-local-version", "boulder", "refresh-model-capabilities", "run", "ulw-loop"]);
 
 export function parseLazyCodexInstallCliArgs(argv) {
 	const args = [...argv];
@@ -72,6 +72,34 @@ export function parseLazyCodexInstallCliArgs(argv) {
 			index += 1;
 			continue;
 		}
+		if (arg === "update") {
+			index += 1;
+			while (index < args.length) {
+				const updateArg = args[index];
+				if (updateArg === "--dry-run") {
+					dryRun = true;
+					index += 1;
+					continue;
+				}
+				if (updateArg === "--repo-root") {
+					repoRoot = readOptionValue(args, index, "--repo-root");
+					index += 2;
+					continue;
+				}
+				if (typeof updateArg === "string" && updateArg.startsWith("--repo-root=")) {
+					const value = updateArg.slice("--repo-root=".length);
+					if (value.trim().length === 0) throw new Error("--repo-root requires a path");
+					repoRoot = value;
+					index += 1;
+					continue;
+				}
+				throw new Error(`Unsupported lazycodex-ai update option: ${String(updateArg)}`);
+			}
+			return { kind: "update", dryRun, repoRoot };
+		}
+		if (arg === "uninstall") {
+			return { kind: "command", command: "cleanup", dryRun, args: args.slice(index + 1) };
+		}
 		if (PASSTHROUGH_COMMANDS.has(arg)) {
 			return { kind: "command", command: arg, dryRun, args: args.slice(index + 1) };
 		}
@@ -104,9 +132,18 @@ function readOptionValue(args, index, option) {
 }
 
 export function formatLazyCodexInstallHelp() {
+	const passthrough = [...PASSTHROUGH_COMMANDS].sort().join(", ");
 	return [
 		"Usage: lazycodex-ai install [--no-tui] [--codex-autonomous|--no-codex-autonomous] [--repo-root <path>]",
+		"       lazycodex-ai uninstall [--project <path>]",
+		"       lazycodex-ai update [--dry-run] [--repo-root <path>]",
+		"       lazycodex-ai version",
+		"       lazycodex-ai <command> [args...]",
+		"",
+		"Installs or removes the Codex Light edition in ~/.codex using Node/npm.",
+		"`uninstall` removes managed Codex Light state; `cleanup` is a backward-compatible alias.",
+		"`update` refreshes the installed Codex Light edition in place.",
 		"",
-		"Installs the Codex Light edition into ~/.codex using Node/npm.",
+		`Pass-through commands delegated to the omo CLI: ${passthrough}.`,
 	].join("\n");
 }