oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/scripts/install/toml-editor.mjs

@@ -0,0 +1,47 @@
+export function findTomlSection(config, header) {
+	const headerLine = `[${header}]`;
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let start = -1;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const trimmed = line.trim();
+		if (start === -1) {
+			if (trimmed === headerLine) start = offset;
+		} else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+			return { start, end: offset, text: config.slice(start, offset) };
+		}
+		offset += line.length;
+	}
+	if (start === -1) return null;
+	return { start, end: config.length, text: config.slice(start) };
+}
+
+export function replaceOrInsertSetting(config, section, key, value) {
+	const linePattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, "m");
+	const replacement = linePattern.test(section.text)
+		? section.text.replace(linePattern, `${key} = ${value}`)
+		: insertSetting(section.text, key, value);
+	return config.slice(0, section.start) + replacement + config.slice(section.end);
+}
+
+export function removeSetting(config, section, key) {
+	const linePattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*(?:\\n|$)`, "m");
+	const replacement = section.text.replace(linePattern, "");
+	return config.slice(0, section.start) + replacement + config.slice(section.end);
+}
+
+export function appendBlock(config, block) {
+	const prefix = config.trimEnd();
+	return `${prefix}${prefix.length > 0 ? "\n\n" : ""}${block.trimEnd()}\n`;
+}
+
+function insertSetting(sectionText, key, value) {
+	const lines = sectionText.split("\n");
+	lines.splice(1, 0, `${key} = ${value}`);
+	return lines.join("\n");
+}
+
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -0,0 +1,15 @@
+import { constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+
+export async function exists(path) {
+	try {
+		await access(path, fsConstants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, readFile, readlink, rm, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installMarketplaceLocally } from "./install-local.mjs";
+import { makeTempDir, writeJson, writePluginAt } from "./install-test-fixtures.mjs";
+
+const legacyCodexPluginMarketplace = ["code", "yeongyu", "codex", "plugins"].join("-");
+
+test(
+	"#given bundled agent roles and stale legacy links #when installing locally #then relinks Codex agents to marketplace snapshot",
+	{ skip: process.platform === "win32" ? "Windows copies agent files instead of symlinking them" : false },
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		for (const agentName of ["explorer", "librarian", "plan"]) {
+			await writeFile(join(agentsRoot, `${agentName}.toml`), `name = "${agentName}"\n`);
+		}
+		await mkdir(join(codexHome, "agents"), { recursive: true });
+		await symlink(
+			join(codexHome, "plugins", "cache", legacyCodexPluginMarketplace, "omo", "0.1.0", "components", "ultrawork", "agents", "explorer.toml"),
+			join(codexHome, "agents", "explorer.toml"),
+		);
+
+		const result = await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		assert.equal(result.installed.length, 1);
+		const snapshotPluginPath = join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo");
+		for (const agentName of ["explorer", "librarian", "plan"]) {
+			const agentPath = join(codexHome, "agents", `${agentName}.toml`);
+			assert.equal((await lstat(agentPath)).isSymbolicLink(), true);
+			assert.equal(await readlink(agentPath), join(snapshotPluginPath, "components", "ultrawork", "agents", `${agentName}.toml`));
+			assert.equal(await readFile(agentPath, "utf8"), `name = "${agentName}"\n`);
+		}
+
+		const installedAgents = JSON.parse(await readFile(join(snapshotPluginPath, ".installed-agents.json"), "utf8"));
+		assert.deepEqual(installedAgents.agents.sort(), [
+			join(codexHome, "agents", "explorer.toml"),
+			join(codexHome, "agents", "librarian.toml"),
+			join(codexHome, "agents", "plan.toml"),
+		]);
+	},
+);
+
+test(
+	"#given local sisyphuslabs install #when plugin cache is pruned #then agent links still resolve through marketplace snapshot",
+	{ skip: process.platform === "win32" ? "Windows copies agent files instead of symlinking them" : false },
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		await writeFile(join(agentsRoot, "explorer.toml"), 'name = "explorer"\n');
+		const snapshotRoot = join(codexHome, ".tmp", "marketplaces", "sisyphuslabs");
+		await mkdir(join(snapshotRoot, ".git"), { recursive: true });
+		await writeFile(join(snapshotRoot, ".git", "config"), "[remote \"origin\"]\n");
+		await writeFile(join(snapshotRoot, ".codex-marketplace-install.json"), '{"source_type":"git"}\n');
+
+		const result = await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		const pluginPath = result.installed[0].path;
+		await rm(pluginPath, { recursive: true, force: true });
+
+		const agentPath = join(codexHome, "agents", "explorer.toml");
+		assert.equal(
+			await readlink(agentPath),
+			join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", "components", "ultrawork", "agents", "explorer.toml"),
+		);
+		assert.equal(await readFile(agentPath, "utf8"), 'name = "explorer"\n');
+		assert.equal(await readFile(join(snapshotRoot, ".git", "config"), "utf8"), "[remote \"origin\"]\n");
+		assert.equal(await readFile(join(snapshotRoot, ".codex-marketplace-install.json"), "utf8"), '{"source_type":"git"}\n');
+	},
+);

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

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { linkCachedPluginBins } from "./install/cache.mjs";
+import { makeTempDir, writeJson } from "./install-test-fixtures.mjs";
+
+test("#given Windows platform #when linking cached plugin bins #then writes command shims", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+
+	await mkdir(pluginRoot, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/alpha",
+		bin: {
+			alpha: "./dist/cli.js",
+		},
+	});
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+
+	const linked = await linkCachedPluginBins({ binDir, pluginRoot, platform: "win32" });
+
+	assert.deepEqual(linked, [{ name: "alpha", path: join(binDir, "alpha.cmd"), target: join(pluginRoot, "dist", "cli.js") }]);
+	const shim = await readFile(join(binDir, "alpha.cmd"), "utf8");
+	assert.match(shim, /@echo off/);
+	assert.match(shim, new RegExp(`node "${join(pluginRoot, "dist", "cli.js").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}" %\\*`));
+});
+
+test("#given existing custom Windows command shim #when linking bins #then rejects without overwriting", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+
+	await mkdir(pluginRoot, { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/alpha",
+		bin: {
+			alpha: "./dist/cli.js",
+		},
+	});
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(join(binDir, "alpha.cmd"), "@echo off\r\necho custom\r\n");
+
+	await assert.rejects(
+		linkCachedPluginBins({ binDir, pluginRoot, platform: "win32" }),
+		/already exists and is not a generated command shim/,
+	);
+	assert.match(await readFile(join(binDir, "alpha.cmd"), "utf8"), /echo custom/);
+});
+
+test("#given managed legacy Codex component symlink #when linking bins #then removes stale symlink and writes OMO bin", 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", "rules", "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", "rules", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "omo-rules": "./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-rules"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	await assert.rejects(readlink(join(binDir, "codex-rules")));
+	assert.equal(await readlink(join(binDir, "omo-rules")), 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");
+	const binDir = join(root, "bin");
+	const userTarget = join(root, "user-tools", "codex-rules");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "user-tools"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(userTarget, "#!/usr/bin/env node\n");
+	await symlink(userTarget, join(binDir, "codex-rules"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	assert.equal(await readlink(join(binDir, "codex-rules")), userTarget);
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
+});
+
+test("#given user-owned legacy Codex symlink with component-like target #when linking bins #then preserves it", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const userTarget = join(root, "workspace", "components", "rules", "dist", "cli.js");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "workspace", "components", "rules", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(userTarget, "#!/usr/bin/env node\n");
+	await symlink(userTarget, join(binDir, "codex-rules"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	assert.equal(await readlink(join(binDir, "codex-rules")), userTarget);
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
+});

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

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installCachedPlugin } from "./install/cache.mjs";
+import { makeTempDir } from "./install-test-fixtures.mjs";
+
+test("#given source plugin has a stale npm lockfile #when caching plugin #then lockfile is regenerated rather than copied", async () => {
+	// given
+	const root = await makeTempDir();
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(root, "plugin");
+	await mkdir(sourceRoot, { recursive: true });
+	await writeFile(join(sourceRoot, "package.json"), JSON.stringify({ name: "@scope/omo", version: "0.1.0" }));
+	await writeFile(join(sourceRoot, "package-lock.json"), '{"packages":{"components/ulw-loop":{}}}\n');
+
+	// when
+	const installed = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "debug",
+		name: "omo",
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+		runCommand: async () => {},
+	});
+
+	// then
+	await assert.rejects(stat(join(installed.path, "package-lock.json")));
+});

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

@@ -0,0 +1,118 @@
+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 empty Codex config #when script installer updates config #then enables MultiAgentV2 with ten thousand session threads", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[features\.multi_agent_v2\]/);
+	assert.match(config, /enabled = true/);
+	assert.match(config, /max_concurrent_threads_per_session = 10000/);
+});
+
+test("#given sisyphuslabs config without explicit source #when script installer updates config #then uses local marketplace", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-sisyphuslabs-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[marketplaces\.sisyphuslabs\]/);
+	assert.match(config, /source_type = "local"/);
+	assert.match(config, /source = "\/repo\/packages\/omo-codex"/);
+	assert.doesNotMatch(config, /lazycodex\.git/);
+	assert.doesNotMatch(config, /ref = "main"/);
+});
+
+test("#given existing MultiAgentV2 table #when script installer updates config #then preserves unrelated tuning while setting ten thousand session threads", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-existing-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = false",
+			"usage_hint_enabled = false",
+			"max_concurrent_threads_per_session = 4",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[features\.multi_agent_v2\]/);
+	assert.match(config, /enabled = true/);
+	assert.match(config, /usage_hint_enabled = false/);
+	assert.match(config, /max_concurrent_threads_per_session = 10000/);
+	assert.doesNotMatch(config, /max_concurrent_threads_per_session = 4/);
+});
+
+test("#given legacy boolean MultiAgentV2 flag and table #when script installer updates config #then normalizes to table config", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-legacy-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[features]",
+			"multi_agent_v2 = true",
+			"plugins = false",
+			"",
+			"[features.multi_agent_v2]",
+			"usage_hint_enabled = false",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.doesNotMatch(config, /^multi_agent_v2\s*=/m);
+	assert.match(config, /\[features\.multi_agent_v2\]/);
+	assert.match(config, /enabled = true/);
+	assert.match(config, /usage_hint_enabled = false/);
+	assert.match(config, /max_concurrent_threads_per_session = 10000/);
+});

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

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+	installCachedPlugin,
+	linkCachedPluginBins,
+	pruneMarketplaceCache,
+	pruneMarketplacePluginCaches,
+} from "./install/cache.mjs";
+import { linkCachedPluginAgents } from "./install/agents.mjs";
+import { updateCodexConfig } from "./install/config.mjs";
+import { trustedHookStatesForPlugin } from "./install/hook-trust.mjs";
+import { defaultRunCommand } from "./install/process.mjs";
+import { writeInstalledMarketplaceSnapshot } from "./install/snapshot.mjs";
+import {
+	readMarketplace,
+	readPluginManifest,
+	resolvePluginSource,
+	validatePathSegment,
+} from "./install/marketplace.mjs";
+
+const LEGACY_CODEX_PLUGIN_MARKETPLACE = ["code", "yeongyu", "codex", "plugins"].join("-");
+const SISYPHUS_LEGACY_CACHE_MARKETPLACES = ["lazycodex", LEGACY_CODEX_PLUGIN_MARKETPLACE];
+
+export function resolveCodexInstallerBinDir(options = {}) {
+	const homeDir = resolve(options.homeDir ?? homedir());
+	const env = options.env ?? process.env;
+	const explicitBinDir = nonEmptyEnvValue(env, "CODEX_LOCAL_BIN_DIR");
+	if (explicitBinDir !== undefined) return explicitBinDir;
+
+	const codexHome = resolve(options.codexHome ?? nonEmptyEnvValue(env, "CODEX_HOME") ?? join(homeDir, ".codex"));
+	const defaultCodexHome = resolve(join(homeDir, ".codex"));
+	return codexHome === defaultCodexHome ? join(homeDir, ".local", "bin") : join(codexHome, "bin");
+}
+
+export async function installMarketplaceLocally(options = {}) {
+	const repoRoot = resolve(options.repoRoot ?? process.cwd());
+	const env = options.env ?? process.env;
+	const homeDir = resolve(options.homeDir ?? homedir());
+	const codexHome = resolve(options.codexHome ?? nonEmptyEnvValue(env, "CODEX_HOME") ?? join(homeDir, ".codex"));
+	const binDir = resolve(options.binDir ?? resolveCodexInstallerBinDir({ codexHome, env, homeDir }));
+	const platform = options.platform ?? process.platform;
+	const runCommand = options.runCommand ?? defaultRunCommand;
+	const log = options.log ?? console.log;
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const marketplace = await readMarketplace(repoRoot, {
+		marketplacePath: join(codexPackageRoot, "marketplace.json"),
+	});
+	const installed = [];
+	const pluginSources = [];
+	const agentConfigs = new Map();
+
+	for (const entry of marketplace.plugins) {
+		const sourcePath = resolvePluginSource(codexPackageRoot, entry, { pathOverride: "./plugin" });
+		const manifest = await readPluginManifest(sourcePath);
+		if (manifest.name !== entry.name) {
+			throw new Error(
+				`plugin manifest name ${JSON.stringify(manifest.name)} does not match marketplace name ${JSON.stringify(entry.name)}`,
+			);
+		}
+		const version = manifest.version ?? "local";
+		validatePathSegment(version, "plugin version");
+
+		log(`Building ${entry.name}@${version}`);
+		const plugin = await installCachedPlugin({
+			codexHome,
+			marketplaceName: marketplace.name,
+			name: entry.name,
+			runCommand,
+			sourcePath,
+			version,
+		});
+		const binLinks = await linkCachedPluginBins({ binDir, pluginRoot: plugin.path, platform });
+		for (const link of binLinks) {
+			log(`Linked ${link.name} -> ${link.target}`);
+		}
+		pluginSources.push({ name: entry.name, sourcePath });
+		installed.push(plugin);
+	}
+
+	const agentSourceRoots = await agentSourceRootsForInstall({ codexHome, marketplace, installed, pluginSources });
+	for (const plugin of installed) {
+		const pluginRoot = agentSourceRoots.get(plugin.name) ?? plugin.path;
+		const agentLinks = await linkCachedPluginAgents({ codexHome, pluginRoot, platform });
+		for (const link of agentLinks) {
+			log(`Linked agent ${link.name} -> ${link.target}`);
+			const agentName = agentNameFromToml(link.name);
+			agentConfigs.set(agentName, { name: agentName, configFile: `./agents/${link.name}` });
+		}
+	}
+
+	const pluginNames = marketplace.plugins.map((plugin) => plugin.name);
+	const trustedHookStates = (
+		await Promise.all(
+			installed.map((plugin) =>
+				trustedHookStatesForPlugin({
+					marketplaceName: marketplace.name,
+					pluginName: plugin.name,
+					pluginRoot: plugin.path,
+				}),
+			),
+		)
+	).flat();
+	await pruneMarketplaceCache({ codexHome, marketplaceName: marketplace.name, keepPluginNames: pluginNames });
+	for (const legacyMarketplaceName of legacyCacheMarketplaces(marketplace.name)) {
+		await pruneMarketplacePluginCaches({ codexHome, marketplaceName: legacyMarketplaceName, pluginNames });
+	}
+	const marketplaceRoot = join(codexHome, "plugins", "cache", marketplace.name);
+	await writeCachedMarketplaceManifest({
+		marketplaceName: marketplace.name,
+		marketplaceRoot,
+		plugins: installed,
+	});
+	await updateCodexConfig({
+		configPath: join(codexHome, "config.toml"),
+		repoRoot: codexPackageRoot,
+		marketplaceName: marketplace.name,
+		marketplaceSource: { sourceType: "local", source: marketplaceRoot },
+		pluginNames,
+		trustedHookStates,
+		agentConfigs: [...agentConfigs.values()].sort((left, right) => left.name.localeCompare(right.name)),
+	});
+
+	for (const plugin of installed) {
+		log(`Installed ${plugin.name}@${marketplace.name} -> ${plugin.path}`);
+	}
+
+	return { marketplaceName: marketplace.name, installed };
+}
+
+function agentNameFromToml(fileName) {
+	return fileName.endsWith(".toml") ? fileName.slice(0, -".toml".length) : fileName;
+}
+
+async function agentSourceRootsForInstall({ codexHome, marketplace, installed, pluginSources }) {
+	if (marketplace.name !== "sisyphuslabs") {
+		return new Map(installed.map((plugin) => [plugin.name, plugin.path]));
+	}
+	const snapshotPlugins = await writeInstalledMarketplaceSnapshot({
+		codexHome,
+		marketplace,
+		plugins: pluginSources,
+	});
+	return new Map(snapshotPlugins.map((plugin) => [plugin.name, plugin.path]));
+}
+
+async function writeCachedMarketplaceManifest({ marketplaceName, marketplaceRoot, plugins }) {
+	const marketplaceDir = join(marketplaceRoot, ".agents", "plugins");
+	await mkdir(marketplaceDir, { recursive: true });
+	await writeFile(
+		join(marketplaceDir, "marketplace.json"),
+		`${JSON.stringify(
+			{
+				name: marketplaceName,
+				plugins: plugins.map((plugin) => ({
+					name: plugin.name,
+					source: { source: "local", path: `./${plugin.name}/${plugin.version}` },
+				})),
+			},
+			null,
+			"\t",
+		)}\n`,
+	);
+}
+
+function nonEmptyEnvValue(env, key) {
+	const value = env[key];
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? undefined : value;
+}
+
+function legacyCacheMarketplaces(marketplaceName) {
+	return marketplaceName === "sisyphuslabs" ? SISYPHUS_LEGACY_CACHE_MARKETPLACES : [];
+}
+
+async function main() {
+	const repoRoot = process.argv[2] ? resolve(process.argv[2]) : process.cwd();
+	const result = await installMarketplaceLocally({ repoRoot });
+	console.log(`Installed ${result.installed.length} plugin(s) from ${result.marketplaceName}.`);
+}
+
+const invokedPath = process.argv[1] ? resolve(process.argv[1]) : "";
+if (invokedPath === fileURLToPath(import.meta.url)) {
+	main().catch((error) => {
+		console.error(error instanceof Error ? error.message : error);
+		process.exitCode = 1;
+	});
+}