oh-my-opencode 4.18.2 → 4.19.1

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

@@ -177,6 +177,81 @@ function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/daemon-request-error.ts
+class DaemonRequestError extends Error {
+  requestWritten;
+  constructor(message, requestWritten) {
+    super(message);
+    this.name = "DaemonRequestError";
+    this.requestWritten = requestWritten;
+  }
+}
+
+class DaemonAuthenticationRejectedError extends DaemonRequestError {
+  constructor() {
+    super("daemon authentication failed before dispatch", true);
+    this.name = "DaemonAuthenticationRejectedError";
+  }
+}
+
+class DaemonRequestCancelledError extends DaemonRequestError {
+  constructor(requestWritten) {
+    super("daemon request cancelled", requestWritten);
+    this.name = "DaemonRequestCancelledError";
+  }
+}
+
+class DaemonRequestTimedOutError extends DaemonRequestError {
+  timeoutMs;
+  constructor(requestWritten, timeoutMs) {
+    super("daemon request timed out", requestWritten);
+    this.name = "DaemonRequestTimedOutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+// src/daemon-failure-result.ts
+function daemonFailureResult(paths, error) {
+  if (error instanceof DaemonRequestCancelledError)
+    return daemonCancelledResult(paths);
+  if (error instanceof DaemonRequestTimedOutError)
+    return daemonTimedOutResult(paths, error.timeoutMs);
+  return daemonUnreachableResult(paths, error);
+}
+function daemonCancelledResult(paths) {
+  const text = [
+    "LSP daemon request cancelled: the caller aborted this request (for example, the turn was interrupted).",
+    "The daemon stays available; no LSP work was applied. Retry when you are ready.",
+    `Socket: ${paths.socket}`
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
+}
+function daemonTimedOutResult(paths, timeoutMs) {
+  const text = [
+    `LSP daemon request timed out after ${timeoutMs}ms: the daemon did not respond in time.`,
+    "The daemon stays available but may be busy. Retry when you are ready.",
+    `Socket: ${paths.socket}`,
+    `Logs: ${paths.log}`
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
+}
+function daemonUnreachableResult(paths, error) {
+  const text = [
+    `LSP daemon unreachable: ${errorText(error)}.`,
+    "The MCP server is a thin proxy and never runs language servers in-process.",
+    `Socket: ${paths.socket}`,
+    `Logs: ${paths.log}`,
+    "The daemon is auto-started on demand and will be retried on the next request."
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/ensure-daemon.ts
 import { spawn } from "node:child_process";
 import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
@@ -904,16 +979,35 @@ function bufferFromChunk(chunk) {
 
 // ../mcp-stdio-core/src/server.ts
 var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60000;
+var DEFAULT_PARENT_POLL_INTERVAL_MS = 30000;
 var noopLog = () => {};
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !hasErrorCode(error, "ESRCH");
+  }
+}
 async function runJsonRpcStdioServer(config) {
   const log = config.log ?? noopLog;
   const idleTimeoutMs = config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-  const idleTimer = createIdleTimer(idleTimeoutMs, log, config.onIdleTimeout);
+  let isClosed = false;
+  const idleTimer = createIdleTimer(idleTimeoutMs, log, () => {
+    isClosed = true;
+    config.onIdleTimeout?.();
+  });
+  const watchdog = createParentWatchdog(config.parentWatchdog, (parentPid, pollIntervalMs) => {
+    isClosed = true;
+    log("parent_exit", { parent_pid: parentPid, poll_interval_ms: pollIntervalMs });
+    config.onParentExit?.();
+    config.input.destroy();
+  });
   log("stdio_started", { cwd: process.cwd(), idle_timeout_ms: idleTimeoutMs });
   idleTimer.arm();
   try {
     for await (const message of readStdioJsonRpcMessages(config.input)) {
-      if (idleTimer.closed())
+      if (isClosed)
         break;
       idleTimer.arm();
       if (message.kind === "parse_error") {
@@ -924,8 +1018,12 @@ async function runJsonRpcStdioServer(config) {
       if (!await handleRequest(message, config, log))
         break;
     }
+  } catch (error) {
+    if (!(isClosed && hasErrorCode(error, "ERR_STREAM_PREMATURE_CLOSE")))
+      throw error;
   } finally {
     idleTimer.clear();
+    watchdog.clear();
     log("stdio_stopped");
   }
 }
@@ -981,9 +1079,33 @@ function isTerminalOutputError(error) {
     return false;
   return error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED" || error.code === "ERR_STREAM_WRITE_AFTER_END";
 }
-function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
+function hasErrorCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function createParentWatchdog(config, onDeadParent) {
+  if (config === undefined)
+    return { clear: () => {} };
+  const pollIntervalMs = config.pollIntervalMs ?? DEFAULT_PARENT_POLL_INTERVAL_MS;
+  if (pollIntervalMs <= 0)
+    return { clear: () => {} };
+  const parentPid = config.parentPid ?? process.ppid;
+  const probeAlive = config.probeAlive ?? isProcessAlive;
+  let fired = false;
+  const timer = setInterval(() => {
+    if (fired || probeAlive(parentPid))
+      return;
+    fired = true;
+    onDeadParent(parentPid, pollIntervalMs);
+  }, pollIntervalMs);
+  timer.unref();
+  return {
+    clear: () => {
+      clearInterval(timer);
+    }
+  };
+}
+function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   let timer = null;
-  let isClosed = false;
   return {
     arm: () => {
       if (timer !== null)
@@ -991,9 +1113,8 @@ function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
       if (idleTimeoutMs <= 0)
         return;
       timer = setTimeout(() => {
-        isClosed = true;
         log("idle_timeout", { idle_timeout_ms: idleTimeoutMs });
-        onIdleTimeout?.();
+        onTimeout();
       }, idleTimeoutMs);
       timer.unref();
     },
@@ -1002,8 +1123,7 @@ function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
         return;
       clearTimeout(timer);
       timer = null;
-    },
-    closed: () => isClosed
+    }
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
@@ -3625,8 +3745,13 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly)
         continue;
       const remainingMs = deadlineAt - Date.now();
-      if (remainingMs <= 0)
+      if (remainingMs <= 0) {
+        if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
+          const cached = this.documents.getPullCache(snapshot);
+          return { items: cached === null ? [] : [...cached.diagnostics] };
+        }
         return this.freshnessTimeout(absPath);
+      }
       const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
       await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
     }
@@ -5715,29 +5840,6 @@ function parseContext(value) {
 // src/daemon-client.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var nextProxyRequestId = 1;
-
-class DaemonRequestError extends Error {
-  requestWritten;
-  constructor(message, requestWritten) {
-    super(message);
-    this.name = "DaemonRequestError";
-    this.requestWritten = requestWritten;
-  }
-}
-
-class DaemonAuthenticationRejectedError extends DaemonRequestError {
-  constructor() {
-    super("daemon authentication failed before dispatch", true);
-    this.name = "DaemonAuthenticationRejectedError";
-  }
-}
-
-class DaemonRequestCancelledError extends DaemonRequestError {
-  constructor(requestWritten) {
-    super("daemon request cancelled", requestWritten);
-    this.name = "DaemonRequestCancelledError";
-  }
-}
 async function callToolViaDaemon(name, args, options) {
   const context = requireContext(options.context);
   const paths = options.paths ?? daemonPaths();
@@ -5766,7 +5868,7 @@ async function callToolViaDaemon(name, args, options) {
         break;
     }
   }
-  return daemonUnreachableResult(paths, lastError);
+  return daemonFailureResult(paths, lastError);
 }
 function callDiagnosticsViaDaemon(filePath, options) {
   return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
@@ -5811,17 +5913,6 @@ function ensureDaemonAvailable(paths, ensure, signal) {
     Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve9()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
   });
 }
-function daemonUnreachableResult(paths, error) {
-  const text2 = [
-    `LSP daemon unreachable: ${errorText(error)}.`,
-    "The MCP server is a thin proxy and never runs language servers in-process.",
-    `Socket: ${paths.socket}`,
-    `Logs: ${paths.log}`,
-    "The daemon is auto-started on demand and will be retried on the next request."
-  ].join(`
-`);
-  return { content: [{ type: "text", text: text2 }], isError: true };
-}
 function sendToolCall(paths, token, name, args, options) {
   return new Promise((resolve9, reject) => {
     const socket = connect(paths.socket);
@@ -5861,7 +5952,7 @@ function sendToolCall(paths, token, name, args, options) {
     };
     const timer = setTimeout(() => {
       sendCancel();
-      finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten)));
+      finish(() => reject(new DaemonRequestTimedOutError(requestWritten, options.timeoutMs)));
     }, options.timeoutMs);
     timer.unref();
     if (options.signal?.aborted) {
@@ -5920,9 +6011,6 @@ function allocateProxyRequestId() {
 function isRetryableTool(name) {
   return name !== "rename" && name !== "lsp_rename";
 }
-function errorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/client.ts
 import { statSync as statSync5 } from "node:fs";

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

@@ -1,16 +1,6 @@
 import { type LspRequestContext } from "@oh-my-opencode/lsp-core/request-context";
 import type { ToolExecutionResult } from "@oh-my-opencode/lsp-core/tools";
 import { type DaemonPaths } from "./paths.js";
-export declare class DaemonRequestError extends Error {
-    readonly requestWritten: boolean;
-    constructor(message: string, requestWritten: boolean);
-}
-export declare class DaemonAuthenticationRejectedError extends DaemonRequestError {
-    constructor();
-}
-export declare class DaemonRequestCancelledError extends DaemonRequestError {
-    constructor(requestWritten: boolean);
-}
 export type DaemonToolContext = LspRequestContext;
 export interface CallToolOptions {
     context: DaemonToolContext;

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

@@ -3,6 +3,8 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseLspRequestContext } from "@oh-my-opencode/lsp-core/request-context";
 import { isPlainRecord } from "@oh-my-opencode/mcp-stdio-core/record";
+import { daemonFailureResult } from "./daemon-failure-result.js";
+import { DaemonAuthenticationRejectedError, DaemonRequestCancelledError, DaemonRequestError, DaemonRequestTimedOutError, } from "./daemon-request-error.js";
 import { ensureDaemonRunning } from "./ensure-daemon.js";
 import { authEnvelope, isAuthErrorResponse, readAuthToken } from "./ipc-protocol.js";
 import { daemonPaths } from "./paths.js";
@@ -10,25 +12,6 @@ import { CONTEXT_KEY } from "./request-routing.js";
 import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 let nextProxyRequestId = 1;
-export class DaemonRequestError extends Error {
-    constructor(message, requestWritten) {
-        super(message);
-        this.name = "DaemonRequestError";
-        this.requestWritten = requestWritten;
-    }
-}
-export class DaemonAuthenticationRejectedError extends DaemonRequestError {
-    constructor() {
-        super("daemon authentication failed before dispatch", true);
-        this.name = "DaemonAuthenticationRejectedError";
-    }
-}
-export class DaemonRequestCancelledError extends DaemonRequestError {
-    constructor(requestWritten) {
-        super("daemon request cancelled", requestWritten);
-        this.name = "DaemonRequestCancelledError";
-    }
-}
 export async function callToolViaDaemon(name, args, options) {
     const context = requireContext(options.context);
     const paths = options.paths ?? daemonPaths();
@@ -59,7 +42,7 @@ export async function callToolViaDaemon(name, args, options) {
                 break;
         }
     }
-    return daemonUnreachableResult(paths, lastError);
+    return daemonFailureResult(paths, lastError);
 }
 export function callDiagnosticsViaDaemon(filePath, options) {
     return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
@@ -106,16 +89,6 @@ function ensureDaemonAvailable(paths, ensure, signal) {
             .then(() => finish(() => resolve()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
     });
 }
-function daemonUnreachableResult(paths, error) {
-    const text = [
-        `LSP daemon unreachable: ${errorText(error)}.`,
-        "The MCP server is a thin proxy and never runs language servers in-process.",
-        `Socket: ${paths.socket}`,
-        `Logs: ${paths.log}`,
-        "The daemon is auto-started on demand and will be retried on the next request.",
-    ].join("\n");
-    return { content: [{ type: "text", text }], isError: true };
-}
 function sendToolCall(paths, token, name, args, options) {
     return new Promise((resolve, reject) => {
         const socket = connect(paths.socket);
@@ -155,7 +128,7 @@ function sendToolCall(paths, token, name, args, options) {
         };
         const timer = setTimeout(() => {
             sendCancel();
-            finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten)));
+            finish(() => reject(new DaemonRequestTimedOutError(requestWritten, options.timeoutMs)));
         }, options.timeoutMs);
         timer.unref();
         if (options.signal?.aborted) {
@@ -214,6 +187,3 @@ function allocateProxyRequestId() {
 function isRetryableTool(name) {
     return name !== "rename" && name !== "lsp_rename";
 }
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/packages/lsp-daemon/dist/daemon-failure-result.d.ts

@@ -0,0 +1,3 @@
+import type { ToolExecutionResult } from "@oh-my-opencode/lsp-core/tools";
+import type { DaemonPaths } from "./paths.js";
+export declare function daemonFailureResult(paths: DaemonPaths, error: unknown): ToolExecutionResult;

package/packages/lsp-daemon/dist/daemon-failure-result.js

@@ -0,0 +1,38 @@
+import { DaemonRequestCancelledError, DaemonRequestTimedOutError } from "./daemon-request-error.js";
+export function daemonFailureResult(paths, error) {
+    if (error instanceof DaemonRequestCancelledError)
+        return daemonCancelledResult(paths);
+    if (error instanceof DaemonRequestTimedOutError)
+        return daemonTimedOutResult(paths, error.timeoutMs);
+    return daemonUnreachableResult(paths, error);
+}
+function daemonCancelledResult(paths) {
+    const text = [
+        "LSP daemon request cancelled: the caller aborted this request (for example, the turn was interrupted).",
+        "The daemon stays available; no LSP work was applied. Retry when you are ready.",
+        `Socket: ${paths.socket}`,
+    ].join("\n");
+    return { content: [{ type: "text", text }], isError: true };
+}
+function daemonTimedOutResult(paths, timeoutMs) {
+    const text = [
+        `LSP daemon request timed out after ${timeoutMs}ms: the daemon did not respond in time.`,
+        "The daemon stays available but may be busy. Retry when you are ready.",
+        `Socket: ${paths.socket}`,
+        `Logs: ${paths.log}`,
+    ].join("\n");
+    return { content: [{ type: "text", text }], isError: true };
+}
+function daemonUnreachableResult(paths, error) {
+    const text = [
+        `LSP daemon unreachable: ${errorText(error)}.`,
+        "The MCP server is a thin proxy and never runs language servers in-process.",
+        `Socket: ${paths.socket}`,
+        `Logs: ${paths.log}`,
+        "The daemon is auto-started on demand and will be retried on the next request.",
+    ].join("\n");
+    return { content: [{ type: "text", text }], isError: true };
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/packages/lsp-daemon/dist/daemon-request-error.d.ts

@@ -0,0 +1,14 @@
+export declare class DaemonRequestError extends Error {
+    readonly requestWritten: boolean;
+    constructor(message: string, requestWritten: boolean);
+}
+export declare class DaemonAuthenticationRejectedError extends DaemonRequestError {
+    constructor();
+}
+export declare class DaemonRequestCancelledError extends DaemonRequestError {
+    constructor(requestWritten: boolean);
+}
+export declare class DaemonRequestTimedOutError extends DaemonRequestError {
+    readonly timeoutMs: number;
+    constructor(requestWritten: boolean, timeoutMs: number);
+}

package/packages/lsp-daemon/dist/daemon-request-error.js

@@ -0,0 +1,26 @@
+export class DaemonRequestError extends Error {
+    constructor(message, requestWritten) {
+        super(message);
+        this.name = "DaemonRequestError";
+        this.requestWritten = requestWritten;
+    }
+}
+export class DaemonAuthenticationRejectedError extends DaemonRequestError {
+    constructor() {
+        super("daemon authentication failed before dispatch", true);
+        this.name = "DaemonAuthenticationRejectedError";
+    }
+}
+export class DaemonRequestCancelledError extends DaemonRequestError {
+    constructor(requestWritten) {
+        super("daemon request cancelled", requestWritten);
+        this.name = "DaemonRequestCancelledError";
+    }
+}
+export class DaemonRequestTimedOutError extends DaemonRequestError {
+    constructor(requestWritten, timeoutMs) {
+        super("daemon request timed out", requestWritten);
+        this.name = "DaemonRequestTimedOutError";
+        this.timeoutMs = timeoutMs;
+    }
+}

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

@@ -1,11 +1,12 @@
 import { chmodSync } from "node:fs";
 import { createServer } from "node:net";
 import { disposeDefaultLspManager, getLspManager } from "@oh-my-opencode/lsp-core/lsp/manager";
-import { setPrivateFileMode } from "./ipc-protocol.js";
 import { pingDaemon } from "./ensure-daemon.js";
+import { setPrivateFileMode } from "./ipc-protocol.js";
 import { acquireStartupLease, DaemonStartupDeferredError, endpointIdentity, removeDaemonMetadataForOwner, writeDaemonOwner, } from "./ownership.js";
 import { handleDaemonMessage } from "./request-routing.js";
 import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
+import { reapStaleDaemonVersions } from "./version-reap.js";
 export { DaemonAlreadyRunningError, DaemonStartupDeferredError } from "./ownership.js";
 const DEFAULT_IDLE_SHUTDOWN_MS = 30 * 60_000;
 const DEFAULT_IDLE_CHECK_INTERVAL_MS = 60_000;
@@ -53,6 +54,9 @@ export async function startDaemonServer(paths, options = {}) {
         throw error;
     }
     lease.lock.release();
+    // Best-effort cross-version reap: the daemon now owns its version, so older
+    // sibling versions may be reaped. Never block or crash startup on failure.
+    void reapStaleDaemonVersions(paths).catch((error) => logServerError(error));
     let closed = false;
     const close = async () => {
         if (closed)