oh-my-opencode 4.18.0 → 4.18.2

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook-cli.js

@@ -1,5 +1,4 @@
 import { stdin as processStdin } from "node:process";
-import { disposeDefaultLspManager } from "@code-yeongyu/lsp-daemon";
 import { isRecord, runLspPostCompactHook, runLspPostToolUseHook } from "./codex-hook.js";
 export async function runPostToolUseHookCli(stdin = processStdin) {
     await runHookCli((input) => runLspPostToolUseHook(input), stdin);
@@ -22,9 +21,6 @@ async function runHookCli(runHook, stdin) {
         // LSP feedback is best-effort: stderr or a non-zero exit here surfaces as harness noise on every edit.
         return;
     }
-    finally {
-        await disposeDefaultLspManager().catch(() => undefined);
-    }
 }
 async function readStdin(stdin) {
     stdin.setEncoding("utf8");

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

@@ -1,5 +1,7 @@
+import { type PostEditDiagnosticsOutcome } from "@oh-my-opencode/lsp-core/post-edit";
+import { type LspRequestContext } from "@oh-my-opencode/lsp-core/request-context";
 export { extractMutatedFilePaths } from "./mutated-file-paths.js";
-export type DiagnosticsRunner = (filePath: string) => Promise<string>;
+export type DiagnosticsRunner = (filePath: string) => Promise<PostEditDiagnosticsOutcome>;
 export interface CodexPostToolUseInput {
     session_id?: unknown;
     tool_name?: unknown;
@@ -10,7 +12,8 @@ export interface CodexPostToolUseInput {
 export interface CodexPostCompactInput {
     session_id?: unknown;
 }
-export declare function runLspDiagnosticsText(filePath: string): Promise<string>;
+export declare function runLspDiagnosticsText(filePath: string): Promise<PostEditDiagnosticsOutcome>;
+export declare function codexLspRequestContext(env?: Record<string, string | undefined>, cwd?: string): LspRequestContext;
 export declare function runLspPostToolUseHook(input: CodexPostToolUseInput, runDiagnostics?: DiagnosticsRunner): Promise<string>;
 export declare function runLspPostCompactHook(input: CodexPostCompactInput): Promise<string>;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook.js

@@ -1,16 +1,17 @@
-import { readFileSync } from "node:fs";
-import { callDiagnosticsViaDaemon, currentRequestContext } from "@code-yeongyu/lsp-daemon";
+import { readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { callDiagnosticsViaDaemon } from "@code-yeongyu/lsp-daemon/client";
+import { collectPostEditDiagnostics } from "@oh-my-opencode/lsp-core/post-edit";
+import { parseLspRequestContext } from "@oh-my-opencode/lsp-core/request-context";
 import { ensureLspDaemonCliEnv } from "./daemon-cli-path.js";
-import { isLspDaemonUnreachableDiagnostics, isUnavailableLspDiagnostics, markLspSessionCompacted, recordLspDiagnosticsObservations, sessionIdFrom, shouldSkipUnavailableLspDiagnostics, } from "./lsp-session-state.js";
+import { isLspDaemonUnreachableDiagnostics, markLspSessionCompacted, readLspPostEditCache, sessionIdFrom, writeLspPostEditCache, } from "./lsp-session-state.js";
 import { extractMutatedFilePaths } from "./mutated-file-paths.js";
 export { extractMutatedFilePaths } from "./mutated-file-paths.js";
-const CLEAN_DIAGNOSTICS_TEXT = "No diagnostics found";
-const UNSUPPORTED_EXTENSION_TEXT = "No LSP server configured for extension:";
 const DIAGNOSTIC_START_PATTERN = /(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/g;
 const DIAGNOSTIC_CHUNK_PATTERN = /^(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/;
 const DEFAULT_MAX_HOOK_FEEDBACK_CHARS = 8000;
 const CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS = 1200;
-const MAX_CONCURRENT_DIAGNOSTICS = 4;
 const CONTEXT_PRESSURE_MARKERS = [
     "context compacted",
     "context_length_exceeded",
@@ -22,30 +23,46 @@ const CONTEXT_PRESSURE_MARKERS = [
 ];
 export async function runLspDiagnosticsText(filePath) {
     ensureLspDaemonCliEnv();
-    const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
+    const result = await callDiagnosticsViaDaemon(filePath, { context: codexLspRequestContext() });
+    return postEditOutcomeFromDaemonResult(result);
+}
+function postEditOutcomeFromDaemonResult(result) {
+    const availability = notConfiguredAvailability(result.details);
+    if (availability !== undefined)
+        return { kind: "not_configured", extension: availability.extension };
     return result.content.map((block) => block.text).join("\n");
 }
+function notConfiguredAvailability(details) {
+    if (!isRecord(details))
+        return undefined;
+    const availability = details["availability"];
+    if (!isRecord(availability))
+        return undefined;
+    if (availability["kind"] !== "not_configured")
+        return undefined;
+    const extension = availability["extension"];
+    return typeof extension === "string" && extension.length > 0 ? { extension } : undefined;
+}
+export function codexLspRequestContext(env = process.env, cwd = process.cwd()) {
+    const canonicalCwd = realpathSync(resolve(cwd));
+    const codexHome = resolve(env["CODEX_HOME"]?.trim() || join(homedir(), ".codex"));
+    return parseLspRequestContext({
+        cwd: canonicalCwd,
+        projectConfigPaths: [join(canonicalCwd, ".codex", "lsp-client.json")],
+        userConfigPath: join(codexHome, "lsp-client.json"),
+        installDecisionsPath: join(codexHome, "lsp-install-decisions.json"),
+        capabilities: { installDecisionTool: true },
+    });
+}
 export async function runLspPostToolUseHook(input, runDiagnostics = runLspDiagnosticsText) {
     const sessionId = sessionIdFrom(input);
-    const filePaths = extractMutatedFilePaths(input).filter((filePath) => !shouldSkipUnavailableLspDiagnostics(filePath, sessionId));
+    const filePaths = extractMutatedFilePaths(input);
     if (filePaths.length === 0)
         return "";
-    const blocks = [];
-    const observations = [];
-    for (const { filePath, diagnostics } of await collectDiagnostics(filePaths, runDiagnostics)) {
-        // A daemon outage is transient (connect-or-spawn retries on the next request);
-        // recording it would silence this extension for the rest of the session.
-        if (isLspDaemonUnreachableDiagnostics(diagnostics))
-            continue;
-        const unavailable = isUnavailableLspDiagnostics(diagnostics);
-        observations.push({ filePath, unavailable });
-        if (isCleanDiagnostics(diagnostics))
-            continue;
-        if (unavailable)
-            continue;
-        blocks.push({ filePath, diagnostics });
-    }
-    recordLspDiagnosticsObservations(sessionId, observations);
+    const cache = readLspPostEditCache(sessionId);
+    const result = await collectPostEditDiagnostics({ filePaths, runDiagnostics, cache });
+    writeLspPostEditCache(sessionId, cache);
+    const blocks = result.blocks.filter(({ diagnostics }) => !isLspDaemonUnreachableDiagnostics(diagnostics));
     if (blocks.length === 0)
         return "";
     const rawReason = blocks.map(formatDiagnosticBlock).join("\n\n");
@@ -64,39 +81,6 @@ export async function runLspPostCompactHook(input) {
     markLspSessionCompacted(sessionIdFrom(input));
     return "";
 }
-async function collectDiagnostics(filePaths, runDiagnostics) {
-    const results = [];
-    let nextIndex = 0;
-    const workerCount = Math.min(MAX_CONCURRENT_DIAGNOSTICS, filePaths.length);
-    async function worker() {
-        for (;;) {
-            const index = nextIndex;
-            nextIndex += 1;
-            const filePath = filePaths[index];
-            if (filePath === undefined)
-                return;
-            results[index] = { filePath, diagnostics: await collectFileDiagnostics(filePath, runDiagnostics) };
-        }
-    }
-    await Promise.all(Array.from({ length: workerCount }, () => worker()));
-    return results;
-}
-async function collectFileDiagnostics(filePath, runDiagnostics) {
-    try {
-        return (await runDiagnostics(filePath)).trim();
-    }
-    catch (error) {
-        return formatDiagnosticsError(error);
-    }
-}
-function formatDiagnosticsError(error) {
-    if (error instanceof Error) {
-        const message = error.message.trim();
-        if (message.length > 0)
-            return message;
-    }
-    return String(error).trim();
-}
 function formatDiagnosticBlock({ filePath, diagnostics }) {
     return `LSP diagnostics after editing ${filePath}:\n\n${formatDiagnosticsForDisplay(diagnostics)}`;
 }
@@ -172,11 +156,6 @@ function limitHookText(text, maxChars) {
     const head = text.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
     return `${head}${marker}`;
 }
-function isCleanDiagnostics(diagnostics) {
-    return (diagnostics.length === 0 ||
-        diagnostics === CLEAN_DIAGNOSTICS_TEXT ||
-        diagnostics.startsWith(UNSUPPORTED_EXTENSION_TEXT));
-}
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/packages/omo-codex/plugin/components/lsp/dist/daemon-cli-path.d.ts

@@ -1,2 +1,2 @@
 export declare function ensureLspDaemonCliEnv(env?: NodeJS.ProcessEnv): void;
-export declare function resolveLspDaemonCliPath(): string;
+export declare function resolveLspDaemonCliPath(env?: NodeJS.ProcessEnv): string;

package/packages/omo-codex/plugin/components/lsp/dist/daemon-cli-path.js

@@ -2,21 +2,21 @@ import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { OMO_LSP_DAEMON_CLI, OMO_LSP_DAEMON_VERSION, resolveDaemonRuntime, } from "@code-yeongyu/lsp-daemon/client";
 const requireFromHere = createRequire(import.meta.url);
-const PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
-const CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
-const CODEX_LSP_DAEMON_VERSION_ENV = "CODEX_LSP_DAEMON_VERSION";
+const PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/cli";
 export function ensureLspDaemonCliEnv(env = process.env) {
-    const configuredCli = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
-    const resolution = configuredCli ? resolveConfiguredLspDaemonCli(configuredCli) : resolveLspDaemonCli();
-    if (!configuredCli)
-        env[CODEX_LSP_DAEMON_CLI_ENV] = resolution.cliPath;
-    if (!env[CODEX_LSP_DAEMON_VERSION_ENV]?.trim() && resolution.version !== null) {
-        env[CODEX_LSP_DAEMON_VERSION_ENV] = resolution.version;
-    }
+    const runtime = resolveDaemonRuntime(env, resolveLspDaemonCli());
+    env[OMO_LSP_DAEMON_CLI] = runtime.cliPath;
+    env[OMO_LSP_DAEMON_VERSION] = runtime.version;
 }
-export function resolveLspDaemonCliPath() {
-    return resolveLspDaemonCli().cliPath;
+export function resolveLspDaemonCliPath(env = process.env) {
+    const runtime = resolveDaemonRuntime(env, resolveLspDaemonCli());
+    if (env[OMO_LSP_DAEMON_CLI] === undefined)
+        env[OMO_LSP_DAEMON_CLI] = runtime.cliPath;
+    if (env[OMO_LSP_DAEMON_VERSION] === undefined)
+        env[OMO_LSP_DAEMON_VERSION] = runtime.version;
+    return runtime.cliPath;
 }
 function resolveLspDaemonCli() {
     const packageCli = resolvePackageLspDaemonCliPath();
@@ -31,14 +31,20 @@ function resolvePackageLspDaemonCliPath() {
     try {
         return requireFromHere.resolve(PACKAGE_LSP_DAEMON_CLI);
     }
-    catch {
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
         return null;
     }
 }
 function resolveConfiguredLspDaemonCli(cliPath) {
+    const version = readDaemonPackageVersion(cliPath);
+    if (version === null) {
+        throw new Error(`Unable to determine packaged LSP daemon version beside ${cliPath}`);
+    }
     return {
         cliPath,
-        version: readDaemonPackageVersion(cliPath),
+        version,
     };
 }
 function readDaemonPackageVersion(cliPath) {
@@ -48,7 +54,10 @@ function readDaemonPackageVersion(cliPath) {
             return parsed["version"];
         }
     }
-    catch { }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+    }
     return null;
 }
 function isRecord(value) {

package/packages/omo-codex/plugin/components/lsp/dist/lsp-session-state.d.ts

@@ -1,12 +1,8 @@
-export interface DiagnosticsObservation {
-    readonly filePath: string;
-    readonly unavailable: boolean;
-}
+import type { PostEditNotConfiguredCache } from "@oh-my-opencode/lsp-core/post-edit";
 export declare function sessionIdFrom(input: {
     readonly session_id?: unknown;
 }): string | undefined;
-export declare function shouldSkipUnavailableLspDiagnostics(filePath: string, sessionId: string | undefined): boolean;
-export declare function recordLspDiagnosticsObservations(sessionId: string | undefined, observations: readonly DiagnosticsObservation[]): void;
+export declare function readLspPostEditCache(sessionId: string | undefined): PostEditNotConfiguredCache;
+export declare function writeLspPostEditCache(sessionId: string | undefined, cache: PostEditNotConfiguredCache): void;
 export declare function markLspSessionCompacted(sessionId: string | undefined): void;
-export declare function isUnavailableLspDiagnostics(diagnostics: string): boolean;
 export declare function isLspDaemonUnreachableDiagnostics(diagnostics: string): boolean;

package/packages/omo-codex/plugin/components/lsp/dist/lsp-session-state.js

@@ -1,53 +1,26 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, extname, join } from "node:path";
+import { dirname, join } from "node:path";
 export function sessionIdFrom(input) {
     return typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : undefined;
 }
-export function shouldSkipUnavailableLspDiagnostics(filePath, sessionId) {
+export function readLspPostEditCache(sessionId) {
     if (sessionId === undefined)
-        return false;
+        return { notConfiguredExtensions: new Set() };
     const state = readSessionState(sessionStatePath(sessionId));
-    const extension = extensionKey(filePath);
-    return (extension !== undefined &&
-        state.postCompactProbePending !== true &&
-        state.unavailableExtensions.includes(extension));
+    return { notConfiguredExtensions: new Set(state.notConfiguredExtensions) };
 }
-export function recordLspDiagnosticsObservations(sessionId, observations) {
-    if (sessionId === undefined || observations.length === 0)
-        return;
-    const state = readSessionState(sessionStatePath(sessionId));
-    const unavailableExtensions = new Set(state.unavailableExtensions);
-    for (const observation of observations) {
-        const extension = extensionKey(observation.filePath);
-        if (extension === undefined)
-            continue;
-        if (observation.unavailable) {
-            unavailableExtensions.add(extension);
-        }
-        else {
-            unavailableExtensions.delete(extension);
-        }
-    }
-    writeSessionState(sessionStatePath(sessionId), { unavailableExtensions: [...unavailableExtensions].sort() });
-}
-export function markLspSessionCompacted(sessionId) {
+export function writeLspPostEditCache(sessionId, cache) {
     if (sessionId === undefined)
         return;
-    const state = readSessionState(sessionStatePath(sessionId));
-    if (state.unavailableExtensions.length === 0)
-        return;
     writeSessionState(sessionStatePath(sessionId), {
-        unavailableExtensions: state.unavailableExtensions,
-        postCompactProbePending: true,
+        notConfiguredExtensions: [...cache.notConfiguredExtensions].sort(),
     });
 }
-export function isUnavailableLspDiagnostics(diagnostics) {
-    const normalized = diagnostics.trim();
-    return (normalized.includes("LSP request timeout (method: initialize)") ||
-        normalized.includes("LSP server is still initializing") ||
-        normalized.includes("NOT INSTALLED") ||
-        normalized.includes("Command not found:"));
+export function markLspSessionCompacted(sessionId) {
+    if (sessionId === undefined)
+        return;
+    writeSessionState(sessionStatePath(sessionId), emptyState());
 }
 export function isLspDaemonUnreachableDiagnostics(diagnostics) {
     return diagnostics.includes("LSP daemon unreachable");
@@ -59,8 +32,8 @@ function sessionStatePath(sessionId) {
 function readSessionState(path) {
     try {
         const parsed = JSON.parse(readFileSync(path, "utf8"));
-        if (isLspSessionState(parsed))
-            return parsed;
+        if (isRecord(parsed) && isLspSessionState(parsed))
+            return normalizeSessionState(parsed);
         return emptyState();
     }
     catch (error) {
@@ -74,21 +47,22 @@ function writeSessionState(path, state) {
     writeFileSync(path, `${JSON.stringify(state)}\n`);
 }
 function emptyState() {
-    return { unavailableExtensions: [] };
-}
-function extensionKey(filePath) {
-    const extension = extname(filePath).toLowerCase();
-    return extension.length === 0 ? undefined : extension;
+    return { notConfiguredExtensions: [] };
 }
 function safePathSegment(value) {
     return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
 }
 function isLspSessionState(value) {
-    if (!isRecord(value) || !Array.isArray(value["unavailableExtensions"]))
-        return false;
-    const postCompactProbePending = value["postCompactProbePending"];
-    return (value["unavailableExtensions"].every((item) => typeof item === "string") &&
-        (postCompactProbePending === undefined || typeof postCompactProbePending === "boolean"));
+    const notConfiguredExtensions = value["notConfiguredExtensions"] ?? value["unavailableExtensions"];
+    return Array.isArray(notConfiguredExtensions) && notConfiguredExtensions.every((item) => typeof item === "string");
+}
+function normalizeSessionState(value) {
+    const notConfiguredExtensions = value["notConfiguredExtensions"] ?? value["unavailableExtensions"];
+    return {
+        notConfiguredExtensions: Array.isArray(notConfiguredExtensions)
+            ? notConfiguredExtensions.filter((item) => typeof item === "string").sort()
+            : [],
+    };
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

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

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "(OmO 4.18.0) Checking LSP Diagnostics"
+						"statusMessage": "(OmO 4.18.2) Checking LSP Diagnostics"
 					}
 				]
 			}
@@ -21,7 +21,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.0) Resetting LSP Diagnostics Cache"
+						"statusMessage": "(OmO 4.18.2) Resetting LSP Diagnostics Cache"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lsp",
-	"version": "4.18.0",
+	"version": "4.18.2",
 	"description": "Codex plugin that exposes Language Server Protocol tools and post-edit diagnostics.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",
@@ -38,7 +38,7 @@
 	"scripts": {
 		"bootstrap": "node scripts/build-lsp-tools.mjs && node scripts/build-lsp-daemon.mjs",
 		"prebuild": "node scripts/build-lsp-tools.mjs && node scripts/build-lsp-daemon.mjs",
-		"build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
+		"build": "node scripts/build-runtime.mjs",
 		"pretest": "npm run build --silent",
 		"test": "node scripts/test.mjs",
 		"test:watch": "vitest",
@@ -50,6 +50,7 @@
 		"check": "tsc --noEmit && biome check src test && tsc -p tsconfig.build.json"
 	},
 	"dependencies": {
+		"@oh-my-opencode/lsp-core": "file:../../../../lsp-core",
 		"@code-yeongyu/lsp-daemon": "file:../../../../lsp-daemon"
 	},
 	"devDependencies": {

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

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { execSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, realpathSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const here = dirname(fileURLToPath(import.meta.url));
+const componentRoot = join(here, "..");
 const force = process.argv.includes("--force");
 
 // Ordered candidate list:
@@ -18,6 +19,8 @@ const candidates = [
 function requiredOutputs(dir) {
 	return [
 		join(dir, "dist", "cli.js"),
+		join(dir, "dist", "client.js"),
+		join(dir, "dist", "client.d.ts"),
 		join(dir, "dist", "index.js"),
 		join(dir, "dist", "index.d.ts"),
 	];
@@ -30,12 +33,14 @@ for (const dir of candidates) {
 	if (existsSync(packageJson)) {
 		const outputs = requiredOutputs(dir);
 		if (!force && isBuildFresh(packageJson, outputs)) {
+			ensureComponentPackageLink(dir);
 			process.exit(0);
 		}
 		console.log("Installing repository lsp-daemon dependencies...");
 		execSync("npm ci", { cwd: dir, stdio: "inherit" });
 		console.log("Building repository lsp-daemon...");
 		execSync("npm run build", { cwd: dir, stdio: "inherit" });
+		ensureComponentPackageLink(dir);
 		console.log("Done.");
 		process.exit(0);
 	}
@@ -46,6 +51,7 @@ for (const dir of candidates) {
 for (const dir of candidates) {
 	const outputs = requiredOutputs(dir);
 	if (outputs.every((p) => existsSync(p))) {
+		ensureComponentPackageLink(dir);
 		console.log(`Using bundled lsp-daemon dist at ${dir}.`);
 		process.exit(0);
 	}
@@ -66,3 +72,27 @@ function isBuildFresh(inputPath, outputPaths) {
 	const inputMtime = statSync(inputPath).mtimeMs;
 	return outputPaths.every((path) => statSync(path).mtimeMs >= inputMtime);
 }
+
+function ensureComponentPackageLink(packageDir) {
+	const scopeDir = join(componentRoot, "node_modules", "@code-yeongyu");
+	const linkPath = join(scopeDir, "lsp-daemon");
+	mkdirSync(scopeDir, { recursive: true });
+	if (isSymlinkToUsablePackage(linkPath, packageDir)) return;
+	rmSync(linkPath, { recursive: true, force: true });
+	symlinkSync(packageDir, linkPath, "junction");
+}
+
+function isSymlinkToUsablePackage(linkPath, packageDir) {
+	try {
+		const stat = lstatSync(linkPath);
+		return (
+			stat.isSymbolicLink() &&
+			existsSync(packageDir) &&
+			realpathSync(linkPath) === realpathSync(packageDir) &&
+			requiredOutputs(linkPath).every((path) => existsSync(path))
+		);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}

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

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { chmod, copyFile, lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { delimiter, 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-daemon-build-"));
+	const componentRoot = join(root, "packages", "omo-codex", "plugin", "components", "lsp");
+	const packageDir = join(root, "packages", "lsp-daemon");
+	const script = join(componentRoot, "scripts", "build-lsp-daemon.mjs");
+	await mkdir(join(componentRoot, "scripts"), { recursive: true });
+	await mkdir(join(packageDir, "dist"), { recursive: true });
+	await copyFile(new URL("./build-lsp-daemon.mjs", import.meta.url), script);
+	await writeFile(join(packageDir, "package.json"), "{}\n");
+	await writeDaemonOutputs(packageDir);
+	return { root, componentRoot, packageDir, script };
+}
+
+async function writeDaemonOutputs(packageDir) {
+	for (const output of ["cli.js", "client.js", "client.d.ts", "index.js", "index.d.ts"]) {
+		await writeFile(join(packageDir, "dist", output), `${output}\n`);
+	}
+}
+
+function runScript(script, fakeBin, args = []) {
+	return spawnSync(process.execPath, [script, ...args], {
+		encoding: "utf8",
+		env: { ...process.env, PATH: fakeBin ? `${fakeBin}${delimiter}${process.env.PATH ?? ""}` : process.env.PATH },
+	});
+}
+
+test("#given fresh daemon dist #when bootstrapping component #then local package link is created", async () => {
+	// given
+	const fixture = await makeFixture();
+	const link = join(fixture.componentRoot, "node_modules", "@code-yeongyu", "lsp-daemon");
+
+	// when
+	const result = runScript(fixture.script);
+
+	// then
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal((await lstat(link)).isSymbolicLink(), true);
+	assert.equal(await realpath(link), await realpath(fixture.packageDir));
+});
+
+test("#given client outputs are missing #when bootstrapping component #then daemon rebuild runs before linking", async () => {
+	// given
+	const fixture = await makeFixture();
+	await rm(join(fixture.packageDir, "dist", "client.d.ts"));
+	const fakeBin = join(fixture.root, "bin");
+	const npmLog = join(fixture.root, "npm.log");
+	await mkdir(fakeBin, { recursive: true });
+	await writeFile(
+		join(fakeBin, "npm.js"),
+		`const { appendFileSync, mkdirSync, writeFileSync } = require("node:fs");\n` +
+			`const { join } = require("node:path");\n` +
+			`appendFileSync(${JSON.stringify(npmLog)}, process.argv.slice(2).join(" ") + "\\n");\n` +
+			`if (process.argv.slice(2).join(" ") === "run build") {\n` +
+			`  const dist = join(process.cwd(), "dist");\n` +
+			`  mkdirSync(dist, { recursive: true });\n` +
+			`  for (const name of ["cli.js", "client.js", "client.d.ts", "index.js", "index.d.ts"]) writeFileSync(join(dist, name), name + "\\n");\n` +
+			`}\n`,
+	);
+	await writeFile(join(fakeBin, "npm"), "#!/usr/bin/env node\nrequire('./npm.js');\n");
+	await chmod(join(fakeBin, "npm"), 0o755);
+
+	// when
+	const result = runScript(fixture.script, fakeBin);
+
+	// then
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(await readFile(npmLog, "utf8"), /ci\nrun build\n/u);
+	assert.equal(await realpath(join(fixture.componentRoot, "node_modules", "@code-yeongyu", "lsp-daemon")), await realpath(fixture.packageDir));
+});