zames_pro 2.73.11 → 2.75.0

package/dist/tui/edit.js

@@ -0,0 +1,317 @@
+// PURE input-editing logic for the Ink TUI — the state transitions of the
+// input line, extracted from the old LineEditor so they are unit-testable
+// without a terminal.
+//
+// The editor state is a plain object (buffer, cursor, history, pastes, ...).
+// Each action returns a NEW state (or the same object when nothing changed), so
+// the React layer can `setState` cheaply. Terminal I/O, rendering and timers
+// live in the component; everything here is a pure function of (state, action).
+import { layoutInput, pasteReplacement, visLen, charWidth, NL, } from '../input/layout.js';
+export function initialEditState() {
+    return {
+        buf: '',
+        cursor: 0,
+        pastes: [],
+        history: [],
+        histIndex: 0,
+        histDraft: '',
+        searchMode: false,
+        searchQuery: '',
+        searchIndex: -1,
+        searchSavedBuf: '',
+        undo: [],
+        typingRun: false,
+    };
+}
+/** Chars (code points) of the buffer. */
+function charsOf(s) {
+    return Array.from(s.buf);
+}
+/** Insert a string at the cursor. */
+export function insertText(s, text) {
+    const chars = charsOf(s);
+    const ins = Array.from(String(text));
+    const next = chars.slice(0, s.cursor).concat(ins, chars.slice(s.cursor));
+    return { ...s, buf: next.join(''), cursor: s.cursor + ins.length };
+}
+/** Push an undo snapshot. `coalesce` keeps one snapshot per typing run. */
+export function pushUndo(s, coalesce = false) {
+    if (coalesce && s.typingRun)
+        return s;
+    const undo = s.undo.concat({ buf: s.buf, cursor: s.cursor });
+    if (undo.length > 200)
+        undo.shift();
+    return { ...s, undo, typingRun: coalesce };
+}
+export function undoEdit(s) {
+    if (!s.undo.length)
+        return s;
+    const undo = s.undo.slice(0, -1);
+    const prev = s.undo[s.undo.length - 1];
+    return {
+        ...s,
+        buf: prev.buf,
+        cursor: Math.min(prev.cursor, Array.from(prev.buf).length),
+        undo,
+        typingRun: false,
+    };
+}
+export function backspace(s) {
+    if (s.cursor <= 0)
+        return s;
+    const chars = charsOf(s);
+    chars.splice(s.cursor - 1, 1);
+    return { ...s, buf: chars.join(''), cursor: s.cursor - 1 };
+}
+export function del(s) {
+    const chars = charsOf(s);
+    if (s.cursor >= chars.length)
+        return s;
+    chars.splice(s.cursor, 1);
+    return { ...s, buf: chars.join('') };
+}
+/** Delete the word on the LEFT of the cursor (Ctrl+W / Alt+Backspace). */
+export function deleteWordLeft(s) {
+    const chars = charsOf(s);
+    let i = s.cursor;
+    while (i > 0 && /\s/.test(chars[i - 1]))
+        i--;
+    while (i > 0 && !/\s/.test(chars[i - 1]))
+        i--;
+    chars.splice(i, s.cursor - i);
+    return { ...s, buf: chars.join(''), cursor: i };
+}
+/**
+ * Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete).
+ *
+ * FALLBACK: at the END of the line there is no word to the right, so the key
+ * did NOTHING and the operator (whose terminal sends the standard xterm
+ * Ctrl+Delete) read it as "Ctrl+Delete does not delete the word before the
+ * cursor". Deleting the word on the LEFT there matches what other terminal
+ * editors do and what the operator expects, while keeping the standard
+ * right-delete when the cursor is mid-line.
+ */
+export function deleteWordRight(s) {
+    const chars = charsOf(s);
+    // Nothing to the right (end of buffer or only whitespace to the newline):
+    // delete the word on the LEFT instead of doing nothing.
+    let probe = s.cursor;
+    while (probe < chars.length &&
+        chars[probe] !== NL &&
+        /\s/.test(chars[probe])) {
+        probe++;
+    }
+    if (probe >= chars.length || chars[probe] === NL) {
+        return deleteWordLeft(s);
+    }
+    let i = s.cursor;
+    while (i < chars.length && /\s/.test(chars[i]))
+        i++;
+    while (i < chars.length && !/\s/.test(chars[i]))
+        i++;
+    chars.splice(s.cursor, i - s.cursor);
+    return { ...s, buf: chars.join('') };
+}
+/** Delete from the cursor to the end of the current LOGICAL line (Ctrl+K). */
+export function killToLineEnd(s) {
+    const arr = charsOf(s);
+    let e = s.cursor;
+    while (e < arr.length && arr[e] !== NL)
+        e++;
+    arr.splice(s.cursor, e - s.cursor);
+    return { ...s, buf: arr.join('') };
+}
+export function moveLeft(s) {
+    return s.cursor > 0 ? { ...s, cursor: s.cursor - 1 } : s;
+}
+export function moveRight(s) {
+    return s.cursor < Array.from(s.buf).length
+        ? { ...s, cursor: s.cursor + 1 }
+        : s;
+}
+export function moveHome(s) {
+    const chars = charsOf(s);
+    let i = s.cursor;
+    while (i > 0 && chars[i - 1] !== NL)
+        i--;
+    return i === s.cursor ? s : { ...s, cursor: i };
+}
+export function moveEnd(s) {
+    const chars = charsOf(s);
+    let i = s.cursor;
+    while (i < chars.length && chars[i] !== NL)
+        i++;
+    return i === s.cursor ? s : { ...s, cursor: i };
+}
+export function wordLeft(s) {
+    const chars = charsOf(s);
+    let i = s.cursor;
+    while (i > 0 && /\s/.test(chars[i - 1]))
+        i--;
+    while (i > 0 && !/\s/.test(chars[i - 1]))
+        i--;
+    return i === s.cursor ? s : { ...s, cursor: i };
+}
+export function wordRight(s) {
+    const chars = charsOf(s);
+    let i = s.cursor;
+    while (i < chars.length && /\s/.test(chars[i]))
+        i++;
+    while (i < chars.length && !/\s/.test(chars[i]))
+        i++;
+    return i === s.cursor ? s : { ...s, cursor: i };
+}
+/**
+ * Move the cursor `delta` VISUAL rows (wrapping-aware) and land in the column
+ * closest to the current one. Returns the same object when the target row is
+ * off the buffer (so Up/Down fall back to history).
+ */
+export function moveVisualRows(s, delta, promptStr, cols) {
+    const lay = layoutInput(promptStr, s.buf, s.cursor, cols);
+    const target = lay.cursorRow + delta;
+    if (target < 0 || target >= lay.rows.length)
+        return s;
+    const row = lay.rows[target];
+    const rowChars = Array.from(row.text);
+    const promptW = visLen(row.prefix);
+    const want = Math.max(0, lay.cursorCol - promptW);
+    let idx = row.start;
+    let w = 0;
+    while (idx < row.start + rowChars.length && w < want) {
+        w += charWidth(rowChars[idx - row.start].codePointAt(0));
+        idx++;
+    }
+    return { ...s, cursor: idx };
+}
+/** Insert a newline; a trailing «\» before the cursor is removed first. */
+export function insertNewline(s) {
+    const chars = charsOf(s);
+    if (s.cursor > 0 && chars[s.cursor - 1] === '\\') {
+        chars.splice(s.cursor - 1, 1);
+        const s2 = { ...s, buf: chars.join(''), cursor: s.cursor - 1 };
+        return insertText(s2, NL);
+    }
+    return insertText(s, NL);
+}
+/** Insert a pasted block: small pastes as-is, large ones as a marker. */
+export function insertPaste(s, raw) {
+    const rep = pasteReplacement(raw);
+    if (!rep) {
+        const text = String(raw).split('\r\n').join(NL).split('\r').join(NL);
+        return insertText(s, text);
+    }
+    return { ...insertText(s, rep.marker), pastes: s.pastes.concat(rep) };
+}
+// ---------- history ----------
+export function historyUp(s) {
+    if (!s.history.length)
+        return s;
+    let histIndex = s.histIndex;
+    let histDraft = s.histDraft;
+    if (histIndex === s.history.length)
+        histDraft = s.buf;
+    if (histIndex > 0) {
+        histIndex--;
+        const buf = s.history[histIndex];
+        return {
+            ...s,
+            histIndex,
+            histDraft,
+            buf,
+            cursor: Array.from(buf).length,
+        };
+    }
+    return { ...s, histDraft };
+}
+export function historyDown(s) {
+    if (!s.history.length)
+        return s;
+    let histIndex = s.histIndex;
+    let buf;
+    if (histIndex < s.history.length - 1) {
+        histIndex++;
+        buf = s.history[histIndex];
+    }
+    else {
+        histIndex = s.history.length;
+        buf = s.histDraft;
+    }
+    return { ...s, histIndex, buf, cursor: Array.from(buf).length };
+}
+export function searchStart(s) {
+    if (!s.history.length)
+        return s;
+    const st = {
+        ...s,
+        searchMode: true,
+        searchQuery: '',
+        searchIndex: s.history.length - 1,
+        searchSavedBuf: s.buf,
+    };
+    return searchRefresh(st, true);
+}
+export function searchRefresh(s, resetToNewest) {
+    const q = s.searchQuery;
+    const index = resetToNewest ? s.history.length - 1 : s.searchIndex;
+    for (let i = index; i >= 0; i--) {
+        if (q === '' || s.history[i].toLowerCase().includes(q.toLowerCase())) {
+            const buf = s.history[i];
+            return {
+                ...s,
+                searchIndex: i,
+                buf,
+                cursor: Array.from(buf).length,
+            };
+        }
+    }
+    return { ...s, searchIndex: -1 };
+}
+export function searchNext(s) {
+    if (s.searchIndex > 0) {
+        const prev = s.searchIndex;
+        const st = searchRefresh({ ...s, searchIndex: prev - 1 }, false);
+        if (st.searchIndex < 0)
+            return { ...st, searchIndex: prev };
+        return st;
+    }
+    return s;
+}
+export function searchAccept(s) {
+    return { ...s, searchMode: false, searchQuery: '' };
+}
+export function searchCancel(s) {
+    return {
+        ...s,
+        searchMode: false,
+        searchQuery: '',
+        buf: s.searchSavedBuf,
+        cursor: Array.from(s.searchSavedBuf).length,
+    };
+}
+export function searchInput(s, ch) {
+    return searchRefresh({ ...s, searchQuery: s.searchQuery + ch }, true);
+}
+export function searchBackspace(s) {
+    if (!s.searchQuery.length)
+        return s;
+    return searchRefresh({ ...s, searchQuery: s.searchQuery.slice(0, -1) }, true);
+}
+/** Record a submitted message in the history (dedup the last one). */
+export function recordHistory(s, text) {
+    if (!text.trim() || s.history[s.history.length - 1] === text) {
+        return { ...s, histIndex: s.history.length, histDraft: '' };
+    }
+    const history = s.history.concat(text);
+    return { ...s, history, histIndex: history.length, histDraft: '' };
+}
+/** Reset the buffer after a submit (keeps history/pastes cleared). */
+export function afterSubmit(s) {
+    return {
+        ...s,
+        buf: '',
+        cursor: 0,
+        pastes: [],
+        histIndex: s.history.length,
+        histDraft: '',
+    };
+}

package/dist/tui/keys.js

@@ -0,0 +1,195 @@
+// PURE key dispatch: turn an Ink (input, key) pair into an editor action.
+//
+// Ink normalizes terminal escape sequences into `input` + a `Key` object
+// (ctrl/meta/shift/arrows/…), so this module does NOT need the raw CSI parsing
+// the old LineEditor had. It maps the normalized keys to the same bindings the
+// operator is used to (Ctrl+W, Ctrl+K, Ctrl+U, Ctrl+_, word movement, history,
+// reverse search, Tab completion, Alt+B/F).
+//
+// Kept free of React/Ink runtime imports beyond the Key TYPE, so it is
+// unit-testable.
+const LF = String.fromCharCode(10);
+/**
+ * Ctrl/Alt + named keys under the KITTY keyboard protocol (CSI-u). Ink's
+ * `parseKeypress` recognizes the MODIFIED ARROW forms but returns `name=''`
+ * for the modified Delete/Backspace codepoints (CSI 3;5u, 127;5u, ...), so
+ * `useInput` yields an empty input/name and the binding never fires — the
+ * operator's "Ctrl+Delete does nothing". The legacy LineEditor parsed these
+ * bytes itself; the TUI reads them from raw stdin (Ink hides `sequence`) and
+ * maps the known ones to the SAME actions so both editors behave alike.
+ *
+ * Returns null when the string is not one of these sequences. Pure + exported
+ * for tests.
+ */
+export function parseCsiU(raw) {
+    // CSI codepoint ; modifier [: eventType] u — e.g. ESC[3;5u (Ctrl+Delete),
+    // ESC[127;5u (Ctrl+Backspace), ESC[3u (plain Delete),
+    // ESC[127u (plain Backspace), ESC[13;5u (Ctrl+Enter).
+    const m = /^\u001b\[(\d+)(?:;(\d+))?(?::\d+)?u$/.exec(raw);
+    if (!m)
+        return null;
+    const cp = Number(m[1]);
+    const mod = m[2] ? Number(m[2]) - 1 : 0;
+    const ctrl = (mod & 4) !== 0;
+    const alt = (mod & 2) !== 0;
+    if (cp === 13 && (ctrl || alt))
+        return { type: 'newline' };
+    if (cp === 3) {
+        return ctrl || alt ? { type: 'deleteWordRight' } : { type: 'delete' };
+    }
+    if (cp === 127) {
+        return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'backspace' };
+    }
+    return null;
+}
+/**
+ * Map a normalized Ink keypress to an editor action.
+ *
+ * `isVisualEdge` reports whether the cursor is on the first/last VISUAL line so
+ * Up/Down act as history only at the edges (inside a multiline input they move
+ * by visual rows). The component computes it from the live layout and passes it
+ * in, keeping this function pure.
+ */
+export function dispatchKey(input, key, ctx, isVisualEdge) {
+    // ---- reverse search modal state ----
+    if (ctx.searchMode) {
+        if (key.ctrl && input === 'r')
+            return { type: 'searchNext' };
+        if (key.return)
+            return { type: 'searchAccept' };
+        if (key.escape)
+            return { type: 'searchCancel' };
+        if (key.ctrl && input === 'c')
+            return { type: 'searchCancel' };
+        if (key.backspace || key.delete)
+            return { type: 'searchBackspace' };
+        if (input && input >= ' ' && !key.ctrl && !key.meta) {
+            return { type: 'searchInput', text: input };
+        }
+        return null;
+    }
+    // ---- control combos ----
+    if (key.ctrl) {
+        // Ctrl+Enter (kitty protocol only) inserts a newline. Ink reports it as
+        // return=true + ctrl=true, so it must be checked BEFORE the plain-return
+        // branch below (which would otherwise SUBMIT).
+        if (key.return)
+            return { type: 'newline' };
+        // Ctrl + a NAMED key (arrows, Delete, Backspace) arrives with an EMPTY
+        // `input` and the named flag set. These are the word-movement bindings:
+        // Ctrl+Left/Right move by word, Ctrl+Delete/Backspace delete a word.
+        // They MUST be checked before the `switch (input)` below, whose `default:
+        // return null` used to swallow them silently (Ctrl+arrows did nothing).
+        if (key.leftArrow)
+            return { type: 'wordLeft' };
+        if (key.rightArrow)
+            return { type: 'wordRight' };
+        if (key.delete)
+            return { type: 'deleteWordRight' };
+        if (key.backspace)
+            return { type: 'deleteWordLeft' };
+        if (key.home)
+            return { type: 'home' };
+        if (key.end)
+            return { type: 'end' };
+        switch (input) {
+            case 'c':
+                return { type: 'ctrlC' };
+            case 'd':
+                return ctx.bufferEmpty ? { type: 'ctrlD' } : { type: 'delete' };
+            case 'a':
+                return { type: 'home' };
+            case 'e':
+                return { type: 'end' };
+            case 'b':
+                return { type: 'left' };
+            case 'f':
+                return { type: 'right' };
+            case 'w':
+                return { type: 'deleteWordLeft' };
+            case 'k':
+                return { type: 'killToEnd' };
+            case 'u':
+                return { type: 'clearLine' };
+            case 'l':
+                return { type: 'clearScreen' };
+            case '_':
+                return { type: 'undoEdit' };
+            case 'r':
+                return { type: 'searchStart' };
+            case 'n':
+                return { type: 'suggestNext' };
+            case 'p':
+                return { type: 'suggestPrev' };
+            case 'v':
+                return { type: 'clipboard' };
+            case 'y':
+                return { type: 'copyCode' };
+            case 'j':
+                return { type: 'newline' };
+            default:
+                return null;
+        }
+    }
+    // ---- Alt / Meta combos (word movement + Alt+Enter newline) ----
+    if (key.meta) {
+        // Alt+Enter inserts a newline (send without submitting).
+        if (key.return)
+            return { type: 'newline' };
+        if (input === 'b')
+            return { type: 'wordLeft' };
+        if (input === 'f')
+            return { type: 'wordRight' };
+        if (key.backspace)
+            return { type: 'deleteWordLeft' };
+        if (key.delete)
+            return { type: 'deleteWordRight' };
+        return null;
+    }
+    // ---- LF as a bare newline (Ctrl+J) ----
+    // Ctrl+J sends LF (0x0A). Ink maps LF to `name='enter'` — which the public
+    // `Key` type does NOT expose — and leaves `key.ctrl` FALSE, so the ctrl
+    // branch above never fires. Without this guard LF fell through every branch
+    // (`input >= ' '` is false for 0x0A) and Ctrl+J did NOTHING. Treat a lone
+    // LF as a newline; a plain Enter (CR) still submits below.
+    if (input === LF)
+        return { type: 'newline' };
+    // ---- named keys ----
+    // Enter inserts a NEWLINE (not submit) when Shift+Enter is pressed, when a
+    // trailing backslash precedes the cursor (line continuation), or via
+    // Alt+Enter / Ctrl+J above. A PLAIN Enter submits.
+    if (key.return) {
+        if (key.shift)
+            return { type: 'newline' };
+        if (ctx.endsWithBackslash)
+            return { type: 'newline' };
+        return { type: 'submit' };
+    }
+    if (key.tab)
+        return { type: 'complete' };
+    if (key.backspace)
+        return { type: 'backspace' };
+    if (key.delete)
+        return { type: 'delete' };
+    if (key.leftArrow)
+        return { type: 'left' };
+    if (key.rightArrow)
+        return { type: 'right' };
+    if (key.upArrow) {
+        return isVisualEdge.atTop ? { type: 'historyPrev' } : { type: 'up' };
+    }
+    if (key.downArrow) {
+        return isVisualEdge.atBottom ? { type: 'historyNext' } : { type: 'down' };
+    }
+    if (key.home)
+        return { type: 'home' };
+    if (key.end)
+        return { type: 'end' };
+    if (key.escape)
+        return { type: 'escape' };
+    // ---- printable text ----
+    if (input && input >= ' ') {
+        return { type: 'insert', text: input };
+    }
+    return null;
+}

package/dist/tui/log-window.js

@@ -0,0 +1,93 @@
+// PURE windowing of the full-screen log BY RENDERED ROW.
+//
+// The old viewport sliced `log` by ENTRY COUNT: one long wrapped answer could
+// fill (or overflow) the panel while a run of short tool lines left it half
+// empty. Windowing by rows needs each entry's rendered height, which this
+// module estimates from the text and the terminal width. It is an ESTIMATE on
+// purpose: measuring the real Yoga layout per entry would need a ref per row
+// and a re-render, while counting wrapped lines is exact enough for a log and
+// costs nothing.
+/** Visible width of a line without ANSI escapes (wide chars count 2). */
+function visWidth(s) {
+    let w = 0;
+    let i = 0;
+    while (i < s.length) {
+        if (s.charCodeAt(i) === 27) {
+            i++;
+            if (s[i] === '[') {
+                i++;
+                while (i < s.length && !/[A-Za-z]/.test(s[i]))
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        const cp = s.codePointAt(i);
+        // Wide ranges (CJK/emoji) count 2; combining marks 0. Approximate — a log
+        // windowing error of one cell is invisible.
+        if (cp >= 0x1f300 && cp <= 0x1faff)
+            w += 2;
+        else if (cp >= 0x1100 && cp <= 0x9fff)
+            w += 2;
+        else if ((cp >= 0x300 && cp <= 0x36f) || cp === 0x200d)
+            w += 0;
+        else
+            w += 1;
+        i += cp > 0xffff ? 2 : 1;
+    }
+    return w;
+}
+/**
+ * How many terminal rows one log entry occupies at `cols` columns. A line
+ * longer than the width wraps (Ink uses hard wrapping for these rows). An
+ * empty line still takes one row.
+ */
+export function entryRows(entry, cols) {
+    const width = Math.max(1, cols);
+    const lines = String(entry.text ?? '').split(String.fromCharCode(10));
+    let rows = 0;
+    for (const line of lines) {
+        rows += Math.max(1, Math.ceil(visWidth(line) / width));
+    }
+    return Math.max(1, rows);
+}
+/**
+ * Slice the log so its RENDERED height fits `height` rows, keeping `scroll`
+ * rows hidden from the bottom (0 = pinned to the newest). Returns the visible
+ * entries. A single entry taller than the viewport is kept whole (its tail is
+ * shown) rather than dropped.
+ */
+export function windowByRows(entries, height, scroll, cols) {
+    const cap = Math.max(1, Math.floor(height));
+    // Walk from the newest entry backwards, accumulating rows, skipping `scroll`
+    // rows from the bottom first.
+    let skip = Math.max(0, Math.floor(scroll));
+    const picked = [];
+    let used = 0;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const r = entryRows(entries[i], cols);
+        if (skip > 0) {
+            if (skip >= r) {
+                skip -= r;
+                continue;
+            }
+            // Partially scrolled into this entry: keep the hidden part accounted.
+            skip = 0;
+        }
+        if (used + r > cap && picked.length > 0)
+            break;
+        picked.push(entries[i]);
+        used += r;
+        if (used >= cap)
+            break;
+    }
+    picked.reverse();
+    return picked;
+}
+/** Total rendered rows of a list of entries (for maxScroll). */
+export function totalRows(entries, cols) {
+    let n = 0;
+    for (const e of entries)
+        n += entryRows(e, cols);
+    return n;
+}

package/dist/tui/login-pure.js

@@ -0,0 +1,20 @@
+// PURE helpers for the Ink login / text-prompt forms. Kept separate from the
+// components so the masking and validation are unit-tested without rendering.
+/** Mask every character of a secret with `*` (code-point aware). */
+export function maskSecret(s) {
+    return '*'.repeat(Array.from(String(s ?? '')).length);
+}
+/**
+ * Validate the login form. Username is trimmed; the password is used as-is
+ * (leading/trailing spaces are legal in a password). Empty fields are
+ * rejected with the field to focus.
+ */
+export function validateLogin(username, password) {
+    if (!String(username ?? '').trim()) {
+        return { ok: false, field: 'user', reason: 'user' };
+    }
+    if (!password) {
+        return { ok: false, field: 'pass', reason: 'pass' };
+    }
+    return { ok: true, field: 'pass', reason: '' };
+}

package/dist/tui/run-config-menu.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { ConfigMenuApp } from './ConfigMenu.js';
+/**
+ * Show the Ink config menu. Returns a promise that resolves when the operator
+ * exits (q/Esc/Ctrl+C). Resolves (rather than throwing) when stdin is not a
+ * TTY so the caller can fall back to the text list.
+ */
+export async function runConfigMenuInk(opts) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+        throw new Error(opts.t('cfg.menu.notty'));
+    }
+    await new Promise((resolve) => {
+        const app = render(_jsx(ConfigMenuApp, { ...opts, onExit: () => {
+                resolve();
+            } }), { exitOnCtrlC: false });
+        app.waitUntilExit().then(() => resolve());
+    });
+}

package/dist/tui/run-confirm.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { ConfirmDialog } from './ConfirmDialog.js';
+/**
+ * Show a modal confirm and resolve with the operator's answer. Resolves false
+ * when stdin is not a TTY (nothing to prompt on).
+ */
+export async function askConfirmInk(opts) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return false;
+    return await new Promise((resolve) => {
+        let answered = false;
+        const app = render(_jsx(ConfirmDialog, { ...opts, onAnswer: (ok) => {
+                answered = true;
+                resolve(ok);
+            } }), { exitOnCtrlC: false });
+        app.waitUntilExit().then(() => {
+            if (!answered)
+                resolve(false);
+        });
+    });
+}