oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,25 @@
+# Repository Conventions
+
+Conventions for humans and agents working on this repository.
+
+## Style
+
+- TypeScript strict mode. No `any`, `@ts-ignore`, `@ts-expect-error`, or enums.
+- ESM modules with `.js` suffix in import paths.
+- Tabs for indentation. Double quotes for strings.
+- Runtime is Node only.
+- Tests use vitest and should exercise Codex hook/MCP behavior before implementation changes.
+
+## Commands
+
+- `npm install` installs dependencies.
+- `npm test` runs the test suite once.
+- `npm run typecheck` runs strict TypeScript checking.
+- `npm run check` runs typecheck, Biome, and build.
+
+## LSP Constraints
+
+- LSP server processes are owned by `LspManager`.
+- Tool execution acquires clients through `withLspClient(...)` unless it only reports static status.
+- `lsp.rename` mutates files by applying workspace edits; keep it sequential at the MCP caller level.
+- Do not add pi-coding-agent or omo source dependencies. This package is standalone.

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

@@ -0,0 +1,25 @@
+# Changelog
+
+## Unreleased
+
+- Reuse the repository-level `packages/lsp-tools-mcp` package instead of carrying a second copy under `components/lsp/packages`.
+
+## 0.2.0
+
+- Extracted the LSP runtime and MCP server into [`@code-yeongyu/lsp-tools-mcp`](https://github.com/code-yeongyu/lsp-tools-mcp).
+- codex-lsp now consumes that runtime as a git submodule at `packages/lsp-tools-mcp`.
+- Kept the Codex-specific PostToolUse hook in this package and routed MCP serving through the upstream CLI.
+
+- Extract LSP runtime to `lsp-tools-mcp` upstream and consume it via git submodule at `packages/lsp-tools-mcp`.
+- Renamed the MCP server namespace to `lsp` and exposed shorter tool names such as `lsp.diagnostics`.
+- Use portable Codex hook interpolation and add package smoke coverage for hook/MCP entrypoints.
+- Spawn language servers without shell mode; Windows `.cmd` and `.bat` shims are routed through `cmd.exe` with explicit arguments.
+- Cap directory diagnostics file traversal and run CI on Windows in addition to Ubuntu and macOS.
+- Replace the external JSON-RPC runtime dependency with an internal LSP framing layer so clean Codex plugin installs run without `node_modules`.
+
+## 0.1.0
+
+- Ported the standalone LSP client, server resolution, diagnostics aggregation, and workspace edit runtime from `pi-lsp-client`.
+- Added Codex `PostToolUse` diagnostics for edit-style tools.
+- Added MCP tools for status, diagnostics, definitions, references, symbols, prepare rename, and rename.
+- Added Codex plugin metadata, skill docs, CI, and release automation.

package/packages/omo-codex/plugin/components/lsp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yeongyu Kim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/omo-codex/plugin/components/lsp/NOTICE

@@ -0,0 +1,3 @@
+codex-lsp ports the standalone LSP runtime from pi-lsp-client into a Codex plugin.
+
+The package includes adapted code originally developed for pi-lsp-client.

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

@@ -0,0 +1,148 @@
+# codex-lsp
+
+[![ci](https://github.com/code-yeongyu/codex-lsp/actions/workflows/ci.yml/badge.svg)](https://github.com/code-yeongyu/codex-lsp/actions/workflows/ci.yml) [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Codex plugin that ports the standalone LSP runtime from [`pi-lsp-client`](https://github.com/code-yeongyu/pi-lsp-client). It gives Codex post-edit diagnostics plus explicit MCP tools for language-aware code work.
+
+## Architecture
+
+The LSP runtime moved to [`lsp-tools-mcp`](https://github.com/code-yeongyu/lsp-tools-mcp) and is consumed from this repository's root `packages/lsp-tools-mcp/` package.
+
+- `codex-lsp` keeps Codex-specific integration (`hook post-tool-use`, plugin metadata, package wiring).
+- `lsp-tools-mcp` owns MCP runtime, LSP manager, and tool implementations.
+- `src/cli.ts` routes `mcp` to upstream runtime and keeps `hook post-tool-use` local.
+
+## Behavior
+
+| Case | Result |
+|------|--------|
+| `apply_patch` succeeds | parses `tool_input.command`, extracts added/updated/moved files, and checks each with LSP error diagnostics |
+| `write` / `edit` / `multiedit` succeeds | checks `path`, `filePath`, or `file_path` aliases |
+| diagnostics contain errors | returns Codex `PostToolUse` blocking feedback and injects the same diagnostics as additional context so Codex fixes the file |
+| no diagnostics | emits no hook output |
+| unsupported extension | emits no hook output |
+| missing configured language server | surfaces the install/config message through hook or MCP output |
+
+Deletes are ignored because they cannot introduce new diagnostics.
+
+## MCP Tools
+
+- `lsp.status`
+- `lsp.diagnostics`
+- `lsp.goto_definition`
+- `lsp.find_references`
+- `lsp.symbols`
+- `lsp.prepare_rename`
+- `lsp.rename`
+
+`lsp.rename` applies the returned workspace edit to files. Use `lsp.prepare_rename` first when possible.
+
+## Configuration
+
+Project config:
+
+```text
+.codex/lsp-client.json
+```
+
+User config:
+
+```text
+~/.codex/lsp-client.json
+```
+
+Example:
+
+```json
+{
+	"lsp": {
+		"typescript": {
+			"command": ["typescript-language-server", "--stdio"],
+			"extensions": [".ts", ".tsx", ".js", ".jsx"]
+		}
+	}
+}
+```
+
+Built-in server definitions are used when no custom config overrides them. `lsp.status` shows which configured servers are installed or missing.
+
+## Codex Plugin
+
+The plugin ships:
+
+- `.codex-plugin/plugin.json` for Codex plugin discovery.
+- `.mcp.json` for the `lsp` MCP server.
+- `hooks/hooks.json` for the `PostToolUse` diagnostics hook.
+- `skills/lsp/SKILL.md` with MCP usage guidance.
+
+The runtime depends on `@code-yeongyu/lsp-tools-mcp` via `file:../../../../lsp-tools-mcp`, so marketplace builds reuse the root package instead of carrying a second copy under this component.
+
+The hook command is:
+
+```bash
+node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use
+```
+
+The MCP command is:
+
+```bash
+node ../../../../lsp-tools-mcp/dist/cli.js mcp
+```
+
+## Local Development
+
+```bash
+npm run bootstrap     # installs + builds the root packages/lsp-tools-mcp package
+npm install
+npm test
+npm run typecheck
+npm run check
+npm pack --dry-run
+```
+
+The `bootstrap` script installs and builds the root `lsp-tools-mcp` package so
+`@code-yeongyu/lsp-tools-mcp/dist/*.js` is available for the codex-lsp build.
+
+Smoke-test the hook:
+
+```bash
+node dist/cli.js hook post-tool-use < test/fixtures/post-tool-use.json
+```
+
+Smoke-test the MCP server:
+
+```bash
+printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node dist/cli.js mcp
+```
+
+## Local Codex Installation
+
+```bash
+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:
+
+```toml
+[plugins."omo@sisyphuslabs"]
+enabled = true
+```
+
+## Branch Rules and Releases
+
+- `main` is protected by `.github/branch-ruleset.json`.
+- CI runs Node 20 and 22 on Ubuntu, macOS, and Windows.
+- Releases are GitHub Releases tagged as `v<semver>`.
+- Publishing runs from the `publish` workflow after a GitHub Release is published.
+
+## Privacy
+
+This plugin runs locally. It starts configured language-server commands on your machine and does not call a network service by itself.
+
+## License
+
+[MIT](LICENSE).
+
+## Related
+
+- [pi-lsp-client](https://github.com/code-yeongyu/pi-lsp-client) - source extension this Codex plugin ports.

package/packages/omo-codex/plugin/components/lsp/biome.json

@@ -0,0 +1,48 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.15/schema.json",
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"style": {
+				"noDefaultExport": "error",
+				"noEnum": "error",
+				"noNonNullAssertion": "error",
+				"useImportType": "error",
+				"useConst": "error",
+				"useNodejsImportProtocol": "off"
+			},
+			"complexity": {
+				"useLiteralKeys": "off"
+			},
+			"suspicious": {
+				"noExplicitAny": "error",
+				"noTsIgnore": "error",
+				"noControlCharactersInRegex": "off",
+				"noEmptyInterface": "off"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"formatWithErrors": false,
+		"indentStyle": "tab",
+		"indentWidth": 3,
+		"lineWidth": 120
+	},
+	"files": {
+		"includes": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts", "!**/node_modules/**/*", "!**/dist/**/*"]
+	},
+	"overrides": [
+		{
+			"includes": ["vitest.config.ts"],
+			"linter": {
+				"rules": {
+					"style": {
+						"noDefaultExport": "off"
+					}
+				}
+			}
+		}
+	]
+}

package/packages/omo-codex/plugin/components/lsp/hooks/hooks.json

@@ -0,0 +1,17 @@
+{
+	"hooks": {
+		"PostToolUse": [
+			{
+				"matcher": "^(apply_patch|Write|Edit|MultiEdit|multi_edit|write|edit|multiedit)$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
+						"timeout": 60,
+						"statusMessage": "LazyCodex(0.2.0): Checking LSP Diagnostics"
+					}
+				]
+			}
+		]
+	}
+}

package/packages/omo-codex/plugin/components/lsp/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@code-yeongyu/codex-lsp",
+	"version": "0.2.0",
+	"description": "Codex plugin that exposes Language Server Protocol tools and post-edit diagnostics.",
+	"type": "module",
+	"packageManager": "npm@11.12.1",
+	"license": "MIT",
+	"homepage": "https://github.com/code-yeongyu/codex-lsp",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/code-yeongyu/codex-lsp.git"
+	},
+	"bugs": {
+		"url": "https://github.com/code-yeongyu/codex-lsp/issues"
+	},
+	"keywords": [
+		"codex",
+		"codex-plugin",
+		"lsp",
+		"language-server-protocol",
+		"mcp",
+		"diagnostics"
+	],
+	"bin": {
+		"omo-lsp": "./dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"hooks",
+		"skills",
+		".codex-plugin",
+		".mcp.json",
+		"LICENSE",
+		"NOTICE",
+		"README.md",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"bootstrap": "node scripts/build-lsp-tools.mjs",
+		"prebuild": "node scripts/build-lsp-tools.mjs",
+		"build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
+		"pretest": "node scripts/build-lsp-tools.mjs",
+		"test": "node scripts/test.mjs",
+		"test:watch": "vitest",
+		"pretypecheck": "node scripts/build-lsp-tools.mjs",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check src test",
+		"lint:fix": "biome check --write src test",
+		"precheck": "node scripts/build-lsp-tools.mjs",
+		"check": "tsc --noEmit && biome check src test && tsc -p tsconfig.build.json"
+	},
+	"dependencies": {
+		"@code-yeongyu/lsp-tools-mcp": "file:../../../../lsp-tools-mcp"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.15",
+		"@types/node": "^25.7.0",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.5"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/packages/omo-codex/plugin/components/lsp/scripts/build-lsp-tools.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Build the repository-level lsp-tools-mcp package used by codex-lsp.
+import { execSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const lspToolsDir = join(__dirname, "..", "..", "..", "..", "..", "lsp-tools-mcp");
+const packageJson = join(lspToolsDir, "package.json");
+const requiredOutputs = [
+	join(lspToolsDir, "dist", "cli.js"),
+	join(lspToolsDir, "dist", "tools.js"),
+	join(lspToolsDir, "dist", "lsp", "manager.js"),
+];
+const force = process.argv.includes("--force");
+
+if (!force && isBuildFresh(packageJson, requiredOutputs)) {
+	process.exit(0);
+}
+
+if (!existsSync(packageJson)) {
+	if (!force && requiredOutputs.every((path) => existsSync(path))) {
+		console.log("Using bundled lsp-tools-mcp dist.");
+		process.exit(0);
+	}
+	console.error(
+		`lsp-tools-mcp package metadata is missing at ${packageJson}; build packages/lsp-tools-mcp before codex-lsp`,
+	);
+	process.exit(1);
+}
+
+console.log("Installing repository lsp-tools-mcp dependencies...");
+execSync("npm ci", { cwd: lspToolsDir, stdio: "inherit" });
+
+console.log("Building repository lsp-tools-mcp...");
+execSync("npm run build", { cwd: lspToolsDir, stdio: "inherit" });
+
+console.log("Done.");
+
+function isBuildFresh(inputPath, outputPaths) {
+	if (!existsSync(inputPath)) return false;
+	if (outputPaths.some((path) => !existsSync(path))) return false;
+	const inputMtime = statSync(inputPath).mtimeMs;
+	return outputPaths.every((path) => statSync(path).mtimeMs >= inputMtime);
+}

package/packages/omo-codex/plugin/components/lsp/scripts/build-lsp-tools.test.mjs

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { chmod, copyFile, mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+async function makeFixture() {
+	const root = await mkdtemp(join(tmpdir(), "codex-lsp-build-"));
+	await mkdir(join(root, "packages", "omo-codex", "plugin", "components", "lsp", "scripts"), { recursive: true });
+	await mkdir(join(root, "packages", "lsp-tools-mcp", "dist"), { recursive: true });
+	await copyFile(
+		new URL("./build-lsp-tools.mjs", import.meta.url),
+		join(root, "packages", "omo-codex", "plugin", "components", "lsp", "scripts", "build-lsp-tools.mjs"),
+	);
+	await writeFile(join(root, "packages", "lsp-tools-mcp", "package.json"), "{}\n");
+	await writeFile(join(root, "packages", "lsp-tools-mcp", "dist", "cli.js"), "cli\n");
+	const fakeBin = join(root, "bin");
+	await mkdir(fakeBin, { recursive: true });
+	const npmLog = join(root, "npm.log");
+	await writeFile(
+		join(fakeBin, "npm"),
+		`#!/usr/bin/env node\nconst { appendFileSync } = require("node:fs");\nappendFileSync(${JSON.stringify(npmLog)}, process.argv.slice(2).join(" ") + "\\n");\n`,
+	);
+	await chmod(join(fakeBin, "npm"), 0o755);
+	return { root, npmLog, script: join(root, "packages", "omo-codex", "plugin", "components", "lsp", "scripts", "build-lsp-tools.mjs"), fakeBin };
+}
+
+function runScript(script, fakeBin, args = []) {
+	return spawnSync(process.execPath, [script, ...args], {
+		encoding: "utf8",
+		env: { ...process.env, PATH: `${fakeBin}:${process.env.PATH ?? ""}` },
+	});
+}
+
+test("#given dist cli exists but required hook outputs are missing #when bootstrapping #then it rebuilds", async () => {
+	// given
+	const fixture = await makeFixture();
+
+	// when
+	const result = runScript(fixture.script, fixture.fakeBin);
+
+	// then
+	assert.equal(result.status, 0);
+	assert.match(await readFile(fixture.npmLog, "utf8"), /ci\nrun build\n/u);
+});
+
+test("#given package metadata is newer than required outputs #when bootstrapping #then it rebuilds", async () => {
+	// given
+	const fixture = await makeFixture();
+	await mkdir(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp"), { recursive: true });
+	await writeFile(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp", "manager.js"), "manager\n");
+	await writeFile(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "tools.js"), "tools\n");
+	const older = new Date("2026-01-01T00:00:00.000Z");
+	const newer = new Date("2026-01-02T00:00:00.000Z");
+	for (const path of [
+		join(fixture.root, "packages", "lsp-tools-mcp", "dist", "cli.js"),
+		join(fixture.root, "packages", "lsp-tools-mcp", "dist", "tools.js"),
+		join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp", "manager.js"),
+	]) {
+		await utimes(path, older, older);
+	}
+	await utimes(join(fixture.root, "packages", "lsp-tools-mcp", "package.json"), newer, newer);
+
+	// when
+	const result = runScript(fixture.script, fixture.fakeBin);
+
+	// then
+	assert.equal(result.status, 0);
+	assert.match(await readFile(fixture.npmLog, "utf8"), /ci\nrun build\n/u);
+});
+
+test("#given force flag #when bootstrapping #then it rebuilds even when dist exists", async () => {
+	// given
+	const fixture = await makeFixture();
+	await mkdir(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp"), { recursive: true });
+	await writeFile(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp", "manager.js"), "manager\n");
+	await writeFile(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "tools.js"), "tools\n");
+
+	// when
+	const result = runScript(fixture.script, fixture.fakeBin, ["--force"]);
+
+	// then
+	assert.equal(result.status, 0);
+	assert.match(await readFile(fixture.npmLog, "utf8"), /ci\nrun build\n/u);
+});
+
+test("#given packaged dist without package metadata #when bootstrapping #then it uses bundled runtime", async () => {
+	// given
+	const fixture = await makeFixture();
+	await mkdir(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp"), { recursive: true });
+	await writeFile(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "lsp", "manager.js"), "manager\n");
+	await writeFile(join(fixture.root, "packages", "lsp-tools-mcp", "dist", "tools.js"), "tools\n");
+	await writeFile(fixture.npmLog, "");
+	await rm(join(fixture.root, "packages", "lsp-tools-mcp", "package.json"));
+
+	// when
+	const result = runScript(fixture.script, fixture.fakeBin);
+
+	// then
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(result.stdout, /Using bundled lsp-tools-mcp dist/);
+	assert.equal(await readFile(fixture.npmLog, "utf8"), "");
+});

package/packages/omo-codex/plugin/components/lsp/scripts/clean-dist.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+await rm(fileURLToPath(new URL("../dist/", import.meta.url)), { recursive: true, force: true });

package/packages/omo-codex/plugin/components/lsp/scripts/test.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+
+const vitest = spawnSync("vitest", ["--run", ...process.argv.slice(2)], { stdio: "inherit" });
+if (vitest.status !== 0) process.exit(vitest.status ?? 1);
+
+const nodeTest = spawnSync(process.execPath, ["--test", "scripts/*.test.mjs"], { stdio: "inherit" });
+process.exit(nodeTest.status ?? 1);

package/packages/omo-codex/plugin/components/lsp/skills/lsp/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: lsp
+description: Use when Codex needs language-server diagnostics, definitions, references, symbols, or rename safety checks in the current workspace.
+---
+
+# Codex LSP
+
+Call `lsp` MCP tools through the tool interface; `lsp.*`/`mcp__lsp__*` are tool-call names, not shell commands.
+
+## Tools
+
+- `lsp.status`: list configured, installed, missing, disabled, and active language servers.
+- `lsp.diagnostics`: check one file or directory for LSP diagnostics. Prefer `severity: "error"` after edits.
+- `lsp.goto_definition`: locate a symbol definition from file, line, and character.
+- `lsp.find_references`: find usages of a symbol across the workspace.
+- `lsp.symbols`: inspect document symbols or search workspace symbols.
+- `lsp.prepare_rename`: check whether a rename is valid at a position.
+- `lsp.rename`: apply a language-server workspace edit for a rename.
+
+## Config
+
+Project config lives at `.codex/lsp-client.json`; user config lives at `~/.codex/lsp-client.json`.
+
+```json
+{
+	"lsp": {
+		"typescript": {
+			"command": ["typescript-language-server", "--stdio"],
+			"extensions": [".ts", ".tsx", ".js", ".jsx"]
+		}
+	}
+}
+```
+
+Use `lsp.status` first when diagnostics report a missing language server.

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { argv, execPath, stderr } from "node:process";
+
+import { runPostToolUseHookCli } from "./codex-hook-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);
+
+	if (command === "hook" && subcommand === "post-tool-use") {
+		await runPostToolUseHookCli();
+		return;
+	}
+
+	if (command === "mcp") {
+		await runPackageLspMcpCli();
+		return;
+	}
+
+	stderr.write("Usage: omo-lsp [mcp | hook post-tool-use]\n");
+	process.exitCode = 2;
+}
+
+main().catch((error: unknown) => {
+	stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+	process.exitCode = 1;
+});
+
+async function runPackageLspMcpCli(): Promise<void> {
+	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);
+		child.once("exit", (code, signal) => {
+			if (code !== null && code !== 0) process.exitCode = code;
+			if (code === null && signal !== null) process.exitCode = 1;
+			resolve();
+		});
+	});
+}

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;
+}