@omnidev-ai/core 0.1.0

package/src/mcp-json/manager.test.ts

@@ -0,0 +1,415 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import type { LoadedCapability } from "../types";
+import { isOmniDevMcp, readMcpJson, syncMcpJson, writeMcpJson } from "./manager";
+
+describe("mcp-json manager", () => {
+	let originalCwd: string;
+	let tempDir: string;
+
+	beforeEach(() => {
+		originalCwd = process.cwd();
+		tempDir = mkdtempSync(join(tmpdir(), "mcp-json-test-"));
+		mkdirSync(join(tempDir, ".omni"), { recursive: true });
+		process.chdir(tempDir);
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	describe("isOmniDevMcp", () => {
+		test("returns true for 'omnidev' server name", () => {
+			expect(isOmniDevMcp("omnidev")).toBe(true);
+		});
+
+		test("returns true for 'omni-' prefixed server names", () => {
+			expect(isOmniDevMcp("omni-tasks")).toBe(true);
+			expect(isOmniDevMcp("omni-context7")).toBe(true);
+			expect(isOmniDevMcp("omni-my-capability")).toBe(true);
+		});
+
+		test("returns false for non-OmniDev server names", () => {
+			expect(isOmniDevMcp("myserver")).toBe(false);
+			expect(isOmniDevMcp("playwright")).toBe(false);
+			expect(isOmniDevMcp("custom-mcp")).toBe(false);
+		});
+
+		test("returns false for similar but different names", () => {
+			expect(isOmniDevMcp("omnidev-extra")).toBe(false);
+			expect(isOmniDevMcp("my-omnidev")).toBe(false);
+			expect(isOmniDevMcp("omnisomething")).toBe(false);
+		});
+	});
+
+	describe("readMcpJson", () => {
+		test("returns empty config when file does not exist", async () => {
+			const config = await readMcpJson();
+			expect(config).toEqual({ mcpServers: {} });
+		});
+
+		test("reads existing .mcp.json file", async () => {
+			const existingConfig = {
+				mcpServers: {
+					myserver: {
+						command: "node",
+						args: ["server.js"],
+					},
+				},
+			};
+			await Bun.write(".mcp.json", JSON.stringify(existingConfig));
+
+			const config = await readMcpJson();
+			expect(config).toEqual(existingConfig);
+		});
+
+		test("handles invalid JSON gracefully", async () => {
+			await Bun.write(".mcp.json", "invalid json {{{");
+
+			const config = await readMcpJson();
+			expect(config).toEqual({ mcpServers: {} });
+		});
+
+		test("handles missing mcpServers field", async () => {
+			await Bun.write(".mcp.json", JSON.stringify({ other: "field" }));
+
+			const config = await readMcpJson();
+			expect(config).toEqual({ mcpServers: {} });
+		});
+	});
+
+	describe("writeMcpJson", () => {
+		test("writes config to .mcp.json", async () => {
+			const config = {
+				mcpServers: {
+					test: {
+						command: "test-cmd",
+						args: ["arg1", "arg2"],
+					},
+				},
+			};
+
+			await writeMcpJson(config);
+
+			const content = await Bun.file(".mcp.json").text();
+			expect(JSON.parse(content)).toEqual(config);
+		});
+
+		test("overwrites existing .mcp.json", async () => {
+			await Bun.write(".mcp.json", JSON.stringify({ mcpServers: { old: { command: "old" } } }));
+
+			const newConfig = {
+				mcpServers: {
+					new: { command: "new" },
+				},
+			};
+
+			await writeMcpJson(newConfig);
+
+			const content = await Bun.file(".mcp.json").text();
+			expect(JSON.parse(content)).toEqual(newConfig);
+		});
+
+		test("formats JSON with indentation", async () => {
+			const config = {
+				mcpServers: {
+					test: { command: "cmd" },
+				},
+			};
+
+			await writeMcpJson(config);
+
+			const content = await Bun.file(".mcp.json").text();
+			expect(content).toContain("\n");
+			expect(content).toContain("  ");
+		});
+	});
+
+	describe("syncMcpJson", () => {
+		const createMockCapability = (
+			id: string,
+			mcp?: { command: string; args?: string[]; env?: Record<string, string> },
+		): LoadedCapability => ({
+			id,
+			path: `/path/to/${id}`,
+			config: {
+				capability: { id, name: id, version: "1.0.0", description: "" },
+				mcp,
+			},
+			skills: [],
+			rules: [],
+			docs: [],
+			subagents: [],
+			commands: [],
+			exports: {},
+		});
+
+		describe("sandbox enabled mode (default)", () => {
+			test("adds only omnidev server when sandbox enabled", async () => {
+				const capabilities = [createMockCapability("tasks")];
+
+				await syncMcpJson(capabilities, true, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omnidev");
+				expect(config.mcpServers.omnidev).toEqual({
+					command: "bunx",
+					args: ["omnidev", "serve"],
+				});
+			});
+
+			test("removes omni- prefixed servers when switching to sandbox enabled", async () => {
+				// Pre-populate with omni- entries
+				await Bun.write(
+					".mcp.json",
+					JSON.stringify({
+						mcpServers: {
+							"omni-tasks": { command: "npx", args: ["tasks-mcp"] },
+							"omni-context7": { command: "npx", args: ["context7-mcp"] },
+						},
+					}),
+				);
+
+				const capabilities = [
+					createMockCapability("tasks", { command: "npx", args: ["tasks-mcp"] }),
+				];
+
+				await syncMcpJson(capabilities, true, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).not.toHaveProperty("omni-tasks");
+				expect(config.mcpServers).not.toHaveProperty("omni-context7");
+				expect(config.mcpServers).toHaveProperty("omnidev");
+			});
+
+			test("preserves user MCPs when sandbox enabled", async () => {
+				await Bun.write(
+					".mcp.json",
+					JSON.stringify({
+						mcpServers: {
+							myserver: { command: "node", args: ["my-server.js"] },
+							playwright: { command: "npx", args: ["@playwright/mcp"] },
+						},
+					}),
+				);
+
+				const capabilities = [createMockCapability("tasks")];
+
+				await syncMcpJson(capabilities, true, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("myserver");
+				expect(config.mcpServers).toHaveProperty("playwright");
+				expect(config.mcpServers).toHaveProperty("omnidev");
+			});
+		});
+
+		describe("sandbox disabled mode", () => {
+			test("adds omni- prefixed servers for MCP capabilities", async () => {
+				const capabilities = [
+					createMockCapability("context7", {
+						command: "npx",
+						args: ["-y", "@upstash/context7-mcp"],
+					}),
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+				expect(config.mcpServers["omni-context7"]).toEqual({
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				});
+				expect(config.mcpServers).not.toHaveProperty("omnidev");
+			});
+
+			test("does not add entries for capabilities without MCP", async () => {
+				const capabilities = [
+					createMockCapability("tasks"), // No MCP
+					createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).not.toHaveProperty("omni-tasks");
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+			});
+
+			test("includes env when present in MCP config", async () => {
+				const capabilities = [
+					createMockCapability("my-cap", {
+						command: "node",
+						args: ["server.js"],
+						env: { API_KEY: "secret", DEBUG: "true" },
+					}),
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers["omni-my-cap"].env).toEqual({
+					API_KEY: "secret",
+					DEBUG: "true",
+				});
+			});
+
+			test("removes omnidev server when switching to sandbox disabled", async () => {
+				await Bun.write(
+					".mcp.json",
+					JSON.stringify({
+						mcpServers: {
+							omnidev: { command: "bunx", args: ["omnidev", "serve"] },
+						},
+					}),
+				);
+
+				const capabilities = [
+					createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).not.toHaveProperty("omnidev");
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+			});
+
+			test("preserves user MCPs when sandbox disabled", async () => {
+				await Bun.write(
+					".mcp.json",
+					JSON.stringify({
+						mcpServers: {
+							myserver: { command: "node", args: ["my-server.js"] },
+						},
+					}),
+				);
+
+				const capabilities = [
+					createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("myserver");
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+			});
+
+			test("results in empty omni entries when no MCP capabilities", async () => {
+				const capabilities = [
+					createMockCapability("tasks"), // No MCP
+					createMockCapability("ralph"), // No MCP
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				const omniEntries = Object.keys(config.mcpServers).filter(isOmniDevMcp);
+				expect(omniEntries).toHaveLength(0);
+			});
+		});
+
+		describe("mode switching", () => {
+			test("switching from sandbox disabled to enabled cleans up correctly", async () => {
+				// Start in sandbox disabled mode
+				const capabilities = [
+					createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+				];
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				let config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+				expect(config.mcpServers).not.toHaveProperty("omnidev");
+
+				// Switch to sandbox enabled
+				await syncMcpJson(capabilities, true, { silent: true });
+
+				config = await readMcpJson();
+				expect(config.mcpServers).not.toHaveProperty("omni-context7");
+				expect(config.mcpServers).toHaveProperty("omnidev");
+			});
+
+			test("switching from sandbox enabled to disabled cleans up correctly", async () => {
+				// Start in sandbox enabled mode
+				const capabilities = [
+					createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+				];
+				await syncMcpJson(capabilities, true, { silent: true });
+
+				let config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omnidev");
+				expect(config.mcpServers).not.toHaveProperty("omni-context7");
+
+				// Switch to sandbox disabled
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+				expect(config.mcpServers).not.toHaveProperty("omnidev");
+			});
+		});
+
+		describe("capability toggle (sandbox disabled)", () => {
+			test("enabling MCP capability adds its entry", async () => {
+				// Start with no MCP capabilities
+				await syncMcpJson([createMockCapability("tasks")], false, { silent: true });
+
+				let config = await readMcpJson();
+				expect(Object.keys(config.mcpServers).filter(isOmniDevMcp)).toHaveLength(0);
+
+				// Enable MCP capability
+				await syncMcpJson(
+					[
+						createMockCapability("tasks"),
+						createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+					],
+					false,
+					{ silent: true },
+				);
+
+				config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+			});
+
+			test("disabling MCP capability removes its entry", async () => {
+				// Start with MCP capability
+				await syncMcpJson(
+					[createMockCapability("context7", { command: "npx", args: ["context7-mcp"] })],
+					false,
+					{ silent: true },
+				);
+
+				let config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+
+				// Disable the capability (only non-MCP capabilities remain)
+				await syncMcpJson([createMockCapability("tasks")], false, { silent: true });
+
+				config = await readMcpJson();
+				expect(config.mcpServers).not.toHaveProperty("omni-context7");
+			});
+		});
+
+		describe("multiple MCP capabilities", () => {
+			test("adds all MCP capabilities when sandbox disabled", async () => {
+				const capabilities = [
+					createMockCapability("context7", { command: "npx", args: ["context7-mcp"] }),
+					createMockCapability("playwright", { command: "npx", args: ["playwright-mcp"] }),
+					createMockCapability("tasks"), // No MCP
+				];
+
+				await syncMcpJson(capabilities, false, { silent: true });
+
+				const config = await readMcpJson();
+				expect(config.mcpServers).toHaveProperty("omni-context7");
+				expect(config.mcpServers).toHaveProperty("omni-playwright");
+				expect(config.mcpServers).not.toHaveProperty("omni-tasks");
+			});
+		});
+	});
+});

package/src/mcp-json/manager.ts

@@ -0,0 +1,118 @@
+import { existsSync } from "node:fs";
+import type { LoadedCapability, McpConfig } from "../types";
+
+/**
+ * MCP server configuration in .mcp.json
+ */
+export interface McpServerConfig {
+	command: string;
+	args?: string[];
+	env?: Record<string, string>;
+}
+
+/**
+ * Structure of .mcp.json file
+ */
+export interface McpJsonConfig {
+	mcpServers: Record<string, McpServerConfig>;
+}
+
+const MCP_JSON_PATH = ".mcp.json";
+
+/**
+ * Check if a server name is managed by OmniDev
+ */
+export function isOmniDevMcp(serverName: string): boolean {
+	return serverName === "omnidev" || serverName.startsWith("omni-");
+}
+
+/**
+ * Read .mcp.json or return empty config if doesn't exist
+ */
+export async function readMcpJson(): Promise<McpJsonConfig> {
+	if (!existsSync(MCP_JSON_PATH)) {
+		return { mcpServers: {} };
+	}
+
+	try {
+		const content = await Bun.file(MCP_JSON_PATH).text();
+		const parsed = JSON.parse(content);
+		return {
+			mcpServers: parsed.mcpServers || {},
+		};
+	} catch {
+		// If file is invalid JSON, return empty config
+		return { mcpServers: {} };
+	}
+}
+
+/**
+ * Write .mcp.json, preserving non-OmniDev entries
+ */
+export async function writeMcpJson(config: McpJsonConfig): Promise<void> {
+	await Bun.write(MCP_JSON_PATH, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Build MCP server config from capability's mcp section
+ */
+function buildMcpServerConfig(mcp: McpConfig): McpServerConfig {
+	const config: McpServerConfig = {
+		command: mcp.command,
+	};
+	if (mcp.args) {
+		config.args = mcp.args;
+	}
+	if (mcp.env) {
+		config.env = mcp.env;
+	}
+	return config;
+}
+
+/**
+ * Sync .mcp.json based on sandbox mode
+ *
+ * When sandboxEnabled = true (default):
+ *   - Only "omnidev" MCP server is registered
+ *   - Capability MCPs run as children of OmniDev server
+ *
+ * When sandboxEnabled = false:
+ *   - Each capability's MCP is registered as "omni-{capabilityId}"
+ *   - OmniDev server is NOT registered
+ */
+export async function syncMcpJson(
+	capabilities: LoadedCapability[],
+	sandboxEnabled: boolean,
+	options: { silent?: boolean } = {},
+): Promise<void> {
+	const mcpJson = await readMcpJson();
+
+	// Remove all OmniDev-managed MCPs first
+	for (const serverName of Object.keys(mcpJson.mcpServers)) {
+		if (isOmniDevMcp(serverName)) {
+			delete mcpJson.mcpServers[serverName];
+		}
+	}
+
+	if (sandboxEnabled) {
+		// Add only OmniDev MCP server
+		mcpJson.mcpServers["omnidev"] = {
+			command: "bunx",
+			args: ["omnidev", "serve"],
+		};
+	} else {
+		// Add MCPs from all enabled capabilities
+		for (const cap of capabilities) {
+			if (cap.config.mcp) {
+				mcpJson.mcpServers[`omni-${cap.id}`] = buildMcpServerConfig(cap.config.mcp);
+			}
+		}
+	}
+
+	await writeMcpJson(mcpJson);
+
+	if (!options.silent) {
+		const count = Object.keys(mcpJson.mcpServers).filter(isOmniDevMcp).length;
+		console.log(`  - .mcp.json (${count} MCP server(s))`);
+	}
+}

package/src/state/active-profile.test.ts

@@ -0,0 +1,131 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	clearActiveProfileState,
+	readActiveProfileState,
+	writeActiveProfileState,
+} from "./active-profile";
+
+describe("active-profile state", () => {
+	let originalCwd: string;
+	let tempDir: string;
+
+	beforeEach(() => {
+		originalCwd = process.cwd();
+		tempDir = mkdtempSync(join(tmpdir(), "active-profile-test-"));
+		mkdirSync(join(tempDir, ".omni"), { recursive: true });
+		process.chdir(tempDir);
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	describe("readActiveProfileState", () => {
+		test("returns null when state file does not exist", async () => {
+			const profile = await readActiveProfileState();
+			expect(profile).toBe(null);
+		});
+
+		test("reads profile from state file", async () => {
+			mkdirSync(".omni/state", { recursive: true });
+			await Bun.write(".omni/state/active-profile", "my-profile");
+
+			const profile = await readActiveProfileState();
+			expect(profile).toBe("my-profile");
+		});
+
+		test("trims whitespace from profile name", async () => {
+			mkdirSync(".omni/state", { recursive: true });
+			await Bun.write(".omni/state/active-profile", "  my-profile  \n");
+
+			const profile = await readActiveProfileState();
+			expect(profile).toBe("my-profile");
+		});
+
+		test("returns null for empty file", async () => {
+			mkdirSync(".omni/state", { recursive: true });
+			await Bun.write(".omni/state/active-profile", "");
+
+			const profile = await readActiveProfileState();
+			expect(profile).toBe(null);
+		});
+
+		test("returns null for whitespace-only file", async () => {
+			mkdirSync(".omni/state", { recursive: true });
+			await Bun.write(".omni/state/active-profile", "   \n  ");
+
+			const profile = await readActiveProfileState();
+			expect(profile).toBe(null);
+		});
+	});
+
+	describe("writeActiveProfileState", () => {
+		test("writes profile to state file", async () => {
+			await writeActiveProfileState("production");
+
+			const content = await Bun.file(".omni/state/active-profile").text();
+			expect(content).toBe("production");
+		});
+
+		test("creates state directory if it does not exist", async () => {
+			expect(existsSync(".omni/state")).toBe(false);
+
+			await writeActiveProfileState("dev");
+
+			expect(existsSync(".omni/state")).toBe(true);
+			const content = await Bun.file(".omni/state/active-profile").text();
+			expect(content).toBe("dev");
+		});
+
+		test("overwrites existing state file", async () => {
+			mkdirSync(".omni/state", { recursive: true });
+			await Bun.write(".omni/state/active-profile", "old-profile");
+
+			await writeActiveProfileState("new-profile");
+
+			const content = await Bun.file(".omni/state/active-profile").text();
+			expect(content).toBe("new-profile");
+		});
+	});
+
+	describe("clearActiveProfileState", () => {
+		test("deletes state file when it exists", async () => {
+			mkdirSync(".omni/state", { recursive: true });
+			await Bun.write(".omni/state/active-profile", "some-profile");
+
+			expect(existsSync(".omni/state/active-profile")).toBe(true);
+
+			await clearActiveProfileState();
+
+			expect(existsSync(".omni/state/active-profile")).toBe(false);
+		});
+
+		test("does nothing when state file does not exist", async () => {
+			expect(existsSync(".omni/state/active-profile")).toBe(false);
+
+			// Should not throw
+			await clearActiveProfileState();
+
+			expect(existsSync(".omni/state/active-profile")).toBe(false);
+		});
+	});
+
+	describe("round-trip", () => {
+		test("write then read returns same profile", async () => {
+			await writeActiveProfileState("test-profile");
+			const profile = await readActiveProfileState();
+			expect(profile).toBe("test-profile");
+		});
+
+		test("clear then read returns null", async () => {
+			await writeActiveProfileState("test-profile");
+			await clearActiveProfileState();
+			const profile = await readActiveProfileState();
+			expect(profile).toBe(null);
+		});
+	});
+});

package/src/state/active-profile.ts

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync } from "node:fs";
+
+const STATE_DIR = ".omni/state";
+const ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
+
+/**
+ * Read the active profile from state file.
+ * Returns null if no active profile is set in state.
+ */
+export async function readActiveProfileState(): Promise<string | null> {
+	if (!existsSync(ACTIVE_PROFILE_PATH)) {
+		return null;
+	}
+
+	try {
+		const content = await Bun.file(ACTIVE_PROFILE_PATH).text();
+		const trimmed = content.trim();
+		return trimmed || null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Write the active profile to state file.
+ * @param profileName - The name of the profile to set as active
+ */
+export async function writeActiveProfileState(profileName: string): Promise<void> {
+	mkdirSync(STATE_DIR, { recursive: true });
+	await Bun.write(ACTIVE_PROFILE_PATH, profileName);
+}
+
+/**
+ * Clear the active profile state (delete the state file).
+ */
+export async function clearActiveProfileState(): Promise<void> {
+	if (existsSync(ACTIVE_PROFILE_PATH)) {
+		const file = Bun.file(ACTIVE_PROFILE_PATH);
+		await file.delete();
+	}
+}

package/src/state/index.ts

@@ -0,0 +1,2 @@
+export * from "./active-profile";
+export * from "./manifest";