oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,247 @@
+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 { 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 async function installCachedPlugin({ buildSource = true, codexHome, marketplaceName, name, 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);
+	return { name, version, path: targetPath };
+}
+
+export async function pruneMarketplaceCache({ codexHome, marketplaceName, keepPluginNames }) {
+	const cacheRoot = join(codexHome, "plugins", "cache", marketplaceName);
+	if (!(await exists(cacheRoot))) return;
+	const keep = new Set(keepPluginNames);
+	const entries = await readdir(cacheRoot, { withFileTypes: true });
+	for (const entry of entries) {
+		if (!entry.isDirectory() || keep.has(entry.name)) continue;
+		await rm(join(cacheRoot, entry.name), { recursive: true, force: true });
+	}
+}
+
+export async function pruneMarketplacePluginCaches({ codexHome, marketplaceName, pluginNames }) {
+	const cacheRoot = join(codexHome, "plugins", "cache", marketplaceName);
+	if (!(await exists(cacheRoot))) return;
+	for (const pluginName of pluginNames) {
+		await rm(join(cacheRoot, pluginName), { recursive: true, force: true });
+	}
+	if ((await readdir(cacheRoot)).length === 0) {
+		await rm(cacheRoot, { recursive: true, force: true });
+	}
+}
+
+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 });
+}
+
+async function maybeRunNpmBuild(cwd, runCommand) {
+	if (!(await exists(join(cwd, "package.json")))) return;
+	const packageJson = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+	if (!isRecord(packageJson.scripts) || typeof packageJson.scripts.build !== "string") return;
+	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) });
+	}
+}
+
+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 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 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");
+}
+
+export async function rewriteCachedMcpManifest(pluginRoot, sourceRoot = pluginRoot) {
+	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;
+	const rewriteRuntimeArg = createCachedMcpRuntimeArgRewriter();
+	for (const [serverName, server] of Object.entries(parsed.mcpServers)) {
+		if (!isRecord(server)) continue;
+		if (server.cwd === "." || server.cwd === "./") {
+			delete server.cwd;
+			changed = true;
+		}
+		if (!Array.isArray(server.args)) continue;
+		const nextArgs = await Promise.all(
+			server.args.map((arg) => rewriteRuntimeArg({ arg, pluginRoot, serverName, sourceRoot })),
+		);
+		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);
+	for (const packageJsonPath of packageJsonPaths) {
+		const raw = await readFile(packageJsonPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isRecord(parsed)) continue;
+		const packageDir = dirname(packageJsonPath);
+		const sourcePackageDir = join(sourceRoot, relative(pluginRoot, packageDir));
+		let changed = false;
+		for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+			const dependencies = parsed[field];
+			if (!isRecord(dependencies)) continue;
+			for (const [name, specifier] of Object.entries(dependencies)) {
+				if (typeof specifier !== "string" || !specifier.startsWith("file:")) continue;
+				const filePath = specifier.slice("file:".length);
+				if (filePath.length === 0 || isAbsolute(filePath)) continue;
+				const targetPath = resolve(packageDir, filePath);
+				if (isPathInside(targetPath, pluginRoot)) continue;
+				dependencies[name] = `file:${resolve(sourcePackageDir, filePath)}`;
+				changed = true;
+			}
+		}
+		if (changed) await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, "\t")}\n`);
+	}
+}
+
+async function collectPackageJsonPaths(directory, root, paths) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
+		paths.push(join(directory, "package.json"));
+	}
+	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 collectPackageJsonPaths(childPath, root, paths);
+	}
+}
+
+function isPathInside(candidatePath, rootPath) {
+	const pathFromRoot = relative(rootPath, candidatePath);
+	return pathFromRoot === "" || (!pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot));
+}

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

@@ -0,0 +1,112 @@
+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"]);
+
+export function parseLazyCodexInstallCliArgs(argv) {
+	const args = [...argv];
+	if (args.length === 0) return { kind: "install", autonomousPermissions: undefined, repoRoot: undefined };
+
+	let repoRoot;
+	let command;
+	let dryRun = false;
+	let noTui = false;
+	let skipAuth = false;
+	let autonomousPermissions;
+	let index = 0;
+	while (index < args.length) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h" || arg === "help") return { kind: "help" };
+		if (arg === "--version" || arg === "-v" || arg === "version") return { kind: "version" };
+		if (arg === "--dry-run") {
+			dryRun = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--no-tui") {
+			noTui = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--skip-auth") {
+			skipAuth = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--codex-autonomous") {
+			autonomousPermissions = true;
+			index += 1;
+			continue;
+		}
+		if (arg === "--no-codex-autonomous") {
+			autonomousPermissions = false;
+			index += 1;
+			continue;
+		}
+		if (arg === "--platform") {
+			const platform = readOptionValue(args, index, "--platform");
+			if (platform !== "codex") throw new Error(CODEX_ONLY_ERROR);
+			index += 2;
+			continue;
+		}
+		if (typeof arg === "string" && arg.startsWith("--platform=")) {
+			const platform = arg.slice("--platform=".length);
+			if (platform.trim().length === 0) throw new Error("--platform requires a value");
+			if (platform !== "codex") throw new Error(CODEX_ONLY_ERROR);
+			index += 1;
+			continue;
+		}
+		if (arg === "--repo-root") {
+			repoRoot = readOptionValue(args, index, "--repo-root");
+			index += 2;
+			continue;
+		}
+		if (typeof arg === "string" && arg.startsWith("--repo-root=")) {
+			const value = arg.slice("--repo-root=".length);
+			if (value.trim().length === 0) throw new Error("--repo-root requires a path");
+			repoRoot = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "install" || arg === "setup") {
+			if (command !== undefined) throw new Error(`Unsupported lazycodex-ai install option: ${String(arg)}`);
+			command = "install";
+			index += 1;
+			continue;
+		}
+		if (PASSTHROUGH_COMMANDS.has(arg)) {
+			return { kind: "command", command: arg, dryRun, args: args.slice(index + 1) };
+		}
+		if (command === undefined && typeof arg === "string" && !arg.startsWith("-")) {
+			throw new Error(`Unsupported lazycodex-ai command: ${String(arg)}`);
+		}
+		throw new Error(`Unsupported lazycodex-ai install option: ${String(arg)}`);
+	}
+
+	if (!dryRun) return { kind: "install", autonomousPermissions, repoRoot };
+
+	return {
+		kind: "command",
+		command: command ?? "install",
+		dryRun,
+		noTui,
+		skipAuth,
+		autonomousPermissions,
+		repoRoot,
+		args: [],
+	};
+}
+
+function readOptionValue(args, index, option) {
+	const value = args[index + 1];
+	if (typeof value !== "string" || value.trim().length === 0) {
+		throw new Error(`${option} requires a value`);
+	}
+	return value;
+}
+
+export function formatLazyCodexInstallHelp() {
+	return [
+		"Usage: lazycodex-ai install [--no-tui] [--codex-autonomous|--no-codex-autonomous] [--repo-root <path>]",
+		"",
+		"Installs the Codex Light edition into ~/.codex using Node/npm.",
+	].join("\n");
+}

package/packages/omo-codex/scripts/install/command-shim.mjs

@@ -0,0 +1 @@
+export const COMMAND_SHIM_MARKER = ":: generated by oh-my-openagent Codex installer";

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

@@ -0,0 +1,264 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+import { ensureCodexMultiAgentV2Config } from "./multi-agent-v2-config.mjs";
+import { ensureCodexReasoningConfig } from "./reasoning-config.mjs";
+import { ensureAutonomousPermissions } from "./permissions.mjs";
+import { appendBlock, findTomlSection, replaceOrInsertSetting } from "./toml-editor.mjs";
+import { exists } from "./utils.mjs";
+
+const LEGACY_CODEX_PLUGIN_MARKETPLACE = ["code", "yeongyu", "codex", "plugins"].join("-");
+const SISYPHUS_LEGACY_MARKETPLACES = ["lazycodex", LEGACY_CODEX_PLUGIN_MARKETPLACE];
+const MANAGED_CODEX_AGENT_NAMES = [
+	"codex-ultrawork-reviewer",
+	"explorer",
+	"librarian",
+	"metis",
+	"momus",
+	"plan",
+];
+const CONTEXT7_MCP_SERVER_HEADER = "mcp_servers.context7";
+const CONTEXT7_MCP_SERVER_BLOCK = [
+	`[${CONTEXT7_MCP_SERVER_HEADER}]`,
+	`command = "npx"`,
+	`args = ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]`,
+	`startup_timeout_sec = 20`,
+	"",
+].join("\n");
+
+export async function updateCodexConfig({
+	configPath,
+	repoRoot,
+	marketplaceName,
+	marketplaceSource = defaultMarketplaceSource(marketplaceName, repoRoot),
+	pluginNames,
+	platform = process.platform,
+	trustedHookStates = [],
+	agentConfigs = [],
+	autonomousPermissions = false,
+}) {
+	await mkdir(dirname(configPath), { recursive: true });
+	let config = "";
+	if (await exists(configPath)) config = await readFile(configPath, "utf8");
+
+	for (const legacyMarketplaceName of legacyMarketplaceNames(marketplaceName)) {
+		config = removeMarketplaceBlock(config, legacyMarketplaceName);
+		config = removeStaleMarketplacePluginBlocks(config, legacyMarketplaceName, new Set());
+		config = removeStaleMarketplaceHookStateBlocks(config, legacyMarketplaceName, new Set());
+	}
+	config = removeStaleMarketplacePluginBlocks(config, marketplaceName, new Set(pluginNames));
+	config = removeStaleMarketplaceHookStateBlocks(config, marketplaceName, new Set(pluginNames));
+	config = removeStaleManagedAgentBlocks(config, new Set(agentConfigs.map((agentConfig) => agentConfig.name)));
+	config = ensureFeatureEnabled(config, "plugins");
+	config = ensureFeatureEnabled(config, "plugin_hooks");
+	config = ensureCodexReasoningConfig(config);
+	config = ensureCodexMultiAgentV2Config(config);
+	if (autonomousPermissions === true) config = ensureAutonomousPermissions(config);
+	config = ensureContext7McpServer(config);
+	config = ensureMarketplaceBlock(config, marketplaceName, marketplaceSource);
+	for (const pluginName of pluginNames) {
+		config = ensurePluginEnabled(config, `${pluginName}@${marketplaceName}`);
+	}
+	config = ensureOmoGitBashMcpPolicy(config, { marketplaceName, pluginNames, platform });
+	for (const state of trustedHookStates) {
+		config = ensureHookTrusted(config, state.key, state.trustedHash);
+	}
+	for (const agentConfig of agentConfigs) {
+		config = ensureAgentConfig(config, agentConfig);
+	}
+
+	await writeFile(configPath, config.trimEnd() + "\n");
+}
+
+function legacyMarketplaceNames(marketplaceName) {
+	return marketplaceName === "sisyphuslabs" ? SISYPHUS_LEGACY_MARKETPLACES : [];
+}
+
+function removeMarketplaceBlock(config, marketplaceName) {
+	return removeTomlSections(config, (header) => header === `marketplaces.${marketplaceName}`);
+}
+
+function defaultMarketplaceSource(marketplaceName, repoRoot) {
+	return {
+		sourceType: "local",
+		source: repoRoot,
+	};
+}
+
+function removeStaleMarketplacePluginBlocks(config, marketplaceName, keepPluginNames) {
+	return removeTomlSections(config, (header) => {
+		const pluginKey = parsePluginHeaderKey(header);
+		if (pluginKey === null) return false;
+		const suffix = `@${marketplaceName}`;
+		if (!pluginKey.endsWith(suffix)) return false;
+		return !keepPluginNames.has(pluginKey.slice(0, -suffix.length));
+	});
+}
+
+function removeStaleMarketplaceHookStateBlocks(config, marketplaceName, keepPluginNames) {
+	return removeTomlSections(config, (header) => {
+		const prefix = "hooks.state.";
+		if (!header.startsWith(prefix)) return false;
+		const hookKey = parseJsonString(header.slice(prefix.length));
+		if (hookKey === null) return false;
+		const separator = hookKey.indexOf(":");
+		if (separator === -1) return false;
+		const pluginKey = hookKey.slice(0, separator);
+		const suffix = `@${marketplaceName}`;
+		if (!pluginKey.endsWith(suffix)) return false;
+		return !keepPluginNames.has(pluginKey.slice(0, -suffix.length));
+	});
+}
+
+function removeStaleManagedAgentBlocks(config, keepAgentNames) {
+	const managedAgentNames = new Set(MANAGED_CODEX_AGENT_NAMES);
+	return splitTomlSections(config)
+		.filter((section) => {
+			if (section.header === null) return true;
+			const agentName = parseAgentHeaderName(section.header);
+			if (agentName === null || !managedAgentNames.has(agentName) || keepAgentNames.has(agentName)) return true;
+			return !section.text.includes(`config_file = ${JSON.stringify(`./agents/${agentName}.toml`)}`);
+		})
+		.map((section) => section.text)
+		.join("")
+		.replace(/\n{3,}/g, "\n\n");
+}
+
+function ensureFeatureEnabled(config, featureName) {
+	const section = findTomlSection(config, "features");
+	if (!section) return appendBlock(config, `[features]\n${featureName} = true\n`);
+	return replaceOrInsertSetting(config, section, featureName, "true");
+}
+
+function ensureMarketplaceBlock(config, marketplaceName, source) {
+	const header = `marketplaces.${marketplaceName}`;
+	const block = [
+		`[${header}]`,
+		`last_updated = "${new Date().toISOString().replace(/\.\d{3}Z$/, "Z")}"`,
+		`source_type = ${JSON.stringify(source.sourceType)}`,
+		`source = ${JSON.stringify(source.source)}`,
+		source.ref === undefined ? null : `ref = ${JSON.stringify(source.ref)}`,
+		"",
+	].filter((line) => line !== null).join("\n");
+	const section = findTomlSection(config, header);
+	if (section) return config.slice(0, section.start) + block + config.slice(section.end);
+	return appendBlock(config, block);
+}
+
+function ensureContext7McpServer(config) {
+	if (findTomlSection(config, CONTEXT7_MCP_SERVER_HEADER)) return config;
+	return appendBlock(config, CONTEXT7_MCP_SERVER_BLOCK);
+}
+
+function ensurePluginEnabled(config, pluginKey) {
+	const header = `plugins.${JSON.stringify(pluginKey)}`;
+	const section = findTomlSection(config, header);
+	if (!section) return appendBlock(config, `[${header}]\nenabled = true\n`);
+	return replaceOrInsertSetting(config, section, "enabled", "true");
+}
+
+function ensurePluginMcpEnabled(config, pluginKey, serverName, enabled) {
+	const header = `plugins.${JSON.stringify(pluginKey)}.mcp_servers.${serverName}`;
+	const section = findTomlSection(config, header);
+	const enabledValue = enabled ? "true" : "false";
+	if (!section) return appendBlock(config, `[${header}]\nenabled = ${enabledValue}\n`);
+	return replaceOrInsertSetting(config, section, "enabled", enabledValue);
+}
+
+function ensureOmoGitBashMcpPolicy(config, { marketplaceName, pluginNames, platform }) {
+	if (marketplaceName !== "sisyphuslabs" || !pluginNames.includes("omo")) return config;
+	return ensurePluginMcpEnabled(config, "omo@sisyphuslabs", "git_bash", platform === "win32");
+}
+
+function ensureHookTrusted(config, key, trustedHash) {
+	const header = `hooks.state.${JSON.stringify(key)}`;
+	const section = findTomlSection(config, header);
+	if (!section) return appendBlock(config, `[${header}]\ntrusted_hash = ${JSON.stringify(trustedHash)}\n`);
+	return replaceOrInsertSetting(config, section, "trusted_hash", JSON.stringify(trustedHash));
+}
+
+function ensureAgentConfig(config, agentConfig) {
+	const header = `agents.${tomlKeySegment(agentConfig.name)}`;
+	const section = findTomlSection(config, header);
+	const configFile = JSON.stringify(agentConfig.configFile);
+	if (!section) return appendBlock(config, `[${header}]\nconfig_file = ${configFile}\n`);
+	return replaceOrInsertSetting(config, section, "config_file", configFile);
+}
+
+function tomlKeySegment(value) {
+	return /^[A-Za-z0-9_-]+$/.test(value) ? value : JSON.stringify(value);
+}
+
+function removeTomlSections(config, shouldRemove) {
+	return splitTomlSections(config)
+		.filter((section) => section.header === null || !shouldRemove(section.header))
+		.map((section) => section.text)
+		.join("")
+		.replace(/\n{3,}/g, "\n\n");
+}
+
+function splitTomlSections(config) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	const sections = [];
+	let current = { header: null, text: "" };
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const header = parseTomlHeader(line);
+		if (header !== null) {
+			if (current.text.length > 0) sections.push(current);
+			current = { header, text: line };
+		} else {
+			current.text += line;
+		}
+	}
+	if (current.text.length > 0) sections.push(current);
+	return sections;
+}
+
+function parseTomlHeader(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
+	if (trimmed.startsWith("[[")) return null;
+	return trimmed.slice(1, -1);
+}
+
+function parsePluginHeaderKey(header) {
+	const prefix = "plugins.";
+	if (!header.startsWith(prefix)) return null;
+	return parseLeadingJsonString(header.slice(prefix.length));
+}
+
+function parseAgentHeaderName(header) {
+	const prefix = "agents.";
+	if (!header.startsWith(prefix)) return null;
+	const key = header.slice(prefix.length);
+	return key.startsWith('"') ? parseLeadingJsonString(key) : key;
+}
+
+function parseLeadingJsonString(value) {
+	if (!value.startsWith('"')) return parseJsonString(value);
+	let escaped = false;
+	for (let index = 1; index < value.length; index += 1) {
+		const char = value[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === '"') return parseJsonString(value.slice(0, index + 1));
+	}
+	return null;
+}
+
+function parseJsonString(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return typeof parsed === "string" ? parsed : null;
+	} catch (error) {
+		if (error instanceof Error) return null;
+		return null;
+	}
+}

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

@@ -0,0 +1,25 @@
+export async function runDelegatedOmoCommand(parsed, options) {
+	const invocation = buildDelegatedOmoInvocation(parsed);
+	if (parsed.dryRun) {
+		options.log(`${invocation.command} ${invocation.args.join(" ")}`);
+		return;
+	}
+	await options.runCommand(invocation.command, invocation.args, { cwd: options.cwd });
+}
+
+export function buildDelegatedOmoInvocation(parsed) {
+	const args = ["--yes", "--package", "oh-my-openagent", "omo", parsed.command];
+	if (parsed.command === "install") {
+		args.push("--platform=codex");
+		if (parsed.noTui) args.push("--no-tui");
+		if (parsed.skipAuth) args.push("--skip-auth");
+		if (parsed.autonomousPermissions === true) args.push("--codex-autonomous");
+		if (parsed.autonomousPermissions === false) args.push("--no-codex-autonomous");
+		if (parsed.repoRoot) args.push(`--repo-root=${parsed.repoRoot}`);
+	} else if (parsed.command === "cleanup") {
+		args.push("--platform=codex", ...parsed.args);
+	} else {
+		args.push(...parsed.args);
+	}
+	return { command: "npx", args };
+}