oh-my-opencode 4.19.4 → 5.0.0-beta.10

package/packages/lsp-daemon/dist/client.js

@@ -254,10 +254,10 @@ function errorText(error) {
 
 // src/ensure-daemon.ts
 import { spawn } from "node:child_process";
-import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
 import { Socket } from "node:net";
-import { dirname as dirname3 } from "node:path";
-import { execPath } from "node:process";
+import { dirname as dirname3, isAbsolute as isAbsolute3 } from "node:path";
+import { argv0, execPath } from "node:process";
 
 // src/ipc-protocol.ts
 import { randomBytes, timingSafeEqual } from "node:crypto";
@@ -727,15 +727,29 @@ function spawnDaemonProcess(paths) {
   mkdirSync2(dirname3(paths.log), { recursive: true });
   const logFd = openSync2(paths.log, "a");
   try {
-    const child = spawn(execPath, [paths.cliPath, "daemon"], {
+    const child = spawn(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
       detached: true,
       stdio: ["ignore", logFd, logFd]
     });
+    child.once("spawn", () => closeSync2(logFd));
+    child.once("error", (error) => {
+      writeSync2(logFd, `[lsp-daemon] failed to spawn daemon: ${error.message}
+`);
+      closeSync2(logFd);
+    });
     child.unref();
-  } finally {
+  } catch (error) {
     closeSync2(logFd);
+    throw error;
   }
 }
+function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync2) {
+  if (pathExists(cachedExecPath))
+    return cachedExecPath;
+  if (isAbsolute3(originalArgv0) && pathExists(originalArgv0))
+    return originalArgv0;
+  return "node";
+}
 function defaultEnsureDaemonDeps() {
   return {
     probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
@@ -1127,8 +1141,8 @@ function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync9, statSync as statSync4 } from "node:fs";
-import { dirname as dirname8, join as join4, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
+import { basename as basename3, dirname as dirname8, join as join4, resolve as resolve7 } from "node:path";
 
 // ../lsp-core/src/lsp/effective-extension.ts
 import { basename as basename2, extname } from "node:path";
@@ -1559,7 +1573,7 @@ function toError(error) {
 
 // ../lsp-core/src/lsp/process.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
-import { existsSync as existsSync2, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
 import { delimiter as delimiter2, join as join2 } from "node:path";
 function isMissingProcessError(error) {
   if (!(error instanceof Error) || !("code" in error))
@@ -1573,7 +1587,7 @@ function reportKillError(context, error) {
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync2(cwd)) {
+    if (!existsSync3(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
     const stats = statSync3(cwd);
@@ -1661,7 +1675,7 @@ function resolveWindowsCommand(command, env) {
   for (const baseDirectory of baseDirectories) {
     for (const extension of extensions) {
       const candidate = baseDirectory ? join2(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
-      if (existsSync2(candidate))
+      if (existsSync3(candidate))
         return candidate;
     }
   }
@@ -2060,7 +2074,7 @@ class LspClientConnection extends LspClientTransport {
       initializationOptions: this.server.initialization
     }, { timeoutMs: this.initializeTimeoutMs });
     this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
-    await this.sendNotification("initialized");
+    await this.sendNotification("initialized", {});
     await this.sendNotification("workspace/didChangeConfiguration", {
       settings: { json: { validate: { enable: true } } }
     });
@@ -2530,11 +2544,11 @@ function workspaceApplyEditConcurrentFailureReason(phase) {
 }
 
 // ../lsp-core/src/lsp/workspace-edit-commit.ts
-import { existsSync as existsSync4, lstatSync as lstatSync3, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync5, lstatSync as lstatSync3, renameSync, rmSync, writeFileSync } from "node:fs";
 
 // ../lsp-core/src/lsp/workspace-edit-path.ts
-import { existsSync as existsSync3, lstatSync as lstatSync2, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync4, lstatSync as lstatSync2, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute4, relative as relative3, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 class WorkspaceEditPathError extends Error {
@@ -2549,11 +2563,11 @@ class WorkspaceEditPathError extends Error {
 }
 function isPathInsideWorkspace(filePath, workspaceRoot) {
   const relativePath = relative3(workspaceRoot, filePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute3(relativePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute4(relativePath);
 }
 function canonicalizeMissingPath(filePath) {
   let ancestor = filePath;
-  while (!existsSync3(ancestor)) {
+  while (!existsSync4(ancestor)) {
     const parent = dirname4(ancestor);
     if (parent === ancestor)
       throw new WorkspaceEditPathError(filePath, "no existing ancestor");
@@ -2571,7 +2585,7 @@ function canonicalWorkspaceRoot(workspaceRoot) {
       success: true,
       path: canonical,
       requestedPath: resolve3(workspaceRoot),
-      followedSymbolicLink: existsSync3(resolve3(workspaceRoot)) && lstatSync2(resolve3(workspaceRoot)).isSymbolicLink()
+      followedSymbolicLink: existsSync4(resolve3(workspaceRoot)) && lstatSync2(resolve3(workspaceRoot)).isSymbolicLink()
     };
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -2591,7 +2605,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
     return { success: false, error: `non-file URI ${uri}: ${detail}` };
   }
   try {
-    const canonical = existsSync3(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
+    const canonical = existsSync4(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
     if (!isPathInsideWorkspace(canonical, workspaceRoot)) {
       return { success: false, error: `${requestedPath}: outside workspace ${workspaceRoot}` };
     }
@@ -2599,7 +2613,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
       success: true,
       path: canonical,
       requestedPath,
-      followedSymbolicLink: existsSync3(requestedPath) && lstatSync2(requestedPath).isSymbolicLink()
+      followedSymbolicLink: existsSync4(requestedPath) && lstatSync2(requestedPath).isSymbolicLink()
     };
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -2607,7 +2621,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
   }
 }
 function snapshotPath(path2, includeChildren) {
-  if (!existsSync3(path2))
+  if (!existsSync4(path2))
     return { kind: "missing" };
   const stats = lstatSync2(path2);
   if (stats.isFile())
@@ -2727,7 +2741,7 @@ function commitOperation(context, operation) {
   }
   if (operation.kind === "rename") {
     if (operation.replaceDestination) {
-      const targetKind = existsSync4(operation.newPath) && lstatSync3(operation.newPath).isDirectory() ? "directory" : "file";
+      const targetKind = existsSync5(operation.newPath) && lstatSync3(operation.newPath).isDirectory() ? "directory" : "file";
       io.remove(operation.newPath, targetKind === "directory");
       accumulator.mutations.push({ kind: "delete", path: operation.newPath, targetKind });
       addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.newPath));
@@ -3337,7 +3351,7 @@ function simulateDelete(operation, virtual) {
 }
 
 // ../lsp-core/src/lsp/workspace-edit-snapshot.ts
-import { existsSync as existsSync5, lstatSync as lstatSync4, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync6, lstatSync as lstatSync4, readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname6, resolve as resolve5 } from "node:path";
 class WorkspaceSnapshotBuilder {
   workspaceRoot;
@@ -3375,7 +3389,7 @@ class WorkspaceSnapshotBuilder {
         break;
       candidate = dirname6(candidate);
     }
-    if (!includeChildren || !existsSync5(path2) || !lstatSync4(path2).isDirectory())
+    if (!includeChildren || !existsSync6(path2) || !lstatSync4(path2).isDirectory())
       return;
     for (const child of readdirSync2(path2))
       this.add(resolve5(path2, child), true);
@@ -4144,14 +4158,14 @@ async function disposeDefaultLspManager() {
 }
 
 // ../lsp-core/src/lsp/server-install-state.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 function getInstallDecisionsPath() {
   return lspRequestContext().installDecisionsPath;
 }
 function loadInstallDecisions() {
   const path2 = getInstallDecisionsPath();
-  if (!existsSync6(path2))
+  if (!existsSync7(path2))
     return {};
   try {
     const parsed = JSON.parse(readFileSync4(path2, "utf8"));
@@ -4192,7 +4206,7 @@ function isRecord5(value) {
 }
 
 // ../lsp-core/src/lsp/config-loader.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
 
 // ../lsp-core/src/lsp/server-definitions.ts
 var LSP_INSTALL_HINTS = {
@@ -4349,7 +4363,7 @@ function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
 function loadJsonFile(path2) {
-  if (!existsSync7(path2))
+  if (!existsSync8(path2))
     return null;
   try {
     const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
@@ -4537,7 +4551,7 @@ function getDisabledServerIds() {
 }
 
 // ../lsp-core/src/lsp/server-installation.ts
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { delimiter as delimiter3, join as join3 } from "node:path";
 function isServerInstalled(command, _workingDirectory) {
   if (command.length === 0)
@@ -4546,7 +4560,7 @@ function isServerInstalled(command, _workingDirectory) {
   if (!cmd)
     return false;
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync8(cmd))
+    if (existsSync9(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -4567,7 +4581,7 @@ function isServerInstalled(command, _workingDirectory) {
   const paths = pathEnv.split(delimiter3);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync8(join3(p, cmd + suffix))) {
+      if (existsSync9(join3(p, cmd + suffix))) {
         return true;
       }
     }
@@ -4672,32 +4686,86 @@ function isDirectoryPath(filePath) {
   }
 }
 function findWorkspaceRoot(filePath) {
-  const abs = resolvePathInsideContext(filePath);
+  const cwd = contextCwd();
+  const abs = resolveReadablePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
     dir = dirname8(dir);
   }
-  let prevDir = "";
-  while (dir !== prevDir) {
-    for (const marker of WORKSPACE_MARKERS) {
-      if (existsSync9(join4(dir, marker))) {
-        return dir;
+  const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
+  while (isPathInside(cwd, dir)) {
+    const canonicalDir = existingDirectoryInsideContext(dir, cwd);
+    if (canonicalDir !== undefined) {
+      for (const marker of WORKSPACE_MARKERS) {
+        if (existsSync10(join4(dir, marker))) {
+          return canonicalDir;
+        }
       }
     }
-    prevDir = dir;
+    if (dir === cwd)
+      break;
     dir = dirname8(dir);
   }
-  return dirname8(abs);
+  return fallbackRoot;
 }
-function resolvePathInsideContext(filePath) {
+function resolveReadablePathInsideContext(filePath) {
   const cwd = contextCwd();
   const abs = resolve7(cwd, filePath);
+  if (isPathInside(cwd, abs))
+    return abs;
+  const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
+  if (rebased !== undefined)
+    return rebased;
+  const canonical = canonicalizeExistingOrNearestAncestor(abs);
+  if (isPathInside(cwd, canonical))
+    return canonical;
+  throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+}
+function resolvePathInsideContext(filePath) {
+  const cwd = contextCwd();
+  const abs = resolveReadablePathInsideContext(filePath);
   const canonical = canonicalizeExistingOrNearestAncestor(abs);
   if (!isPathInside(cwd, canonical)) {
     throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
   }
   return canonical;
 }
+function rebaseThroughCanonicalAncestor(path2, cwd) {
+  let current = path2;
+  const suffix = [];
+  while (true) {
+    if (existsSync10(current)) {
+      const canonical = realpathSync4(current);
+      if (isPathInside(cwd, canonical))
+        return suffix.length === 0 ? canonical : join4(canonical, ...suffix);
+    }
+    const parent = dirname8(current);
+    if (parent === current)
+      return;
+    suffix.unshift(basename3(current));
+    current = parent;
+  }
+}
+function existingDirectoryInsideContext(directory, cwd) {
+  if (!existsSync10(directory))
+    return;
+  const canonical = realpathSync4(directory);
+  if (!statSync4(canonical).isDirectory())
+    return;
+  return isPathInside(cwd, canonical) ? canonical : undefined;
+}
+function nearestExistingDirectoryInsideContext(directory, cwd) {
+  let current = directory;
+  while (isPathInside(cwd, current)) {
+    const canonical = existingDirectoryInsideContext(current, cwd);
+    if (canonical !== undefined)
+      return canonical;
+    if (current === cwd)
+      return;
+    current = dirname8(current);
+  }
+  return;
+}
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
     return formatNotInstalled(result);
@@ -4768,7 +4836,7 @@ function formatNotInstalled(result) {
   ].join(`
 `);
 }
-var READ_ONLY_RETRY_TOOLS = new Set([
+var READ_ONLY_TOOLS = new Set([
   "diagnostics",
   "definition",
   "references",
@@ -4777,7 +4845,7 @@ var READ_ONLY_RETRY_TOOLS = new Set([
   "prepareRename"
 ]);
 async function withLspClient(filePath, fn, toolName, options = {}) {
-  const absPath = resolvePathInsideContext(filePath);
+  const absPath = READ_ONLY_TOOLS.has(toolName) ? resolveReadablePathInsideContext(filePath) : resolvePathInsideContext(filePath);
   if (isDirectoryPath(absPath)) {
     throw new LspInvalidPathError("Directory paths are not supported by this LSP tool. " + "Use lsp.diagnostics with a directory path for directory diagnostics.");
   }
@@ -4792,9 +4860,9 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
   const acquireAndCall = async (allowRetry) => {
     const client = await manager.getClient(root, server2, options.signal);
     try {
-      return await fn(client, root);
+      return await fn(client, root, absPath);
     } catch (err) {
-      if (allowRetry && READ_ONLY_RETRY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
+      if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
         manager.invalidateClient(root, server2.id, client);
         return acquireAndCall(false);
       }
@@ -4812,7 +4880,7 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
 }
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
-import { existsSync as existsSync10, lstatSync as lstatSync5, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync11, lstatSync as lstatSync5, readdirSync as readdirSync3 } from "node:fs";
 import { join as join5, resolve as resolve8 } from "node:path";
 
 // ../lsp-core/src/lsp/formatters.ts
@@ -4969,7 +5037,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
   }
   const absDir = resolve8(options.workspaceRoot ?? contextCwd(), directory);
-  if (!existsSync10(absDir)) {
+  if (!existsSync11(absDir)) {
     throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
   }
   const serverResult = options.server === undefined ? findServerForExtension(extension) : { status: "found", server: options.server };
@@ -5249,7 +5317,7 @@ async function executeLspDiagnostics(params, signal) {
   const filePath = requireString(params, "filePath");
   const severity = severityFilter(params);
   try {
-    const absPath = resolvePathInsideContext(filePath);
+    const absPath = resolveReadablePathInsideContext(filePath);
     if (isDirectoryPath(absPath)) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
@@ -5278,7 +5346,7 @@ async function executeLspDiagnostics(params, signal) {
       };
       return text(output2.output, details2);
     }
-    const result = await withLspClient(filePath, async (client) => client.diagnostics(filePath, signal), "diagnostics", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal), "diagnostics", clientOptions(signal));
     if (result.transientError) {
       const message = result.transientError.message;
       const details2 = {
@@ -5353,7 +5421,7 @@ async function executeLspGotoDefinition(params, signal) {
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.definition(filePath, line, character, signal), "definition", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.definition(resolvedFilePath, line, character, signal), "definition", clientOptions(signal));
     const locations = !result ? [] : Array.isArray(result) ? result : [result];
     const details = { filePath, line, character, locations };
     if (locations.length === 0)
@@ -5378,7 +5446,7 @@ async function executeLspFindReferences(params, signal) {
   const character = requireNumber(params, "character");
   const includeDeclaration = optionalBoolean(params, "includeDeclaration") ?? true;
   try {
-    const result = await withLspClient(filePath, async (client) => client.references(filePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.references(resolvedFilePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
     const references = Array.isArray(result) ? result : [];
     const total = references.length;
     const truncated = total > DEFAULT_MAX_REFERENCES;
@@ -5420,7 +5488,7 @@ async function executeLspPrepareRename(params, signal) {
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.prepareRename(filePath, line, character, signal), "prepareRename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.prepareRename(resolvedFilePath, line, character, signal), "prepareRename", clientOptions(signal));
     const details = { filePath, line, character, result };
     return text(formatPrepareRenameResult(result), details);
   } catch (error) {
@@ -5441,7 +5509,7 @@ async function executeLspRename(params, signal) {
   const character = requireNumber(params, "character");
   const newName = requireString(params, "newName");
   try {
-    const result = await withLspClient(filePath, async (client) => client.rename(filePath, line, character, newName, signal), "rename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.rename(resolvedFilePath, line, character, newName, signal), "rename", clientOptions(signal));
     const details = { filePath, line, character, newName, apply: result.apply, edit: result.edit };
     return text(formatApplyResult(result.apply), details, !result.apply.success);
   } catch (error) {
@@ -5521,7 +5589,7 @@ async function executeLspSymbols(params, signal) {
       const symbols2 = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
       return formatSymbolsResult(filePath, scope, symbols2, limit, query);
     }
-    const symbols = await withLspClient(filePath, async (client) => client.documentSymbols(filePath, signal), "documentSymbols", clientOptions(signal));
+    const symbols = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
   } catch (error) {
     const query = optionalString(params, "query");
@@ -6014,7 +6082,7 @@ function isRetryableTool(name) {
 
 // src/client.ts
 import { statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { isAbsolute as isAbsolute5 } from "node:path";
 var OMO_LSP_DAEMON_DIR2 = "OMO_LSP_DAEMON_DIR";
 var OMO_LSP_DAEMON_CLI2 = "OMO_LSP_DAEMON_CLI";
 var OMO_LSP_DAEMON_VERSION2 = "OMO_LSP_DAEMON_VERSION";
@@ -6044,12 +6112,12 @@ function resolveDaemonRuntime2(env, defaults) {
     throw new InvalidRuntimeOverrideError2("paired_values_required", `${OMO_LSP_DAEMON_CLI2} and ${OMO_LSP_DAEMON_VERSION2} must be set together`);
   }
   if (!hasCliOverride || !hasVersionOverride) {
-    if (!isAbsolute4(defaults.cliPath)) {
+    if (!isAbsolute5(defaults.cliPath)) {
       throw new InvalidRuntimeOverrideError2("packaged_cli_must_be_absolute", "Packaged LSP daemon CLI path must be absolute");
     }
     return { cliPath: defaults.cliPath, version: validateDaemonVersion2(defaults.version) };
   }
-  if (!isAbsolute4(cliOverride)) {
+  if (!isAbsolute5(cliOverride)) {
     throw new InvalidRuntimeOverrideError2("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI2} must be an absolute path to an existing regular file`);
   }
   const stat = statSync5(cliOverride, { throwIfNoEntry: false });

package/packages/lsp-daemon/dist/ensure-daemon.d.ts

@@ -20,5 +20,6 @@ export declare function ensureDaemonRunning(paths: DaemonPaths, deps?: EnsureDae
 export declare function probeDaemon(paths: DaemonPaths, timeoutMs?: number, signal?: AbortSignal): Promise<boolean>;
 export declare function pingDaemon(paths: DaemonPaths, token: string, timeoutMs?: number, signal?: AbortSignal): Promise<OwnerPing | null>;
 export declare function spawnDaemonProcess(paths: DaemonPaths): void;
+export declare function resolveDaemonNodeExecutable(cachedExecPath?: string, originalArgv0?: string, pathExists?: (path: string) => boolean): string;
 export declare function resolveDaemonCliPath(env?: NodeJS.ProcessEnv, defaults?: DaemonRuntimeDefaults): string;
 export declare function defaultEnsureDaemonDeps(): EnsureDaemonDeps;

package/packages/lsp-daemon/dist/ensure-daemon.js

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
-import { closeSync, mkdirSync, openSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, writeSync } from "node:fs";
 import { Socket } from "node:net";
-import { dirname } from "node:path";
-import { execPath } from "node:process";
+import { dirname, isAbsolute } from "node:path";
+import { argv0, execPath } from "node:process";
 import { authEnvelope, readAuthToken } from "./ipc-protocol.js";
 import { packagedRuntimeDefaults } from "./paths.js";
 import { resolveDaemonRuntime } from "./runtime-contract.js";
@@ -85,16 +85,29 @@ export function spawnDaemonProcess(paths) {
     mkdirSync(dirname(paths.log), { recursive: true });
     const logFd = openSync(paths.log, "a");
     try {
-        const child = spawn(execPath, [paths.cliPath, "daemon"], {
+        const child = spawn(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
             detached: true,
             stdio: ["ignore", logFd, logFd],
         });
+        child.once("spawn", () => closeSync(logFd));
+        child.once("error", (error) => {
+            writeSync(logFd, `[lsp-daemon] failed to spawn daemon: ${error.message}\n`);
+            closeSync(logFd);
+        });
         child.unref();
     }
-    finally {
+    catch (error) {
         closeSync(logFd);
+        throw error;
     }
 }
+export function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync) {
+    if (pathExists(cachedExecPath))
+        return cachedExecPath;
+    if (isAbsolute(originalArgv0) && pathExists(originalArgv0))
+        return originalArgv0;
+    return "node";
+}
 export function resolveDaemonCliPath(env = process.env, defaults = packagedRuntimeDefaults()) {
     return resolveDaemonRuntime(env, defaults).cliPath;
 }