@aria-cli/cli 1.0.57 → 1.0.58

package/dist/attached-local-control-client.js

@@ -1,826 +0,0 @@
-import * as net from "node:net";
-import { appendFileSync, mkdirSync } from "node:fs";
-import { join as pathJoin } from "node:path";
-import { randomUUID } from "node:crypto";
-import { createRuntimeSocketAttachedLocalControlClient, createRuntimeSocketLocalControlClient, createTrustedRuntimeError, AttachedClientLeaseGrantSchema, LocalControlSocketAttachClientRequestSchema, LocalControlSocketAttachClientResponseSchema, LocalControlSocketRequestSchema, LocalControlSocketResponseSchema, } from "@aria-cli/tools";
-import { assertAttachableRuntimeBootstrap } from "./local-control-bootstrap.js";
-import { reportTrustedLocalControlFailure } from "./local-control-error-reporting.js";
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, Math.max(ms, 0)));
-}
-const EXISTING_RUNTIME_ATTACH_TIMEOUT_MS = 10_000;
-const EXISTING_RUNTIME_ATTACH_RETRY_MS = 250;
-let hostSupervisorModulePromise;
-let nodeMetadataModulePromise;
-let nodeStoreModulePromise;
-function loadHostSupervisorModule() {
-    hostSupervisorModulePromise ??= import("@aria-cli/server/runtime/host-supervisor");
-    return hostSupervisorModulePromise;
-}
-function loadNodeMetadataModule() {
-    nodeMetadataModulePromise ??= import("@aria-cli/server/runtime/node-metadata");
-    return nodeMetadataModulePromise;
-}
-function loadNodeStoreModule() {
-    nodeStoreModulePromise ??= import("@aria-cli/server/runtime/node-store");
-    return nodeStoreModulePromise;
-}
-async function resolveOrCreateLocalNode(ariaHome) {
-    const { resolveOrCreateNode } = await loadNodeMetadataModule();
-    return resolveOrCreateNode({ ariaHome });
-}
-async function resolveLocalRuntimeOwnerRecord(ariaHome, nodeId) {
-    const { NodeStore } = await loadNodeStoreModule();
-    const nodeStore = new NodeStore({ ariaHome });
-    try {
-        return nodeStore.readRuntimeOwnerRecord(nodeId);
-    }
-    finally {
-        nodeStore.close();
-    }
-}
-function isPublishedRuntimeUnavailableError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const message = error.message;
-    return (message.includes("connect ENOENT") ||
-        message.includes("ECONNREFUSED") ||
-        message.includes("Missing runtime owner record") ||
-        message.includes("not attachable") ||
-        message.includes("not control-ready"));
-}
-async function connectToPublishedRuntimeSocket(options) {
-    const ownerRecord = await resolveLocalRuntimeOwnerRecord(options.ariaHome, options.nodeId);
-    if (!ownerRecord) {
-        throw new Error(`[local-control-client] Missing runtime owner record for node ${options.nodeId}`);
-    }
-    const control = createSocketLocalControlClient({
-        runtimeSocket: ownerRecord.runtimeSocket,
-        pollIntervalMs: options.pollIntervalMs,
-    });
-    const bootstrap = assertAttachableRuntimeBootstrap(options.nodeId, await control.getRuntimeBootstrap());
-    let externalClientId;
-    let externalClientAuthToken;
-    let resilientClient;
-    if (options.clientKind) {
-        resilientClient = await createResilientAttachedClient({
-            runtimeSocket: ownerRecord.runtimeSocket,
-            clientKind: options.clientKind,
-            logDir: pathJoin(options.ariaHome, "logs"),
-        });
-        externalClientId = resilientClient.getClientId();
-        externalClientAuthToken = resilientClient.getClientAuthToken();
-    }
-    let releasePromise = null;
-    return {
-        nodeId: options.nodeId,
-        runtimeId: bootstrap.runtimeId,
-        port: bootstrap.controlEndpoint.port,
-        ownership: options.ownership,
-        ...(externalClientId ? { attachedClientId: externalClientId } : {}),
-        ...(externalClientAuthToken ? { attachedClientAuthToken: externalClientAuthToken } : {}),
-        control: resilientClient ? resilientClient.api : control,
-        getConnectionState: resilientClient
-            ? (() => {
-                const rc = resilientClient;
-                return () => rc.getState();
-            })()
-            : undefined,
-        onConnectionStateChange: resilientClient
-            ? (() => {
-                const rc = resilientClient;
-                return (listener) => rc.onStateChange(listener);
-            })()
-            : undefined,
-        release: async (releaseOptions) => {
-            if (releasePromise) {
-                return releasePromise;
-            }
-            releasePromise = (async () => {
-                const rc = resilientClient;
-                resilientClient = undefined;
-                externalClientId = undefined;
-                externalClientAuthToken = undefined;
-                await rc?.release().catch(() => { });
-                await options.release(releaseOptions);
-            })();
-            return releasePromise;
-        },
-    };
-}
-export async function requestRuntimeSocketLease(runtimeSocket, payload) {
-    const request = LocalControlSocketRequestSchema.parse({
-        id: randomUUID(),
-        method: "attachClient",
-        payload,
-    });
-    return new Promise((resolve, reject) => {
-        const socket = net.createConnection(runtimeSocket);
-        let buffer = "";
-        let settled = false;
-        let closed = false;
-        let closeResolve;
-        const closePromise = new Promise((resolveClose) => {
-            closeResolve = resolveClose;
-        });
-        const markClosed = () => {
-            if (closed) {
-                return;
-            }
-            closed = true;
-            closeResolve?.();
-            if (!settled) {
-                settled = true;
-                reject(new Error("Local control socket closed before establishing an attached-client lease"));
-            }
-        };
-        socket.setEncoding("utf8");
-        socket.once("connect", () => {
-            socket.write(`${JSON.stringify(request)}\n`);
-        });
-        socket.once("error", (error) => {
-            if (!settled) {
-                settled = true;
-                reject(error);
-                return;
-            }
-            markClosed();
-        });
-        socket.once("end", markClosed);
-        socket.once("close", markClosed);
-        socket.on("data", async (chunk) => {
-            buffer += chunk;
-            const newlineIndex = buffer.indexOf("\n");
-            if (newlineIndex === -1 || settled) {
-                return;
-            }
-            try {
-                const response = LocalControlSocketResponseSchema.parse(JSON.parse(buffer.slice(0, newlineIndex)));
-                if (response.id !== request.id) {
-                    settled = true;
-                    socket.destroy();
-                    reject(new Error("Local control socket response ID mismatch"));
-                    return;
-                }
-                if (!response.ok) {
-                    const trustedError = createTrustedRuntimeError(response.error, response.diagnostic);
-                    await reportTrustedLocalControlFailure(trustedError, {
-                        endpoint: "attachClient",
-                        responseStatus: null,
-                        payload: response,
-                        transport: "runtime_socket_attach",
-                    });
-                    settled = true;
-                    socket.destroy();
-                    reject(trustedError);
-                    return;
-                }
-                const attached = AttachedClientLeaseGrantSchema.parse(LocalControlSocketAttachClientResponseSchema.parse(response.payload));
-                settled = true;
-                resolve({
-                    clientId: attached.clientId,
-                    clientAuthToken: attached.clientAuthToken,
-                    release: async () => {
-                        if (!closed) {
-                            socket.destroy();
-                        }
-                        await closePromise;
-                    },
-                });
-            }
-            catch (error) {
-                settled = true;
-                socket.destroy();
-                reject(error);
-            }
-        });
-    });
-}
-export async function attachExistingLocalControlClient(options) {
-    const resolvedNode = await resolveOrCreateLocalNode(options.ariaHome);
-    if (!(await resolveLocalRuntimeOwnerRecord(options.ariaHome, resolvedNode.nodeId))) {
-        return null;
-    }
-    const deadline = Date.now() + EXISTING_RUNTIME_ATTACH_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        try {
-            return await connectToPublishedRuntimeSocket({
-                ariaHome: options.ariaHome,
-                nodeId: resolvedNode.nodeId,
-                ownership: "reattached",
-                release: async () => { },
-                pollIntervalMs: options.pollIntervalMs,
-                clientKind: options.clientKind,
-            });
-        }
-        catch (error) {
-            if (!isPublishedRuntimeUnavailableError(error)) {
-                throw error;
-            }
-            if (!(await resolveLocalRuntimeOwnerRecord(options.ariaHome, resolvedNode.nodeId))) {
-                return null;
-            }
-            await sleep(EXISTING_RUNTIME_ATTACH_RETRY_MS);
-        }
-    }
-    return null;
-}
-function createSocketLocalControlClient(options) {
-    if (options.auth) {
-        return createRuntimeSocketAttachedLocalControlClient({
-            runtimeSocket: options.runtimeSocket,
-            pollIntervalMs: options.pollIntervalMs,
-            auth: options.auth,
-        });
-    }
-    return createRuntimeSocketLocalControlClient(options);
-}
-export async function attachLocalControlClient(options) {
-    const attachToPublishedRuntime = async (nodeId, clientKind) => {
-        const retryIntervalMs = options.pollIntervalMs ?? 100;
-        const deadline = Date.now() + Math.max(retryIntervalMs * 20, 2_000);
-        let lastError = null;
-        while (Date.now() < deadline) {
-            if (options.signal?.aborted) {
-                throw new Error(`[local-control-client] Attach-only client ${clientKind} aborted while waiting for a live runtime owner on node ${nodeId}`);
-            }
-            try {
-                const ownerRecord = await resolveLocalRuntimeOwnerRecord(options.ariaHome, nodeId);
-                if (!ownerRecord) {
-                    lastError = new Error(`[local-control-client] No live runtime owner available for attach-only client ${clientKind} on node ${nodeId}`);
-                }
-                else {
-                    return await connectToPublishedRuntimeSocket({
-                        ariaHome: options.ariaHome,
-                        nodeId,
-                        ownership: "reattached",
-                        release: async () => { },
-                        pollIntervalMs: options.pollIntervalMs,
-                        clientKind,
-                    });
-                }
-            }
-            catch (error) {
-                if (!isPublishedRuntimeUnavailableError(error)) {
-                    throw error;
-                }
-                lastError = error;
-            }
-            await sleep(retryIntervalMs);
-        }
-        throw (lastError ??
-            new Error(`[local-control-client] No live runtime owner available for attach-only client ${clientKind} on node ${nodeId}`));
-    };
-    const { getHostSupervisor, HostSupervisorSplitBrainError } = await loadHostSupervisorModule();
-    const supervisor = getHostSupervisor();
-    let attachment;
-    try {
-        attachment = await supervisor.attach({
-            ariaHome: options.ariaHome,
-            arionName: options.arionName,
-            clientKind: options.clientKind,
-            memoriaFactory: options.memoriaFactory,
-            router: options.router,
-            authResolver: options.authResolver,
-            runSessionConfig: options.runSessionConfig,
-            mcpServers: options.mcpServers,
-            daemonSafetyPolicy: options.daemonSafetyPolicy,
-            autonomousIntervalMs: options.autonomousIntervalMs,
-            signal: options.signal,
-            silent: options.silent,
-            runtimeLifecycle: options.runtimeLifecycle,
-            port: options.port,
-        });
-    }
-    catch (error) {
-        if (error instanceof HostSupervisorSplitBrainError) {
-            return connectToPublishedRuntimeSocket({
-                ariaHome: options.ariaHome,
-                nodeId: error.nodeId,
-                ownership: "reattached",
-                release: async () => { },
-                pollIntervalMs: options.pollIntervalMs,
-                clientKind: options.clientKind,
-            });
-        }
-        throw error;
-    }
-    try {
-        await attachment.runtime.waitForInitialDiscovery();
-        return await connectToPublishedRuntimeSocket({
-            ariaHome: options.ariaHome,
-            nodeId: attachment.nodeId,
-            ownership: attachment.ownership,
-            pollIntervalMs: options.pollIntervalMs,
-            clientKind: options.clientKind,
-            release: (releaseOptions) => attachment.release(releaseOptions),
-        });
-    }
-    catch (error) {
-        await attachment.release();
-        throw error;
-    }
-}
-export async function resolveLocalControlClient(options) {
-    const resolvedNode = await resolveOrCreateLocalNode(options.ariaHome);
-    try {
-        const attached = await connectToPublishedRuntimeSocket({
-            ariaHome: options.ariaHome,
-            nodeId: resolvedNode.nodeId,
-            ownership: "reattached",
-            release: async () => { },
-            pollIntervalMs: options.pollIntervalMs,
-        });
-        return attached.control;
-    }
-    catch (error) {
-        if (isPublishedRuntimeUnavailableError(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-export function resolveLocalControlClientSync(options) {
-    void options;
-    // Published runtime liveness is an async property established by a bootstrap round-trip.
-    // A synchronous raw-socket fallback would recreate the stale-owner bypass.
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Resilient attached client — THE canonical way to get a client that survives
-// daemon restarts.  Fuses lease acquisition, auth, reattach, background
-// reconnection, and diagnostic logging at the lowest level so callers cannot
-// get it wrong.
-//
-// Design (modeled after ioredis / node-redis / gRPC channel semantics):
-//
-//   1.  **Background reconnect loop** — runs forever with capped exponential
-//       backoff + jitter.  As soon as the daemon is reachable the loop
-//       acquires a fresh lease and flips the state to `connected`.
-//
-//   2.  **Connection state** — `connected | disconnected | reconnecting`
-//       with an EventEmitter so the REPL / overlay can react in real time.
-//
-//   3.  **Per-call waiting** — when the connection is down a call does NOT
-//       fail immediately.  It waits for the background loop to reconnect
-//       (up to `callTimeoutMs`, default 5 minutes) then retries.  This
-//       means a daemon restart that takes 1-2 minutes is fully transparent.
-//
-//   4.  **Jitter** — prevents thundering-herd reconnect storms when many
-//       clients try to reconnect at the same time.
-// ---------------------------------------------------------------------------
-/** Backoff parameters (all in milliseconds). */
-const INITIAL_BACKOFF_MS = 250;
-const MAX_BACKOFF_MS = 30_000;
-const DEFAULT_CALL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-/**
- * Methods whose streams are safe to re-issue after reconnect (subscriptions).
- * Streams NOT in this set are treated as non-idempotent executions and will
- * NOT be silently restarted — the error propagates so callers can handle it.
- */
-const RESUBSCRIBABLE_STREAMS = new Set([
-    "subscribeRuntimeEvents",
-    "subscribeInbox",
-    "subscribePeers",
-    "subscribeDirectClientInbox",
-]);
-function isRecoverableError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const msg = error.message;
-    return (msg.includes("attached-local-client-only") ||
-        msg.includes("ECONNRESET") ||
-        msg.includes("ECONNREFUSED") ||
-        msg.includes("EPIPE") ||
-        msg.includes("connect ENOENT") ||
-        msg.includes("socket hang up") ||
-        msg.includes("closed before"));
-}
-function jitter(ms) {
-    return ms + Math.floor(Math.random() * ms * 0.3);
-}
-function backoffSleep(ms) {
-    if (ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        timer.unref?.();
-    });
-}
-/**
- * Acquire a one-shot lease from the daemon socket.  Returns credentials
- * without creating a background reconnect loop.  Use this when you only
- * need clientId/token (e.g. for resolveCredentials) but do NOT need a
- * long-lived resilient client.
- */
-export async function requestOneShotLease(runtimeSocket, clientKind = "local-api") {
-    const lease = await requestRuntimeSocketLease(runtimeSocket, LocalControlSocketAttachClientRequestSchema.parse({
-        clientKind,
-        lease: true,
-        pid: process.pid,
-    }));
-    return {
-        clientId: lease.clientId,
-        clientAuthToken: lease.clientAuthToken,
-        release: () => lease.release(),
-    };
-}
-/**
- * Creates a self-healing AttachedLocalControlApi that survives daemon
- * restarts — including long outages of minutes or hours.
- *
- * Architecture:
- *
- *   ┌────────────────────────────────┐
- *   │   Background Reconnect Loop    │  runs forever until release()
- *   │   exponential backoff + jitter │  capped at 30 s
- *   │   acquires fresh lease on      │
- *   │   success → state = connected  │
- *   └──────────────┬─────────────────┘
- *                  │
- *                  ▼
- *   ┌────────────────────────────────┐
- *   │        Per-Call Path           │
- *   │  connected → execute           │
- *   │  disconnected → wait for       │
- *   │    reconnect (up to 5 min)     │
- *   │    then retry                  │
- *   └────────────────────────────────┘
- */
-export async function createResilientAttachedClient(options) {
-    const { runtimeSocket, clientKind = "local-api" } = options;
-    const callTimeoutMs = options.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
-    let released = false;
-    let state = "disconnected";
-    /** Internal flag: true when the reconnect loop should attempt reconnection
-     *  even though the external `state` has not been changed to `disconnected`.
-     *  This lets transient errors trigger reconnection without flashing the UI. */
-    let needsReconnect = false;
-    let currentClientId;
-    let currentAuthToken;
-    let inner = null;
-    let currentReleaseLease = null;
-    // --- State management + listeners ---
-    const listeners = new Set();
-    function setState(next) {
-        if (next === state)
-            return;
-        state = next;
-        for (const fn of listeners) {
-            try {
-                fn(next);
-            }
-            catch {
-                /* never break the client */
-            }
-        }
-    }
-    // --- "connected" promise that per-call waiters block on ---
-    // Resolves every time the background loop transitions to `connected`.
-    let connectedResolve = null;
-    let connectedPromise = new Promise((r) => {
-        connectedResolve = r;
-    });
-    function signalConnected() {
-        connectedResolve?.();
-        // Reset for next disconnect cycle
-        connectedPromise = new Promise((r) => {
-            connectedResolve = r;
-        });
-    }
-    // --- Logging ---
-    const log = (event) => {
-        if (!options.logDir)
-            return;
-        try {
-            mkdirSync(options.logDir, { recursive: true });
-            appendFileSync(pathJoin(options.logDir, "reattach.jsonl"), JSON.stringify({ ts: new Date().toISOString(), pid: process.pid, ...event }) + "\n");
-        }
-        catch {
-            /* never break the client */
-        }
-    };
-    // --- Lease acquisition ---
-    async function acquireLease() {
-        if (currentReleaseLease) {
-            await currentReleaseLease().catch(() => { });
-            currentReleaseLease = null;
-        }
-        const lease = await requestRuntimeSocketLease(runtimeSocket, LocalControlSocketAttachClientRequestSchema.parse({
-            clientKind,
-            lease: true,
-            pid: process.pid,
-            displayName: options.displayName,
-        }));
-        currentClientId = lease.clientId;
-        currentAuthToken = lease.clientAuthToken;
-        currentReleaseLease = () => lease.release();
-        inner = createRuntimeSocketAttachedLocalControlClient({
-            runtimeSocket,
-            auth: { clientId: lease.clientId, clientAuthToken: lease.clientAuthToken },
-        });
-        log({ event: "lease_acquired", clientId: lease.clientId });
-    }
-    // --- Disconnect trigger ---
-    // Event-driven: the reconnect loop sleeps on this promise instead of
-    // polling.  Resolved by triggerReconnect() so the loop wakes immediately.
-    let disconnectResolve = null;
-    let disconnectPromise = new Promise((r) => {
-        disconnectResolve = r;
-    });
-    // Release signal: resolved by release() to unblock all pending waiters.
-    // The .catch() suppresses the unhandled-rejection when no waiter is active.
-    let releaseReject = null;
-    const releasePromise = new Promise((_, reject) => {
-        releaseReject = (err) => reject(err);
-    });
-    releasePromise.catch(() => { });
-    /**
-     * Internal: wake the background reconnect loop.  Does NOT immediately
-     * change external state — the reconnect loop decides when to surface
-     * `disconnected` vs `reconnecting` based on whether fast-reattach
-     * succeeds or fails.  This prevents transient blips from flashing
-     * "disconnected" in the UI.
-     */
-    function triggerReconnect() {
-        disconnectResolve?.();
-        disconnectPromise = new Promise((r) => {
-            disconnectResolve = r;
-        });
-    }
-    /**
-     * Try to acquire a fresh lease immediately (fast-path recovery for
-     * transient errors).  Returns true if successful.  On failure it wakes
-     * the background reconnect loop but does NOT change external state —
-     * that is the reconnect loop's responsibility.  This prevents brief
-     * transient errors from flashing "disconnected" in the UI when the
-     * daemon is actually fine.
-     */
-    async function tryFastReattach() {
-        try {
-            await acquireLease();
-            needsReconnect = false;
-            log({ event: "fast_reattach_success" });
-            return true;
-        }
-        catch (error) {
-            log({ event: "fast_reattach_failed", error: error.message });
-            // Set the internal flag so the reconnect loop knows to attempt
-            // reconnection, then wake it.  External state is NOT changed here —
-            // the reconnect loop decides when to surface "disconnected" to the UI.
-            needsReconnect = true;
-            triggerReconnect();
-            return false;
-        }
-    }
-    // --- Background reconnect loop ---
-    // Runs forever.  Sleeps on disconnectPromise while connected (no polling).
-    // When disconnected it retries with capped exponential backoff + jitter
-    // until the daemon comes back or the client is released/aborted.
-    async function reconnectLoop() {
-        let backoff = INITIAL_BACKOFF_MS;
-        while (!released && !options.signal?.aborted) {
-            if (state === "connected" && !needsReconnect) {
-                // Event-driven wait — no polling.  Wakes only when triggerReconnect()
-                // is called or the abort signal fires.
-                const loopAc = new AbortController();
-                try {
-                    await Promise.race([
-                        disconnectPromise,
-                        ...(options.signal
-                            ? [
-                                new Promise((r) => {
-                                    options.signal.addEventListener("abort", () => r(), {
-                                        once: true,
-                                        signal: loopAc.signal,
-                                    });
-                                }),
-                            ]
-                            : []),
-                    ]);
-                }
-                finally {
-                    loopAc.abort();
-                }
-                continue;
-            }
-            // Attempt reconnection.  Don't change external state to
-            // "reconnecting" / "disconnected" on the first attempt — give the
-            // daemon a chance to respond before alarming the UI.
-            const firstAttempt = state === "connected" && needsReconnect;
-            if (!firstAttempt) {
-                setState("reconnecting");
-            }
-            try {
-                await acquireLease();
-                backoff = INITIAL_BACKOFF_MS;
-                needsReconnect = false;
-                setState("connected");
-                signalConnected();
-                log({ event: "reconnect_success" });
-            }
-            catch (error) {
-                const delay = jitter(backoff);
-                log({
-                    event: "reconnect_failed",
-                    error: error.message,
-                    nextRetryMs: delay,
-                });
-                // NOW surface the disconnect — reconnect genuinely failed.
-                needsReconnect = true;
-                setState("disconnected");
-                backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
-                await backoffSleep(delay);
-            }
-        }
-    }
-    // --- Per-call waiting ---
-    // If disconnected, wait for the background loop to reconnect (up to
-    // callTimeoutMs).  Supports AbortSignal for cancellation.
-    // All racing promises are cleaned up after the race resolves to prevent
-    // timer leaks and unhandled rejections.
-    async function waitForConnection(perCallSignal) {
-        if (state === "connected" && !needsReconnect)
-            return;
-        if (released)
-            throw new Error("ResilientAttachedClient has been released");
-        if (options.signal?.aborted)
-            throw new Error("ResilientAttachedClient aborted");
-        if (perCallSignal?.aborted)
-            throw new Error("Call cancelled");
-        // Cleanup handles so we can teardown all racing promises after the race.
-        let timeoutTimer = null;
-        const ac = new AbortController(); // internal signal to clean up listeners
-        try {
-            const racers = [connectedPromise, releasePromise];
-            // Per-call timeout
-            racers.push(new Promise((_, reject) => {
-                timeoutTimer = setTimeout(() => reject(new Error("Timed out waiting for daemon reconnection")), callTimeoutMs);
-                timeoutTimer.unref?.();
-            }));
-            // Client-level abort signal
-            if (options.signal) {
-                racers.push(new Promise((_, reject) => {
-                    const onAbort = () => reject(new Error("ResilientAttachedClient aborted"));
-                    options.signal.addEventListener("abort", onAbort, { once: true, signal: ac.signal });
-                }));
-            }
-            // Per-call abort signal
-            if (perCallSignal) {
-                racers.push(new Promise((_, reject) => {
-                    const onAbort = () => reject(new Error("Call cancelled"));
-                    perCallSignal.addEventListener("abort", onAbort, { once: true, signal: ac.signal });
-                }));
-            }
-            await Promise.race(racers);
-        }
-        finally {
-            // Cleanup: cancel timeout and remove abort listeners to prevent leaks.
-            if (timeoutTimer !== null)
-                clearTimeout(timeoutTimer);
-            ac.abort();
-        }
-    }
-    // --- Call / stream wrappers ---
-    async function callWithReattach(methodName, fn) {
-        if (released)
-            throw new Error("ResilientAttachedClient has been released");
-        // Wait for a live connection (may resolve instantly or wait minutes)
-        await waitForConnection();
-        try {
-            return await fn(inner);
-        }
-        catch (error) {
-            if (!isRecoverableError(error))
-                throw error;
-            log({
-                event: "call_failed_recoverable",
-                method: methodName,
-                error: error.message,
-            });
-            // Try fast reattach first — if it succeeds, no UI disruption.
-            if (await tryFastReattach()) {
-                // Retry with the freshly-reattached connection.
-                return await fn(inner);
-            }
-            // Fast reattach failed — state is now disconnected, background loop
-            // is running.  Wait for it to reconnect then retry.
-            await waitForConnection();
-            return await fn(inner);
-        }
-    }
-    async function* streamWithReattach(methodName, fn, resubscribable) {
-        if (released)
-            throw new Error("ResilientAttachedClient has been released");
-        await waitForConnection();
-        try {
-            yield* fn(inner);
-            return;
-        }
-        catch (error) {
-            if (!isRecoverableError(error))
-                throw error;
-            log({
-                event: "stream_failed_recoverable",
-                method: methodName,
-                resubscribable,
-                error: error.message,
-            });
-            if (!resubscribable) {
-                // Non-idempotent stream (e.g. streamRun) — do NOT silently restart.
-                // Try fast reattach so the background loop is primed, then propagate
-                // the error so the caller (run orchestrator) can handle it properly
-                // via its own abort/cleanup/session-ledger mechanism.
-                await tryFastReattach();
-                throw error;
-            }
-            // Resubscribable stream (subscriptions) — try fast reattach first.
-            if (await tryFastReattach()) {
-                yield* fn(inner);
-                return;
-            }
-            // Fast reattach failed — wait for background reconnect.
-            await waitForConnection();
-            yield* fn(inner);
-        }
-    }
-    // Static set of methods that return AsyncIterable (streaming).
-    const STREAMING_METHODS = new Set([
-        "streamRun",
-        "subscribeRuntimeEvents",
-        "subscribeInbox",
-        "subscribePeers",
-        "subscribeDirectClientInbox",
-    ]);
-    // Build the proxy — every method call goes through reattach logic.
-    // IMPORTANT: we must NOT call the inner method to probe its return type,
-    // because that fires a real network request that's never awaited.
-    const api = new Proxy({}, {
-        get(_target, prop) {
-            if (prop === "then" || prop === "catch" || prop === "finally")
-                return undefined;
-            // Local wrapper-only methods: NOT RPC, never forward into the daemon API.
-            if (prop === "getConnectionState") {
-                return () => state;
-            }
-            if (prop === "onConnectionStateChange") {
-                return (listener) => {
-                    listeners.add(listener);
-                    return () => {
-                        listeners.delete(listener);
-                    };
-                };
-            }
-            if (prop === "getClientId") {
-                return () => currentClientId;
-            }
-            if (prop === "getClientAuthToken") {
-                return () => currentAuthToken;
-            }
-            if (STREAMING_METHODS.has(prop)) {
-                return (...args) => streamWithReattach(prop, 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                (client) => client[prop](...args), RESUBSCRIBABLE_STREAMS.has(prop));
-            }
-            return (...args) => 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            callWithReattach(prop, (client) => client[prop](...args));
-        },
-    });
-    // --- Bootstrap ---
-    // Acquire initial lease, then start the background loop.
-    await acquireLease();
-    setState("connected");
-    signalConnected();
-    // Fire-and-forget the background reconnect loop.
-    // It runs for the lifetime of this client.
-    void reconnectLoop();
-    return {
-        api,
-        getClientId: () => currentClientId,
-        setSessionCredentialOverlay: (input) => api.setSessionCredentialOverlay?.(input),
-        clearSessionCredentialOverlay: () => api.clearSessionCredentialOverlay?.(),
-        getClientAuthToken: () => currentAuthToken,
-        getState: () => state,
-        onStateChange: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        release: async () => {
-            released = true;
-            const releaseStack = new Error("release() caller").stack;
-            if (currentReleaseLease) {
-                await currentReleaseLease().catch(() => { });
-                currentReleaseLease = null;
-            }
-            // Unblock any pending waitForConnection() calls.
-            releaseReject?.(new Error("ResilientAttachedClient has been released"));
-            setState("disconnected");
-            log({ event: "released", clientId: currentClientId, releaseStack });
-        },
-    };
-}
-//# sourceMappingURL=attached-local-control-client.js.map