oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/plugin/test/sync-skills.test.mjs

@@ -0,0 +1,199 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const repoRoot = join(root, "..", "..", "..");
+
+const expectedSkills = [
+	"comment-checker",
+	"debugging",
+	"frontend-ui-ux",
+	"init-deep",
+	"lsp",
+	"programming",
+	"refactor",
+	"remove-ai-slops",
+	"review-work",
+	"rules",
+	"start-work",
+	"ulw-loop",
+	"ulw-plan",
+];
+
+const componentSkillSources = [
+	["comment-checker", "components/comment-checker/skills/comment-checker"],
+	["lsp", "components/lsp/skills/lsp"],
+	["rules", "components/rules/skills/rules"],
+	["ulw-loop", "components/ulw-loop/skills/ulw-loop"],
+];
+
+const codexCompatibilityEndMarkers = [
+	"When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
+	"When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
+];
+
+function removeCodexCompatibilityGuidance(content) {
+	const start = content.indexOf("## Codex Harness Tool Compatibility\n\n");
+	if (start === -1) return content;
+	const endMarker = codexCompatibilityEndMarkers.find((marker) => content.indexOf(marker, start) !== -1);
+	assert.notEqual(endMarker, undefined, "Codex compatibility guidance block is missing its terminator");
+	const end = content.indexOf(endMarker, start);
+	assert.notEqual(end, -1, "Codex compatibility guidance block is missing its terminator");
+	return `${content.slice(0, start)}${content.slice(end + endMarker.length)}`;
+}
+
+test("#given synced aggregate Codex skills #when inspected #then component and shared skills are present", async () => {
+	// given
+	const skillsRoot = join(root, "skills");
+
+	// when
+	const skillNames = (await readdir(skillsRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+
+	// then
+	assert.deepEqual(skillNames, expectedSkills);
+	for (const skillName of expectedSkills) {
+		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
+		assert.match(removeCodexCompatibilityGuidance(content), /^---\r?\n/);
+	}
+});
+
+test("#given aggregate Codex skills #when source wiring is inspected #then shared skills are imported from the shared-skills package", async () => {
+	// given
+	const pluginPackageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	const sharedPackageJson = JSON.parse(await readFile(join(root, "..", "..", "shared-skills", "package.json"), "utf8"));
+	const rootPackageJson = JSON.parse(await readFile(join(repoRoot, "package.json"), "utf8"));
+	const syncScript = await readFile(join(root, "scripts", "sync-skills.mjs"), "utf8");
+
+	// when
+	const sharedSkillDependency = pluginPackageJson.dependencies?.["@oh-my-opencode/shared-skills"];
+	const rootPackageFiles = rootPackageJson.files ?? [];
+
+	// then
+	assert.equal(sharedPackageJson.exports?.["."], "./index.mjs");
+	assert.equal(sharedPackageJson.files?.includes("skills"), true);
+	assert.equal(rootPackageFiles.includes("packages/shared-skills/package.json"), true);
+	assert.equal(rootPackageFiles.includes("packages/shared-skills/index.mjs"), true);
+	assert.equal(rootPackageFiles.includes("packages/shared-skills/skills"), true);
+	assert.equal(sharedSkillDependency, "file:../../shared-skills");
+	assert.match(syncScript, /from "@oh-my-opencode\/shared-skills"/);
+	assert.doesNotMatch(syncScript, /shared-skills",\s*"skills"/);
+});
+
+test("#given shared skill package source #when aggregate Codex shared skills are inspected #then generated copies have no hand-authored drift", async () => {
+	// given
+	const sharedSkillsRoot = sharedSkillsRootPath();
+	const aggregateSkillsRoot = join(root, "skills");
+	const sharedSkillNames = (await readdir(sharedSkillsRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+
+	// when / then
+	for (const skillName of sharedSkillNames) {
+		const sharedContent = await readFile(join(sharedSkillsRoot, skillName, "SKILL.md"), "utf8");
+		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
+		assert.equal(
+			removeCodexCompatibilityGuidance(aggregateContent),
+			removeCodexCompatibilityGuidance(sharedContent),
+			`${skillName} drifted from shared-skills`,
+		);
+	}
+});
+
+test("#given component skill sources #when aggregate Codex component skills are inspected #then generated copies have no hand-authored drift", async () => {
+	// given
+	const aggregateSkillsRoot = join(root, "skills");
+
+	// when / then
+	for (const [skillName, sourcePath] of componentSkillSources) {
+		const sourceContent = await readFile(join(root, sourcePath, "SKILL.md"), "utf8");
+		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
+		assert.equal(
+			removeCodexCompatibilityGuidance(aggregateContent),
+			removeCodexCompatibilityGuidance(sourceContent),
+			`${skillName} drifted from its component skill source`,
+		);
+	}
+});
+
+test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then ulw-loop surfaces the ulw-loop alias", async () => {
+	// given
+	const skillRoot = join(root, "skills", "ulw-loop");
+
+	// when
+	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+
+	// then
+	assert.match(skill, /^---\r?\nname: ulw-loop\r?\n/m);
+	assert.match(skill, /Goal-like loop that uses ultrawork mode to decompose work into systematic, evidence-bound steps\./);
+	assert.match(interfaceMetadata, /display_name: "ulw-loop \(omo\)"/);
+	assert.doesNotMatch(interfaceMetadata, /ulw-loop \/ ulw-loop/);
+	assert.match(interfaceMetadata, /short_description: "Goal-like ultrawork loop for systematic decomposition"/);
+	assert.match(interfaceMetadata, /default_prompt: "Use \$ulw-loop/);
+});
+
+test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then ulw-loop remains discoverable as an alias", async () => {
+	// given
+	const skillRoot = join(root, "skills", "ulw-loop");
+
+	// when
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+
+	// then
+	assert.match(interfaceMetadata, /search_terms:/);
+	assert.match(interfaceMetadata, /- "ulw-loop"/);
+});
+
+test("#given synced ulw-loop skill #when worker guidance is inspected #then context-hygiene guidance matches the source", async () => {
+	// given
+	const sourceSkill = await readFile(join(root, "components", "ulw-loop", "skills", "ulw-loop", "SKILL.md"), "utf8");
+	const syncedSkill = await readFile(join(root, "skills", "ulw-loop", "SKILL.md"), "utf8");
+	const requiredPatterns = [
+		["list_agents polling guard", /list_agents/],
+		["status polling warning", /polling or status tool/],
+		["large payload replay risk", /replay large agent status and latest-message payloads/],
+		["local spawned-name tracking", /Track spawned agent names locally/],
+		["wait_agent completion path", /wait_agent.*completion/],
+		["targeted followups", /targeted followups only when needed/],
+		["close_agent cleanup", /close_agent.*after integrating each result/],
+	];
+
+	// when / then
+	for (const [label, pattern] of requiredPatterns) {
+		assert.match(sourceSkill, pattern, `source skill missing ${label}`);
+		assert.match(syncedSkill, pattern, `synced skill missing ${label}`);
+	}
+});
+
+test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {
+	// given
+	const skillsRoot = join(root, "skills");
+	const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
+
+	// when
+	const skillNames = (await readdir(skillsRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+
+	// then
+	for (const skillName of skillNames) {
+		const content = await readFile(join(skillsRoot, skillName, "SKILL.md"), "utf8");
+		if (!opencodeOnlyToolPattern.test(content)) continue;
+
+		const compatibilityIndex = content.indexOf("## Codex Harness Tool Compatibility");
+		assert.notEqual(compatibilityIndex, -1, `${skillName} is missing Codex compatibility guidance`);
+		assert.ok(
+			compatibilityIndex < content.search(opencodeOnlyToolPattern),
+			`${skillName} must explain Codex tool translation before OpenCode-only examples`,
+		);
+	}
+});

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

@@ -0,0 +1,84 @@
+import { basename, join } from "node:path";
+import { copyFile, lstat, mkdir, readdir, rm, symlink, writeFile } from "node:fs/promises";
+
+import { exists } from "./utils.mjs";
+
+const MANIFEST_FILE = ".installed-agents.json";
+
+export async function linkCachedPluginAgents({ codexHome, pluginRoot, platform = process.platform }) {
+	const bundledAgents = await discoverBundledAgents(pluginRoot);
+	if (bundledAgents.length === 0) {
+		await writeManifest(pluginRoot, []);
+		return [];
+	}
+
+	const agentsDir = join(codexHome, "agents");
+	await mkdir(agentsDir, { recursive: true });
+	const linked = [];
+	for (const agentPath of bundledAgents) {
+		const linkPath = join(agentsDir, basename(agentPath));
+		if (platform === "win32") {
+			await replaceWithCopy(linkPath, agentPath);
+		} else {
+			await replaceWithSymlink(linkPath, agentPath);
+		}
+		linked.push({ name: basename(agentPath), path: linkPath, target: agentPath });
+	}
+	await writeManifest(pluginRoot, linked.map((entry) => entry.path));
+	return linked;
+}
+
+async function discoverBundledAgents(pluginRoot) {
+	const componentsRoot = join(pluginRoot, "components");
+	if (!(await exists(componentsRoot))) return [];
+
+	const componentEntries = await readdir(componentsRoot, { withFileTypes: true });
+	const agents = [];
+	for (const entry of componentEntries) {
+		if (!entry.isDirectory()) continue;
+		const agentsRoot = join(componentsRoot, entry.name, "agents");
+		if (!(await exists(agentsRoot))) continue;
+		const agentEntries = await readdir(agentsRoot, { withFileTypes: true });
+		for (const file of agentEntries) {
+			if (!file.isFile() || !file.name.endsWith(".toml")) continue;
+			agents.push(join(agentsRoot, file.name));
+		}
+	}
+	agents.sort();
+	return agents;
+}
+
+async function replaceWithSymlink(linkPath, target) {
+	await prepareReplacement(linkPath);
+	await symlink(target, linkPath);
+}
+
+async function replaceWithCopy(linkPath, target) {
+	await prepareReplacement(linkPath);
+	await copyFile(target, linkPath);
+}
+
+async function prepareReplacement(linkPath) {
+	if (!(await lstatExists(linkPath))) return;
+	const entryStat = await lstat(linkPath);
+	if (entryStat.isDirectory() && !entryStat.isSymbolicLink()) {
+		throw new Error(`${linkPath} already exists and is a directory; refusing to replace`);
+	}
+	await rm(linkPath, { force: true });
+}
+
+async function writeManifest(pluginRoot, agentPaths) {
+	const manifestPath = join(pluginRoot, MANIFEST_FILE);
+	const payload = { agents: [...agentPaths].sort() };
+	await writeFile(manifestPath, `${JSON.stringify(payload, null, "\t")}\n`);
+}
+
+async function lstatExists(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/cache.mjs

@@ -0,0 +1,245 @@
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { cp, lstat, mkdir, readFile, readdir, readlink, rename, rm, symlink, writeFile } from "node:fs/promises";
+
+import { createCachedMcpRuntimeArgRewriter } from "./mcp-runtime-cache.mjs";
+import { exists, isRecord } from "./utils.mjs";
+import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
+import { removeLegacyCodexComponentBins } from "./legacy-bins.mjs";
+
+export async function installCachedPlugin({ codexHome, marketplaceName, name, runCommand, sourcePath, version }) {
+	await maybeRunNpmInstall(sourcePath, runCommand);
+	await maybeRunNpmBuild(sourcePath, runCommand);
+
+	const targetPath = join(codexHome, "plugins", "cache", marketplaceName, name, version);
+	await replaceDirectory(sourcePath, targetPath, shouldCopyPluginPath);
+	await rewriteCachedPackageLocalFileDependencies(targetPath, sourcePath);
+	await maybeRunNpmInstall(targetPath, runCommand, ["install", "--omit=dev"]);
+	await rewriteCachedMcpManifest(targetPath, sourcePath);
+	return { name, version, path: targetPath };
+}
+
+export async function pruneMarketplaceCache({ codexHome, marketplaceName, keepPluginNames }) {
+	const cacheRoot = join(codexHome, "plugins", "cache", marketplaceName);
+	if (!(await exists(cacheRoot))) return;
+	const keep = new Set(keepPluginNames);
+	const entries = await readdir(cacheRoot, { withFileTypes: true });
+	for (const entry of entries) {
+		if (!entry.isDirectory() || keep.has(entry.name)) continue;
+		await rm(join(cacheRoot, entry.name), { recursive: true, force: true });
+	}
+}
+
+export async function pruneMarketplacePluginCaches({ codexHome, marketplaceName, pluginNames }) {
+	const cacheRoot = join(codexHome, "plugins", "cache", marketplaceName);
+	if (!(await exists(cacheRoot))) return;
+	for (const pluginName of pluginNames) {
+		await rm(join(cacheRoot, pluginName), { recursive: true, force: true });
+	}
+	if ((await readdir(cacheRoot)).length === 0) {
+		await rm(cacheRoot, { recursive: true, force: true });
+	}
+}
+
+export async function linkCachedPluginBins({ binDir, pluginRoot, platform = process.platform }) {
+	const binLinks = await discoverPackageBins(pluginRoot);
+	await mkdir(binDir, { recursive: true });
+	await removeLegacyCodexComponentBins(binDir, platform);
+	const linked = [];
+	for (const link of binLinks) {
+		const linkPath = await linkCachedPluginBin(binDir, link, platform);
+		linked.push({ name: link.name, path: linkPath, target: link.target });
+	}
+	return linked;
+}
+
+async function linkCachedPluginBin(binDir, link, platform) {
+	if (platform === "win32") {
+		const linkPath = join(binDir, `${link.name}.cmd`);
+		await replaceCommandShim(linkPath, link.target);
+		return linkPath;
+	}
+
+	const linkPath = join(binDir, link.name);
+	await replaceSymlink(linkPath, link.target);
+	return linkPath;
+}
+
+async function maybeRunNpmInstall(cwd, runCommand, args = ["install"]) {
+	if (!(await exists(join(cwd, "package.json")))) return;
+	await runCommand("npm", args, { cwd });
+}
+
+async function maybeRunNpmBuild(cwd, runCommand) {
+	if (!(await exists(join(cwd, "package.json")))) return;
+	const packageJson = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+	if (!isRecord(packageJson.scripts) || typeof packageJson.scripts.build !== "string") return;
+	await runCommand("npm", ["run", "build"], { cwd });
+}
+
+async function replaceDirectory(sourcePath, targetPath, filter) {
+	await mkdir(dirname(targetPath), { recursive: true });
+	const tempPath = join(dirname(targetPath), `.tmp-${basename(targetPath)}-${process.pid}-${Date.now()}`);
+	await rm(tempPath, { recursive: true, force: true });
+	await cp(sourcePath, tempPath, {
+		recursive: true,
+		filter: (source) => filter(source, sourcePath),
+	});
+	await rm(targetPath, { recursive: true, force: true });
+	await rename(tempPath, targetPath);
+}
+
+async function discoverPackageBins(root) {
+	const links = [];
+	await collectPackageBins(root, root, links);
+	return links;
+}
+
+async function collectPackageBins(directory, root, links) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	const packageJsonPath = join(directory, "package.json");
+	if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
+		await appendPackageBinLinks(packageJsonPath, directory, links);
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+		const childPath = join(directory, entry.name);
+		if (!childPath.startsWith(root)) continue;
+		await collectPackageBins(childPath, root, links);
+	}
+}
+
+async function appendPackageBinLinks(packageJsonPath, packageRoot, links) {
+	const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	if (!isRecord(packageJson)) return;
+	const bin = packageJson.bin;
+	if (typeof bin === "string" && typeof packageJson.name === "string") {
+		links.push({ name: basename(packageJson.name), target: join(packageRoot, bin) });
+		return;
+	}
+	if (!isRecord(bin)) return;
+	for (const [name, target] of Object.entries(bin)) {
+		if (typeof target !== "string") continue;
+		links.push({ name, target: join(packageRoot, target) });
+	}
+}
+
+async function replaceSymlink(linkPath, targetPath) {
+	if (await existingNonSymlink(linkPath)) {
+		throw new Error(`${linkPath} already exists and is not a symlink`);
+	}
+	await rm(linkPath, { force: true });
+	await symlink(targetPath, linkPath);
+}
+
+async function replaceCommandShim(linkPath, targetPath) {
+	if (await existingNonShim(linkPath)) {
+		throw new Error(`${linkPath} already exists and is not a command shim`);
+	}
+	await writeFile(linkPath, `@echo off\r\n${COMMAND_SHIM_MARKER}\r\nnode "${targetPath}" %*\r\n`);
+}
+
+async function existingNonShim(path) {
+	try {
+		const stat = await lstat(path);
+		if (!stat.isFile()) return true;
+		const content = await readFile(path, "utf8");
+		if (content.includes(COMMAND_SHIM_MARKER)) return false;
+		throw new Error(`${path} already exists and is not a generated command shim`);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function existingNonSymlink(path) {
+	try {
+		const stat = await lstat(path);
+		if (!stat.isSymbolicLink()) return true;
+		await readlink(path);
+		return false;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+function shouldCopyPluginPath(path, root) {
+	const relative = path === root ? "" : path.slice(root.length + sep.length);
+	if (relative === "") return true;
+	const parts = relative.split(sep);
+	if (parts[parts.length - 1] === "package-lock.json") return false;
+	return !parts.some((part) => part === ".git" || part === "node_modules");
+}
+
+export async function rewriteCachedMcpManifest(pluginRoot, sourceRoot = pluginRoot) {
+	const manifestPath = join(pluginRoot, ".mcp.json");
+	if (!(await exists(manifestPath))) return;
+	const raw = await readFile(manifestPath, "utf8");
+	const parsed = JSON.parse(raw);
+	if (!isRecord(parsed) || !isRecord(parsed.mcpServers)) return;
+	let changed = false;
+	const rewriteRuntimeArg = createCachedMcpRuntimeArgRewriter();
+	for (const [serverName, server] of Object.entries(parsed.mcpServers)) {
+		if (!isRecord(server)) continue;
+		if (server.cwd === "." || server.cwd === "./") {
+			delete server.cwd;
+			changed = true;
+		}
+		if (!Array.isArray(server.args)) continue;
+		const nextArgs = await Promise.all(
+			server.args.map((arg) => rewriteRuntimeArg({ arg, pluginRoot, serverName, sourceRoot })),
+		);
+		if (nextArgs.some((value, index) => value !== server.args[index])) {
+			server.args = nextArgs;
+			changed = true;
+		}
+	}
+	if (changed) await writeFile(manifestPath, `${JSON.stringify(parsed, null, "\t")}\n`);
+}
+
+async function rewriteCachedPackageLocalFileDependencies(pluginRoot, sourceRoot) {
+	const packageJsonPaths = [];
+	await collectPackageJsonPaths(pluginRoot, pluginRoot, packageJsonPaths);
+	for (const packageJsonPath of packageJsonPaths) {
+		const raw = await readFile(packageJsonPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isRecord(parsed)) continue;
+		const packageDir = dirname(packageJsonPath);
+		const sourcePackageDir = join(sourceRoot, relative(pluginRoot, packageDir));
+		let changed = false;
+		for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+			const dependencies = parsed[field];
+			if (!isRecord(dependencies)) continue;
+			for (const [name, specifier] of Object.entries(dependencies)) {
+				if (typeof specifier !== "string" || !specifier.startsWith("file:")) continue;
+				const filePath = specifier.slice("file:".length);
+				if (filePath.length === 0 || isAbsolute(filePath)) continue;
+				const targetPath = resolve(packageDir, filePath);
+				if (isPathInside(targetPath, pluginRoot)) continue;
+				dependencies[name] = `file:${resolve(sourcePackageDir, filePath)}`;
+				changed = true;
+			}
+		}
+		if (changed) await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, "\t")}\n`);
+	}
+}
+
+async function collectPackageJsonPaths(directory, root, paths) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
+		paths.push(join(directory, "package.json"));
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") continue;
+		const childPath = join(directory, entry.name);
+		if (!childPath.startsWith(root)) continue;
+		await collectPackageJsonPaths(childPath, root, paths);
+	}
+}
+
+function isPathInside(candidatePath, rootPath) {
+	const pathFromRoot = relative(rootPath, candidatePath);
+	return pathFromRoot === "" || (!pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot));
+}

package/packages/omo-codex/scripts/install/command-shim.mjs

@@ -0,0 +1 @@
+export const COMMAND_SHIM_MARKER = ":: generated by oh-my-openagent Codex installer";