oh-my-opencode 4.9.2 → 4.11.0

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

@@ -1,81 +0,0 @@
-import { existsSync } from "node:fs";
-import { cp } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-
-export function createCachedMcpRuntimeArgRewriter({ copyDist = cp } = {}) {
-	const copiedDistRoots = new Map();
-	return async function rewriteCachedMcpRuntimeArg({ arg, pluginRoot, serverName, sourceRoot }) {
-		return rewriteCachedMcpRuntimeArgWithCache({ arg, pluginRoot, serverName, sourceRoot }, { copiedDistRoots, copyDist });
-	};
-}
-
-export async function rewriteCachedMcpRuntimeArg(args) {
-	return createCachedMcpRuntimeArgRewriter()(args);
-}
-
-async function rewriteCachedMcpRuntimeArgWithCache({ arg, pluginRoot, serverName, sourceRoot }, { copiedDistRoots, copyDist }) {
-	if (typeof arg !== "string" || (!arg.startsWith("./") && !arg.startsWith("../"))) return arg;
-	const fallback = resolveCachedRuntimePath(pluginRoot, sourceRoot, arg);
-	const targetPath = resolve(pluginRoot, arg);
-	const runtimePath = isPathInside(targetPath, pluginRoot) ? targetPath : resolve(sourceRoot, arg);
-	const packageRoot = resolveExternalMcpPackageRoot(runtimePath, sourceRoot);
-	if (packageRoot === undefined) return fallback;
-	const distRoot = join(packageRoot, "dist");
-	const distPath = relative(distRoot, runtimePath);
-	if (distPath.startsWith("..") || isAbsolute(distPath)) return fallback;
-	const cachedRoot = join(pluginRoot, "mcp", safePathSegment(serverName));
-	const cacheKey = `${distRoot}\0${cachedRoot}`;
-	let copyPromise = copiedDistRoots.get(cacheKey);
-	if (copyPromise === undefined) {
-		copyPromise = copyDist(distRoot, join(cachedRoot, "dist"), { recursive: true });
-		copiedDistRoots.set(cacheKey, copyPromise);
-	}
-	await copyPromise;
-	return join(cachedRoot, "dist", distPath);
-}
-
-function resolveExternalMcpPackageRoot(runtimePath, sourceRoot) {
-	const packagesRoot = findPackagesRoot(sourceRoot);
-	if (packagesRoot === undefined) return undefined;
-	if (!isPathInside(runtimePath, packagesRoot)) return undefined;
-	let packageRoot = dirname(runtimePath);
-	while (packageRoot !== packagesRoot) {
-		if (isPathInside(runtimePath, join(packageRoot, "dist")) && isRuntimePackageRoot(packageRoot)) {
-			return packageRoot;
-		}
-		const parent = dirname(packageRoot);
-		if (parent === packageRoot) return undefined;
-		packageRoot = parent;
-	}
-	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++) {
-		if (basename(current) === "packages") return current;
-		const parent = dirname(current);
-		if (parent === current) return undefined;
-		current = parent;
-	}
-	return undefined;
-}
-
-function resolveCachedRuntimePath(pluginRoot, sourceRoot, runtimePath) {
-	const targetPath = resolve(pluginRoot, runtimePath);
-	if (isPathInside(targetPath, pluginRoot)) return targetPath;
-	return resolve(sourceRoot, runtimePath);
-}
-
-function isPathInside(candidatePath, rootPath) {
-	const pathFromRoot = relative(rootPath, candidatePath);
-	return pathFromRoot === "" || (!pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot));
-}
-
-function safePathSegment(value) {
-	return value.replace(/[^A-Za-z0-9._-]/g, "_");
-}

package/packages/omo-codex/scripts/install/model-catalog.mjs

@@ -1,74 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const FALLBACK_CODEX_MODEL_CATALOG = {
-	current: {
-		model: "gpt-5.5",
-		modelContextWindow: 400_000,
-		modelReasoningEffort: "high",
-		planModeReasoningEffort: "xhigh",
-	},
-	managedProfiles: [
-		{
-			model: "gpt-5.5",
-			modelContextWindow: 1_000_000,
-			modelReasoningEffort: "high",
-			planModeReasoningEffort: "xhigh",
-		},
-		{ model: "gpt-5.5", modelContextWindow: 272_000 },
-	],
-};
-
-export async function readCodexModelCatalog(codexPackageRoot) {
-	try {
-		const parsed = JSON.parse(await readFile(join(codexPackageRoot, "plugin", "model-catalog.json"), "utf8"));
-		return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
-	} catch (error) {
-		if (!(error instanceof Error)) throw error;
-		return FALLBACK_CODEX_MODEL_CATALOG;
-	}
-}
-
-export async function readCodexReasoningProfile(codexPackageRoot) {
-	return (await readCodexModelCatalog(codexPackageRoot)).current;
-}
-
-function parseCodexModelCatalog(value) {
-	if (!isRecord(value) || !isRecord(value.current) || !Array.isArray(value.managedProfiles)) return null;
-	const { current } = value;
-	if (
-		typeof current.model !== "string" ||
-		typeof current.model_context_window !== "number" ||
-		typeof current.model_reasoning_effort !== "string" ||
-		typeof current.plan_mode_reasoning_effort !== "string"
-	) {
-		return null;
-	}
-	const managedProfiles = [];
-	for (const profile of value.managedProfiles) {
-		if (!isRecord(profile) || !isRecord(profile.match)) return null;
-		managedProfiles.push(parseProfileMatch(profile.match));
-	}
-	return {
-		current: {
-			model: current.model,
-			modelContextWindow: current.model_context_window,
-			modelReasoningEffort: current.model_reasoning_effort,
-			planModeReasoningEffort: current.plan_mode_reasoning_effort,
-		},
-		managedProfiles,
-	};
-}
-
-function parseProfileMatch(match) {
-	const profile = {};
-	if (typeof match.model === "string") profile.model = match.model;
-	if (typeof match.model_context_window === "number") profile.modelContextWindow = match.model_context_window;
-	if (typeof match.model_reasoning_effort === "string") profile.modelReasoningEffort = match.model_reasoning_effort;
-	if (typeof match.plan_mode_reasoning_effort === "string") profile.planModeReasoningEffort = match.plan_mode_reasoning_effort;
-	return profile;
-}
-
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

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

@@ -1,50 +0,0 @@
-import { appendBlock, findTomlSection, removeSetting, replaceOrInsertSetting } from "./toml-editor.mjs";
-
-const CODEX_MULTI_AGENT_V2_HEADER = "features.multi_agent_v2";
-const CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION = 10000;
-
-/**
- * Configure multi_agent_v2 thread limits without forcing the feature on.
- *
- * Whether V2 is active is determined at runtime by the model's server-side
- * catalog entry (ModelInfo.multi_agent_version).  Forcing enabled = true
- * in config breaks models whose API does not support encrypted tool
- * parameters.  The installer therefore only sets the tuning knob
- * (max_concurrent_threads_per_session) so that sessions that DO activate
- * V2 benefit from the higher limit.
- */
-export function ensureCodexMultiAgentV2Config(config) {
-	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) {
-		return appendBlock(
-			normalizedConfig,
-			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nmax_concurrent_threads_per_session = ${maxThreadsValue}\nhide_spawn_agent_metadata = false\n`,
-		);
-	}
-
-	// Codex defaults hide_spawn_agent_metadata to true on V2, which strips the
-	// agent_type parameter from spawn_agent and makes the role TOMLs this
-	// installer ships unselectable.
-	const withMaxThreads = replaceOrInsertSetting(
-		normalizedConfig,
-		section,
-		"max_concurrent_threads_per_session",
-		maxThreadsValue,
-	);
-	const updatedSection = findTomlSection(withMaxThreads, CODEX_MULTI_AGENT_V2_HEADER);
-	return replaceOrInsertSetting(withMaxThreads, updatedSection, "hide_spawn_agent_metadata", "false");
-}
-
-function removeFeatureFlagSetting(config, featureName) {
-	const section = findTomlSection(config, "features");
-	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

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

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

@@ -1,37 +0,0 @@
-import { appendBlock, findTomlSection, removeSetting, replaceOrInsertRootSetting, replaceOrInsertSetting } from "./toml-editor.mjs";
-
-const AUTONOMOUS_FEATURES = ["multi_agent", "child_agents_md", "unified_exec", "goals"];
-
-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"));
-	for (const featureName of AUTONOMOUS_FEATURES) {
-		next = ensureFeatureEnabled(next, featureName);
-	}
-	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 ensureFeatureEnabled(config, key) {
-	const section = findTomlSection(config, "features");
-	if (!section) return appendBlock(config, `[features]\n${key} = true\n`);
-	return replaceOrInsertSetting(config, section, key, "true");
-}
-
-function appendNoticeBlock(config, key) {
-	return appendBlock(config, `[notice]\n${key} = true\n`);
-}

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

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

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

@@ -1,228 +0,0 @@
-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 = [
-	".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

@@ -1,72 +0,0 @@
-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/snapshot.mjs

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

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

@@ -1,20 +0,0 @@
-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);
-}