ragevault 0.2.3

package/dist/tui/app.js

@@ -0,0 +1,607 @@
+/**
+ * RageVault terminal UI — a menu-driven, searchable vault browser.
+ *
+ * No shortcuts to memorise: you move with the arrow keys, **type to search**, and
+ * press Enter to open a **menu** of actions. Secrets stay blurred until you pick
+ * "Reveal". Passwords live in a folder tree (branches), each item shows an icon,
+ * and there's a built-in generator and one-key copy. Auto-locks after idle.
+ *
+ * Part of RageVault.
+ * Crafted by SoyRage Agency — https://soyrage.es/
+ * MIT licensed (see LICENSE).
+ */
+import { ASCII_BANNER, BRAND } from "../branding.js";
+import { color, ctl, padEnd, truncate, visLen } from "./ansi.js";
+import { readVaultFile, saveVault, unlockVault } from "../store/vaultfile.js";
+import { estimateStrength, generatePassphrase, generatePassword } from "../generator.js";
+import { breachCount } from "../audit.js";
+import { totp } from "../totp.js";
+import { newId } from "../model.js";
+const IDLE_LOCK_MS = 5 * 60 * 1000;
+const UNFILED = "__unfiled__";
+export class VaultTui {
+    path;
+    out;
+    inp;
+    mode = "unlock";
+    vault = null;
+    pwBuffer = "";
+    unlockError = "";
+    search = "";
+    sel = 0;
+    expanded = new Set();
+    revealed = new Set();
+    menu = null;
+    prompt = null;
+    overlay = "";
+    status = "";
+    lastActivity = Date.now();
+    timer = null;
+    clearTimer = null;
+    /** Breach-check cache: password → count (-2 checking, -1 unknown/offline). */
+    breach = new Map();
+    breachTimer = null;
+    onData = (k) => this.onKey(k);
+    constructor(path, out = process.stdout, inp = process.stdin) {
+        this.path = path;
+        this.out = out;
+        this.inp = inp;
+    }
+    start() {
+        this.out.write(ctl.enterAlt + ctl.hideCursor + ctl.clear);
+        if (this.inp.isTTY)
+            this.inp.setRawMode(true);
+        this.inp.resume();
+        this.inp.setEncoding("utf8");
+        this.inp.on("data", this.onData);
+        this.out.on("resize", () => this.render());
+        this.timer = setInterval(() => {
+            if (this.mode === "main" && Date.now() - this.lastActivity > IDLE_LOCK_MS)
+                this.lock("Auto-locked (idle).");
+        }, 5000);
+        if (typeof this.timer.unref === "function")
+            this.timer.unref();
+        this.render();
+    }
+    quit() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.clearTimer) {
+            clearTimeout(this.clearTimer);
+            this.out.write("\x1b]52;c;\x07");
+        }
+        this.out.write(ctl.showCursor + ctl.exitAlt);
+        this.out.write(`\n  Locked. Thanks for using ${color.accent(BRAND.product)} — ${color.brightBlue(BRAND.url)}\n\n`);
+        process.exit(0);
+    }
+    lock(reason) {
+        this.vault = null;
+        this.revealed.clear();
+        this.mode = "unlock";
+        this.pwBuffer = "";
+        this.menu = null;
+        this.prompt = null;
+        this.overlay = "";
+        this.unlockError = reason;
+        this.render();
+    }
+    save() { if (this.vault)
+        saveVault(this.path, this.vault); }
+    // ---- input routing ------------------------------------------------------
+    onKey(key) {
+        if (key === "\x03")
+            return this.quit();
+        this.lastActivity = Date.now();
+        if (this.overlay) {
+            this.overlay = "";
+            return this.render();
+        }
+        if (this.mode === "unlock")
+            return this.onUnlockKey(key);
+        if (this.prompt)
+            return this.onPromptKey(key);
+        if (this.menu)
+            return this.onMenuKey(key);
+        return this.onBrowseKey(key);
+    }
+    onUnlockKey(key) {
+        if (key === "\r" || key === "\n")
+            return this.tryUnlock();
+        if (key === "\x7f" || key === "\b") {
+            this.pwBuffer = this.pwBuffer.slice(0, -1);
+            return this.render();
+        }
+        if (key >= " " && key.length === 1) {
+            this.pwBuffer += key;
+            this.render();
+        }
+    }
+    tryUnlock() {
+        const pw = this.pwBuffer;
+        this.pwBuffer = "";
+        try {
+            this.vault = unlockVault(readVaultFile(this.path), pw);
+            this.vault.data.folders ??= [];
+            this.vault.data.trash ??= [];
+            for (const f of this.vault.data.folders)
+                if (!f.parentId)
+                    this.expanded.add(f.id);
+            this.expanded.add(UNFILED);
+            this.mode = "main";
+            this.sel = 0;
+            this.unlockError = "";
+        }
+        catch (e) {
+            this.unlockError = e.message;
+        }
+        this.render();
+        this.scheduleBreach();
+    }
+    onPromptKey(key) {
+        const p = this.prompt;
+        if (key === "\x1b") {
+            this.prompt = null;
+            return this.render();
+        }
+        if (key === "\r" || key === "\n") {
+            this.prompt = null;
+            p.onSubmit(p.value.trim());
+            return;
+        }
+        if (key === "\x7f" || key === "\b")
+            p.value = p.value.slice(0, -1);
+        else if (key >= " " && key.length === 1)
+            p.value += key;
+        this.render();
+    }
+    onMenuKey(key) {
+        const m = this.menu;
+        if (key === "\x1b" || key === "q") {
+            this.menu = null;
+            return this.render();
+        }
+        if (key === "\x1b[A" || key === "k") {
+            m.index = (m.index - 1 + m.items.length) % m.items.length;
+            return this.render();
+        }
+        if (key === "\x1b[B" || key === "j") {
+            m.index = (m.index + 1) % m.items.length;
+            return this.render();
+        }
+        if (key === "\r" || key === "\n") {
+            const it = m.items[m.index];
+            this.menu = null;
+            it.run();
+            return;
+        }
+    }
+    onBrowseKey(key) {
+        const rows = this.rows();
+        switch (key) {
+            case "\x1b":
+                if (this.search) {
+                    this.search = "";
+                    this.sel = 0;
+                    return this.render();
+                }
+                return this.openMainMenu();
+            case "\x1b[A":
+            case "\x10":
+                this.move(rows, -1);
+                return;
+            case "\x1b[B":
+            case "\x0e":
+                this.move(rows, 1);
+                return;
+            case "\r":
+            case "\n": return this.activate(rows[this.sel]);
+            case "\x7f":
+            case "\b":
+                if (this.search) {
+                    this.search = this.search.slice(0, -1);
+                    this.sel = 0;
+                    this.render();
+                    this.scheduleBreach();
+                }
+                return;
+            default:
+                if (key >= " " && key.length === 1) {
+                    this.search += key;
+                    this.sel = 0;
+                    this.render();
+                    this.scheduleBreach();
+                }
+        }
+    }
+    move(rows, d) {
+        if (!rows.length)
+            return;
+        this.sel = (this.sel + d + rows.length) % rows.length;
+        this.render();
+        this.scheduleBreach();
+    }
+    activate(row) {
+        if (!row)
+            return;
+        if (row.kind === "folder") {
+            const id = row.folder.id;
+            this.expanded.has(id) ? this.expanded.delete(id) : this.expanded.add(id);
+            return this.render();
+        }
+        this.openItemMenu(row.item);
+    }
+    // ---- menus --------------------------------------------------------------
+    openMainMenu() {
+        this.menu = {
+            title: "Menu", index: 0, items: [
+                { label: "＋  New item", run: () => this.newItem() },
+                { label: "📁  New folder", run: () => this.newFolder() },
+                { label: "🎲  Generate a password", run: () => this.generate() },
+                { label: "🔒  Lock the vault", run: () => this.lock("Locked.") },
+                { label: "✕  Quit", run: () => this.quit() },
+            ],
+        };
+        this.render();
+    }
+    openItemMenu(item) {
+        const shown = this.revealed.has(item.id);
+        const items = [
+            { label: shown ? "🙈  Hide password" : "👁  Reveal password", run: () => { shown ? this.revealed.delete(item.id) : this.revealed.add(item.id); this.render(); } },
+            { label: "📋  Copy password", run: () => { if (item.password) {
+                    this.copy(item.password);
+                    this.flash("Password copied (clears in 20s)");
+                } } },
+        ];
+        if (item.username)
+            items.push({ label: "👤  Copy username", run: () => { this.copy(item.username); this.flash("Username copied"); } });
+        if (item.totp)
+            items.push({ label: "🔑  Copy 2FA code", run: () => { try {
+                    const { code, remaining } = totp(item.totp);
+                    this.copy(code);
+                    this.flash(`2FA ${code} copied (${remaining}s)`);
+                }
+                catch {
+                    this.flash("bad 2FA secret");
+                } } });
+        items.push({ label: "✏️  Rename", run: () => this.rename(item) }, { label: "🎲  Regenerate password", run: () => this.regenerate(item) }, { label: "📂  Move to folder…", run: () => this.openMoveMenu(item) }, { label: "🗑  Delete", danger: true, run: () => this.confirmDelete(item) }, { label: "←  Close", run: () => { } });
+        this.menu = { title: item.title, items, index: 0 };
+        this.render();
+    }
+    openMoveMenu(item) {
+        const folders = this.vault.data.folders;
+        const items = [{ label: "＊  General (no folder)", run: () => { item.folderId = undefined; item.updatedAt = new Date().toISOString(); this.save(); this.flash("Moved to General"); } }];
+        for (const f of folders)
+            items.push({ label: `📁  ${f.name}`, run: () => { item.folderId = f.id; item.updatedAt = new Date().toISOString(); this.save(); this.flash(`Moved to ${f.name}`); } });
+        items.push({ label: "←  Cancel", run: () => { } });
+        this.menu = { title: `Move “${item.title}”`, items, index: 0 };
+        this.render();
+    }
+    confirmDelete(item) {
+        this.menu = {
+            title: `Delete “${item.title}”?`, index: 1, items: [
+                { label: "🗑  Yes, move to trash", danger: true, run: () => { const v = this.vault.data; v.items = v.items.filter((i) => i.id !== item.id); (v.trash ??= []).unshift(item); this.save(); this.sel = Math.max(0, this.sel - 1); this.flash("Moved to trash"); } },
+                { label: "←  No, keep it", run: () => { } },
+            ],
+        };
+        this.render();
+    }
+    // ---- actions ------------------------------------------------------------
+    currentFolderId() {
+        const row = this.rows()[this.sel];
+        if (!row)
+            return undefined;
+        if (row.kind === "folder")
+            return row.folder.id === UNFILED ? undefined : row.folder.id;
+        return row.item.folderId;
+    }
+    newItem() {
+        this.prompt = { label: "New item — title", value: "", hint: "a strong password is generated for you", onSubmit: (title) => {
+                if (!title)
+                    return this.render();
+                const now = new Date().toISOString();
+                const item = { id: newId(), title, password: generatePassword({ length: 20 }), folderId: this.currentFolderId(), tags: [], favorite: false, createdAt: now, updatedAt: now, history: [] };
+                this.vault.data.items.push(item);
+                this.save();
+                this.flash(`Added “${title}” with a generated password`);
+                this.render();
+            } };
+        this.render();
+    }
+    newFolder() {
+        this.prompt = { label: "New folder — name", value: "", onSubmit: (name) => {
+                if (!name)
+                    return this.render();
+                const parentId = this.currentFolderId();
+                const f = { id: newId(), name, parentId };
+                this.vault.data.folders.push(f);
+                this.expanded.add(f.id);
+                this.save();
+                this.flash(`Created folder “${name}”`);
+                this.render();
+            } };
+        this.render();
+    }
+    rename(item) {
+        this.prompt = { label: "Rename to", value: item.title, onSubmit: (v) => { if (v) {
+                item.title = v;
+                item.updatedAt = new Date().toISOString();
+                this.save();
+                this.flash("Renamed");
+            } this.render(); } };
+        this.render();
+    }
+    regenerate(item) {
+        if (item.password)
+            item.history.unshift({ password: item.password, changedAt: new Date().toISOString() });
+        item.password = generatePassword({ length: 20 });
+        item.updatedAt = new Date().toISOString();
+        this.revealed.add(item.id);
+        this.save();
+        const s = estimateStrength(item.password);
+        this.flash(`New password · ${s.bits} bits · ${s.label}`);
+    }
+    generate() {
+        const pw = generatePassword({ length: 20 });
+        const s = estimateStrength(pw);
+        this.copy(pw);
+        this.overlay = `${color.bold("Generated password")}\n\n  ${color.accent(pw)}\n\n  ${color.dim(`${s.bits} bits · ${s.label} · copied to clipboard`)}\n\n  ${color.dim("Passphrase:")} ${color.accent(generatePassphrase(4))}`;
+        this.render();
+    }
+    flash(msg) { this.status = msg; this.render(); }
+    copy(text) {
+        this.out.write(`\x1b]52;c;${Buffer.from(text).toString("base64")}\x07`);
+        if (this.clearTimer)
+            clearTimeout(this.clearTimer);
+        this.clearTimer = setTimeout(() => { this.out.write("\x1b]52;c;\x07"); if (this.mode === "main") {
+            this.status = color.gray("Clipboard cleared");
+            this.render();
+        } }, 20000);
+        if (typeof this.clearTimer.unref === "function")
+            this.clearTimer.unref();
+    }
+    // ---- password safety (strength + HIBP breach check) ---------------------
+    isRisky(it) {
+        if (!it.password)
+            return false;
+        if (estimateStrength(it.password).bits < 50)
+            return true;
+        return (this.breach.get(it.password) ?? 0) > 0;
+    }
+    breachStatus(it) {
+        if (!it.password)
+            return color.gray("—");
+        if (process.env.RAGEVAULT_NO_BREACH_CHECK)
+            return color.gray("check disabled");
+        const n = this.breach.get(it.password);
+        if (n === undefined)
+            return color.dim("…");
+        if (n === -2)
+            return color.dim("checking HIBP…");
+        if (n === -1)
+            return color.gray("unavailable (offline)");
+        if (n === 0)
+            return color.green("✓ not in known breaches");
+        return color.red(`⚠ found in ${n.toLocaleString()} breaches — regenerate!`);
+    }
+    /** Debounced HIBP check for the selected item (k-anonymity — only a hash prefix leaves). */
+    scheduleBreach() {
+        if (process.env.RAGEVAULT_NO_BREACH_CHECK)
+            return;
+        if (this.breachTimer)
+            clearTimeout(this.breachTimer);
+        this.breachTimer = setTimeout(() => {
+            const row = this.rows()[this.sel];
+            const it = row?.item;
+            if (!it?.password || this.breach.has(it.password))
+                return;
+            const pw = it.password;
+            this.breach.set(pw, -2);
+            this.render();
+            void breachCount(pw).then((n) => { this.breach.set(pw, n); if (this.mode === "main")
+                this.render(); }).catch(() => this.breach.set(pw, -1));
+        }, 350);
+        if (typeof this.breachTimer.unref === "function")
+            this.breachTimer.unref();
+    }
+    // ---- tree ---------------------------------------------------------------
+    matches(i) {
+        const f = this.search.trim().toLowerCase();
+        return !f || i.title.toLowerCase().includes(f) || (i.username ?? "").toLowerCase().includes(f) || (i.url ?? "").toLowerCase().includes(f);
+    }
+    rows() {
+        const v = this.vault?.data;
+        if (!v)
+            return [];
+        const rows = [];
+        // When searching, show a flat list of matches (no folder chrome).
+        if (this.search.trim()) {
+            for (const i of v.items.filter((x) => this.matches(x)).sort((a, b) => a.title.localeCompare(b.title)))
+                rows.push({ kind: "item", depth: 0, last: false, item: i });
+            return rows;
+        }
+        const childFolders = (pid) => v.folders.filter((f) => (f.parentId ?? undefined) === pid).sort((a, b) => a.name.localeCompare(b.name));
+        const itemsIn = (fid) => v.items.filter((i) => (i.folderId ?? UNFILED) === fid).sort((a, b) => Number(b.favorite) - Number(a.favorite) || a.title.localeCompare(b.title));
+        const walk = (folder, depth) => {
+            rows.push({ kind: "folder", depth, last: false, folder });
+            if (!this.expanded.has(folder.id))
+                return;
+            for (const c of childFolders(folder.id))
+                walk(c, depth + 1);
+            const its = itemsIn(folder.id);
+            its.forEach((i, k) => rows.push({ kind: "item", depth: depth + 1, last: k === its.length - 1, item: i }));
+        };
+        for (const root of childFolders(undefined))
+            walk(root, 0);
+        // Unfiled items under a synthetic "General" branch.
+        const unfiled = itemsIn(UNFILED);
+        if (unfiled.length || !v.folders.length) {
+            rows.push({ kind: "folder", depth: 0, last: false, folder: { id: UNFILED, name: "General" } });
+            if (this.expanded.has(UNFILED))
+                unfiled.forEach((i, k) => rows.push({ kind: "item", depth: 1, last: k === unfiled.length - 1, item: i }));
+        }
+        return rows;
+    }
+    // ---- render -------------------------------------------------------------
+    cols() { return this.out.columns && this.out.columns > 40 ? this.out.columns : 92; }
+    rows_() { return this.out.rows && this.out.rows > 12 ? this.out.rows : 28; }
+    render() {
+        const lines = this.mode === "unlock" ? this.unlockLines() : this.mainLines();
+        if (this.menu)
+            this.overlayBox(lines, this.menuText(), "☰ " + this.menu.title);
+        if (this.prompt)
+            this.overlayBox(lines, this.promptText(), "✎");
+        if (this.overlay)
+            this.overlayBox(lines, this.overlay, "");
+        const cols = this.cols();
+        let frame = ctl.home;
+        for (let i = 0; i < lines.length; i++) {
+            frame += truncate(lines[i] ?? "", cols) + ctl.clearLine;
+            if (i < lines.length - 1)
+                frame += "\n";
+        }
+        frame += ctl.clearBelow;
+        this.out.write(frame);
+    }
+    unlockLines() {
+        const cols = this.cols(), rows = this.rows_();
+        const center = (s) => " ".repeat(Math.max(0, Math.floor((cols - visLen(s)) / 2))) + s;
+        const lines = [];
+        const banner = ASCII_BANNER.split("\n");
+        for (let i = 0; i < Math.max(1, Math.floor((rows - banner.length - 7) / 2)); i++)
+            lines.push("");
+        for (const b of banner)
+            lines.push(center(color.accent(b)));
+        lines.push("", center(color.bold("Enter your master password to unlock")), "");
+        lines.push(center(`${color.accent("❯")} ${"•".repeat(Math.min(32, this.pwBuffer.length))}${color.dim("▏")}`), "");
+        if (this.unlockError)
+            lines.push(center(color.red("✗ " + this.unlockError)), "");
+        lines.push(center(color.dim("Enter to unlock · Ctrl-C to quit · keep this behind your VPN")));
+        return lines;
+    }
+    mainLines() {
+        const cols = this.cols(), rows = this.rows_();
+        const list = this.rows();
+        if (this.sel >= list.length)
+            this.sel = Math.max(0, list.length - 1);
+        const lines = [];
+        const brand = `${color.accent(color.bold("SOYRAGE"))} ${color.gray("▸")} ${color.bold(BRAND.product)} ${color.gray("·")} ${this.vault.data.meta.name}`;
+        const count = `${color.gray(this.vault.data.items.length + " items")}  ${color.green("● unlocked")}`;
+        lines.push(" " + brand + " ".repeat(Math.max(1, cols - 2 - visLen(brand) - visLen(count))) + count);
+        const sb = this.search ? `${color.bold(this.search)}${color.dim("▏")}` : color.dim("type to search…");
+        const hint = color.dim("Enter = open · Esc = menu");
+        lines.push(` ${color.accent("⌕")} ${sb}${" ".repeat(Math.max(1, cols - 4 - visLen(sb) - visLen(hint)))}${hint}`);
+        lines.push(" " + color.gray("─".repeat(cols - 2)));
+        // Two panes: the tree on the left, live detail for the selection on the right.
+        const bodyH = Math.max(4, rows - 5);
+        const leftW = Math.max(28, Math.floor(cols * 0.52));
+        const rightW = Math.max(20, cols - leftW - 3);
+        const start = Math.max(0, Math.min(this.sel - Math.floor(bodyH / 2), Math.max(0, list.length - bodyH)));
+        const detail = this.detailRows(list[this.sel], rightW, bodyH);
+        for (let i = 0; i < bodyH; i++) {
+            const row = list[start + i];
+            const left = row ? this.rowText(row, start + i === this.sel, leftW) : " ".repeat(leftW);
+            lines.push(` ${left} ${color.gray("│")} ${detail[i] ?? ""}`);
+        }
+        lines.push(" " + color.gray("─".repeat(cols - 2)));
+        const foot = this.status ? color.green(this.status) : color.gray("↑/↓ move · type to search · Enter opens a menu · Esc for the main menu");
+        lines.push(" " + truncate(foot, cols - 2));
+        return lines;
+    }
+    rowText(row, active, width) {
+        const indent = "  ".repeat(row.depth);
+        let text;
+        if (row.kind === "folder") {
+            const open = this.expanded.has(row.folder.id);
+            const caret = color.gray(open ? "▾" : "▸");
+            const glyph = row.folder.icon || "📁";
+            text = `${indent}${caret} ${glyph} ${color.bold(color.accent(row.folder.name))}`;
+        }
+        else {
+            const it = row.item;
+            const branch = color.gray(row.last ? "└─" : "├─");
+            const icon = this.itemIcon(it);
+            const twofa = it.totp ? color.gray(" ·2FA") : "";
+            const bad = this.isRisky(it) ? color.red(" ⚠") : "";
+            text = `${indent}${branch} ${icon} ${it.title}${twofa}${bad}`;
+        }
+        const t = padEnd(truncate(text, width), width);
+        return active ? color.bgAccent(t) : t;
+    }
+    /** The live detail pane for whatever is selected. */
+    detailRows(sel, width, height) {
+        const field = (k, v) => `${color.gray(padEnd(k, 9))} ${v}`;
+        let out = [];
+        if (!sel)
+            out = [color.gray("Empty vault.")];
+        else if (sel.kind === "folder") {
+            const f = sel.folder;
+            const n = this.vault.data.items.filter((i) => (i.folderId ?? UNFILED) === f.id).length;
+            out = [`${f.icon || "📁"} ${color.bold(color.accent(f.name))}`, "", field("Items", String(n)), "", color.dim("Enter to " + (this.expanded.has(f.id) ? "collapse" : "expand") + " this folder.")];
+        }
+        else {
+            const it = sel.item;
+            const revealed = this.revealed.has(it.id);
+            const s = it.password ? estimateStrength(it.password) : null;
+            out = [
+                `${this.itemIcon(it)}  ${color.bold(it.title)}`,
+                "",
+                field("User", it.username ?? color.gray("—")),
+                field("URL", it.url ?? color.gray("—")),
+                field("Folder", this.vault.data.folders.find((f) => f.id === it.folderId)?.name ?? color.gray("General")),
+                "",
+                field("Password", revealed ? color.accent(it.password ?? "") : color.dim("•••••••• ") + color.gray("(reveal in menu)")),
+            ];
+            if (s)
+                out.push(field("Strength", `${s.bits < 50 ? color.red(s.bits + " bits · " + s.label) : color.green(s.bits + " bits · " + s.label)}`));
+            out.push(field("Breach", this.breachStatus(it)));
+            if (it.totp) {
+                try {
+                    const { code, remaining } = totp(it.totp);
+                    out.push(field("2FA", `${color.accent(code)} ${color.gray("(" + remaining + "s)")}`));
+                }
+                catch {
+                    out.push(field("2FA", color.red("bad secret")));
+                }
+            }
+            for (const f of it.fields ?? [])
+                out.push(field(f.label.slice(0, 8), f.secret && !revealed ? color.dim("••••••") : f.value));
+            if (this.isRisky(it))
+                out.push("", color.red("⚠ Weak or breached — open the menu and pick"), color.red("  “Regenerate password”."));
+            out.push("", color.dim("Enter → actions menu"));
+        }
+        return out.slice(0, height).map((r) => truncate(r, width)).concat(Array(Math.max(0, height - out.length)).fill(""));
+    }
+    itemIcon(it) {
+        if (it.icon)
+            return it.icon;
+        const ch = (it.title.trim()[0] || "•").toUpperCase();
+        return color.accent(ch);
+    }
+    menuText() {
+        return this.menu.items.map((it, i) => {
+            const label = it.danger ? color.red(it.label) : it.label;
+            return i === this.menu.index ? color.bgAccent(" " + padEnd(it.label, 26) + " ") : "  " + label;
+        }).join("\n");
+    }
+    promptText() {
+        const p = this.prompt;
+        return `${color.bold(p.label)}\n\n  ${color.accent("❯")} ${color.bold(p.value)}${color.dim("▏")}\n${p.hint ? "\n  " + color.dim(p.hint) : ""}\n  ${color.dim("Enter to confirm · Esc to cancel")}`;
+    }
+    overlayBox(lines, body, title) {
+        const cols = this.cols(), rows = this.rows_();
+        const raw = (title ? [color.accent(color.bold(title)), color.gray("─".repeat(Math.max(6, visLen(title) + 2))), ""] : []).concat(body.split("\n"));
+        const w = Math.min(cols - 6, Math.max(28, ...raw.map(visLen)) + 4);
+        const box = [color.gray("╭" + "─".repeat(w) + "╮")];
+        for (const r of raw)
+            box.push(color.gray("│") + " " + padEnd(r, w - 2) + " " + color.gray("│"));
+        box.push(color.gray("╰" + "─".repeat(w) + "╯"));
+        if (this.overlay)
+            box.push(color.gray("  press any key to close"));
+        const top = Math.max(0, Math.floor((rows - box.length) / 2));
+        const left = Math.max(0, Math.floor((cols - w) / 2));
+        for (let i = 0; i < box.length; i++)
+            if (top + i < lines.length)
+                lines[top + i] = " ".repeat(left) + box[i];
+    }
+}
+//# sourceMappingURL=app.js.map