@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

package/dist/devbox/commands/provider/directDaemonRuntime.js

@@ -1,1442 +0,0 @@
-import { randomUUID } from "node:crypto";
-import WebSocket from "ws";
-import { buildControlAuthMessage, CONTROL_TTY_REPLACED_CLOSE_CODE, CONTROL_TTY_REPLACED_ERROR_CODE, createLogger, findMissingTtyControlCapabilities, parseControlReadyMessage, TTY_CONTROL_PROTOCOL_VERSION, } from "@boxes-dev/core";
-import { parseDaemonControlError, parseDaemonJsonRecord, } from "./daemonRuntimeShared.js";
-const DIRECT_DAEMON_CONTROL_WS_PATH = "/ws";
-const MANAGED_DAEMON_CONNECT_TOKEN_QUERY = "_modal_connect_token";
-const DIRECT_DAEMON_CONTROL_IDLE_MS = 15 * 60 * 1000;
-const DIRECT_DAEMON_CONTROL_CONNECT_TIMEOUT_PADDING_MS = 10_000;
-const DIRECT_DAEMON_CONTROL_CONNECT_TIMEOUT_MIN_MS = 25_000;
-const DIRECT_DAEMON_CONTROL_CONNECT_TIMEOUT_MAX_MS = 120_000;
-const DIRECT_DAEMON_CONTROL_CONNECT_RETRY_INITIAL_DELAY_MS = 250;
-const DIRECT_DAEMON_CONTROL_CONNECT_RETRY_MAX_DELAY_MS = 2_000;
-const DIRECT_DAEMON_CONTROL_PING_INTERVAL_MS = 20_000;
-const DIRECT_DAEMON_CONTROL_PONG_GRACE_MS = 45_000;
-const DIRECT_DAEMON_REQUEST_TRANSPORT_RETRY_LIMIT = 1;
-const logger = createLogger("direct_daemon_runtime");
-const DEFAULT_DIRECT_DAEMON_CONTROL_TIMING = {
-    idleMs: DIRECT_DAEMON_CONTROL_IDLE_MS,
-    connectTimeoutPaddingMs: DIRECT_DAEMON_CONTROL_CONNECT_TIMEOUT_PADDING_MS,
-    connectTimeoutMinMs: DIRECT_DAEMON_CONTROL_CONNECT_TIMEOUT_MIN_MS,
-    connectTimeoutMaxMs: DIRECT_DAEMON_CONTROL_CONNECT_TIMEOUT_MAX_MS,
-    connectRetryInitialDelayMs: DIRECT_DAEMON_CONTROL_CONNECT_RETRY_INITIAL_DELAY_MS,
-    connectRetryMaxDelayMs: DIRECT_DAEMON_CONTROL_CONNECT_RETRY_MAX_DELAY_MS,
-    pingIntervalMs: DIRECT_DAEMON_CONTROL_PING_INTERVAL_MS,
-    pongGraceMs: DIRECT_DAEMON_CONTROL_PONG_GRACE_MS,
-};
-let directDaemonControlTimingOverrides = null;
-const formatProviderLabel = (provider) => provider === "e2b" ? "E2B" : "Modal";
-const resolveDirectDaemonRequestType = (requestPayload) => typeof requestPayload.type === "string" ? requestPayload.type : "unknown";
-const DIRECT_DAEMON_REPLAY_SAFE_REQUEST_TYPES = new Set([
-    "fs_read",
-    "services_list",
-    "service_get",
-    "sessions_list",
-]);
-const isDirectDaemonReplaySafeRequest = (requestPayload) => DIRECT_DAEMON_REPLAY_SAFE_REQUEST_TYPES.has(resolveDirectDaemonRequestType(requestPayload));
-const buildDirectDaemonWsUrl = (connectInfo) => {
-    const url = new URL(connectInfo.url);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    url.pathname = DIRECT_DAEMON_CONTROL_WS_PATH;
-    url.search = "";
-    if (connectInfo.provider === "modal") {
-        url.searchParams.set(MANAGED_DAEMON_CONNECT_TOKEN_QUERY, connectInfo.connectToken);
-    }
-    return url.toString();
-};
-const buildDirectDaemonAuthPayload = (connectInfo) => buildControlAuthMessage(connectInfo.provider === "e2b" ? connectInfo.authToken : undefined);
-const buildDirectDaemonRequestContext = (args) => {
-    const requestType = resolveDirectDaemonRequestType(args.requestPayload);
-    const wsUrl = new URL(buildDirectDaemonWsUrl(args.connectInfo));
-    const parts = [
-        `alias=${args.alias}`,
-        `request=${requestType}`,
-        `expected=${args.expectedType}`,
-        `ws=${wsUrl.origin}${wsUrl.pathname}`,
-    ];
-    if (typeof args.requestPayload.path === "string") {
-        parts.push(`path=${args.requestPayload.path}`);
-    }
-    if (typeof args.requestPayload.serviceName === "string") {
-        parts.push(`service=${args.requestPayload.serviceName}`);
-    }
-    if (typeof args.requestPayload.sessionId === "string") {
-        parts.push(`session=${args.requestPayload.sessionId}`);
-    }
-    return `${formatProviderLabel(args.provider)} control request failed (${parts.join(", ")})`;
-};
-const isDirectDaemonAuthRefreshError = (provider, error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    if (provider === "e2b") {
-        return (message.includes("Auth token is required.") ||
-            message.includes("invalid auth token"));
-    }
-    return /Unexpected server response: (401|403)/.test(message);
-};
-const buildDirectDaemonControlErrorText = (provider, message) => {
-    const { text } = parseDaemonControlError(message, `${formatProviderLabel(provider)} daemon control request failed.`);
-    return text;
-};
-const buildDirectDaemonWsLogFields = (connectInfo) => {
-    if (!connectInfo) {
-        return {};
-    }
-    const wsUrl = new URL(buildDirectDaemonWsUrl(connectInfo));
-    return {
-        wsOrigin: wsUrl.origin,
-        wsPath: wsUrl.pathname,
-    };
-};
-const buildDirectDaemonRequestLogFields = (requestPayload) => ({
-    requestType: resolveDirectDaemonRequestType(requestPayload),
-    ...(typeof requestPayload.path === "string"
-        ? { path: requestPayload.path }
-        : {}),
-    ...(typeof requestPayload.serviceName === "string"
-        ? { serviceName: requestPayload.serviceName }
-        : {}),
-    ...(typeof requestPayload.sessionId === "string"
-        ? { sessionId: requestPayload.sessionId }
-        : {}),
-});
-const buildDirectDaemonOperationLogFields = (args) => ({
-    alias: args.alias,
-    provider: args.provider,
-    operationId: args.operationId,
-    attempt: args.attempt,
-    expectedType: args.expectedType,
-    ...buildDirectDaemonRequestLogFields(args.requestPayload),
-});
-const formatDirectDaemonWebSocketState = (ws) => {
-    if (!ws) {
-        return "none";
-    }
-    switch (ws.readyState) {
-        case WebSocket.CONNECTING:
-            return "connecting";
-        case WebSocket.OPEN:
-            return "open";
-        case WebSocket.CLOSING:
-            return "closing";
-        case WebSocket.CLOSED:
-            return "closed";
-        default:
-            return `unknown:${String(ws.readyState)}`;
-    }
-};
-const measureDirectDaemonRawMessageBytes = (raw) => {
-    if (typeof raw === "string") {
-        return Buffer.byteLength(raw);
-    }
-    if (raw instanceof ArrayBuffer) {
-        return raw.byteLength;
-    }
-    if (Array.isArray(raw)) {
-        return raw.reduce((total, chunk) => total + chunk.length, 0);
-    }
-    if (ArrayBuffer.isView(raw)) {
-        return raw.byteLength;
-    }
-    return null;
-};
-const refDirectDaemonWebSocket = (ws) => {
-    const socket = ws._socket;
-    socket?.ref?.();
-};
-const unrefDirectDaemonWebSocket = (ws) => {
-    const socket = ws._socket;
-    socket?.unref?.();
-};
-const getDirectDaemonControlTiming = () => ({
-    ...DEFAULT_DIRECT_DAEMON_CONTROL_TIMING,
-    ...(directDaemonControlTimingOverrides ?? {}),
-});
-const setDirectDaemonControlTimingForTests = (overrides) => {
-    directDaemonControlTimingOverrides = overrides;
-};
-const sleep = async (ms) => {
-    await new Promise((resolve) => {
-        // Foreground request retries must keep the process alive until the next
-        // connect attempt runs, otherwise Node can exit cleanly while the caller
-        // is still awaiting the request promise.
-        setTimeout(resolve, ms);
-    });
-};
-const resolveDirectDaemonConnectTimeoutMs = (requestTimeoutMs) => {
-    const timing = getDirectDaemonControlTiming();
-    const baseTimeoutMs = Number.isFinite(requestTimeoutMs)
-        ? Math.max(0, Math.ceil(requestTimeoutMs))
-        : 0;
-    return Math.min(Math.max(baseTimeoutMs + timing.connectTimeoutPaddingMs, timing.connectTimeoutMinMs), timing.connectTimeoutMaxMs);
-};
-const createDirectDaemonTransportError = (args) => {
-    const error = new Error(args.message);
-    error.directDaemonTransport = true;
-    error.transportCode = args.transportCode;
-    error.retryable = args.retryable;
-    error.provider = args.provider;
-    error.alias = args.alias;
-    if (args.cause !== undefined) {
-        error.cause = args.cause;
-    }
-    return error;
-};
-const isDirectDaemonTransportError = (error) => Boolean(error &&
-    typeof error === "object" &&
-    "directDaemonTransport" in error &&
-    error.directDaemonTransport ===
-        true);
-const wrapDirectDaemonRequestError = (context, error) => {
-    if (isDirectDaemonTransportError(error)) {
-        return createDirectDaemonTransportError({
-            provider: error.provider,
-            alias: error.alias,
-            transportCode: error.transportCode,
-            retryable: error.retryable,
-            message: `${context}: ${error.message}`,
-            cause: error,
-        });
-    }
-    const detail = error instanceof Error ? error.message : String(error);
-    const wrapped = new Error(`${context}: ${detail}`);
-    wrapped.cause = error;
-    return wrapped;
-};
-const validateDirectDaemonControlReadyMessage = (args) => {
-    const ready = parseControlReadyMessage(args.message);
-    const providerLabel = formatProviderLabel(args.provider);
-    if (!ready) {
-        throw createDirectDaemonTransportError({
-            provider: args.provider,
-            alias: args.alias,
-            transportCode: "invalid_handshake",
-            retryable: false,
-            message: `${providerLabel} control handshake is missing protocol metadata.`,
-        });
-    }
-    if (ready.protocolVersion !== TTY_CONTROL_PROTOCOL_VERSION) {
-        throw createDirectDaemonTransportError({
-            provider: args.provider,
-            alias: args.alias,
-            transportCode: "protocol_version_mismatch",
-            retryable: false,
-            message: `Unsupported ${providerLabel} control protocol version ${String(ready.protocolVersion)} (expected ${String(TTY_CONTROL_PROTOCOL_VERSION)}).`,
-        });
-    }
-    const missingCapabilities = findMissingTtyControlCapabilities(ready.capabilities);
-    if (missingCapabilities.length > 0) {
-        throw createDirectDaemonTransportError({
-            provider: args.provider,
-            alias: args.alias,
-            transportCode: "missing_capabilities",
-            retryable: false,
-            message: `${providerLabel} control handshake is missing capabilities: ${missingCapabilities.join(", ")}.`,
-        });
-    }
-    return ready;
-};
-class DirectDaemonControlSocket {
-    provider;
-    resolveConnectInfo;
-    alias;
-    onDispose;
-    ws = null;
-    connectInfo = null;
-    authenticated = false;
-    connecting = null;
-    idleTimer = null;
-    pingInterval = null;
-    lastPongAt = 0;
-    controlProtocolVersion = null;
-    controlCapabilities = new Set();
-    reconnecting = false;
-    disposed = false;
-    pendingRequests = new Map();
-    constructor(provider, resolveConnectInfo, alias, onDispose) {
-        this.provider = provider;
-        this.resolveConnectInfo = resolveConnectInfo;
-        this.alias = alias;
-        this.onDispose = onDispose;
-    }
-    buildLogFields(extra = {}) {
-        return {
-            provider: this.provider,
-            alias: this.alias,
-            authenticated: this.authenticated,
-            pendingCount: this.pendingRequests.size,
-            wsState: formatDirectDaemonWebSocketState(this.ws),
-            reconnecting: this.reconnecting,
-            protocolVersion: this.controlProtocolVersion,
-            capabilities: [...this.controlCapabilities],
-            ...buildDirectDaemonWsLogFields(this.connectInfo),
-            ...extra,
-        };
-    }
-    clearIdleTimer() {
-        if (!this.idleTimer) {
-            return;
-        }
-        clearTimeout(this.idleTimer);
-        this.idleTimer = null;
-    }
-    scheduleIdleClose() {
-        if (this.pendingRequests.size > 0 || this.disposed) {
-            return;
-        }
-        this.clearIdleTimer();
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            unrefDirectDaemonWebSocket(this.ws);
-        }
-        const { idleMs } = getDirectDaemonControlTiming();
-        this.idleTimer = setTimeout(() => {
-            this.dispose();
-        }, idleMs);
-        this.idleTimer.unref();
-    }
-    stopKeepalive() {
-        if (!this.pingInterval) {
-            return;
-        }
-        clearInterval(this.pingInterval);
-        this.pingInterval = null;
-    }
-    startKeepalive() {
-        this.stopKeepalive();
-        this.lastPongAt = Date.now();
-        const { pingIntervalMs, pongGraceMs } = getDirectDaemonControlTiming();
-        this.pingInterval = setInterval(() => {
-            const ws = this.ws;
-            if (!ws || ws.readyState !== WebSocket.OPEN) {
-                return;
-            }
-            const now = Date.now();
-            const elapsedSincePongMs = now - this.lastPongAt;
-            if (elapsedSincePongMs > pongGraceMs) {
-                const error = createDirectDaemonTransportError({
-                    provider: this.provider,
-                    alias: this.alias,
-                    transportCode: "keepalive_timeout",
-                    retryable: true,
-                    message: `${formatProviderLabel(this.provider)} control websocket missed keepalive pong for ${String(pongGraceMs)}ms.`,
-                });
-                logger.warn("direct_daemon_control_keepalive_timeout", this.buildLogFields({
-                    elapsedSincePongMs,
-                    pongGraceMs,
-                }));
-                try {
-                    ws.terminate();
-                }
-                catch {
-                    // ignore termination failures
-                }
-                this.failConnection(error);
-                return;
-            }
-            try {
-                ws.send(JSON.stringify({
-                    type: "ping",
-                    ts: now,
-                }));
-            }
-            catch {
-                // ignore ping failures; socket lifecycle handles disconnects
-            }
-        }, pingIntervalMs);
-        this.pingInterval.unref();
-    }
-    cleanupWebSocket() {
-        const ws = this.ws;
-        this.ws = null;
-        this.connectInfo = null;
-        this.authenticated = false;
-        this.stopKeepalive();
-        this.lastPongAt = 0;
-        this.controlProtocolVersion = null;
-        this.controlCapabilities = new Set();
-        if (!ws) {
-            return;
-        }
-        ws.removeAllListeners();
-        try {
-            if (ws.readyState <= WebSocket.OPEN) {
-                ws.close();
-            }
-        }
-        catch {
-            // ignore close failures
-        }
-    }
-    failPendingRequests(error) {
-        const pendingEntries = [...this.pendingRequests.entries()];
-        this.pendingRequests.clear();
-        if (pendingEntries.length > 0) {
-            logger.warn("direct_daemon_control_pending_requests_failed", this.buildLogFields({
-                failedRequestCount: pendingEntries.length,
-                error: error instanceof Error ? error.message : String(error),
-            }));
-        }
-        for (const [, pending] of pendingEntries) {
-            if (pending.timer) {
-                clearTimeout(pending.timer);
-            }
-            pending.reject(wrapDirectDaemonRequestError(pending.context, error));
-        }
-    }
-    handleAuthenticatedMessage(message) {
-        const type = typeof message.type === "string" ? message.type : "";
-        if (type === "pong") {
-            this.lastPongAt = Date.now();
-            return;
-        }
-        const responseRequestId = typeof message.requestId === "string" ? message.requestId : null;
-        if (!responseRequestId) {
-            if (type === "error") {
-                this.failConnection(new Error(buildDirectDaemonControlErrorText(this.provider, message)));
-            }
-            return;
-        }
-        const pending = this.pendingRequests.get(responseRequestId);
-        if (!pending) {
-            logger.warn("direct_daemon_control_response_unmatched", this.buildLogFields({
-                requestId: responseRequestId,
-                responseType: type || "unknown",
-                status: typeof message.status === "string" ? message.status : null,
-            }));
-            return;
-        }
-        this.pendingRequests.delete(responseRequestId);
-        if (pending.timer) {
-            clearTimeout(pending.timer);
-        }
-        this.scheduleIdleClose();
-        logger.debug("direct_daemon_control_response_received", this.buildLogFields({
-            requestId: responseRequestId,
-            responseType: type || "unknown",
-            expectedType: pending.expectedType,
-            status: typeof message.status === "string" ? message.status : null,
-        }));
-        if (type === "error") {
-            pending.reject(wrapDirectDaemonRequestError(pending.context, buildDirectDaemonControlErrorText(this.provider, message)));
-            return;
-        }
-        if (type !== pending.expectedType) {
-            pending.reject(wrapDirectDaemonRequestError(pending.context, `Unexpected ${formatProviderLabel(this.provider)} control response type "${type}" (expected "${pending.expectedType}").`));
-            return;
-        }
-        pending.resolve(message);
-    }
-    failConnection(error) {
-        this.reconnecting = !this.disposed;
-        this.cleanupWebSocket();
-        this.failPendingRequests(error);
-        this.scheduleIdleClose();
-    }
-    async ensureConnected(args) {
-        const forceRefresh = args.forceRefresh === true;
-        if (this.disposed) {
-            throw new Error(`${formatProviderLabel(this.provider)} control socket is closed.`);
-        }
-        if (forceRefresh) {
-            this.reconnecting = true;
-            this.cleanupWebSocket();
-        }
-        if (this.authenticated &&
-            this.ws &&
-            this.ws.readyState === WebSocket.OPEN &&
-            this.connectInfo) {
-            return this.connectInfo;
-        }
-        if (this.connecting) {
-            await this.connecting;
-            if (this.authenticated &&
-                this.ws &&
-                this.ws.readyState === WebSocket.OPEN &&
-                this.connectInfo) {
-                return this.connectInfo;
-            }
-        }
-        this.connecting = this.connectWithRetry({
-            forceRefresh,
-            requestPayload: args.requestPayload,
-            expectedType: args.expectedType,
-            timeoutMs: args.timeoutMs,
-        }).finally(() => {
-            this.connecting = null;
-        });
-        await this.connecting;
-        if (!this.connectInfo) {
-            throw new Error(`${formatProviderLabel(this.provider)} control socket lost connect info after handshake.`);
-        }
-        return this.connectInfo;
-    }
-    async connectWithRetry(args) {
-        const startedAt = Date.now();
-        const connectTimeoutMs = resolveDirectDaemonConnectTimeoutMs(args.timeoutMs);
-        let attempt = 0;
-        let delayMs = getDirectDaemonControlTiming().connectRetryInitialDelayMs;
-        let lastError = null;
-        let lastConnectInfo = null;
-        const wrapConnectError = (error) => {
-            const normalized = error instanceof Error ? error : new Error(String(error));
-            if (!lastConnectInfo) {
-                return normalized;
-            }
-            const context = buildDirectDaemonRequestContext({
-                alias: this.alias,
-                provider: this.provider,
-                requestPayload: args.requestPayload,
-                expectedType: args.expectedType,
-                connectInfo: lastConnectInfo,
-            });
-            return wrapDirectDaemonRequestError(context, normalized);
-        };
-        while (!this.disposed) {
-            attempt += 1;
-            const forceRefresh = args.forceRefresh || attempt > 1;
-            try {
-                lastConnectInfo = await this.resolveConnectInfo({
-                    alias: this.alias,
-                    intent: "proxy",
-                    // Direct daemon control is always driven by an active CLI operation,
-                    // so retries and forced reconnects should keep wake enabled instead
-                    // of failing when a devbox sleeps between request attempts.
-                    allowWake: true,
-                    ...(forceRefresh ? { forceRefresh: true } : {}),
-                });
-                logger.debug("direct_daemon_control_socket_connect_start", this.buildLogFields({
-                    ...buildDirectDaemonWsLogFields(lastConnectInfo),
-                    attempt,
-                    connectTimeoutMs,
-                    expectedType: args.expectedType,
-                    ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                }));
-                await this.connectOnce(lastConnectInfo);
-                if (this.reconnecting || attempt > 1) {
-                    logger.info("direct_daemon_control_socket_reconnected", this.buildLogFields({
-                        attempt,
-                        elapsedMs: Date.now() - startedAt,
-                        connectTimeoutMs,
-                        ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                    }));
-                }
-                this.reconnecting = false;
-                return;
-            }
-            catch (error) {
-                const failure = error instanceof Error ? error : new Error(String(error));
-                lastError = failure;
-                if (isDirectDaemonAuthRefreshError(this.provider, failure)) {
-                    logger.warn("direct_daemon_control_connect_info_auth_failed", this.buildLogFields({
-                        attempt,
-                        connectTimeoutMs,
-                        error: failure.message,
-                        ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                        ...(lastConnectInfo
-                            ? buildDirectDaemonWsLogFields(lastConnectInfo)
-                            : {}),
-                    }));
-                    throw wrapConnectError(failure);
-                }
-                if (!isDirectDaemonTransportError(failure)) {
-                    logger.warn("direct_daemon_control_connect_info_failed", this.buildLogFields({
-                        attempt,
-                        connectTimeoutMs,
-                        error: failure.message,
-                        ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                        ...(lastConnectInfo
-                            ? buildDirectDaemonWsLogFields(lastConnectInfo)
-                            : {}),
-                    }));
-                    throw wrapConnectError(failure);
-                }
-                if (!failure.retryable) {
-                    throw wrapConnectError(failure);
-                }
-                const elapsedMs = Date.now() - startedAt;
-                const remainingMs = Math.max(0, connectTimeoutMs - elapsedMs);
-                if (remainingMs <= 0) {
-                    break;
-                }
-                this.reconnecting = true;
-                const retryInMs = Math.min(delayMs, remainingMs);
-                logger.warn("direct_daemon_control_socket_connect_retry", this.buildLogFields({
-                    attempt,
-                    elapsedMs,
-                    retryInMs,
-                    connectTimeoutMs,
-                    error: failure.message,
-                    ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                    ...(lastConnectInfo
-                        ? buildDirectDaemonWsLogFields(lastConnectInfo)
-                        : {}),
-                }));
-                await sleep(retryInMs);
-                delayMs = Math.min(delayMs * 2, getDirectDaemonControlTiming().connectRetryMaxDelayMs);
-            }
-        }
-        this.reconnecting = false;
-        if (this.disposed) {
-            throw new Error(`${formatProviderLabel(this.provider)} control socket is closed.`);
-        }
-        const detail = lastError && lastError.message.trim().length > 0
-            ? `: ${lastError.message}`
-            : "";
-        throw wrapConnectError(createDirectDaemonTransportError({
-            provider: this.provider,
-            alias: this.alias,
-            transportCode: "connect_timeout",
-            retryable: true,
-            message: `Timed out connecting ${formatProviderLabel(this.provider)} control websocket for "${this.alias}"${detail}`,
-            ...(lastError ? { cause: lastError } : {}),
-        }));
-    }
-    async connectOnce(connectInfo) {
-        this.cleanupWebSocket();
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            const ws = new WebSocket(buildDirectDaemonWsUrl(connectInfo));
-            this.ws = ws;
-            this.connectInfo = connectInfo;
-            this.authenticated = false;
-            this.lastPongAt = Date.now();
-            const finishResolve = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                resolve();
-            };
-            const finishReject = (error) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                this.cleanupWebSocket();
-                reject(error instanceof Error ? error : new Error(String(error)));
-            };
-            ws.on("open", () => {
-                logger.debug("direct_daemon_control_socket_open", this.buildLogFields(buildDirectDaemonWsLogFields(connectInfo)));
-                try {
-                    ws.send(JSON.stringify(buildDirectDaemonAuthPayload(connectInfo)));
-                }
-                catch (error) {
-                    finishReject(createDirectDaemonTransportError({
-                        provider: this.provider,
-                        alias: this.alias,
-                        transportCode: "socket_error",
-                        retryable: true,
-                        message: `${formatProviderLabel(this.provider)} control websocket failed to send auth.`,
-                        cause: error,
-                    }));
-                }
-            });
-            ws.on("message", (raw) => {
-                const parsed = parseDaemonJsonRecord(raw);
-                if (!parsed) {
-                    logger.warn("direct_daemon_control_socket_message_parse_failed", this.buildLogFields({
-                        rawBytes: measureDirectDaemonRawMessageBytes(raw),
-                    }));
-                    return;
-                }
-                const type = typeof parsed.type === "string" ? parsed.type : "";
-                if (!this.authenticated) {
-                    if (type === "pong") {
-                        this.lastPongAt = Date.now();
-                        return;
-                    }
-                    if (type === "control_ready") {
-                        try {
-                            const ready = validateDirectDaemonControlReadyMessage({
-                                provider: this.provider,
-                                alias: this.alias,
-                                message: parsed,
-                            });
-                            this.authenticated = true;
-                            this.controlProtocolVersion = ready.protocolVersion;
-                            this.controlCapabilities = new Set(ready.capabilities);
-                            this.lastPongAt = Date.now();
-                            this.startKeepalive();
-                            logger.debug("direct_daemon_control_socket_ready", this.buildLogFields(buildDirectDaemonWsLogFields(connectInfo)));
-                            finishResolve();
-                        }
-                        catch (error) {
-                            if (isDirectDaemonTransportError(error)) {
-                                try {
-                                    ws.removeAllListeners();
-                                    ws.close(1008, error.transportCode === "protocol_version_mismatch"
-                                        ? "unsupported protocol version"
-                                        : error.transportCode === "missing_capabilities"
-                                            ? "missing control capabilities"
-                                            : "invalid control handshake");
-                                }
-                                catch {
-                                    // ignore close failures
-                                }
-                            }
-                            finishReject(error);
-                        }
-                        return;
-                    }
-                    if (type === "error") {
-                        finishReject(new Error(buildDirectDaemonControlErrorText(this.provider, parsed)));
-                    }
-                    return;
-                }
-                this.handleAuthenticatedMessage(parsed);
-            });
-            ws.on("pong", () => {
-                this.lastPongAt = Date.now();
-            });
-            ws.on("error", (error) => {
-                logger.warn("direct_daemon_control_socket_error", this.buildLogFields({
-                    ...buildDirectDaemonWsLogFields(connectInfo),
-                    error: error.message,
-                }));
-                const transportError = createDirectDaemonTransportError({
-                    provider: this.provider,
-                    alias: this.alias,
-                    transportCode: "socket_error",
-                    retryable: true,
-                    message: `${formatProviderLabel(this.provider)} control websocket error: ${error.message}`,
-                    cause: error,
-                });
-                if (!this.authenticated) {
-                    finishReject(transportError);
-                    return;
-                }
-                this.failConnection(transportError);
-            });
-            ws.on("close", (code, reason) => {
-                const reasonText = reason.toString("utf8");
-                logger.warn("direct_daemon_control_socket_close", this.buildLogFields({
-                    ...buildDirectDaemonWsLogFields(connectInfo),
-                    code,
-                    reason: reasonText || "no reason",
-                }));
-                const closeError = createDirectDaemonTransportError({
-                    provider: this.provider,
-                    alias: this.alias,
-                    transportCode: "socket_closed",
-                    retryable: true,
-                    message: `${formatProviderLabel(this.provider)} control websocket closed (${String(code)}): ${reasonText || "no reason"}`,
-                });
-                if (!this.authenticated) {
-                    finishReject(closeError);
-                    return;
-                }
-                this.failConnection(closeError);
-            });
-        });
-    }
-    async request(args) {
-        this.clearIdleTimer();
-        const connectInfo = await this.ensureConnected({
-            forceRefresh: args.forceRefresh === true,
-            requestPayload: args.requestPayload,
-            expectedType: args.expectedType,
-            timeoutMs: args.timeoutMs,
-        });
-        const requestId = randomUUID().replace(/-/g, "");
-        const requestContext = buildDirectDaemonRequestContext({
-            alias: this.alias,
-            provider: this.provider,
-            requestPayload: args.requestPayload,
-            expectedType: args.expectedType,
-            connectInfo,
-        });
-        return await new Promise((resolve, reject) => {
-            const pending = {
-                expectedType: args.expectedType,
-                context: requestContext,
-                resolve: (value) => resolve(value),
-                reject,
-                timer: null,
-            };
-            pending.timer = setTimeout(() => {
-                this.pendingRequests.delete(requestId);
-                this.scheduleIdleClose();
-                logger.warn("direct_daemon_control_request_timeout", this.buildLogFields({
-                    requestId,
-                    expectedType: args.expectedType,
-                    timeoutMs: args.timeoutMs,
-                    ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                }));
-                reject(wrapDirectDaemonRequestError(requestContext, createDirectDaemonTransportError({
-                    provider: this.provider,
-                    alias: this.alias,
-                    transportCode: "request_timeout",
-                    retryable: true,
-                    message: `Timed out waiting for ${formatProviderLabel(this.provider)} control response (${args.expectedType}).`,
-                })));
-            }, args.timeoutMs);
-            pending.timer.unref();
-            this.pendingRequests.set(requestId, pending);
-            try {
-                const ws = this.ws;
-                if (!ws || ws.readyState !== WebSocket.OPEN) {
-                    throw createDirectDaemonTransportError({
-                        provider: this.provider,
-                        alias: this.alias,
-                        transportCode: "socket_closed",
-                        retryable: true,
-                        message: `${formatProviderLabel(this.provider)} control websocket is not open.`,
-                    });
-                }
-                refDirectDaemonWebSocket(ws);
-                logger.debug("direct_daemon_control_request_send", this.buildLogFields({
-                    requestId,
-                    expectedType: args.expectedType,
-                    timeoutMs: args.timeoutMs,
-                    ...buildDirectDaemonRequestLogFields(args.requestPayload),
-                }));
-                ws.send(JSON.stringify({
-                    ...args.requestPayload,
-                    requestId,
-                }));
-            }
-            catch (error) {
-                this.failConnection(isDirectDaemonTransportError(error)
-                    ? error
-                    : createDirectDaemonTransportError({
-                        provider: this.provider,
-                        alias: this.alias,
-                        transportCode: "socket_error",
-                        retryable: true,
-                        message: `${formatProviderLabel(this.provider)} control websocket send failed.`,
-                        cause: error,
-                    }));
-            }
-        });
-    }
-    dispose() {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        this.reconnecting = false;
-        logger.debug("direct_daemon_control_socket_dispose", this.buildLogFields());
-        this.clearIdleTimer();
-        this.failPendingRequests(new Error(`${formatProviderLabel(this.provider)} control socket disposed.`));
-        this.cleanupWebSocket();
-        this.onDispose();
-    }
-}
-const directDaemonControlSockets = new Map();
-const buildDirectDaemonControlSocketKey = (provider, alias) => `${provider}:${alias}`;
-const resolveDirectDaemonControlSocket = (args) => {
-    const key = buildDirectDaemonControlSocketKey(args.provider, args.alias);
-    if (args.forceRefresh) {
-        directDaemonControlSockets.get(key)?.dispose();
-        directDaemonControlSockets.delete(key);
-    }
-    const existing = directDaemonControlSockets.get(key);
-    if (existing) {
-        return existing;
-    }
-    const socket = new DirectDaemonControlSocket(args.provider, args.resolveConnectInfo, args.alias, () => {
-        const current = directDaemonControlSockets.get(key);
-        if (current === socket) {
-            directDaemonControlSockets.delete(key);
-        }
-    });
-    directDaemonControlSockets.set(key, socket);
-    return socket;
-};
-const closeAllDirectDaemonControlSocketsForTests = () => {
-    for (const socket of directDaemonControlSockets.values()) {
-        socket.dispose();
-    }
-    directDaemonControlSockets.clear();
-    setDirectDaemonControlTimingForTests(null);
-};
-class DirectDaemonExecSocket {
-    provider;
-    resolveConnectInfo;
-    alias;
-    options;
-    binaryType = "nodebuffer";
-    readyState = 0;
-    listeners = {
-        open: new Set(),
-        close: new Set(),
-        error: new Set(),
-        message: new Set(),
-    };
-    pongListeners = new Set();
-    requestId = randomUUID().replace(/-/g, "");
-    channelId = randomUUID().replace(/-/g, "");
-    sessionId = null;
-    ws = null;
-    closed = false;
-    authenticated = false;
-    handshakeTimer = null;
-    replayInProgress = false;
-    replayBufferedOutbound = [];
-    constructor(provider, resolveConnectInfo, alias, options) {
-        this.provider = provider;
-        this.resolveConnectInfo = resolveConnectInfo;
-        this.alias = alias;
-        this.options = options;
-        if (typeof this.options.sessionId === "string" && this.options.sessionId) {
-            this.sessionId = this.options.sessionId;
-        }
-        void this.start();
-    }
-    emit(type, event = {}) {
-        for (const listener of this.listeners[type]) {
-            listener(event);
-        }
-    }
-    emitPong() {
-        for (const listener of this.pongListeners) {
-            listener();
-        }
-    }
-    clearHandshakeTimer() {
-        if (!this.handshakeTimer) {
-            return;
-        }
-        clearTimeout(this.handshakeTimer);
-        this.handshakeTimer = null;
-    }
-    startHandshakeTimer() {
-        this.clearHandshakeTimer();
-        const providerLabel = formatProviderLabel(this.provider);
-        this.handshakeTimer = setTimeout(() => {
-            if (this.closed || this.readyState !== 0) {
-                return;
-            }
-            this.emit("error", {
-                data: new Error(`Timed out waiting for ${providerLabel} tty session handshake.`),
-            });
-            this.close();
-        }, 30_000);
-        this.handshakeTimer.unref();
-    }
-    sendJson(payload) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            throw new Error(`${formatProviderLabel(this.provider)} daemon socket is not open.`);
-        }
-        this.ws.send(JSON.stringify(payload));
-    }
-    markReplayActivity() {
-        this.emit("message", { data: new Uint8Array(0) });
-    }
-    queueOrSend(payload) {
-        if (this.replayInProgress) {
-            this.replayBufferedOutbound.push(payload);
-            this.markReplayActivity();
-            return;
-        }
-        this.sendJson(payload);
-    }
-    flushReplayBufferedOutbound() {
-        if (this.replayInProgress || this.replayBufferedOutbound.length === 0) {
-            return;
-        }
-        const pending = [...this.replayBufferedOutbound];
-        this.replayBufferedOutbound = [];
-        for (const payload of pending) {
-            try {
-                this.sendJson(payload);
-            }
-            catch (error) {
-                this.emit("error", {
-                    data: error instanceof Error ? error : new Error(String(error)),
-                });
-                this.close();
-                return;
-            }
-        }
-    }
-    buildExecLogFields(extra) {
-        return {
-            alias: this.alias,
-            provider: this.provider,
-            requestId: this.requestId,
-            channelId: this.channelId,
-            ...(this.sessionId ? { sessionId: this.sessionId } : {}),
-            ...(this.options.ephemeral === true ? { ephemeral: true } : {}),
-            ...extra,
-        };
-    }
-    buildTtyOpenPayload() {
-        const payload = {
-            type: "tty_open",
-            requestId: this.requestId,
-            channelId: this.channelId,
-        };
-        if (typeof this.options.sessionId === "string" && this.options.sessionId) {
-            payload.sessionId = this.options.sessionId;
-            payload.allowCreateIfMissing = this.options.allowCreateIfMissing === true;
-        }
-        if (Array.isArray(this.options.cmd) && this.options.cmd.length > 0) {
-            payload.command = this.options.cmd;
-        }
-        if (typeof this.options.cwd === "string" && this.options.cwd) {
-            payload.cwd = this.options.cwd;
-        }
-        if (this.options.env) {
-            payload.env = this.options.env;
-        }
-        if (typeof this.options.cols === "number") {
-            payload.cols = this.options.cols;
-        }
-        if (typeof this.options.rows === "number") {
-            payload.rows = this.options.rows;
-        }
-        if (typeof this.options.logPath === "string" && this.options.logPath) {
-            payload.logPath = this.options.logPath;
-        }
-        if (typeof this.options.ephemeral === "boolean") {
-            payload.ephemeral = this.options.ephemeral;
-        }
-        return payload;
-    }
-    closeFromRemote(code) {
-        if (this.closed)
-            return;
-        this.clearHandshakeTimer();
-        this.closed = true;
-        this.replayBufferedOutbound = [];
-        this.readyState = 3;
-        if (this.ws && this.ws.readyState <= WebSocket.OPEN) {
-            try {
-                this.ws.close();
-            }
-            catch {
-                // ignore close failures
-            }
-        }
-        this.emit("close", { code: code ?? 1000 });
-    }
-    handleDaemonMessage(message) {
-        const type = typeof message.type === "string" ? message.type : "";
-        if (!this.authenticated) {
-            if (type === "control_ready") {
-                try {
-                    validateDirectDaemonControlReadyMessage({
-                        provider: this.provider,
-                        alias: this.alias,
-                        message,
-                    });
-                }
-                catch (error) {
-                    this.emit("error", {
-                        data: error instanceof Error ? error : new Error(String(error)),
-                    });
-                    this.close();
-                    return;
-                }
-                this.authenticated = true;
-                try {
-                    this.sendJson(this.buildTtyOpenPayload());
-                }
-                catch (error) {
-                    this.emit("error", {
-                        data: error instanceof Error ? error : new Error(String(error)),
-                    });
-                    this.close();
-                }
-                return;
-            }
-            if (type === "error") {
-                this.emit("error", {
-                    data: new Error(buildDirectDaemonControlErrorText(this.provider, message)),
-                });
-                this.close();
-            }
-            return;
-        }
-        if (type === "tty_open_result") {
-            const responseRequestId = typeof message.requestId === "string" ? message.requestId : null;
-            if (responseRequestId !== this.requestId) {
-                return;
-            }
-            if (message.status === "error") {
-                this.emit("error", {
-                    data: new Error(buildDirectDaemonControlErrorText(this.provider, message)),
-                });
-                this.close();
-                return;
-            }
-            const channelId = typeof message.channelId === "string" ? message.channelId.trim() : "";
-            if (channelId) {
-                this.channelId = channelId;
-            }
-            const sessionId = typeof message.sessionId === "string" ? message.sessionId.trim() : "";
-            if (sessionId) {
-                this.sessionId = sessionId;
-            }
-            return;
-        }
-        if (type === "tty_ready") {
-            this.clearHandshakeTimer();
-            this.readyState = 1;
-            this.emit("open");
-            queueMicrotask(() => {
-                if (this.closed)
-                    return;
-                this.emit("message", { data: JSON.stringify(message) });
-            });
-            return;
-        }
-        if (type === "tty_replay_start") {
-            this.replayInProgress = true;
-            this.markReplayActivity();
-            this.emit("message", { data: JSON.stringify(message) });
-            return;
-        }
-        if (type === "tty_replay_done") {
-            this.replayInProgress = false;
-            this.markReplayActivity();
-            this.flushReplayBufferedOutbound();
-            this.emit("message", { data: JSON.stringify(message) });
-            return;
-        }
-        if (type === "tty_data") {
-            this.emit("message", { data: JSON.stringify(message) });
-            return;
-        }
-        if (type === "tty_exit") {
-            this.emit("message", { data: JSON.stringify(message) });
-            this.close();
-            return;
-        }
-        if (type === "tty_closed") {
-            const closeCode = typeof message.code === "number" && Number.isFinite(message.code)
-                ? message.code
-                : undefined;
-            const closeReason = typeof message.reason === "string" && message.reason.length > 0
-                ? message.reason
-                : "no reason";
-            const errorPayload = message.error && typeof message.error === "object"
-                ? message.error
-                : null;
-            const errorCode = errorPayload && typeof errorPayload.code === "string"
-                ? errorPayload.code
-                : undefined;
-            const errorMessage = errorPayload && typeof errorPayload.message === "string"
-                ? errorPayload.message
-                : undefined;
-            const replacedByNewerClient = closeCode === CONTROL_TTY_REPLACED_CLOSE_CODE ||
-                errorPayload?.code === CONTROL_TTY_REPLACED_ERROR_CODE;
-            const ttyCloseLogFields = this.buildExecLogFields({
-                ...(typeof closeCode === "number" ? { code: closeCode } : {}),
-                reason: closeReason,
-                replacedByNewerClient,
-                ...(errorCode ? { errorCode } : {}),
-                ...(errorMessage ? { errorMessage } : {}),
-            });
-            if (replacedByNewerClient) {
-                logger.info("direct_daemon_exec_tty_closed", ttyCloseLogFields);
-            }
-            else if (closeCode === 1000 &&
-                typeof errorMessage !== "string" &&
-                typeof errorCode !== "string") {
-                logger.info("direct_daemon_exec_tty_closed", ttyCloseLogFields);
-            }
-            else {
-                logger.warn("direct_daemon_exec_tty_closed", ttyCloseLogFields);
-            }
-            if (replacedByNewerClient) {
-                this.closeFromRemote(CONTROL_TTY_REPLACED_CLOSE_CODE);
-                return;
-            }
-            if (errorPayload && typeof errorPayload.message === "string") {
-                this.emit("error", { data: new Error(errorPayload.message) });
-            }
-            this.closeFromRemote(closeCode);
-            return;
-        }
-        if (type === "error") {
-            this.emit("error", {
-                data: new Error(buildDirectDaemonControlErrorText(this.provider, message)),
-            });
-            return;
-        }
-        if (type === "pong") {
-            this.emitPong();
-            return;
-        }
-        if (type === "port_opened" || type === "port_closed") {
-            this.emit("message", { data: JSON.stringify(message) });
-        }
-    }
-    async start() {
-        try {
-            if (this.closed)
-                return;
-            const connectInfo = await this.resolveConnectInfo({
-                alias: this.alias,
-                intent: "shell",
-                allowWake: true,
-            });
-            if (this.closed)
-                return;
-            const ws = new WebSocket(buildDirectDaemonWsUrl(connectInfo));
-            this.ws = ws;
-            this.startHandshakeTimer();
-            ws.on("open", () => {
-                try {
-                    this.sendJson(buildDirectDaemonAuthPayload(connectInfo));
-                }
-                catch (error) {
-                    this.emit("error", {
-                        data: error instanceof Error ? error : new Error(String(error)),
-                    });
-                    this.close();
-                }
-            });
-            ws.on("message", (raw) => {
-                const parsed = parseDaemonJsonRecord(raw);
-                if (!parsed)
-                    return;
-                this.handleDaemonMessage(parsed);
-            });
-            ws.on("pong", () => {
-                this.emitPong();
-            });
-            ws.on("error", (error) => {
-                this.clearHandshakeTimer();
-                logger.warn("direct_daemon_exec_socket_error", this.buildExecLogFields({
-                    ...buildDirectDaemonWsLogFields(connectInfo),
-                    error: error instanceof Error
-                        ? error.message
-                        : new Error(String(error)).message,
-                }));
-                this.emit("error", {
-                    data: error instanceof Error ? error : new Error(String(error)),
-                });
-            });
-            ws.on("close", (code, reason) => {
-                this.clearHandshakeTimer();
-                const reasonText = reason.toString("utf8") || "no reason";
-                const logMethod = code === 1000 ? logger.info : logger.warn;
-                logMethod("direct_daemon_exec_socket_close", this.buildExecLogFields({
-                    ...buildDirectDaemonWsLogFields(connectInfo),
-                    code,
-                    reason: reasonText,
-                }));
-                if (this.closed)
-                    return;
-                this.closed = true;
-                this.readyState = 3;
-                this.emit("close", { code });
-            });
-        }
-        catch (error) {
-            this.clearHandshakeTimer();
-            this.emit("error", {
-                data: error instanceof Error ? error : new Error(String(error)),
-            });
-            this.close();
-        }
-    }
-    send(data, cb) {
-        if (this.closed) {
-            cb?.();
-            return;
-        }
-        try {
-            if (typeof data === "string") {
-                try {
-                    const parsed = JSON.parse(data);
-                    if (parsed && typeof parsed === "object") {
-                        const record = parsed;
-                        if (record.type === "resize") {
-                            this.queueOrSend({
-                                type: "tty_resize",
-                                channelId: this.channelId,
-                                cols: record.cols,
-                                rows: record.rows,
-                            });
-                            cb?.();
-                            return;
-                        }
-                        if (record.type === "detach") {
-                            this.queueOrSend({
-                                type: "tty_detach",
-                                channelId: this.channelId,
-                            });
-                            cb?.();
-                            return;
-                        }
-                    }
-                }
-                catch {
-                    // fall through to stdin send
-                }
-                this.queueOrSend({
-                    type: "tty_input",
-                    channelId: this.channelId,
-                    data: Buffer.from(data, "utf8").toString("base64"),
-                });
-                cb?.();
-                return;
-            }
-            this.queueOrSend({
-                type: "tty_input",
-                channelId: this.channelId,
-                data: Buffer.from(data).toString("base64"),
-            });
-            cb?.();
-        }
-        catch (error) {
-            cb?.(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    close() {
-        if (this.closed)
-            return;
-        this.clearHandshakeTimer();
-        this.closed = true;
-        this.replayBufferedOutbound = [];
-        this.readyState = 3;
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            try {
-                this.sendJson({
-                    type: "tty_close",
-                    channelId: this.channelId,
-                });
-            }
-            catch {
-                // ignore close send failures
-            }
-        }
-        if (this.ws && this.ws.readyState <= WebSocket.OPEN) {
-            try {
-                this.ws.close();
-            }
-            catch {
-                // ignore close failures
-            }
-        }
-        this.emit("close", { code: 1000 });
-    }
-    ping() {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
-            return;
-        try {
-            this.ws.ping();
-        }
-        catch {
-            try {
-                this.sendJson({ type: "ping", ts: Date.now() });
-            }
-            catch {
-                // ignore ping failure
-            }
-        }
-    }
-    get bufferedAmount() {
-        return this.ws?.bufferedAmount ?? 0;
-    }
-    addEventListener(type, listener) {
-        this.listeners[type].add(listener);
-    }
-    removeEventListener(type, listener) {
-        this.listeners[type].delete(listener);
-    }
-    on(event, listener) {
-        if (event !== "pong") {
-            return;
-        }
-        this.pongListeners.add(listener);
-    }
-    off(event, listener) {
-        if (event !== "pong") {
-            return;
-        }
-        this.pongListeners.delete(listener);
-    }
-    removeListener(event, listener) {
-        this.off(event, listener);
-    }
-}
-const runDirectDaemonControlRequest = async (args) => {
-    const operationId = randomUUID().replace(/-/g, "");
-    const executeRequest = async (forceRefresh = false) => {
-        const socket = resolveDirectDaemonControlSocket({
-            provider: args.provider,
-            resolveConnectInfo: args.resolveConnectInfo,
-            alias: args.alias,
-            ...(forceRefresh ? { forceRefresh: true } : {}),
-        });
-        return await socket.request({
-            requestPayload: args.requestPayload,
-            expectedType: args.expectedType,
-            timeoutMs: args.timeoutMs,
-            ...(forceRefresh ? { forceRefresh: true } : {}),
-        });
-    };
-    let attempt = 0;
-    let authRefreshRetried = false;
-    let transportRetries = 0;
-    let forceRefresh = false;
-    while (true) {
-        attempt += 1;
-        try {
-            const response = await executeRequest(forceRefresh);
-            if (transportRetries > 0) {
-                logger.info("direct_daemon_control_request_retry_recovered", buildDirectDaemonOperationLogFields({
-                    alias: args.alias,
-                    provider: args.provider,
-                    operationId,
-                    attempt,
-                    expectedType: args.expectedType,
-                    requestPayload: args.requestPayload,
-                }));
-            }
-            return response;
-        }
-        catch (error) {
-            if (!authRefreshRetried &&
-                isDirectDaemonAuthRefreshError(args.provider, error)) {
-                authRefreshRetried = true;
-                forceRefresh = true;
-                logger.warn("direct_daemon_control_request_auth_retry", {
-                    ...buildDirectDaemonOperationLogFields({
-                        alias: args.alias,
-                        provider: args.provider,
-                        operationId,
-                        attempt,
-                        expectedType: args.expectedType,
-                        requestPayload: args.requestPayload,
-                    }),
-                    nextAttempt: attempt + 1,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                continue;
-            }
-            if (transportRetries < DIRECT_DAEMON_REQUEST_TRANSPORT_RETRY_LIMIT &&
-                isDirectDaemonReplaySafeRequest(args.requestPayload) &&
-                isDirectDaemonTransportError(error) &&
-                error.retryable) {
-                transportRetries += 1;
-                forceRefresh = true;
-                logger.warn("direct_daemon_control_request_retry", {
-                    ...buildDirectDaemonOperationLogFields({
-                        alias: args.alias,
-                        provider: args.provider,
-                        operationId,
-                        attempt,
-                        expectedType: args.expectedType,
-                        requestPayload: args.requestPayload,
-                    }),
-                    nextAttempt: attempt + 1,
-                    transportCode: error.transportCode,
-                    error: error.message,
-                });
-                continue;
-            }
-            throw error;
-        }
-    }
-};
-export { DirectDaemonExecSocket, isDirectDaemonTransportError, runDirectDaemonControlRequest, };
-export const __testOnly = {
-    closeAllDirectDaemonControlSocketsForTests,
-    setDirectDaemonControlTimingForTests,
-};
-//# sourceMappingURL=directDaemonRuntime.js.map