oh-my-opencode 4.5.12 → 4.6.0

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 };
+}

package/packages/omo-codex/scripts/install/git-bash.mjs

@@ -0,0 +1,99 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+
+const GIT_BASH_ENV_KEY = "OMO_CODEX_GIT_BASH_PATH";
+const SKIP_GIT_BASH_AUTO_INSTALL_ENV_KEY = "OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL";
+const PROGRAM_FILES_GIT_BASH = "C:\\Program Files\\Git\\bin\\bash.exe";
+const PROGRAM_FILES_X86_GIT_BASH = "C:\\Program Files (x86)\\Git\\bin\\bash.exe";
+const WINGET_INSTALL_ARGS = ["install", "--id", "Git.Git", "-e", "--source", "winget"];
+
+export function resolveGitBash({ platform, env, exists, where }) {
+	if (platform !== "win32") return { found: true, path: null, source: "not-required" };
+
+	const checkedPaths = [];
+	const envPath = nonEmptyEnvValue(env, GIT_BASH_ENV_KEY);
+	if (envPath !== undefined) {
+		checkedPaths.push(envPath);
+		if (isBashExePath(envPath) && exists(envPath)) return { found: true, path: envPath, source: "env" };
+		return missingGitBash(checkedPaths);
+	}
+
+	for (const candidate of [
+		{ path: PROGRAM_FILES_GIT_BASH, source: "program-files" },
+		{ path: PROGRAM_FILES_X86_GIT_BASH, source: "program-files-x86" },
+	]) {
+		checkedPaths.push(candidate.path);
+		if (exists(candidate.path)) return { found: true, path: candidate.path, source: candidate.source };
+	}
+
+	for (const pathCandidate of where("bash")) {
+		const candidate = pathCandidate.trim();
+		if (candidate.length === 0) continue;
+		checkedPaths.push(candidate);
+		if (isBashExePath(candidate) && exists(candidate)) return { found: true, path: candidate, source: "path" };
+	}
+
+	return missingGitBash(checkedPaths);
+}
+
+export function resolveGitBashForCurrentProcess(options = {}) {
+	return resolveGitBash({
+		platform: options.platform ?? process.platform,
+		env: options.env ?? process.env,
+		exists: existsSync,
+		where: whereCommand,
+	});
+}
+
+export async function prepareGitBashForInstall(options) {
+	const resolveGitBashWithDefaults = options.resolveGitBash
+		?? (() => resolveGitBashForCurrentProcess({ platform: options.platform, env: options.env }));
+	const initialResolution = resolveGitBashWithDefaults();
+	if (options.platform !== "win32" || initialResolution.found) return initialResolution;
+	if (options.env[SKIP_GIT_BASH_AUTO_INSTALL_ENV_KEY] === "1") return initialResolution;
+
+	try {
+		await options.runCommand("winget", WINGET_INSTALL_ARGS, { cwd: options.cwd });
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		return initialResolution;
+	}
+
+	return resolveGitBashWithDefaults();
+}
+
+function missingGitBash(checkedPaths) {
+	return {
+		found: false,
+		checkedPaths,
+		installHint: [
+			"Git Bash is required for native Windows Codex profile installs.",
+			"Install it with: winget install --id Git.Git -e --source winget",
+			`For a custom install, set ${GIT_BASH_ENV_KEY}=C:\\path\\to\\bash.exe`,
+			"Then rerun `npx lazycodex-ai install`.",
+		].join("\n"),
+	};
+}
+
+function nonEmptyEnvValue(env, key) {
+	const value = env[key];
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? undefined : trimmed;
+}
+
+function isBashExePath(path) {
+	return path.toLowerCase().endsWith("bash.exe");
+}
+
+function whereCommand(command) {
+	try {
+		return execFileSync("where", [command], { encoding: "utf8" })
+			.split(/\r?\n/)
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0);
+	} catch (error) {
+		if (error instanceof Error) return [];
+		throw error;
+	}
+}

package/packages/omo-codex/scripts/install/git-bash.test.mjs

@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { prepareGitBashForInstall, resolveGitBash } from "./git-bash.mjs";
+
+const programFilesGitBash = "C:\\Program Files\\Git\\bin\\bash.exe";
+const programFilesX86GitBash = "C:\\Program Files (x86)\\Git\\bin\\bash.exe";
+
+test("#given non-Windows platform #when resolving Git Bash #then no preflight is required", () => {
+	const result = resolveGitBash({
+		platform: "linux",
+		env: {},
+		exists: () => false,
+		where: () => [],
+	});
+
+	assert.deepEqual(result, { found: true, path: null, source: "not-required" });
+});
+
+test("#given Windows env override to bash.exe #when the file exists #then env path wins", () => {
+	const overridePath = "D:\\Tools\\Git\\bin\\bash.exe";
+	const result = resolveGitBash({
+		platform: "win32",
+		env: { OMO_CODEX_GIT_BASH_PATH: overridePath },
+		exists: (path) => path === overridePath,
+		where: () => [programFilesGitBash],
+	});
+
+	assert.deepEqual(result, { found: true, path: overridePath, source: "env" });
+});
+
+test("#given Windows standard paths are absent and PATH contains bash #when resolving #then uses where bash candidate", () => {
+	const pathCandidate = "E:\\Git\\bin\\bash.exe";
+	const result = resolveGitBash({
+		platform: "win32",
+		env: {},
+		exists: (path) => path === pathCandidate,
+		where: () => ["C:\\Windows\\System32\\bash.exe", pathCandidate],
+	});
+
+	assert.deepEqual(result, { found: true, path: pathCandidate, source: "path" });
+});
+
+test("#given Windows invalid env override #when resolving #then returns guidance without falling through", () => {
+	const overridePath = "D:\\Tools\\Git\\bin\\git.exe";
+	const result = resolveGitBash({
+		platform: "win32",
+		env: { OMO_CODEX_GIT_BASH_PATH: overridePath },
+		exists: () => true,
+		where: () => [programFilesGitBash],
+	});
+
+	assert.equal(result.found, false);
+	assert.deepEqual(result.checkedPaths, [overridePath]);
+	assert.match(result.installHint, /OMO_CODEX_GIT_BASH_PATH=C:\\path\\to\\bash\.exe/);
+});
+
+test("#given Windows without Git Bash #when resolving #then returns install guidance", () => {
+	const result = resolveGitBash({
+		platform: "win32",
+		env: {},
+		exists: () => false,
+		where: () => [],
+	});
+
+	assert.equal(result.found, false);
+	assert.deepEqual(result.checkedPaths, [programFilesGitBash, programFilesX86GitBash]);
+	assert.match(result.installHint, /winget install --id Git\.Git -e --source winget/);
+	assert.match(result.installHint, /rerun `npx lazycodex-ai install`/);
+	assert.doesNotMatch(result.installHint, /bunx/);
+});
+
+test("#given Windows without Git Bash and winget is allowed #when preparing #then winget runs and resolver retries", async () => {
+	const runCalls = [];
+	const resolutions = [
+		{ found: false, checkedPaths: [programFilesGitBash], installHint: "install hint" },
+		{ found: true, path: programFilesGitBash, source: "program-files" },
+	];
+	let resolveCallCount = 0;
+
+	const result = await prepareGitBashForInstall({
+		platform: "win32",
+		env: {},
+		cwd: "C:\\repo",
+		resolveGitBash: () => resolutions[resolveCallCount++] ?? resolutions[resolutions.length - 1],
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+	});
+
+	assert.deepEqual(runCalls, ["winget install --id Git.Git -e --source winget C:\\repo"]);
+	assert.equal(resolveCallCount, 2);
+	assert.deepEqual(result, { found: true, path: programFilesGitBash, source: "program-files" });
+});
+
+test("#given Windows without Git Bash and skip env is set #when preparing #then winget is not run and install hint remains", async () => {
+	const runCalls = [];
+	const missingResolution = {
+		found: false,
+		checkedPaths: [programFilesGitBash, programFilesX86GitBash],
+		installHint: "install hint",
+	};
+
+	const result = await prepareGitBashForInstall({
+		platform: "win32",
+		env: { OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL: "1" },
+		cwd: "C:\\repo",
+		resolveGitBash: () => missingResolution,
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+	});
+
+	assert.deepEqual(runCalls, []);
+	assert.deepEqual(result, missingResolution);
+});
+
+test("#given non-Windows platform #when preparing #then winget is never called", async () => {
+	const runCalls = [];
+	const result = await prepareGitBashForInstall({
+		platform: "linux",
+		env: {},
+		cwd: "/repo",
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+	});
+
+	assert.deepEqual(runCalls, []);
+	assert.deepEqual(result, { found: true, path: null, source: "not-required" });
+});
+
+test("#given Windows without Git Bash and winget fails #when preparing #then original install hint is preserved", async () => {
+	const missingResolution = {
+		found: false,
+		checkedPaths: [programFilesGitBash, programFilesX86GitBash],
+		installHint: "install hint",
+	};
+
+	const result = await prepareGitBashForInstall({
+		platform: "win32",
+		env: {},
+		cwd: "C:\\repo",
+		resolveGitBash: () => missingResolution,
+		runCommand: async () => {
+			throw new Error("winget unavailable");
+		},
+	});
+
+	assert.deepEqual(result, missingResolution);
+});
+
+test("#given Windows without Git Bash and winget succeeds but bash is still missing #when preparing #then install hint remains", async () => {
+	const missingResolution = {
+		found: false,
+		checkedPaths: [programFilesGitBash, programFilesX86GitBash],
+		installHint: "install hint",
+	};
+	let resolveCallCount = 0;
+
+	const result = await prepareGitBashForInstall({
+		platform: "win32",
+		env: {},
+		cwd: "C:\\repo",
+		resolveGitBash: () => {
+			resolveCallCount += 1;
+			return missingResolution;
+		},
+		runCommand: async () => {},
+	});
+
+	assert.equal(resolveCallCount, 2);
+	assert.deepEqual(result, missingResolution);
+});

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

@@ -40,7 +40,7 @@ function resolveExternalMcpPackageRoot(runtimePath, sourceRoot) {
 	if (!isPathInside(runtimePath, packagesRoot)) return undefined;
 	let packageRoot = dirname(runtimePath);
 	while (packageRoot !== packagesRoot) {
-		if (existsSync(join(packageRoot, "package.json")) && isPathInside(runtimePath, join(packageRoot, "dist"))) {
+		if (isPathInside(runtimePath, join(packageRoot, "dist")) && isRuntimePackageRoot(packageRoot)) {
 			return packageRoot;
 		}
 		const parent = dirname(packageRoot);
@@ -50,6 +50,10 @@ function resolveExternalMcpPackageRoot(runtimePath, sourceRoot) {
 	return undefined;
 }
 
+function isRuntimePackageRoot(packageRoot) {
+	return existsSync(join(packageRoot, "package.json")) || existsSync(join(packageRoot, "dist"));
+}
+
 function findPackagesRoot(path) {
 	let current = resolve(path);
 	for (let index = 0; index < 8; index++) {

package/packages/omo-codex/scripts/install/multi-agent-v2-config.mjs

@@ -4,7 +4,7 @@ const CODEX_MULTI_AGENT_V2_HEADER = "features.multi_agent_v2";
 const CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION = 10000;
 
 export function ensureCodexMultiAgentV2Config(config) {
-	const normalizedConfig = removeFeatureFlagSetting(config, "multi_agent_v2");
+	const normalizedConfig = removeLegacyAgentsMaxThreadsSetting(removeFeatureFlagSetting(config, "multi_agent_v2"));
 	const section = findTomlSection(normalizedConfig, CODEX_MULTI_AGENT_V2_HEADER);
 	const maxThreadsValue = CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION.toString();
 	if (!section) {
@@ -30,3 +30,9 @@ function removeFeatureFlagSetting(config, featureName) {
 	if (!section) return config;
 	return removeSetting(config, section, featureName);
 }
+
+function removeLegacyAgentsMaxThreadsSetting(config) {
+	const section = findTomlSection(config, "agents");
+	if (!section) return config;
+	return removeSetting(config, section, "max_threads");
+}

package/packages/omo-codex/scripts/install/permissions.d.mts

@@ -0,0 +1 @@
+export function ensureAutonomousPermissions(config: string): string;

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

@@ -0,0 +1,26 @@
+import { appendBlock, findTomlSection, removeSetting, replaceOrInsertRootSetting, replaceOrInsertSetting } from "./toml-editor.mjs";
+
+export function ensureAutonomousPermissions(config) {
+	let next = replaceOrInsertRootSetting(config, "approval_policy", JSON.stringify("never"));
+	next = replaceOrInsertRootSetting(next, "sandbox_mode", JSON.stringify("danger-full-access"));
+	next = replaceOrInsertRootSetting(next, "network_access", JSON.stringify("enabled"));
+	next = removeWindowsSandboxSetting(next);
+	next = ensureNoticeEnabled(next, "hide_full_access_warning");
+	return ensureNoticeEnabled(next, "hide_world_writable_warning");
+}
+
+function removeWindowsSandboxSetting(config) {
+	const section = findTomlSection(config, "windows");
+	if (!section) return config;
+	return removeSetting(config, section, "sandbox");
+}
+
+function ensureNoticeEnabled(config, key) {
+	const section = findTomlSection(config, "notice");
+	if (!section) return appendNoticeBlock(config, key);
+	return replaceOrInsertSetting(config, section, key, "true");
+}
+
+function appendNoticeBlock(config, key) {
+	return appendBlock(config, `[notice]\n${key} = true\n`);
+}

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/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, "\\$&");
 }