oh-my-opencode 4.18.1 → 4.18.2

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

@@ -1,5 +1,5 @@
 // src/daemon-client.ts
-import { connect as connect2 } from "node:net";
+import { connect } from "node:net";
 import { homedir as homedir3 } from "node:os";
 import { join as join7 } from "node:path";
 
@@ -180,7 +180,7 @@ function isPlainRecord(value) {
 // src/ensure-daemon.ts
 import { spawn } from "node:child_process";
 import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
-import { connect } from "node:net";
+import { Socket } from "node:net";
 import { dirname as dirname3 } from "node:path";
 import { execPath } from "node:process";
 
@@ -587,42 +587,48 @@ class DaemonUnreachableError extends Error {
 async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
   const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  if (await deps.probe(paths))
+  const signal = options.signal;
+  throwIfAborted(signal);
+  if (await awaitWithSignal(deps.probe(paths, signal), signal))
     return;
+  throwIfAborted(signal);
   deps.spawnDaemon(paths);
-  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs);
+  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
 }
-async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs) {
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
   const deadline = deps.now() + readyTimeoutMs;
   for (;; ) {
-    if (await deps.probe(paths))
+    throwIfAborted(signal);
+    if (await awaitWithSignal(deps.probe(paths, signal), signal))
       return;
     if (deps.now() >= deadline)
       throw new DaemonUnreachableError(paths.socket);
-    await deps.sleep(pollIntervalMs);
+    await awaitWithSignal(deps.sleep(pollIntervalMs, signal), signal);
   }
 }
-async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS) {
+async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   const token = readAuthToken(paths);
   if (!token)
     return false;
-  return await pingDaemon(paths, token, timeoutMs) !== null;
+  return await pingDaemon(paths, token, timeoutMs, signal) !== null;
 }
-function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
+function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   return new Promise((resolve2) => {
-    const socket = connect(paths.socket);
+    const socket = new Socket;
     let settled = false;
+    let timer;
     const finish = (value) => {
       if (settled)
         return;
       settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
       socket.destroy();
       resolve2(value);
     };
-    const timer = setTimeout(() => finish(null), timeoutMs);
-    timer.unref?.();
+    const onAbort = () => finish(null);
     const decoder = createLineDecoder((message) => {
-      clearTimeout(timer);
       finish(parsePingResponse(message));
     });
     socket.once("connect", () => {
@@ -630,9 +636,16 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
     });
     socket.on("data", (chunk) => decoder.push(chunk));
     socket.once("error", () => {
-      clearTimeout(timer);
       finish(null);
     });
+    timer = setTimeout(() => finish(null), timeoutMs);
+    timer.unref?.();
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    socket.connect(paths.socket);
   });
 }
 function spawnDaemonProcess(paths) {
@@ -650,14 +663,62 @@ function spawnDaemonProcess(paths) {
 }
 function defaultEnsureDaemonDeps() {
   return {
-    probe: (paths) => probeDaemon(paths),
+    probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
     spawnDaemon: (paths) => spawnDaemonProcess(paths),
-    sleep: (ms) => new Promise((resolve2) => {
-      setTimeout(resolve2, ms);
-    }),
+    sleep: (ms, signal) => sleepWithSignal(ms, signal),
     now: () => Date.now()
   };
 }
+function sleepWithSignal(ms, signal) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", finish);
+      resolve2();
+    };
+    const timer = setTimeout(finish, ms);
+    if (signal?.aborted) {
+      finish();
+      return;
+    }
+    signal?.addEventListener("abort", finish, { once: true });
+  });
+}
+function awaitWithSignal(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(abortError(signal));
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(abortError(signal)));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => finish(() => resolve2(value)), (error) => finish(() => reject(error)));
+  });
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw abortError(signal);
+}
+function abortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  const error = new Error(typeof reason === "string" ? reason : "daemon startup cancelled");
+  error.name = "AbortError";
+  return error;
+}
 function parsePingResponse(message) {
   if (!message || typeof message !== "object" || Array.isArray(message))
     return null;
@@ -697,6 +758,9 @@ function errorResponse(id, code, message, data) {
 function jsonRpcId2(value) {
   return typeof value === "string" || typeof value === "number" || value === null ? value : null;
 }
+function messageFromError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 // ../mcp-stdio-core/src/transport.ts
 var HEADER_SEPARATOR = Buffer.from(`\r
 \r
@@ -719,16 +783,45 @@ async function* readStdioJsonRpcMessages(input) {
     yield parseJsonPayload(trailing, "line");
   }
 }
-function writeStdioJsonRpcResponse(output, response, responseMode) {
+async function writeStdioJsonRpcResponse(output, response, responseMode) {
   const body = JSON.stringify(response);
-  if (responseMode === "framed") {
-    output.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+  const payload = responseMode === "framed" ? `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
 \r
-${body}`);
-    return;
-  }
-  output.write(`${body}
-`);
+${body}` : `${body}
+`;
+  await writeChunk(output, payload);
+}
+function writeChunk(output, chunk) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const onError = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      reject(error);
+    };
+    output.once("error", onError);
+    try {
+      output.write(chunk, (error) => {
+        if (settled)
+          return;
+        settled = true;
+        if (error) {
+          queueMicrotask(() => output.removeListener("error", onError));
+          reject(error);
+          return;
+        }
+        output.removeListener("error", onError);
+        resolve2();
+      });
+    } catch (error) {
+      output.removeListener("error", onError);
+      if (settled)
+        return;
+      settled = true;
+      reject(error);
+    }
+  });
 }
 function readNextMessage(buffer) {
   if (buffer.length === 0)
@@ -824,39 +917,69 @@ async function runJsonRpcStdioServer(config) {
         break;
       idleTimer.arm();
       if (message.kind === "parse_error") {
-        handleParseError(message, config, log);
+        if (!await handleParseError(message, config, log))
+          break;
         continue;
       }
-      await handleRequest(message, config, log);
+      if (!await handleRequest(message, config, log))
+        break;
     }
   } finally {
     idleTimer.clear();
     log("stdio_stopped");
   }
 }
-function handleParseError(message, config, log) {
+async function handleParseError(message, config, log) {
   log("parse_error", { message: message.message });
   const response = config.parseErrorResponse?.(message.message) ?? errorResponse(null, -32700, "Parse error", message.message);
-  if (response !== undefined) {
-    writeStdioJsonRpcResponse(config.output, response, message.responseMode);
-  }
+  if (response === undefined)
+    return true;
+  return writeResponse(response, {
+    output: config.output,
+    responseMode: message.responseMode,
+    log
+  });
 }
 async function handleRequest(message, config, log) {
   const parsed = message.payload;
   const id = isPlainRecord(parsed) ? jsonRpcId2(parsed["id"]) : null;
   const method = isPlainRecord(parsed) && typeof parsed["method"] === "string" ? parsed["method"] : null;
   log("request", { id: id === null ? null : String(id), method });
+  let response;
   try {
-    const response = await config.handler(parsed, config.handlerOptions);
-    if (response === undefined)
-      return;
-    writeStdioJsonRpcResponse(config.output, response, message.responseMode);
-    log("response", { id: String(response.id), method, is_error: response.error !== undefined });
+    response = await config.handler(parsed, config.handlerOptions);
   } catch (error) {
     if (config.onHandlerError === undefined)
       throw error;
     config.onHandlerError(error);
+    return true;
   }
+  if (response === undefined)
+    return true;
+  if (!await writeResponse(response, {
+    output: config.output,
+    responseMode: message.responseMode,
+    log
+  }))
+    return false;
+  log("response", { id: String(response.id), method, is_error: response.error !== undefined });
+  return true;
+}
+async function writeResponse(response, context) {
+  try {
+    await writeStdioJsonRpcResponse(context.output, response, context.responseMode);
+    return true;
+  } catch (error) {
+    if (!isTerminalOutputError(error))
+      throw error;
+    context.log("output_error", { message: messageFromError(error) });
+    return false;
+  }
+}
+function isTerminalOutputError(error) {
+  if (!(error instanceof Error) || !("code" in error))
+    return false;
+  return error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED" || error.code === "ERR_STREAM_WRITE_AFTER_END";
 }
 function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
   let timer = null;
@@ -1065,7 +1188,7 @@ class JsonRpcConnection {
         settled = true;
         this.pendingRequests.delete(key);
         cleanup();
-        const rejectCancelled = () => reject(abortError(options.signal));
+        const rejectCancelled = () => reject(abortError2(options.signal));
         if (!requestWritten) {
           cancelAfterWrite = true;
           rejectCancelled();
@@ -1269,7 +1392,7 @@ ${body}`;
     }
   }
 }
-function abortError(signal) {
+function abortError2(signal) {
   const reason = signal?.reason;
   if (reason instanceof Error)
     return reason;
@@ -3547,11 +3670,11 @@ function waitForDiagnosticsActivity(wait, signal) {
   if (!signal)
     return wait;
   if (signal.aborted)
-    return Promise.reject(abortError2(signal));
+    return Promise.reject(abortError3(signal));
   return new Promise((resolve7, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
-      reject(abortError2(signal));
+      reject(abortError3(signal));
     };
     signal.addEventListener("abort", onAbort, { once: true });
     wait.then(() => {
@@ -3586,7 +3709,7 @@ function preCommitAbortReason(source) {
     return reason;
   return new Error("LSP request cancelled before workspace edit commit");
 }
-function abortError2(signal) {
+function abortError3(signal) {
   const reason = signal.reason;
   if (reason instanceof Error)
     return reason;
@@ -3621,7 +3744,7 @@ async function stopClientBestEffort(client) {
     reportBestEffortCleanupError("client stop", error);
   }
 }
-function awaitWithSignal(promise, signal) {
+function awaitWithSignal2(promise, signal) {
   if (!signal)
     return promise;
   return new Promise((resolve7, reject) => {
@@ -3724,7 +3847,7 @@ class LspManager {
       if (managed.initPromise) {
         managed.pendingWaiters++;
         try {
-          await awaitWithSignal(managed.initPromise, signal);
+          await awaitWithSignal2(managed.initPromise, signal);
         } catch (err) {
           managed.pendingWaiters--;
           await this.tryDeleteIfOrphaned(key, managed);
@@ -3762,7 +3885,7 @@ class LspManager {
     };
     this.clients.set(key, newManaged);
     try {
-      await awaitWithSignal(initPromise, signal);
+      await awaitWithSignal2(initPromise, signal);
     } catch (err) {
       newManaged.pendingWaiters--;
       if (this.clients.get(key) === newManaged) {
@@ -4748,7 +4871,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   const fileErrors = [];
   const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
   options.signal?.throwIfAborted();
-  const client = await manager.getClient(root, server2);
+  const client = await manager.getClient(root, server2, options.signal);
   try {
     let nextIndex = 0;
     const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
@@ -5618,14 +5741,14 @@ class DaemonRequestCancelledError extends DaemonRequestError {
 async function callToolViaDaemon(name, args, options) {
   const context = requireContext(options.context);
   const paths = options.paths ?? daemonPaths();
-  const ensure = options.ensure ?? ensureDaemonRunning;
+  const ensure = options.ensure ?? ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
   const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const requestArgs = withContext(args, context);
   let lastError;
   let authRefreshUsed = false;
   for (let attempt = 0;attempt < 3; attempt += 1) {
     try {
-      await ensure(paths);
+      await ensureDaemonAvailable(paths, ensure, options.signal);
       const token = readAuthToken(paths);
       if (!token)
         throw new DaemonRequestError("daemon auth token missing", false);
@@ -5667,6 +5790,27 @@ function requireContext(context) {
 function withContext(args, context) {
   return { ...args, [CONTEXT_KEY]: context };
 }
+function ensureDaemonAvailable(paths, ensure, signal) {
+  if (!signal)
+    return ensure(paths);
+  return new Promise((resolve9, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(new DaemonRequestCancelledError(false)));
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    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)}.`,
@@ -5680,7 +5824,7 @@ function daemonUnreachableResult(paths, error) {
 }
 function sendToolCall(paths, token, name, args, options) {
   return new Promise((resolve9, reject) => {
-    const socket = connect2(paths.socket);
+    const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
     let requestWritten = false;

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

@@ -1,5 +1,5 @@
-import type { ToolExecutionResult } from "@oh-my-opencode/lsp-core/tools";
 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;
@@ -17,7 +17,7 @@ export interface CallToolOptions {
     paths?: DaemonPaths;
     requestTimeoutMs?: number;
     signal?: AbortSignal;
-    ensure?: (paths: DaemonPaths) => Promise<void>;
+    ensure?: (paths: DaemonPaths, signal?: AbortSignal) => Promise<void>;
 }
 export declare function callToolViaDaemon(name: string, args: Record<string, unknown>, options: CallToolOptions): Promise<ToolExecutionResult>;
 export declare function callDiagnosticsViaDaemon(filePath: string, options: CallToolOptions): Promise<ToolExecutionResult>;

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

@@ -32,14 +32,15 @@ export class DaemonRequestCancelledError extends DaemonRequestError {
 export async function callToolViaDaemon(name, args, options) {
     const context = requireContext(options.context);
     const paths = options.paths ?? daemonPaths();
-    const ensure = options.ensure ?? ensureDaemonRunning;
+    const ensure = options.ensure ??
+        ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
     const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     const requestArgs = withContext(args, context);
     let lastError;
     let authRefreshUsed = false;
     for (let attempt = 0; attempt < 3; attempt += 1) {
         try {
-            await ensure(paths);
+            await ensureDaemonAvailable(paths, ensure, options.signal);
             const token = readAuthToken(paths);
             if (!token)
                 throw new DaemonRequestError("daemon auth token missing", false);
@@ -82,6 +83,29 @@ function requireContext(context) {
 function withContext(args, context) {
     return { ...args, [CONTEXT_KEY]: context };
 }
+function ensureDaemonAvailable(paths, ensure, signal) {
+    if (!signal)
+        return ensure(paths);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (run) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            run();
+        };
+        const onAbort = () => finish(() => reject(new DaemonRequestCancelledError(false)));
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        Promise.resolve()
+            .then(() => ensure(paths, signal))
+            .then(() => finish(() => resolve()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+    });
+}
 function daemonUnreachableResult(paths, error) {
     const text = [
         `LSP daemon unreachable: ${errorText(error)}.`,

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

@@ -6,18 +6,19 @@ export declare class DaemonUnreachableError extends Error {
     constructor(socketPath: string);
 }
 export interface EnsureDaemonDeps {
-    probe(paths: DaemonPaths): Promise<boolean>;
+    probe(paths: DaemonPaths, signal?: AbortSignal): Promise<boolean>;
     spawnDaemon(paths: DaemonPaths): void;
-    sleep(ms: number): Promise<void>;
+    sleep(ms: number, signal?: AbortSignal): Promise<void>;
     now(): number;
 }
 export interface EnsureDaemonOptions {
     readyTimeoutMs?: number;
     pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
 }
 export declare function ensureDaemonRunning(paths: DaemonPaths, deps?: EnsureDaemonDeps, options?: EnsureDaemonOptions): Promise<void>;
-export declare function probeDaemon(paths: DaemonPaths, timeoutMs?: number): Promise<boolean>;
-export declare function pingDaemon(paths: DaemonPaths, token: string, timeoutMs?: number): Promise<OwnerPing | null>;
+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 resolveDaemonCliPath(env?: NodeJS.ProcessEnv, defaults?: DaemonRuntimeDefaults): string;
 export declare function defaultEnsureDaemonDeps(): EnsureDaemonDeps;

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

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { closeSync, mkdirSync, openSync } from "node:fs";
-import { connect } from "node:net";
+import { Socket } from "node:net";
 import { dirname } from "node:path";
 import { execPath } from "node:process";
 import { authEnvelope, readAuthToken } from "./ipc-protocol.js";
@@ -20,42 +20,48 @@ export class DaemonUnreachableError extends Error {
 export async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
     const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
     const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    if (await deps.probe(paths))
+    const signal = options.signal;
+    throwIfAborted(signal);
+    if (await awaitWithSignal(deps.probe(paths, signal), signal))
         return;
+    throwIfAborted(signal);
     deps.spawnDaemon(paths);
-    await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs);
+    await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
 }
-async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs) {
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
     const deadline = deps.now() + readyTimeoutMs;
     for (;;) {
-        if (await deps.probe(paths))
+        throwIfAborted(signal);
+        if (await awaitWithSignal(deps.probe(paths, signal), signal))
             return;
         if (deps.now() >= deadline)
             throw new DaemonUnreachableError(paths.socket);
-        await deps.sleep(pollIntervalMs);
+        await awaitWithSignal(deps.sleep(pollIntervalMs, signal), signal);
     }
 }
-export async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS) {
+export async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
     const token = readAuthToken(paths);
     if (!token)
         return false;
-    return (await pingDaemon(paths, token, timeoutMs)) !== null;
+    return (await pingDaemon(paths, token, timeoutMs, signal)) !== null;
 }
-export function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
+export function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
     return new Promise((resolve) => {
-        const socket = connect(paths.socket);
+        const socket = new Socket();
         let settled = false;
+        let timer;
         const finish = (value) => {
             if (settled)
                 return;
             settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
             socket.destroy();
             resolve(value);
         };
-        const timer = setTimeout(() => finish(null), timeoutMs);
-        timer.unref?.();
+        const onAbort = () => finish(null);
         const decoder = createLineDecoder((message) => {
-            clearTimeout(timer);
             finish(parsePingResponse(message));
         });
         socket.once("connect", () => {
@@ -63,9 +69,16 @@ export function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
         });
         socket.on("data", (chunk) => decoder.push(chunk));
         socket.once("error", () => {
-            clearTimeout(timer);
             finish(null);
         });
+        timer = setTimeout(() => finish(null), timeoutMs);
+        timer.unref?.();
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        signal?.addEventListener("abort", onAbort, { once: true });
+        socket.connect(paths.socket);
     });
 }
 export function spawnDaemonProcess(paths) {
@@ -87,14 +100,62 @@ export function resolveDaemonCliPath(env = process.env, defaults = packagedRunti
 }
 export function defaultEnsureDaemonDeps() {
     return {
-        probe: (paths) => probeDaemon(paths),
+        probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
         spawnDaemon: (paths) => spawnDaemonProcess(paths),
-        sleep: (ms) => new Promise((resolve) => {
-            setTimeout(resolve, ms);
-        }),
+        sleep: (ms, signal) => sleepWithSignal(ms, signal),
         now: () => Date.now(),
     };
 }
+function sleepWithSignal(ms, signal) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, ms);
+        if (signal?.aborted) {
+            finish();
+            return;
+        }
+        signal?.addEventListener("abort", finish, { once: true });
+    });
+}
+function awaitWithSignal(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortError(signal));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (run) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            run();
+        };
+        const onAbort = () => finish(() => reject(abortError(signal)));
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError(signal);
+}
+function abortError(signal) {
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    const error = new Error(typeof reason === "string" ? reason : "daemon startup cancelled");
+    error.name = "AbortError";
+    return error;
+}
 function parsePingResponse(message) {
     if (!message || typeof message !== "object" || Array.isArray(message))
         return null;