@aria-cli/cli 1.0.57 → 1.0.59

package/dist/local-control-lazy-wrapper.js

@@ -1,363 +0,0 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-export function isStaleLeaseError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const msg = error.message;
-    if (msg.includes("attached-local-client-only"))
-        return true;
-    if (msg.includes("ECONNRESET"))
-        return true;
-    if (msg.includes("ECONNREFUSED"))
-        return true;
-    if (msg.includes("EPIPE"))
-        return true;
-    if (msg.includes("connect ENOENT"))
-        return true;
-    if (msg.includes("socket hang up"))
-        return true;
-    if (msg.includes("closed before"))
-        return true;
-    if (msg.includes("has been released"))
-        return true;
-    if (msg.includes("no daemon found"))
-        return true;
-    return false;
-}
-export function enrichStaleLeaseError(error) {
-    if (!isStaleLeaseError(error))
-        return error instanceof Error ? error : new Error(String(error));
-    const original = error;
-    const msg = original.message;
-    const reason = original.reason ?? "";
-    const isSocketError = msg.includes("ECONNRESET") ||
-        msg.includes("ECONNREFUSED") ||
-        msg.includes("EPIPE") ||
-        msg.includes("connect ENOENT") ||
-        msg.includes("socket hang up") ||
-        msg.includes("closed before");
-    const hint = isSocketError
-        ? "Lost connection to the ARIA daemon. It may have restarted. Run `aria` again to reconnect."
-        : reason === "invalid_or_expired_lease" || reason === ""
-            ? "The ARIA daemon restarted and your session could not be restored. Run `aria` again to start a new session."
-            : reason === "missing_client_id" || reason === "missing_proof"
-                ? "Client credentials were not sent. This is likely a bug — please report it."
-                : reason === "no_authority"
-                    ? "The daemon has no attached-client authority configured. It may still be starting up."
-                    : `Session authentication failed (${reason}). Run \`aria\` again to start a new session.`;
-    return Object.assign(new Error(`Session expired: ${hint} (${original.message})`), {
-        code: "ARIA_SESSION_EXPIRED",
-        reason: isSocketError ? "connection_lost" : reason,
-        cause: original,
-    }, original.diagnostic !== undefined ? { diagnostic: original.diagnostic } : {});
-}
-export const REATTACH_BACKOFF_DELAYS = [0, 250, 500, 1000, 2000, 3000];
-const _reattachLogDirs = new Map();
-export function logReattach(ariaDir, event) {
-    try {
-        let logDir = _reattachLogDirs.get(ariaDir);
-        if (!logDir) {
-            logDir = join(ariaDir, "logs");
-            mkdirSync(logDir, { recursive: true });
-            _reattachLogDirs.set(ariaDir, logDir);
-        }
-        const entry = JSON.stringify({ ts: new Date().toISOString(), pid: process.pid, ...event });
-        appendFileSync(join(logDir, "reattach.jsonl"), entry + "\n");
-    }
-    catch {
-        // Never let logging break reattach flow
-    }
-}
-export function reattachSleep(ms) {
-    if (ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        timer.unref?.();
-    });
-}
-export function createLazyAttachedLocalControlApi(loader, onStaleLeaseDetected, ariaDir) {
-    let cached = null;
-    let currentState = "connected";
-    let currentClientId;
-    let currentClientAuthToken;
-    const stateListeners = new Set();
-    let innerStateUnsub = null;
-    function emitState(next) {
-        if (next === currentState)
-            return;
-        currentState = next;
-        for (const fn of stateListeners) {
-            try {
-                fn(next);
-            }
-            catch {
-                // Never let listener failures break wrapper state.
-            }
-        }
-    }
-    async function syncStateSubscription(control) {
-        innerStateUnsub?.();
-        innerStateUnsub = null;
-        const stateAware = control;
-        if (typeof stateAware.getConnectionState === "function")
-            emitState(stateAware.getConnectionState());
-        currentClientId = stateAware.getClientId?.();
-        currentClientAuthToken = stateAware.getClientAuthToken?.();
-        if (typeof stateAware.onConnectionStateChange === "function") {
-            innerStateUnsub = stateAware.onConnectionStateChange((next) => {
-                emitState(next);
-                currentClientId = stateAware.getClientId?.();
-                currentClientAuthToken = stateAware.getClientAuthToken?.();
-            });
-        }
-    }
-    const ensure = () => {
-        if (!cached) {
-            cached = loader().then(async (control) => {
-                await syncStateSubscription(control);
-                return control;
-            });
-        }
-        return cached;
-    };
-    function invalidate() {
-        cached = null;
-        onStaleLeaseDetected?.();
-    }
-    async function withReattach(fn) {
-        try {
-            const control = await ensure();
-            return await fn(control);
-        }
-        catch (error) {
-            if (!isStaleLeaseError(error))
-                throw error;
-            const trigger = error instanceof Error ? error.message : String(error);
-            if (ariaDir)
-                logReattach(ariaDir, {
-                    event: "reattach_start",
-                    trigger,
-                    maxAttempts: REATTACH_BACKOFF_DELAYS.length,
-                });
-            for (let attempt = 0; attempt < REATTACH_BACKOFF_DELAYS.length; attempt++) {
-                await reattachSleep(REATTACH_BACKOFF_DELAYS[attempt] ?? 0);
-                invalidate();
-                try {
-                    const control = await ensure();
-                    if (ariaDir)
-                        logReattach(ariaDir, { event: "reattach_success", attempt, trigger });
-                    return await fn(control);
-                }
-                catch (retryError) {
-                    const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
-                    if (ariaDir) {
-                        logReattach(ariaDir, {
-                            event: "reattach_retry_failed",
-                            attempt,
-                            error: retryMsg,
-                            willRetry: isStaleLeaseError(retryError) && attempt < REATTACH_BACKOFF_DELAYS.length - 1,
-                        });
-                    }
-                    if (!isStaleLeaseError(retryError) || attempt === REATTACH_BACKOFF_DELAYS.length - 1) {
-                        throw enrichStaleLeaseError(retryError);
-                    }
-                }
-            }
-            throw enrichStaleLeaseError(error);
-        }
-    }
-    async function* withReattachStream(fn) {
-        try {
-            const control = await ensure();
-            yield* fn(control);
-            return;
-        }
-        catch (error) {
-            if (!isStaleLeaseError(error))
-                throw error;
-            const trigger = error instanceof Error ? error.message : String(error);
-            if (ariaDir)
-                logReattach(ariaDir, {
-                    event: "reattach_stream_start",
-                    trigger,
-                    maxAttempts: REATTACH_BACKOFF_DELAYS.length,
-                });
-            for (let attempt = 0; attempt < REATTACH_BACKOFF_DELAYS.length; attempt++) {
-                await reattachSleep(REATTACH_BACKOFF_DELAYS[attempt] ?? 0);
-                invalidate();
-                try {
-                    const control = await ensure();
-                    if (ariaDir)
-                        logReattach(ariaDir, { event: "reattach_stream_success", attempt, trigger });
-                    yield* fn(control);
-                    return;
-                }
-                catch (retryError) {
-                    if (!isStaleLeaseError(retryError) || attempt === REATTACH_BACKOFF_DELAYS.length - 1) {
-                        throw enrichStaleLeaseError(retryError);
-                    }
-                }
-            }
-        }
-    }
-    return {
-        submitRun(request) {
-            return withReattach((c) => c.submitRun(request));
-        },
-        resumeRun(request) {
-            return withReattach((c) => c.resumeRun(request));
-        },
-        async *streamRun(request, signal) {
-            yield* withReattachStream((c) => c.streamRun(request, signal));
-        },
-        async *subscribeRuntimeEvents(cursor) {
-            yield* withReattachStream((c) => c.subscribeRuntimeEvents(cursor));
-        },
-        sendBestEffort(message) {
-            return withReattach((c) => c.sendBestEffort(message));
-        },
-        sendDurable(message) {
-            return withReattach((c) => c.sendDurable(message));
-        },
-        listInbox(request) {
-            return withReattach((c) => c.listInbox(request));
-        },
-        async *subscribeInbox(cursor) {
-            yield* withReattachStream((c) => c.subscribeInbox(cursor));
-        },
-        listPeers() {
-            return withReattach((c) => c.listPeers());
-        },
-        listNearbyPeers() {
-            return withReattach((c) => c.listNearbyPeers());
-        },
-        async *subscribePeers() {
-            yield* withReattachStream((c) => c.subscribePeers());
-        },
-        getRuntimeStatus() {
-            return withReattach((c) => c.getRuntimeStatus());
-        },
-        getModelSnapshot() {
-            return withReattach((c) => {
-                if (!c.getModelSnapshot)
-                    throw new Error("getModelSnapshot not available");
-                return c.getModelSnapshot();
-            });
-        },
-        refreshModelSnapshot(input) {
-            return withReattach((c) => {
-                if (!c.refreshModelSnapshot)
-                    throw new Error("refreshModelSnapshot not available");
-                return c.refreshModelSnapshot(input);
-            });
-        },
-        setCurrentModel(model) {
-            return withReattach((c) => {
-                if (!c.setCurrentModel)
-                    throw new Error("setCurrentModel not available");
-                return c.setCurrentModel(model);
-            });
-        },
-        getSessionCredentialOverlayState() {
-            return withReattach((c) => {
-                if (!c.getSessionCredentialOverlayState) {
-                    return Promise.resolve({ providers: [] });
-                }
-                return c.getSessionCredentialOverlayState();
-            });
-        },
-        setSessionCredentialOverlay(input) {
-            return withReattach((c) => {
-                if (!c.setSessionCredentialOverlay)
-                    throw new Error("setSessionCredentialOverlay not available");
-                return c.setSessionCredentialOverlay(input);
-            });
-        },
-        clearSessionCredentialOverlay() {
-            return withReattach((c) => {
-                if (!c.clearSessionCredentialOverlay)
-                    throw new Error("clearSessionCredentialOverlay not available");
-                return c.clearSessionCredentialOverlay();
-            });
-        },
-        getRuntimeBootstrap() {
-            return withReattach((c) => c.getRuntimeBootstrap());
-        },
-        listPendingPairRequests() {
-            return withReattach((c) => c.listPendingPairRequests());
-        },
-        respondToPairRequest(input) {
-            return withReattach((c) => c.respondToPairRequest(input));
-        },
-        createInvite(input) {
-            return withReattach((c) => c.createInvite(input));
-        },
-        listPendingInvites() {
-            return withReattach((c) => c.listPendingInvites());
-        },
-        acceptInviteToken(input) {
-            return withReattach((c) => c.acceptInviteToken(input));
-        },
-        cancelInvite(input) {
-            return withReattach((c) => c.cancelInvite(input));
-        },
-        invitePeer(input) {
-            return withReattach((c) => c.invitePeer(input));
-        },
-        acceptInvite(input) {
-            return withReattach((c) => c.acceptInvite(input));
-        },
-        directPair(input) {
-            return withReattach((c) => c.directPair(input));
-        },
-        revokePeer(input) {
-            return withReattach((c) => c.revokePeer(input));
-        },
-        repairPeer(input) {
-            return withReattach((c) => c.repairPeer(input));
-        },
-        listAttachedClients() {
-            return withReattach((c) => c.listAttachedClients());
-        },
-        listDirectClientInbox(request) {
-            return withReattach((c) => c.listDirectClientInbox(request));
-        },
-        async *subscribeDirectClientInbox(cursor) {
-            yield* withReattachStream((c) => c.subscribeDirectClientInbox(cursor));
-        },
-        appendSessionMessages(sessionId, messages) {
-            return withReattach((c) => c.appendSessionMessages(sessionId, messages));
-        },
-        markSessionCompleted(sessionId) {
-            return withReattach((c) => c.markSessionCompleted(sessionId));
-        },
-        replaceSessionMessages(sessionId, messages) {
-            return withReattach((c) => c.replaceSessionMessages(sessionId, messages));
-        },
-        startAutonomousLoop(input) {
-            return withReattach((c) => c.startAutonomousLoop?.(input) ??
-                Promise.reject(new Error("startAutonomousLoop not available")));
-        },
-        stopAutonomousLoop() {
-            return withReattach((c) => c.stopAutonomousLoop?.() ?? Promise.reject(new Error("stopAutonomousLoop not available")));
-        },
-        getConnectionState() {
-            return currentState;
-        },
-        getClientId() {
-            return currentClientId;
-        },
-        getClientAuthToken() {
-            return currentClientAuthToken;
-        },
-        __ariaLazyControl: true,
-        onConnectionStateChange(listener) {
-            stateListeners.add(listener);
-            return () => {
-                stateListeners.delete(listener);
-            };
-        },
-    };
-}
-//# sourceMappingURL=local-control-lazy-wrapper.js.map

package/dist/local-control-manager.js

@@ -1,146 +0,0 @@
-import { join } from "node:path";
-import { createResilientAttachedClient } from "./attached-local-control-client.js";
-import { createLazyAttachedLocalControlApi } from "./local-control-lazy-wrapper.js";
-import { log } from "@aria-cli/types";
-/**
- * Process-wide local-control manager for the CLI process.
- *
- * Responsibilities:
- * - owns the single active AttachedLocalControlClient/control used by the REPL process
- * - exposes one authoritative control object for all consumers (REPL UI,
- *   direct subscriptions, HeadlessKernel, SessionHistory IPC)
- * - forwards connection-state events from the active control
- * - allows future client replacement without consumers chasing instances
- */
-let singletonInstance = null;
-export class LocalControlManager {
-    attached;
-    listeners = new Set();
-    innerUnsub = null;
-    state = "connected";
-    stale = false;
-    released = false;
-    runtimeSocket = null;
-    managedControl;
-    /**
-     * Creates the process-wide LocalControlManager singleton.
-     * Throws if one already exists — use release() first.
-     */
-    constructor(attached) {
-        if (singletonInstance) {
-            throw new Error("LocalControlManager: another instance already exists. " +
-                "Call release() on the existing instance before creating a new one.");
-        }
-        singletonInstance = this;
-        this.attached = attached;
-        this.stale = false;
-        this.managedControl = createLazyAttachedLocalControlApi(async () => {
-            if (!this.stale) {
-                return this.attached?.control ?? attached.control;
-            }
-            const server = await import("@aria-cli/server");
-            const ariaDir = process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`;
-            const runtimeRoot = server.resolveRuntimeRootDirectory();
-            const owner = server.findRuntimeOwnerRecordByAriaHome(runtimeRoot, ariaDir);
-            if (!owner?.runtimeSocket) {
-                throw new Error("Cannot reconnect: no daemon found after restart");
-            }
-            const resilient = await createResilientAttachedClient({
-                runtimeSocket: owner.runtimeSocket,
-                clientKind: "local-api",
-                logDir: join(ariaDir, "logs"),
-            });
-            return resilient.api;
-        }, () => {
-            this.stale = true;
-        }, process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`);
-        this.bind(attached);
-    }
-    emit(next) {
-        if (next === this.state)
-            return;
-        this.state = next;
-        for (const fn of this.listeners) {
-            try {
-                fn(next);
-            }
-            catch {
-                // Never let listeners break the manager.
-            }
-        }
-    }
-    bind(attached) {
-        this.innerUnsub?.();
-        this.innerUnsub = null;
-        this.attached = attached;
-        const control = this.managedControl;
-        const current = control.getConnectionState?.() ?? attached.getConnectionState?.() ?? "connected";
-        this.emit(current);
-        const subscribe = control.onConnectionStateChange;
-        if (subscribe) {
-            this.innerUnsub = subscribe((next) => this.emit(next));
-        }
-    }
-    /** Replace the active attached client while keeping all consumers on one stable manager. */
-    replaceAttached(attached) {
-        if (this.released) {
-            throw new Error("LocalControlManager: cannot replace attached client after release(). " +
-                "Create a new manager instead.");
-        }
-        log.debug(`[LocalControlManager] Replacing attached client runtime=${attached.runtimeId} node=${attached.nodeId}`);
-        this.stale = false;
-        this.bind(attached);
-    }
-    getControl() {
-        return this.managedControl;
-    }
-    getAttached() {
-        return this.attached;
-    }
-    getCredentials() {
-        const control = this.managedControl;
-        const clientId = control.getClientId?.() ?? this.attached?.attachedClientId;
-        const clientAuthToken = control.getClientAuthToken?.() ?? this.attached?.attachedClientAuthToken;
-        if (!clientId || !clientAuthToken)
-            return null;
-        return { clientId, clientAuthToken };
-    }
-    async resolveRuntimeSocket() {
-        if (this.runtimeSocket)
-            return this.runtimeSocket;
-        try {
-            const server = await import("@aria-cli/server");
-            const ariaDir = process.env.ARIA_HOME ?? `${process.env.HOME}/.aria`;
-            const root = server.resolveRuntimeRootDirectory();
-            this.runtimeSocket =
-                server.findRuntimeOwnerRecordByAriaHome(root, ariaDir)?.runtimeSocket ?? null;
-            return this.runtimeSocket;
-        }
-        catch {
-            return null;
-        }
-    }
-    getState() {
-        return this.state;
-    }
-    onStateChange(listener) {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-    async release() {
-        if (this.released)
-            return;
-        this.released = true;
-        this.innerUnsub?.();
-        this.innerUnsub = null;
-        const attached = this.attached;
-        this.attached = null;
-        if (singletonInstance === this) {
-            singletonInstance = null;
-        }
-        await attached?.release().catch(() => { });
-    }
-}
-//# sourceMappingURL=local-control-manager.js.map

package/dist/main.js

@@ -1,62 +0,0 @@
-import "./runtime/configure-bun-sqlite.js";
-import { installProcessCrashHandlers } from "./runtime/crash-handlers.js";
-import { installOwnerLeaseIfNeeded } from "./runtime/owner-lease.js";
-import { parseInternalInvocation } from "./runtime/internal-mode.js";
-import { isPublicCommandInvocation } from "./runtime/public-mode.js";
-import { parseInteractiveInvocation } from "./runtime/interactive-invocation.js";
-import { isChildProcess, superviseInteractiveSession } from "./relaunch.js";
-import { isCompiledRuntime } from "./runtime/runtime-kind.js";
-export async function main(argv = process.argv) {
-    installProcessCrashHandlers();
-    installOwnerLeaseIfNeeded();
-    const userArgs = argv.slice(2);
-    const internal = parseInternalInvocation(userArgs);
-    if (internal) {
-        const { runInternalMode } = await import("./runtime/run-internal-mode.js");
-        await runInternalMode(internal);
-        return;
-    }
-    if (isPublicCommandInvocation(userArgs)) {
-        const { runCommandMode } = await import("./entrypoints/command-mode.js");
-        await runCommandMode(argv);
-        return;
-    }
-    const interactive = parseInteractiveInvocation(userArgs);
-    if (isChildProcess()) {
-        const { runInteractiveEntrypoint } = await import("./entrypoints/interactive.js");
-        await runInteractiveEntrypoint(interactive);
-        return;
-    }
-    // Compiled binary: run REPL directly in this process instead of spawning
-    // a supervisor + child (which loads the 82MB binary twice). Saves ~3-13s
-    // on cold start. Relaunch (rare) spawns a new process in supervisor mode.
-    // ARIA_USE_SUPERVISOR is set by requestRelaunch() to force the supervisor
-    // path on respawned processes, preventing waiter process accumulation.
-    if (isCompiledRuntime() && !process.env.ARIA_USE_SUPERVISOR) {
-        await runCompiledDirect(interactive);
-        return;
-    }
-    await superviseInteractiveSession(interactive);
-}
-/**
- * Compiled-binary direct mode: run the REPL in-process (single binary load).
- *
- * The normal supervisor pattern loads the 82MB binary twice (parent + child).
- * In compiled mode, we skip the supervisor and run the REPL directly. If the
- * user requests a relaunch (rare), requestRelaunch() spawns a new process
- * with resume env vars — the current process waits and propagates exit code.
- */
-async function runCompiledDirect(interactive) {
-    const { NO_RELAUNCH_ENV } = await import("@aria-cli/types");
-    process.env[NO_RELAUNCH_ENV] = "true";
-    const { runInteractiveEntrypoint } = await import("./entrypoints/interactive.js");
-    await runInteractiveEntrypoint(interactive);
-}
-if (import.meta.main) {
-    main(process.argv).catch((error) => {
-        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-        process.stderr.write(`${message}\n`);
-        process.exit(1);
-    });
-}
-//# sourceMappingURL=main.js.map

package/dist/network-security.js

@@ -1,62 +0,0 @@
-import { createHash } from "node:crypto";
-import * as nodePath from "node:path";
-import { PrincipalFingerprintSchema, SigningPublicKeySchema, TlsCaFingerprintSchema, } from "@aria-cli/tools/network-runtime";
-const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
-export function isLocalCoordinationHost(hostname) {
-    if (LOCAL_HOSTS.has(hostname))
-        return true;
-    return hostname.toLowerCase().endsWith(".localhost");
-}
-export function parseAndValidateCoordinationUrl(rawUrl) {
-    let parsed;
-    try {
-        parsed = new URL(rawUrl);
-    }
-    catch {
-        throw new Error(`Invalid coordination URL: ${rawUrl}`);
-    }
-    const hostname = parsed.hostname.toLowerCase();
-    if (parsed.protocol === "https:")
-        return parsed;
-    if (parsed.protocol === "http:" && isLocalCoordinationHost(hostname))
-        return parsed;
-    throw new Error(`Insecure coordination URL "${rawUrl}". Use https:// (http:// allowed only for localhost).`);
-}
-export function normalizeTlsCaFingerprintId(fingerprint) {
-    const normalized = TlsCaFingerprintSchema.parse(fingerprint).trim().toLowerCase();
-    if (!/^[a-f0-9]{16,128}$/.test(normalized)) {
-        throw new Error("Invalid fingerprint format for trusted CA path");
-    }
-    return normalized;
-}
-function normalizePrincipalFingerprintId(fingerprint) {
-    const normalized = PrincipalFingerprintSchema.parse(fingerprint).trim().toLowerCase();
-    if (!/^[a-f0-9]{16,128}$/.test(normalized)) {
-        throw new Error("Invalid fingerprint format for responder identity");
-    }
-    return normalized;
-}
-export function trustedCaPathForFingerprint(ariaDir, fingerprint) {
-    const id = normalizeTlsCaFingerprintId(fingerprint);
-    const trustedDir = nodePath.resolve(nodePath.join(ariaDir, "network", "trusted-cas"));
-    const targetPath = nodePath.resolve(nodePath.join(trustedDir, `${id}.pem`));
-    if (!targetPath.startsWith(`${trustedDir}${nodePath.sep}`)) {
-        throw new Error("Trusted CA path escapes trusted-cas directory");
-    }
-    return targetPath;
-}
-export function signingKeyFingerprintHex(signingPublicKeyB64) {
-    return PrincipalFingerprintSchema.parse(createHash("sha256")
-        .update(Buffer.from(SigningPublicKeySchema.parse(signingPublicKeyB64), "base64"))
-        .digest("hex"));
-}
-export function assertResponderIdentityMatchesExpectedFingerprint(expectedFingerprint, responderSigningPublicKeyB64) {
-    if (!expectedFingerprint)
-        return;
-    const expected = normalizePrincipalFingerprintId(expectedFingerprint);
-    const actual = signingKeyFingerprintHex(responderSigningPublicKeyB64);
-    if (!(actual === expected || actual.startsWith(expected))) {
-        throw new Error("Responder signing key fingerprint mismatch");
-    }
-}
-//# sourceMappingURL=network-security.js.map

package/dist/networking-server.js

@@ -1,38 +0,0 @@
-/**
- * CLI adapter over the real server-owned NodeRuntime.
- *
- * Machine-local attach/start semantics now route through the server-owned
- * HostSupervisor. This file is only the CLI adapter layer.
- */
-import { HostSupervisorSplitBrainError, getHostSupervisor, } from "@aria-cli/server";
-/**
- * Start the ARIA networking server — shared between interactive and daemon modes.
- * Returns null if this arion is already running (caller should use client mode).
- */
-export async function ensureNetworkingServer(opts) {
-    const supervisor = getHostSupervisor();
-    let attachment;
-    try {
-        attachment = await supervisor.attach({
-            ...opts,
-            clientKind: "daemon-launcher",
-        });
-    }
-    catch (error) {
-        if (error instanceof HostSupervisorSplitBrainError) {
-            return null;
-        }
-        throw error;
-    }
-    const cleanup = async () => {
-        attachment.release();
-        if (attachment.ownership === "started") {
-            await supervisor.shutdownRuntime(attachment.nodeId);
-        }
-    };
-    return {
-        ...attachment.runtime,
-        cleanup,
-    };
-}
-//# sourceMappingURL=networking-server.js.map