oh-my-opencode 4.7.4 → 4.8.0

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

@@ -1,19 +1,21 @@
 import assert from "node:assert/strict";
-import { mkdir, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { realpathSync } from "node:fs";
+import { mkdir, readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { basename, join, relative, sep } 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 () => {
+test("#given source plugin has an npm lockfile #when caching plugin #then lockfile is preserved for deterministic install", 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');
+	const lockfile = '{"packages":{"components/ulw-loop":{}}}\n';
+	await writeFile(join(sourceRoot, "package-lock.json"), lockfile);
 
 	// when
 	const installed = await installCachedPlugin({
@@ -26,5 +28,127 @@ test("#given source plugin has a stale npm lockfile #when caching plugin #then l
 	});
 
 	// then
-	await assert.rejects(stat(join(installed.path, "package-lock.json")));
+	assert.equal(await readFile(join(installed.path, "package-lock.json"), "utf8"), lockfile);
+});
+
+test("#given cached file dependency is rewritten #when lockfile exists #then package lock stays in sync", async () => {
+	// given
+	const root = await makeTempDir();
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(root, "packages", "omo-codex", "plugin");
+	await mkdir(sourceRoot, { recursive: true });
+	await writeFile(
+		join(sourceRoot, "package.json"),
+		JSON.stringify({
+			name: "@scope/omo",
+			version: "0.1.0",
+			dependencies: { "@scope/lsp-tools": "file:../lsp-tools-mcp" },
+		}),
+	);
+	await writeFile(
+		join(sourceRoot, "package-lock.json"),
+		JSON.stringify({
+			name: "@scope/omo",
+			version: "0.1.0",
+			lockfileVersion: 3,
+			packages: {
+				"": {
+					name: "@scope/omo",
+					version: "0.1.0",
+					dependencies: { "@scope/lsp-tools": "file:../lsp-tools-mcp" },
+				},
+				"../lsp-tools-mcp": { name: "@scope/lsp-tools", version: "0.1.0" },
+				"node_modules/@scope/lsp-tools": {
+					resolved: "../lsp-tools-mcp",
+					link: true,
+				},
+			},
+		}),
+	);
+
+	// when
+	const installed = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "debug",
+		name: "omo",
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+		runCommand: async () => {},
+	});
+
+	// then
+	const sourceDependencyPath = join(root, "packages", "omo-codex", "lsp-tools-mcp");
+	const packageLockDependencyPath = relative(realpathSync(installed.path), sourceDependencyPath).split(sep).join("/");
+	const cachedPackageJson = JSON.parse(await readFile(join(installed.path, "package.json"), "utf8"));
+	const cachedPackageLock = JSON.parse(await readFile(join(installed.path, "package-lock.json"), "utf8"));
+	assert.equal(cachedPackageJson.dependencies["@scope/lsp-tools"], `file:${sourceDependencyPath}`);
+	assert.equal(cachedPackageLock.packages[""].dependencies["@scope/lsp-tools"], `file:${sourceDependencyPath}`);
+	assert.deepEqual(cachedPackageLock.packages[packageLockDependencyPath], { name: "@scope/lsp-tools", version: "0.1.0" });
+	assert.equal(cachedPackageLock.packages["node_modules/@scope/lsp-tools"].resolved, packageLockDependencyPath);
+});
+
+test("#given existing cache #when npm install fails #then previous active cache is preserved", async () => {
+	// given
+	const root = await makeTempDir();
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(root, "plugin");
+	const cacheRoot = join(codexHome, "plugins", "cache", "debug", "omo", "0.1.0");
+	await mkdir(sourceRoot, { recursive: true });
+	await mkdir(cacheRoot, { recursive: true });
+	await writeFile(join(sourceRoot, "package.json"), JSON.stringify({ name: "@scope/omo", version: "0.1.0" }));
+	await writeFile(join(cacheRoot, "package.json"), JSON.stringify({ name: "@scope/omo-old", version: "0.0.9" }));
+
+	// when
+	await assert.rejects(
+		installCachedPlugin({
+			codexHome,
+			marketplaceName: "debug",
+			name: "omo",
+			sourcePath: sourceRoot,
+			version: "0.1.0",
+			runCommand: async (_command, args) => {
+				if (args.join(" ") === "ci --omit=dev") throw new Error("spawn npm ENOENT");
+			},
+		}),
+		/spawn npm ENOENT/,
+	);
+
+	// then
+	assert.equal(await readFile(join(cacheRoot, "package.json"), "utf8"), JSON.stringify({ name: "@scope/omo-old", version: "0.0.9" }));
+	const cacheParentEntries = await readdir(join(codexHome, "plugins", "cache", "debug", "omo"));
+	assert.deepEqual(cacheParentEntries, ["0.1.0"]);
+});
+
+test("#given existing cache #when final promotion fails #then previous active cache is restored", async () => {
+	// given
+	const root = await makeTempDir();
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(root, "plugin");
+	const cacheRoot = join(codexHome, "plugins", "cache", "debug", "omo", "0.1.0");
+	await mkdir(sourceRoot, { recursive: true });
+	await mkdir(cacheRoot, { recursive: true });
+	await writeFile(join(sourceRoot, "package.json"), JSON.stringify({ name: "@scope/omo", version: "0.1.0" }));
+	await writeFile(join(cacheRoot, "package.json"), JSON.stringify({ name: "@scope/omo-old", version: "0.0.9" }));
+
+	// when
+	await assert.rejects(
+		installCachedPlugin({
+			codexHome,
+			marketplaceName: "debug",
+			name: "omo",
+			sourcePath: sourceRoot,
+			version: "0.1.0",
+			runCommand: async () => undefined,
+			renameDirectory: async (fromPath, toPath) => {
+				if (toPath === cacheRoot && basename(fromPath).startsWith(".tmp-")) throw new Error("rename final failed");
+				await rename(fromPath, toPath);
+			},
+		}),
+		/rename final failed/,
+	);
+
+	// then
+	assert.equal(await readFile(join(cacheRoot, "package.json"), "utf8"), JSON.stringify({ name: "@scope/omo-old", version: "0.0.9" }));
+	const cacheParentEntries = await readdir(join(codexHome, "plugins", "cache", "debug", "omo"));
+	assert.deepEqual(cacheParentEntries, ["0.1.0"]);
 });

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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { parseLazyCodexInstallCliArgs } from "./install/cli-args.mjs";
+import { PASSTHROUGH_COMMANDS, formatLazyCodexInstallHelp, parseLazyCodexInstallCliArgs } from "./install/cli-args.mjs";
 
 test("#given lazycodex install flags #when parsing Node installer argv #then keeps Codex autonomous intent", () => {
 	// given
@@ -77,6 +77,41 @@ test("#given install help flag #when parsing Node installer argv #then returns h
 	assert.deepEqual(parsed, { kind: "help" });
 });
 
+test("#given installer help #when formatting usage #then includes uninstall", () => {
+	// given
+	const help = formatLazyCodexInstallHelp();
+
+	// when
+	const includesUninstall = help.includes("lazycodex-ai uninstall");
+
+	// then
+	assert.equal(includesUninstall, true);
+});
+
+test("#given installer help #when formatting usage #then advertises every pass-through command it actually delegates", () => {
+	// given
+	const help = formatLazyCodexInstallHelp();
+
+	// when
+	const missing = [...PASSTHROUGH_COMMANDS].filter((command) => !help.includes(command));
+
+	// then
+	assert.deepEqual(missing, []);
+});
+
+test("#given installer help #when formatting usage #then documents update and version entry points", () => {
+	// given
+	const help = formatLazyCodexInstallHelp();
+
+	// when
+	const includesUpdate = help.includes("lazycodex-ai update");
+	const includesVersion = help.includes("lazycodex-ai version");
+
+	// then
+	assert.equal(includesUpdate, true);
+	assert.equal(includesVersion, true);
+});
+
 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"];
@@ -113,6 +148,36 @@ test("#given dry-run doctor command #when parsing Node installer argv #then retu
 	});
 });
 
+test("#given update command #when parsing Node installer argv #then returns lazycodex update intent", () => {
+	// given
+	const argv = ["update"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "update",
+		dryRun: false,
+		repoRoot: undefined,
+	});
+});
+
+test("#given dry-run update with repo root #when parsing Node installer argv #then keeps local update intent", () => {
+	// given
+	const argv = ["--dry-run", "update", "--repo-root=/tmp/omo"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "update",
+		dryRun: true,
+		repoRoot: "/tmp/omo",
+	});
+});
+
 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"];
@@ -129,6 +194,22 @@ test("#given dry-run cleanup command #when parsing Node installer argv #then ret
 	});
 });
 
+test("#given uninstall command #when parsing Node installer argv #then returns delegated codex cleanup command", () => {
+	// given
+	const argv = ["uninstall", "--project", "/tmp/lazycodex-qa"];
+
+	// when
+	const parsed = parseLazyCodexInstallCliArgs(argv);
+
+	// then
+	assert.deepEqual(parsed, {
+		kind: "command",
+		command: "cleanup",
+		dryRun: false,
+		args: ["--project", "/tmp/lazycodex-qa"],
+	});
+});
+
 test("#given doctor flags #when parsing Node installer argv #then preserves pass-through arguments", () => {
 	// given
 	const argv = ["doctor", "--json"];

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

@@ -0,0 +1,43 @@
+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 unrelated Codex config tables #when script installer updates config #then preserves them", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-unrelated-tables-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[features]",
+			"plugins = false",
+			"",
+			"[tui]",
+			'hud = "compact"',
+			"",
+			"[shell_environment_policy]",
+			'inherit = "core"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[features\][\s\S]*plugins = true/);
+	assert.match(config, /\[tui\][\s\S]*hud = "compact"/);
+	assert.match(config, /\[shell_environment_policy\][\s\S]*inherit = "core"/);
+	assert.match(config, /\[plugins\."omo@sisyphuslabs"\]/);
+});

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

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import test from "node:test";
 
 import { updateCodexConfig } from "./install/config.mjs";
+import { readCodexModelCatalog } from "./install/model-catalog.mjs";
 
 test("#given empty Codex config #when script installer updates config #then sets worker model and reasoning defaults", async () => {
 	// given
@@ -35,7 +36,7 @@ test("#given existing model and reasoning config #when script installer updates
 	await writeFile(
 		configPath,
 		[
-			'model = "gpt-5.2"',
+			'model = "gpt-5.5"',
 			"model_context_window = 272000",
 			'model_reasoning_effort = "low"',
 			'plan_mode_reasoning_effort = "medium"',
@@ -139,3 +140,15 @@ test("#given bundled model catalog #when script installer updates config #then r
 	assert.match(content, /model_reasoning_effort = "medium"/);
 	assert.match(content, /plan_mode_reasoning_effort = "high"/);
 });
+
+test("#given fallback model catalog #when catalog file is unavailable #then no managed preset uses pure GPT-5.4", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-fallback-catalog-"));
+
+	// when
+	const catalog = await readCodexModelCatalog(root);
+
+	// then
+	assert.equal(catalog.current.model, "gpt-5.5");
+	assert.equal(catalog.managedProfiles.some((profile) => profile.model === "gpt-5.4"), false);
+});

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

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { lstat, mkdtemp, readFile, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -48,6 +48,29 @@ test("#given empty Codex config #when script installer updates config #then leav
 	assert.doesNotMatch(config, /YOUR_API_KEY/);
 });
 
+test("#given sisyphuslabs omo install #when script installer updates config #then enables Context7 plugin mcp policy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-context7-plugin-policy-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.context7\]/);
+	assert.match(config, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.context7\][\s\S]*?enabled = true/);
+	assert.doesNotMatch(config, /\[mcp_servers\.context7\]/);
+	assert.doesNotMatch(config, /@upstash\/context7-mcp/);
+	assert.doesNotMatch(config, /YOUR_API_KEY/);
+});
+
 test("#given existing Context7 MCP config #when script installer updates config #then leaves user setup untouched", async () => {
 	// given
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-context7-existing-"));
@@ -81,6 +104,31 @@ test("#given existing Context7 MCP config #when script installer updates config
 	assert.doesNotMatch(config, /YOUR_API_KEY/);
 });
 
+test("#given Codex config is a symlink #when script installer updates config #then writes through the target", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-symlink-"));
+	const targetPath = join(root, "actual-config.toml");
+	const configPath = join(root, "config.toml");
+	await writeFile(targetPath, "[features]\nplugins = false\n");
+	await symlink(targetPath, configPath);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const configStat = await lstat(configPath);
+	const targetConfig = await readFile(targetPath, "utf8");
+	assert.equal(configStat.isSymbolicLink(), true);
+	assert.match(targetConfig, /plugins = true/);
+	assert.match(targetConfig, /\[plugins\."omo@sisyphuslabs"\]/);
+});
+
 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-"));

package/packages/omo-codex/scripts/install-lazycodex-version-stamp.test.mjs

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { readFile } 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";
+
+test("#given sisyphuslabs lazycodex install #when installing locally #then stamps the distribution version", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+
+	await writeJson(join(repoRoot, "package.json"), { name: "lazycodex-ai", version: "4.7.6" });
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "sisyphuslabs",
+		plugins: [{ name: "omo", source: "./plugin" }],
+	});
+	await writePluginAt(pluginRoot, "omo", "0.1.0");
+	await writeJson(join(pluginRoot, "components", "ulw-loop", "package.json"), {
+		name: "@code-yeongyu/codex-ulw-loop",
+		version: "0.1.0",
+	});
+	await writeJson(join(pluginRoot, "components", "ulw-loop", "hooks", "hooks.json"), {
+		hooks: {
+			UserPromptSubmit: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook user-prompt-submit',
+							statusMessage: "LazyCodex(0.1.0): Checking Ulw-Loop Steering",
+						},
+					],
+				},
+			],
+		},
+	});
+	await writeJson(join(pluginRoot, "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking Comments",
+						},
+					],
+				},
+			],
+		},
+	});
+
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		platform: "linux",
+		runCommand: async () => {},
+		log: () => {},
+	});
+
+	const cacheRoot = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "4.7.6");
+	assert.equal(result.installed[0].version, "4.7.6");
+	assert.equal(result.installed[0].path, cacheRoot);
+	const manifest = JSON.parse(await readFile(join(cacheRoot, ".codex-plugin", "plugin.json"), "utf8"));
+	const packageJson = JSON.parse(await readFile(join(cacheRoot, "package.json"), "utf8"));
+	const componentPackageJson = JSON.parse(await readFile(join(cacheRoot, "components", "ulw-loop", "package.json"), "utf8"));
+	const hooks = JSON.parse(await readFile(join(cacheRoot, "hooks", "hooks.json"), "utf8"));
+	const componentHooks = JSON.parse(await readFile(join(cacheRoot, "components", "ulw-loop", "hooks", "hooks.json"), "utf8"));
+	const snapshot = JSON.parse(await readFile(join(cacheRoot, "lazycodex-install.json"), "utf8"));
+	assert.equal(manifest.version, "4.7.6");
+	assert.equal(packageJson.version, "4.7.6");
+	assert.equal(componentPackageJson.version, "4.7.6");
+	assert.equal(hooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(4.7.6): Checking Comments");
+	assert.equal(componentHooks.hooks.UserPromptSubmit[0].hooks[0].statusMessage, "LazyCodex(4.7.6): Checking Ulw-Loop Steering");
+	assert.deepEqual(snapshot, {
+		packageName: "lazycodex-ai",
+		version: "4.7.6",
+	});
+});

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

@@ -115,6 +115,57 @@ test("#given dry-run cleanup #when running the Node installer entrypoint #then p
 	assert.equal(output, "npx --yes --package oh-my-openagent omo cleanup --platform=codex --project /tmp/lazycodex-qa");
 });
 
+test("#given dry-run uninstall #when running the Node installer entrypoint #then prints delegated codex cleanup command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "uninstall", "--project", "/tmp/lazycodex-qa"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo cleanup --platform=codex --project /tmp/lazycodex-qa");
+});
+
+test("#given stale lazycodex version #when running update dry-run #then prints the latest installer command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--dry-run", "update"], {
+		encoding: "utf8",
+		env: {
+			...process.env,
+			LAZYCODEX_CURRENT_VERSION: "1.0.0",
+			LAZYCODEX_LATEST_VERSION: "1.0.1",
+		},
+	}).trim();
+
+	// then
+	assert.equal(output, "npx --yes lazycodex-ai@latest install --no-tui --codex-autonomous");
+});
+
+test("#given current lazycodex version #when running update dry-run #then reports already current", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--dry-run", "update"], {
+		encoding: "utf8",
+		env: {
+			...process.env,
+			LAZYCODEX_CURRENT_VERSION: "1.0.1",
+			LAZYCODEX_LATEST_VERSION: "1.0.1",
+		},
+	}).trim();
+
+	// then
+	assert.equal(output, "lazycodex-ai 1.0.1 is already up to date.");
+});
+
 test("#given dry-run ulw-loop #when running the Node installer entrypoint #then prints delegated ulw-loop command", () => {
 	// given
 	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));