oh-my-opencode 4.15.0 → 4.16.0

package/packages/omo-codex/plugin/components/codegraph/src/hook.ts

@@ -1,14 +1,23 @@
 import { execFile, spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { cwd as processCwd, env as processEnv, stdin as processStdin, stdout as processStdout } from "node:process";
+import {
+	cwd as processCwd,
+	env as processEnv,
+	stderr as processStderr,
+	stdin as processStdin,
+	stdout as processStdout,
+} from "node:process";
 import type { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
 import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
 import { buildCodegraphInitGuidanceForToolResult } from "../../../../../utils/src/codegraph/guidance.ts";
 import { resolveCodegraphCommand } from "../../../../../utils/src/codegraph/resolve.ts";
+import { shouldExcludeCodegraphProject } from "../../../../../utils/src/codegraph/workspace.ts";
 import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
+import { pruneCodegraphProjectStoresBestEffort } from "./cache-gc.js";
+import { sweepCodegraphZombiesBestEffort } from "./hook-sweep.js";
 import { resolveCodegraphCommandInvocation, SESSION_START_CWD_ENV } from "./session-start-worker.js";
 import type {
 	HookStdout,
@@ -57,10 +66,25 @@ export async function executeCodegraphSessionStartHook(options: SessionStartHook
 	const projectRoot = resolveProjectRoot(input, options.cwd ?? processCwd());
 	const homeDir = resolveHomeDir(env);
 	const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
+	pruneCodegraphProjectStoresBestEffort(homeDir, { debugLog: writeDebugLog });
+	await sweepCodegraphZombiesBestEffort({
+		env,
+		homeDir,
+		...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
+		log: writeDebugLog,
+	}, options.sweepZombies);
 
 	if (config.codegraph?.enabled === false) {
 		return { action: "skipped-disabled", exitCode: 0 };
 	}
+	const excludedRoots = config.codegraph?.excluded_roots;
+	const exclusion = shouldExcludeCodegraphProject(projectRoot, {
+		homeDir,
+		...(excludedRoots === undefined ? {} : { excludedRoots }),
+	});
+	if (exclusion.excluded) {
+		return { action: "skipped-excluded", exitCode: 0 };
+	}
 
 	const isInitialized = await (options.statusProbe ?? isCodegraphProjectInitialized)({
 		env,
@@ -193,6 +217,11 @@ function writeHookJson(stdout: HookStdout): void {
 	stdout.write(`${JSON.stringify(output)}\n`);
 }
 
+function writeDebugLog(message: string): void {
+	if (processEnv["OMO_CODEGRAPH_DEBUG"] !== "1") return;
+	processStderr.write(`${message}\n`);
+}
+
 function spawnDetachedWorker(invocation: WorkerSpawnInvocation): void {
 	const child = spawn(invocation.command, [...invocation.args], { detached: true, env: invocation.env, stdio: "ignore" });
 	child.unref();

package/packages/omo-codex/plugin/components/codegraph/src/serve.ts

@@ -12,7 +12,11 @@ import {
 import type { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
-import { buildCodegraphChildEnv, buildCodegraphEnv } from "../../../../../utils/src/codegraph/env.ts";
+import {
+	CODEGRAPH_NO_DAEMON_ENV,
+	buildCodegraphChildEnv,
+	buildCodegraphEnv,
+} from "../../../../../utils/src/codegraph/env.ts";
 import {
 	buildCodegraphNodeSkipHint,
 	evaluateCodegraphNodeSupport,
@@ -27,6 +31,7 @@ import {
 	type CodegraphCommandResolution,
 	type ResolveCodegraphCommandOptions,
 } from "../../../../../utils/src/codegraph/resolve.ts";
+import { shouldExcludeCodegraphProject } from "../../../../../utils/src/codegraph/workspace.ts";
 import { getCodexOmoConfig, type CodexOmoConfig } from "../../../shared/src/config-loader.ts";
 import type { CodegraphConfig } from "./hook.js";
 import { runBridgedCodegraphProcess } from "./mcp-bridge.js";
@@ -78,6 +83,7 @@ const CODEGRAPH_SKIP_HINT =
 	"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n";
 const CODEGRAPH_DISABLED_HINT =
 	"CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.\n";
+const CODEGRAPH_EXCLUDED_HINT = "CodeGraph MCP skipped: project excluded by OMO CodeGraph policy.\n";
 const CODEGRAPH_VERSION = "1.0.1";
 const PROJECT_CWD_ENV_KEYS = ["OMO_CODEGRAPH_PROJECT_CWD", SESSION_START_CWD_ENV, "PWD"] as const;
 
@@ -91,6 +97,14 @@ export async function runCodegraphServe(options: RunCodegraphServeOptions = {}):
 	if (codegraphConfig.enabled === false) {
 		return runUnavailableMcp(CODEGRAPH_DISABLED_HINT, options);
 	}
+	const excludedRoots = codegraphConfig.excluded_roots;
+	const exclusion = shouldExcludeCodegraphProject(projectCwd, {
+		homeDir,
+		...(excludedRoots === undefined ? {} : { excludedRoots }),
+	});
+	if (exclusion.excluded) {
+		return runUnavailableMcp(CODEGRAPH_EXCLUDED_HINT, options);
+	}
 
 	const trustedInstallDir = config.trustedCodegraphInstallDir;
 	const resolutionOptions = {
@@ -183,7 +197,7 @@ function codegraphEnvForConfig(
 	homeDir: string,
 	buildEnv: ((options: { readonly homeDir: string }) => Record<string, string>) | undefined,
 ): Record<string, string> {
-	const env = buildEnv?.({ homeDir }) ?? buildCodegraphEnv({ homeDir });
+	const env = { ...(buildEnv?.({ homeDir }) ?? buildCodegraphEnv({ homeDir })), [CODEGRAPH_NO_DAEMON_ENV]: "1" };
 	return trustedInstallDir === undefined ? env : { ...env, CODEGRAPH_INSTALL_DIR: trustedInstallDir };
 }
 

package/packages/omo-codex/plugin/components/codegraph/src/sweep-cli.ts

@@ -0,0 +1,80 @@
+import type { HookStdout } from "./hook-types.js";
+import {
+	sweepCodegraphZombies,
+	type CodegraphZombieProcess,
+	type SweepCodegraphZombiesOptions,
+	type SweepCodegraphZombiesResult,
+} from "../../../../../utils/src/codegraph/process-sweep.ts";
+
+export interface RunCodegraphSweepCliOptions extends SweepCodegraphZombiesOptions {
+	readonly argv?: readonly string[];
+	readonly stdout?: HookStdout;
+}
+
+interface SweepCliArgs {
+	readonly dryRun: boolean;
+	readonly force: boolean;
+	readonly roots: readonly string[];
+}
+
+export async function runCodegraphSweepCli(options: RunCodegraphSweepCliOptions = {}): Promise<number> {
+	const args = parseSweepCliArgs(options.argv ?? process.argv);
+	const result = await sweepCodegraphZombies({
+		...options,
+		dryRun: args.dryRun,
+		extraRoots: args.roots,
+		force: args.force,
+		...(args.roots.length > 0 ? { ownedRoots: args.roots } : {}),
+	});
+	writeSweepReport(options.stdout ?? process.stdout, result);
+	return result.action === "failed" ? 1 : 0;
+}
+
+function parseSweepCliArgs(argv: readonly string[]): SweepCliArgs {
+	const roots: string[] = [];
+	let dryRun = false;
+	let force = false;
+	for (let index = 3; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--dry-run") {
+			dryRun = true;
+			continue;
+		}
+		if (arg === "--force") {
+			force = true;
+			continue;
+		}
+		if (arg === "--root") {
+			const value = argv[index + 1];
+			if (value !== undefined && value.trim().length > 0) roots.push(value);
+			index += 1;
+		}
+	}
+	return { dryRun, force, roots };
+}
+
+function writeSweepReport(stdout: HookStdout, result: SweepCodegraphZombiesResult): void {
+	stdout.write(`${JSON.stringify({
+		action: result.action,
+		candidates: result.candidates.map(formatProcess),
+		dryRun: result.dryRun,
+		failed: result.failed,
+		killed: result.killed.map(formatProcess),
+		ownedRoots: result.ownedRoots,
+		stampFile: result.stampFile,
+	})}\n`);
+}
+
+function formatProcess(processInfo: CodegraphZombieProcess): {
+	readonly matchKind: string;
+	readonly matchedRoot: string;
+	readonly pid: number;
+	readonly ppid: number;
+} {
+	return {
+		matchKind: processInfo.matchKind,
+		matchedRoot: processInfo.matchedRoot,
+		pid: processInfo.pid,
+		ppid: processInfo.ppid,
+	};
+}

package/packages/omo-codex/plugin/components/codegraph/test/cache-gc.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "bun:test";
+
+import { pruneCodegraphProjectStoresBestEffort } from "../src/cache-gc.ts";
+
+describe("CodeGraph cache GC wrapper", () => {
+	it("#given cache GC hits an expected filesystem race #when best-effort wrapper runs #then it logs and continues", () => {
+		const logs: string[] = [];
+		const error = Object.assign(new Error("project cache vanished"), { code: "ENOENT" });
+
+		pruneCodegraphProjectStoresBestEffort("/home/test", {
+			debugLog: (message) => logs.push(message),
+			prune: () => {
+				throw error;
+			},
+		});
+
+		expect(logs).toEqual(["CodeGraph cache GC skipped: project cache vanished"]);
+	});
+
+	it("#given cache GC hits an unknown code bug #when best-effort wrapper runs #then it rethrows", () => {
+		const logs: string[] = [];
+		const error = new Error("metadata invariant broken");
+
+		expect(() =>
+			pruneCodegraphProjectStoresBestEffort("/home/test", {
+				debugLog: (message) => logs.push(message),
+				prune: () => {
+					throw error;
+				},
+			}),
+		).toThrow("metadata invariant broken");
+		expect(logs).toEqual([]);
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/hook-exclusion.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+
+import {
+	executeCodegraphSessionStartHook,
+	type WorkerSpawnInvocation,
+} from "../src/hook.ts";
+
+const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
+
+function createAllowedWorkspace(prefix: string): string {
+	return mkdtempSync(join(pluginRoot, `.tmp-${prefix}-`));
+}
+
+describe("CodeGraph SessionStart exclusion policy", () => {
+	it("#given project root is inside an OMO state directory #when SessionStart fires #then it skips before probing or spawning", async () => {
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+		const stateRoot = createAllowedWorkspace("codegraph-omo-state");
+		const workspace = join(stateRoot, ".omo", "ultraresearch", "run", "clones", "repo");
+		mkdirSync(workspace, { recursive: true });
+
+		try {
+			// when
+			const result = await executeCodegraphSessionStartHook({
+				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
+				cwd: workspace,
+				env: { HOME: "/tmp/home" },
+				stdin: Readable.from(["{}"]),
+				stdout: { write: (chunk) => stdout.push(chunk) },
+				spawnWorker: (invocation) => spawned.push(invocation),
+				statusProbe: () => {
+					throw new Error("excluded projects must not probe CodeGraph status");
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
+			expect(spawned).toEqual([]);
+			expect(stdout.join("")).toBe("");
+		} finally {
+			rmSync(stateRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("#given project root is under a configured excluded root #when SessionStart fires #then it skips before spawning", async () => {
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+		const excludedRoot = createAllowedWorkspace("codegraph-custom-excluded");
+		const workspace = join(excludedRoot, "repo");
+		mkdirSync(workspace, { recursive: true });
+
+		try {
+			// when
+			const result = await executeCodegraphSessionStartHook({
+				config: { codegraph: { enabled: true, excluded_roots: [excludedRoot] }, sources: [], warnings: [] },
+				cwd: workspace,
+				env: { HOME: "/tmp/home" },
+				stdin: Readable.from(["{}"]),
+				stdout: { write: (chunk) => stdout.push(chunk) },
+				spawnWorker: (invocation) => spawned.push(invocation),
+				statusProbe: () => Promise.resolve(false),
+			});
+
+			// then
+			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
+			expect(spawned).toEqual([]);
+			expect(stdout.join("")).toBe("");
+		} finally {
+			rmSync(excludedRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("#given project root is under /tmp #when SessionStart fires on POSIX #then it skips before spawning", async () => {
+		if (process.platform === "win32") return;
+
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+		const workspace = mkdtempSync(join("/tmp", "omo-codegraph-excluded-"));
+
+		try {
+			// when
+			const result = await executeCodegraphSessionStartHook({
+				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
+				cwd: workspace,
+				env: { HOME: "/tmp/home" },
+				stdin: Readable.from(["{}"]),
+				stdout: { write: (chunk) => stdout.push(chunk) },
+				spawnWorker: (invocation) => spawned.push(invocation),
+				statusProbe: () => Promise.resolve(false),
+			});
+
+			// then
+			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
+			expect(spawned).toEqual([]);
+			expect(stdout.join("")).toBe("");
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/hook-registration.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
+const pluginConfigPath = resolve(pluginRoot, ".codex-plugin/plugin.json");
+
+describe("CodeGraph hook registration", () => {
+	it("#given plugin hook config #when inspected #then CodeGraph is registered after bootstrap SessionStart", () => {
+		// given
+		const pluginConfig: unknown = JSON.parse(readFileSync(pluginConfigPath, "utf8"));
+
+		// when
+		const hookPaths =
+			typeof pluginConfig === "object" && pluginConfig !== null && "hooks" in pluginConfig && Array.isArray(pluginConfig.hooks)
+				? pluginConfig.hooks.filter((hookPath): hookPath is string => typeof hookPath === "string")
+				: [];
+
+		// then
+		expect(hookPaths).toContain("./hooks/session-start-checking-codegraph-bootstrap.json");
+		expect(hookPaths.indexOf("./hooks/session-start-checking-bootstrap-provisioning.json")).toBeLessThan(
+			hookPaths.indexOf("./hooks/session-start-checking-codegraph-bootstrap.json"),
+		);
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/hook-sweep.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "bun:test";
+import { Readable } from "node:stream";
+
+import { executeCodegraphSessionStartHook, type WorkerSpawnInvocation } from "../src/hook.ts";
+
+describe("CodeGraph SessionStart zombie sweep", () => {
+	it("#given the zombie sweep fails #when SessionStart fires #then the hook still exits zero", async () => {
+		// given
+		const stdout: string[] = [];
+		const spawned: WorkerSpawnInvocation[] = [];
+
+		// when
+		const result = await executeCodegraphSessionStartHook({
+			config: { codegraph: { enabled: false }, sources: [], warnings: [] },
+			env: { HOME: "/tmp/home" },
+			stdin: Readable.from(["{}"]),
+			stdout: { write: (chunk) => stdout.push(chunk) },
+			spawnWorker: (invocation) => spawned.push(invocation),
+			sweepZombies: () => {
+				throw new Error("ps unavailable");
+			},
+		});
+
+		// then
+		expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
+		expect(spawned).toEqual([]);
+		expect(stdout.join("")).toBe("");
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/hook.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { Readable } from "node:stream";
@@ -13,7 +13,10 @@ import {
 } from "../src/hook.ts";
 
 const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
-const pluginConfigPath = resolve(pluginRoot, ".codex-plugin/plugin.json");
+
+function createAllowedWorkspace(prefix: string): string {
+	return mkdtempSync(join(pluginRoot, `.tmp-${prefix}-`));
+}
 
 function expectOmoCodegraphProjectStoreGuidance(context: string): void {
 	expect(context).toContain(".omo");
@@ -32,7 +35,7 @@ describe("CodeGraph SessionStart hook", () => {
 			// when
 			const exitCode = await runCodegraphCli({
 				argv: ["node", "cli.js", "hook", "session-start"],
-				cwd: mkdtempSync(join(tmpdir(), "omo-codegraph-hook-workspace-")),
+				cwd: createAllowedWorkspace("codegraph-hook-workspace"),
 				env: { HOME: homeDir },
 				stdin: Readable.from(["{}"]),
 				stdout: { write: (chunk) => stdout.push(chunk) },
@@ -212,7 +215,7 @@ describe("CodeGraph SessionStart hook", () => {
 		// given
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-workspace-"));
+		const workspace = createAllowedWorkspace("codegraph-workspace");
 
 		try {
 			// when
@@ -256,7 +259,7 @@ describe("CodeGraph SessionStart hook", () => {
 		// given
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-initialized-workspace-"));
+		const workspace = createAllowedWorkspace("codegraph-initialized-workspace");
 
 		try {
 			// when
@@ -299,20 +302,4 @@ describe("CodeGraph SessionStart hook", () => {
 		expect(stdout.join("")).toBe("");
 	});
 
-	it("#given plugin hook config #when inspected #then CodeGraph is registered after bootstrap SessionStart", () => {
-		// given
-		const pluginConfig: unknown = JSON.parse(readFileSync(pluginConfigPath, "utf8"));
-
-		// when
-		const hookPaths =
-			typeof pluginConfig === "object" && pluginConfig !== null && "hooks" in pluginConfig && Array.isArray(pluginConfig.hooks)
-				? pluginConfig.hooks.filter((hookPath): hookPath is string => typeof hookPath === "string")
-				: [];
-
-		// then
-		expect(hookPaths).toContain("./hooks/session-start-checking-codegraph-bootstrap.json");
-		expect(hookPaths.indexOf("./hooks/session-start-checking-bootstrap-provisioning.json")).toBeLessThan(
-			hookPaths.indexOf("./hooks/session-start-checking-codegraph-bootstrap.json"),
-		);
-	});
 });

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

@@ -0,0 +1,108 @@
+import { chmodSync, writeFileSync } from "node:fs";
+
+export function writeFakeNewlineCodegraph(filePath: string): void {
+	writeFileSync(
+		filePath,
+		[
+			"#!/usr/bin/env node",
+			"const fs = require('node:fs');",
+			"const readline = require('node:readline');",
+			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
+			"const rl = readline.createInterface({ input: process.stdin });",
+			"rl.on('line', (line) => {",
+			"  const request = JSON.parse(line);",
+			"  if (request.method === 'initialize') {",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { capabilities: { tools: { listChanged: false } }, protocolVersion: request.params.protocolVersion, serverInfo: { name: 'codegraph', version: '1.0.1' } } }) + '\\n');",
+			"  }",
+			"  if (request.method === 'tools/list') {",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [{ name: 'codegraph_search' }, { name: 'codegraph_node' }, { name: 'codegraph_explore' }, { name: 'codegraph_callers' }] } }) + '\\n');",
+			"  }",
+			"});",
+		].join("\n"),
+	);
+	chmodSync(filePath, 0o755);
+}
+
+export function writeFakeContractCodegraph(filePath: string): void {
+	writeFileSync(
+		filePath,
+		[
+			"#!/usr/bin/env node",
+			"const fs = require('node:fs');",
+			"const readline = require('node:readline');",
+			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
+			"const rl = readline.createInterface({ input: process.stdin });",
+			"rl.on('line', (line) => {",
+			"  const request = JSON.parse(line);",
+			"  if (request.method === 'tools/list') {",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [",
+			"      { name: 'codegraph_search', description: 'search stays unchanged' },",
+			"      { name: 'codegraph_node', description: 'ONE SYMBOL you can name - its location, signature, verbatim source (includeCode=true) and caller/callee trail in one call', inputSchema: { type: 'object', properties: { includeCode: { type: 'boolean', description: \"Symbol mode: include the symbol's full body (default: false).\" }, symbol: { type: 'string' } } } }",
+			"    ] } }) + '\\n');",
+			"  }",
+			"  if (request.method === 'tools/call') {",
+			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { content: [{ type: 'text', text: 'JsonlMCP\\nMembers (7)\\nStructural outline only. For full source, use the Read tool on this file or request a member.' }] } }) + '\\n');",
+			"  }",
+			"});",
+		].join("\n"),
+	);
+	chmodSync(filePath, 0o755);
+}
+
+export 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}`;
+}
+
+export function parseMcpBodies(transcript: string): readonly unknown[] {
+	const bodies: unknown[] = [];
+	let cursor = 0;
+	while (cursor < transcript.length) {
+		const headerEnd = transcript.indexOf("\r\n\r\n", cursor);
+		if (headerEnd === -1) break;
+		const header = transcript.slice(cursor, headerEnd);
+		const match = /^Content-Length: (?<length>\d+)$/m.exec(header);
+		if (match?.groups?.["length"] === undefined) break;
+		const length = Number.parseInt(match.groups["length"], 10);
+		const bodyStart = headerEnd + 4;
+		const body = transcript.slice(bodyStart, bodyStart + length);
+		bodies.push(JSON.parse(body));
+		cursor = bodyStart + length;
+	}
+	return bodies;
+}
+
+export function findTool(tools: readonly unknown[], name: string): Record<string, unknown> {
+	for (const tool of tools) {
+		const record = recordValue(tool);
+		if (record["name"] === name) return record;
+	}
+	throw new Error(`Missing tool ${name}`);
+}
+
+export function arrayProperty(record: Record<string, unknown>, key: string): readonly unknown[] {
+	const value = record[key];
+	if (!Array.isArray(value)) throw new Error(`Expected ${key} to be an array`);
+	return value;
+}
+
+export function recordProperty(record: Record<string, unknown>, key: string): Record<string, unknown> {
+	return recordValue(record[key]);
+}
+
+export function stringProperty(record: Record<string, unknown>, key: string): string {
+	const value = record[key];
+	if (typeof value !== "string") throw new Error(`Expected ${key} to be a string`);
+	return value;
+}
+
+export function recordValue(value: unknown): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		throw new Error("Expected record value");
+	}
+	return value as Record<string, unknown>;
+}

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

@@ -0,0 +1,76 @@
+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");
+}