@boxes-dev/dvb-runtime 1.0.298 → 1.0.299

package/dist/devbox/commands/connect.js

@@ -1,1367 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import os from "node:os";
-import { createInterface as createLineReader } from "node:readline";
-import readline from "node:readline/promises";
-import { resolveSocketInfo } from "@boxes-dev/core";
-import { CONTROL_TTY_REPLACED_CLOSE_CODE, createSecretStore, createSpritesClient, loadConfig, readSpriteSessions, resolveProjectWorkdir, resolveRelayBaseUrl, writeSpriteSessions, } from "@boxes-dev/core";
-import { DAEMON_TIMEOUT_MS, ensureDaemonRunning, requestJson, requireDaemonFeatures, throwDaemonResponseError, } from "../daemonClient.js";
-import { ensureSpritesToken } from "../auth.js";
-import { openBrowser } from "../browser.js";
-import { logger } from "../logger.js";
-import { createLatencyTracker } from "../latency.js";
-import { streamExecSession, } from "../terminal/sessionProtocol.js";
-import { createStatusLine } from "../ui/statusLine.js";
-import { recordCompletionSessionsFromMap } from "../completions/index.js";
-import { listDevboxes, selectDevbox } from "./boxSelect.js";
-import { assertCommandProviderCapability, hasCommandProviderCapability, resolveCommandComputeProvider, } from "./commandProvider.js";
-import { finalizeAutoNamedSession, initializeSessionMapState, refreshSessionMapState, renameMappedSession, } from "./connectSessionMapping.js";
-import { resolveRuntimeClient } from "./runtimeClient.js";
-import { resolveRemoteHome } from "./sshAccess.js";
-import { buildSessionLogPath, shellQuote } from "./sessionUtils.js";
-import { parseCommandArgs, readBooleanFlag, readStringFlag, } from "../commandRegistry/args.js";
-import { usageError } from "../commandRegistry/errors.js";
-export const resolveInitialSessionId = ({ supportsAttachExecSession, sessionIdOverride, sessionName, sessions, requireFreshSessionOpen, }) => {
-    if (!supportsAttachExecSession)
-        return undefined;
-    if (sessionIdOverride)
-        return sessionIdOverride;
-    if (requireFreshSessionOpen)
-        return undefined;
-    return sessionName ? sessions[sessionName] : undefined;
-};
-export const shouldAttachToExistingSession = ({ supportsAttachExecSession, sessionId, requireFreshSessionOpen, }) => supportsAttachExecSession && Boolean(sessionId) && !requireFreshSessionOpen;
-export const resolveSessionSpecifierFromExplicitTarget = ({ sessionName, availableSessions, }) => {
-    const requested = sessionName?.trim();
-    if (!requested) {
-        return { sessionName, sessionIdOverride: undefined };
-    }
-    const match = availableSessions.find((session) => session.id === requested && session.tty !== false);
-    if (!match) {
-        return { sessionName, sessionIdOverride: undefined };
-    }
-    return { sessionName: undefined, sessionIdOverride: match.id };
-};
-export const isAttachReplacedCloseCode = (closeCode) => closeCode === CONTROL_TTY_REPLACED_CLOSE_CODE;
-export const shouldCancelConnectOnSigint = (phase) => phase !== "attached";
-export const isRawCtrlCChunk = (chunk) => chunk.length === 1 && chunk[0] === 0x03;
-export const normalizeTtyTerm = (term) => {
-    const trimmed = term?.trim() ?? "";
-    const normalized = trimmed.toLowerCase();
-    if (!trimmed || normalized === "dumb" || normalized === "unknown") {
-        return "xterm-256color";
-    }
-    return trimmed;
-};
-const DEFAULT_TTY_COLS = 80;
-const DEFAULT_TTY_ROWS = 24;
-const TERMINAL_INPUT_MODE_RESET = [
-    "\u001b[?1004l", // disable focus in/out reporting
-    "\u001b[?2004l", // disable bracketed paste
-    "\u001b[>4;0m", // disable xterm modifyOtherKeys (CSI-u style ctrl keys)
-    "\u001b[<u", // disable kitty keyboard protocol
-].join("");
-const resetTerminalInputModes = () => {
-    const stream = process.stderr.isTTY
-        ? process.stderr
-        : process.stdout.isTTY
-            ? process.stdout
-            : null;
-    if (!stream)
-        return;
-    try {
-        stream.write(TERMINAL_INPUT_MODE_RESET);
-    }
-    catch {
-        // ignore terminal reset failures
-    }
-};
-const warnSetupStatus = (status, spriteAlias) => {
-    if (status === "complete")
-        return;
-    if (status === "local_required") {
-        console.warn(`Warning: devbox setup incomplete for ${spriteAlias}. Resume from the repo with \`dvb init --resume\`.`);
-        return;
-    }
-    if (status === "remote_ready") {
-        console.warn(`Warning: devbox setup incomplete for ${spriteAlias}. Finish setup with \`dvb init --resume\`.`);
-    }
-};
-const resolveTtyEnv = (terminalSessionId) => {
-    const env = {};
-    env.TERM = normalizeTtyTerm(process.env.TERM);
-    const colorterm = process.env.COLORTERM?.trim();
-    if (colorterm)
-        env.COLORTERM = colorterm;
-    if (terminalSessionId)
-        env.DEVBOX_TERM_SESSION_ID = terminalSessionId;
-    return env;
-};
-const formatEnvExports = (env) => Object.entries(env)
-    .map(([key, value]) => `export ${key}=${shellQuote(value)}`)
-    .join("; ");
-const parseEnvSize = (value) => {
-    if (!value)
-        return undefined;
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0)
-        return undefined;
-    return Math.floor(parsed);
-};
-const readStreamSize = (stream) => {
-    const cols = stream.columns;
-    const rows = stream.rows;
-    if (typeof cols !== "number" || cols <= 0)
-        return null;
-    if (typeof rows !== "number" || rows <= 0)
-        return null;
-    return { cols, rows };
-};
-const resolveTtySize = () => {
-    const stdoutSize = readStreamSize(process.stdout);
-    if (stdoutSize)
-        return stdoutSize;
-    const stderrSize = readStreamSize(process.stderr);
-    if (stderrSize)
-        return stderrSize;
-    const envCols = parseEnvSize(process.env.COLUMNS);
-    const envRows = parseEnvSize(process.env.LINES);
-    return {
-        cols: envCols ?? DEFAULT_TTY_COLS,
-        rows: envRows ?? DEFAULT_TTY_ROWS,
-    };
-};
-const resolveSessionEnv = (terminalSessionId, sessionName) => {
-    const env = {};
-    if (terminalSessionId)
-        env.DEVBOX_TERM_SESSION_ID = terminalSessionId;
-    if (sessionName) {
-        env[SESSION_NAME_TOKEN_KEY] = encodeSessionNameToken(sessionName);
-    }
-    return env;
-};
-const parseReachabilityState = (output) => {
-    const lines = output
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    for (const line of lines) {
-        if (line.startsWith("Not Reachable"))
-            return "not_reachable";
-    }
-    for (const line of lines) {
-        if (line.startsWith("Reachable"))
-            return "reachable";
-    }
-    return "unknown";
-};
-const runCommand = async (command, args) => new Promise((resolve) => {
-    const child = spawn(command, args, {
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    let stderr = "";
-    if (child.stdout) {
-        child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-    }
-    if (child.stderr) {
-        child.stderr.setEncoding("utf8");
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-    }
-    child.on("error", () => resolve({ ok: false, stdout, stderr }));
-    child.on("close", (code) => resolve({ ok: code === 0, stdout, stderr }));
-});
-const checkReachability = async (targetHost) => {
-    const result = await runCommand("scutil", ["-r", targetHost]);
-    if (!result.ok)
-        return "unknown";
-    return parseReachabilityState(result.stdout);
-};
-const watchReachabilityWithScutil = (targetHost, signal) => new Promise((resolve) => {
-    let settled = false;
-    let rl = null;
-    const child = spawn("scutil", ["-r", "-W", targetHost], {
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    const finish = (result) => {
-        if (settled)
-            return;
-        settled = true;
-        cleanup();
-        resolve(result);
-    };
-    const onAbort = () => finish("aborted");
-    const onError = () => finish("error");
-    const onClose = () => finish("error");
-    const cleanup = () => {
-        signal.removeEventListener("abort", onAbort);
-        rl?.removeAllListeners();
-        rl?.close();
-        if (child.stdout)
-            child.stdout.removeAllListeners();
-        if (child.stderr)
-            child.stderr.removeAllListeners();
-        child.removeListener("error", onError);
-        child.removeListener("close", onClose);
-        if (child.exitCode === null && !child.killed) {
-            try {
-                child.kill();
-            }
-            catch {
-                // ignore kill failure
-            }
-        }
-    };
-    if (signal.aborted) {
-        finish("aborted");
-        return;
-    }
-    signal.addEventListener("abort", onAbort);
-    child.on("error", onError);
-    child.on("close", onClose);
-    if (!child.stdout) {
-        finish("error");
-        return;
-    }
-    child.stdout.setEncoding("utf8");
-    rl = createLineReader({ input: child.stdout });
-    rl.on("line", (line) => {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("Reachable")) {
-            finish("online");
-        }
-    });
-});
-const watchReachabilityWithNotifyutil = (targetHost, signal) => new Promise((resolve) => {
-    let settled = false;
-    let checking = false;
-    let pending = false;
-    let rl = null;
-    const child = spawn("notifyutil", ["-w", "com.apple.system.config.network_change"], { stdio: ["ignore", "pipe", "pipe"] });
-    const finish = (result) => {
-        if (settled)
-            return;
-        settled = true;
-        cleanup();
-        resolve(result);
-    };
-    const onAbort = () => finish("aborted");
-    const onError = () => finish("error");
-    const onClose = () => finish("error");
-    const cleanup = () => {
-        signal.removeEventListener("abort", onAbort);
-        rl?.removeAllListeners();
-        rl?.close();
-        if (child.stdout)
-            child.stdout.removeAllListeners();
-        if (child.stderr)
-            child.stderr.removeAllListeners();
-        child.removeListener("error", onError);
-        child.removeListener("close", onClose);
-        if (child.exitCode === null && !child.killed) {
-            try {
-                child.kill();
-            }
-            catch {
-                // ignore kill failure
-            }
-        }
-    };
-    if (signal.aborted) {
-        finish("aborted");
-        return;
-    }
-    signal.addEventListener("abort", onAbort);
-    child.on("error", onError);
-    child.on("close", onClose);
-    if (!child.stdout) {
-        finish("error");
-        return;
-    }
-    const triggerCheck = () => {
-        if (settled)
-            return;
-        if (checking) {
-            pending = true;
-            return;
-        }
-        checking = true;
-        void (async () => {
-            const state = await checkReachability(targetHost);
-            if (state === "reachable") {
-                finish("online");
-                return;
-            }
-            checking = false;
-            if (pending) {
-                pending = false;
-                triggerCheck();
-            }
-        })();
-    };
-    child.stdout.setEncoding("utf8");
-    rl = createLineReader({ input: child.stdout });
-    rl.on("line", () => {
-        triggerCheck();
-    });
-    triggerCheck();
-});
-const waitForNetworkOnline = async (options) => {
-    if (process.platform !== "darwin")
-        return "skipped";
-    if (!options.targetHost)
-        return "skipped";
-    const initial = await checkReachability(options.targetHost);
-    if (initial !== "not_reachable")
-        return "skipped";
-    resetTerminalInputModes();
-    options.onStatus?.("Waiting for network");
-    options.onNotice?.("Network offline. Waiting for connectivity... (Ctrl+C to cancel)");
-    const controller = new AbortController();
-    const onSigint = () => controller.abort();
-    process.once("SIGINT", onSigint);
-    try {
-        const watchResult = await watchReachabilityWithScutil(options.targetHost, controller.signal);
-        if (watchResult === "online")
-            return "waited";
-        if (watchResult === "aborted")
-            return "aborted";
-        const fallback = await watchReachabilityWithNotifyutil(options.targetHost, controller.signal);
-        if (fallback === "online")
-            return "waited";
-        if (fallback === "aborted")
-            return "aborted";
-    }
-    finally {
-        process.removeListener("SIGINT", onSigint);
-    }
-    return "skipped";
-};
-const parseConnectArgs = (args) => {
-    const { flags, positionals } = parseCommandArgs({
-        args,
-        commandPath: ["connect"],
-        flagLabel: "connect",
-        boolean: ["detach", "no-log"],
-        string: ["name", "command"],
-        aliases: { n: "name" },
-    });
-    if (positionals.length > 1) {
-        throw usageError(["connect"], `Unexpected argument: ${positionals[1]}`);
-    }
-    const target = positionals[0];
-    const name = readStringFlag(flags, "name");
-    const command = readStringFlag(flags, "command");
-    return {
-        ...(target ? { target } : {}),
-        ...(name ? { name } : {}),
-        ...(command ? { command } : {}),
-        ...(readBooleanFlag(flags, "detach") ? { detach: true } : {}),
-        ...(readBooleanFlag(flags, "no-log") ? { noLog: true } : {}),
-    };
-};
-const parseConnectTarget = (value) => {
-    const slashIndex = value.indexOf("/");
-    if (slashIndex === -1) {
-        return { box: value, session: undefined };
-    }
-    const box = value.slice(0, slashIndex);
-    const session = value.slice(slashIndex + 1);
-    if (!box || !session) {
-        throw new Error("Invalid connect target. Use <box> or <box>/<session>.");
-    }
-    return { box, session };
-};
-const SESSION_NAME_TOKEN_KEY = "DEVBOX_SESSION_NAME_B64";
-const encodeSessionNameToken = (sessionName) => Buffer.from(sessionName, "utf8").toString("base64url");
-const SESSION_LOG_FLUSH_BYTES = 24 * 1024;
-const SESSION_LOG_EOF_MARKER = "__DVB_LOG_EOF__";
-const createRemoteSessionLogSink = (client, spriteAlias, logPath) => {
-    let bufferedBytes = 0;
-    let chunks = [];
-    let closed = false;
-    let appendQueue = Promise.resolve();
-    const appendRemote = (payload) => {
-        const encoded = payload.toString("base64");
-        const command = [
-            `log_dir=$(dirname ${shellQuote(logPath)})`,
-            'mkdir -p "$log_dir"',
-            `base64 -d >> ${shellQuote(logPath)} <<'${SESSION_LOG_EOF_MARKER}'`,
-            encoded,
-            SESSION_LOG_EOF_MARKER,
-        ].join("\n");
-        appendQueue = appendQueue
-            .then(async () => {
-            const result = await client.exec(spriteAlias, [
-                "/bin/bash",
-                "-lc",
-                command,
-            ]);
-            if (result.exitCode !== 0) {
-                logger.warn("session_log_append_failed", {
-                    box: spriteAlias,
-                    logPath,
-                    exitCode: result.exitCode,
-                });
-            }
-        })
-            .catch((error) => {
-            logger.warn("session_log_append_failed", {
-                box: spriteAlias,
-                logPath,
-                error: String(error),
-            });
-        });
-    };
-    const flush = (force) => {
-        if (bufferedBytes === 0)
-            return;
-        if (!force && bufferedBytes < SESSION_LOG_FLUSH_BYTES)
-            return;
-        const payload = Buffer.concat(chunks, bufferedBytes);
-        chunks = [];
-        bufferedBytes = 0;
-        appendRemote(payload);
-    };
-    return {
-        write: (chunk) => {
-            if (closed || chunk.length === 0)
-                return;
-            chunks.push(Buffer.from(chunk));
-            bufferedBytes += chunk.length;
-            flush(false);
-        },
-        close: async () => {
-            if (closed) {
-                await appendQueue;
-                return;
-            }
-            closed = true;
-            flush(true);
-            await appendQueue;
-        },
-    };
-};
-const CONNECT_SHELL_CANDIDATES = ["/bin/zsh", "/bin/bash", "/bin/sh"];
-const buildConnectShellProbeCommand = (shellPath) => [
-    "/bin/bash",
-    "--noprofile",
-    "--norc",
-    "-lc",
-    `[ -x ${shellQuote(shellPath)} ] && printf '%s\\n' ${shellQuote(shellPath)}`,
-];
-export const resolveConnectShell = async (client, spriteAlias) => {
-    for (const shellPath of CONNECT_SHELL_CANDIDATES) {
-        const result = await client.exec(spriteAlias, buildConnectShellProbeCommand(shellPath));
-        if (result.exitCode !== 0)
-            continue;
-        const resolved = result.stdout.trim();
-        if (resolved === shellPath) {
-            return shellPath;
-        }
-    }
-    throw new Error("No interactive shell found on devbox. Expected one of /bin/zsh, /bin/bash, or /bin/sh.");
-};
-const confirmNewSession = async (name) => {
-    if (!process.stdin.isTTY) {
-        throw new Error(`Session "${name}" not found. Run in a TTY to confirm creation.`);
-    }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const answer = await rl.question(`Session "${name}" does not exist. Create it? (y/N) `);
-    rl.close();
-    return answer.trim().toLowerCase() === "y";
-};
-const promptRenameSession = async (current) => {
-    if (!process.stdin.isTTY)
-        return null;
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const answer = await rl.question(`Name this session? (enter to keep "${current}") `);
-    rl.close();
-    const trimmed = answer.trim();
-    return trimmed.length ? trimmed : null;
-};
-const CONNECT_OPEN_TIMEOUT_MS = 20_000;
-export const runConnect = async (args, overrides) => {
-    const parsed = parseConnectArgs(args);
-    const latency = createLatencyTracker();
-    const initialInput = overrides?.initialInput;
-    let sessionIdOverride = overrides?.sessionIdOverride;
-    const disableAutoName = overrides?.disableAutoName ?? Boolean(sessionIdOverride);
-    let targetArg = parsed.target;
-    if (!targetArg) {
-        const selected = await selectDevbox("Use `dvb connect <box>` to connect to a specific box.");
-        if (!selected)
-            return;
-        targetArg = selected.box;
-    }
-    if (parsed.command && parsed.detach) {
-        throw new Error("Cannot combine --command and --detach.");
-    }
-    if (!process.stdin.isTTY && !parsed.command && !parsed.detach) {
-        throw new Error("dvb connect requires a TTY (or use --command/--detach).");
-    }
-    const parsedTarget = parseConnectTarget(targetArg);
-    let target = parsedTarget;
-    if (target.session && parsed.name) {
-        throw new Error("Provide session name via -n or <box>/<session>, not both.");
-    }
-    let sessionName = parsed.name ?? target.session;
-    if (sessionIdOverride) {
-        sessionName = undefined;
-    }
-    let explicitName = Boolean(sessionName);
-    let autoNameRequested = !explicitName && !parsed.command && !disableAutoName;
-    let autoNamed = false;
-    if (sessionName && parsed.command) {
-        throw new Error("Cannot use --command with a named session.");
-    }
-    const isDetached = Boolean(parsed.detach);
-    const isTty = !parsed.command;
-    let shouldLog = isTty && !parsed.noLog;
-    const statusEnabled = isTty && !parsed.command && !isDetached && process.stderr.isTTY;
-    let allowStatus = statusEnabled;
-    const status = createStatusLine({ enabled: statusEnabled });
-    const stage = (text) => {
-        if (!allowStatus)
-            return;
-        status.stage(text);
-    };
-    const shouldReportSession = isTty && !parsed.command && !isDetached;
-    const pauseStatus = () => {
-        if (statusEnabled)
-            status.stop();
-    };
-    const pendingPortLogs = new Map();
-    let nextPortLogToken = 1;
-    try {
-        stage("Starting dvbd");
-        const socketInfo = resolveSocketInfo();
-        await ensureDaemonRunning(socketInfo.socketPath);
-        await requireDaemonFeatures(socketInfo.socketPath, ["registry", "ports"]);
-        let boxes = null;
-        if (parsed.target) {
-            try {
-                boxes = await listDevboxes();
-            }
-            catch (error) {
-                logger.warn("registry_boxes_lookup_failed", { error: String(error) });
-            }
-        }
-        if (parsed.target && !parsedTarget.session) {
-            if (boxes && boxes.length === 1) {
-                const onlyBox = boxes[0];
-                const alias = onlyBox?.alias?.trim() ?? "";
-                const canonical = onlyBox?.canonical?.trim() ?? "";
-                const matchesBoxName = (alias.length > 0 && targetArg === alias) ||
-                    (canonical.length > 0 && targetArg === canonical);
-                if (!matchesBoxName) {
-                    const handle = alias;
-                    if (handle) {
-                        target = { box: handle, session: targetArg };
-                        if (!sessionName) {
-                            sessionName = targetArg;
-                        }
-                    }
-                }
-            }
-        }
-        stage("Resolving devbox target");
-        let spriteAlias = target.box;
-        if (!boxes) {
-            const response = await requestJson(socketInfo.socketPath, "GET", "/boxes", DAEMON_TIMEOUT_MS.registry);
-            if (response.status !== 200) {
-                throwDaemonResponseError(response);
-            }
-            boxes = response.body.boxes;
-        }
-        const matchedEntry = boxes.find((entry) => entry.alias === spriteAlias) ??
-            boxes.find((entry) => entry.canonical === spriteAlias) ??
-            null;
-        if (matchedEntry?.alias && matchedEntry.alias !== spriteAlias) {
-            spriteAlias = matchedEntry.alias;
-            target = { ...target, box: spriteAlias };
-        }
-        const providerTarget = await resolveCommandComputeProvider({
-            box: spriteAlias,
-            boxes,
-            homeDir: process.env.HOME ?? os.homedir(),
-        });
-        spriteAlias = providerTarget.alias;
-        target = { ...target, box: spriteAlias };
-        const computeProvider = providerTarget.computeProvider;
-        assertCommandProviderCapability({
-            provider: computeProvider,
-            command: "connect",
-            capability: "exec.sessions.open",
-        });
-        const supportsAttachExecSession = hasCommandProviderCapability({
-            provider: computeProvider,
-            command: "connect",
-            capability: "exec.sessions.attach",
-        });
-        const supportsListExecSessions = hasCommandProviderCapability({
-            provider: computeProvider,
-            command: "connect",
-            capability: "exec.sessions.list",
-        });
-        const supportsResizeControlMessages = computeProvider === "sprites" ||
-            computeProvider === "modal" ||
-            computeProvider === "e2b";
-        let client;
-        let networkTargetHost = null;
-        if (computeProvider === "modal" || computeProvider === "e2b") {
-            stage("Loading managed devbox access");
-            client = await resolveRuntimeClient({
-                provider: computeProvider,
-                alias: spriteAlias,
-                targetBox: target.box ?? spriteAlias,
-                cwd: process.cwd(),
-                failureContext: "connect",
-                stage,
-            });
-        }
-        else {
-            stage("Loading devbox config");
-            const config = await loadConfig(process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-            const store = await createSecretStore(config?.tokenStore, process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-            const relayBaseUrl = resolveRelayBaseUrl(config);
-            const { token } = await ensureSpritesToken(store, stage);
-            networkTargetHost = (() => {
-                try {
-                    return new URL(relayBaseUrl).hostname || null;
-                }
-                catch {
-                    return null;
-                }
-            })();
-            const spritesClient = createSpritesClient({
-                apiBaseUrl: relayBaseUrl,
-                token,
-            });
-            client = spritesClient;
-            stage("Checking devbox exists");
-            const sprite = await spritesClient.getSprite(spriteAlias);
-            if (!sprite) {
-                throw new Error(`No devbox found named "${target.box}". Run "dvb init" in a repo to create one, or "dvb list" to see existing devboxes.`);
-            }
-        }
-        if (!sessionIdOverride &&
-            sessionName &&
-            supportsAttachExecSession &&
-            supportsListExecSessions) {
-            try {
-                const available = await client.listExecSessions(spriteAlias);
-                const resolved = resolveSessionSpecifierFromExplicitTarget({
-                    sessionName,
-                    availableSessions: available,
-                });
-                if (resolved.sessionIdOverride) {
-                    sessionIdOverride = resolved.sessionIdOverride;
-                    sessionName = undefined;
-                    explicitName = false;
-                    autoNameRequested = false;
-                    latency?.setContext({ box: spriteAlias });
-                }
-            }
-            catch (error) {
-                logger.warn("session_id_resolution_failed", { error: String(error) });
-            }
-        }
-        stage("Syncing devbox");
-        const notifyPortEvent = (event) => {
-            if (event.type !== "port_opened") {
-                pendingPortLogs.delete(event.port);
-                return;
-            }
-            const token = nextPortLogToken;
-            nextPortLogToken += 1;
-            pendingPortLogs.set(event.port, token);
-            const delays = [30, 60, 120, 200];
-            void (async () => {
-                for (const delay of delays) {
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                    if (pendingPortLogs.get(event.port) !== token) {
-                        return;
-                    }
-                    try {
-                        const response = await requestJson(socketInfo.socketPath, "GET", "/ports", DAEMON_TIMEOUT_MS.quick);
-                        if (response.status < 200 || response.status >= 300) {
-                            continue;
-                        }
-                        const forward = response.body.forwards.find((entry) => entry.box === spriteAlias && entry.remotePort === event.port);
-                        if (forward) {
-                            console.error(`Forwarded ${spriteAlias}:${event.port} -> 127.0.0.1:${forward.localPort}`);
-                            pendingPortLogs.delete(event.port);
-                            return;
-                        }
-                    }
-                    catch (error) {
-                        logger.warn("ports_snapshot_failed", { error: String(error) });
-                    }
-                }
-                if (pendingPortLogs.get(event.port) === token) {
-                    pendingPortLogs.delete(event.port);
-                }
-            })();
-        };
-        try {
-            const response = await requestJson(socketInfo.socketPath, "POST", "/registry/usage", DAEMON_TIMEOUT_MS.registry, { alias: spriteAlias });
-            if (response.status !== 200) {
-                logger.warn("registry_usage_failed", {
-                    status: response.status,
-                    error: response.body?.error,
-                });
-            }
-        }
-        catch (error) {
-            logger.warn("registry_usage_failed", { error: String(error) });
-        }
-        let setupStatus = null;
-        try {
-            const resolvedBoxes = boxes
-                ? { status: 200, body: { boxes } }
-                : await requestJson(socketInfo.socketPath, "GET", "/boxes", DAEMON_TIMEOUT_MS.registry);
-            if (resolvedBoxes.status === 200) {
-                const summary = resolvedBoxes.body.boxes.find((box) => box.alias === spriteAlias);
-                setupStatus = summary?.setupStatus ?? null;
-            }
-        }
-        catch (error) {
-            logger.warn("registry_setup_status_failed", { error: String(error) });
-        }
-        if (setupStatus && setupStatus !== "complete") {
-            pauseStatus();
-            warnSetupStatus(setupStatus, spriteAlias);
-        }
-        stage("Preparing devbox");
-        if (computeProvider !== "modal") {
-            await client.exec(spriteAlias, [
-                "/bin/bash",
-                "-lc",
-                "mkdir -p ~/.devbox",
-            ]);
-        }
-        let projectWorkdir = null;
-        try {
-            projectWorkdir = await resolveProjectWorkdir(client, spriteAlias);
-        }
-        catch (error) {
-            logger.warn("workdir_lookup_failed", {
-                box: spriteAlias,
-                error: String(error),
-            });
-        }
-        const connectShell = computeProvider === "modal"
-            ? "/bin/bash"
-            : await resolveConnectShell(client, spriteAlias);
-        const warnSessionMap = (event, fields) => logger.warn(event, fields);
-        const initialSessionState = await initializeSessionMapState({
-            client,
-            alias: spriteAlias,
-            sessionName,
-            autoNameRequested,
-            onWarn: warnSessionMap,
-        });
-        let sessions = initialSessionState.sessions;
-        sessionName = initialSessionState.sessionName;
-        autoNamed = initialSessionState.autoNamed;
-        let requireFreshSessionOpen = initialSessionState.requireFreshSessionOpen;
-        let sessionId = resolveInitialSessionId({
-            supportsAttachExecSession,
-            sessionIdOverride,
-            sessionName,
-            sessions,
-            requireFreshSessionOpen,
-        });
-        let confirmedCreateExplicit = Boolean(sessionId && explicitName);
-        if (latency) {
-            if (sessionName) {
-                latency.setContext({ box: spriteAlias, session: sessionName });
-            }
-            else {
-                latency.setContext({ box: spriteAlias });
-            }
-        }
-        const refreshSessionMapping = async () => {
-            const refreshed = await refreshSessionMapState({
-                client,
-                alias: spriteAlias,
-                computeProvider,
-                supportsAttachExecSession,
-                supportsListExecSessions,
-                sessionName,
-                sessionId,
-                sessions,
-                requireFreshSessionOpen,
-                explicitName,
-                onWarn: warnSessionMap,
-            });
-            sessions = refreshed.sessions;
-            sessionId = refreshed.sessionId;
-            if (refreshed.confirmedCreateExplicit) {
-                confirmedCreateExplicit = true;
-            }
-        };
-        const remoteHome = await resolveRemoteHome(client, spriteAlias);
-        const finalizeAutoSession = async (id) => {
-            const finalized = await finalizeAutoNamedSession({
-                client,
-                alias: spriteAlias,
-                autoNamed,
-                sessionName,
-                sessionId: id,
-                sessions,
-                remoteHome,
-                onWarn: warnSessionMap,
-            });
-            sessions = finalized.sessions;
-            sessionName = finalized.sessionName;
-            if (finalized.renamed && latency && sessionName) {
-                latency.setContext({ box: spriteAlias, session: sessionName });
-            }
-        };
-        const renameSessionMapping = async (fromName, toName, expectedId) => {
-            const latest = await renameMappedSession({
-                client,
-                alias: spriteAlias,
-                fromName,
-                toName,
-                expectedId,
-                remoteHome,
-                sessions,
-            });
-            sessions = latest;
-            sessionName = toName;
-            autoNamed = false;
-            if (latency) {
-                latency.setContext({ box: spriteAlias, session: sessionName });
-            }
-        };
-        await refreshSessionMapping();
-        if (explicitName && sessionName && !sessionId) {
-            pauseStatus();
-            const confirmed = await confirmNewSession(sessionName);
-            if (!confirmed) {
-                throw new Error(`Session "${sessionName}" not created.`);
-            }
-            confirmedCreateExplicit = true;
-        }
-        latency?.setContext({ tty: isTty });
-        const openStdin = !parsed.command;
-        const localStdin = !parsed.command && !isDetached;
-        const terminalSessionId = process.env.DEVBOX_TERM_SESSION_ID?.trim() ||
-            process.env.TERM_SESSION_ID?.trim() ||
-            process.env.ITERM_SESSION_ID?.trim() ||
-            `dvb-${randomUUID()}`;
-        const logPath = shouldLog && sessionName
-            ? buildSessionLogPath(sessionName, remoteHome)
-            : null;
-        const modalSessionLogPath = computeProvider === "modal" ? logPath : null;
-        const sessionLogSink = logPath && computeProvider !== "modal"
-            ? createRemoteSessionLogSink(client, spriteAlias, logPath)
-            : null;
-        const sessionEnv = resolveSessionEnv(terminalSessionId, sessionName);
-        const ttyEnv = isTty ? resolveTtyEnv(terminalSessionId) : null;
-        const shellEnv = ttyEnv ? { ...sessionEnv, ...ttyEnv } : sessionEnv;
-        const envExports = Object.keys(shellEnv).length > 0 ? formatEnvExports(shellEnv) : "";
-        const tracePathExport = 'export PATH="$HOME/.devbox/bin:$PATH"';
-        const envPrefix = [tracePathExport, envExports].filter(Boolean).join("; ");
-        const envCommandPrefix = envPrefix ? `${envPrefix}; ` : "";
-        const modalTtyOpenOptions = computeProvider === "modal" && isTty
-            ? {
-                env: shellEnv,
-                ...(projectWorkdir ? { cwd: projectWorkdir } : {}),
-            }
-            : null;
-        const execCommand = (() => {
-            if (parsed.command) {
-                if (projectWorkdir) {
-                    return [
-                        connectShell,
-                        "-lc",
-                        `${envCommandPrefix}cd ${shellQuote(projectWorkdir)} && ${parsed.command}`,
-                    ];
-                }
-                return [connectShell, "-lc", `${envCommandPrefix}${parsed.command}`];
-            }
-            if (computeProvider === "modal") {
-                return [];
-            }
-            if (projectWorkdir) {
-                return [
-                    connectShell,
-                    "-c",
-                    `${envCommandPrefix}cd ${shellQuote(projectWorkdir)} && ${`exec ${shellQuote(connectShell)}`}`,
-                ];
-            }
-            return [
-                connectShell,
-                "-c",
-                `${envCommandPrefix}exec ${shellQuote(connectShell)}`,
-            ];
-        })();
-        if (parsed.command) {
-            stage("Running command");
-            const result = await client.exec(spriteAlias, execCommand);
-            if (result.stdout.length > 0) {
-                process.stdout.write(result.stdout);
-            }
-            if (result.stderr.length > 0) {
-                process.stderr.write(result.stderr);
-            }
-            process.exitCode = result.exitCode;
-            return;
-        }
-        const resolveCurrentTtySize = () => (isTty ? resolveTtySize() : null);
-        try {
-            if (isDetached) {
-                if (!sessionId) {
-                    latency?.noteConnectStart();
-                    const ws = client.openExecSession(spriteAlias, {
-                        cmd: execCommand,
-                        tty: isTty,
-                        stdin: openStdin,
-                        ...(() => {
-                            const ttySize = resolveCurrentTtySize();
-                            return ttySize ? { cols: ttySize.cols, rows: ttySize.rows } : {};
-                        })(),
-                        ...(modalSessionLogPath ? { logPath: modalSessionLogPath } : {}),
-                        ...(modalTtyOpenOptions ?? {}),
-                    });
-                    let mappingWrite = null;
-                    const streamResult = await streamExecSession(ws, {
-                        tty: isTty,
-                        stdin: false,
-                        supportsResizeControlMessages,
-                        resolveTtySize,
-                        openBrowser,
-                        isRawCtrlCChunk,
-                        ...(latency ? { latency } : {}),
-                        onSessionInfo: (id) => {
-                            if (supportsAttachExecSession) {
-                                requireFreshSessionOpen = false;
-                                sessionId = sessionId ?? id;
-                            }
-                            if (sessionName) {
-                                if (autoNamed) {
-                                    mappingWrite = finalizeAutoSession(id);
-                                }
-                                else {
-                                    sessions[sessionName] = id;
-                                    mappingWrite = writeSpriteSessions(client, spriteAlias, sessions);
-                                }
-                            }
-                            ws.close();
-                        },
-                    });
-                    if (streamResult.kind === "disconnect" && !sessionId) {
-                        const detail = streamResult.errorMessage?.trim();
-                        throw new Error(detail
-                            ? `Failed to open exec session: ${detail}`
-                            : "Failed to open exec session.");
-                    }
-                    if (mappingWrite) {
-                        await mappingWrite;
-                    }
-                    if (!sessionId) {
-                        throw new Error("Failed to create detached session.");
-                    }
-                }
-                process.exitCode = 0;
-                return;
-            }
-            const shouldReconnect = isTty && !parsed.command && !isDetached;
-            let reconnectNoticeShown = false;
-            let pendingInitialInput = initialInput;
-            let retryDelayMs = 250;
-            let printedSessionInfo = false;
-            let sawOutput = false;
-            let connectPhase = "connecting";
-            let activeSocket = null;
-            let localCancelRequested = false;
-            let attemptedAttach = false;
-            let sigintListenerInstalled = false;
-            const printSessionInfo = (message) => {
-                if (process.stderr.isTTY && process.stdout.isTTY) {
-                    process.stderr.write(`\u001b7\r\n${message}\r\n\u001b8`);
-                    return;
-                }
-                console.error(message);
-            };
-            const reportSessionInfo = (id) => {
-                if (printedSessionInfo || !shouldReportSession || sawOutput)
-                    return;
-                printedSessionInfo = true;
-                const label = sessionName ? `${target.box}/${sessionName}` : target.box;
-                const message = `Session connected: ${label} (${id})`;
-                if (statusEnabled) {
-                    status.stop();
-                }
-                printSessionInfo(message);
-            };
-            const noteOutput = () => {
-                if (sawOutput)
-                    return;
-                sawOutput = true;
-                if (statusEnabled) {
-                    allowStatus = false;
-                    status.stop();
-                }
-            };
-            const onSigint = () => {
-                logger.info("connect_sigint", {
-                    connectPhase,
-                    hasActiveSocket: Boolean(activeSocket),
-                    localCancelRequested,
-                });
-                localCancelRequested = true;
-                if (!activeSocket)
-                    return;
-                try {
-                    activeSocket.terminate?.();
-                }
-                catch {
-                    logger.warn("connect_sigint_terminate_failed", {
-                        connectPhase,
-                    });
-                    // ignore terminate failures
-                }
-                try {
-                    activeSocket.close();
-                }
-                catch {
-                    logger.warn("connect_sigint_close_failed", {
-                        connectPhase,
-                    });
-                    // ignore close failures
-                }
-            };
-            const setConnectPhase = (phase) => {
-                if (connectPhase !== phase) {
-                    logger.debug("connect_phase_change", {
-                        from: connectPhase,
-                        to: phase,
-                    });
-                }
-                connectPhase = phase;
-                const shouldInstallListener = shouldReconnect && shouldCancelConnectOnSigint(connectPhase);
-                if (shouldInstallListener && !sigintListenerInstalled) {
-                    process.on("SIGINT", onSigint);
-                    sigintListenerInstalled = true;
-                    return;
-                }
-                if (!shouldInstallListener && sigintListenerInstalled) {
-                    process.removeListener("SIGINT", onSigint);
-                    sigintListenerInstalled = false;
-                }
-            };
-            setConnectPhase("connecting");
-            try {
-                while (true) {
-                    if (localCancelRequested) {
-                        process.exitCode = 130;
-                        break;
-                    }
-                    setConnectPhase(attemptedAttach ? "reconnecting" : "connecting");
-                    attemptedAttach = true;
-                    try {
-                        await refreshSessionMapping();
-                    }
-                    catch (error) {
-                        logger.warn("session_refresh_failed", { error: String(error) });
-                    }
-                    if (explicitName &&
-                        sessionName &&
-                        !sessionId &&
-                        !confirmedCreateExplicit) {
-                        pauseStatus();
-                        const confirmed = await confirmNewSession(sessionName);
-                        if (!confirmed) {
-                            throw new Error(`Session "${sessionName}" not created.`);
-                        }
-                        confirmedCreateExplicit = true;
-                    }
-                    let createdNew = false;
-                    let mappingWrite = null;
-                    latency?.noteConnectStart();
-                    const canAttach = shouldAttachToExistingSession({
-                        supportsAttachExecSession,
-                        sessionId,
-                        requireFreshSessionOpen,
-                    });
-                    const attachSessionId = canAttach ? sessionId : undefined;
-                    const modalAttachViaOpen = canAttach &&
-                        computeProvider === "modal" &&
-                        typeof attachSessionId === "string" &&
-                        attachSessionId.length > 0;
-                    stage(canAttach ? "Attaching to session" : "Opening session");
-                    let ws;
-                    if (modalAttachViaOpen) {
-                        const ttySize = resolveCurrentTtySize();
-                        ws = client.openExecSession(spriteAlias, {
-                            cmd: execCommand,
-                            tty: isTty,
-                            stdin: openStdin,
-                            sessionId: attachSessionId,
-                            ...(ttySize ? { cols: ttySize.cols, rows: ttySize.rows } : {}),
-                            ...(modalSessionLogPath ? { logPath: modalSessionLogPath } : {}),
-                            ...(modalTtyOpenOptions ?? {}),
-                        });
-                    }
-                    else if (canAttach) {
-                        if (!attachSessionId) {
-                            throw new Error("Missing session id for attach.");
-                        }
-                        ws = client.attachExecSession(spriteAlias, attachSessionId);
-                    }
-                    else {
-                        createdNew = true;
-                        const ttySize = resolveCurrentTtySize();
-                        ws = client.openExecSession(spriteAlias, {
-                            cmd: execCommand,
-                            tty: isTty,
-                            stdin: openStdin,
-                            ...(ttySize ? { cols: ttySize.cols, rows: ttySize.rows } : {}),
-                            ...(modalSessionLogPath ? { logPath: modalSessionLogPath } : {}),
-                            ...(modalTtyOpenOptions ?? {}),
-                        });
-                    }
-                    activeSocket = ws;
-                    const shouldSendInitialInput = createdNew && Boolean(pendingInitialInput);
-                    const initialInputToSend = shouldSendInitialInput
-                        ? pendingInitialInput
-                        : undefined;
-                    let result;
-                    try {
-                        result = await streamExecSession(ws, {
-                            tty: isTty,
-                            stdin: localStdin,
-                            supportsResizeControlMessages,
-                            resolveTtySize,
-                            openBrowser,
-                            isRawCtrlCChunk,
-                            ...(latency ? { latency } : {}),
-                            openTimeoutMs: CONNECT_OPEN_TIMEOUT_MS,
-                            onOutput: noteOutput,
-                            onOutputChunk: (chunk) => {
-                                sessionLogSink?.write(chunk);
-                            },
-                            onInputChunk: (chunk) => {
-                                sessionLogSink?.write(chunk);
-                            },
-                            onOpen: () => {
-                                setConnectPhase("attached");
-                                if (shouldSendInitialInput) {
-                                    pendingInitialInput = undefined;
-                                }
-                                if (sessionId) {
-                                    reportSessionInfo(sessionId);
-                                }
-                            },
-                            ...(initialInputToSend
-                                ? { initialInput: initialInputToSend }
-                                : {}),
-                            onSessionInfo: (id) => {
-                                const replacedSessionViaModalFallback = modalAttachViaOpen && attachSessionId !== id;
-                                if (supportsAttachExecSession) {
-                                    if (createdNew || replacedSessionViaModalFallback) {
-                                        requireFreshSessionOpen = false;
-                                    }
-                                    sessionId = id;
-                                }
-                                if (sessionName &&
-                                    (createdNew || replacedSessionViaModalFallback)) {
-                                    if (autoNamed) {
-                                        mappingWrite = finalizeAutoSession(id);
-                                        if (mappingWrite) {
-                                            mappingWrite
-                                                .then(() => {
-                                                reportSessionInfo(id);
-                                            })
-                                                .catch((error) => {
-                                                logger.warn("session_auto_rename_failed", {
-                                                    error: String(error),
-                                                });
-                                                reportSessionInfo(id);
-                                            });
-                                        }
-                                        else {
-                                            reportSessionInfo(id);
-                                        }
-                                    }
-                                    else {
-                                        sessions[sessionName] = id;
-                                        mappingWrite = writeSpriteSessions(client, spriteAlias, sessions);
-                                        reportSessionInfo(id);
-                                    }
-                                }
-                                else {
-                                    reportSessionInfo(id);
-                                }
-                                if (isDetached) {
-                                    ws.close();
-                                }
-                            },
-                            onPortEvent: notifyPortEvent,
-                            ...(shouldReconnect
-                                ? {
-                                    onRawCtrlC: () => {
-                                        if (!shouldCancelConnectOnSigint(connectPhase)) {
-                                            return false;
-                                        }
-                                        onSigint();
-                                        return true;
-                                    },
-                                    onDisconnectNotice: () => {
-                                        setConnectPhase("reconnecting");
-                                        resetTerminalInputModes();
-                                        if (!reconnectNoticeShown) {
-                                            console.error("Connection lost. Reconnecting... (Ctrl+C to cancel)");
-                                            reconnectNoticeShown = true;
-                                        }
-                                    },
-                                }
-                                : {}),
-                        });
-                    }
-                    finally {
-                        activeSocket = null;
-                    }
-                    if (mappingWrite) {
-                        try {
-                            await mappingWrite;
-                        }
-                        catch (error) {
-                            logger.warn("session_write_failed", { error: String(error) });
-                        }
-                    }
-                    if (localCancelRequested) {
-                        process.exitCode = 130;
-                        break;
-                    }
-                    if (result.kind === "exit") {
-                        process.exitCode = result.code;
-                        break;
-                    }
-                    if (result.kind === "detach") {
-                        if (autoNamed && sessionName && sessionId) {
-                            const nextName = await promptRenameSession(sessionName);
-                            if (nextName && nextName !== sessionName) {
-                                try {
-                                    await renameSessionMapping(sessionName, nextName, sessionId);
-                                }
-                                catch (error) {
-                                    console.error(`Failed to rename session: ${error instanceof Error ? error.message : String(error)}`);
-                                }
-                            }
-                        }
-                        process.exitCode = 0;
-                        break;
-                    }
-                    if (isDetached) {
-                        process.exitCode = 0;
-                        break;
-                    }
-                    if (isAttachReplacedCloseCode(result.closeCode)) {
-                        resetTerminalInputModes();
-                        console.error("Session attached from another client. Closing this window.");
-                        process.exitCode = 0;
-                        break;
-                    }
-                    if (!shouldReconnect) {
-                        if (result.errorMessage) {
-                            throw new Error(`Connection lost: ${result.errorMessage}`);
-                        }
-                        throw new Error("Connection lost.");
-                    }
-                    setConnectPhase("reconnecting");
-                    resetTerminalInputModes();
-                    if (!reconnectNoticeShown) {
-                        console.error("Connection lost. Reconnecting... (Ctrl+C to cancel)");
-                        reconnectNoticeShown = true;
-                    }
-                    if (sessionId && supportsAttachExecSession) {
-                        if (computeProvider !== "modal" &&
-                            result.opened === false &&
-                            supportsListExecSessions) {
-                            try {
-                                const available = await client.listExecSessions(spriteAlias);
-                                const match = available.find((session) => session.id === sessionId);
-                                if (!match || match.tty === false) {
-                                    if (sessionName) {
-                                        delete sessions[sessionName];
-                                        await writeSpriteSessions(client, spriteAlias, sessions);
-                                    }
-                                    sessionId = undefined;
-                                }
-                            }
-                            catch (error) {
-                                logger.warn("session_lookup_failed", { error: String(error) });
-                            }
-                        }
-                    }
-                    const networkWait = await waitForNetworkOnline({
-                        targetHost: networkTargetHost,
-                        onStatus: stage,
-                        onNotice: (message) => console.error(message),
-                    });
-                    if (networkWait === "aborted" || localCancelRequested) {
-                        process.exitCode = 130;
-                        break;
-                    }
-                    if (networkWait === "waited") {
-                        retryDelayMs = 250;
-                    }
-                    await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
-                    retryDelayMs = Math.min(5000, Math.round(retryDelayMs * 1.6));
-                }
-            }
-            finally {
-                if (sigintListenerInstalled) {
-                    process.removeListener("SIGINT", onSigint);
-                }
-            }
-        }
-        finally {
-            const exitCode = typeof process.exitCode === "number" ? process.exitCode : undefined;
-            latency?.flush(exitCode);
-            if (sessionLogSink) {
-                await sessionLogSink.close().catch((error) => {
-                    logger.warn("session_log_close_failed", {
-                        box: spriteAlias,
-                        logPath,
-                        error: String(error),
-                    });
-                });
-            }
-        }
-        try {
-            await recordCompletionSessionsFromMap(spriteAlias, sessions);
-        }
-        catch (error) {
-            logger.warn("completion_cache_update_failed", { error: String(error) });
-        }
-    }
-    catch (error) {
-        status.fail("Connect failed");
-        throw error;
-    }
-    finally {
-        if (isTty) {
-            resetTerminalInputModes();
-        }
-        status.stop();
-    }
-};
-//# sourceMappingURL=connect.js.map