@boxes-dev/dvb-runtime 1.0.298 → 1.0.299

package/dist/devbox/completions/index.js

@@ -1,759 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import readline from "node:readline/promises";
-import { addDevboxClientVersionHeader, createSecretStore, loadConfig, loadRegistry, resolveRelayBaseUrl, resolveSocketInfo, } from "@boxes-dev/core";
-import { mergeSessionEntries, resolveCompletionsDir, saveCompletionCache, loadCompletionCache, updateCompletionCacheSessionsFromMap, updateCompletionCacheSessionsFromViews, } from "./cache.js";
-import { DAEMON_TIMEOUT_MS, ensureDaemonUpToDateIfRunning, requestJson, } from "../daemonClient.js";
-import { parseCommandArgs, readStringFlag } from "../commandRegistry/args.js";
-import { usageError } from "../commandRegistry/errors.js";
-import { createCompletionRoot, } from "../commandRegistry/tab.js";
-const SESSION_TTL_MS = 30_000;
-const REMOTE_ATTEMPT_INTERVAL_MS = 30_000;
-const REMOTE_TIMEOUT_MS = 500;
-const PRIME_SESSION_LIMIT = 5;
-const ALIAS_TTL_MS = 60_000;
-const ALIAS_ATTEMPT_INTERVAL_MS = 30_000;
-const ALIAS_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const RESERVED_ALIAS_PATTERN = /^dvb-[a-f0-9]{12}-/;
-const resolveCliName = () => {
-    const raw = process.env.DEVBOX_CLI_NAME?.trim();
-    if (!raw)
-        return "dvb";
-    // Limit to a safe filename / shell marker subset.
-    const normalized = raw.replace(/[^A-Za-z0-9_-]+/g, "").slice(0, 32);
-    return normalized.length > 0 ? normalized : "dvb";
-};
-const rcMarkers = (cliName) => ({
-    begin: `# >>> ${cliName} completions >>>`,
-    end: `# <<< ${cliName} completions <<<`,
-});
-const SUPPORTED_SHELLS = ["bash", "zsh", "fish"];
-const normalizeShell = (value) => {
-    if (!value)
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return null;
-    const base = path.basename(trimmed);
-    const lower = base.toLowerCase();
-    if (lower === "bash" || lower === "zsh" || lower === "fish") {
-        return lower;
-    }
-    return null;
-};
-const resolveShellFromEnv = () => normalizeShell(process.env.SHELL);
-const nowIso = () => new Date().toISOString();
-const normalizeAlias = (value) => value.trim().toLowerCase();
-const isValidAlias = (value) => {
-    const normalized = normalizeAlias(value);
-    if (!normalized)
-        return false;
-    if (RESERVED_ALIAS_PATTERN.test(normalized))
-        return false;
-    return ALIAS_PATTERN.test(normalized);
-};
-const dedupeAliases = (values) => {
-    const seen = new Set();
-    for (const raw of values) {
-        const alias = normalizeAlias(raw);
-        if (!isValidAlias(alias))
-            continue;
-        seen.add(alias);
-    }
-    return [...seen];
-};
-const sameAliasSet = (left, right) => {
-    if (left.length !== right.length)
-        return false;
-    const leftSet = new Set(left);
-    if (leftSet.size !== right.length)
-        return false;
-    for (const alias of right) {
-        if (!leftSet.has(alias))
-            return false;
-    }
-    return true;
-};
-const isStale = (timestamp, ttlMs) => {
-    if (!timestamp)
-        return true;
-    const parsed = Date.parse(timestamp);
-    if (!Number.isFinite(parsed))
-        return true;
-    return Date.now() - parsed > ttlMs;
-};
-const readTextFile = async (filePath) => {
-    try {
-        return await fs.readFile(filePath, "utf8");
-    }
-    catch {
-        return null;
-    }
-};
-const writeTextFile = async (filePath, contents) => {
-    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    await fs.writeFile(filePath, contents, { mode: 0o600 });
-};
-const captureConsole = (fn) => {
-    const lines = [];
-    const original = console.log;
-    console.log = (...args) => {
-        lines.push(args.map((arg) => String(arg)).join(" "));
-    };
-    try {
-        fn();
-    }
-    finally {
-        console.log = original;
-    }
-    return lines.join("\n");
-};
-const parseCompletionContext = (words) => {
-    const cleaned = words[0] === "--" ? words.slice(1) : words;
-    if (cleaned.length === 0)
-        return { token: "" };
-    const hasTrailingEmpty = cleaned[cleaned.length - 1] === "";
-    const token = hasTrailingEmpty ? "" : (cleaned[cleaned.length - 1] ?? "");
-    const tokens = hasTrailingEmpty ? cleaned.slice(0, -1) : cleaned.slice(0, -1);
-    const command = tokens[0];
-    const subcommand = command === "sessions" ? tokens[1] : undefined;
-    const context = { token };
-    if (command)
-        context.command = command;
-    if (subcommand)
-        context.subcommand = subcommand;
-    return context;
-};
-const listAliasesFromRegistry = async () => {
-    // Use local registry alias keys only for box-name hints. Canonical values are
-    // intentionally ignored and never written into completion cache.
-    const homeDir = process.env.HOME ? { homeDir: process.env.HOME } : undefined;
-    try {
-        const registry = await loadRegistry(homeDir);
-        return dedupeAliases(Object.keys(registry.aliases ?? {}));
-    }
-    catch {
-        return [];
-    }
-};
-const createRelayAuth = async () => {
-    const homeDir = process.env.HOME ? { homeDir: process.env.HOME } : undefined;
-    const config = await loadConfig(homeDir);
-    const store = await createSecretStore(config?.tokenStore, process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-    const token = await store.getControlPlaneToken();
-    if (!token)
-        return null;
-    return { token, relayBaseUrl: resolveRelayBaseUrl(config) };
-};
-const fetchWithTimeout = async (url, token, timeoutMs) => {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const headers = {
-            authorization: `Bearer ${token}`,
-        };
-        addDevboxClientVersionHeader(headers);
-        const response = await fetch(url, {
-            signal: controller.signal,
-            headers,
-        });
-        const body = await response.text();
-        return { status: response.status, body };
-    }
-    catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-};
-export const resolveRemoteSessionMapPath = (computeProvider) => {
-    switch (computeProvider) {
-        case "modal":
-            return "/root/.devbox/sessions.json";
-        case "e2b":
-            return "/home/boxes/.devbox/sessions.json";
-        case "sprites":
-        default:
-            return "/home/sprite/.devbox/sessions.json";
-    }
-};
-const fetchRemoteSessionMap = async (relayBaseUrl, token, box, computeProvider) => {
-    const url = new URL(`/v1/sprites/${encodeURIComponent(box)}/fs/read`, relayBaseUrl);
-    url.searchParams.set("path", resolveRemoteSessionMapPath(computeProvider));
-    const result = await fetchWithTimeout(url, token, REMOTE_TIMEOUT_MS);
-    if (!result)
-        return null;
-    if (result.status === 404)
-        return {};
-    if (result.status !== 200 || !result.body)
-        return null;
-    try {
-        const parsed = JSON.parse(result.body);
-        const mapped = {};
-        for (const [key, value] of Object.entries(parsed ?? {})) {
-            if (typeof value === "string")
-                mapped[key] = value;
-        }
-        return mapped;
-    }
-    catch {
-        return null;
-    }
-};
-const shouldAttemptRemote = (updatedAt, lastAttemptAt, ttlMs, attemptIntervalMs = REMOTE_ATTEMPT_INTERVAL_MS) => isStale(updatedAt, ttlMs) && isStale(lastAttemptAt, attemptIntervalMs);
-const refreshAliasesFromDaemonIfNeeded = async (cache) => {
-    if (!shouldAttemptRemote(cache.boxes?.updatedAt, cache.boxes?.lastAttemptAt, ALIAS_TTL_MS, ALIAS_ATTEMPT_INTERVAL_MS)) {
-        return {
-            cache,
-            changed: false,
-            aliases: cache.boxes?.remote ?? [],
-            providerByAlias: {},
-        };
-    }
-    const attemptAt = nowIso();
-    cache.boxes = {
-        ...(cache.boxes ?? {}),
-        lastAttemptAt: attemptAt,
-    };
-    try {
-        const socketInfo = resolveSocketInfo();
-        await ensureDaemonUpToDateIfRunning(socketInfo.socketPath);
-        const response = await requestJson(socketInfo.socketPath, "GET", "/boxes", DAEMON_TIMEOUT_MS.quick);
-        if (response.status !== 200) {
-            return {
-                cache,
-                changed: true,
-                aliases: cache.boxes?.remote ?? [],
-                providerByAlias: {},
-            };
-        }
-        if (!Array.isArray(response.body.boxes)) {
-            return {
-                cache,
-                changed: true,
-                aliases: cache.boxes?.remote ?? [],
-                providerByAlias: {},
-            };
-        }
-        const providerByAlias = {};
-        for (const box of response.body.boxes) {
-            const alias = typeof box.alias === "string" ? normalizeAlias(box.alias) : "";
-            if (!isValidAlias(alias))
-                continue;
-            if (box.computeProvider === "sprites" ||
-                box.computeProvider === "modal") {
-                providerByAlias[alias] = box.computeProvider;
-            }
-        }
-        const aliases = dedupeAliases(response.body.boxes
-            .map((box) => (typeof box.alias === "string" ? box.alias : ""))
-            .filter((alias) => alias.length > 0));
-        cache.boxes = {
-            ...(cache.boxes ?? {}),
-            remote: aliases,
-            updatedAt: nowIso(),
-            lastAttemptAt: attemptAt,
-        };
-        return { cache, changed: true, aliases, providerByAlias };
-    }
-    catch {
-        return {
-            cache,
-            changed: true,
-            aliases: cache.boxes?.remote ?? [],
-            providerByAlias: {},
-        };
-    }
-};
-const refreshRemoteSessionsIfNeeded = async (cache, spriteAlias, computeProvider) => {
-    const alias = normalizeAlias(spriteAlias);
-    if (!isValidAlias(alias)) {
-        return { cache, changed: false };
-    }
-    const existing = cache.sessions?.[alias];
-    if (!shouldAttemptRemote(existing?.updatedAt, existing?.lastAttemptAt, SESSION_TTL_MS)) {
-        return { cache, changed: false };
-    }
-    const auth = await createRelayAuth();
-    const attemptAt = nowIso();
-    cache.sessions = {
-        ...cache.sessions,
-        [alias]: {
-            ...existing,
-            entries: existing?.entries ?? [],
-            lastAttemptAt: attemptAt,
-        },
-    };
-    if (!auth)
-        return { cache, changed: true };
-    const remote = await fetchRemoteSessionMap(auth.relayBaseUrl, auth.token, alias, computeProvider);
-    if (!remote)
-        return { cache, changed: true };
-    const entries = Object.entries(remote).map(([name, id]) => ({ name, id }));
-    const merged = mergeSessionEntries(existing?.entries ?? [], entries);
-    cache.sessions[alias] = {
-        entries: merged,
-        updatedAt: nowIso(),
-        lastAttemptAt: attemptAt,
-    };
-    return { cache, changed: true };
-};
-const primeCompletionCache = async () => {
-    const homeDir = process.env.HOME ? { homeDir: process.env.HOME } : undefined;
-    const localAliases = await listAliasesFromRegistry();
-    let cache = await loadCompletionCache(homeDir);
-    let cacheDirty = false;
-    const aliasRefresh = await refreshAliasesFromDaemonIfNeeded(cache);
-    cache = aliasRefresh.cache;
-    cacheDirty = cacheDirty || aliasRefresh.changed;
-    const attemptAt = nowIso();
-    const mergedAliases = dedupeAliases([
-        ...localAliases,
-        ...aliasRefresh.aliases,
-        ...(cache.boxes?.remote ?? []),
-    ]);
-    const existingAliases = cache.boxes?.remote ?? [];
-    const aliasChanged = !sameAliasSet(mergedAliases, existingAliases);
-    if (aliasChanged) {
-        cache.boxes = {
-            ...(cache.boxes ?? {}),
-            remote: mergedAliases,
-            updatedAt: attemptAt,
-            lastAttemptAt: attemptAt,
-        };
-        cacheDirty = true;
-    }
-    const auth = await createRelayAuth();
-    if (auth) {
-        const targets = mergedAliases.slice(0, PRIME_SESSION_LIMIT);
-        for (const alias of targets) {
-            const remote = await fetchRemoteSessionMap(auth.relayBaseUrl, auth.token, alias, aliasRefresh.providerByAlias[alias]);
-            if (!remote) {
-                continue;
-            }
-            const entries = Object.entries(remote).map(([name, id]) => ({
-                name,
-                id,
-            }));
-            cache.sessions = {
-                ...cache.sessions,
-                [alias]: {
-                    entries,
-                    updatedAt: attemptAt,
-                    lastAttemptAt: attemptAt,
-                },
-            };
-            cacheDirty = true;
-        }
-    }
-    if (cacheDirty) {
-        await saveCompletionCache(cache, homeDir);
-    }
-};
-const loadCompletionData = async (words) => {
-    const homeDir = process.env.HOME ? { homeDir: process.env.HOME } : undefined;
-    const localAliases = await listAliasesFromRegistry();
-    let cache = await loadCompletionCache(homeDir);
-    let cacheDirty = false;
-    const aliasRefresh = await refreshAliasesFromDaemonIfNeeded(cache);
-    cache = aliasRefresh.cache;
-    cacheDirty = cacheDirty || aliasRefresh.changed;
-    const boxes = new Set(dedupeAliases([...localAliases, ...aliasRefresh.aliases]));
-    const context = parseCompletionContext(words);
-    if ((context.command === "connect" ||
-        (context.command === "sessions" &&
-            (context.subcommand === "rename" || context.subcommand === "kill"))) &&
-        context.token.includes("/")) {
-        const boxPart = normalizeAlias(context.token.split("/", 1)[0] ?? "");
-        if (boxes.has(boxPart)) {
-            const provider = aliasRefresh.providerByAlias[boxPart];
-            const result = await refreshRemoteSessionsIfNeeded(cache, boxPart, provider);
-            cache = result.cache;
-            cacheDirty = cacheDirty || result.changed;
-        }
-    }
-    if (cacheDirty) {
-        await saveCompletionCache(cache, homeDir);
-    }
-    const boxSessionNames = new Set();
-    const boxSessionRefs = new Set();
-    const sessionRefs = new Set();
-    for (const [alias, sessionData] of Object.entries(cache.sessions ?? {})) {
-        if (!boxes.has(alias))
-            continue;
-        const entries = sessionData.entries ?? [];
-        for (const entry of entries) {
-            if (entry.name) {
-                boxSessionNames.add(`${alias}/${entry.name}`);
-                boxSessionRefs.add(`${alias}/${entry.name}`);
-                sessionRefs.add(entry.name);
-            }
-            if (entry.id) {
-                boxSessionRefs.add(`${alias}/${entry.id}`);
-                sessionRefs.add(entry.id);
-            }
-        }
-    }
-    return {
-        boxes: [...boxes].sort(),
-        boxSessionNames: [...boxSessionNames].sort(),
-        boxSessionRefs: [...boxSessionRefs].sort(),
-        sessionRefs: [...sessionRefs].sort(),
-    };
-};
-const resolveShellPaths = (shell) => {
-    const cliName = resolveCliName();
-    const home = os.homedir();
-    if (shell === "fish") {
-        const configHome = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
-        return {
-            scriptPath: path.join(configHome, "fish", "completions", `${cliName}.fish`),
-            rcPath: undefined,
-        };
-    }
-    const completionsDir = resolveCompletionsDir(home);
-    const scriptPath = shell === "zsh"
-        ? path.join(completionsDir, `${cliName}.zsh`)
-        : path.join(completionsDir, `${cliName}.bash`);
-    const rcPath = shell === "zsh"
-        ? path.join(process.env.ZDOTDIR ?? home, ".zshrc")
-        : path.join(home, ".bashrc");
-    return { scriptPath, rcPath };
-};
-const buildRcBlock = (scriptPath, markers) => [
-    markers.begin,
-    `if [ -f "${scriptPath}" ]; then`,
-    `  source "${scriptPath}"`,
-    "fi",
-    markers.end,
-].join("\n");
-const updateRcFile = async (rcPath, block, markers) => {
-    const existing = (await readTextFile(rcPath)) ?? "";
-    if (existing.includes(markers.begin) && existing.includes(markers.end)) {
-        const updated = existing.replace(new RegExp(`${markers.begin}[\\s\\S]*?${markers.end}`, "m"), block);
-        await writeTextFile(rcPath, updated);
-        return;
-    }
-    const suffix = existing.endsWith("\n") || existing.length === 0 ? "" : "\n";
-    await writeTextFile(rcPath, `${existing}${suffix}${block}\n`);
-};
-const removeRcBlock = async (rcPath, markers) => {
-    const existing = await readTextFile(rcPath);
-    if (!existing)
-        return;
-    if (!existing.includes(markers.begin) || !existing.includes(markers.end)) {
-        return;
-    }
-    const updated = existing.replace(new RegExp(`\\n?${markers.begin}[\\s\\S]*?${markers.end}\\n?`, "m"), "\n");
-    await writeTextFile(rcPath, updated.trimEnd() + "\n");
-};
-const generateCompletionScript = (shell) => {
-    const cliName = resolveCliName();
-    const root = createCompletionRoot({
-        boxes: [],
-        boxSessionNames: [],
-        boxSessionRefs: [],
-        sessionRefs: [],
-    });
-    return captureConsole(() => {
-        root.setup(cliName, cliName, shell);
-    });
-};
-const installCompletions = async (shell) => {
-    const cliName = resolveCliName();
-    const markers = rcMarkers(cliName);
-    const { scriptPath, rcPath } = resolveShellPaths(shell);
-    const script = generateCompletionScript(shell);
-    await writeTextFile(scriptPath, script);
-    if (rcPath) {
-        await updateRcFile(rcPath, buildRcBlock(scriptPath, markers), markers);
-    }
-    try {
-        await primeCompletionCache();
-    }
-    catch {
-        // ignore cache prime failures
-    }
-    const cache = await loadCompletionCache();
-    cache.install = {
-        shell,
-        scriptPath,
-        ...(rcPath ? { rcPath } : {}),
-        installedAt: nowIso(),
-        updatedAt: nowIso(),
-    };
-    await saveCompletionCache(cache);
-    return { scriptPath, rcPath };
-};
-const uninstallCompletions = async (shell) => {
-    const cliName = resolveCliName();
-    const markers = rcMarkers(cliName);
-    const { scriptPath, rcPath } = resolveShellPaths(shell);
-    try {
-        await fs.unlink(scriptPath);
-    }
-    catch {
-        // ignore missing file
-    }
-    if (rcPath) {
-        await removeRcBlock(rcPath, markers);
-    }
-    const cache = await loadCompletionCache();
-    if (cache.install?.shell === shell) {
-        delete cache.install;
-        await saveCompletionCache(cache);
-    }
-    return { scriptPath, rcPath };
-};
-const detectStatusForShell = async (shell) => {
-    const cliName = resolveCliName();
-    const markers = rcMarkers(cliName);
-    const { scriptPath, rcPath } = resolveShellPaths(shell);
-    const scriptExists = Boolean(await readTextFile(scriptPath));
-    let rcConfigured = scriptExists;
-    if (rcPath) {
-        const rcContents = await readTextFile(rcPath);
-        rcConfigured = Boolean(rcContents?.includes(markers.begin) && rcContents?.includes(markers.end));
-    }
-    const status = {
-        shell,
-        scriptPath,
-        scriptExists,
-        rcConfigured,
-    };
-    if (rcPath)
-        status.rcPath = rcPath;
-    return status;
-};
-const resolveCompletionStatus = async () => {
-    const cache = await loadCompletionCache();
-    if (cache.install?.shell) {
-        return detectStatusForShell(cache.install.shell);
-    }
-    for (const shell of SUPPORTED_SHELLS) {
-        const status = await detectStatusForShell(shell);
-        if (status.scriptExists)
-            return status;
-    }
-    return { scriptExists: false, rcConfigured: false };
-};
-export const maybeAutoUpdateCompletions = async () => {
-    try {
-        const cache = await loadCompletionCache();
-        const install = cache.install;
-        if (!install)
-            return;
-        const script = await readTextFile(install.scriptPath);
-        if (!script)
-            return;
-        const desired = generateCompletionScript(install.shell);
-        if (script === desired)
-            return;
-        await writeTextFile(install.scriptPath, desired);
-        cache.install = {
-            ...install,
-            updatedAt: nowIso(),
-        };
-        await saveCompletionCache(cache);
-    }
-    catch {
-        // ignore auto-update failures
-    }
-};
-const promptYesNo = async (label) => {
-    if (!process.stdin.isTTY)
-        return false;
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const answer = await rl.question(label);
-    rl.close();
-    return parsePromptYesNoAnswer(answer);
-};
-export const parsePromptYesNoAnswer = (answer, { defaultValue = true } = {}) => {
-    const normalized = answer.trim().toLowerCase();
-    if (normalized.length === 0)
-        return defaultValue;
-    return normalized === "y" || normalized === "yes";
-};
-export const maybeOfferCompletionsInstall = async () => {
-    if (!process.stdin.isTTY)
-        return;
-    const status = await resolveCompletionStatus();
-    if (status.scriptExists)
-        return;
-    const shell = resolveShellFromEnv();
-    if (!shell)
-        return;
-    const approved = await promptYesNo("Install shell completions? (Y/n): ");
-    if (!approved)
-        return;
-    try {
-        await installCompletions(shell);
-        console.log(`Shell completions installed for ${shell}.`);
-    }
-    catch (error) {
-        console.error(`Failed to install completions: ${error instanceof Error ? error.message : String(error)}`);
-    }
-};
-const usage = () => {
-    const cliName = resolveCliName();
-    console.log("Usage:");
-    console.log(`  ${cliName} completions status`);
-    console.log(`  ${cliName} completions install [--shell <bash|zsh|fish>]`);
-    console.log(`  ${cliName} completions uninstall [--shell <bash|zsh|fish>]`);
-    console.log(`  ${cliName} completions generate <bash|zsh|fish>`);
-};
-const parseCompletionsArgs = (args) => {
-    const parsed = {
-        subcommand: "status",
-    };
-    const hasSubcommand = Boolean(args[0] && !args[0].startsWith("-"));
-    if (hasSubcommand && args[0]) {
-        parsed.subcommand = args[0];
-    }
-    const commandPath = parsed.subcommand === "status" ||
-        parsed.subcommand === "install" ||
-        parsed.subcommand === "uninstall" ||
-        parsed.subcommand === "generate"
-        ? ["completions", parsed.subcommand]
-        : ["completions"];
-    const { flags, positionals } = parseCommandArgs({
-        args: args.slice(hasSubcommand ? 1 : 0),
-        commandPath,
-        flagLabel: "completions",
-        string: ["shell"],
-        aliases: { s: "shell" },
-    });
-    const shellFromFlag = normalizeShell(readStringFlag(flags, "shell"));
-    if (readStringFlag(flags, "shell") && !shellFromFlag) {
-        throw usageError(commandPath, "Unknown shell. Use bash, zsh, or fish.");
-    }
-    if (shellFromFlag) {
-        parsed.shell = shellFromFlag;
-    }
-    if (positionals.length > 0) {
-        if (parsed.subcommand === "generate" &&
-            !parsed.shell &&
-            positionals.length === 1) {
-            const shell = normalizeShell(positionals[0]);
-            if (!shell) {
-                throw usageError(["completions", "generate"], "Unknown shell. Use bash, zsh, or fish.");
-            }
-            parsed.shell = shell;
-            return parsed;
-        }
-        if (parsed.subcommand === "status") {
-            throw usageError(["completions", "status"], "Usage: dvb completions status");
-        }
-        throw usageError(["completions"], `Unknown completions flag: ${positionals[0]}`);
-    }
-    return parsed;
-};
-export const runCompletions = async (args) => {
-    const parsed = parseCompletionsArgs(args);
-    if (parsed.subcommand === "status") {
-        const status = await resolveCompletionStatus();
-        if (!status.scriptExists) {
-            console.log("Shell completions are not installed.");
-            return;
-        }
-        console.log(`shell: ${status.shell ?? "unknown"}`);
-        if (status.scriptPath)
-            console.log(`script: ${status.scriptPath}`);
-        if (status.rcPath) {
-            console.log(status.rcConfigured
-                ? `rc: ${status.rcPath}`
-                : `rc: missing (${status.rcPath})`);
-        }
-        return;
-    }
-    if (parsed.subcommand === "generate") {
-        if (!parsed.shell)
-            throw new Error("Usage: dvb completions generate <shell>");
-        console.log(generateCompletionScript(parsed.shell));
-        return;
-    }
-    const shell = parsed.shell ?? resolveShellFromEnv();
-    if (!shell) {
-        throw new Error("Unable to detect shell. Use --shell <bash|zsh|fish>.");
-    }
-    if (parsed.subcommand === "install") {
-        const { scriptPath, rcPath } = await installCompletions(shell);
-        console.log(`Installed completions for ${shell}.`);
-        console.log(`script: ${scriptPath}`);
-        if (rcPath)
-            console.log(`rc: ${rcPath}`);
-        return;
-    }
-    if (parsed.subcommand === "uninstall") {
-        const { scriptPath, rcPath } = await uninstallCompletions(shell);
-        console.log(`Removed completions for ${shell}.`);
-        console.log(`script: ${scriptPath}`);
-        if (rcPath)
-            console.log(`rc: ${rcPath}`);
-        return;
-    }
-    usage();
-    process.exitCode = 1;
-};
-export const runComplete = async (args) => {
-    if (args.length === 0) {
-        process.exitCode = 1;
-        return;
-    }
-    if (args.length === 1) {
-        const shell = normalizeShell(args[0]);
-        if (!shell) {
-            process.exitCode = 1;
-            return;
-        }
-        console.log(generateCompletionScript(shell));
-        return;
-    }
-    const words = args[0] === "--" ? args.slice(1) : args.slice(0);
-    let data;
-    try {
-        data = await loadCompletionData(words);
-    }
-    catch {
-        data = {
-            boxes: [],
-            boxSessionNames: [],
-            boxSessionRefs: [],
-            sessionRefs: [],
-        };
-    }
-    const root = createCompletionRoot(data);
-    root.parse(words);
-};
-export const recordCompletionAliases = async (boxes) => {
-    const aliases = dedupeAliases(boxes
-        .map((box) => (typeof box.alias === "string" ? box.alias : ""))
-        .filter((alias) => alias.length > 0));
-    const cache = await loadCompletionCache();
-    const existing = cache.boxes?.remote ?? [];
-    const aliasChanged = !sameAliasSet(aliases, existing);
-    if (!aliasChanged)
-        return;
-    cache.boxes = {
-        ...(cache.boxes ?? {}),
-        remote: aliases,
-        updatedAt: nowIso(),
-    };
-    await saveCompletionCache(cache);
-};
-export const recordCompletionSessionsFromMap = async (spriteAlias, sessions) => {
-    await updateCompletionCacheSessionsFromMap(spriteAlias, sessions, {
-        mode: "replace",
-    });
-};
-export const recordCompletionSessionsFromViews = async (spriteAlias, sessions) => {
-    await updateCompletionCacheSessionsFromViews(spriteAlias, sessions, {
-        mode: "replace",
-    });
-};
-//# sourceMappingURL=index.js.map