zames_pro 2.73.10 → 2.74.0

package/dist/tui/InputLine.js

@@ -0,0 +1,285 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The live INPUT LINE — a wrapping, multi-line editor rendered by Ink with a
+// real terminal cursor (useCursor), so IME composition and the caret land on
+// the right cell.
+//
+// The editor state transitions are PURE (src/tui/edit.ts) and the key mapping
+// is PURE (src/tui/keys.ts). This component owns only the imperative parts:
+// reading key events from Ink's useInput, bracketed paste from usePaste,
+// calling the operator callbacks (submit / abort / attach), and painting the
+// visual rows via the shared layoutInput.
+import { useCallback, useMemo, useRef, useState } from 'react';
+import { Box, Text, useInput, usePaste, useCursor, useWindowSize } from 'ink';
+import { translate } from '../i18n.js';
+import { layoutInput, visLen, charWidth, SUGGEST_PAGE, } from '../input/layout.js';
+import { insertText, insertPaste, insertNewline, backspace, del, moveLeft, moveRight, moveHome, moveEnd, wordLeft, wordRight, deleteWordLeft, deleteWordRight, killToLineEnd, moveVisualRows, pushUndo, undoEdit, historyUp, historyDown, searchStart, searchNext, searchAccept, searchCancel, searchInput, searchBackspace, recordHistory, afterSubmit, } from './edit.js';
+import { dispatchKey } from './keys.js';
+import { useSyncExternalStore } from 'react';
+import { matchSlashCommands, suggestWindow, completeSlashCommand, } from '../input/suggest.js';
+/** Render the visual rows of the buffer with the prompt on the first row. */
+function InputRows({ prompt, buf, cols, }) {
+    const lay = layoutInput(prompt, buf, 0, cols);
+    return (_jsx(Box, { flexDirection: "column", children: lay.rows.map((r, i) => (_jsxs(Text, { children: [_jsx(Text, { color: "#c8b06a", bold: true, children: r.prefix }), r.text] }, i))) }));
+}
+export function InputLine(props) {
+    const { columns } = useWindowSize();
+    const cols = columns || 80;
+    const { setCursorPosition } = useCursor();
+    const [suggestSelected, setSuggestSelected] = useState(-1);
+    // The visible page of the suggestion list follows the SELECTION: with more
+    // matches than one page, Ctrl+N could move the selection past the page and
+    // the highlight vanished (the operator "lost" the selected command). Derive
+    // the offset from the selection instead of keeping a separate state.
+    const suggestOffset = suggestSelected < 0 ? 0 : suggestSelected - (suggestSelected % SUGGEST_PAGE);
+    // The editor state lives in the STORE (props.store), read via
+    // useSyncExternalStore. This is what makes the typed line survive an Ink
+    // remount (a resize / pause): a local useState would be reset to empty on
+    // every remount, wiping what the operator had typed.
+    const st = useSyncExternalStore(props.store.subscribe, () => props.store.getSnapshot().edit);
+    const setSt = useCallback((next) => {
+        props.store.update((snap) => ({
+            edit: typeof next === 'function' ? next(snap.edit) : next,
+        }));
+    }, [props.store]);
+    // The input lives inside a rounded box: 2 columns of border (left/right) plus
+    // 1 column of inner padding on each side. The layout must wrap to the INNER
+    // width, or a long line would overflow the frame.
+    const innerCols = Math.max(4, cols - 4);
+    // Mirror the state into a ref so the useInput callback (a stable closure Ink
+    // calls for every key) always sees the latest values.
+    const stRef = useRef(st);
+    stRef.current = st;
+    // Layout for the CURRENT state — cursor positioning + visual-edge check.
+    const lay = useMemo(() => layoutInput(props.prompt, st.buf, st.cursor, innerCols), [props.prompt, st.buf, st.cursor, innerCols]);
+    const suggestions = useMemo(() => matchSlashCommands(st.buf, props.commands), [st.buf, props.commands]);
+    const apply = useCallback((fn) => {
+        setSt((prev) => {
+            const next = fn(prev);
+            if (next.pastes !== prev.pastes)
+                props.onPastesChange(next.pastes);
+            return next;
+        });
+    }, [props]);
+    const doSubmit = useCallback(() => {
+        const s = stRef.current;
+        if (props.locked)
+            return;
+        if (!s.buf.trim())
+            return;
+        const withHist = recordHistory(s, s.buf);
+        const next = afterSubmit(withHist);
+        setSt(next);
+        props.onPastesChange(next.pastes);
+        props.onHistoryChange(withHist.history);
+        props.onSubmit(s.buf, props.attachments.slice());
+    }, [props]);
+    const handlePaste = useCallback(async (text) => {
+        const trimmed = String(text).trim();
+        const looksPath = !/\s/.test(trimmed) && /[./\\]/.test(trimmed) && trimmed.length < 500;
+        if (looksPath || trimmed.startsWith('data:')) {
+            try {
+                const att = await props.onAttach(text);
+                if (att) {
+                    apply((s) => insertText(s, att.marker));
+                    return;
+                }
+            }
+            catch {
+                // fall through to plain insert
+            }
+        }
+        apply((s) => insertPaste(s, text));
+    }, [apply, props]);
+    const tryClipboard = useCallback(async () => {
+        try {
+            const att = await props.onClipboard();
+            if (att)
+                apply((s) => insertText(s, att.marker));
+        }
+        catch {
+            // ignore
+        }
+    }, [apply, props]);
+    const runAction = useCallback((action) => {
+        if (!action)
+            return;
+        switch (action.type) {
+            case 'submit':
+                doSubmit();
+                return;
+            case 'newline':
+                apply(insertNewline);
+                return;
+            case 'insert':
+                apply((s) => pushUndo(insertText(s, action.text), true));
+                return;
+            case 'backspace':
+                apply((s) => backspace(pushUndo(s, true)));
+                return;
+            case 'delete':
+                apply((s) => del(pushUndo(s, true)));
+                return;
+            case 'left':
+                apply(moveLeft);
+                return;
+            case 'right':
+                apply(moveRight);
+                return;
+            case 'up':
+                apply((s) => moveVisualRows(s, -1, props.prompt, innerCols));
+                return;
+            case 'down':
+                apply((s) => moveVisualRows(s, 1, props.prompt, innerCols));
+                return;
+            case 'home':
+                apply(moveHome);
+                return;
+            case 'end':
+                apply(moveEnd);
+                return;
+            case 'wordLeft':
+                apply(wordLeft);
+                return;
+            case 'wordRight':
+                apply(wordRight);
+                return;
+            case 'deleteWordLeft':
+                apply((s) => deleteWordLeft(pushUndo(s)));
+                return;
+            case 'deleteWordRight':
+                apply((s) => deleteWordRight(pushUndo(s)));
+                return;
+            case 'killToEnd':
+                apply((s) => killToLineEnd(pushUndo(s)));
+                return;
+            case 'clearLine':
+                apply((s) => ({ ...pushUndo(s), buf: '', cursor: 0, pastes: [] }));
+                return;
+            case 'undoEdit':
+                apply(undoEdit);
+                return;
+            case 'complete':
+                apply((s) => {
+                    const next = completeSlashCommand(s.buf, matchSlashCommands(s.buf, props.commands), suggestSelected);
+                    if (next === null)
+                        return s;
+                    return { ...s, buf: next, cursor: Array.from(next).length };
+                });
+                return;
+            case 'suggestNext':
+                setSuggestSelected((n) => Math.min(suggestions.length - 1, (n < 0 ? -1 : n) + 1));
+                return;
+            case 'suggestPrev':
+                setSuggestSelected((n) => Math.max(-1, n - 1));
+                return;
+            case 'historyPrev':
+                apply(historyUp);
+                return;
+            case 'historyNext':
+                apply(historyDown);
+                return;
+            case 'searchStart':
+                apply(searchStart);
+                return;
+            case 'searchNext':
+                apply(searchNext);
+                return;
+            case 'searchAccept':
+                apply(searchAccept);
+                return;
+            case 'searchCancel':
+                apply(searchCancel);
+                return;
+            case 'searchInput':
+                apply((s) => searchInput(s, action.text));
+                return;
+            case 'searchBackspace':
+                apply(searchBackspace);
+                return;
+            case 'escape':
+                props.onEscape();
+                return;
+            case 'ctrlC':
+            case 'ctrlD':
+                props.onCtrlC();
+                return;
+            case 'clearScreen':
+                props.onClearScreen();
+                return;
+            case 'clipboard':
+                void tryClipboard();
+                return;
+            case 'copyCode':
+                props.onCopyCode();
+                return;
+            default:
+                return;
+        }
+    }, [
+        apply,
+        props,
+        suggestions,
+        suggestSelected,
+        innerCols,
+        doSubmit,
+        tryClipboard,
+    ]);
+    useInput((input, key) => {
+        const s = stRef.current;
+        if (props.locked) {
+            if (key.ctrl && input === 'c')
+                props.onCtrlC();
+            return;
+        }
+        const curLay = layoutInput(props.prompt, s.buf, s.cursor, innerCols);
+        const atTop = curLay.cursorRow === 0;
+        const atBottom = curLay.cursorRow === curLay.rows.length - 1;
+        const action = dispatchKey(input, key, {
+            searchMode: s.searchMode,
+            bufferEmpty: s.buf.length === 0,
+            // A trailing backslash before the cursor = line continuation: Enter
+            // then inserts a newline (and drops the backslash).
+            endsWithBackslash: Array.from(s.buf)[s.cursor - 1] === '\\',
+        }, { atTop, atBottom });
+        runAction(action);
+    }, { isActive: true });
+    // Bracketed paste arrives on a SEPARATE channel — Ink enables the paste mode
+    // automatically. Deliver the whole string to the same handler.
+    usePaste((text) => {
+        void handlePaste(text);
+    });
+    // Position the real terminal cursor on the input cell. `y` is the row within
+    // the live Ink output BELOW the log. Panel layout (top to bottom):
+    //   row 0            = divider
+    //   row 1            = status bar
+    //   row 2            = input box TOP border
+    //   rows 3..         = input rows
+    const cursorRow = lay.cursorRow;
+    const rowText = lay.rows[cursorRow]?.text ?? '';
+    const cursorX = 
+    // The input rows sit inside the rounded box, indented by 1 column for the
+    // left border and 1 for the box's inner padding.
+    2 +
+        visLen(lay.rows[cursorRow]?.prefix ?? '') +
+        colWidth(rowText, lay.cursorCol - visLen(lay.rows[cursorRow]?.prefix ?? ''));
+    setCursorPosition({ x: cursorX, y: (props.cursorTop ?? 3) + cursorRow });
+    const { shown, moreCount } = suggestWindow(suggestions, suggestOffset);
+    const t = translate(props.locale);
+    return (_jsxs(Box, { flexDirection: "column", children: [suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [shown.map((c, i) => {
+                        const label = c.hint ? c.name + ' ' + c.hint : c.name;
+                        const selected = suggestOffset + i === suggestSelected;
+                        return (_jsxs(Text, { children: [_jsx(Text, { color: "#c8b06a", children: selected ? ' ▸ ' : '   ' }), _jsx(Text, { color: "#c8b06a", children: label }), _jsx(Text, { color: "#5b616e", children: '  ' + c.description })] }, c.name));
+                    }), moreCount > 0 && (_jsx(Text, { color: "#5b616e", children: '   ' +
+                            t('editor.more', { n: String(moreCount) }) +
+                            '  ' +
+                            t('editor.page_hint') }))] })), _jsx(Box, { borderStyle: "round", borderColor: props.locked ? '#5b616e' : '#c8b06a', paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(InputRows, { prompt: props.prompt, buf: st.buf, cols: innerCols }) })] }));
+}
+/** Visible width of the first `col` code points of `text` (wide chars = 2). */
+function colWidth(text, col) {
+    const chars = Array.from(text);
+    let w = 0;
+    for (let i = 0; i < col && i < chars.length; i++) {
+        w += charWidth(chars[i].codePointAt(0));
+    }
+    return Math.max(0, w);
+}

package/dist/tui/LogView.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Static, Box, Text } from 'ink';
+import { theme } from '../theme.js';
+/** One log entry. `raw` items already carry ANSI colors and are printed
+ *  verbatim; structured items get a themed prefix. */
+export function LogRow({ entry }) {
+    if (entry.raw) {
+        // Pre-rendered (markdown answer, tool preview). Print as-is; Ink passes
+        // embedded ANSI escape sequences through to the terminal.
+        return _jsx(Text, { children: entry.text });
+    }
+    switch (entry.kind) {
+        case 'user':
+            return _jsx(Text, { children: theme.user('❯ ') + entry.text });
+        case 'assistant':
+            return _jsx(Text, { children: entry.text });
+        case 'tool':
+            return _jsx(Text, { children: entry.text });
+        case 'toolResult':
+            return _jsx(Text, { children: entry.text });
+        case 'warning':
+            return _jsx(Text, { children: theme.warn(entry.text) });
+        case 'summary':
+            return _jsx(Text, { children: entry.text });
+        case 'system':
+        default:
+            return _jsx(Text, { children: theme.system(entry.text) });
+    }
+}
+/**
+ * A NON-Static log list — a plain column of rows. Used in FULL-SCREEN mode,
+ * where <Static> does NOT work: Static is absolutely positioned and is ignored
+ * by a fixed-height flex layout (the rows would not appear inside our
+ * viewport). The caller windows the entries, so only the visible slice is
+ * rendered each frame.
+ */
+export function LogList({ entries, }) {
+    return (_jsx(Box, { flexDirection: "column", children: entries.map((entry) => (_jsx(LogRow, { entry: entry }, entry.id))) }));
+}
+/**
+ * The INLINE log — rendered through Ink's <Static>, which prints each item
+ * ONCE above the live area and never repaints it. This is the right tool for
+ * the inline layout (the terminal keeps the scrollback), but it must NOT be
+ * used inside a fixed-height flex box (see LogList).
+ */
+export function LogView({ entries, }) {
+    return (_jsx(Static, { items: entries, children: (entry) => (_jsx(Box, { flexDirection: "column", children: _jsx(LogRow, { entry: entry }) }, entry.id)) }));
+}

package/dist/tui/LoginForm.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A TUI LOGIN form (username + masked password) rendered by Ink.
+//
+// The browser's own interactive login uses readline / askPassword, which
+// PAUSES the whole TUI (Ink loses the terminal to readline and both fight for
+// stdin). This form keeps the login INSIDE the TUI: the browser calls an
+// injected `onLoginPrompt` callback and never touches stdin itself.
+//
+// It is deliberately simple (two fields, Tab/↑/↓ to switch, Enter to submit,
+// Esc to cancel) — a login is a rare, focused step, not a place for menus.
+import { useState } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { UI, HintBar } from './widgets.js';
+import { maskSecret, validateLogin } from './login-pure.js';
+/** Mask every character of the password with `*`. */
+function mask(s) {
+    return maskSecret(s);
+}
+export function LoginForm({ t, initialUsername = '', initialPassword = '', note, onResult, }) {
+    const { exit } = useApp();
+    const [field, setField] = useState(initialUsername ? 'pass' : 'user');
+    const [user, setUser] = useState(initialUsername);
+    const [pass, setPass] = useState(initialPassword);
+    const [error, setError] = useState('');
+    const finish = (res) => {
+        onResult(res);
+        exit();
+    };
+    const submit = () => {
+        const v = validateLogin(user, pass);
+        if (!v.ok) {
+            setError(t(v.reason === 'user' ? 'auth.form.need_user' : 'auth.form.need_pass'));
+            setField(v.field);
+            return;
+        }
+        finish({ username: user.trim(), password: pass });
+    };
+    const append = (ch) => {
+        setError('');
+        if (field === 'user')
+            setUser((v) => v + ch);
+        else
+            setPass((v) => v + ch);
+    };
+    const backspace = () => {
+        setError('');
+        if (field === 'user')
+            setUser((v) => Array.from(v).slice(0, -1).join(''));
+        else
+            setPass((v) => Array.from(v).slice(0, -1).join(''));
+    };
+    useInput((input, key) => {
+        if (key.escape) {
+            finish(null);
+            return;
+        }
+        if (key.return) {
+            // Enter on the username moves to the password first (so a two-step
+            // prompt feels natural); Enter on the password submits.
+            if (field === 'user') {
+                setField('pass');
+                return;
+            }
+            submit();
+            return;
+        }
+        if (key.tab || key.upArrow || key.downArrow) {
+            setField((f) => (f === 'user' ? 'pass' : 'user'));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            backspace();
+            return;
+        }
+        if (input && input >= ' ')
+            append(input);
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.accent, paddingX: 2, children: [_jsx(Text, { color: UI.title, bold: true, children: '🔐 ' + t('auth.form.title') }), note ? _jsx(Text, { color: UI.dim, children: note }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: field === 'user' ? UI.accent : UI.dim, children: (field === 'user' ? '❯ ' : '  ') + t('auth.form.login') + ' ' }), _jsx(Text, { color: UI.text, children: user }), field === 'user' ? _jsx(Text, { color: UI.accent, children: "\u258F" }) : null] }), _jsxs(Box, { children: [_jsx(Text, { color: field === 'pass' ? UI.accent : UI.dim, children: (field === 'pass' ? '❯ ' : '  ') + t('auth.form.password') + ' ' }), _jsx(Text, { color: UI.text, children: mask(pass) }), field === 'pass' ? _jsx(Text, { color: UI.accent, children: "\u258F" }) : null] }), error ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: UI.err, children: '⚠ ' + error }) })) : null, _jsx(Box, { marginTop: 1, children: _jsx(HintBar, { hints: [
+                        ['Tab/↑↓', t('auth.form.hint_field')],
+                        ['Enter', t('auth.form.hint_submit')],
+                        ['Esc', t('auth.form.hint_cancel')],
+                    ] }) })] }));
+}

package/dist/tui/SelectList.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A reusable Ink SELECT LIST — a scrollable, keyboard-navigable list of items
+// with a title and an optional detail/description per row. Used by the model
+// picker and any future list menu (chats, sessions, ...).
+import { useMemo, useState } from 'react';
+import { Box, Text, useInput, useApp, useWindowSize } from 'ink';
+import { UI, HintBar } from './widgets.js';
+export function SelectList({ title, items, initial, onSelect, }) {
+    const { exit } = useApp();
+    const { rows } = useWindowSize();
+    const start = Math.max(0, items.findIndex((it) => it.value === initial));
+    const [cursor, setCursor] = useState(start);
+    const maxRows = Math.max(3, (rows || 24) - 7);
+    const win = useMemo(() => {
+        let top = Math.max(0, cursor - maxRows + 1);
+        if (cursor < top)
+            top = cursor;
+        return { top, end: Math.min(items.length, top + maxRows) };
+    }, [cursor, items.length, maxRows]);
+    const finish = (value) => {
+        onSelect(value);
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c') || input === 'q') {
+            finish(null);
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setCursor((c) => items.length ? (c - 1 + items.length) % items.length : 0);
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setCursor((c) => (items.length ? (c + 1) % items.length : 0));
+            return;
+        }
+        if (key.return) {
+            finish(items[cursor]?.value ?? null);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: UI.title, bold: true, children: '◆ ' + title }), _jsx(Text, { color: UI.dim, children: items.length })] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(40) }), items.slice(win.top, win.end).map((it, i) => {
+                const idx = win.top + i;
+                const sel = idx === cursor;
+                return (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, children: sel ? '❯ ' : '  ' }), _jsx(Text, { color: sel ? UI.accent : undefined, bold: sel, children: it.label }), it.detail ? _jsx(Text, { color: UI.dim, children: '  ' + it.detail }) : null] }, it.value));
+            }), _jsx(HintBar, { hints: [
+                    ['↑/↓', 'выбор'],
+                    ['Enter', 'ok'],
+                    ['Esc', 'отмена'],
+                ] })] }));
+}

package/dist/tui/StatusBar.js

@@ -0,0 +1,140 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useAnimation, useWindowSize } from 'ink';
+import { translate } from '../i18n.js';
+import { DOTS, stripEllipsis } from '../spinner.js';
+import { truncateToWidth } from '../input/layout.js';
+/** Elapsed seconds of the current animated phase ("0s", "45s", "2m 05s"). */
+function elapsedLabel(startedAt, animating) {
+    if (!animating || !startedAt)
+        return '';
+    const sec = Math.floor((Date.now() - startedAt) / 1000);
+    const m = Math.floor(sec / 60);
+    const s = sec % 60;
+    const text = m > 0 ? m + 'm ' + String(s).padStart(2, '0') + 's' : s + 's';
+    return ' · ' + text;
+}
+/** Lifecycle prefix, colored by meaning (generating / settled). */
+function stateLabel(state, locale) {
+    if (state.sendState === 'generating') {
+        return translate(locale)('state.generating') + ':';
+    }
+    if (state.sendState === 'settled') {
+        return translate(locale)('state.settled') + ':';
+    }
+    return '';
+}
+/** Visible width of the badge row (used to reserve space for the left
+ *  status). An emoji is counted as 2 columns; the rest as 1. Approximation is
+ *  fine — the goal is only to avoid clipping the badges. */
+function badgeTextWidth(state) {
+    let w = 0;
+    if (state.statusLine)
+        w += state.statusLine.length + 1;
+    if (state.provider)
+        w += state.provider.length + 3;
+    if (state.queueLength > 0)
+        w += 2 + String(state.queueLength).length;
+    if (state.codeBlocks.length > 0)
+        w += 8;
+    if (state.tasks)
+        w += state.tasks.length + 1;
+    if (state.thinkingEnabled)
+        w += 3;
+    if (state.searchEnabled)
+        w += 3;
+    if (state.contextText) {
+        const marker = state.contextLevel === 'high' ? 2 : state.contextLevel === 'warn' ? 2 : 0;
+        w += state.contextText.length + marker;
+    }
+    return w;
+}
+/** The badge row: statusLine, provider, queue, tasks, toggles, context. */
+function Badges({ state }) {
+    const parts = [];
+    if (state.statusLine) {
+        parts.push(_jsxs(Text, { color: "#808896", children: [state.statusLine, ' '] }, "sl"));
+    }
+    if (state.provider) {
+        parts.push(_jsx(Text, { color: "#808896", children: '[' + state.provider + '] ' }, "prov"));
+    }
+    if (state.queueLength > 0) {
+        parts.push(_jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
+    }
+    if (state.codeBlocks.length > 0) {
+        // A hint that the last answer has copyable code: Ctrl+Y copies the last
+        // block (or the focused one), like a copy button in a GUI chat.
+        const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
+        parts.push(_jsx(Text, { color: "#7fc4f0", children: '⌘ ' + idx + '/' + state.codeBlocks.length + ' ' }, "code"));
+    }
+    if (state.tasks) {
+        parts.push(_jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
+    }
+    const toggles = [];
+    if (state.thinkingEnabled)
+        toggles.push('🧠\uFE0E');
+    if (state.searchEnabled)
+        toggles.push('🌐\uFE0E');
+    if (toggles.length) {
+        parts.push(_jsx(Text, { color: "#6fd0b0", children: toggles.join(' ') + ' ' }, "tg"));
+    }
+    if (state.contextText) {
+        const color = state.contextLevel === 'high'
+            ? '#c98a80'
+            : state.contextLevel === 'warn'
+                ? '#c9a86a'
+                : '#a9c08c';
+        const marker = state.contextLevel === 'high'
+            ? '⛔ '
+            : state.contextLevel === 'warn'
+                ? '▲ '
+                : '';
+        parts.push(_jsx(Text, { color: color, children: marker + state.contextText }, "ctx"));
+    }
+    if (!parts.length)
+        return null;
+    return _jsx(Box, { children: parts });
+}
+export function StatusBar({ state, divider = true, }) {
+    // Drive the spinner from Ink's shared animation timer (one timer for the
+    // whole tree). The interval matches the old 400ms dot cadence.
+    const animating = state.busy || !!state.animBase;
+    const { frame } = useAnimation({ interval: 400, isActive: animating });
+    const t = translate(state.locale);
+    const stateLbl = stateLabel(state, state.locale);
+    let left;
+    if (state.pendingText) {
+        left = '✎ ' + state.pendingText + '  ·  ' + t('spinner.hint');
+    }
+    else if (state.animBase) {
+        const dots = DOTS[frame % DOTS.length] ?? '';
+        const pad = '   '.slice(dots.length);
+        left =
+            stripEllipsis(state.animBase) +
+                dots +
+                pad +
+                elapsedLabel(state.animStart, animating) +
+                '  ·  ' +
+                t('spinner.hint');
+    }
+    else if (state.statusText) {
+        left = state.statusText;
+    }
+    else {
+        left = '';
+    }
+    const prefix = stateLbl ? stateLbl + ' ' : '';
+    // When the log is scrolled up, show a marker in the status line (NOT as a
+    // separate row below the input — that pushed the panel up and made the input
+    // jump). It replaces the spinner text while scrolled, so it never adds a row.
+    const scrollNote = state.scroll > 0 ? `↑ прокручено на ${state.scroll} стр. · PgDn/End` : '';
+    const leftText = scrollNote || prefix + left;
+    const showLeft = !!leftText;
+    // Keep the badge row visible: the left status truncates to whatever space is
+    // left after the badges, instead of pushing them off the right edge (they
+    // used to be clipped: "[DeepSee⧗1 задачи: 3/...").
+    const cols = useWindowSize().columns || 80;
+    const badgeWidth = badgeTextWidth(state);
+    const maxLeft = Math.max(0, cols - badgeWidth - 2);
+    const leftOut = showLeft ? truncateToWidth(leftText, maxLeft) : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [divider ? _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) }) : null, _jsxs(Box, { justifyContent: "space-between", children: [_jsx(Box, { children: leftOut ? _jsx(Text, { color: "#a1723f", children: leftOut }) : _jsx(Text, { children: " " }) }), _jsx(Badges, { state: state })] })] }));
+}

package/dist/tui/TextPrompt.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A one-line Ink TEXT PROMPT (label + single input + Enter/Esc).
+//
+// Used for steps the browser asks for interactively (currently the DeepSeek
+// email one-time code) so they stay INSIDE the TUI instead of falling back to
+// promptOnce/readline, which pauses Ink and fights it for stdin.
+import { useState } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { UI, HintBar } from './widgets.js';
+import { maskSecret } from './login-pure.js';
+function mask(s) {
+    return maskSecret(s);
+}
+export function TextPrompt({ label, secret, t, onResult, }) {
+    const { exit } = useApp();
+    const [value, setValue] = useState('');
+    const finish = (v) => {
+        onResult(v);
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.escape) {
+            finish(null);
+            return;
+        }
+        if (key.return) {
+            finish(value.trim());
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setValue((v) => Array.from(v).slice(0, -1).join(''));
+            return;
+        }
+        if (input && input >= ' ')
+            setValue((v) => v + input);
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.accent, paddingX: 2, children: [_jsx(Text, { color: UI.text, children: label }), _jsxs(Text, { color: UI.accent, children: ['❯ ', secret ? mask(value) : value, '▏'] }), _jsx(HintBar, { hints: [
+                    ['Enter', t('auth.form.hint_submit')],
+                    ['Esc', t('auth.form.hint_cancel')],
+                ] })] }));
+}