@bytevion/cli 0.2.0 → 0.4.0

package/dist/tui/components/Picker.js

@@ -0,0 +1,68 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import React from 'react';
+import { glyphs, tones } from '../theme.js';
+// A keyboard-driven list: Up/Down (and j/k) move the cursor, Enter selects, with an optional
+// type-to-filter box. Long lists window around the cursor so they never blow past the screen.
+// The selected row shows the accent arrow + bold label; hints render dim and inline.
+export function Picker({ items, onSelect, ascii, plainColor, initialValue, search = false, searchLabel = 'Search', pageSize = 8, isActive = true, }) {
+    const g = glyphs(ascii);
+    const tone = tones(plainColor);
+    const [query, setQuery] = React.useState('');
+    const filtered = React.useMemo(() => {
+        if (!query.trim())
+            return items;
+        const q = query.toLowerCase();
+        return items.filter((it) => it.label.toLowerCase().includes(q) || it.value.toLowerCase().includes(q));
+    }, [items, query]);
+    const startIdx = React.useMemo(() => {
+        if (!initialValue)
+            return 0;
+        const i = items.findIndex((it) => it.value === initialValue);
+        return i >= 0 ? i : 0;
+    }, [items, initialValue]);
+    const [cursor, setCursor] = React.useState(startIdx);
+    // Clamp the cursor whenever the filtered set shrinks under it.
+    React.useEffect(() => {
+        if (cursor > filtered.length - 1)
+            setCursor(Math.max(0, filtered.length - 1));
+    }, [filtered.length, cursor]);
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setCursor((c) => (c - 1 + filtered.length) % Math.max(1, filtered.length));
+        }
+        else if (key.downArrow || input === 'j') {
+            setCursor((c) => (c + 1) % Math.max(1, filtered.length));
+        }
+        else if (key.return) {
+            const picked = filtered[cursor];
+            if (picked)
+                onSelect(picked.value);
+        }
+    }, { isActive: isActive && !search });
+    // With search on, the TextInput owns the keystrokes; Up/Down still need to move the cursor,
+    // so a second handler runs only for the arrow keys while typing is active.
+    useInput((_input, key) => {
+        if (key.upArrow)
+            setCursor((c) => (c - 1 + filtered.length) % Math.max(1, filtered.length));
+        else if (key.downArrow)
+            setCursor((c) => (c + 1) % Math.max(1, filtered.length));
+    }, { isActive: isActive && search });
+    // Window the rows so the cursor stays visible without scrolling the whole terminal.
+    const total = filtered.length;
+    const half = Math.floor(pageSize / 2);
+    let from = Math.max(0, cursor - half);
+    const to = Math.min(total, from + pageSize);
+    from = Math.max(0, to - pageSize);
+    const window = filtered.slice(from, to);
+    return (_jsxs(Box, { flexDirection: "column", children: [search ? (_jsxs(Box, { flexDirection: "row", marginBottom: 1, children: [_jsxs(Text, { color: tone.accent, children: [g.arrow, " "] }), _jsxs(Text, { color: tone.muted, children: [searchLabel, ": "] }), _jsx(TextInput, { value: query, onChange: setQuery, placeholder: "type to filter", onSubmit: () => {
+                            const picked = filtered[cursor];
+                            if (picked)
+                                onSelect(picked.value);
+                        } })] })) : null, from > 0 ? _jsx(Text, { color: tone.muted, children: `  ${g.bullet} ${from} more above` }) : null, window.map((it, i) => {
+                const idx = from + i;
+                const focused = idx === cursor;
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: focused ? tone.accent : undefined, children: focused ? g.arrow : ' ' }), _jsx(Text, { children: " " }), _jsx(Text, { bold: focused, color: focused ? tone.accent : undefined, children: it.label }), it.hint ? _jsx(Text, { color: tone.muted, children: `  ${it.hint}` }) : null] }, it.value));
+            }), to < total ? _jsx(Text, { color: tone.muted, children: `  ${g.bullet} ${total - to} more below` }) : null, total === 0 ? _jsx(Text, { color: tone.muted, children: "  no matches" }) : null] }));
+}

package/dist/tui/components/PresetStep.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { PresetCardDTO } from '../contract.js';
+interface PresetStepProps {
+    cards: PresetCardDTO[];
+    ascii: boolean;
+    plainColor: boolean;
+    busy: boolean;
+    initial?: string;
+    onSelect: (value: string) => void;
+}
+export declare function PresetStep({ cards, ascii, plainColor, busy, initial, onSelect }: PresetStepProps): React.ReactElement;
+export {};

package/dist/tui/components/PresetStep.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React from 'react';
+import { glyphs, tones } from '../theme.js';
+import { Card } from './Card.js';
+// Optimization-mode picker rendered as stacked cards (label + hint + wrapped blurb). Up/Down
+// moves focus, Enter applies. Default focus lands on the passed initial (or 'maximum').
+export function PresetStep({ cards, ascii, plainColor, busy, initial = 'maximum', onSelect }) {
+    const g = glyphs(ascii);
+    const tone = tones(plainColor);
+    const startIdx = Math.max(0, cards.findIndex((c) => c.value === initial));
+    const [cursor, setCursor] = React.useState(startIdx === -1 ? 0 : startIdx);
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k')
+            setCursor((c) => (c - 1 + cards.length) % cards.length);
+        else if (key.downArrow || input === 'j')
+            setCursor((c) => (c + 1) % cards.length);
+        else if (key.return)
+            onSelect(cards[cursor].value);
+    }, { isActive: !busy });
+    if (busy) {
+        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: tone.accent, children: _jsx(Spinner, { type: ascii ? 'line' : 'dots' }) }), _jsx(Text, { children: " Applying the optimization mode\u2026" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tone.accent, bold: true, children: "Optimization mode" }), _jsx(Text, { color: tone.muted, children: `How hard Byte optimizes every request.  ${g.divider}  ↑↓ move · enter apply` }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: cards.map((c, i) => (_jsx(Box, { marginBottom: i < cards.length - 1 ? 1 : 0, children: _jsx(Card, { label: c.label, hint: c.hint, blurb: c.blurb, focused: i === cursor, ascii: ascii, plainColor: plainColor }) }, c.value))) })] }));
+}

package/dist/tui/components/ProviderStep.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { ProviderPresetDTO, WizardPorts } from '../contract.js';
+interface ProviderStepProps {
+    presets: ProviderPresetDTO[];
+    ports: WizardPorts;
+    ascii: boolean;
+    plainColor: boolean;
+    busy: boolean;
+    error?: string;
+    onConnected: (r: {
+        status: 'connected' | 'saved' | 'failed';
+        models: any[];
+        connId?: number;
+    }) => void;
+    onSkip: () => void;
+    onBusy: (busy: boolean) => void;
+    onError: (message: string) => void;
+}
+export declare function ProviderStep({ presets, ports, ascii, plainColor, busy, error, onConnected, onSkip, onBusy, onError, }: ProviderStepProps): React.ReactElement;
+export {};

package/dist/tui/components/ProviderStep.js

@@ -0,0 +1,159 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+import Spinner from 'ink-spinner';
+import React from 'react';
+import { glyphs, tones } from '../theme.js';
+import { Picker } from './Picker.js';
+// Provider connection step. Walks: choose a provider (searchable) → optional base-URL for
+// custom/advanced presets → masked API key (live non-empty validation) → spinner while the port
+// runs → on success hand back the models; on a saved-but-no-models result, drop into a
+// retry/keep/skip recovery picker so a failed import never passes as a clean success.
+export function ProviderStep({ presets, ports, ascii, plainColor, busy, error, onConnected, onSkip, onBusy, onError, }) {
+    const g = glyphs(ascii);
+    const tone = tones(plainColor);
+    const [phase, setPhase] = React.useState('pick');
+    const [preset, setPreset] = React.useState();
+    const [baseUrl, setBaseUrl] = React.useState('');
+    const [apiKey, setApiKey] = React.useState('');
+    const [keyTouched, setKeyTouched] = React.useState(false);
+    const [recover, setRecover] = React.useState();
+    const items = React.useMemo(() => [
+        ...presets.map((p) => ({ value: p.id, label: p.label, hint: p.advanced ? 'advanced' : p.custom ? 'custom' : undefined })),
+        { value: '__skip__', label: 'Skip — connect a provider later' },
+    ], [presets]);
+    const beginConnect = React.useCallback(async (chosen, url, key) => {
+        setPhase('connecting');
+        onBusy(true);
+        try {
+            const res = await ports.connectProvider({
+                id: chosen.id,
+                label: chosen.label,
+                baseUrl: url || chosen.base_url || undefined,
+                apiKey: key,
+                mode: chosen.gateway_mode,
+            });
+            if (res.status === 'connected' && res.models.length) {
+                // Enable the first imported model right away so the gateway can route without a
+                // follow-up BYTE_ALIAS_NOT_CONFIGURED on the first run.
+                const first = res.models[0];
+                if (first?.id)
+                    await ports.enableModel(first.id).catch(() => undefined);
+                onConnected({ status: 'connected', models: res.models, connId: res.connId });
+            }
+            else if (res.status === 'failed') {
+                setRecover({ message: res.error || 'Could not save the provider connection.', connId: res.connId });
+                setPhase('recover');
+                onBusy(false);
+            }
+            else {
+                // saved (or connected w/o models): offer recovery rather than claiming success.
+                setRecover({ message: res.error || 'Saved, but its models could not be loaded.', connId: res.connId });
+                setPhase('recover');
+                onBusy(false);
+            }
+        }
+        catch (err) {
+            setRecover({ message: err?.message ?? String(err) });
+            setPhase('recover');
+            onBusy(false);
+        }
+    }, [ports, onBusy, onConnected]);
+    const onPickProvider = (value) => {
+        if (value === '__skip__') {
+            onSkip();
+            return;
+        }
+        const p = presets.find((x) => x.id === value);
+        if (!p)
+            return;
+        setPreset(p);
+        setApiKey('');
+        setKeyTouched(false);
+        setBaseUrl(p.base_url || '');
+        if (p.custom || !p.base_url)
+            setPhase('baseUrl');
+        else
+            setPhase('apiKey');
+    };
+    const retryWithKey = React.useCallback(async (connId, key) => {
+        setPhase('connecting');
+        onBusy(true);
+        try {
+            const res = await ports.rotateAndTest(connId, key);
+            if (res.models.length) {
+                const first = res.models[0];
+                if (first?.id)
+                    await ports.enableModel(first.id).catch(() => undefined);
+                onConnected({ status: 'connected', models: res.models, connId });
+            }
+            else {
+                setRecover({ message: res.error || 'Still no models returned.', connId });
+                setPhase('recover');
+                onBusy(false);
+            }
+        }
+        catch (err) {
+            setRecover({ message: err?.message ?? String(err), connId });
+            setPhase('recover');
+            onBusy(false);
+        }
+    }, [ports, onBusy, onConnected]);
+    // ---- render per phase ----
+    if (phase === 'pick') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tone.accent, bold: true, children: "Connect a provider" }), _jsx(Text, { color: tone.muted, children: "Bring your own key \u2014 Byte routes through it. Type to filter." }), _jsx(Box, { marginTop: 1, children: _jsx(Picker, { items: items, onSelect: onPickProvider, ascii: ascii, plainColor: plainColor, search: true, searchLabel: "Provider" }) }), error ? _jsx(Text, { color: tone.bad, children: `${g.bullet} ${error}` }) : null] }));
+    }
+    if (phase === 'baseUrl' && preset) {
+        const valid = baseUrl.trim().startsWith('http');
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tone.accent, bold: true, children: `${preset.label} — base URL` }), preset.note ? _jsx(Text, { color: tone.warn, children: `${g.bullet} ${preset.note}` }) : null, _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsxs(Text, { color: tone.accent, children: [g.arrow, " "] }), _jsx(TextInput, { value: baseUrl, onChange: setBaseUrl, placeholder: "https://api.example.com/v1", onSubmit: () => {
+                                if (valid)
+                                    setPhase('apiKey');
+                            } })] }), !valid ? _jsx(Text, { color: tone.muted, children: "Must be a URL (starts with http)" }) : _jsx(Text, { color: tone.muted, children: "Enter to continue" })] }));
+    }
+    if (phase === 'apiKey' && preset) {
+        const valid = apiKey.trim().length > 0;
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tone.accent, bold: true, children: `${preset.label} — API key` }), preset.note ? _jsx(Text, { color: tone.warn, children: `${g.bullet} ${preset.note}` }) : null, _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsxs(Text, { color: tone.accent, children: [g.arrow, " "] }), _jsx(TextInput, { value: apiKey, mask: "\u2022", onChange: (v) => {
+                                setApiKey(v);
+                                setKeyTouched(true);
+                            }, placeholder: "paste your key", onSubmit: () => {
+                                if (valid)
+                                    void beginConnect(preset, baseUrl, apiKey);
+                            } })] }), keyTouched && !valid ? _jsx(Text, { color: tone.bad, children: "Required" }) : _jsx(Text, { color: tone.muted, children: "Enter to connect" })] }));
+    }
+    if (phase === 'connecting' || busy) {
+        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: tone.accent, children: _jsx(Spinner, { type: ascii ? 'line' : 'dots' }) }), _jsx(Text, { children: ` Connecting ${preset?.label ?? 'provider'}…` })] }));
+    }
+    // recover: saved but no models, or a hard failure — let the user retry the key, keep it, or skip.
+    if (phase === 'recover' && recover) {
+        const canRetry = recover.connId !== undefined;
+        return (_jsx(RecoverPhase, { message: recover.message, label: preset?.label ?? 'Provider', canRetry: canRetry, ascii: ascii, plainColor: plainColor, onRetry: (key) => recover.connId !== undefined && retryWithKey(recover.connId, key), onKeep: () => onConnected({ status: 'saved', models: [], connId: recover.connId }), onSkip: onSkip }));
+    }
+    return _jsx(Text, { color: tone.muted, children: "\u2026" });
+}
+// The retry/keep/skip recovery UI, with an inline masked key re-entry when "retry" is chosen.
+function RecoverPhase({ message, label, canRetry, ascii, plainColor, onRetry, onKeep, onSkip, }) {
+    const g = glyphs(ascii);
+    const tone = tones(plainColor);
+    const [mode, setMode] = React.useState('choose');
+    const [key, setKey] = React.useState('');
+    const options = [
+        ...(canRetry ? [{ value: 'retry', label: 'Re-enter the key and retry' }] : []),
+        { value: 'keep', label: 'Keep it — I will pick a model later' },
+        { value: 'skip', label: 'Skip the provider for now' },
+    ];
+    if (mode === 'retryKey') {
+        const valid = key.trim().length > 0;
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tone.accent, bold: true, children: `${label} — API key` }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsxs(Text, { color: tone.accent, children: [g.arrow, " "] }), _jsx(TextInput, { value: key, mask: "\u2022", onChange: setKey, placeholder: "paste your key", onSubmit: () => {
+                                if (valid)
+                                    onRetry(key);
+                            } })] }), !valid ? _jsx(Text, { color: tone.bad, children: "Required" }) : _jsx(Text, { color: tone.muted, children: "Enter to retry" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: tone.warn, children: `${g.bullet} ${message}` }), _jsx(Box, { marginTop: 1, children: _jsx(Picker, { items: options, ascii: ascii, plainColor: plainColor, onSelect: (v) => {
+                        if (v === 'retry')
+                            setMode('retryKey');
+                        else if (v === 'keep')
+                            onKeep();
+                        else
+                            onSkip();
+                    } }) })] }));
+}

package/dist/tui/components/Stepper.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Step } from '../state.js';
+interface StepperProps {
+    current: Step;
+    ascii: boolean;
+    plainColor: boolean;
+}
+export declare function Stepper({ current, ascii, plainColor }: StepperProps): React.ReactElement;
+export {};

package/dist/tui/components/Stepper.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { glyphs, tones } from '../theme.js';
+// Ordered labels for the visible wizard steps. 'welcome' is the entry and 'done' the exit, so
+// the progress dots track the seven meaningful stops in between (welcome folds into the first).
+const ORDER = [
+    { step: 'welcome', label: 'Start' },
+    { step: 'signin', label: 'Sign in' },
+    { step: 'provider', label: 'Provider' },
+    { step: 'model', label: 'Model' },
+    { step: 'key', label: 'Key' },
+    { step: 'preset', label: 'Mode' },
+    { step: 'integrate', label: 'Connect' },
+    { step: 'done', label: 'Done' },
+];
+// Horizontal 8-step tracker: completed steps get a filled tone-ok glyph, the active step a
+// bright accent glyph + label, upcoming steps a muted empty glyph. Connectors are dim dividers.
+export function Stepper({ current, ascii, plainColor }) {
+    const g = glyphs(ascii);
+    const tone = tones(plainColor);
+    const activeIdx = ORDER.findIndex((o) => o.step === current);
+    return (_jsx(Box, { flexDirection: "row", alignItems: "center", children: ORDER.map((o, i) => {
+            const done = i < activeIdx;
+            const active = i === activeIdx;
+            const color = done ? tone.ok : active ? tone.accent : tone.muted;
+            const dot = done ? g.check : active ? g.filled : g.empty;
+            return (_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: color, bold: active, children: dot }), _jsx(Text, { children: " " }), _jsx(Text, { color: color, bold: active, dimColor: !active && !done, children: o.label }), i < ORDER.length - 1 ? _jsx(Text, { color: tone.muted, children: `  ${g.divider}  ` }) : null] }, o.step));
+        }) }));
+}

package/dist/tui/contract.d.ts

@@ -0,0 +1,99 @@
+export interface HomeData {
+    email?: string;
+    org?: string;
+    providers?: number;
+    models?: number;
+    byteKeyMasked?: string;
+    gateway: 'healthy' | 'down' | 'unknown';
+    savingsSeries: number[];
+    savedTotal: number;
+    tokensTotal: number;
+    hitRate?: number;
+}
+export interface HomeIslandProps {
+    signedIn: boolean;
+    data: HomeData;
+    plainColor: boolean;
+    ascii: boolean;
+    version: string;
+}
+export type HomeResult = {
+    status: 'fallback';
+} | {
+    status: 'exit';
+} | {
+    status: 'action';
+    commandId: string;
+    argv: string[];
+};
+export interface WizardPorts {
+    signIn(): Promise<{
+        email?: string;
+    }>;
+    listProviders(): Promise<any[]>;
+    connectProvider(a: {
+        id: string;
+        label: string;
+        baseUrl?: string;
+        apiKey: string;
+        mode: string;
+    }): Promise<{
+        status: 'connected' | 'saved' | 'failed';
+        models: any[];
+        connId?: number;
+        error?: string;
+    }>;
+    rotateAndTest(connId: number, apiKey: string): Promise<{
+        models: any[];
+        error?: string;
+    }>;
+    enableModel(id: number): Promise<void>;
+    createByteKey(name: string, preset: string): Promise<{
+        key: string;
+    }>;
+    applyPreset(preset: string): Promise<void>;
+}
+export interface ProviderPresetDTO {
+    id: string;
+    label: string;
+    base_url: string;
+    gateway_mode: string;
+    advanced?: boolean;
+    custom?: boolean;
+    note?: string;
+}
+export interface PresetCardDTO {
+    value: string;
+    label: string;
+    hint: string;
+    blurb: string;
+}
+export interface WizardIslandProps {
+    plainColor: boolean;
+    ascii: boolean;
+    version: string;
+    initial: {
+        signedIn: boolean;
+        email?: string;
+        byteKey?: string;
+    };
+    ports: WizardPorts;
+    providerPresets: ProviderPresetDTO[];
+    presetCards: PresetCardDTO[];
+}
+export interface WizardSummary {
+    profile?: string;
+    model?: string;
+    provider: 'connected' | 'saved' | 'skipped' | 'failed';
+    preset: string;
+    byteKeyCreated: boolean;
+    connect?: string;
+}
+export type WizardResult = {
+    status: 'fallback';
+} | {
+    status: 'cancelled';
+} | {
+    status: 'done';
+    summary: WizardSummary;
+};

package/dist/tui/contract.js

@@ -0,0 +1,5 @@
+// The ONLY types that cross the CJS↔ESM boundary. Zero react/ink imports so this file can
+// be referenced from both the CommonJS CLI and the ESM Ink island without dragging the UI
+// runtime into the control path. Keep these structural — the bridge in src/lib/tui.ts mirrors
+// them so neither side has to import the other across the build boundary.
+export {};

package/dist/tui/index.d.ts

@@ -0,0 +1,3 @@
+import type { HomeIslandProps, HomeResult, WizardIslandProps, WizardResult } from './contract.js';
+export declare function renderHome(props: HomeIslandProps): Promise<HomeResult>;
+export declare function renderWizard(props: WizardIslandProps): Promise<WizardResult>;

package/dist/tui/index.js

@@ -0,0 +1,78 @@
+import { render } from 'ink';
+import React from 'react';
+import { App } from './components/App.js';
+import { Home } from './components/Home.js';
+// ESM island entry. The CJS bridge (src/lib/tui.ts) dynamic-imports this and calls renderHome /
+// renderWizard. Each mounts an Ink root, resolves the result Promise when the component reports
+// done/exit/cancel, then ALWAYS unmounts and restores the cursor in a finally so we never leave
+// the terminal in raw mode or with a hidden cursor — even if rendering throws.
+const SHOW_CURSOR = '\x1b[?25h';
+export async function renderHome(props) {
+    let settled = false;
+    let resolve;
+    const done = new Promise((res) => {
+        resolve = (r) => {
+            if (!settled) {
+                settled = true;
+                res(r);
+            }
+        };
+    });
+    const instance = render(React.createElement(Home, {
+        signedIn: props.signedIn,
+        data: props.data,
+        ascii: props.ascii,
+        plainColor: props.plainColor,
+        version: props.version,
+        onDone: resolve,
+    }), { exitOnCtrlC: false });
+    try {
+        // If Ink exits on its own (e.g. an unexpected unmount), fall back rather than hang.
+        instance.waitUntilExit().then(() => resolve({ status: 'exit' }), () => resolve({ status: 'fallback' }));
+        return await done;
+    }
+    finally {
+        instance.unmount();
+        try {
+            process.stdout.write(SHOW_CURSOR);
+        }
+        catch {
+            /* stream may be closed */
+        }
+    }
+}
+export async function renderWizard(props) {
+    let settled = false;
+    let resolve;
+    const done = new Promise((res) => {
+        resolve = (r) => {
+            if (!settled) {
+                settled = true;
+                res(r);
+            }
+        };
+    });
+    const instance = render(React.createElement(App, {
+        plainColor: props.plainColor,
+        ascii: props.ascii,
+        version: props.version,
+        initial: props.initial,
+        ports: props.ports,
+        providerPresets: props.providerPresets,
+        presetCards: props.presetCards,
+        onDone: resolve,
+    }), { exitOnCtrlC: false });
+    try {
+        instance.waitUntilExit().then(() => resolve({ status: 'cancelled' }), () => resolve({ status: 'fallback' }));
+        return await done;
+    }
+    finally {
+        instance.unmount();
+        try {
+            process.stdout.write(SHOW_CURSOR);
+        }
+        catch {
+            /* stream may be closed */
+        }
+    }
+}

package/dist/tui/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/tui/state.d.ts

@@ -0,0 +1,77 @@
+import type { WizardSummary } from './contract.js';
+export type Step = 'welcome' | 'signin' | 'provider' | 'model' | 'key' | 'preset' | 'integrate' | 'done';
+export declare const STEPS: Step[];
+export type ProviderStatus = 'connected' | 'saved' | 'skipped' | 'failed' | 'pending';
+export interface State {
+    step: Step;
+    busy: boolean;
+    error?: {
+        from: Step;
+        message: string;
+    };
+    signedIn: boolean;
+    email?: string;
+    providerChoice?: string;
+    baseUrl?: string;
+    providerStatus: ProviderStatus;
+    connId?: number;
+    models: any[];
+    model?: string;
+    preset: string;
+    byteKey?: string;
+    byteKeyRevealed: boolean;
+    connect?: string;
+}
+export interface Initial {
+    signedIn: boolean;
+    email?: string;
+    byteKey?: string;
+}
+export declare function initialState(initial: Initial): State;
+export type Action = {
+    type: 'NEXT';
+} | {
+    type: 'BUSY';
+    busy: boolean;
+} | {
+    type: 'ERROR';
+    from: Step;
+    message: string;
+} | {
+    type: 'CLEAR_ERROR';
+} | {
+    type: 'SIGNED_IN';
+    email?: string;
+} | {
+    type: 'PICK_PROVIDER';
+    id: string;
+    baseUrl?: string;
+} | {
+    type: 'PROVIDER_RESULT';
+    status: 'connected' | 'saved' | 'failed';
+    models: any[];
+    connId?: number;
+} | {
+    type: 'PROVIDER_SKIP';
+} | {
+    type: 'PROVIDER_RETRY';
+} | {
+    type: 'PICK_MODEL';
+    model: string;
+} | {
+    type: 'KEY_CREATED';
+    key: string;
+} | {
+    type: 'REVEAL_KEY';
+} | {
+    type: 'PICK_PRESET';
+    preset: string;
+} | {
+    type: 'PICK_CONNECT';
+    connect?: string;
+} | {
+    type: 'GOTO';
+    step: Step;
+};
+export declare function reducer(state: State, action: Action): State;
+export declare function selectSummary(state: State): WizardSummary;