oh-my-opencode 4.5.12 → 4.7.0

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,72 @@
+import { replaceOrInsertRootSetting } from "./toml-editor.mjs";
+
+const MANAGED_KEYS = ["model", "model_context_window", "model_reasoning_effort", "plan_mode_reasoning_effort"];
+
+export function ensureCodexReasoningConfig(config, catalog) {
+	const current = readRootReasoningSettings(config);
+	if (
+		Object.keys(current).length > 0 &&
+		!matchesProfile(current, catalog.current) &&
+		!catalog.managedProfiles.some((profile) => matchesProfile(current, profile))
+	) {
+		return config;
+	}
+	let next = replaceOrInsertRootSetting(config, "model", JSON.stringify(catalog.current.model));
+	next = replaceOrInsertRootSetting(next, "model_context_window", catalog.current.modelContextWindow.toString());
+	next = replaceOrInsertRootSetting(
+		next,
+		"model_reasoning_effort",
+		JSON.stringify(catalog.current.modelReasoningEffort),
+	);
+	next = replaceOrInsertRootSetting(next, "plan_mode_reasoning_effort", JSON.stringify(catalog.current.planModeReasoningEffort));
+	return next;
+}
+
+function readRootReasoningSettings(config) {
+	const settings = {};
+	for (const line of config.split(/\n/)) {
+		if (isSectionHeader(line)) break;
+		for (const key of MANAGED_KEYS) {
+			if (!isRootSetting(line, key)) continue;
+			const value = parseTomlScalar(line.slice(line.indexOf("=") + 1));
+			if (key === "model" && typeof value === "string") settings.model = value;
+			if (key === "model_context_window" && typeof value === "number") settings.modelContextWindow = value;
+			if (key === "model_reasoning_effort" && typeof value === "string") settings.modelReasoningEffort = value;
+			if (key === "plan_mode_reasoning_effort" && typeof value === "string") settings.planModeReasoningEffort = value;
+		}
+	}
+	return settings;
+}
+
+function matchesProfile(current, profile) {
+	for (const [key, value] of Object.entries(profile)) {
+		if (current[key] !== value) return false;
+	}
+	return true;
+}
+
+function parseTomlScalar(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+		try {
+			return JSON.parse(trimmed);
+		} catch (error) {
+			if (error instanceof SyntaxError) return undefined;
+			throw error;
+		}
+	}
+	const numeric = Number(trimmed);
+	return Number.isFinite(numeric) ? numeric : undefined;
+}
+
+function isSectionHeader(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+
+function isRootSetting(line, key) {
+	const trimmed = line.trimStart();
+	if (trimmed.startsWith("#") || trimmed.startsWith("[")) return false;
+	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+	return match?.[1] === key;
+}

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

@@ -26,22 +26,39 @@ export function replaceOrInsertSetting(config, section, key, value) {
 }
 
 export function removeSetting(config, section, key) {
-	const linePattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*(?:\\n|$)`, "m");
+	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");
 }
 
-function escapeRegExp(value) {
+export function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

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

@@ -76,6 +76,29 @@ test("#given managed legacy Codex component symlink #when linking bins #then rem
 	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
 });
 
+test("#given managed legacy Codex LSP symlink #when linking bins #then removes stale lsp symlink", 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", "lsp", "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", "lsp", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { omo: "./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-lsp"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	await assert.rejects(readlink(join(binDir, "codex-lsp")));
+	assert.equal(await readlink(join(binDir, "omo")), 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");

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

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseLazyCodexInstallCliArgs } from "./install/cli-args.mjs";
+
+test("#given lazycodex install flags #when parsing Node installer argv #then keeps Codex autonomous intent", () => {
+	// given
+	const argv = ["install", "--no-tui", "--codex-autonomous", "--platform=codex"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "install",
+		autonomousPermissions: true,
+		repoRoot: undefined,
+	});
+});
+
+test("#given unsupported OpenCode platform override #when parsing Node installer argv #then rejects the Bun-backed path", () => {
+	// given
+	const argv = ["install", "--platform=both"];
+
+	// when
+	const parse = () => parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.throws(parse, /lazycodex-ai installs the Codex Light edition only/);
+});
+
+test("#given missing platform value #when parsing Node installer argv #then rejects the incomplete option", () => {
+	// given
+	const argv = ["install", "--platform"];
+
+	// when
+	const parse = () => parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.throws(parse, /--platform requires a value/);
+});
+
+test("#given repo root equals option #when parsing Node installer argv #then keeps the explicit path", () => {
+	// given
+	const argv = ["install", "--repo-root=/tmp/project"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "install",
+		autonomousPermissions: undefined,
+		repoRoot: "/tmp/project",
+	});
+});
+
+test("#given unknown positional command #when parsing Node installer argv #then rejects instead of treating it as a repo root", () => {
+	// given
+	const argv = ["banana"];
+
+	// when
+	const parse = () => parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.throws(parse, /Unsupported lazycodex-ai command: banana/);
+});
+
+test("#given install help flag #when parsing Node installer argv #then returns help", () => {
+	// given
+	const argv = ["install", "--help"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, { kind: "help" });
+});
+
+test("#given dry-run install with codex autonomy flags #when parsing Node installer argv #then keeps delegated install command and dry-run intent", () => {
+	// given
+	const argv = ["--dry-run", "install", "--no-tui", "--codex-autonomous"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "command",
+		command: "install",
+		dryRun: true,
+		noTui: true,
+		skipAuth: false,
+		autonomousPermissions: true,
+		repoRoot: undefined,
+		args: [],
+	});
+});
+
+test("#given dry-run doctor command #when parsing Node installer argv #then returns delegated doctor command", () => {
+	// given
+	const argv = ["--dry-run", "doctor"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "command",
+		command: "doctor",
+		dryRun: true,
+		args: [],
+	});
+});
+
+test("#given dry-run cleanup command #when parsing Node installer argv #then returns delegated codex cleanup command", () => {
+	// given
+	const argv = ["--dry-run", "cleanup", "--project", "/tmp/lazycodex-qa"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "command",
+		command: "cleanup",
+		dryRun: true,
+		args: ["--project", "/tmp/lazycodex-qa"],
+	});
+});
+
+test("#given doctor flags #when parsing Node installer argv #then preserves pass-through arguments", () => {
+	// given
+	const argv = ["doctor", "--json"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "command",
+		command: "doctor",
+		dryRun: false,
+		args: ["--json"],
+	});
+});

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

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { updateCodexConfig } from "./install/config.mjs";
+
+test("#given autonomous permissions requested #when script installer updates config #then enables full Codex autonomy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-autonomous-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'approval_policy = "on-request"',
+			'sandbox_mode = "workspace-write"',
+			'network_access = "disabled"',
+			"",
+			"[notice]",
+			"hide_full_access_warning = false",
+			"",
+			"[windows]",
+			'sandbox = "workspace-write"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		autonomousPermissions: true,
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /approval_policy = "never"/);
+	assert.match(config, /sandbox_mode = "danger-full-access"/);
+	assert.match(config, /network_access = "enabled"/);
+	assert.match(config, /\[notice\]/);
+	assert.match(config, /hide_full_access_warning = true/);
+	assert.match(config, /hide_world_writable_warning = true/);
+	assert.doesNotMatch(config, /sandbox = "workspace-write"/);
+});