@boxes-dev/dvb 0.2.4

package/dist/devbox/commands/wezterm.js

@@ -0,0 +1,878 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { createLogger, createSecretStore, createSpritesClient, loadConfig, resolveSocketInfo, resolveSpritesApiUrl, } from "@boxes-dev/core";
+import { DAEMON_TIMEOUT_MS, ensureDaemonRunning, requestJson, requireDaemonFeatures, } from "../daemonClient.js";
+import { ensureSpritesToken } from "../auth.js";
+import { selectDevbox } from "./boxSelect.js";
+import { WEZTERM_MUX_SERVICE_NAME, WEZTERM_MUX_TCP_PORT, } from "../weztermMux.js";
+import { ensureWeztermMuxService, installWeztermMux, isWeztermMuxHealthy, } from "./init/remote.js";
+const logger = createLogger("devbox-wezterm");
+const WEZTERM_APP_PATH = "/Applications/WezTerm.app";
+const WEZTERM_BIN_PATH = "/Applications/WezTerm.app/Contents/MacOS/wezterm";
+const WEZTERM_BIN_DIR = "/Applications/WezTerm.app/Contents/MacOS";
+const WEZTERM_INSTALL_URL = "https://wezfurlong.org/wezterm/install.html";
+const WEZTERM_PATH_EXPORT = 'export PATH="$PATH:/Applications/WezTerm.app/Contents/MacOS"';
+const WEZTERM_HEALTH_POLL_INTERVAL_MS = 200;
+const WEZTERM_HEALTH_POLL_TIMEOUT_MS = 6_000;
+const WEZTERM_PROXY_ENV = [
+    "DEVBOX_LOG_LEVEL=silent",
+    "DEVBOX_WEZTERM_PROXY=1",
+    "NODE_NO_WARNINGS=1",
+];
+const WEZTERM_PROXY_LOG_NAME = "proxy.log";
+const WEZTERM_USAGE = "Usage: dvb wezterm [<box>] [--port <port>] [--domain <name>] [--path <path>]\n" +
+    "       dvb wezterm proxy [<box>] [--port <port>] [--version <ver>] [--asset-url <url>]\n" +
+    "       dvb wezterm setup [<box>] [--port <port>] [--domain <name>] [--path <path>]";
+const parseWeztermArgs = (args) => {
+    const parsed = {};
+    if (!args.length) {
+        return parsed;
+    }
+    const subcommand = args[0];
+    if (!subcommand) {
+        return parsed;
+    }
+    const rest = args.slice(1);
+    let argList = rest;
+    if (subcommand === "proxy" || subcommand === "setup") {
+        parsed.subcommand = subcommand;
+    }
+    else if (subcommand.startsWith("-")) {
+        // `dvb wezterm --domain ...` should behave like `dvb wezterm <box> --domain ...`
+        // and prompt for a box when multiple exist.
+        parsed.subcommand = "launch";
+        argList = args;
+    }
+    else {
+        parsed.subcommand = "launch";
+        parsed.box = subcommand;
+        argList = rest;
+    }
+    for (let i = 0; i < argList.length; i += 1) {
+        const arg = argList[i];
+        if (!arg)
+            continue;
+        if (arg === "--help" || arg === "-h") {
+            throw new Error(WEZTERM_USAGE);
+        }
+        if (arg === "--port") {
+            const value = argList[i + 1];
+            if (!value)
+                throw new Error("Missing value for --port.");
+            const parsedPort = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedPort) || parsedPort <= 0) {
+                throw new Error(`Invalid port: ${value}`);
+            }
+            parsed.port = parsedPort;
+            i += 1;
+            continue;
+        }
+        if (arg === "--domain") {
+            const value = argList[i + 1];
+            if (!value)
+                throw new Error("Missing value for --domain.");
+            parsed.domainName = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--path") {
+            const value = argList[i + 1];
+            if (!value)
+                throw new Error("Missing value for --path.");
+            parsed.configPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--version") {
+            const value = argList[i + 1];
+            if (!value)
+                throw new Error("Missing value for --version.");
+            parsed.version = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--asset-url") {
+            const value = argList[i + 1];
+            if (!value)
+                throw new Error("Missing value for --asset-url.");
+            parsed.assetUrl = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown wezterm flag: ${arg}`);
+        }
+        if (!parsed.box) {
+            parsed.box = arg;
+            continue;
+        }
+        throw new Error(`Unexpected argument: ${arg}`);
+    }
+    return parsed;
+};
+const resolveCanonical = async (box) => {
+    const socketInfo = resolveSocketInfo();
+    await ensureDaemonRunning(socketInfo.socketPath);
+    await requireDaemonFeatures(socketInfo.socketPath, ["registry"]);
+    const response = await requestJson(socketInfo.socketPath, "GET", `/registry/alias?alias=${encodeURIComponent(box)}`, DAEMON_TIMEOUT_MS.registry);
+    return response.body.canonical ?? box;
+};
+const initWeztermClient = async (box) => {
+    const canonical = await resolveCanonical(box);
+    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 { token } = await ensureSpritesToken(store, () => { });
+    const apiBaseUrl = resolveSpritesApiUrl(config);
+    const client = createSpritesClient({ apiBaseUrl, token });
+    const sprite = await client.getSprite(canonical);
+    if (!sprite) {
+        throw new Error(`No devbox found named "${box}". Run "dvb init" first.`);
+    }
+    return { canonical, client };
+};
+const waitForWeztermMuxHealthy = async (client, canonical) => {
+    const start = Date.now();
+    while (Date.now() - start < WEZTERM_HEALTH_POLL_TIMEOUT_MS) {
+        const healthy = await isWeztermMuxHealthy({ client, spriteName: canonical });
+        if (healthy)
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, WEZTERM_HEALTH_POLL_INTERVAL_MS));
+    }
+    return false;
+};
+const ensureWeztermMuxReady = async (box, options) => {
+    const { canonical, client } = await initWeztermClient(box);
+    const installOptions = {
+        client,
+        spriteName: canonical,
+        ...(options?.assetUrl !== undefined ? { assetUrl: options.assetUrl } : {}),
+        ...(options?.assetName !== undefined ? { assetName: options.assetName } : {}),
+        ...(options?.version !== undefined ? { version: options.version } : {}),
+    };
+    const updated = await installWeztermMux(installOptions);
+    if (updated) {
+        try {
+            await client.stopService(canonical, WEZTERM_MUX_SERVICE_NAME);
+        }
+        catch (error) {
+            logger.warn("wezterm_mux_restart_failed", {
+                error: error instanceof Error ? error.message : String(error),
+                box: canonical,
+            });
+        }
+    }
+    await ensureWeztermMuxService({ client, spriteName: canonical });
+    let healthy = await waitForWeztermMuxHealthy(client, canonical);
+    if (!healthy) {
+        logger.warn("wezterm_mux_unhealthy", { box: canonical });
+        try {
+            await client.stopService(canonical, WEZTERM_MUX_SERVICE_NAME);
+        }
+        catch (error) {
+            logger.warn("wezterm_mux_restart_failed", {
+                error: error instanceof Error ? error.message : String(error),
+                box: canonical,
+            });
+        }
+        await ensureWeztermMuxService({ client, spriteName: canonical });
+        healthy = await waitForWeztermMuxHealthy(client, canonical);
+        if (!healthy) {
+            throw new Error("WezTerm mux service failed health check.");
+        }
+    }
+    return { canonical, client };
+};
+const runWeztermProxy = async (box, port, options) => {
+    const writeProxyLog = async (message) => {
+        if (process.env.DEVBOX_WEZTERM_PROXY !== "1")
+            return;
+        const homeDir = os.homedir();
+        if (!homeDir)
+            return;
+        try {
+            const logDir = path.join(homeDir, ".devbox", "wezterm");
+            await fs.mkdir(logDir, { recursive: true });
+            const line = `${new Date().toISOString()} ${message}\n`;
+            await fs.appendFile(path.join(logDir, WEZTERM_PROXY_LOG_NAME), line, "utf8");
+        }
+        catch {
+            // ignore proxy log failures
+        }
+    };
+    await writeProxyLog(`proxy_begin box=${box} port=${port}`);
+    const skipSetup = process.env.DEVBOX_WEZTERM_PROXY === "1";
+    const { canonical, client } = skipSetup
+        ? await initWeztermClient(box)
+        : await ensureWeztermMuxReady(box, options);
+    await writeProxyLog(`proxy_ready box=${canonical} setup=${skipSetup ? "skip" : "full"}`);
+    const requestId = randomUUID();
+    const proxyPath = `/v1/sprites/${canonical}/proxy`;
+    logger.info("sprites_request", {
+        requestId,
+        method: "proxy",
+        path: proxyPath,
+        box: canonical,
+        port,
+    });
+    await writeProxyLog(`proxy_start box=${canonical} port=${port}`);
+    const ws = client.openProxySocket(canonical);
+    ws.binaryType = "arraybuffer";
+    let wsOpen = false;
+    const pending = [];
+    let closed = false;
+    const flushPending = () => {
+        if (!wsOpen)
+            return;
+        for (const chunk of pending) {
+            ws.send(chunk);
+        }
+        pending.length = 0;
+    };
+    const closeAll = () => {
+        if (closed)
+            return;
+        closed = true;
+        try {
+            ws.close();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.stdin.pause();
+        }
+        catch {
+            // ignore
+        }
+    };
+    ws.addEventListener("open", () => {
+        wsOpen = true;
+        ws.send(JSON.stringify({ host: "localhost", port }));
+        flushPending();
+        logger.info("sprites_response", {
+            requestId,
+            method: "proxy",
+            path: proxyPath,
+            status: "ok",
+            box: canonical,
+            port,
+        });
+        void writeProxyLog(`proxy_ws_open box=${canonical}`);
+    });
+    ws.addEventListener("message", (event) => {
+        const data = event.data;
+        if (!data || closed)
+            return;
+        if (typeof data === "string") {
+            return;
+        }
+        if (Buffer.isBuffer(data)) {
+            process.stdout.write(data);
+            return;
+        }
+        if (data instanceof ArrayBuffer) {
+            process.stdout.write(Buffer.from(new Uint8Array(data)));
+            return;
+        }
+        if (data instanceof Uint8Array) {
+            process.stdout.write(Buffer.from(data));
+            return;
+        }
+        if (typeof Blob !== "undefined" && data instanceof Blob) {
+            data
+                .arrayBuffer()
+                .then((buffer) => {
+                process.stdout.write(Buffer.from(new Uint8Array(buffer)));
+            })
+                .catch(() => {
+                // ignore blob decode failures
+            });
+        }
+    });
+    ws.addEventListener("close", (event) => {
+        logger.info("sprites_response", {
+            requestId,
+            method: "proxy",
+            path: proxyPath,
+            status: "closed",
+            box: canonical,
+            port,
+        });
+        let detail = "";
+        if (event && typeof event === "object") {
+            if ("code" in event && typeof event.code === "number") {
+                detail += ` code=${event.code}`;
+            }
+            if ("reason" in event && typeof event.reason === "string" && event.reason) {
+                detail += ` reason=${event.reason}`;
+            }
+        }
+        void writeProxyLog(`proxy_ws_close box=${canonical}${detail}`);
+        closeAll();
+    });
+    const wsAny = ws;
+    if (wsAny.on) {
+        wsAny.on("unexpected-response", (_request, response) => {
+            const status = typeof response === "object" && response && "statusCode" in response
+                ? Number(response.statusCode ?? 0)
+                : 0;
+            logger.warn("sprites_response", {
+                requestId,
+                method: "proxy",
+                path: proxyPath,
+                status: "error",
+                box: canonical,
+                port,
+            });
+            void writeProxyLog(`proxy_ws_unexpected box=${canonical} status=${status}`);
+            closeAll();
+        });
+        wsAny.on("error", (error) => {
+            logger.warn("sprites_response", {
+                requestId,
+                method: "proxy",
+                path: proxyPath,
+                status: "error",
+                box: canonical,
+                port,
+            });
+            let detail = error instanceof Error ? error.message : String(error);
+            if (error && typeof error === "object" && "code" in error) {
+                const code = error.code;
+                if (code !== undefined) {
+                    detail = `${detail} code=${code}`;
+                }
+            }
+            void writeProxyLog(`proxy_ws_error box=${canonical} error=${detail}`);
+            closeAll();
+        });
+    }
+    else {
+        ws.addEventListener("error", () => {
+            logger.warn("sprites_response", {
+                requestId,
+                method: "proxy",
+                path: proxyPath,
+                status: "error",
+                box: canonical,
+                port,
+            });
+            void writeProxyLog(`proxy_ws_error box=${canonical}`);
+            closeAll();
+        });
+    }
+    process.stdin.on("data", (chunk) => {
+        if (closed)
+            return;
+        if (!wsOpen) {
+            pending.push(Buffer.from(chunk));
+            return;
+        }
+        ws.send(Buffer.from(chunk));
+    });
+    process.stdin.on("error", closeAll);
+    process.stdin.on("end", closeAll);
+};
+const runCommand = async (command, args) => new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        resolve(result);
+    };
+    let child;
+    try {
+        child = spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        finish({
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+        finish({
+            ok: false,
+            stdout: stdout.trim(),
+            stderr: error instanceof Error ? error.message : String(error),
+        });
+    });
+    child.on("close", (code) => {
+        finish({
+            ok: code === 0,
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+        });
+    });
+});
+const promptYesNo = async (question, defaultYes = false) => {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("This command requires a TTY to confirm changes.");
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultYes ? " (Y/n): " : " (y/N): ";
+    const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
+    rl.close();
+    if (!answer)
+        return defaultYes;
+    return ["y", "yes"].includes(answer);
+};
+const fileExists = async (value) => {
+    try {
+        await fs.access(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const parseWeztermVersion = (output) => {
+    const match = /wezterm\s+([0-9][^\s]+)/i.exec(output.trim());
+    return match ? match[1] : null;
+};
+const hasWeztermOnPath = async () => {
+    const result = await runCommand("wezterm", ["--version"]);
+    return result.ok;
+};
+const resolveShellProfilePath = async () => {
+    const homeDir = process.env.HOME ?? "";
+    if (!homeDir) {
+        throw new Error("HOME is not set; cannot update shell profile.");
+    }
+    const shell = process.env.SHELL ?? "";
+    if (shell.includes("zsh")) {
+        return path.join(homeDir, ".zshrc");
+    }
+    if (shell.includes("bash")) {
+        const profile = path.join(homeDir, ".bash_profile");
+        if (await fileExists(profile)) {
+            return profile;
+        }
+        return path.join(homeDir, ".bashrc");
+    }
+    return path.join(homeDir, ".profile");
+};
+const ensureWeztermOnPath = async () => {
+    if (await hasWeztermOnPath()) {
+        return { executable: "wezterm", updatedProfile: false };
+    }
+    if (process.platform !== "darwin" || !(await fileExists(WEZTERM_BIN_PATH))) {
+        throw new Error("WezTerm is not available on your PATH. Install it and try again.");
+    }
+    const profilePath = await resolveShellProfilePath();
+    const shouldUpdate = await promptYesNo(`WezTerm is installed but not on your PATH. Add it to ${profilePath}?`, true);
+    let updatedProfile = false;
+    if (shouldUpdate) {
+        let content = "";
+        try {
+            content = await fs.readFile(profilePath, "utf8");
+        }
+        catch {
+            content = "";
+        }
+        if (!content.includes(WEZTERM_BIN_DIR)) {
+            const next = `${content.trimEnd()}\n${content ? "\n" : ""}${WEZTERM_PATH_EXPORT}\n`;
+            await fs.writeFile(profilePath, next, "utf8");
+            updatedProfile = true;
+        }
+        const currentPath = process.env.PATH ?? "";
+        if (!currentPath.split(":").includes(WEZTERM_BIN_DIR)) {
+            process.env.PATH = `${currentPath}${currentPath ? ":" : ""}${WEZTERM_BIN_DIR}`;
+        }
+    }
+    if (await hasWeztermOnPath()) {
+        return { executable: "wezterm", updatedProfile };
+    }
+    return { executable: WEZTERM_BIN_PATH, updatedProfile };
+};
+const ensureWeztermInstalled = async () => {
+    if (await hasWeztermOnPath()) {
+        return;
+    }
+    if (process.platform === "darwin") {
+        if (await fileExists(WEZTERM_APP_PATH)) {
+            return;
+        }
+    }
+    console.log("WezTerm is not installed.");
+    console.log(`Install it here: ${WEZTERM_INSTALL_URL}`);
+    throw new Error("WezTerm is required to continue.");
+};
+const resolveLocalWeztermVersion = async () => {
+    const candidates = [];
+    if (process.env.WEZTERM_EXECUTABLE) {
+        candidates.push(process.env.WEZTERM_EXECUTABLE);
+    }
+    candidates.push("wezterm");
+    if (process.platform === "darwin") {
+        candidates.push("/Applications/WezTerm.app/Contents/MacOS/wezterm");
+    }
+    for (const command of candidates) {
+        if (!command)
+            continue;
+        if (command.includes("/")) {
+            try {
+                await fs.access(command);
+            }
+            catch {
+                continue;
+            }
+        }
+        const result = await runCommand(command, ["--version"]);
+        if (!result.ok) {
+            continue;
+        }
+        const parsed = parseWeztermVersion(result.stdout) ?? parseWeztermVersion(result.stderr);
+        if (parsed)
+            return parsed;
+    }
+    return null;
+};
+const resolveWeztermAssetUrl = async (version) => {
+    const response = await fetch(`https://api.github.com/repos/wez/wezterm/releases/tags/${encodeURIComponent(version)}`, {
+        headers: {
+            "User-Agent": "devbox-cli",
+            Accept: "application/vnd.github+json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to resolve WezTerm release ${version} (HTTP ${response.status}).`);
+    }
+    const payload = (await response.json());
+    const assets = Array.isArray(payload.assets) ? payload.assets : [];
+    const matches = (asset, pattern) => asset.name && pattern.test(asset.name);
+    const byName = (pattern) => assets.filter((asset) => matches(asset, pattern));
+    const isNonLinux = (name) => /(windows|win32|msvc|mingw|macos|darwin|osx|apple|dmg)\b/i.test(name);
+    const byLinuxArchive = (pattern) => assets.filter((asset) => asset.name && pattern.test(asset.name) && !isNonLinux(asset.name));
+    const appImageCandidates = byLinuxArchive(/\.AppImage$/i);
+    const archiveCandidates = [
+        ...byLinuxArchive(/\.tar\.xz$/i),
+        ...byLinuxArchive(/\.tar\.gz$/i),
+        ...byLinuxArchive(/\.tgz$/i),
+        ...byLinuxArchive(/\.zip$/i),
+    ];
+    const candidates = appImageCandidates.length > 0 ? appImageCandidates : archiveCandidates;
+    const selected = candidates.find((asset) => asset.browser_download_url);
+    if (!selected?.browser_download_url || !selected.name) {
+        throw new Error(`Unable to find a Linux WezTerm asset for version ${version}.`);
+    }
+    return { url: selected.browser_download_url, name: selected.name };
+};
+const resolveWeztermInstallOptions = async ({ version, assetUrl, quiet = false, }) => {
+    let resolvedVersion = version;
+    if (!resolvedVersion) {
+        const localVersion = await resolveLocalWeztermVersion();
+        if (localVersion) {
+            resolvedVersion = localVersion;
+        }
+    }
+    let resolvedAssetUrl = assetUrl;
+    let assetName;
+    if (!resolvedAssetUrl && resolvedVersion) {
+        try {
+            const resolved = await resolveWeztermAssetUrl(resolvedVersion);
+            resolvedAssetUrl = resolved.url;
+            assetName = resolved.name;
+        }
+        catch (error) {
+            logger.warn("wezterm_asset_lookup_failed", {
+                error: error instanceof Error ? error.message : String(error),
+                version: resolvedVersion,
+            });
+            if (!quiet) {
+                console.warn(`Warning: unable to resolve a Linux WezTerm build for ${resolvedVersion}. ` +
+                    "The Sprite may use a different version, which can break mux connections. " +
+                    "Pass --asset-url to override.");
+            }
+        }
+    }
+    const result = {};
+    if (resolvedAssetUrl !== undefined)
+        result.assetUrl = resolvedAssetUrl;
+    if (assetName !== undefined)
+        result.assetName = assetName;
+    if (resolvedVersion !== undefined)
+        result.version = resolvedVersion;
+    return result;
+};
+const expandPath = (value) => {
+    if (value.startsWith("~/")) {
+        const homeDir = process.env.HOME ?? "";
+        return homeDir ? path.join(homeDir, value.slice(2)) : value;
+    }
+    return value;
+};
+const resolveDefaultConfigPath = async () => {
+    const homeDir = process.env.HOME ?? "";
+    if (!homeDir) {
+        throw new Error("HOME is not set; pass --path to wezterm setup.");
+    }
+    const candidates = [
+        path.join(homeDir, ".wezterm.lua"),
+        path.join(homeDir, ".config", "wezterm", "wezterm.lua"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await fs.access(candidate);
+            return candidate;
+        }
+        catch {
+            // ignore missing
+        }
+    }
+    return candidates[0];
+};
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const resolveDvbCommand = async () => {
+    const scriptPath = process.argv[1];
+    if (scriptPath) {
+        const candidate = path.isAbsolute(scriptPath)
+            ? scriptPath
+            : path.resolve(process.cwd(), scriptPath);
+        try {
+            await fs.access(candidate);
+            return [process.execPath, candidate];
+        }
+        catch {
+            // fall through
+        }
+    }
+    return ["dvb"];
+};
+const formatLuaArgs = (args) => `{ ${args.map((arg) => JSON.stringify(arg)).join(", ")} }`;
+const buildProxyCommand = async (box, port) => {
+    const command = await resolveDvbCommand();
+    const args = ["env", ...WEZTERM_PROXY_ENV, ...command, "wezterm", "proxy", box];
+    if (port) {
+        args.push("--port", String(port));
+    }
+    return formatLuaArgs(args);
+};
+const buildDomainBlock = (domainName, proxyCommand) => {
+    const start = `-- devbox: wezterm domain begin (${domainName})`;
+    const end = `-- devbox: wezterm domain end (${domainName})`;
+    const lines = [
+        start,
+        "do",
+        "  local devbox_domain = {",
+        `    name = "${domainName}",`,
+        `    proxy_command = ${proxyCommand},`,
+        "  }",
+        "  config.unix_domains = config.unix_domains or {}",
+        "  local exists = false",
+        "  for _, domain in ipairs(config.unix_domains) do",
+        "    if domain.name == devbox_domain.name then",
+        "      domain.proxy_command = devbox_domain.proxy_command",
+        "      exists = true",
+        "      break",
+        "    end",
+        "  end",
+        "  if not exists then",
+        "    table.insert(config.unix_domains, devbox_domain)",
+        "  end",
+        "end",
+        end,
+        "",
+    ];
+    return { start, end, block: lines.join("\n") };
+};
+const canAppendToConfig = (content) => {
+    const hasConfig = /\blocal\s+config\b/.test(content) || /\bconfig\s*=/.test(content);
+    const hasReturnConfig = /\breturn\s+config\b/.test(content);
+    return hasConfig || hasReturnConfig;
+};
+const countReturns = (content) => (content.match(/\breturn\b/g) ?? []).length;
+const applyReturnTableTransform = (content) => {
+    if (!/\breturn\s*{/.test(content))
+        return null;
+    if (countReturns(content) !== 1)
+        return null;
+    const replaced = content.replace(/\breturn\s*{/, "local config = {");
+    return `${replaced.trimEnd()}\n\nreturn config\n`;
+};
+const insertBlock = (content, block) => {
+    const match = /\breturn\s+config\b/.exec(content);
+    if (match && match.index > 0) {
+        return `${content.slice(0, match.index).trimEnd()}\n\n${block}${content.slice(match.index)}`;
+    }
+    return `${content.trimEnd()}\n\n${block}`;
+};
+const runWeztermSetup = async (box, options) => {
+    const resolvedPath = options.configPath ?? (await resolveDefaultConfigPath());
+    if (!resolvedPath) {
+        throw new Error("WezTerm config path unavailable. Pass --path to override.");
+    }
+    const configPath = expandPath(resolvedPath);
+    const domainName = options.domainName ?? `sprite:${box}`;
+    const proxyCommand = await buildProxyCommand(box, options.port);
+    const { block, start, end } = buildDomainBlock(domainName, proxyCommand);
+    let existing = "";
+    let hasExisting = false;
+    try {
+        existing = await fs.readFile(configPath, "utf8");
+        hasExisting = true;
+    }
+    catch {
+        hasExisting = false;
+    }
+    let nextContent = "";
+    let updated = true;
+    if (!hasExisting) {
+        const header = [
+            'local wezterm = require "wezterm"',
+            "local config = wezterm.config_builder and wezterm.config_builder() or {}",
+            "",
+        ].join("\n");
+        nextContent = `${header}${block}return config\n`;
+    }
+    else {
+        const marker = new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`);
+        if (marker.test(existing)) {
+            nextContent = existing.replace(marker, block);
+            updated = nextContent !== existing;
+        }
+        else {
+            let candidate = existing;
+            if (!canAppendToConfig(candidate)) {
+                const transformed = applyReturnTableTransform(candidate);
+                if (transformed) {
+                    candidate = transformed;
+                }
+                else {
+                    throw new Error(`Unable to safely modify ${configPath}. ` +
+                        "Add the domain snippet manually or use --path to target a different file.");
+                }
+            }
+            nextContent = insertBlock(candidate, block);
+            updated = nextContent !== existing;
+        }
+    }
+    if (updated) {
+        await fs.mkdir(path.dirname(configPath), { recursive: true });
+        await fs.writeFile(configPath, nextContent, "utf8");
+        console.log(`Updated WezTerm config: ${configPath}`);
+    }
+    else {
+        console.log(`WezTerm config already up to date: ${configPath}`);
+    }
+    console.log(`Domain "${domainName}" now targets ${box}.`);
+    return { configPath, domainName, updated };
+};
+const startWeztermDomain = async (executable, domainName) => {
+    try {
+        const child = spawn(executable, ["connect", domainName], {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.unref();
+        if (process.platform === "darwin") {
+            const activator = spawn("osascript", [
+                "-e",
+                'tell application "WezTerm" to activate',
+            ]);
+            activator.unref();
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to launch WezTerm: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const runWezterm = async (args) => {
+    const parsed = parseWeztermArgs(args);
+    const subcommand = parsed.subcommand ?? "launch";
+    let targetBox = parsed.box;
+    if (!targetBox) {
+        const reminder = subcommand === "proxy"
+            ? "To target a specific box, use `dvb wezterm proxy <box>`."
+            : subcommand === "setup"
+                ? "To target a specific box, use `dvb wezterm setup <box>`."
+                : "To target a specific box, use `dvb wezterm <box>`.";
+        const selected = await selectDevbox(reminder);
+        if (!selected)
+            return;
+        targetBox = selected.box;
+    }
+    if (subcommand === "setup") {
+        const options = {};
+        if (parsed.port !== undefined)
+            options.port = parsed.port;
+        if (parsed.configPath !== undefined)
+            options.configPath = parsed.configPath;
+        if (parsed.domainName !== undefined)
+            options.domainName = parsed.domainName;
+        await runWeztermSetup(targetBox, options);
+        return;
+    }
+    if (subcommand === "launch") {
+        await ensureWeztermInstalled();
+        const domainName = parsed.domainName ?? `sprite:${targetBox}`;
+        const { executable, updatedProfile } = await ensureWeztermOnPath();
+        if (updatedProfile) {
+            console.log("Updated your shell profile for WezTerm PATH.");
+        }
+        const setupOptions = { domainName };
+        if (parsed.port !== undefined)
+            setupOptions.port = parsed.port;
+        if (parsed.configPath !== undefined) {
+            setupOptions.configPath = parsed.configPath;
+        }
+        await runWeztermSetup(targetBox, setupOptions);
+        const installInput = { quiet: false };
+        if (parsed.version !== undefined)
+            installInput.version = parsed.version;
+        if (parsed.assetUrl !== undefined)
+            installInput.assetUrl = parsed.assetUrl;
+        const installOptions = await resolveWeztermInstallOptions(installInput);
+        await ensureWeztermMuxReady(targetBox, installOptions);
+        await startWeztermDomain(executable, domainName);
+        console.log(`Opened WezTerm domain "${domainName}".`);
+        return;
+    }
+    const port = parsed.port ?? WEZTERM_MUX_TCP_PORT;
+    if (subcommand === "proxy") {
+        const quietProxy = process.env.DEVBOX_WEZTERM_PROXY === "1";
+        let resolvedOptions = {};
+        if (!quietProxy) {
+            const proxyInput = { quiet: quietProxy };
+            if (parsed.version !== undefined)
+                proxyInput.version = parsed.version;
+            if (parsed.assetUrl !== undefined)
+                proxyInput.assetUrl = parsed.assetUrl;
+            resolvedOptions = await resolveWeztermInstallOptions(proxyInput);
+        }
+        const proxyOptions = {};
+        if (resolvedOptions.assetUrl !== undefined) {
+            proxyOptions.assetUrl = resolvedOptions.assetUrl;
+        }
+        if (resolvedOptions.assetName !== undefined) {
+            proxyOptions.assetName = resolvedOptions.assetName;
+        }
+        if (resolvedOptions.version !== undefined) {
+            proxyOptions.version = resolvedOptions.version;
+        }
+        await runWeztermProxy(targetBox, port, proxyOptions);
+        return;
+    }
+};
+export { runWezterm };
+//# sourceMappingURL=wezterm.js.map