oh-my-opencode 5.0.0-beta.33 → 5.0.0-beta.35

package/packages/omo-codex/plugin/components/codegraph/test/serve-built-wrapper.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-const componentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-
-describe("built CodeGraph serve wrappers", () => {
-	it("#given built serve entry #when invoked with a fake CodeGraph binary #then it runs serve mcp exactly once", () => {
-		// given
-		const tempRoot = createFakeCodegraphRoot();
-		try {
-			// when
-			const result = runBuiltWrapper("dist/serve.js", tempRoot);
-
-			// then
-			expect(result.status).toBe(0);
-			expect(result.stderr).toBe("");
-			expect(readInvocations(tempRoot)).toEqual(['["serve","--mcp"]']);
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given built cli entry #when invoked with a fake CodeGraph binary #then it runs serve mcp exactly once", () => {
-		// given
-		const tempRoot = createFakeCodegraphRoot();
-		try {
-			// when
-			const result = runBuiltWrapper("dist/cli.js", tempRoot);
-
-			// then
-			expect(result.status).toBe(0);
-			expect(result.stderr).toBe("");
-			expect(readInvocations(tempRoot)).toEqual(['["serve","--mcp"]']);
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-});
-
-function createFakeCodegraphRoot(): string {
-	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-wrapper-"));
-	const fakeBinaryPath = join(tempRoot, "codegraph-fake.cjs");
-	writeFileSync(
-		fakeBinaryPath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"fs.appendFileSync(process.env.CODEGRAPH_FAKE_LOG, JSON.stringify(process.argv.slice(2)) + '\\n');",
-			"",
-		].join("\n"),
-	);
-	chmodSync(fakeBinaryPath, 0o755);
-	return tempRoot;
-}
-
-function runBuiltWrapper(entryPath: string, tempRoot: string): ReturnType<typeof spawnSync> {
-	return spawnSync(process.execPath, [join(componentRoot, entryPath)], {
-		cwd: componentRoot,
-		encoding: "utf8",
-		env: {
-			...process.env,
-			CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-			CODEGRAPH_FAKE_LOG: join(tempRoot, "invocations.log"),
-			OMO_CODEGRAPH_BIN: join(tempRoot, "codegraph-fake.cjs"),
-		},
-		timeout: 5000,
-	});
-}
-
-function readInvocations(tempRoot: string): readonly string[] {
-	return readFileSync(join(tempRoot, "invocations.log"), "utf8").trim().split("\n");
-}

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-bridge-lifecycle.test.ts

@@ -1,133 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { PassThrough, Writable } from "node:stream";
-import { fileURLToPath } from "node:url";
-
-import { isProcessAlive } from "../../../../../mcp-stdio-core/src/index.ts";
-import { runCodegraphServe } from "../src/serve.ts";
-import {
-	frameMcpRequest,
-	writeFakeExitingCodegraph,
-	writeFakeHeldOpenCodegraph,
-} from "./mcp-bridge-fixtures.ts";
-
-const componentRoot = realpathSync(
-	fileURLToPath(new URL("..", import.meta.url)),
-);
-
-describe("runCodegraphServe MCP bridge lifecycle", () => {
-	it("#given an exiting Codegraph child and delayed closed parent output #when the final response write fails #then the output error is preserved", async () => {
-		const tempRoot = mkdtempSync(
-			join(componentRoot, ".tmp-codegraph-exit-output-failure-"),
-		);
-		const projectRoot = join(tempRoot, "project");
-		const fakeCodegraph = join(tempRoot, "codegraph-exiting.cjs");
-		const input = new PassThrough();
-		const outputError = Object.assign(
-			new Error("parent output closed after child exit"),
-			{ code: "EPIPE" },
-		);
-		const writeStarted = Promise.withResolvers<void>();
-		const output = new Writable({
-			write(_chunk, _encoding, callback) {
-				writeStarted.resolve();
-				setTimeout(() => callback(outputError), 150);
-			},
-		});
-
-		try {
-			mkdirSync(projectRoot, { recursive: true });
-			writeFakeExitingCodegraph(fakeCodegraph);
-			const run = runCodegraphServe({
-				cwd: tempRoot,
-				env: {
-					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-					OMO_CODEGRAPH_BIN: fakeCodegraph,
-					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
-					PATH: process.env["PATH"],
-				},
-				nodeVersion: "22.14.0",
-				buildEnv: () => ({}),
-				resolve: () => ({
-					argsPrefix: [],
-					command: fakeCodegraph,
-					exists: true,
-					source: "env",
-				}),
-				stderr: { write: () => undefined },
-				stdin: input,
-				stdout: output,
-			});
-
-			input.end(frameMcpRequest({ id: 1, method: "tools/list", params: {} }));
-
-			await writeStarted.promise;
-			await expect(run).rejects.toBe(outputError);
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given a held-open Codegraph child and a dead parent #when the bridge watchdog polls #then the child is terminated and the bridge settles through the child-exit path", async () => {
-		// given
-		const tempRoot = mkdtempSync(
-			join(componentRoot, ".tmp-codegraph-orphan-"),
-		);
-		const projectRoot = join(tempRoot, "project");
-		const fakeCodegraph = join(tempRoot, "codegraph-held-open.cjs");
-		const childPidFile = join(tempRoot, "child.pid");
-		// Client stdio is held open and never sees EOF, so the parent-liveness
-		// watchdog is the only settle path. The probe reports the parent alive
-		// until the child has started, making the poll fire deterministically.
-		const input = new PassThrough();
-		const output = new PassThrough();
-		output.resume();
-		let childPid: number | undefined;
-
-		try {
-			mkdirSync(projectRoot, { recursive: true });
-			writeFakeHeldOpenCodegraph(fakeCodegraph);
-			const run = runCodegraphServe({
-				cwd: tempRoot,
-				env: {
-					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-					CODEGRAPH_FAKE_LOG: childPidFile,
-					OMO_CODEGRAPH_BIN: fakeCodegraph,
-					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
-					PATH: process.env["PATH"],
-				},
-				nodeVersion: "22.14.0",
-				buildEnv: () => ({}),
-				resolve: () => ({
-					argsPrefix: [],
-					command: fakeCodegraph,
-					exists: true,
-					source: "env",
-				}),
-				stderr: { write: () => undefined },
-				stdin: input,
-				stdout: output,
-				parentWatchdog: {
-					pollIntervalMs: 10,
-					probeAlive: () => !existsSync(childPidFile),
-				},
-			});
-
-			// when
-			const exitCode = await run;
-
-			// then
-			expect(exitCode).not.toBe(0);
-			childPid = Number(readFileSync(childPidFile, "utf8"));
-			expect(isProcessAlive(childPid)).toBe(false);
-		} finally {
-			if (childPid !== undefined && isProcessAlive(childPid)) {
-				process.kill(childPid, "SIGKILL");
-			}
-			input.destroy();
-			output.destroy();
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-});

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-bridge.test.ts

@@ -1,245 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { PassThrough, Writable } from "node:stream";
-import { fileURLToPath } from "node:url";
-
-import { runCodegraphServe } from "../src/serve.ts";
-import {
-	arrayProperty,
-	CODEGRAPH_150_DEFAULT_TOOLS,
-	findTool,
-	frameMcpRequest,
-	parseMcpBodies,
-	recordProperty,
-	recordValue,
-	stringProperty,
-	writeFakeContractCodegraph,
-	writeFakeHeldOpenCodegraph,
-	writeFakeNewlineCodegraph,
-} from "./mcp-bridge-fixtures.ts";
-
-const componentRoot = realpathSync(fileURLToPath(new URL("..", import.meta.url)));
-
-describe("runCodegraphServe MCP protocol bridge", () => {
-	it("#given Codex framed stdio and a newline-json CodeGraph child #when listing tools #then it bridges frames and serves from the project cwd", async () => {
-		// given
-		const tempRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-bridge-"));
-		const projectRoot = join(tempRoot, "project");
-		const pluginCacheRoot = join(tempRoot, "plugin-cache");
-		const fakeCodegraph = join(tempRoot, "codegraph-fake.cjs");
-		const childLog = join(tempRoot, "child.log");
-		const input = new PassThrough();
-		const output = new PassThrough();
-		let stdout = "";
-		output.on("data", (chunk: Buffer) => {
-			stdout += chunk.toString("utf8");
-		});
-
-		try {
-			mkdirSync(projectRoot, { recursive: true });
-			mkdirSync(pluginCacheRoot, { recursive: true });
-			writeFakeNewlineCodegraph(fakeCodegraph);
-
-			const run = runCodegraphServe({
-				cwd: pluginCacheRoot,
-				env: {
-					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-					CODEGRAPH_FAKE_LOG: childLog,
-					OMO_CODEGRAPH_BIN: fakeCodegraph,
-					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
-					PATH: process.env["PATH"],
-				},
-				nodeVersion: "22.14.0",
-				buildEnv: () => ({}),
-				resolve: () => ({ argsPrefix: [], command: fakeCodegraph, exists: true, source: "env" }),
-				stderr: { write: () => undefined },
-				stdin: input,
-				stdout: output,
-			});
-
-			// when
-			input.end([
-				frameMcpRequest({
-					id: 1,
-					method: "initialize",
-					params: {
-						capabilities: {},
-						clientInfo: { name: "codex", version: "0.141.0" },
-						protocolVersion: "2025-06-18",
-					},
-				}),
-				frameMcpRequest({
-					id: 2,
-					method: "tools/list",
-					params: {},
-				}),
-			].join(""));
-			const exitCode = await run;
-
-			// then
-			expect(exitCode).toBe(0);
-			const bodies = parseMcpBodies(stdout);
-			expect(bodies).toEqual([
-				{
-					id: 1,
-					jsonrpc: "2.0",
-					result: {
-						capabilities: { tools: { listChanged: false } },
-						protocolVersion: "2025-06-18",
-						serverInfo: { name: "codegraph", version: "1.5.0" },
-					},
-				},
-				{
-					id: 2,
-					jsonrpc: "2.0",
-					result: {
-						tools: CODEGRAPH_150_DEFAULT_TOOLS,
-					},
-				},
-			]);
-			expect(readFileSync(childLog, "utf8")).toContain(`cwd=${realpathSync(projectRoot)}`);
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given old upstream codegraph_node metadata and container outline guidance #when bridging #then it exposes the corrected LazyCodex contract", async () => {
-		// given
-		const tempRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-contract-"));
-		const projectRoot = join(tempRoot, "project");
-		const fakeCodegraph = join(tempRoot, "codegraph-contract-fake.cjs");
-		const childLog = join(tempRoot, "child.log");
-		const input = new PassThrough();
-		const output = new PassThrough();
-		let stdout = "";
-		output.on("data", (chunk: Buffer) => {
-			stdout += chunk.toString("utf8");
-		});
-
-		try {
-			mkdirSync(projectRoot, { recursive: true });
-			writeFakeContractCodegraph(fakeCodegraph);
-
-			const run = runCodegraphServe({
-				cwd: tempRoot,
-				env: {
-					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-					CODEGRAPH_FAKE_LOG: childLog,
-					OMO_CODEGRAPH_BIN: fakeCodegraph,
-					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
-					PATH: process.env["PATH"],
-				},
-				nodeVersion: "22.14.0",
-				buildEnv: () => ({}),
-				resolve: () => ({ argsPrefix: [], command: fakeCodegraph, exists: true, source: "env" }),
-				stderr: { write: () => undefined },
-				stdin: input,
-				stdout: output,
-			});
-
-			// when
-			input.end([
-				frameMcpRequest({
-					id: 1,
-					method: "tools/list",
-					params: {},
-				}),
-				frameMcpRequest({
-					id: 2,
-					method: "tools/call",
-					params: {
-						arguments: { includeCode: true, symbol: "JsonlMCP" },
-						name: "codegraph_node",
-					},
-				}),
-			].join(""));
-			const exitCode = await run;
-
-			// then
-			expect(exitCode).toBe(0);
-			const bodies = parseMcpBodies(stdout);
-			const tools = arrayProperty(recordProperty(recordValue(bodies[0]), "result"), "tools");
-			const nodeTool = findTool(tools, "codegraph_node");
-			const searchTool = findTool(tools, "codegraph_search");
-			expect(stringProperty(nodeTool, "description")).toContain("Container symbols");
-			expect(stringProperty(nodeTool, "description")).toContain("file mode");
-			expect(stringProperty(nodeTool, "description")).not.toContain("verbatim source");
-			expect(stringProperty(nodeTool, "description")).not.toContain("full body");
-			expect(
-				stringProperty(
-					recordProperty(recordProperty(recordProperty(nodeTool, "inputSchema"), "properties"), "includeCode"),
-					"description",
-				),
-			).toBe(
-				"Symbol mode: include leaf-symbol source when available. Container symbols such as classes, interfaces, structs, enums, modules, and namespaces intentionally return structural outlines with members; request a specific member symbol or use file mode with symbolsOnly=false plus offset/limit for source.",
-			);
-			expect(searchTool).toEqual({ description: "search stays unchanged", name: "codegraph_search" });
-
-			const callResult = recordProperty(recordValue(bodies[1]), "result");
-			const text = stringProperty(recordValue(arrayProperty(callResult, "content")[0]), "text");
-			expect(text).toContain("Container symbols intentionally return structural outlines");
-			expect(text).toContain("specific member symbol");
-			expect(text).toContain("file mode");
-			expect(text).toContain("symbolsOnly=false");
-			expect(text).not.toContain("Read tool");
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given a held-open Codegraph child and closed parent output #when response forwarding fails #then the child is terminated before rejection", async () => {
-		const tempRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-output-failure-"));
-		const projectRoot = join(tempRoot, "project");
-		const fakeCodegraph = join(tempRoot, "codegraph-held-open.cjs");
-		const childPidFile = join(tempRoot, "child.pid");
-		const input = new PassThrough();
-		const outputError = Object.assign(new Error("parent output closed"), { code: "EPIPE" });
-		const output = new Writable({
-			write(_chunk, _encoding, callback) {
-				callback(outputError);
-			},
-		});
-		let childPid: number | undefined;
-
-		try {
-			mkdirSync(projectRoot, { recursive: true });
-			writeFakeHeldOpenCodegraph(fakeCodegraph);
-			const run = runCodegraphServe({
-				cwd: tempRoot,
-				env: {
-					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-					CODEGRAPH_FAKE_LOG: childPidFile,
-					OMO_CODEGRAPH_BIN: fakeCodegraph,
-					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
-					PATH: process.env["PATH"],
-				},
-				nodeVersion: "22.14.0",
-				buildEnv: () => ({}),
-				resolve: () => ({ argsPrefix: [], command: fakeCodegraph, exists: true, source: "env" }),
-				stderr: { write: () => undefined },
-				stdin: input,
-				stdout: output,
-			});
-
-			input.end(frameMcpRequest({ id: 1, method: "tools/list", params: {} }));
-
-			await expect(run).rejects.toBe(outputError);
-			childPid = Number(readFileSync(childPidFile, "utf8"));
-			expect(isProcessAlive(childPid)).toBe(false);
-		} finally {
-			if (childPid !== undefined && isProcessAlive(childPid)) process.kill(childPid, "SIGKILL");
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-});
-
-function isProcessAlive(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ESRCH") return false;
-		throw error;
-	}
-}

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-facade.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { PassThrough } from "node:stream";
-
-import { runCodegraphServe } from "../src/serve.ts";
-
-describe("runCodegraphServe MCP unavailable facade", () => {
-	it("#given CodeGraph is unavailable #when an MCP client initializes #then it answers with an empty-tool facade", async () => {
-		// given
-		const input = new PassThrough();
-		const output = new PassThrough();
-		const stderr: string[] = [];
-		let stdout = "";
-		output.on("data", (chunk: Buffer) => {
-			stdout += chunk.toString("utf8");
-		});
-
-		const run = runCodegraphServe({
-			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
-			env: { PATH: "/bin" },
-			nodeVersion: "22.14.0",
-			buildEnv: () => ({}),
-			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
-			stderr: { write: (chunk: string) => stderr.push(chunk) },
-			stdin: input,
-			stdout: output,
-		});
-
-		// when
-		input.end(frameMcpRequest({
-			id: 1,
-			method: "initialize",
-			params: {
-				capabilities: {},
-				clientInfo: { name: "ulw-red", version: "0.0.0" },
-				protocolVersion: "2025-06-18",
-			},
-		}));
-		const exitCode = await run;
-
-		// then
-		expect(exitCode).toBe(0);
-		expect(stderr).toEqual([
-			"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n",
-		]);
-		expect(parseFirstJsonRpcBody(stdout)).toEqual({
-			id: 1,
-			jsonrpc: "2.0",
-			result: {
-				capabilities: { tools: { listChanged: false } },
-				protocolVersion: "2025-06-18",
-				serverInfo: { name: "codegraph", version: "1.5.0" },
-			},
-		});
-	});
-});
-
-function frameMcpRequest(request: {
-	readonly id: number;
-	readonly method: string;
-	readonly params: Record<string, unknown>;
-}): string {
-	const body = JSON.stringify({ jsonrpc: "2.0", ...request });
-	return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
-}
-
-function parseFirstJsonRpcBody(transcript: string): unknown {
-	const [, body = ""] = transcript.split("\r\n\r\n", 2);
-	return JSON.parse(body);
-}

package/packages/omo-codex/plugin/components/codegraph/test/serve-node-support.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { PassThrough } from "node:stream";
-
-import { CODEGRAPH_UNSAFE_NODE_ENV } from "../../../../../utils/src/codegraph/node-support.ts";
-import { runCodegraphServe } from "../src/serve.ts";
-
-describe("runCodegraphServe node support", () => {
-	it("#given Node is too new and no command resolves #when serving MCP #then the unsupported-node hint wins", async () => {
-		// given
-		const stderr: string[] = [];
-		const spawned: string[] = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			...closedMcpStdio(),
-			env: { PATH: "/bin" },
-			nodeVersion: "26.3.0",
-			buildEnv: () => ({}),
-			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
-			runProcess: (command: string) => {
-				spawned.push(command);
-				return Promise.resolve(0);
-			},
-			stderr: { write: (chunk: string) => stderr.push(chunk) },
-		});
-
-		// then
-		expect(exitCode).toBe(0);
-		expect(spawned).toEqual([]);
-		expect(stderr).toHaveLength(1);
-		expect(stderr[0]).toContain("CodeGraph MCP skipped");
-		expect(stderr[0]).toContain("Node 26 is unsupported");
-		expect(stderr[0]).toContain(CODEGRAPH_UNSAFE_NODE_ENV);
-	});
-});
-
-function closedMcpStdio(): { readonly stdin: PassThrough; readonly stdout: PassThrough } {
-	const stdin = new PassThrough();
-	const stdout = new PassThrough();
-	stdout.resume();
-	stdin.end();
-	return { stdin, stdout };
-}