@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

package/dist/devbox/commands/ide.js

@@ -1,987 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { resolveProjectWorkdir, resolveSocketInfo, } from "@boxes-dev/core";
-import { DAEMON_TIMEOUT_MS, ensureDaemonRunning, requestJson, requireDaemonFeatures, throwDaemonResponseError, } from "../daemonClient.js";
-import { logger } from "../logger.js";
-import { selectDevbox } from "./boxSelect.js";
-import { resolveCommandComputeProvider } from "./commandProvider.js";
-import { resolveRuntimeClient } from "./runtimeClient.js";
-import { ensureKnownHostsFile, ensureLocalSshKey, ensureRemoteSshAccess, ensureSshdService, getKnownHostsPath, getManagedSshConfigPath, getManagedSshKeyPath, readLocalSshPublicKey, resolveRemoteHome, resolveRemoteSshUser, } from "./sshAccess.js";
-import { ensureSshConfigInclude, readManagedSshEntries, resolveMainSshConfigPath, resolveManagedHostAlias, resolveManagedHostKeyAlias, writeManagedSshEntries, } from "./sshConfig.js";
-import { parseCommandArgs, readBooleanFlag, readStringFlag, } from "../commandRegistry/args.js";
-import { usageError } from "../commandRegistry/errors.js";
-import { createStatusLine } from "../ui/statusLine.js";
-const IDE_USAGE = [
-    "Usage:",
-    "  dvb ide setup [<box>] [--all] [--json]",
-    "  dvb ide doctor [<box>] [--all] [--editor <vscode|jetbrains|all>] [--json]",
-    "  dvb ide open <box> --editor <vscode|jetbrains> [--path <remote-path>] [--ide <jetbrains-ide>]",
-].join("\n");
-const VS_CODE_SETTINGS_RELATIVE_PATH = process.platform === "darwin"
-    ? path.join("Library", "Application Support", "Code", "User", "settings.json")
-    : path.join(".config", "Code", "User", "settings.json");
-const JETBRAINS_MIN_DISK_KB = 5_000_000;
-const JETBRAINS_MIN_CPU_COUNT = 2;
-const JETBRAINS_MIN_MEM_KB = 4_000_000;
-const JETBRAINS_IDE_CODE_TO_LABEL = new Map([
-    ["AI", "Android Studio"],
-    ["CL", "CLion"],
-    ["DB", "DataGrip"],
-    ["GO", "GoLand"],
-    ["IU", "IntelliJ IDEA Ultimate"],
-    ["PS", "PhpStorm"],
-    ["PY", "PyCharm"],
-    ["RD", "Rider"],
-    ["RM", "RubyMine"],
-    ["RR", "RustRover"],
-    ["WS", "WebStorm"],
-]);
-const JETBRAINS_IDE_NAME_TO_CODE = new Map([
-    ["android-studio", "AI"],
-    ["androidstudio", "AI"],
-    ["clion", "CL"],
-    ["datagrip", "DB"],
-    ["goland", "GO"],
-    ["idea", "IU"],
-    ["intellij", "IU"],
-    ["intellij-idea", "IU"],
-    ["intellij-ultimate", "IU"],
-    ["phpstorm", "PS"],
-    ["pycharm", "PY"],
-    ["pycharm-professional", "PY"],
-    ["rider", "RD"],
-    ["rubymine", "RM"],
-    ["rustrover", "RR"],
-    ["webstorm", "WS"],
-]);
-const shellEscape = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-const commandExists = (command) => {
-    const checker = process.platform === "win32" ? "where" : "which";
-    const result = spawnSync(checker, [command], { stdio: "ignore" });
-    return result.status === 0;
-};
-const fileExists = async (filePath) => {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const readTextFile = async (filePath) => {
-    try {
-        return await fs.readFile(filePath, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            "code" in error &&
-            error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-};
-const normalizeBoxKey = (value) => {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-};
-const parseEditor = (value, mode) => {
-    if (value === "vscode" || value === "jetbrains") {
-        return value;
-    }
-    if (mode === "doctor" && value === "all") {
-        return value;
-    }
-    throw new Error(mode === "doctor"
-        ? "Expected --editor to be one of: vscode, jetbrains, all."
-        : "Expected --editor to be one of: vscode, jetbrains.");
-};
-const parseSetupArgs = (args) => {
-    const { flags, positionals } = parseCommandArgs({
-        args,
-        commandPath: ["ide", "setup"],
-        flagLabel: "ide setup",
-        boolean: ["all", "json"],
-    });
-    if (positionals.length > 1) {
-        throw usageError(["ide", "setup"], `Unexpected argument: ${positionals[1]}`);
-    }
-    const parsed = {
-        all: readBooleanFlag(flags, "all"),
-        json: readBooleanFlag(flags, "json"),
-        ...(positionals[0] ? { box: positionals[0] } : {}),
-    };
-    if (parsed.all && parsed.box) {
-        throw usageError(["ide", "setup"], "Use either <box> or --all, not both.");
-    }
-    return parsed;
-};
-const parseDoctorArgs = (args) => {
-    const { flags, positionals } = parseCommandArgs({
-        args,
-        commandPath: ["ide", "doctor"],
-        flagLabel: "ide doctor",
-        boolean: ["all", "json"],
-        string: ["editor"],
-    });
-    if (positionals.length > 1) {
-        throw usageError(["ide", "doctor"], `Unexpected argument: ${positionals[1]}`);
-    }
-    const editor = readStringFlag(flags, "editor");
-    const parsed = {
-        all: readBooleanFlag(flags, "all"),
-        json: readBooleanFlag(flags, "json"),
-        editor: editor ? parseEditor(editor, "doctor") : "all",
-        ...(positionals[0] ? { box: positionals[0] } : {}),
-    };
-    if (parsed.all && parsed.box) {
-        throw usageError(["ide", "doctor"], "Use either <box> or --all, not both.");
-    }
-    return parsed;
-};
-const parseOpenArgs = (args) => {
-    const { flags, positionals } = parseCommandArgs({
-        args,
-        commandPath: ["ide", "open"],
-        flagLabel: "ide open",
-        string: ["editor", "ide", "path"],
-    });
-    if (positionals.length === 0) {
-        throw usageError(["ide", "open"], "Usage: dvb ide open <box> --editor <vscode|jetbrains> [--path <remote-path>] [--ide <jetbrains-ide>]");
-    }
-    if (positionals.length > 1) {
-        throw usageError(["ide", "open"], `Unexpected argument: ${positionals[1]}`);
-    }
-    const editor = readStringFlag(flags, "editor");
-    if (!editor) {
-        throw usageError(["ide", "open"], "dvb ide open requires --editor <vscode|jetbrains>.");
-    }
-    const box = positionals[0];
-    if (!box) {
-        throw usageError(["ide", "open"], "Usage: dvb ide open <box> --editor <vscode|jetbrains> [--path <remote-path>] [--ide <jetbrains-ide>]");
-    }
-    const parsedEditor = parseEditor(editor, "open");
-    const ide = parseJetBrainsIdeHint(readStringFlag(flags, "ide"));
-    if (ide && parsedEditor !== "jetbrains") {
-        throw usageError(["ide", "open"], "Use --ide only with --editor jetbrains.");
-    }
-    return {
-        box,
-        editor: parsedEditor,
-        path: readStringFlag(flags, "path") ?? null,
-        ide,
-    };
-};
-const parseJetBrainsIdeHint = (value) => {
-    const normalized = value?.trim();
-    if (!normalized) {
-        return null;
-    }
-    const named = JETBRAINS_IDE_NAME_TO_CODE.get(normalized.toLowerCase());
-    if (named) {
-        return named;
-    }
-    const upper = normalized.toUpperCase();
-    const prefix = upper.split("-", 1)[0] ?? upper;
-    if (JETBRAINS_IDE_CODE_TO_LABEL.has(prefix)) {
-        return upper;
-    }
-    throw new Error("Expected --ide to be one of: pycharm, intellij, webstorm, goland, clion, rider, phpstorm, rubymine, datagrip, rustrover, android-studio, or a supported JetBrains product code.");
-};
-const resolveJetBrainsIdeLabel = (ideHint) => {
-    if (!ideHint) {
-        return null;
-    }
-    const prefix = ideHint.split("-", 1)[0] ?? ideHint;
-    return JETBRAINS_IDE_CODE_TO_LABEL.get(prefix) ?? ideHint;
-};
-const addFinding = (findings, level, scope, code, message) => {
-    findings.push({ level, scope, code, message });
-};
-const hasErrors = (findings) => findings.some((finding) => finding.level === "error");
-const loadBoxes = async (socketPath) => {
-    const response = await requestJson(socketPath, "GET", "/boxes", DAEMON_TIMEOUT_MS.registry);
-    if (response.status !== 200) {
-        throwDaemonResponseError(response);
-    }
-    return response.body.boxes;
-};
-const resolveBoxSummary = (boxes, target) => {
-    const normalizedTarget = normalizeBoxKey(target);
-    if (!normalizedTarget) {
-        return null;
-    }
-    return (boxes.find((entry) => normalizeBoxKey(entry.alias) === normalizedTarget) ??
-        boxes.find((entry) => normalizeBoxKey(entry.canonical) === normalizedTarget) ??
-        null);
-};
-const resolveIdeTarget = async ({ boxes, target, }) => {
-    const matched = resolveBoxSummary(boxes, target);
-    if (!matched) {
-        throw new Error(`Unknown devbox: ${target}`);
-    }
-    const providerTarget = await resolveCommandComputeProvider({
-        box: matched.alias?.trim() || matched.canonical,
-        boxes: [...boxes],
-        homeDir: process.env.HOME ?? os.homedir(),
-    });
-    const canonical = normalizeBoxKey(matched.canonical);
-    const instanceId = normalizeBoxKey(matched.instanceId);
-    if (!canonical) {
-        throw new Error(`Devbox "${providerTarget.alias}" is missing canonical metadata.`);
-    }
-    if (!instanceId) {
-        throw new Error(`Devbox "${providerTarget.alias}" is missing instanceId metadata. Restart dvbd and retry.`);
-    }
-    return {
-        alias: providerTarget.alias,
-        canonical,
-        computeProvider: providerTarget.computeProvider,
-        instanceId,
-    };
-};
-const resolveTargets = async ({ socketPath, boxes, box, all, reminder, }) => {
-    if (all) {
-        const aliases = boxes
-            .map((entry) => normalizeBoxKey(entry.alias))
-            .filter((value) => value !== null);
-        if (aliases.length === 0) {
-            throw new Error("No devboxes found. Use `dvb init` to create one.");
-        }
-        return aliases;
-    }
-    if (box) {
-        return [box];
-    }
-    const selected = await selectDevbox(reminder);
-    return selected ? [selected.box] : [];
-};
-const buildVsCodeFolderUri = ({ hostAlias, remotePath, }) => {
-    if (!remotePath.startsWith("/")) {
-        throw new Error(`VS Code remote path must be absolute: ${remotePath}`);
-    }
-    const uri = new URL(`vscode-remote://ssh-remote+${hostAlias}`);
-    uri.pathname = remotePath;
-    return uri.toString();
-};
-const buildJetBrainsGatewayUrl = ({ hostAlias, sshUser, remotePath, ideHint, }) => {
-    if (!remotePath.startsWith("/")) {
-        throw new Error(`JetBrains remote path must be absolute: ${remotePath}`);
-    }
-    const uri = new URL("jetbrains://gateway/ssh/environment");
-    uri.searchParams.set("h", hostAlias);
-    uri.searchParams.set("u", sshUser);
-    uri.searchParams.set("p", "22");
-    uri.searchParams.set("projectHint", remotePath);
-    uri.searchParams.set("launchIde", "true");
-    if (ideHint) {
-        uri.searchParams.set("ideHint", ideHint);
-    }
-    return uri.toString();
-};
-const spawnDetached = async (command, args) => await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-        stdio: "ignore",
-        detached: true,
-    });
-    child.once("error", reject);
-    child.once("spawn", () => {
-        child.unref();
-        resolve();
-    });
-});
-const resolvePlatformOpener = () => {
-    if (process.platform === "darwin") {
-        return { command: "open", args: (value) => [value] };
-    }
-    if (process.platform === "linux") {
-        return { command: "xdg-open", args: (value) => [value] };
-    }
-    if (process.platform === "win32") {
-        return {
-            command: "cmd",
-            args: (value) => ["/c", "start", "", value],
-        };
-    }
-    return null;
-};
-const resolveVsCodeSettingsOverride = async () => {
-    const homeDir = process.env.HOME ?? os.homedir();
-    const settingsPath = path.join(homeDir, VS_CODE_SETTINGS_RELATIVE_PATH);
-    const content = await readTextFile(settingsPath);
-    if (!content) {
-        return null;
-    }
-    const match = content.match(/"remote\.SSH\.configFile"\s*:\s*"([^"]+)"/);
-    if (!match?.[1]) {
-        return null;
-    }
-    const configured = match[1].replace(/\\"/g, '"');
-    if (configured.startsWith("~/")) {
-        return path.join(homeDir, configured.slice(2));
-    }
-    return configured;
-};
-const execRemoteBash = async (client, box, script) => await client.exec(box, ["/bin/bash", "-lc", script]);
-const readRemoteFile = async ({ client, box, filePath, }) => {
-    const result = await execRemoteBash(client, box, `set -euo pipefail\ncat ${shellEscape(filePath)}`);
-    if (result.exitCode !== 0) {
-        return null;
-    }
-    return result.stdout;
-};
-const resolveRemoteCommandStatuses = async ({ client, box, commands, }) => {
-    const unique = [
-        ...new Set(commands.map((value) => value.trim()).filter(Boolean)),
-    ];
-    const script = [
-        "set -euo pipefail",
-        ...unique.flatMap((command) => [
-            `if command -v ${shellEscape(command)} >/dev/null 2>&1; then`,
-            `  printf '%s\\n' ${shellEscape(`${command}=1`)}`,
-            "else",
-            `  printf '%s\\n' ${shellEscape(`${command}=0`)}`,
-            "fi",
-        ]),
-    ].join("\n");
-    const result = await execRemoteBash(client, box, script);
-    if (result.exitCode !== 0) {
-        throw new Error(result.stderr.trim() || "remote command probe failed");
-    }
-    const statuses = new Map();
-    for (const line of result.stdout.split(/\r?\n/)) {
-        const [name, value] = line.split("=");
-        if (!name)
-            continue;
-        statuses.set(name, value === "1");
-    }
-    return statuses;
-};
-const resolveJetBrainsHostStats = async ({ client, box, }) => {
-    const script = [
-        "set -euo pipefail",
-        'cache="missing"',
-        'if [ -d "$HOME/.cache" ]; then',
-        '  if [ -w "$HOME/.cache" ]; then cache="writable"; else cache="not_writable"; fi',
-        "fi",
-        'printf "cache=%s\\n" "$cache"',
-        'printf "diskKb=%s\\n" "$(df -Pk "$HOME" 2>/dev/null | awk \'NR==2 {print $4}\')"',
-        'printf "cpu=%s\\n" "$(getconf _NPROCESSORS_ONLN 2>/dev/null || nproc 2>/dev/null || true)"',
-        'printf "memKb=%s\\n" "$(awk \'/MemTotal:/ {print $2}\' /proc/meminfo 2>/dev/null || true)"',
-    ].join("\n");
-    const result = await execRemoteBash(client, box, script);
-    if (result.exitCode !== 0) {
-        throw new Error(result.stderr.trim() || "remote host stats probe failed");
-    }
-    const values = new Map();
-    for (const line of result.stdout.split(/\r?\n/)) {
-        const [key, ...rest] = line.split("=");
-        if (!key)
-            continue;
-        values.set(key, rest.join("="));
-    }
-    return {
-        cache: values.get("cache") ?? "missing",
-        diskKb: Number.parseInt(values.get("diskKb") ?? "", 10),
-        cpu: Number.parseInt(values.get("cpu") ?? "", 10),
-        memKb: Number.parseInt(values.get("memKb") ?? "", 10),
-    };
-};
-const checkRemoteHttpReachability = async ({ client, box, url, }) => {
-    const script = [
-        "set -euo pipefail",
-        "if command -v curl >/dev/null 2>&1; then",
-        `  curl -fsSI --max-time 5 ${shellEscape(url)} >/dev/null`,
-        "  exit 0",
-        "fi",
-        "if command -v wget >/dev/null 2>&1; then",
-        `  wget -q --spider --timeout=5 ${shellEscape(url)}`,
-        "  exit 0",
-        "fi",
-        "exit 2",
-    ].join("\n");
-    const result = await execRemoteBash(client, box, script);
-    if (result.exitCode === 0) {
-        return "ok";
-    }
-    if (result.exitCode === 2) {
-        return "missing_tool";
-    }
-    return "failed";
-};
-const prepareManagedEntry = async ({ target, requireWorkdir, onStage, }) => {
-    onStage?.("connecting to runtime");
-    const client = await resolveRuntimeClient({
-        provider: target.computeProvider,
-        alias: target.alias,
-        targetBox: target.alias,
-        cwd: process.cwd(),
-        serviceRole: "system",
-    });
-    onStage?.("authorizing SSH access");
-    const publicKey = await readLocalSshPublicKey();
-    const remoteSshAccess = await ensureRemoteSshAccess({
-        client,
-        box: target.alias,
-        publicKey,
-        computeProvider: target.computeProvider,
-    });
-    onStage?.("ensuring sshd");
-    await ensureSshdService(client, target.alias, target.computeProvider);
-    onStage?.("detecting project workdir");
-    const workdir = await resolveProjectWorkdir(client, target.alias);
-    if (requireWorkdir && !workdir) {
-        throw new Error(`Remote project workdir was not found for "${target.alias}". Run \`dvb init --resume\` in the repo first.`);
-    }
-    const hostAlias = resolveManagedHostAlias(target.alias);
-    const hostKeyAlias = resolveManagedHostKeyAlias(target.instanceId);
-    return {
-        entry: {
-            boxAlias: target.alias,
-            hostAlias,
-            hostKeyAlias,
-            instanceId: target.instanceId,
-            sshUser: remoteSshAccess.sshUser,
-            workdir,
-            computeProvider: target.computeProvider,
-        },
-        workdir,
-        sshUser: remoteSshAccess.sshUser,
-    };
-};
-const ensureAbsoluteRemotePath = (remotePath) => {
-    if (!remotePath.startsWith("/")) {
-        throw new Error(`Remote path must be absolute: ${remotePath}`);
-    }
-    return remotePath;
-};
-const printSetupHuman = (successes, failures) => {
-    if (successes.length > 0) {
-        console.log("Configured SSH hosts:");
-        for (const result of successes) {
-            console.log(`  ${result.hostAlias} -> ${result.workdir}`);
-        }
-    }
-    if (failures.length > 0) {
-        console.error("Failed boxes:");
-        for (const failure of failures) {
-            console.error(`  ${failure.box}: ${failure.error}`);
-        }
-    }
-};
-const printDoctorHuman = (results) => {
-    for (const result of results) {
-        console.log(`${result.box} (${result.hostAlias})`);
-        for (const finding of result.findings) {
-            console.log(`  [${finding.level}] ${finding.scope}:${finding.code} ${finding.message}`);
-        }
-        console.log("");
-    }
-};
-const runIdeSetup = async (args) => {
-    const parsed = parseSetupArgs(args);
-    const socketInfo = resolveSocketInfo();
-    const statusEnabled = process.stderr.isTTY && !parsed.json;
-    const status = createStatusLine({ enabled: statusEnabled });
-    logger.info("ide_setup_start", {
-        box: parsed.box ?? null,
-        all: parsed.all,
-    });
-    const run = async () => {
-        status.stage("Starting dvbd");
-        await ensureDaemonRunning(socketInfo.socketPath);
-        status.stage("Checking dvbd IDE support");
-        await requireDaemonFeatures(socketInfo.socketPath, [
-            "boxes",
-            "registry",
-            "ports.forward.owners",
-        ]);
-        status.stage("Loading devboxes");
-        const boxes = await loadBoxes(socketInfo.socketPath);
-        if (!parsed.box && !parsed.all) {
-            status.stop();
-        }
-        const targets = await resolveTargets({
-            socketPath: socketInfo.socketPath,
-            boxes,
-            box: parsed.box,
-            all: parsed.all,
-            reminder: "Use `dvb ide setup <box>` to target a specific box.",
-        });
-        if (targets.length === 0) {
-            return;
-        }
-        status.stage("Preparing local SSH files");
-        await ensureLocalSshKey();
-        await ensureKnownHostsFile();
-        await ensureSshConfigInclude();
-        const successes = [];
-        const failures = [];
-        const nextEntries = parsed.all
-            ? new Map()
-            : await readManagedSshEntries();
-        for (const [index, target] of targets.entries()) {
-            const targetPosition = `${index + 1}/${targets.length}`;
-            try {
-                status.stage(`Resolving devbox ${targetPosition}: ${target}`);
-                const resolvedTarget = await resolveIdeTarget({
-                    boxes,
-                    target,
-                });
-                const prepared = await prepareManagedEntry({
-                    target: resolvedTarget,
-                    requireWorkdir: true,
-                    onStage: (detail) => status.stage(`Configuring ${resolvedTarget.alias} (${targetPosition}): ${detail}`),
-                });
-                nextEntries.set(prepared.entry.hostAlias, prepared.entry);
-                if (!prepared.workdir) {
-                    throw new Error(`Remote project workdir was not found for "${resolvedTarget.alias}".`);
-                }
-                successes.push({
-                    box: resolvedTarget.alias,
-                    hostAlias: prepared.entry.hostAlias,
-                    workdir: prepared.workdir,
-                    sshUser: prepared.sshUser,
-                    instanceId: resolvedTarget.instanceId,
-                });
-            }
-            catch (error) {
-                failures.push({
-                    box: target,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        status.stage("Writing managed SSH config");
-        await writeManagedSshEntries(nextEntries.values());
-        const ok = failures.length === 0;
-        logger.info(ok ? "ide_setup_complete" : "ide_setup_failed", {
-            box: parsed.box ?? null,
-            all: parsed.all,
-            successes: successes.length,
-            failures: failures.length,
-        });
-        status.stop();
-        if (parsed.json) {
-            console.log(JSON.stringify({
-                ok,
-                configured: successes,
-                errors: failures,
-            }, null, 2));
-            if (!ok) {
-                process.exitCode = 1;
-            }
-            return;
-        }
-        printSetupHuman(successes, failures);
-        if (!ok) {
-            process.exitCode = 1;
-        }
-    };
-    try {
-        await run();
-    }
-    finally {
-        status.stop();
-    }
-};
-const runIdeDoctor = async (args) => {
-    const parsed = parseDoctorArgs(args);
-    const socketInfo = resolveSocketInfo();
-    logger.info("ide_doctor_start", {
-        box: parsed.box ?? null,
-        all: parsed.all,
-        editor: parsed.editor,
-    });
-    await ensureDaemonRunning(socketInfo.socketPath);
-    await requireDaemonFeatures(socketInfo.socketPath, [
-        "boxes",
-        "registry",
-        "ports.forward.owners",
-    ]);
-    const boxes = await loadBoxes(socketInfo.socketPath);
-    const targets = await resolveTargets({
-        socketPath: socketInfo.socketPath,
-        boxes,
-        box: parsed.box,
-        all: parsed.all,
-        reminder: "Use `dvb ide doctor <box>` to target a specific box.",
-    });
-    if (targets.length === 0) {
-        return;
-    }
-    const mainConfigPath = resolveMainSshConfigPath();
-    const mainConfig = await readTextFile(mainConfigPath);
-    const managedEntries = await readManagedSshEntries();
-    const managedConfigExists = await fileExists(getManagedSshConfigPath());
-    const keyExists = await fileExists(getManagedSshKeyPath());
-    const knownHostsExists = await fileExists(getKnownHostsPath());
-    const vsCodeOverride = parsed.editor === "vscode" || parsed.editor === "all"
-        ? await resolveVsCodeSettingsOverride()
-        : null;
-    const results = [];
-    for (const target of targets) {
-        const resolvedTarget = await resolveIdeTarget({
-            boxes,
-            target,
-        });
-        const hostAlias = resolveManagedHostAlias(resolvedTarget.alias);
-        const findings = [];
-        const expectedHostKeyAlias = resolveManagedHostKeyAlias(resolvedTarget.instanceId);
-        const managedEntry = managedEntries.get(hostAlias);
-        if (mainConfig &&
-            mainConfig.includes("# >>> dvb ssh include >>>") &&
-            mainConfig.includes("# <<< dvb ssh include <<<")) {
-            addFinding(findings, "ok", "local", "ssh_include", `managed include present in ${mainConfigPath}`);
-        }
-        else {
-            addFinding(findings, "error", "local", "ssh_include", `managed include missing from ${mainConfigPath}`);
-        }
-        addFinding(findings, managedConfigExists ? "ok" : "error", "local", "managed_config", managedConfigExists
-            ? `managed SSH config exists at ${getManagedSshConfigPath()}`
-            : `managed SSH config missing at ${getManagedSshConfigPath()}`);
-        addFinding(findings, keyExists ? "ok" : "error", "local", "ssh_key", keyExists
-            ? `managed SSH key exists at ${getManagedSshKeyPath()}`
-            : `managed SSH key missing at ${getManagedSshKeyPath()}`);
-        addFinding(findings, knownHostsExists ? "ok" : "error", "local", "known_hosts", knownHostsExists
-            ? `managed known_hosts exists at ${getKnownHostsPath()}`
-            : `managed known_hosts missing at ${getKnownHostsPath()}`);
-        if (!managedEntry) {
-            addFinding(findings, "error", "local", "host_entry", `managed SSH host entry missing for ${hostAlias}; run \`dvb ide setup ${resolvedTarget.alias}\``);
-        }
-        else {
-            addFinding(findings, managedEntry.hostKeyAlias === expectedHostKeyAlias &&
-                managedEntry.instanceId === resolvedTarget.instanceId
-                ? "ok"
-                : "error", "local", "host_entry", managedEntry.hostKeyAlias === expectedHostKeyAlias &&
-                managedEntry.instanceId === resolvedTarget.instanceId
-                ? `managed SSH host entry exists for ${hostAlias}`
-                : `managed SSH host entry for ${hostAlias} is stale; run \`dvb ide setup ${resolvedTarget.alias}\``);
-        }
-        if (vsCodeOverride) {
-            const expectedConfigPath = resolveMainSshConfigPath();
-            addFinding(findings, path.resolve(vsCodeOverride) === path.resolve(expectedConfigPath)
-                ? "ok"
-                : "warn", "vscode", "config_file", path.resolve(vsCodeOverride) === path.resolve(expectedConfigPath)
-                ? `VS Code Remote-SSH uses ${expectedConfigPath}`
-                : `VS Code remote.SSH.configFile points to ${vsCodeOverride}; the managed include lives in ${expectedConfigPath}`);
-        }
-        if (parsed.editor === "vscode" || parsed.editor === "all") {
-            addFinding(findings, commandExists("code") ? "ok" : "warn", "vscode", "local_cli", commandExists("code")
-                ? "VS Code CLI (`code`) is available locally"
-                : "VS Code CLI (`code`) is not on PATH; `dvb ide open --editor vscode` will fail locally");
-        }
-        if (parsed.editor === "jetbrains" || parsed.editor === "all") {
-            const opener = resolvePlatformOpener();
-            addFinding(findings, opener && commandExists(opener.command) ? "ok" : "warn", "jetbrains", "local_opener", opener && commandExists(opener.command)
-                ? `platform URL opener (${opener.command}) is available locally`
-                : "no supported platform URL opener is available locally for JetBrains Gateway links");
-        }
-        try {
-            const client = await resolveRuntimeClient({
-                provider: resolvedTarget.computeProvider,
-                alias: resolvedTarget.alias,
-                targetBox: resolvedTarget.alias,
-                cwd: process.cwd(),
-            });
-            const sshUser = await resolveRemoteSshUser(client, resolvedTarget.alias);
-            addFinding(findings, "ok", "remote", "ssh_user", `remote SSH user resolves to ${sshUser}`);
-            const remoteHome = await resolveRemoteHome(client, resolvedTarget.alias);
-            addFinding(findings, "ok", "remote", "remote_home", `remote home resolves to ${remoteHome}`);
-            const workdir = await resolveProjectWorkdir(client, resolvedTarget.alias);
-            addFinding(findings, workdir ? "ok" : "error", "remote", "workdir", workdir
-                ? `remote project workdir resolves to ${workdir}`
-                : "remote project workdir is missing; rerun `dvb init --resume` for this repo");
-            const service = await client.getService(resolvedTarget.alias, "devbox-sshd");
-            const serviceStatus = service?.state?.status ?? "missing";
-            addFinding(findings, serviceStatus === "running" ? "ok" : "error", "remote", "sshd_service", serviceStatus === "running"
-                ? "devbox-sshd is running"
-                : serviceStatus === "missing"
-                    ? "devbox-sshd service is missing"
-                    : `devbox-sshd is ${serviceStatus}`);
-            const sshdConfigPath = `${remoteHome}/.devbox/ssh/sshd_config`;
-            const sshdConfig = await readRemoteFile({
-                client,
-                box: resolvedTarget.alias,
-                filePath: sshdConfigPath,
-            });
-            if (!sshdConfig) {
-                addFinding(findings, "error", "remote", "sshd_config", `remote SSH config missing at ${sshdConfigPath}`);
-            }
-            else {
-                const requiredLines = [
-                    "AllowTcpForwarding yes",
-                    "AllowStreamLocalForwarding yes",
-                    "GatewayPorts no",
-                    "X11Forwarding no",
-                ];
-                const missingLines = requiredLines.filter((line) => !sshdConfig.includes(line));
-                addFinding(findings, missingLines.length === 0 ? "ok" : "error", "remote", "sshd_config", missingLines.length === 0
-                    ? "remote SSH config contains required forwarding settings"
-                    : `remote SSH config is missing: ${missingLines.join(", ")}`);
-            }
-            const commonCommandStatuses = await resolveRemoteCommandStatuses({
-                client,
-                box: resolvedTarget.alias,
-                commands: ["bash", "tar", "curl", "wget"],
-            });
-            const hasCurlOrWget = commonCommandStatuses.get("curl") || commonCommandStatuses.get("wget");
-            addFinding(findings, commonCommandStatuses.get("bash") ? "ok" : "error", "remote", "bash", commonCommandStatuses.get("bash")
-                ? "`bash` is available remotely"
-                : "`bash` is missing remotely");
-            addFinding(findings, commonCommandStatuses.get("tar") ? "ok" : "error", "remote", "tar", commonCommandStatuses.get("tar")
-                ? "`tar` is available remotely"
-                : "`tar` is missing remotely");
-            addFinding(findings, hasCurlOrWget ? "ok" : "error", "remote", "fetch_tool", hasCurlOrWget
-                ? "`curl` or `wget` is available remotely"
-                : "`curl` and `wget` are both missing remotely");
-            if (parsed.editor === "vscode" || parsed.editor === "all") {
-                const vscodeConnectivity = await checkRemoteHttpReachability({
-                    client,
-                    box: resolvedTarget.alias,
-                    url: "https://update.code.visualstudio.com/",
-                });
-                addFinding(findings, vscodeConnectivity === "ok" ? "ok" : "warn", "vscode", "outbound", vscodeConnectivity === "ok"
-                    ? "remote outbound connectivity for VS Code server downloads looks healthy"
-                    : "remote outbound connectivity for VS Code server downloads could not be confirmed");
-            }
-            if (parsed.editor === "jetbrains" || parsed.editor === "all") {
-                const jetbrainsCommands = await resolveRemoteCommandStatuses({
-                    client,
-                    box: resolvedTarget.alias,
-                    commands: [
-                        "dd",
-                        "chmod",
-                        "test",
-                        "mkdir",
-                        "echo",
-                        "mv",
-                        "uname",
-                        "command",
-                        "gzip",
-                    ],
-                });
-                for (const command of [
-                    "dd",
-                    "chmod",
-                    "test",
-                    "mkdir",
-                    "echo",
-                    "mv",
-                    "uname",
-                    "command",
-                    "gzip",
-                ]) {
-                    const present = jetbrainsCommands.get(command);
-                    addFinding(findings, present ? "ok" : "error", "jetbrains", `cmd_${command}`, present
-                        ? `JetBrains helper command \`${command}\` is available remotely`
-                        : `JetBrains helper command \`${command}\` is missing remotely`);
-                }
-                const stats = await resolveJetBrainsHostStats({
-                    client,
-                    box: resolvedTarget.alias,
-                });
-                addFinding(findings, stats.cache === "writable" ? "ok" : "warn", "jetbrains", "cache", stats.cache === "writable"
-                    ? "$HOME/.cache is writable"
-                    : stats.cache === "not_writable"
-                        ? "$HOME/.cache exists but is not writable"
-                        : "$HOME/.cache is missing");
-                addFinding(findings, Number.isFinite(stats.diskKb) && stats.diskKb >= JETBRAINS_MIN_DISK_KB
-                    ? "ok"
-                    : "warn", "jetbrains", "disk", Number.isFinite(stats.diskKb)
-                    ? `free disk under $HOME is ${Math.floor(stats.diskKb / 1024)} MB`
-                    : "free disk under $HOME could not be determined");
-                addFinding(findings, Number.isFinite(stats.cpu) && stats.cpu >= JETBRAINS_MIN_CPU_COUNT
-                    ? "ok"
-                    : "warn", "jetbrains", "cpu", Number.isFinite(stats.cpu)
-                    ? `remote CPU count is ${stats.cpu}`
-                    : "remote CPU count could not be determined");
-                addFinding(findings, Number.isFinite(stats.memKb) && stats.memKb >= JETBRAINS_MIN_MEM_KB
-                    ? "ok"
-                    : "warn", "jetbrains", "memory", Number.isFinite(stats.memKb)
-                    ? `remote memory is ${Math.floor(stats.memKb / 1024)} MB`
-                    : "remote memory could not be determined");
-                const jetbrainsConnectivity = await checkRemoteHttpReachability({
-                    client,
-                    box: resolvedTarget.alias,
-                    url: "https://download.jetbrains.com/",
-                });
-                addFinding(findings, jetbrainsConnectivity === "ok" ? "ok" : "warn", "jetbrains", "outbound", jetbrainsConnectivity === "ok"
-                    ? "remote outbound connectivity for JetBrains downloads looks healthy"
-                    : "remote outbound connectivity for JetBrains downloads could not be confirmed");
-            }
-        }
-        catch (error) {
-            addFinding(findings, "error", "remote", "probe_failed", error instanceof Error ? error.message : String(error));
-        }
-        results.push({
-            box: resolvedTarget.alias,
-            hostAlias,
-            findings,
-        });
-    }
-    const ok = results.every((result) => !hasErrors(result.findings));
-    logger.info("ide_doctor_complete", {
-        box: parsed.box ?? null,
-        all: parsed.all,
-        editor: parsed.editor,
-        ok,
-    });
-    if (parsed.json) {
-        console.log(JSON.stringify({ ok, results }, null, 2));
-        if (!ok) {
-            process.exitCode = 1;
-        }
-        return;
-    }
-    printDoctorHuman(results);
-    if (!ok) {
-        process.exitCode = 1;
-    }
-};
-const launchVsCode = async ({ hostAlias, remotePath, }) => {
-    if (!commandExists("code")) {
-        throw new Error([
-            "VS Code CLI (`code`) is not on PATH.",
-            `SSH host alias: ${hostAlias}`,
-            `Remote path: ${remotePath}`,
-            `Manual next step: use Remote-SSH to connect to ${hostAlias}, then open ${remotePath}.`,
-        ].join("\n"));
-    }
-    const folderUri = buildVsCodeFolderUri({ hostAlias, remotePath });
-    await spawnDetached("code", ["--folder-uri", folderUri]);
-};
-const launchJetBrains = async ({ hostAlias, sshUser, remotePath, ideHint, }) => {
-    const opener = resolvePlatformOpener();
-    if (!opener || !commandExists(opener.command)) {
-        throw new Error([
-            "A platform URL opener is not available for JetBrains Gateway.",
-            `SSH host alias: ${hostAlias}`,
-            `Remote path: ${remotePath}`,
-            `Manual next step: open JetBrains Toolbox Remote Development, choose SSH host ${hostAlias}, then open ${remotePath}.`,
-        ].join("\n"));
-    }
-    const gatewayUrl = buildJetBrainsGatewayUrl({
-        hostAlias,
-        sshUser,
-        remotePath,
-        ideHint,
-    });
-    await spawnDetached(opener.command, opener.args(gatewayUrl));
-};
-const printJetBrainsOpenInstructions = ({ box, hostAlias, remotePath, ideHint, }) => {
-    const ideLabel = resolveJetBrainsIdeLabel(ideHint);
-    const lines = [
-        "",
-        `JetBrains launch requested for ${box}.`,
-        `SSH host alias: ${hostAlias}`,
-        `Remote project path: ${remotePath}`,
-        "",
-        "Next steps in JetBrains Toolbox:",
-        `1. Connect to ${hostAlias} and make sure the SSH connection succeeds.`,
-        ideLabel
-            ? `2. If ${ideLabel} is not installed for that remote host yet, install it from Toolbox.`
-            : "2. If your JetBrains IDE is not installed for that remote host yet, install it from Toolbox.",
-        `3. Open ${remotePath}. The dvb launch already passed this path as the project hint, so it may already be preselected.`,
-        `4. If the project does not open automatically, use File | Open and choose ${remotePath}.`,
-        `5. If Toolbox cannot connect or launch the project, run \`dvb ide doctor ${box} --editor jetbrains\`.`,
-    ];
-    console.log(lines.join("\n"));
-};
-const runIdeOpen = async (args) => {
-    const parsed = parseOpenArgs(args);
-    const socketInfo = resolveSocketInfo();
-    logger.info("ide_open_start", {
-        box: parsed.box,
-        editor: parsed.editor,
-    });
-    await ensureDaemonRunning(socketInfo.socketPath);
-    await requireDaemonFeatures(socketInfo.socketPath, [
-        "boxes",
-        "registry",
-        "ports.forward.owners",
-    ]);
-    const boxes = await loadBoxes(socketInfo.socketPath);
-    const resolvedTarget = await resolveIdeTarget({
-        boxes,
-        target: parsed.box,
-    });
-    await ensureLocalSshKey();
-    await ensureKnownHostsFile();
-    await ensureSshConfigInclude();
-    const existingEntries = await readManagedSshEntries();
-    const prepared = await prepareManagedEntry({
-        target: resolvedTarget,
-        requireWorkdir: parsed.path === null,
-    });
-    existingEntries.set(prepared.entry.hostAlias, prepared.entry);
-    await writeManagedSshEntries(existingEntries.values());
-    const remotePath = ensureAbsoluteRemotePath(parsed.path ?? prepared.workdir ?? "");
-    if (parsed.editor === "vscode") {
-        await launchVsCode({
-            hostAlias: prepared.entry.hostAlias,
-            remotePath,
-        });
-    }
-    else {
-        await launchJetBrains({
-            hostAlias: prepared.entry.hostAlias,
-            sshUser: prepared.sshUser,
-            remotePath,
-            ideHint: parsed.ide,
-        });
-        printJetBrainsOpenInstructions({
-            box: resolvedTarget.alias,
-            hostAlias: prepared.entry.hostAlias,
-            remotePath,
-            ideHint: parsed.ide,
-        });
-    }
-    logger.info("ide_open_complete", {
-        box: resolvedTarget.alias,
-        editor: parsed.editor,
-        remotePath,
-    });
-};
-export const runIde = async (args) => {
-    const subcommand = args[0];
-    if (!subcommand) {
-        console.log(IDE_USAGE);
-        return;
-    }
-    try {
-        if (subcommand === "setup") {
-            await runIdeSetup(args.slice(1));
-            return;
-        }
-        if (subcommand === "doctor") {
-            await runIdeDoctor(args.slice(1));
-            return;
-        }
-        if (subcommand === "open") {
-            await runIdeOpen(args.slice(1));
-            return;
-        }
-        throw new Error(IDE_USAGE);
-    }
-    catch (error) {
-        const event = subcommand === "setup"
-            ? "ide_setup_failed"
-            : subcommand === "doctor"
-                ? "ide_doctor_complete"
-                : "ide_open_failed";
-        logger.warn(event, {
-            subcommand,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        throw error;
-    }
-};
-export { buildJetBrainsGatewayUrl, buildVsCodeFolderUri, parseDoctorArgs, parseOpenArgs, parseSetupArgs, };
-//# sourceMappingURL=ide.js.map