oh-my-opencode 4.12.1 → 4.14.0

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

@@ -0,0 +1,146 @@
+import { describe, expect, it } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+
+import { runCodegraphServe } from "../src/serve.ts";
+
+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(tmpdir(), "omo-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.0.1" },
+					},
+				},
+				{
+					id: 2,
+					jsonrpc: "2.0",
+					result: {
+						tools: [
+							{ name: "codegraph_search" },
+							{ name: "codegraph_node" },
+							{ name: "codegraph_explore" },
+							{ name: "codegraph_callers" },
+						],
+					},
+				},
+			]);
+			expect(readFileSync(childLog, "utf8")).toContain(`cwd=${realpathSync(projectRoot)}`);
+		} finally {
+			rmSync(tempRoot, { recursive: true, force: true });
+		}
+	});
+});
+
+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);
+}
+
+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 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;
+}

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

@@ -0,0 +1,68 @@
+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" },
+			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.0.1" },
+			},
+		});
+	});
+});
+
+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,4 +1,5 @@
 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";
@@ -11,6 +12,7 @@ describe("runCodegraphServe node support", () => {
 
 		// when
 		const exitCode = await runCodegraphServe({
+			...closedMcpStdio(),
 			env: { PATH: "/bin" },
 			nodeVersion: "26.3.0",
 			buildEnv: () => ({}),
@@ -23,7 +25,7 @@ describe("runCodegraphServe node support", () => {
 		});
 
 		// then
-		expect(exitCode).toBe(1);
+		expect(exitCode).toBe(0);
 		expect(spawned).toEqual([]);
 		expect(stderr).toHaveLength(1);
 		expect(stderr[0]).toContain("CodeGraph MCP skipped");
@@ -31,3 +33,11 @@ describe("runCodegraphServe node support", () => {
 		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 };
+}

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

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+
+import { runCodegraphServe } from "../src/serve.ts";
+
+describe("runCodegraphServe unavailable CodeGraph paths", () => {
+	it("#given CodeGraph is unresolved #when serving MCP #then exposes an empty facade with a skip hint", async () => {
+		// given
+		const stderr: string[] = [];
+		const spawned: string[] = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			...closedMcpStdio(),
+			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
+			env: { PATH: "/bin" },
+			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).toEqual([
+			"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n",
+		]);
+	});
+
+	it("#given an unsupported local Node #when serving MCP #then exposes an empty facade without spawning codegraph", async () => {
+		// given
+		const stderr: string[] = [];
+		const spawned: string[] = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			...closedMcpStdio(),
+			env: {},
+			nodeVersion: "26.3.0",
+			buildEnv: () => ({}),
+			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: true, 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("CODEGRAPH_ALLOW_UNSAFE_NODE");
+	});
+
+	it("#given OMO_CODEGRAPH_BIN points at a missing path #when serving MCP #then exposes an empty facade before spawn", async () => {
+		// given
+		const stderr: string[] = [];
+		const spawned: string[] = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			...closedMcpStdio(),
+			buildEnv: () => ({}),
+			commandExists: () => false,
+			resolve: () => ({ argsPrefix: [], command: "/nonexistent", exists: true, source: "env" }),
+			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).toEqual([
+			"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n",
+		]);
+	});
+
+	it("#given Codex SOT disables CodeGraph #when serving MCP #then exposes an empty facade with a disabled hint", async () => {
+		// given
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-disabled-home-"));
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-disabled-workspace-"));
+		const stderr: string[] = [];
+		const spawned: string[] = [];
+		try {
+			mkdirSync(join(homeDir, ".omo"), { recursive: true });
+			mkdirSync(join(workspace, ".omo"), { recursive: true });
+			writeFileSync(join(homeDir, ".omo", "config.jsonc"), '{ "codegraph": { "enabled": true } }\n');
+			writeFileSync(join(workspace, ".omo", "config.jsonc"), '{ "[codex]": { "codegraph": { "enabled": false } } }\n');
+
+			// when
+			const exitCode = await runCodegraphServe({
+				...closedMcpStdio(),
+				cwd: workspace,
+				env: { HOME: homeDir },
+				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).toEqual([
+				"CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.\n",
+			]);
+		} finally {
+			rmSync(homeDir, { recursive: true, force: true });
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+});
+
+function closedMcpStdio(): { readonly stdin: PassThrough; readonly stdout: PassThrough } {
+	const stdin = new PassThrough();
+	const stdout = new PassThrough();
+	stdout.resume();
+	stdin.end();
+	return { stdin, stdout };
+}

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

@@ -10,44 +10,21 @@ import { resolveServeProcessInvocation, runCodegraphServe } from "../src/serve.t
 const componentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 describe("runCodegraphServe", () => {
-	it("#given CodeGraph is unresolved #when serving MCP #then exits non-zero with a one-line skip hint", async () => {
-		// given
-		const stderr: string[] = [];
-		const spawned: string[] = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
-			env: { PATH: "/bin" },
-			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(1);
-		expect(spawned).toEqual([]);
-		expect(stderr).toEqual([
-			"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n",
-		]);
-	});
-
-	it("#given CodeGraph resolves #when serving MCP #then execs codegraph serve --mcp with inherited stdio and telemetry disabled", async () => {
+	it("#given CodeGraph resolves #when serving MCP #then execs codegraph serve --mcp with bridged stdio and telemetry disabled", async () => {
 		// given
+		const runCwd = componentRoot;
 		const calls: Array<{
 			readonly args: readonly string[];
 			readonly command: string;
+			readonly cwd: string;
 			readonly env: Record<string, string | undefined>;
-			readonly stdio: "inherit";
+			readonly stdio: "pipe";
 		}> = [];
 
 		// when
 		const exitCode = await runCodegraphServe({
-			env: { CUSTOM: "keep", HOME: "/tmp/home" },
+			cwd: runCwd,
+			env: { CUSTOM: "drop", HOME: "/tmp/home", OPENAI_API_KEY: "sk-test-secret" },
 			nodeVersion: "22.14.0",
 			homeDir: "/tmp/home",
 			buildEnv: ({ homeDir }) => ({
@@ -60,9 +37,9 @@ describe("runCodegraphServe", () => {
 			runProcess: (
 				command: string,
 				args: readonly string[],
-				options: { readonly env: Record<string, string | undefined>; readonly stdio: "inherit" },
+				options: { readonly cwd: string; readonly env: Record<string, string | undefined>; readonly stdio: "pipe" },
 			) => {
-				calls.push({ args, command, env: options.env, stdio: options.stdio });
+				calls.push({ args, command, cwd: options.cwd, env: options.env, stdio: options.stdio });
 				return Promise.resolve(7);
 			},
 			stderr: { write: () => undefined },
@@ -74,43 +51,19 @@ describe("runCodegraphServe", () => {
 			{
 				args: ["shim.js", "serve", "--mcp"],
 				command: "node",
+				cwd: resolve(runCwd),
 				env: {
 					CODEGRAPH_INSTALL_DIR: "/tmp/home/.omo/codegraph",
 					CODEGRAPH_NO_DOWNLOAD: "1",
 					CODEGRAPH_TELEMETRY: "0",
-					CUSTOM: "keep",
 					DO_NOT_TRACK: "1",
 					HOME: "/tmp/home",
 				},
-				stdio: "inherit",
+				stdio: "pipe",
 			},
 		]);
-	});
-
-	it("#given an unsupported local Node #when serving MCP #then skips fast without spawning codegraph", async () => {
-		// given
-		const stderr: string[] = [];
-		const spawned: string[] = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			env: {},
-			nodeVersion: "26.3.0",
-			buildEnv: () => ({}),
-			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: true, source: "path" }),
-			runProcess: (command: string) => {
-				spawned.push(command);
-				return Promise.resolve(0);
-			},
-			stderr: { write: (chunk: string) => stderr.push(chunk) },
-		});
-
-		// then
-		expect(exitCode).toBe(1);
-		expect(spawned).toEqual([]);
-		expect(stderr).toHaveLength(1);
-		expect(stderr[0]).toContain("CodeGraph MCP skipped");
-		expect(stderr[0]).toContain("CODEGRAPH_ALLOW_UNSAFE_NODE");
+		expect(calls[0]?.env["CUSTOM"]).toBeUndefined();
+		expect(calls[0]?.env["OPENAI_API_KEY"]).toBeUndefined();
 	});
 
 	it("#given an unsupported local Node but the unsafe override is set #when serving MCP #then it still spawns codegraph", async () => {
@@ -182,66 +135,6 @@ describe("runCodegraphServe", () => {
 		expect(spawned).toEqual([{ args: ["serve", "--mcp"], command: commandPath }]);
 	});
 
-	it("#given OMO_CODEGRAPH_BIN points at a missing path #when serving MCP #then exits before spawn", async () => {
-		// given
-		const stderr: string[] = [];
-		const spawned: string[] = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			buildEnv: () => ({}),
-			commandExists: () => false,
-			resolve: () => ({ argsPrefix: [], command: "/nonexistent", exists: true, source: "env" }),
-			runProcess: (command: string) => {
-				spawned.push(command);
-				return Promise.resolve(0);
-			},
-			stderr: { write: (chunk: string) => stderr.push(chunk) },
-		});
-
-		// then
-		expect(exitCode).toBe(1);
-		expect(spawned).toEqual([]);
-		expect(stderr).toEqual([
-			"CodeGraph MCP skipped: codegraph binary not found. Install CodeGraph or set OMO_CODEGRAPH_BIN.\n",
-		]);
-	});
-
-	it("#given Codex SOT disables CodeGraph #when serving MCP #then exits non-zero with a disabled hint", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-disabled-home-"));
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-disabled-workspace-"));
-		const stderr: string[] = [];
-		const spawned: string[] = [];
-		try {
-			mkdirSync(join(homeDir, ".omo"), { recursive: true });
-			mkdirSync(join(workspace, ".omo"), { recursive: true });
-			writeFileSync(join(homeDir, ".omo", "config.jsonc"), '{ "codegraph": { "enabled": true } }\n');
-			writeFileSync(join(workspace, ".omo", "config.jsonc"), '{ "[codex]": { "codegraph": { "enabled": false } } }\n');
-
-			// when
-			const exitCode = await runCodegraphServe({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				runProcess: (command: string) => {
-					spawned.push(command);
-					return Promise.resolve(0);
-				},
-				stderr: { write: (chunk: string) => stderr.push(chunk) },
-			});
-
-			// then
-			expect(exitCode).toBe(1);
-			expect(spawned).toEqual([]);
-			expect(stderr).toEqual([
-				"CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.\n",
-			]);
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
 	it("#given Windows Codex SOT install_dir has codegraph.cmd #when serving MCP #then it resolves there and exports CODEGRAPH_INSTALL_DIR", async () => {
 		await withProcessPlatform("win32", async () => {
 			// given
@@ -260,7 +153,7 @@ describe("runCodegraphServe", () => {
 
 				// when
 				const exitCode = await runCodegraphServe({
-					config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], warnings: [] },
+					config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
 					env: { HOME: "/tmp/home" },
 					nodeVersion: "22.14.0",
 					homeDir: "/tmp/home",

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

@@ -52,6 +52,7 @@ describe("CodeGraph SessionStart worker Node support", () => {
 		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-home-"));
 		const binPath = join(homeDir, ".omo", "codegraph", "bin", "codegraph");
 		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
+		const provisionCalls: Array<{ readonly installDir?: string; readonly lockDir: string; readonly version: "1.0.1" }> = [];
 		const outcomes: unknown[] = [];
 
 		try {
@@ -63,7 +64,10 @@ describe("CodeGraph SessionStart worker Node support", () => {
 				logOutcome: (outcome) => outcomes.push(outcome),
 				deps: {
 					ensureGitignored: () => true,
-					ensureProvisioned: () => Promise.resolve({ binPath, provisioned: true }),
+					ensureProvisioned: (options) => {
+						provisionCalls.push(options);
+						return Promise.resolve({ binPath, provisioned: true });
+					},
 					prepareWorkspace: () => ({
 						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
 						dataRoot: join(homeDir, ".omo/codegraph"),
@@ -85,6 +89,9 @@ describe("CodeGraph SessionStart worker Node support", () => {
 				{ args: ["status", "--json"], command: binPath },
 				{ args: ["init"], command: binPath },
 			]);
+			expect(provisionCalls).toEqual([
+				{ installDir: join(homeDir, ".omo", "codegraph"), lockDir: join(homeDir, ".omo", "codegraph", ".locks"), version: "1.0.1" },
+			]);
 			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
 		} finally {
 			rmSync(workspace, { recursive: true, force: true });

package/packages/omo-codex/plugin/components/codegraph/test/session-start-trust-boundary.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runCodegraphSessionStartWorker } from "../src/hook.ts";
+
+describe("CodeGraph SessionStart trust boundary", () => {
+	it("#given project config sets install_dir #when worker provisions CodeGraph #then it uses the trusted home install root", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-untrusted-project-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-untrusted-project-home-"));
+		const attackerInstallDir = join(workspace, "attacker-install");
+		const trustedInstallDir = join(homeDir, ".omo", "codegraph");
+		const calls: Array<{ readonly env: Record<string, string>; readonly installDir?: string; readonly lockDir?: string }> = [];
+		try {
+			mkdirSync(join(workspace, ".omo"), { recursive: true });
+			writeFileSync(join(workspace, ".omo", "config.jsonc"), JSON.stringify({ codegraph: { enabled: true, install_dir: attackerInstallDir } }));
+
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				cwd: workspace,
+				env: { HOME: homeDir },
+				nodeVersion: "22.14.0",
+				deps: {
+					ensureGitignored: () => true,
+					ensureProvisioned: (options) => {
+						calls.push({
+							env: {},
+							...(options.installDir === undefined ? {} : { installDir: options.installDir }),
+							...(options.lockDir === undefined ? {} : { lockDir: options.lockDir }),
+						});
+						return Promise.resolve({ binPath: join(trustedInstallDir, "bin", "codegraph"), provisioned: true });
+					},
+					prepareWorkspace: () => ({
+						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
+						dataRoot: join(homeDir, ".omo/codegraph"),
+						linked: true,
+						mode: "global-linked",
+						projectLink: join(workspace, ".codegraph"),
+					}),
+					resolveCommand: (options) => {
+						expect(options?.provisioned?.()).toBe(null);
+						return { argsPrefix: [], command: "missing-codegraph", exists: false, source: "path" };
+					},
+					runCommand: (_projectRoot, _command, _args, options) => {
+						calls.push({ env: options.env });
+						return Promise.resolve({ exitCode: 0, stdout: calls.length === 2 ? '{"initialized":false}' : "", timedOut: false });
+					},
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "initialized" });
+			expect(calls[0]).toEqual({ env: {}, installDir: trustedInstallDir, lockDir: join(trustedInstallDir, ".locks") });
+			expect(calls[1]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(trustedInstallDir);
+			expect(calls[1]?.env["CODEGRAPH_INSTALL_DIR"]).not.toBe(attackerInstallDir);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+		}
+	});
+});