oh-my-opencode 4.5.12 → 4.6.0

package/packages/omo-codex/plugin/components/git-bash/package.json

@@ -0,0 +1,23 @@
+{
+	"name": "@sisyphuslabs/codex-git-bash-hook",
+	"version": "0.1.0",
+	"description": "Codex hook component that reminds Windows sessions to prefer the OMO git_bash MCP.",
+	"type": "module",
+	"private": true,
+	"bin": {
+		"omo-git-bash-hook": "./dist/cli.js"
+	},
+	"files": ["dist", "hooks"],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"test": "bun test test/*.test.ts",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@types/node": "^25.7.0",
+		"typescript": "^6.0.3"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/packages/omo-codex/plugin/components/git-bash/src/cli.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { runGitBashHookCli } from "./codex-hook.js";
+
+const TOP_LEVEL_HELP =
+	"Usage:\n  omo-git-bash-hook hook pre-tool-use\n  omo-git-bash-hook hook post-compact\n  omo-git-bash-hook help | --help | -h\n";
+
+async function main(): Promise<number> {
+	const argv = process.argv.slice(2);
+	const command = argv[0];
+	if (command === undefined || command === "help" || command === "--help" || command === "-h") {
+		process.stdout.write(TOP_LEVEL_HELP);
+		return 0;
+	}
+	if (command === "hook" && argv[1] === "pre-tool-use") {
+		await runGitBashHookCli(process.stdin, process.stdout, "pre-tool-use");
+		return 0;
+	}
+	if (command === "hook" && argv[1] === "post-compact") {
+		await runGitBashHookCli(process.stdin, process.stdout, "post-compact");
+		return 0;
+	}
+	process.stderr.write(`[omo-git-bash-hook] unknown command: ${argv.join(" ")}\n${TOP_LEVEL_HELP}`);
+	return 1;
+}
+
+main()
+	.then((code) => {
+		process.exit(code);
+	})
+	.catch((error: unknown) => {
+		process.stderr.write(`[omo-git-bash-hook] ${error instanceof Error ? error.message : String(error)}\n`);
+		process.exit(1);
+	});

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

@@ -0,0 +1,180 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export interface PreToolUsePayload {
+	readonly cwd: string;
+	readonly hook_event_name: "PreToolUse";
+	readonly model: string;
+	readonly permission_mode: string;
+	readonly session_id: string;
+	readonly tool_input: unknown;
+	readonly tool_name: string;
+	readonly tool_use_id: string;
+	readonly transcript_path: string | null;
+	readonly turn_id: string;
+}
+
+export interface GitBashHookOptions {
+	readonly env?: NodeJS.ProcessEnv;
+	readonly platform?: NodeJS.Platform | string;
+	readonly pluginDataRoot?: string;
+}
+
+export interface PostCompactPayload {
+	readonly hook_event_name: "PostCompact";
+	readonly session_id: string;
+	readonly transcript_path?: string | null;
+	readonly trigger?: string;
+}
+
+interface PreToolUseHookOutput {
+	readonly hookSpecificOutput: {
+		readonly hookEventName: "PreToolUse";
+		readonly additionalContext: string;
+	};
+}
+
+const BASH_TOOL_NAME = "Bash";
+const REMINDER =
+	"On Windows, prefer the OMO git_bash MCP for shell commands before using built-in exec_command. Use exec_command only when git_bash is unavailable or for non-shell operations.";
+
+export function parsePreToolUsePayload(raw: string): PreToolUsePayload | null {
+	if (raw.trim().length === 0) return null;
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return isPreToolUsePayload(parsed) ? parsed : null;
+	} catch (error) {
+		if (error instanceof SyntaxError) return null;
+		return null;
+	}
+}
+
+export function parsePostCompactPayload(raw: string): PostCompactPayload | null {
+	if (raw.trim().length === 0) return null;
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return isPostCompactPayload(parsed) ? parsed : null;
+	} catch (error) {
+		if (error instanceof SyntaxError) return null;
+		return null;
+	}
+}
+
+export function applyGitBashPreToolUseReminder(payload: PreToolUsePayload, options: GitBashHookOptions = {}): string {
+	if (payload.hook_event_name !== "PreToolUse") return "";
+	if (payload.tool_name !== BASH_TOOL_NAME) return "";
+	if (!isWindowsHost(options)) return "";
+
+	const markerPath = reminderMarkerPath(payload.session_id, options.pluginDataRoot);
+	if (hasReminderMarker(markerPath)) return "";
+	mkdirSync(dirname(markerPath), { recursive: true });
+	writeFileSync(markerPath, `${new Date().toISOString()}\n`);
+
+	const output: PreToolUseHookOutput = {
+		hookSpecificOutput: {
+			hookEventName: "PreToolUse",
+			additionalContext: REMINDER,
+		},
+	};
+	return `${JSON.stringify(output)}\n`;
+}
+
+export function applyGitBashPostCompactReset(payload: PostCompactPayload, options: GitBashHookOptions = {}): string {
+	if (payload.hook_event_name !== "PostCompact") return "";
+	rmSync(reminderMarkerPath(payload.session_id, options.pluginDataRoot), { force: true });
+	return "";
+}
+
+export async function runGitBashHookCli(
+	stdin: NodeJS.ReadableStream,
+	stdout: NodeJS.WritableStream,
+	eventName: "pre-tool-use" | "post-compact" = "pre-tool-use",
+	options: GitBashHookOptions = {},
+): Promise<void> {
+	try {
+		const raw = await readAll(stdin);
+		const output =
+			eventName === "post-compact" ? postCompactOutput(raw, options) : preToolUseOutput(raw, options);
+		if (output.length > 0) stdout.write(output);
+	} catch (error) {
+		if (error instanceof Error) return;
+		return;
+	}
+}
+
+function preToolUseOutput(raw: string, options: GitBashHookOptions): string {
+	const payload = parsePreToolUsePayload(raw);
+	if (payload === null) return "";
+	return applyGitBashPreToolUseReminder(payload, options);
+}
+
+function postCompactOutput(raw: string, options: GitBashHookOptions): string {
+	const payload = parsePostCompactPayload(raw);
+	if (payload === null) return "";
+	return applyGitBashPostCompactReset(payload, options);
+}
+
+function isWindowsHost(options: GitBashHookOptions): boolean {
+	const platform = options.platform ?? process.platform;
+	if (platform === "win32") return true;
+	const env = options.env ?? process.env;
+	return env["OS"] === "Windows_NT" || env["ComSpec"] !== undefined || env["SystemRoot"] !== undefined;
+}
+
+function hasReminderMarker(path: string): boolean {
+	return existsSync(path);
+}
+
+function reminderMarkerPath(sessionId: string, pluginDataRoot?: string): string {
+	const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "omo-git-bash");
+	return join(root, "git-bash-reminder", `${safePathSegment(sessionId)}.seen`);
+}
+
+function safePathSegment(value: string): string {
+	return value.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+
+function isPreToolUsePayload(value: unknown): value is PreToolUsePayload {
+	if (!isRecord(value)) return false;
+	return (
+		value["hook_event_name"] === "PreToolUse" &&
+		typeof value["cwd"] === "string" &&
+		typeof value["model"] === "string" &&
+		typeof value["permission_mode"] === "string" &&
+		typeof value["session_id"] === "string" &&
+		typeof value["tool_name"] === "string" &&
+		typeof value["tool_use_id"] === "string" &&
+		(value["transcript_path"] === null || typeof value["transcript_path"] === "string") &&
+		typeof value["turn_id"] === "string" &&
+		Object.hasOwn(value, "tool_input")
+	);
+}
+
+function isPostCompactPayload(value: unknown): value is PostCompactPayload {
+	if (!isRecord(value)) return false;
+	return (
+		value["hook_event_name"] === "PostCompact" &&
+		typeof value["session_id"] === "string" &&
+		(value["transcript_path"] === undefined ||
+			value["transcript_path"] === null ||
+			typeof value["transcript_path"] === "string") &&
+		(value["trigger"] === undefined || typeof value["trigger"] === "string")
+	);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readAll(stdin: NodeJS.ReadableStream): Promise<string> {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		stdin.setEncoding("utf8");
+		stdin.on("data", (chunk: unknown) => {
+			data += chunk instanceof Buffer ? chunk.toString() : String(chunk);
+		});
+		stdin.once("error", reject);
+		stdin.once("end", () => resolve(data));
+	});
+}

package/packages/omo-codex/plugin/components/git-bash/src/index.ts

@@ -0,0 +1,10 @@
+export {
+	applyGitBashPostCompactReset,
+	applyGitBashPreToolUseReminder,
+	parsePostCompactPayload,
+	parsePreToolUsePayload,
+	runGitBashHookCli,
+	type GitBashHookOptions,
+	type PostCompactPayload,
+	type PreToolUsePayload,
+} from "./codex-hook.js";

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

@@ -0,0 +1,195 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable, Writable } from "node:stream";
+
+import {
+	applyGitBashPostCompactReset,
+	applyGitBashPreToolUseReminder,
+	runGitBashHookCli,
+	type PostCompactPayload,
+	type PreToolUsePayload,
+} from "../src/codex-hook.js";
+
+const temporaryDirectories: string[] = [];
+
+function createTemporaryDirectory(prefix: string): string {
+	const directory = mkdtempSync(join(tmpdir(), prefix));
+	temporaryDirectories.push(directory);
+	return directory;
+}
+
+afterEach(() => {
+	for (const directory of temporaryDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function preToolPayload(toolName: string, sessionId = "session-1"): PreToolUsePayload {
+	return {
+		cwd: "/repo",
+		hook_event_name: "PreToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		session_id: sessionId,
+		tool_input: { command: "pwd" },
+		tool_name: toolName,
+		tool_use_id: "call-1",
+		transcript_path: null,
+		turn_id: "turn-1",
+	};
+}
+
+function postCompactPayload(sessionId = "session-1"): PostCompactPayload {
+	return {
+		hook_event_name: "PostCompact",
+		session_id: sessionId,
+		transcript_path: null,
+		trigger: "manual",
+	};
+}
+
+function windowsEnv(): NodeJS.ProcessEnv {
+	return { OS: "Windows_NT", ComSpec: "C:\\Windows\\System32\\cmd.exe" };
+}
+
+function captureStdout(): { readonly stdout: Writable; readonly read: () => string } {
+	let captured = "";
+	const stdout = new Writable({
+		write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+			captured += chunk instanceof Buffer ? chunk.toString() : String(chunk);
+			callback();
+		},
+	});
+	return { stdout, read: () => captured };
+}
+
+describe("applyGitBashPreToolUseReminder", () => {
+	it("#given first Windows Bash call #when hook runs #then emits non-blocking git_bash guidance", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+
+		// when
+		const output = applyGitBashPreToolUseReminder(preToolPayload("Bash"), {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		const parsed = JSON.parse(output);
+		expect(parsed.hookSpecificOutput).toEqual({
+			hookEventName: "PreToolUse",
+			additionalContext:
+				"On Windows, prefer the OMO git_bash MCP for shell commands before using built-in exec_command. Use exec_command only when git_bash is unavailable or for non-shell operations.",
+		});
+	});
+
+	it("#given second Windows Bash call in same session #when hook runs #then it stays silent", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const payload = preToolPayload("Bash");
+
+		// when
+		const first = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+		const second = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+
+		// then
+		expect(first).toContain("git_bash");
+		expect(second).toBe("");
+	});
+
+	it("#given non-Windows Bash call #when hook runs #then it stays silent", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+
+		// when
+		const output = applyGitBashPreToolUseReminder(preToolPayload("Bash"), {
+			env: {},
+			platform: "darwin",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given non-Bash tool call #when hook runs #then it stays silent", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+
+		// when
+		const output = applyGitBashPreToolUseReminder(preToolPayload("exec_command"), {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+});
+
+describe("applyGitBashPostCompactReset", () => {
+	it("#given reminder already emitted #when PostCompact runs #then next Windows Bash call emits reminder again", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const payload = preToolPayload("Bash");
+		const first = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+		const second = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+
+		// when
+		applyGitBashPostCompactReset(postCompactPayload(), { pluginDataRoot });
+		const afterCompact = applyGitBashPreToolUseReminder(payload, {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(first).toContain("git_bash");
+		expect(second).toBe("");
+		expect(afterCompact).toContain("git_bash");
+	});
+});
+
+describe("runGitBashHookCli", () => {
+	it("#given Codex PreToolUse stdin on Windows #when CLI hook runs #then it writes reminder JSON", async () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const stdin = Readable.from([JSON.stringify(preToolPayload("Bash"))]);
+		const capture = captureStdout();
+
+		// when
+		await runGitBashHookCli(stdin, capture.stdout, "pre-tool-use", {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(capture.read()).toContain("git_bash MCP");
+	});
+
+	it("#given PostCompact stdin #when CLI hook runs #then it resets the one-shot reminder", async () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const payload = preToolPayload("Bash");
+		applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+		const resetStdin = Readable.from([JSON.stringify(postCompactPayload())]);
+		const capture = captureStdout();
+
+		// when
+		await runGitBashHookCli(resetStdin, capture.stdout, "post-compact", { pluginDataRoot });
+		const afterCompact = applyGitBashPreToolUseReminder(payload, {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(capture.read()).toBe("");
+		expect(afterCompact).toContain("git_bash");
+	});
+});

package/packages/omo-codex/plugin/components/git-bash/tsconfig.build.json

@@ -0,0 +1,13 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": false,
+		"declaration": true,
+		"outDir": "dist",
+		"rootDir": "src",
+		"noEmit": false,
+		"types": ["node"]
+	},
+	"include": ["src/**/*"],
+	"exclude": ["test/**/*"]
+}

package/packages/omo-codex/plugin/components/git-bash/tsconfig.json

@@ -0,0 +1,25 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"lib": ["ES2022"],
+		"strict": true,
+		"exactOptionalPropertyTypes": true,
+		"noUncheckedIndexedAccess": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"verbatimModuleSyntax": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"esModuleInterop": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"types": ["node", "bun-types"],
+		"noEmit": true
+	},
+	"include": ["src/**/*", "test/**/*"]
+}

package/packages/omo-codex/plugin/components/lsp/README.md

@@ -118,7 +118,7 @@ printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node dist/cli.j
 ## Local Codex Installation
 
 ```bash
-bunx lazycodex install
+npx lazycodex-ai install
 ```
 
 The installer builds and copies the plugin into `~/.codex/plugins/cache/sisyphuslabs/omo/0.1.0`, registers the `sisyphuslabs` marketplace from the `lazycodex` Git repository, and enables:

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

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { dirname, resolve } from "node:path";
+import { createRequire } from "node:module";
 import { argv, execPath, stderr } from "node:process";
-import { fileURLToPath } from "node:url";
 
-import { runPostToolUseHookCli } from "./codex-hook.js";
+import { runPostToolUseHookCli } from "./codex-hook-cli.js";
 
-const PACKAGE_LSP_MCP_CLI = "../../../../../lsp-tools-mcp/dist/cli.js";
+const require = createRequire(import.meta.url);
+const PACKAGE_LSP_MCP_CLI = "@code-yeongyu/lsp-tools-mcp/dist/cli.js";
 
 async function main(): Promise<void> {
 	const [command = "mcp", subcommand = ""] = argv.slice(2);
@@ -31,7 +31,7 @@ main().catch((error: unknown) => {
 });
 
 async function runPackageLspMcpCli(): Promise<void> {
-	const cliPath = resolve(dirname(fileURLToPath(import.meta.url)), PACKAGE_LSP_MCP_CLI);
+	const cliPath = require.resolve(PACKAGE_LSP_MCP_CLI);
 	const child = spawn(execPath, [cliPath, "mcp"], { stdio: "inherit" });
 	await new Promise<void>((resolve, reject) => {
 		child.once("error", reject);

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

@@ -0,0 +1,33 @@
+import { stdin as processStdin } from "node:process";
+
+import { disposeDefaultLspManager } from "@code-yeongyu/lsp-tools-mcp/dist/lsp/manager.js";
+
+import { isRecord, runLspPostToolUseHook } from "./codex-hook.js";
+
+export async function runPostToolUseHookCli(stdin: NodeJS.ReadStream = processStdin): Promise<void> {
+	try {
+		const raw = await readStdin(stdin);
+		if (!raw.trim()) return;
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(raw);
+		} catch (error) {
+			if (error instanceof SyntaxError) return;
+			throw error;
+		}
+		const input = isRecord(parsed) ? parsed : {};
+		const output = await runLspPostToolUseHook(input);
+		if (output) process.stdout.write(output);
+	} finally {
+		await disposeDefaultLspManager();
+	}
+}
+
+async function readStdin(stdin: NodeJS.ReadStream): Promise<string> {
+	stdin.setEncoding("utf8");
+	let raw = "";
+	for await (const chunk of stdin) {
+		raw += chunk;
+	}
+	return raw;
+}

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

@@ -1,8 +1,6 @@
 import { readFileSync } from "node:fs";
-import { stdin as processStdin } from "node:process";
 
-import { disposeDefaultLspManager } from "../../../../../lsp-tools-mcp/dist/lsp/manager.js";
-import { executeLspDiagnostics } from "../../../../../lsp-tools-mcp/dist/tools.js";
+import { executeLspDiagnostics } from "@code-yeongyu/lsp-tools-mcp/dist/tools.js";
 
 export type DiagnosticsRunner = (filePath: string) => Promise<string>;
 
@@ -91,13 +89,29 @@ async function collectDiagnostics(
 			nextIndex += 1;
 			const filePath = filePaths[index];
 			if (filePath === undefined) return;
-			results[index] = { filePath, diagnostics: (await runDiagnostics(filePath)).trim() };
+			results[index] = { filePath, diagnostics: await collectFileDiagnostics(filePath, runDiagnostics) };
 		}
 	}
 	await Promise.all(Array.from({ length: workerCount }, () => worker()));
 	return results;
 }
 
+async function collectFileDiagnostics(filePath: string, runDiagnostics: DiagnosticsRunner): Promise<string> {
+	try {
+		return (await runDiagnostics(filePath)).trim();
+	} catch (error) {
+		return formatDiagnosticsError(error);
+	}
+}
+
+function formatDiagnosticsError(error: unknown): string {
+	if (error instanceof Error) {
+		const message = error.message.trim();
+		if (message.length > 0) return message;
+	}
+	return String(error).trim();
+}
+
 function formatDiagnosticBlock({ filePath, diagnostics }: DiagnosticBlock): string {
 	return `LSP diagnostics after editing ${filePath}:\n\n${formatDiagnosticsForDisplay(diagnostics)}`;
 }
@@ -191,19 +205,6 @@ export function extractMutatedFilePaths(input: CodexPostToolUseInput): string[]
 	return [...paths];
 }
 
-export async function runPostToolUseHookCli(stdin: NodeJS.ReadStream = processStdin): Promise<void> {
-	try {
-		const raw = await readStdin(stdin);
-		if (!raw.trim()) return;
-		const parsed: unknown = JSON.parse(raw);
-		const input = isRecord(parsed) ? parsed : {};
-		const output = await runLspPostToolUseHook(input);
-		if (output) process.stdout.write(output);
-	} finally {
-		await disposeDefaultLspManager();
-	}
-}
-
 function isMutationTool(value: unknown): boolean {
 	if (typeof value !== "string") return false;
 	return MUTATION_TOOL_NAMES.has(value.toLowerCase());
@@ -271,15 +272,6 @@ function addPatchFiles(paths: Set<string>, value: unknown): void {
 	}
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
+export function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-async function readStdin(stdin: NodeJS.ReadStream): Promise<string> {
-	stdin.setEncoding("utf8");
-	let raw = "";
-	for await (const chunk of stdin) {
-		raw += chunk;
-	}
-	return raw;
-}

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

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+describe("codex PostToolUse hook CLI", () => {
+	it("#given malformed post-tool-use stdin #when hook CLI runs #then it no-ops without stderr", () => {
+		// given
+		const input = "break;\n";
+
+		// when
+		const result = runBuiltHookCli(input);
+
+		// then
+		expect(result.status).toBe(0);
+		expect(result.stderr).toBe("");
+		expect(result.stdout).toBe("");
+	});
+});
+
+function runBuiltHookCli(input: string): ReturnType<typeof spawnSync> {
+	const cliPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../dist/cli.js");
+	return spawnSync(process.execPath, [cliPath, "hook", "post-tool-use"], {
+		input,
+		encoding: "utf8",
+	});
+}