oh-my-opencode 4.18.0 → 4.18.2

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

@@ -1,19 +1,24 @@
+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 interface DaemonToolContext {
-    cwd?: string;
-    env?: Record<string, string>;
+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;
+    context: DaemonToolContext;
     paths?: DaemonPaths;
     requestTimeoutMs?: number;
-    ensure?: (paths: DaemonPaths) => Promise<void>;
+    signal?: AbortSignal;
+    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>;
+export declare function callToolViaDaemon(name: string, args: Record<string, unknown>, options: CallToolOptions): Promise<ToolExecutionResult>;
+export declare function callDiagnosticsViaDaemon(filePath: string, options: CallToolOptions): Promise<ToolExecutionResult>;
 export declare function currentRequestContext(env?: NodeJS.ProcessEnv): DaemonToolContext;

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

@@ -1,11 +1,15 @@
 import { connect } from "node:net";
+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 { ensureDaemonRunning } from "./ensure-daemon.js";
+import { authEnvelope, isAuthErrorResponse, readAuthToken } from "./ipc-protocol.js";
 import { daemonPaths } from "./paths.js";
 import { CONTEXT_KEY } from "./request-routing.js";
 import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
-const REQUEST_ID = 1;
+let nextProxyRequestId = 1;
 export class DaemonRequestError extends Error {
     constructor(message, requestWritten) {
         super(message);
@@ -13,47 +17,95 @@ export class DaemonRequestError extends Error {
         this.requestWritten = requestWritten;
     }
 }
-export async function callToolViaDaemon(name, args, options = {}) {
+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();
-    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, options.context);
+    const requestArgs = withContext(args, context);
     let lastError;
-    for (let attempt = 0; attempt < 2; attempt += 1) {
+    let authRefreshUsed = false;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
         try {
-            await ensure(paths);
-            return await sendToolCall(paths.socket, name, requestArgs, timeoutMs);
+            await ensureDaemonAvailable(paths, ensure, options.signal);
+            const token = readAuthToken(paths);
+            if (!token)
+                throw new DaemonRequestError("daemon auth token missing", false);
+            const sendOptions = options.signal === undefined ? { timeoutMs } : { timeoutMs, signal: options.signal };
+            return await sendToolCall(paths, token, name, requestArgs, sendOptions);
         }
         catch (error) {
             lastError = error;
-            if (error instanceof DaemonRequestError && error.requestWritten)
+            if (error instanceof DaemonAuthenticationRejectedError && !authRefreshUsed) {
+                authRefreshUsed = true;
+                continue;
+            }
+            if (error instanceof DaemonRequestCancelledError)
+                break;
+            if (error instanceof DaemonRequestError && (error.requestWritten || !isRetryableTool(name)))
                 break;
         }
     }
     return daemonUnreachableResult(paths, lastError);
 }
-export function callDiagnosticsViaDaemon(filePath, options = {}) {
+export function callDiagnosticsViaDaemon(filePath, options) {
     return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
 }
-const FORWARDED_ENV_KEYS = [
-    "LSP_TOOLS_MCP_PROJECT_CONFIG",
-    "LSP_TOOLS_MCP_USER_CONFIG",
-    "LSP_TOOLS_MCP_INSTALL_DECISIONS",
-];
 export function currentRequestContext(env = process.env) {
-    const forwarded = {};
-    for (const key of FORWARDED_ENV_KEYS) {
-        const value = env[key];
-        if (value !== undefined)
-            forwarded[key] = value;
-    }
-    return { cwd: process.cwd(), env: forwarded };
+    const cwd = process.cwd();
+    const home = env["HOME"] ?? homedir();
+    return parseLspRequestContext({
+        cwd,
+        projectConfigPaths: [join(cwd, ".codex", "lsp-client.json")],
+        userConfigPath: join(home, ".codex", "lsp-client.json"),
+        installDecisionsPath: join(home, ".codex", "lsp-install-decisions.json"),
+        capabilities: { installDecisionTool: true },
+    });
+}
+function requireContext(context) {
+    if (!context)
+        throw new DaemonRequestError("daemon tool context is required", false);
+    return parseLspRequestContext(context);
 }
 function withContext(args, context) {
-    if (!context || (context.cwd === undefined && context.env === undefined))
-        return args;
     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)}.`,
@@ -64,39 +116,84 @@ function daemonUnreachableResult(paths, error) {
     ].join("\n");
     return { content: [{ type: "text", text }], isError: true };
 }
-function sendToolCall(socketPath, name, args, timeoutMs) {
+function sendToolCall(paths, token, name, args, options) {
     return new Promise((resolve, reject) => {
-        const socket = connect(socketPath);
+        const socket = connect(paths.socket);
+        const requestId = allocateProxyRequestId();
         let settled = false;
         let requestWritten = false;
+        let cancelAfterWrite = false;
+        const cancelPayload = () => encodeJsonLine({
+            jsonrpc: "2.0",
+            method: "$/cancelRequest",
+            params: { _omo: authEnvelope(token), id: requestId },
+        });
         const finish = (run) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
-            socket.destroy();
+            options.signal?.removeEventListener("abort", onAbort);
+            destroyAfterCancel();
             run();
         };
-        const timer = setTimeout(() => finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten))), timeoutMs);
+        const sendCancel = () => {
+            if (!requestWritten) {
+                cancelAfterWrite = true;
+                return;
+            }
+            if (!socket.writable)
+                return;
+            socket.write(cancelPayload());
+        };
+        const destroyAfterCancel = () => {
+            socket.destroy();
+        };
+        const onAbort = () => {
+            sendCancel();
+            finish(() => reject(new DaemonRequestCancelledError(requestWritten)));
+        };
+        const timer = setTimeout(() => {
+            sendCancel();
+            finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten)));
+        }, options.timeoutMs);
         timer.unref();
+        if (options.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        options.signal?.addEventListener("abort", onAbort, { once: true });
         const decoder = createLineDecoder((message) => {
-            const result = toToolResult(message);
+            if (isAuthErrorResponse(message)) {
+                finish(() => reject(new DaemonAuthenticationRejectedError()));
+                return;
+            }
+            const result = toToolResult(message, requestId);
             if (result)
                 finish(() => resolve(result));
             else
                 finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
         });
         socket.once("connect", () => {
-            requestWritten = true;
-            socket.write(encodeJsonLine({ jsonrpc: "2.0", id: REQUEST_ID, method: "tools/call", params: { name, arguments: args } }));
+            const payload = encodeJsonLine({
+                jsonrpc: "2.0",
+                id: requestId,
+                method: "tools/call",
+                params: { _omo: authEnvelope(token), name, arguments: args },
+            });
+            socket.write(payload, () => {
+                requestWritten = true;
+                if (cancelAfterWrite && socket.writable)
+                    socket.write(cancelPayload());
+            });
         });
         socket.on("data", (chunk) => decoder.push(chunk));
         socket.once("error", (error) => finish(() => reject(new DaemonRequestError(error.message, requestWritten))));
         socket.once("close", () => finish(() => reject(new DaemonRequestError("daemon connection closed", requestWritten))));
     });
 }
-function toToolResult(message) {
-    if (!isPlainRecord(message) || message["id"] !== REQUEST_ID)
+function toToolResult(message, requestId) {
+    if (!isPlainRecord(message) || message["id"] !== requestId)
         return null;
     const result = message["result"];
     if (!isPlainRecord(result) || !Array.isArray(result["content"]))
@@ -107,6 +204,16 @@ function toToolResult(message) {
         details: result["details"],
     };
 }
+function allocateProxyRequestId() {
+    const id = nextProxyRequestId;
+    nextProxyRequestId += 1;
+    if (nextProxyRequestId > Number.MAX_SAFE_INTEGER)
+        nextProxyRequestId = 1;
+    return id;
+}
+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-server.d.ts

@@ -1,5 +1,6 @@
 import { type Server } from "node:net";
 import type { DaemonPaths } from "./paths.js";
+export { DaemonAlreadyRunningError, DaemonStartupDeferredError } from "./ownership.js";
 export interface DaemonServerOptions {
     idleShutdownMs?: number;
     idleCheckIntervalMs?: number;

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

@@ -1,41 +1,58 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { chmodSync } from "node:fs";
 import { createServer } from "node:net";
-import { join } from "node:path";
 import { disposeDefaultLspManager, getLspManager } from "@oh-my-opencode/lsp-core/lsp/manager";
-import { unlinkQuietly } from "./lock.js";
+import { setPrivateFileMode } from "./ipc-protocol.js";
+import { pingDaemon } from "./ensure-daemon.js";
+import { acquireStartupLease, DaemonStartupDeferredError, endpointIdentity, removeDaemonMetadataForOwner, writeDaemonOwner, } from "./ownership.js";
 import { handleDaemonMessage } from "./request-routing.js";
 import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
+export { DaemonAlreadyRunningError, DaemonStartupDeferredError } from "./ownership.js";
 const DEFAULT_IDLE_SHUTDOWN_MS = 30 * 60_000;
 const DEFAULT_IDLE_CHECK_INTERVAL_MS = 60_000;
 export async function startDaemonServer(paths, options = {}) {
     const idleShutdownMs = options.idleShutdownMs ?? DEFAULT_IDLE_SHUTDOWN_MS;
     const idleCheckIntervalMs = options.idleCheckIntervalMs ?? DEFAULT_IDLE_CHECK_INTERVAL_MS;
-    mkdirSync(paths.dir, { recursive: true });
-    unlinkQuietly(paths.socket);
+    const lease = await acquireStartupLease(paths, (token) => pingDaemon(paths, token));
     const connections = new Set();
     let lastActiveAt = Date.now();
     const touch = () => {
         lastActiveAt = Date.now();
     };
+    let routeOwner = lease.owner;
     const server = createServer((socket) => {
         connections.add(socket);
+        const activeRequests = new Map();
         touch();
         const decoder = createLineDecoder((message) => {
             touch();
-            void respond(socket, message);
+            void respond(socket, message, lease.token, routeOwner, activeRequests);
         });
         socket.on("data", (chunk) => decoder.push(chunk));
         socket.on("error", () => socket.destroy());
         socket.on("close", () => {
+            for (const controller of activeRequests.values())
+                controller.abort();
+            activeRequests.clear();
             connections.delete(socket);
             touch();
         });
     });
     server.on("error", (error) => logServerError(error));
-    const endpointPath = join(paths.dir, "daemon.endpoint");
-    await listen(server, paths.socket);
-    writeFileSync(paths.pid, `${process.pid}\n`);
-    writeFileSync(endpointPath, paths.socket);
+    let owner;
+    try {
+        await listen(server, paths.socket);
+        if (process.platform !== "win32")
+            chmodSync(paths.socket, 0o600);
+        owner = { ...lease.owner, endpoint: endpointIdentity(paths.socket) };
+        routeOwner = owner;
+        writeDaemonOwner(paths, owner);
+        await assertSelfProbe(paths, lease.token, owner);
+    }
+    catch (error) {
+        lease.lock.release();
+        throw error;
+    }
+    lease.lock.release();
     let closed = false;
     const close = async () => {
         if (closed)
@@ -46,9 +63,7 @@ export async function startDaemonServer(paths, options = {}) {
             socket.destroy();
         connections.clear();
         await closeServer(server);
-        unlinkQuietly(paths.socket);
-        unlinkQuietly(paths.pid);
-        unlinkQuietly(endpointPath);
+        removeDaemonMetadataForOwner(paths, owner);
         await disposeDefaultLspManager();
     };
     const idleTimer = setInterval(() => {
@@ -70,16 +85,26 @@ export async function startDaemonServer(paths, options = {}) {
     installSignalHandlers(close);
     return { server, close };
 }
-async function respond(socket, message) {
+async function respond(socket, message, token, owner, activeRequests) {
     try {
-        const response = await handleDaemonMessage(message);
+        const response = await handleDaemonMessage(message, { token, owner, activeRequests });
         if (response && socket.writable)
             socket.write(encodeJsonLine(response));
     }
     catch (error) {
+        if (!(error instanceof Error))
+            throw error;
         logServerError(error);
     }
 }
+async function assertSelfProbe(paths, token, owner) {
+    setPrivateFileMode(paths.pid);
+    setPrivateFileMode(paths.endpoint);
+    setPrivateFileMode(paths.owner);
+    const ping = await pingDaemon(paths, token);
+    if (!ping || ping.nonce !== owner.nonce)
+        throw new DaemonStartupDeferredError("self_probe_failed");
+}
 function listen(server, socketPath) {
     return new Promise((resolve, reject) => {
         const onError = (error) => reject(error);

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

@@ -1,22 +1,24 @@
-import { type LockHandle } from "./lock.js";
-import type { DaemonPaths } from "./paths.js";
+import type { OwnerPing } from "./ownership.js";
+import { type DaemonPaths } from "./paths.js";
+import { type DaemonRuntimeDefaults } from "./runtime-contract.js";
+export { InvalidRuntimeOverrideError, OMO_LSP_DAEMON_CLI, resolveDaemonRuntime } from "./runtime-contract.js";
 export declare class DaemonUnreachableError extends Error {
     constructor(socketPath: string);
 }
 export interface EnsureDaemonDeps {
-    probe(socketPath: string): Promise<boolean>;
-    acquireLock(lockPath: string): LockHandle | null;
-    cleanupStaleSocket(socketPath: string): void;
+    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 probeSocket(socketPath: string, timeoutMs?: number): Promise<boolean>;
+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): 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,14 +1,16 @@
 import { spawn } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
-import { connect } from "node:net";
+import { closeSync, mkdirSync, openSync } from "node:fs";
+import { Socket } from "node:net";
 import { dirname } from "node:path";
 import { execPath } from "node:process";
-import { fileURLToPath } from "node:url";
-import { tryAcquireLock, unlinkQuietly } from "./lock.js";
+import { authEnvelope, readAuthToken } from "./ipc-protocol.js";
+import { packagedRuntimeDefaults } from "./paths.js";
+import { resolveDaemonRuntime } from "./runtime-contract.js";
+import { createLineDecoder, encodeJsonLine } from "./socket-jsonrpc.js";
+export { InvalidRuntimeOverrideError, OMO_LSP_DAEMON_CLI, resolveDaemonRuntime } from "./runtime-contract.js";
 const PROBE_TIMEOUT_MS = 500;
 const DEFAULT_READY_TIMEOUT_MS = 5_000;
 const DEFAULT_POLL_INTERVAL_MS = 100;
-const CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
 export class DaemonUnreachableError extends Error {
     constructor(socketPath) {
         super(`LSP daemon did not become reachable at ${socketPath}`);
@@ -18,59 +20,72 @@ 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.socket))
+    const signal = options.signal;
+    throwIfAborted(signal);
+    if (await awaitWithSignal(deps.probe(paths, signal), signal))
         return;
-    const lock = deps.acquireLock(paths.lock);
-    if (!lock) {
-        await waitUntilReachable(paths.socket, deps, readyTimeoutMs, pollIntervalMs);
-        return;
-    }
-    try {
-        if (await deps.probe(paths.socket))
-            return;
-        deps.cleanupStaleSocket(paths.socket);
-        deps.spawnDaemon(paths);
-        await waitUntilReachable(paths.socket, deps, readyTimeoutMs, pollIntervalMs);
-    }
-    finally {
-        lock.release();
-    }
+    throwIfAborted(signal);
+    deps.spawnDaemon(paths);
+    await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
 }
-async function waitUntilReachable(socketPath, deps, readyTimeoutMs, pollIntervalMs) {
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
     const deadline = deps.now() + readyTimeoutMs;
     for (;;) {
-        if (await deps.probe(socketPath))
+        throwIfAborted(signal);
+        if (await awaitWithSignal(deps.probe(paths, signal), signal))
             return;
         if (deps.now() >= deadline)
-            throw new DaemonUnreachableError(socketPath);
-        await deps.sleep(pollIntervalMs);
+            throw new DaemonUnreachableError(paths.socket);
+        await awaitWithSignal(deps.sleep(pollIntervalMs, signal), signal);
     }
 }
-export function probeSocket(socketPath, 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, signal)) !== null;
+}
+export function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
     return new Promise((resolve) => {
-        const socket = connect(socketPath);
-        const finish = (ok) => {
+        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(ok);
+            resolve(value);
         };
-        const timer = setTimeout(() => finish(false), timeoutMs);
-        timer.unref?.();
+        const onAbort = () => finish(null);
+        const decoder = createLineDecoder((message) => {
+            finish(parsePingResponse(message));
+        });
         socket.once("connect", () => {
-            clearTimeout(timer);
-            finish(true);
+            socket.write(encodeJsonLine({ jsonrpc: "2.0", id: 1, method: "omo/ping", params: { _omo: authEnvelope(token) } }));
         });
+        socket.on("data", (chunk) => decoder.push(chunk));
         socket.once("error", () => {
-            clearTimeout(timer);
-            finish(false);
+            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) {
     mkdirSync(dirname(paths.log), { recursive: true });
     const logFd = openSync(paths.log, "a");
     try {
-        const cliPath = resolveDaemonCliPath();
-        const child = spawn(execPath, [cliPath, "daemon"], {
+        const child = spawn(execPath, [paths.cliPath, "daemon"], {
             detached: true,
             stdio: ["ignore", logFd, logFd],
         });
@@ -80,24 +95,93 @@ export function spawnDaemonProcess(paths) {
         closeSync(logFd);
     }
 }
-export function resolveDaemonCliPath(env = process.env) {
-    const override = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
-    if (override)
-        return override;
-    return fileURLToPath(new URL("./cli.js", import.meta.url));
+export function resolveDaemonCliPath(env = process.env, defaults = packagedRuntimeDefaults()) {
+    return resolveDaemonRuntime(env, defaults).cliPath;
 }
 export function defaultEnsureDaemonDeps() {
     return {
-        probe: (socketPath) => probeSocket(socketPath),
-        acquireLock: (lockPath) => tryAcquireLock(lockPath),
-        cleanupStaleSocket: (socketPath) => {
-            if (existsSync(socketPath))
-                unlinkQuietly(socketPath);
-        },
+        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;
+    const result = Reflect.get(message, "result");
+    if (!result || typeof result !== "object" || Array.isArray(result))
+        return null;
+    const pid = Reflect.get(result, "pid");
+    const nonce = Reflect.get(result, "nonce");
+    const startedAt = Reflect.get(result, "startedAt");
+    const endpoint = Reflect.get(result, "endpoint");
+    if (typeof pid !== "number" || typeof nonce !== "string" || typeof startedAt !== "string")
+        return null;
+    if (!endpoint || typeof endpoint !== "object" || Array.isArray(endpoint))
+        return null;
+    const path = Reflect.get(endpoint, "path");
+    const kind = Reflect.get(endpoint, "kind");
+    if (typeof path !== "string")
+        return null;
+    if (kind === "windows")
+        return { pid, nonce, startedAt, endpoint: { kind, path } };
+    if (kind === "missing")
+        return { pid, nonce, startedAt, endpoint: { kind, path } };
+    const dev = Reflect.get(endpoint, "dev");
+    const ino = Reflect.get(endpoint, "ino");
+    if (kind === "unix" && typeof dev === "number" && typeof ino === "number") {
+        return { pid, nonce, startedAt, endpoint: { kind, path, dev, ino } };
+    }
+    return null;
+}