@sigrun/tui 0.1.1 → 0.2.1

package/dist/keymaps/types.d.ts

@@ -1,43 +0,0 @@
-/**
- * The keymap contract (Task C3, UI refresh): a keymap maps raw terminal
- * input to an {@link Action}, `"pass"` (the focused component — usually
- * the composer — gets the key), or `"consume"` (swallow silently). The
- * launcher's single input listener asks the keymap first, then dispatches
- * / consumes / passes.
- *
- * RESERVED_KEYS are the composer's line-editing chords (readline-style)
- * and the tmux prefix: a keymap must NEVER bind them — it returns "pass"
- * for every one in every focus so the editor (or tmux) always sees them.
- * Ctrl+B in particular is the user's hard rule.
- */
-import type { Action, Focus } from "../actions.js";
-/** The state a keymap decision depends on. */
-export interface KeyContext {
-    readonly focus: Focus;
-    /** A live run is in flight (Esc aborts it). */
-    readonly busy: boolean;
-    /** The composer's autocomplete dropdown is open (Esc/Tab pass to it). */
-    readonly autocompleteOpen: boolean;
-    /** A modal overlay (picker/search/answer) owns the keys. */
-    readonly overlayOpen: boolean;
-}
-/** What the launcher does with the key: run the action, swallow, or pass. */
-export type KeyResult = Action | "pass" | "consume";
-export interface Keymap {
-    readonly name: "standard" | "vim" | "emacs";
-    /** The status-bar mode chip text; undefined = no chip (standard). */
-    modeLabel(): string | undefined;
-    handle(data: string, ctx: KeyContext): KeyResult;
-    /** The one-line hint cluster for the status bar. */
-    hints(ctx: KeyContext): readonly string[];
-    /** The help listing: every binding with a human description. */
-    describe(): readonly {
-        keys: string;
-        action: string;
-    }[];
-}
-/**
- * Keys no keymap may bind: the composer's readline chords plus the tmux
- * prefix (ctrl+b). Keymaps return "pass" for all of them in every focus.
- */
-export declare const RESERVED_KEYS: readonly string[];

package/dist/keymaps/types.js

@@ -1,28 +0,0 @@
-/**
- * The keymap contract (Task C3, UI refresh): a keymap maps raw terminal
- * input to an {@link Action}, `"pass"` (the focused component — usually
- * the composer — gets the key), or `"consume"` (swallow silently). The
- * launcher's single input listener asks the keymap first, then dispatches
- * / consumes / passes.
- *
- * RESERVED_KEYS are the composer's line-editing chords (readline-style)
- * and the tmux prefix: a keymap must NEVER bind them — it returns "pass"
- * for every one in every focus so the editor (or tmux) always sees them.
- * Ctrl+B in particular is the user's hard rule.
- */
-/**
- * Keys no keymap may bind: the composer's readline chords plus the tmux
- * prefix (ctrl+b). Keymaps return "pass" for all of them in every focus.
- */
-export const RESERVED_KEYS = [
-    "ctrl+b",
-    "ctrl+a",
-    "ctrl+e",
-    "ctrl+f",
-    "ctrl+k",
-    "ctrl+u",
-    "ctrl+w",
-    "ctrl+y",
-    "ctrl+d",
-    "ctrl+j",
-];

package/dist/keymaps/vim.d.ts

@@ -1,48 +0,0 @@
-/**
- * The vim keymap (Task C4, UI refresh): real insert/normal/command modes
- * over the C3 action layer. Starts in INSERT with the composer focused —
- * every key types through except Esc (→ NORMAL, focus transcript),
- * Ctrl+C (abort a live run; otherwise consumed — quitting is ZZ or :q),
- * and Ctrl+O (answer an interaction). Every {@link RESERVED_KEYS} chord
- * passes in INSERT (the composer's readline chords and the tmux prefix
- * are never shadowed; ctrl+b is NEVER bound anywhere).
- *
- * NORMAL owns the transcript/list: j/k move, h/l focus list/transcript,
- * ctrl+d/ctrl+u half-page (bound here — RESERVED exists to protect the
- * composer's editing, and in NORMAL the composer is not focused),
- * gg/G edges, {/} prompt jumps, Enter/za fold, o open, y/yy copy,
- * f fork, e edit, v edit-in-vim, //?/n/N search, i/a back to INSERT,
- * `:` the command line, ctrl+p picker, ctrl+l redraw, ZZ quit. UNBOUND
- * PRINTABLE KEYS ARE CONSUMED — they must never leak into the composer.
- *
- * COMMAND accumulates a line after `:` (the app renders ":"+buffer in
- * the status bar via {@link VimKeymap.getCommandLine}); Enter dispatches
- * run-command, Esc cancels, Tab completes the command name.
- *
- * The two-key chords (gg, yy, za, ZZ) share one pending-key window of
- * 500 ms; a timed-out or mismatched prefix is consumed silently.
- */
-import { type Keymap } from "./types.js";
-export type VimMode = "insert" | "normal" | "command";
-/** The keymap plus the mode/command-line seam the app polls after each key. */
-export interface VimKeymap extends Keymap {
-    readonly mode: VimMode;
-    /** The ":" line while in command mode; undefined otherwise. */
-    getCommandLine(): string | undefined;
-    /**
-     * Drop to INSERT (the app calls this after an external edit-in-vim so
-     * the mode agrees with the restored composer focus).
-     */
-    enterInsertMode(): void;
-}
-/** Options for {@link createVimKeymap}. */
-export interface VimKeymapOptions {
-    /**
-     * The slash-command catalog's names (C3's picker source); they join
-     * COMMAND_NAMES in the Tab completion table as `"/"`-prefixed
-     * entries. Defaults to none (the launcher fills a shared array once
-     * the catalog fetch lands).
-     */
-    readonly catalogNames?: readonly string[];
-}
-export declare function createVimKeymap(options?: VimKeymapOptions): VimKeymap;

package/dist/keymaps/vim.js

@@ -1,291 +0,0 @@
-/**
- * The vim keymap (Task C4, UI refresh): real insert/normal/command modes
- * over the C3 action layer. Starts in INSERT with the composer focused —
- * every key types through except Esc (→ NORMAL, focus transcript),
- * Ctrl+C (abort a live run; otherwise consumed — quitting is ZZ or :q),
- * and Ctrl+O (answer an interaction). Every {@link RESERVED_KEYS} chord
- * passes in INSERT (the composer's readline chords and the tmux prefix
- * are never shadowed; ctrl+b is NEVER bound anywhere).
- *
- * NORMAL owns the transcript/list: j/k move, h/l focus list/transcript,
- * ctrl+d/ctrl+u half-page (bound here — RESERVED exists to protect the
- * composer's editing, and in NORMAL the composer is not focused),
- * gg/G edges, {/} prompt jumps, Enter/za fold, o open, y/yy copy,
- * f fork, e edit, v edit-in-vim, //?/n/N search, i/a back to INSERT,
- * `:` the command line, ctrl+p picker, ctrl+l redraw, ZZ quit. UNBOUND
- * PRINTABLE KEYS ARE CONSUMED — they must never leak into the composer.
- *
- * COMMAND accumulates a line after `:` (the app renders ":"+buffer in
- * the status bar via {@link VimKeymap.getCommandLine}); Enter dispatches
- * run-command, Esc cancels, Tab completes the command name.
- *
- * The two-key chords (gg, yy, za, ZZ) share one pending-key window of
- * 500 ms; a timed-out or mismatched prefix is consumed silently.
- */
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { RESERVED_KEYS } from "./types.js";
-/** The two-key chord window (gg, yy, za, ZZ). */
-const CHORD_MS = 500;
-/** The command-mode completion table (Tab completes the command name). */
-const COMMAND_NAMES = ["new", "fork", "model", "set", "b", "ls", "q", "quit"];
-const BINDINGS = [
-    { keys: "esc (insert)", action: "normal mode" },
-    { keys: "i / a", action: "insert mode" },
-    { keys: "j / k", action: "move down / up" },
-    { keys: "h / l", action: "focus list / transcript" },
-    { keys: "ctrl+d / ctrl+u", action: "half page down / up" },
-    { keys: "gg / G", action: "top / bottom" },
-    { keys: "{ / }", action: "previous / next prompt" },
-    { keys: "enter / za", action: "toggle fold" },
-    { keys: "o", action: "open" },
-    { keys: "y / yy", action: "copy turn" },
-    { keys: "f", action: "fork here" },
-    { keys: "e", action: "edit here" },
-    { keys: "v", action: "edit in vim" },
-    { keys: "/ / ?", action: "search forward / backward" },
-    { keys: "n / N", action: "next / previous match" },
-    { keys: ":", action: "command line" },
-    { keys: "ctrl+p", action: "conversation picker" },
-    { keys: "ctrl+o", action: "answer interaction" },
-    { keys: "ctrl+l", action: "redraw" },
-    { keys: "ctrl+c", action: "abort run (busy)" },
-    { keys: "g?", action: "key reference" },
-    { keys: "ZZ / :q", action: "quit" },
-    { keys: "m", action: "pick up (block surface)" },
-    { keys: "enter", action: "drop (block surface)" },
-    { keys: "esc", action: "cancel move (block surface)" },
-    { keys: "space", action: "select (block surface)" },
-    { keys: ".", action: "action menu (block surface)" },
-    { keys: "x", action: "check (block surface)" },
-    { keys: "[ / ]", action: "previous / next range (calendar)" },
-    { keys: "t", action: "today (calendar)" },
-];
-function isReserved(data) {
-    return RESERVED_KEYS.some((id) => matchesKey(data, id));
-}
-/** A printable single character (space through ~, plus unicode text). */
-function isPrintable(data) {
-    return data.length === 1 && data >= " ";
-}
-export function createVimKeymap(options) {
-    const catalogNames = options?.catalogNames ?? [];
-    /** Tab completion table: the vim-native commands plus `/`-catalog names. */
-    const completionNames = () => [
-        ...COMMAND_NAMES,
-        ...catalogNames.map((name) => `/${name}`),
-    ];
-    let mode = "insert";
-    let commandLine = "";
-    /** The pending chord prefix ("g" | "y" | "z" | "Z") and its timestamp. */
-    let pending;
-    /**
-     * Resolve the pending two-key chord (gg → top, ZZ → quit, za → fold)
-     * against `data`. Returns the chord's action, "consume" when `data`
-     * STARTS a chord, or undefined to process `data` fresh (a mismatched
-     * or timed-out follow-up).
-     */
-    const chord = (data) => {
-        const now = Date.now();
-        if (pending !== undefined) {
-            const prefix = pending;
-            pending = undefined;
-            if (now - prefix.at <= CHORD_MS) {
-                if (prefix.key === "g" && data === "g")
-                    return { type: "edge", to: "top" };
-                // g? is vim normal's help key — "?" stays search-backward.
-                if (prefix.key === "g" && data === "?")
-                    return { type: "help" };
-                if (prefix.key === "Z" && data === "Z")
-                    return { type: "quit" };
-                if (prefix.key === "z" && data === "a")
-                    return { type: "toggle-fold" };
-            }
-            // Mismatch/timeout: `data` is processed fresh below.
-        }
-        if (data === "g" || data === "Z" || data === "z") {
-            pending = { key: data, at: now };
-            return "consume";
-        }
-        return undefined;
-    };
-    const insert = (data, ctx) => {
-        // The composer's readline chords + the tmux prefix: NEVER bound.
-        if (isReserved(data))
-            return "pass";
-        if (matchesKey(data, Key.escape)) {
-            if (ctx.autocompleteOpen)
-                return "pass";
-            mode = "normal";
-            return { type: "focus", target: "transcript" };
-        }
-        if (matchesKey(data, Key.ctrl("c"))) {
-            return ctx.busy ? { type: "cancel-run" } : "consume";
-        }
-        if (matchesKey(data, Key.ctrl("o")))
-            return { type: "answer-interaction" };
-        return "pass";
-    };
-    /** Block-surface keys (spec §12.4): NORMAL mode over a `surface`
-     *  focus. The surface wins over transcript/list bindings for the
-     *  shared keys (o/x/etc). */
-    const surfaceNormal = (data) => {
-        if (data === "m")
-            return { type: "blocks.pickUp" };
-        if (matchesKey(data, Key.enter))
-            return { type: "blocks.drop" };
-        if (matchesKey(data, Key.escape))
-            return { type: "blocks.cancelMove" };
-        if (data === " ")
-            return { type: "blocks.select" };
-        if (data === ".")
-            return { type: "blocks.actionMenu" };
-        if (data === "x")
-            return { type: "blocks.check" };
-        if (data === "[")
-            return { type: "blocks.rangePrev" };
-        if (data === "]")
-            return { type: "blocks.rangeNext" };
-        if (data === "t")
-            return { type: "blocks.today" };
-        return undefined;
-    };
-    const normal = (data, ctx) => {
-        // ctrl+b / ctrl+f are NOT bound in vim normal — reserved chords pass.
-        const chorded = chord(data);
-        if (chorded !== undefined)
-            return chorded;
-        if (ctx.focus === "surface") {
-            const surfaceResult = surfaceNormal(data);
-            if (surfaceResult !== undefined)
-                return surfaceResult;
-        }
-        if (data === "y")
-            return { type: "copy" }; // yy is two copies — same action
-        if (data === "j")
-            return { type: "move", delta: 1 };
-        if (data === "k")
-            return { type: "move", delta: -1 };
-        if (data === "h")
-            return { type: "focus", target: "list" };
-        if (data === "l")
-            return { type: "focus", target: "transcript" };
-        if (matchesKey(data, Key.ctrl("d")))
-            return { type: "page", direction: 1, half: true };
-        if (matchesKey(data, Key.ctrl("u")))
-            return { type: "page", direction: -1, half: true };
-        if (data === "G")
-            return { type: "edge", to: "bottom" };
-        if (data === "{")
-            return { type: "prompt-jump", delta: -1 };
-        if (data === "}")
-            return { type: "prompt-jump", delta: 1 };
-        if (matchesKey(data, Key.enter))
-            return { type: "toggle-fold" };
-        if (data === "o")
-            return { type: "open" };
-        if (data === "f")
-            return { type: "fork-here" };
-        if (data === "e")
-            return { type: "edit-here" };
-        if (data === "v")
-            return { type: "edit-in-vim" };
-        if (data === "/")
-            return { type: "search", direction: "forward" };
-        if (data === "?")
-            return { type: "search", direction: "backward" };
-        if (data === "n")
-            return { type: "search-next", reverse: false };
-        if (data === "N")
-            return { type: "search-next", reverse: true };
-        if (data === "i" || data === "a") {
-            mode = "insert";
-            return { type: "focus", target: "composer" };
-        }
-        if (data === ":") {
-            mode = "command";
-            commandLine = "";
-            return "consume";
-        }
-        if (matchesKey(data, Key.ctrl("p")))
-            return { type: "picker", kind: "conversation" };
-        if (matchesKey(data, Key.ctrl("l")))
-            return { type: "redraw" };
-        if (matchesKey(data, Key.ctrl("c"))) {
-            return ctx.busy ? { type: "cancel-run" } : "consume";
-        }
-        // Reserved chords the composer owns pass even here (they are no-ops
-        // in a non-composer focus, but the invariant is one rule).
-        if (isReserved(data))
-            return "pass";
-        // UNBOUND PRINTABLE KEYS ARE CONSUMED: never typed into the composer.
-        if (isPrintable(data))
-            return "consume";
-        return "consume";
-    };
-    const command = (data) => {
-        if (matchesKey(data, Key.escape)) {
-            mode = "normal";
-            commandLine = "";
-            return "consume";
-        }
-        if (matchesKey(data, Key.enter) || data === "\r") {
-            const line = commandLine;
-            mode = "normal";
-            commandLine = "";
-            if (line.trim() === "")
-                return "consume";
-            return { type: "run-command", line };
-        }
-        if (matchesKey(data, Key.backspace) || data === "\x7f" || data === "\b") {
-            commandLine = commandLine.slice(0, -1);
-            return "consume";
-        }
-        if (matchesKey(data, Key.tab) || data === "\t") {
-            const match = completionNames().find((name) => name.startsWith(commandLine) && name !== commandLine);
-            if (match !== undefined)
-                commandLine = match;
-            return "consume";
-        }
-        if (isPrintable(data)) {
-            commandLine += data;
-            return "consume";
-        }
-        return "consume";
-    };
-    return {
-        name: "vim",
-        get mode() {
-            return mode;
-        },
-        getCommandLine: () => (mode === "command" ? `:${commandLine}` : undefined),
-        enterInsertMode: () => {
-            mode = "insert";
-        },
-        modeLabel: () => {
-            if (mode === "insert")
-                return "-- INSERT --";
-            if (mode === "normal")
-                return "-- NORMAL --";
-            return undefined; // the status bar shows the ":" line instead
-        },
-        handle(data, ctx) {
-            // A modal overlay owns the keys; only its cancel key is held back.
-            if (ctx.overlayOpen) {
-                return matchesKey(data, Key.escape) ? "consume" : "pass";
-            }
-            if (mode === "insert")
-                return insert(data, ctx);
-            if (mode === "normal")
-                return normal(data, ctx);
-            return command(data);
-        },
-        hints(ctx) {
-            if (mode === "command")
-                return ["enter run", "esc cancel", "tab complete"];
-            if (mode === "insert" || ctx.focus === "composer")
-                return ["Esc normal"];
-            return ["i insert", ": command", "g? keys"];
-        },
-        describe: () => BINDINGS,
-    };
-}

package/dist/launch.d.ts

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-/**
- * The TUI entry the CLI's default `launchTui` runs (Task 6): boot the
- * pi-tui fullscreen alt-screen renderer (task C1b — the terminal scrollback
- * is gone for the session; the app owns the viewport), mount the layout
- * root, and resolve when the user exits (ctrl+c). The CLI's `run`
- * lifecycle owns the shutdown from there — this promise resolving IS the
- * exit signal. There is no main-screen fallback.
- *
- * As of build-and-webui Task 2 this file is ALSO the package's bin
- * (`sigrun-tui` → `dist/launch.js`): the CLI no longer imports
- * `launchTuiShell` in-process — it spawns this bin as a child process
- * (`node <resolved dist/launch.js>`), passing the resolved server URL,
- * user, and tui.json UI fields as `--flags`. Run standalone, the bin
- * resolves them itself: `--server`/`SIGRUN_SERVER` (default
- * `http://localhost:$SIGRUN_PORT` or 3000) and `--user`/`SIGRUN_USER`.
- *
- * Layout (task C1b): `tui.setLayoutRoot(new VStack([...]))` — the body row
- * (`HStack`: the sidebar at basis 28, visible only at width ≥ 80, and the
- * pane wrapped in the follow-end PRIMARY ScrollView growing to fill), then
- * the interaction + ambient seam strips (basis "auto" — zero height when
- * empty), the composer Editor (basis "auto"), and the status bar pinned to
- * one line at the bottom (basis 1).
- *
- * Keybindings: BEFORE the screen is constructed, the alt-screen built-ins
- * the action layer will own are disabled (search, search next/previous,
- * previous/next prompt — the built-ins search raw lines and jump OSC 133
- * marks sigrun never emits); pageUp/pageDown/ctrl+home/ctrl+end scrolling
- * and the wheel stay. The shell's global input listener keeps ctrl+c
- * (exit), ctrl+o (answer mode), and Esc (abort a live run); task C3's
- * action layer reintroduces navigation — until then the composer is the
- * focus and the mouse drives the sidebar.
- *
- * Test seams (the shell itself needs a real terminal): `screen` injects
- * the screen constructor (tests assert TuiAltScreen's arguments), and
- * `terminal`/`fetchFn` inject the terminal and boot fetch. Production
- * callers pass none of them.
- */
-import { type Component, type Terminal, type TuiAltScreenOptions } from "@earendil-works/pi-tui";
-import { type AccentName, type ModeName, type PaletteName } from "@sigrun/shared/themes";
-import { type FetchLike } from "./api.js";
-/** The input-listener signature pi-tui's TUI uses. */
-export type TuiInputListenerFn = (data: string) => {
-    consume: boolean;
-} | undefined;
-/** The screen surface the launcher drives (a TuiAltScreen satisfies it). */
-export interface TuiScreen extends Component {
-    setLayoutRoot(component: Component | undefined): void;
-    setFocus(component: Component | null): void;
-    start(): void;
-    stop(options?: {
-        preserveScreen?: boolean;
-    }): void;
-    requestRender(force?: boolean): void;
-    addInputListener(listener: TuiInputListenerFn): () => void;
-}
-/**
- * The screen-constructor seam (task C1b): matches TuiAltScreen's
- * constructor signature so tests can record the arguments without a real
- * terminal. Production uses `TuiAltScreen` itself.
- */
-export type TuiScreenFactory = (terminal: Terminal, showHardwareCursor?: boolean, logDirectory?: string, options?: TuiAltScreenOptions) => TuiScreen;
-export interface LaunchTuiShellOptions {
-    /** The server's base URL (`SigrunClient`'s `baseUrl`). */
-    readonly baseUrl: string;
-    /** The `X-Sigrun-User` identity; absent = the server's naive mode. */
-    readonly user?: string;
-    /**
-     * The bearer token (Task 7): `authorization: Bearer` on every client
-     * request and the stream connect. The launcher sources it from env
-     * `SIGRUN_TOKEN` — a credential never rides argv.
-     */
-    readonly token?: string;
-    /** The UI refresh's tui.json fields (C1a threads them in from the CLI). */
-    readonly palette?: PaletteName;
-    readonly accent?: AccentName;
-    readonly mode?: ModeName;
-    /** The keymap (C3); defaults to the standard one. */
-    readonly keymap?: "standard" | "vim" | "emacs";
-    /** The tui.json `editor` field (C1); a vim-family value feeds edit-in-vim. */
-    readonly editor?: string;
-    /** TEST SEAM: the screen constructor (defaults to TuiAltScreen). */
-    readonly screen?: TuiScreenFactory;
-    /** TEST SEAM: the terminal (defaults to ProcessTerminal). */
-    readonly terminal?: Terminal;
-    /** TEST SEAM: the boot fetch (defaults to the ambient fetch). */
-    readonly fetchFn?: FetchLike;
-}
-/**
- * The stream-health transition notices (fix wave F5): state-deduped, so a
- * reconnect storm shows ONE "disconnected" and ONE "reconnected", never a
- * pane full of retries. Exported for the unit test (the shell itself needs
- * a real terminal).
- */
-export declare function createStreamHealthNotices(notify: (message: string) => void): {
-    onError(): void;
-    onOpen(): void;
-};
-/**
- * Run the shell against `baseUrl` until the user exits. Boot failures
- * (the initial refresh rejecting) propagate — the CLI prints and exits 1.
- */
-export declare function launchTuiShell(options: LaunchTuiShellOptions): Promise<void>;
-/**
- * The flags {@link tuiMain} accepts. The CLI passes the fields it
- * resolved (tui.json + its own flags) through these; a standalone
- * invocation may pass any subset.
- */
-export interface TuiLaunchArgs {
-    readonly server?: string;
-    readonly user?: string;
-    readonly palette?: PaletteName;
-    readonly accent?: AccentName;
-    readonly mode?: ModeName;
-    readonly keymap?: "standard" | "vim" | "emacs";
-    readonly editor?: string;
-}
-/**
- * Parse the bin's argv (post-`node` slices): every entry must be a known
- * flag followed by a value. A validator returning `undefined` means the
- * VALUE was malformed for that flag (not a parse-usage error) — it is
- * reported naming the flag's expected form.
- */
-export declare function parseTuiLaunchArgs(argv: readonly string[]): TuiLaunchArgs;
-/**
- * Resolve the bin's launch options from its parsed flags + environment
- * (Task 7): server (`--server` > `SIGRUN_SERVER` > the localhost default),
- * user (`--user` > `SIGRUN_USER`), token (`SIGRUN_TOKEN` ONLY — there is
- * deliberately no `--token` flag; a credential never rides argv), and
- * the tui.json UI fields the CLI threads through as flags.
- */
-export declare function launchOptionsFrom(args: TuiLaunchArgs, env: NodeJS.ProcessEnv): LaunchTuiShellOptions;
-/**
- * The dedicated startup-failure message for a server still in its
- * unclaimed state (Task 7): a standalone `sigrun-tui` that hits the
- * setup gate exits with the `sigrun attach` onboarding hint instead of
- * a bare 403. Any other failure maps to `undefined` (the generic path).
- */
-export declare function tuiStartupMessage(error: unknown): string | undefined;
-/**
- * The bin's `main`: resolve the launch options (flags + env, see
- * {@link launchOptionsFrom}) and run {@link launchTuiShell}. Returns the
- * process exit code (0 clean; 1 on a usage error or a boot failure,
- * with the message printed — the setup-gate failure carries its own
- * `sigrun attach` onboarding hint).
- */
-export declare function tuiMain(argv?: readonly string[], env?: NodeJS.ProcessEnv, io?: {
-    error(text: string): void;
-}): Promise<number>;