oh-my-opencode 4.5.12 → 4.6.0

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

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

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

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

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

@@ -0,0 +1,62 @@
+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 sets default and Plan-mode reasoning effort", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-reasoning-"));
+	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 content = await readFile(configPath, "utf8");
+	assert.match(content, /model_reasoning_effort = "high"/);
+	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
+});
+
+test("#given existing reasoning config #when script installer updates config #then replaces stale defaults without duplicate keys", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-reasoning-existing-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model_reasoning_effort = "low"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[features]",
+			"plugins = 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 content = await readFile(configPath, "utf8");
+	assert.equal(content.match(/^model_reasoning_effort\s*=/gm)?.length, 1);
+	assert.equal(content.match(/^plan_mode_reasoning_effort\s*=/gm)?.length, 1);
+	assert.match(content, /model_reasoning_effort = "high"/);
+	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
+	assert.doesNotMatch(content, /model_reasoning_effort = "low"/);
+	assert.doesNotMatch(content, /plan_mode_reasoning_effort = "medium"/);
+});

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

@@ -27,6 +27,61 @@ test("#given empty Codex config #when script installer updates config #then enab
 	assert.match(config, /max_concurrent_threads_per_session = 10000/);
 });
 
+test("#given empty Codex config #when script installer updates config #then installs Context7 MCP", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-context7-"));
+	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, /\[mcp_servers\.context7\]/);
+	assert.match(config, /command = "npx"/);
+	assert.match(config, /args = \["-y", "@upstash\/context7-mcp", "--api-key", "YOUR_API_KEY"\]/);
+	assert.match(config, /startup_timeout_sec = 20/);
+});
+
+test("#given existing Context7 MCP config #when script installer updates config #then preserves user setup", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-context7-existing-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[mcp_servers.context7]",
+			'command = "node"',
+			'args = ["/opt/context7/server.js"]',
+			'startup_timeout_sec = 40',
+			"",
+		].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, /\[mcp_servers\.context7\]/);
+	assert.match(config, /command = "node"/);
+	assert.match(config, /args = \["\/opt\/context7\/server\.js"\]/);
+	assert.match(config, /startup_timeout_sec = 40/);
+	assert.doesNotMatch(config, /YOUR_API_KEY/);
+});
+
 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-"));
@@ -116,3 +171,154 @@ test("#given legacy boolean MultiAgentV2 flag and table #when script installer u
 	assert.match(config, /usage_hint_enabled = false/);
 	assert.match(config, /max_concurrent_threads_per_session = 10000/);
 });
+
+test("#given legacy agents max_threads #when script installer updates config #then removes the conflicting legacy thread cap", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-legacy-threads-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[agents]",
+			"max_threads = 16",
+			"max_depth = 4",
+			"job_max_runtime_seconds = 3600",
+			"",
+		].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, /max_concurrent_threads_per_session = 10000/);
+	assert.match(config, /\[agents\]/);
+	assert.doesNotMatch(config, /^max_threads\s*=/m);
+	assert.match(config, /max_depth = 4/);
+	assert.match(config, /job_max_runtime_seconds = 3600/);
+});
+
+test("#given managed agent role sections #when script installer updates config #then preserves role config while removing only root agents max_threads", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-role-section-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[agents]",
+			"max_threads = 16",
+			"",
+			"[agents.explorer]",
+			'description = "read-only explorer"',
+			'config_file = "./agents/explorer.toml"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		agentConfigs: [{ name: "explorer", configFile: "./agents/explorer.toml" }],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.doesNotMatch(config, /^max_threads\s*=/m);
+	assert.match(config, /\[agents\.explorer\]/);
+	assert.match(config, /description = "read-only explorer"/);
+	assert.match(config, /config_file = "\.\/agents\/explorer\.toml"/);
+});
+
+test("#given existing trust and lsp blocks #when updating config #then existing blocks are preserved", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-baseline-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'[plugins."omo@sisyphuslabs"]',
+			"enabled = true",
+			"",
+			'[plugins."omo@sisyphuslabs".mcp_servers.lsp]',
+			"enabled = true",
+			"",
+			'[hooks.state."omo@sisyphuslabs:hooks/hooks.json:post_tool_use:0:0"]',
+			'trusted_hash = "sha256:keep"',
+			"",
+		].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"],
+		trustedHookStates: [{ key: "omo@sisyphuslabs:hooks/hooks.json:post_tool_use:0:0", trustedHash: "sha256:keep" }],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.lsp\]/);
+	assert.match(content, /\[hooks\.state\."omo@sisyphuslabs:hooks\/hooks\.json:post_tool_use:0:0"\]/);
+	assert.match(content, /trusted_hash = "sha256:keep"/);
+});
+
+test("#given windows platform #when updating config #then enables git_bash plugin mcp policy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-git-bash-win32-"));
+	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"],
+		platform: "win32",
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = true/);
+});
+
+test("#given non-windows platforms #when updating config #then disables git_bash plugin mcp policy", async () => {
+	for (const platform of ["linux", "darwin"]) {
+		// given
+		const root = await mkdtemp(join(tmpdir(), `omo-codex-config-git-bash-${platform}-`));
+		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"],
+			platform,
+		});
+
+		// then
+		const content = await readFile(configPath, "utf8");
+		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = false/);
+	}
+});

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

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { resolveDefaultRepoRoot } from "./install-local.mjs";
+
+test("#given published lazycodex bin runs outside the package #when resolving default repo root #then uses installer location", () => {
+	// given
+	const scriptsDir = dirname(fileURLToPath(import.meta.url));
+
+	// when
+	const repoRoot = resolveDefaultRepoRoot();
+
+	// then
+	assert.equal(repoRoot, join(scriptsDir, "..", "..", ".."));
+});
+
+test("#given lazycodex version flag #when running the Node installer entrypoint #then prints the package version", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const manifestPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--version"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, `lazycodex-ai ${manifest.version}`);
+});
+
+test("#given lazycodex runs through an npm bin symlink #when running the Node installer entrypoint #then it still executes main", { skip: process.platform === "win32" }, () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const manifestPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	const tempDir = mkdtempSync(join(tmpdir(), "lazycodex-bin-"));
+	const binPath = join(tempDir, "lazycodex-ai");
+
+	try {
+		symlinkSync(scriptPath, binPath);
+
+		// when
+		const output = execFileSync(process.execPath, [binPath, "--version"], {
+			encoding: "utf8",
+		}).trim();
+
+		// then
+		assert.equal(output, `lazycodex-ai ${manifest.version}`);
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});
+
+test("#given dry-run install flags #when running the Node installer entrypoint #then prints delegated codex install command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "install", "--no-tui", "--codex-autonomous"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo install --platform=codex --no-tui --codex-autonomous");
+});
+
+test("#given dry-run doctor #when running the Node installer entrypoint #then prints delegated doctor command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--dry-run", "doctor"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo doctor");
+});
+
+test("#given dry-run cleanup #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", "cleanup", "--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 the invoking argv path disappears #when importing the Node installer module #then the entrypoint guard does not throw", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const tempDir = mkdtempSync(join(tmpdir(), "lazycodex-import-"));
+	const missingArgvPath = join(tempDir, "missing-entrypoint.mjs");
+	const probePath = join(tempDir, "probe.mjs");
+
+	try {
+		writeFileSync(
+			probePath,
+			[
+				`process.argv[1] = ${JSON.stringify(missingArgvPath)};`,
+				`await import(${JSON.stringify(pathToFileURL(scriptPath).href)});`,
+			].join("\n"),
+		);
+
+		// when
+		const output = execFileSync(process.execPath, [probePath], {
+			encoding: "utf8",
+		}).trim();
+
+		// then
+		assert.equal(output, "");
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});