oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, stat, 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";
+
+test("#given packaged lazycodex adapter #when installing locally #then uses bundled artifacts without source builds", async () => {
+	// given
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const lspRuntimeRoot = join(repoRoot, "packages", "lsp-tools-mcp");
+
+	await writeJson(join(repoRoot, "package.json"), {
+		name: "lazycodex-ai",
+		version: "0.1.2",
+	});
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "sisyphuslabs",
+		plugins: [{ name: "omo", source: "./plugins/omo" }],
+	});
+	await writePluginAt(pluginRoot, "omo", "0.1.0");
+	await writeJson(join(pluginRoot, ".mcp.json"), {
+		mcpServers: {
+			lsp: {
+				command: "node",
+				args: ["../../lsp-tools-mcp/dist/cli.js", "mcp"],
+				cwd: ".",
+			},
+		},
+	});
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\nconsole.log('prebuilt')\n");
+	await writeJson(join(lspRuntimeRoot, "dist", "cli.js"), { executable: true });
+
+	const commands = [];
+
+	// when
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			commands.push([command, args.join(" "), options.cwd]);
+		},
+		log: () => {},
+	});
+
+	// then
+	const pluginCacheRoot = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "0.1.0");
+	const cachedMcp = JSON.parse(await readFile(join(pluginCacheRoot, ".mcp.json"), "utf8"));
+	const cachedLspCli = join(pluginCacheRoot, "mcp", "lsp", "dist", "cli.js");
+
+	assert.deepEqual(result.installed.map((plugin) => `${plugin.name}@${plugin.version}`), ["omo@0.1.0"]);
+	assert.deepEqual(
+		commands.map(([command, args, cwd]) => [command, args, cwd]),
+		[["npm", "install --omit=dev", pluginCacheRoot]],
+	);
+	assert.deepEqual(cachedMcp.mcpServers.lsp.args, [cachedLspCli, "mcp"]);
+	assert.equal((await stat(cachedLspCli)).isFile(), true);
+	assert.notEqual(cachedMcp.mcpServers.lsp.args[0], join(lspRuntimeRoot, "dist", "cli.js"));
+});

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

@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, readFile, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installMarketplaceLocally } from "./install-local.mjs";
+import { repairNearestProjectLocalCodexArtifacts } from "./install/project-local-cleanup.mjs";
+import { makeTempDir, writeJson, writePluginAt } from "./install-test-fixtures.mjs";
+
+test("#given stale project-local Codex config #when Node installer runs #then repairs the local conflict", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const projectRoot = await makeTempDir();
+	const projectDirectory = join(projectRoot, "nested");
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const projectConfigPath = join(projectRoot, ".codex", "config.toml");
+
+	await mkdir(projectDirectory, { recursive: true });
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "debug-marketplace",
+		plugins: [{ name: "alpha", source: "./plugin" }],
+	});
+	await writePluginAt(pluginRoot, "alpha", "1.2.3");
+	await writeFile(
+		projectConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"  max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		projectDirectory,
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			if (command === "npm" && args.join(" ") === "run build") {
+				await mkdir(join(options.cwd, "dist"), { recursive: true });
+				await writeFile(join(options.cwd, "dist", "cli.js"), "#!/usr/bin/env node\n");
+			}
+		},
+		log: () => {},
+	});
+
+	assert.equal(result.projectCleanup.configPath, projectConfigPath);
+	assert.equal(result.projectCleanup.changed, true);
+	assert.deepEqual(result.projectCleanup.removedKeys, ["max_threads"]);
+	assert.equal(result.projectCleanup.configs.length, 1);
+	assert.match(await readFile(result.projectCleanup.backupPath, "utf8"), /max_threads = 10/);
+	const content = await readFile(projectConfigPath, "utf8");
+	assert.doesNotMatch(content, /^\s*max_threads\s*=/m);
+	assert.match(content, /max_depth = 4/);
+});
+
+test("#given root and nested project-local Codex configs #when script cleanup runs #then it repairs every loaded project layer", async () => {
+	const projectRoot = await makeTempDir();
+	const projectDirectory = join(projectRoot, "nested");
+	const rootConfigPath = join(projectRoot, ".codex", "config.toml");
+	const nestedConfigPath = join(projectDirectory, ".codex", "config.toml");
+
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await mkdir(join(projectDirectory, ".codex"), { recursive: true });
+	await mkdir(join(projectDirectory, ".omx"), { recursive: true });
+	await writeFile(join(projectDirectory, ".codex", "hooks.json"), "{}\n");
+	await writeFile(
+		rootConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+	await writeFile(
+		nestedConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"job_max_runtime_seconds = 7200",
+			"",
+		].join("\n"),
+	);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: projectDirectory,
+		now: () => new Date("2026-06-01T01:02:03.004Z"),
+	});
+
+	assert.equal(result.projectRoot, projectRoot);
+	assert.equal(result.changed, true);
+	assert.equal(result.configPath, rootConfigPath);
+	assert.deepEqual(
+		result.configs.map((config) => config.configPath),
+		[rootConfigPath, nestedConfigPath],
+	);
+	assert.deepEqual(
+		result.configs.map((config) => config.changed),
+		[true, false],
+	);
+	assert.equal(result.backupPath, `${rootConfigPath}.backup-2026-06-01T01-02-03-004Z`);
+	const rootContent = await readFile(rootConfigPath, "utf8");
+	const nestedContent = await readFile(nestedConfigPath, "utf8");
+	assert.doesNotMatch(rootContent, /^max_threads\s*=/m);
+	assert.match(rootContent, /max_depth = 4/);
+	assert.match(nestedContent, /job_max_runtime_seconds = 7200/);
+	assert.deepEqual(
+		result.artifacts.map((artifact) => artifact.path).sort(),
+		[join(projectDirectory, ".codex", "hooks.json"), join(projectDirectory, ".omx")],
+	);
+});
+
+test("#given no project-local config and CODEX_HOME in the parent chain #when script cleanup runs #then global Codex config is not treated as project state", async () => {
+	const homeRoot = await makeTempDir();
+	const codexHome = join(homeRoot, ".codex");
+	const projectDirectory = join(homeRoot, "workspace", "nested");
+	const globalConfigPath = join(codexHome, "config.toml");
+
+	await mkdir(projectDirectory, { recursive: true });
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		globalConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({ startDirectory: projectDirectory, codexHome });
+
+	assert.equal(result.configPath, null);
+	assert.equal(result.changed, false);
+	const content = await readFile(globalConfigPath, "utf8");
+	assert.match(content, /max_threads = 10/);
+	assert.match(content, /max_depth = 4/);
+});
+
+test("#given project-local config is a symlink to CODEX_HOME #when script cleanup runs #then it skips the link without mutating the target", async () => {
+	if (process.platform === "win32") return;
+
+	const codexHome = await makeTempDir();
+	const projectRoot = await makeTempDir();
+	const globalConfigPath = join(codexHome, "config.toml");
+	const projectConfigPath = join(projectRoot, ".codex", "config.toml");
+
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await writeFile(
+		globalConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+	await symlink(globalConfigPath, projectConfigPath);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: projectRoot,
+		codexHome,
+		now: () => new Date("2026-06-01T00:00:00Z"),
+	});
+
+	assert.equal(result.configPath, null);
+	assert.equal(result.changed, false);
+	assert.equal(await pathExists(`${projectConfigPath}.backup-2026-06-01T00-00-00-000Z`), false);
+	const content = await readFile(globalConfigPath, "utf8");
+	assert.match(content, /max_threads = 10/);
+	assert.match(content, /max_depth = 4/);
+});
+
+test("#given malformed project directory from the environment #when script cleanup runs #then it skips project-local cleanup without failing install", async () => {
+	const codexHome = await makeTempDir();
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: `bad${"\0"}path`,
+		codexHome,
+	});
+
+	assert.deepEqual(result, {
+		projectRoot: null,
+		configPath: null,
+		changed: false,
+		removedKeys: [],
+		configs: [],
+		artifacts: [],
+	});
+});
+
+test("#given absent project directory from the script surface #when script cleanup runs #then it skips project-local cleanup without throwing", async () => {
+	const codexHome = await makeTempDir();
+
+	const result = await repairNearestProjectLocalCodexArtifacts({ codexHome });
+
+	assert.deepEqual(result, {
+		projectRoot: null,
+		configPath: null,
+		changed: false,
+		removedKeys: [],
+		configs: [],
+		artifacts: [],
+	});
+});
+
+test("#given project cleanup hits a filesystem edge #when Node installer runs #then install succeeds and reports skipped cleanup", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const projectRoot = await makeTempDir();
+	const projectDirectory = join(projectRoot, "not-a-directory");
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const logs = [];
+
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "debug-marketplace",
+		plugins: [{ name: "alpha", source: "./plugin" }],
+	});
+	await writePluginAt(pluginRoot, "alpha", "1.2.3");
+	await writeFile(projectDirectory, "file, not directory\n");
+
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		projectDirectory,
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			if (command === "npm" && args.join(" ") === "run build") {
+				await mkdir(join(options.cwd, "dist"), { recursive: true });
+				await writeFile(join(options.cwd, "dist", "cli.js"), "#!/usr/bin/env node\n");
+			}
+		},
+		log: (message) => logs.push(message),
+	});
+
+	assert.equal(result.projectCleanup.projectRoot, null);
+	assert.equal(result.projectCleanup.changed, false);
+	assert.equal(logs.some((message) => message.includes("Skipped project-local Codex cleanup")), true);
+	assert.equal(logs.some((message) => message.includes("not a directory")), true);
+	assert.equal(await pathExists(join(codexHome, "config.toml")), true);
+});
+
+async function pathExists(path) {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}

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

@@ -0,0 +1,58 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+export async function makeTempDir() {
+	return mkdtemp(join(tmpdir(), "omo-codex-install-"));
+}
+
+export async function writeJson(path, value) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function writePlugin(root, name, version) {
+	const pluginRoot = join(root, "plugins", name);
+	await writePluginAt(pluginRoot, name, version);
+}
+
+export async function writePluginAt(pluginRoot, name, version) {
+	await mkdir(join(pluginRoot, ".codex-plugin"), { recursive: true });
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(pluginRoot, "hooks"), { recursive: true });
+	await mkdir(join(pluginRoot, "skills", name), { recursive: true });
+	await mkdir(join(pluginRoot, "components", "ultrawork", "agents"), { recursive: true });
+	await writeJson(join(pluginRoot, ".codex-plugin", "plugin.json"), {
+		name,
+		version,
+		description: `${name} test plugin`,
+		mcpServers: "./.mcp.json",
+		hooks: "./hooks/hooks.json",
+		skills: "./skills/",
+	});
+	await writeJson(join(pluginRoot, ".mcp.json"), {
+		mcpServers: {
+			[name]: {
+				command: "node",
+				args: ["./dist/cli.js", "mcp"],
+				cwd: ".",
+			},
+		},
+	});
+	await writeJson(join(pluginRoot, "hooks", "hooks.json"), { hooks: {} });
+	await writeFile(join(pluginRoot, "skills", name, "SKILL.md"), "---\nname: test\n---\n");
+	await writeFile(join(pluginRoot, "components", "ultrawork", "agents", "explorer.toml"), 'name = "explorer"\n');
+	await writeFile(join(pluginRoot, "components", "ultrawork", "agents", "librarian.toml"), 'name = "librarian"\n');
+	await writeFile(join(pluginRoot, "components", "ultrawork", "agents", "plan.toml"), 'name = "plan"\n');
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: `@example/${name}`,
+		version,
+		bin: {
+			[name]: "./dist/cli.js",
+		},
+		scripts: {
+			build: "node -e \"require('fs').writeFileSync('dist/cli.js', 'console.log(1)')\"",
+		},
+		dependencies: {},
+	});
+}

package/packages/omo-codex/scripts/sync-telemetry-component.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const TELEMETRY_SYNC_FILES = [
+	"atomic-write.ts",
+	"data-path.ts",
+	"env-flags.ts",
+	"posthog-activity-state.ts",
+];
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = dirname(SCRIPT_DIR);
+const DEFAULT_SOURCE_DIR = join(PACKAGE_ROOT, "src", "telemetry");
+const DEFAULT_COMPONENT_DIR = join(PACKAGE_ROOT, "plugin", "components", "telemetry", "src");
+
+export async function syncTelemetryComponent(options = {}) {
+	const sourceDirProvided = options.sourceDir !== undefined;
+	const sourceDir = resolve(options.sourceDir ?? DEFAULT_SOURCE_DIR);
+	const componentDir = resolve(options.componentDir ?? DEFAULT_COMPONENT_DIR);
+	const files = options.files ?? TELEMETRY_SYNC_FILES;
+	const check = options.check ?? false;
+	const changed = [];
+
+	for (const fileName of files) {
+		const sourcePath = join(sourceDir, fileName);
+		const componentPath = join(componentDir, fileName);
+		const componentText = await readOptionalText(componentPath);
+		const sourceText = await readOptionalText(sourcePath);
+		if (sourceText === null && !sourceDirProvided) continue;
+		if (sourceText === null) {
+			await readFile(sourcePath, "utf8");
+			continue;
+		}
+		const nextText = toComponentSource(sourceText);
+		if (componentText === nextText) continue;
+		changed.push(fileName);
+		if (!check) {
+			await mkdir(dirname(componentPath), { recursive: true });
+			await writeFile(componentPath, nextText);
+		}
+	}
+
+	if (check && changed.length > 0) {
+		throw new Error(`telemetry component out of sync: ${changed.join(", ")}`);
+	}
+
+	return { checked: check, changed };
+}
+
+function toComponentSource(sourceText) {
+	return sourceText
+		.replaceAll(/\bprocess\.env\.([A-Z0-9_]+)/g, 'process.env["$1"]')
+		.replaceAll(/from "(\.\/[^"]+)"/g, 'from "$1.js"');
+}
+
+async function readOptionalText(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+
+function parseArgs(args) {
+	const parsed = {
+		check: false,
+	};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--check") {
+			parsed.check = true;
+			continue;
+		}
+		if (arg === "--source-dir") {
+			const value = args[index + 1];
+			if (value === undefined) throw new Error("--source-dir requires a value");
+			parsed.sourceDir = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--component-dir") {
+			const value = args[index + 1];
+			if (value === undefined) throw new Error("--component-dir requires a value");
+			parsed.componentDir = value;
+			index += 1;
+			continue;
+		}
+		throw new Error(`unknown argument: ${arg}`);
+	}
+	return parsed;
+}
+
+async function main() {
+	const result = await syncTelemetryComponent(parseArgs(process.argv.slice(2)));
+	if (result.changed.length === 0) {
+		console.log("telemetry component in sync");
+		return;
+	}
+	console.log(`synced telemetry component: ${result.changed.join(", ")}`);
+}
+
+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;
+	});
+}

package/packages/omo-codex/scripts/sync-telemetry-component.test.mjs

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+const SCRIPT_PATH = new URL("./sync-telemetry-component.mjs", import.meta.url);
+
+async function makeTempDir() {
+	return mkdtemp(join(tmpdir(), "omo-codex-telemetry-sync-"));
+}
+
+async function runSync(args) {
+	const { syncTelemetryComponent } = await import(SCRIPT_PATH);
+	return syncTelemetryComponent(args);
+}
+
+test("#given stale telemetry component files #when sync runs #then pure package telemetry source rewrites the component copy", async () => {
+	// given
+	const root = await makeTempDir();
+	const sourceDir = join(root, "source");
+	const componentDir = join(root, "component");
+	await mkdir(sourceDir);
+	await mkdir(componentDir);
+	await writeFile(join(sourceDir, "atomic-write.ts"), "export const source = true\n", { flush: true });
+	await writeFile(join(componentDir, "atomic-write.ts"), "export const stale = true\n", { flush: true });
+
+	try {
+		// when
+		const result = await runSync({
+			sourceDir,
+			componentDir,
+			files: ["atomic-write.ts"],
+			check: false,
+		});
+
+		// then
+		assert.deepEqual(result, {
+			checked: false,
+			changed: ["atomic-write.ts"],
+		});
+		assert.equal(await readFile(join(componentDir, "atomic-write.ts"), "utf8"), "export const source = true\n");
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});
+
+test("#given a missing pure telemetry source file #when sync runs #then it fails with the missing source path", async () => {
+	// given
+	const root = await makeTempDir();
+	const sourceDir = join(root, "source");
+	const componentDir = join(root, "component");
+	await mkdir(componentDir);
+	await writeFile(join(componentDir, "atomic-write.ts"), "export const stale = true\n", { flush: true });
+
+	try {
+		// when / then
+		await assert.rejects(
+			runSync({
+				sourceDir,
+				componentDir,
+				files: ["atomic-write.ts"],
+				check: false,
+			}),
+			(error) => error instanceof Error && error.message.includes(join(sourceDir, "atomic-write.ts")),
+		);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});
+
+test("#given packaged default layout without pure telemetry source #when cli sync runs #then it exits cleanly", async () => {
+	// given
+	const root = await makeTempDir();
+	const scriptPath = join(root, "packages", "omo-codex", "scripts", "sync-telemetry-component.mjs");
+	await mkdir(join(root, "packages", "omo-codex", "scripts"), { recursive: true });
+	await cp(new URL("./sync-telemetry-component.mjs", import.meta.url), scriptPath);
+
+	try {
+		// when
+		const result = spawnSync(process.execPath, [scriptPath], {
+			encoding: "utf8",
+			env: {
+				...process.env,
+			},
+		});
+
+		// then
+		assert.equal(result.status, 0, result.stderr);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});

package/packages/shared-skills/index.mjs

@@ -0,0 +1,5 @@
+import { fileURLToPath } from "node:url";
+
+export function sharedSkillsRootPath() {
+	return fileURLToPath(new URL("./skills/", import.meta.url));
+}

package/packages/shared-skills/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@oh-my-opencode/shared-skills",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "description": "Cross-harness SKILL.md files shared between OMO and Codex",
+  "exports": {
+    ".": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "skills"
+  ]
+}