@xingular/harness 2.0.0 → 2.0.1-unstable

package/dist/sdk/terminal/tui/modelPicker.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The `/model` picker: every model the account can use, searched in the standard place, with the
+ * current model marked, the default noted, and Tab to move between all models and the scoped set.
+ * Enter uses a model for this session; Ctrl+S also saves it as the default.
+ */
+import type { AgentSession, Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, type Focusable, type TUI } from '@earendil-works/pi-tui';
+type PiModel = NonNullable<AgentSession['model']>;
+type ModelCatalog = Pick<AgentSession['modelRuntime'], 'getAvailableSnapshot' | 'getModel' | 'getError' | 'refresh'>;
+export interface ModelPickerOptions {
+    theme: () => Theme;
+    tui: TUI;
+    runtime: ModelCatalog;
+    current: PiModel | undefined;
+    /** The models Ctrl+P cycles through, when any are chosen. */
+    scoped: ReadonlyArray<{
+        model: PiModel;
+    }>;
+    defaultModel?: {
+        provider: string;
+        id: string;
+    };
+    initialSearch?: string;
+    select(model: PiModel, persist: boolean): void;
+    cancel(): void;
+    changed(): void;
+}
+export declare class ModelPicker implements Component, Focusable {
+    private readonly options;
+    private scope;
+    private all;
+    private scoped;
+    private status;
+    private error;
+    private closed;
+    private readonly abort;
+    private readonly timer;
+    private readonly list;
+    constructor(options: ModelPickerOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    private isCurrent;
+    private isDefault;
+    private load;
+    /** The current model first, the default second, then by provider. */
+    private fill;
+    private refresh;
+    private finish;
+    private cancel;
+    dispose(): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
+export {};

package/dist/sdk/terminal/tui/modelPicker.js

@@ -0,0 +1,150 @@
+import { matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
+import { centerDialogChromeRows, centerDialogContentWidth, centerDialogFrame, contentWidth, pageFrame, safeText, tabStrip } from "./chrome.js";
+import { centeredDialogHost, dialogFits, pageRows } from "./dialogGeometry.js";
+import { FilterList } from "./list.js";
+const REFRESH_TIMEOUT_MS = 15_000;
+const SCOPES = [{ id: 'all', title: 'All models' }, { id: 'scoped', title: 'Scoped models' }];
+const keyOf = (model) => `${model.provider}\u0000${model.id}`;
+export class ModelPicker {
+    options;
+    scope;
+    all = [];
+    scoped;
+    status = 'Refreshing model catalogs…';
+    error;
+    closed = false;
+    abort = new AbortController();
+    timer;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.scoped = options.scoped.map(item => options.runtime.getModel(item.model.provider, item.model.id) ?? item.model);
+        this.scope = this.scoped.length ? 'scoped' : 'all';
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['model', 'models'], empty: 'No models are available for this account.',
+            searchContext: () => this.scope === 'all' ? 'all models' : 'scoped models',
+            onActivate: row => { if (row.data)
+                this.finish(row.data, false); },
+            onCancel: () => this.cancel()
+        });
+        this.load();
+        if (options.initialSearch)
+            this.list.setQuery(options.initialSearch);
+        this.timer = setTimeout(() => this.abort.abort(), REFRESH_TIMEOUT_MS);
+        void this.refresh();
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    isCurrent(model) { return this.options.current ? keyOf(this.options.current) === keyOf(model) : false; }
+    isDefault(model) { return this.options.defaultModel ? keyOf(this.options.defaultModel) === keyOf(model) : false; }
+    load() {
+        this.all = [...this.options.runtime.getAvailableSnapshot()];
+        this.fill();
+    }
+    /** The current model first, the default second, then by provider. */
+    fill() {
+        const source = this.scope === 'scoped' ? this.scoped : this.all;
+        const ordered = [...source].sort((left, right) => Number(this.isCurrent(right)) - Number(this.isCurrent(left)) || Number(this.isDefault(right)) - Number(this.isDefault(left)) || left.provider.localeCompare(right.provider));
+        const rows = ordered.map(model => ({
+            id: keyOf(model), data: model,
+            label: `${this.isCurrent(model) ? '✓' : ' '} ${safeText(model.id)}`,
+            detail: `${safeText(model.provider)}${this.isDefault(model) ? ' · default' : ''}`,
+            tone: 'muted',
+            searchText: `${model.provider} ${model.provider}/${model.id} ${model.id} ${model.name ?? ''}${this.isDefault(model) ? ' default' : ''}`
+        }));
+        this.list.setRows(rows);
+        const current = ordered.find(model => this.isCurrent(model));
+        if (current)
+            this.list.select(keyOf(current));
+    }
+    async refresh() {
+        try {
+            const result = await this.options.runtime.refresh({ allowNetwork: true, signal: this.abort.signal });
+            if (this.closed)
+                return;
+            this.status = '';
+            if (result.aborted)
+                this.error = 'Model refresh timed out; showing cached models.';
+            else if (result.errors.size)
+                this.error = `Could not refresh ${[...result.errors.keys()].join(', ')}; showing cached models.`;
+            else
+                this.error = this.options.runtime.getError();
+            this.load();
+        }
+        catch (error) {
+            if (this.closed)
+                return;
+            this.status = '';
+            this.error = `Could not refresh model catalogs: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        finally {
+            clearTimeout(this.timer);
+            if (!this.closed)
+                this.options.changed();
+        }
+    }
+    finish(model, persist) {
+        this.dispose();
+        this.options.select(model, persist);
+    }
+    cancel() {
+        this.dispose();
+        this.options.cancel();
+    }
+    dispose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        clearTimeout(this.timer);
+        this.abort.abort();
+    }
+    invalidate() { this.list.invalidate(); }
+    handleInput(data) {
+        if (matchesKey(data, 'ctrl+c')) {
+            this.cancel();
+            return;
+        }
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const scopeForward = matchesKey(data, 'tab') || (centered && matchesKey(data, 'right'));
+        const scopeBackward = matchesKey(data, 'shift+tab') || (centered && matchesKey(data, 'left'));
+        if (scopeForward || scopeBackward) {
+            if (this.scoped.length && !this.list.query) {
+                this.scope = this.scope === 'all' ? 'scoped' : 'all';
+                this.fill();
+            }
+            return;
+        }
+        if (matchesKey(data, 'ctrl+s')) {
+            const model = this.list.selected?.data;
+            if (model)
+                this.finish(model, true);
+            return;
+        }
+        const before = this.list.query;
+        this.list.handleInput(data);
+        if (this.list.query !== before)
+            this.options.changed();
+    }
+    render(width) {
+        const rows = pageRows(this.options.tui);
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const inner = centered ? centerDialogContentWidth(width) : contentWidth(width);
+        const notes = [
+            this.status ? theme.fg('muted', this.status) : '',
+            this.error ? theme.fg('error', this.error) : ''
+        ].filter(Boolean);
+        const chromeRows = centered ? centerDialogChromeRows(rows) : 4;
+        const lines = this.list.render(inner, Math.max(2, rows - chromeRows - 1 - (notes.length ? notes.length + 1 : 0)));
+        if (this.scoped.length)
+            lines.splice(this.list.pinnedRows, 0, tabStrip(SCOPES, this.scope, inner, theme, 'sub'));
+        if (notes.length)
+            lines.push('', ...notes);
+        const hint = `Enter use · Ctrl+S set as default${this.scoped.length ? ' · Tab scope' : ''} · Esc cancel`;
+        if (centered)
+            return centerDialogFrame({ title: 'Model', body: lines.map(line => truncateToWidth(line, inner, '')), width, rows, theme });
+        return pageFrame({ title: 'Model', meta: this.status || undefined, body: lines.map(line => truncateToWidth(line, inner, '')), footer: hint, width, rows, theme });
+    }
+}

package/dist/sdk/terminal/tui/mouse.d.ts

@@ -0,0 +1,3 @@
+import type { TuiMouseEvent } from '@earendil-works/pi-tui';
+export type TerminalMouseInput = TuiMouseEvent;
+export declare function isPrimaryClick(event: TerminalMouseInput): boolean;

package/dist/sdk/terminal/tui/mouse.js

@@ -0,0 +1,3 @@
+export function isPrimaryClick(event) {
+    return event.type === 'click' && event.button === 'left';
+}

package/dist/sdk/terminal/tui/mouseReport.d.ts

@@ -0,0 +1,30 @@
+import { Input } from '@earendil-works/pi-tui';
+/** A leaked report is echoed within one read; ten characters in this window is 50 characters a second. */
+export declare const MOUSE_REPORT_TAIL_WINDOW_MS = 200;
+export interface MouseReportMatch {
+    /** The whole report the keys spelled, without its `ESC[` prefix. */
+    report: string;
+    /** What a text field already held before the completing sequence. */
+    inserted: string;
+}
+/**
+ * Follows the printable characters of one report. A caller that receives the completing sequence
+ * before insertion removes `inserted`; a caller that receives it after insertion removes `report`.
+ */
+export declare class MouseReportTail {
+    private text;
+    private startedAt;
+    push(sequence: string, nowMs?: number): MouseReportMatch | undefined;
+    reset(): void;
+}
+/** A single-line input that drops a leaked mouse report instead of keeping it as text. */
+export declare class MouseSafeInput extends Input {
+    private readonly mouseTail;
+    handleInput(data: string): void;
+    setValue(value: string): void;
+}
+/**
+ * Removes reports from text that is about to be printed. A bare `<\d;\d;\d>M` stays: once recorded it
+ * is content, and rewriting it would misreport what a run received.
+ */
+export declare function stripMouseReports(text: string): string;

package/dist/sdk/terminal/tui/mouseReport.js

@@ -0,0 +1,80 @@
+// A mouse report that the input parser split across its timeout loses its `ESC[` prefix: the orphaned
+// prefix is flushed as an unknown response and the rest is decoded as keystrokes. These helpers keep
+// that tail out of text fields, without touching what a person types or pastes.
+import { Input } from '@earendil-works/pi-tui';
+/** A leaked report is echoed within one read; ten characters in this window is 50 characters a second. */
+export const MOUSE_REPORT_TAIL_WINDOW_MS = 200;
+const REPORT = /^<\d{1,3};\d{1,4};\d{1,4}[Mm]$/;
+const PARTIAL = /^<\d{0,3}(;\d{0,4}){0,2}$/;
+const WHOLE = /^(?:\x1b\[)?<\d{1,3};\d{1,4};\d{1,4}[Mm]$/;
+const SGR_REPORT = /\x1b\[<\d+;\d+;\d+[Mm]|\\u001b\[<\d+;\d+;\d+[Mm]|\\x1b\[<\d+;\d+;\d+[Mm]/g;
+const X10_REPORT = /\x1b\[M[\u0020-\u00ff]{3}/g;
+/**
+ * Follows the printable characters of one report. A caller that receives the completing sequence
+ * before insertion removes `inserted`; a caller that receives it after insertion removes `report`.
+ */
+export class MouseReportTail {
+    text = '';
+    startedAt = 0;
+    push(sequence, nowMs = Date.now()) {
+        if (WHOLE.test(sequence)) {
+            this.reset();
+            return { report: sequence.replace(/^\x1b\[/, ''), inserted: '' };
+        }
+        if (sequence.length !== 1) {
+            this.reset();
+            return undefined;
+        }
+        if (sequence === '<') {
+            this.text = '<';
+            this.startedAt = nowMs;
+            return undefined;
+        }
+        if (!this.text)
+            return undefined;
+        if (nowMs - this.startedAt > MOUSE_REPORT_TAIL_WINDOW_MS) {
+            this.reset();
+            return undefined;
+        }
+        const next = this.text + sequence;
+        if (REPORT.test(next)) {
+            const inserted = this.text;
+            this.reset();
+            return { report: next, inserted };
+        }
+        if (!PARTIAL.test(next)) {
+            this.reset();
+            return undefined;
+        }
+        this.text = next;
+        return undefined;
+    }
+    reset() {
+        this.text = '';
+        this.startedAt = 0;
+    }
+}
+/** A single-line input that drops a leaked mouse report instead of keeping it as text. */
+export class MouseSafeInput extends Input {
+    mouseTail = new MouseReportTail();
+    handleInput(data) {
+        super.handleInput(data);
+        const match = this.mouseTail.push(data);
+        if (!match)
+            return;
+        const value = this.getValue();
+        if (value.endsWith(match.report))
+            this.setValue(value.slice(0, -match.report.length));
+    }
+    setValue(value) {
+        this.mouseTail.reset();
+        super.setValue(value);
+    }
+}
+/**
+ * Removes reports from text that is about to be printed. A bare `<\d;\d;\d>M` stays: once recorded it
+ * is content, and rewriting it would misreport what a run received.
+ */
+export function stripMouseReports(text) {
+    return text.replace(SGR_REPORT, '').replace(X10_REPORT, '');
+}

package/dist/sdk/terminal/tui/page.d.ts

@@ -0,0 +1,17 @@
+import type { TuiMouseEventResult } from '@earendil-works/pi-tui';
+import type { TabInfo } from "./chrome.js";
+import type { TerminalMouseInput } from "./mouse.js";
+export interface TerminalPage {
+    presentation?: 'centered' | 'fullscreen';
+    ownsNavigation?: boolean;
+    selectTab?(id: string): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    render(width: number, rows: number): string[];
+    handleInput(data: string): boolean;
+    handleMouse?(event: TerminalMouseInput): TuiMouseEventResult | undefined;
+    hint(): string;
+    focused?: boolean;
+    activate?(): void;
+    dispose?(): void;
+}

package/dist/sdk/terminal/tui/page.js

@@ -0,0 +1 @@
+export {};

package/dist/sdk/terminal/tui/pageOverlay.d.ts

@@ -0,0 +1,30 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, type Focusable, type TUI, type TuiMouseEventResult } from '@earendil-works/pi-tui';
+import type { TerminalMouseInput } from "./mouse.js";
+import type { TerminalPage } from "./page.js";
+export interface PageOverlayOptions {
+    page: TerminalPage;
+    tui: TUI;
+    theme: () => Theme;
+    close(): void;
+    changed(): void;
+}
+export declare class PageOverlay implements Component, Focusable {
+    readonly options: PageOverlayOptions;
+    private focusedValue;
+    private disposed;
+    private pointerLayout?;
+    private hoveredTab?;
+    private activated;
+    constructor(options: PageOverlayOptions);
+    /** The host shows this overlay now: the page starts. */
+    mounted(): void;
+    get page(): TerminalPage;
+    get focused(): boolean;
+    set focused(value: boolean);
+    invalidate(): void;
+    handleMouse(event: TerminalMouseInput): TuiMouseEventResult | undefined;
+    handleInput(data: string): void;
+    render(width: number): string[];
+    dispose(): void;
+}

package/dist/sdk/terminal/tui/pageOverlay.js

@@ -0,0 +1,183 @@
+import { matchesKey, visibleWidth } from '@earendil-works/pi-tui';
+import { CENTER_DIALOG_PAD, CHROME_PAD, centerDialogBodyRows, centerDialogContentWidth, centerDialogFrame, centerDialogVerticalPad, contentWidth, pageBodyRows, pageFrame, tabIndexAt, tabStrip } from "./chrome.js";
+import { centeredDialogHost, dialogFits, pageRows } from "./dialogGeometry.js";
+export class PageOverlay {
+    options;
+    focusedValue = false;
+    disposed = false;
+    pointerLayout;
+    hoveredTab;
+    activated = false;
+    constructor(options) {
+        this.options = options;
+        // A page may open a dialog as it starts. It starts once its own overlay is showing, so the dialog
+        // lands above it; a host that never reports mounting still starts it on the next turn.
+        const fallback = setTimeout(() => this.mounted(), 0);
+        fallback.unref?.();
+    }
+    /** The host shows this overlay now: the page starts. */
+    mounted() {
+        if (this.activated || this.disposed)
+            return;
+        this.activated = true;
+        this.options.page.activate?.();
+    }
+    get page() { return this.options.page; }
+    get focused() { return this.focusedValue; }
+    set focused(value) {
+        this.focusedValue = value;
+        if (this.options.page.focused !== undefined)
+            this.options.page.focused = value;
+    }
+    invalidate() { }
+    handleMouse(event) {
+        if (this.disposed)
+            return undefined;
+        if (event.type === 'wheel') {
+            const layout = this.pointerLayout;
+            if (layout && event.y >= layout.bodyStart) {
+                const handled = this.page.handleMouse?.({ ...event, x: event.x - layout.contentX, y: event.y - layout.bodyStart });
+                if (handled?.handled)
+                    return handled;
+            }
+            const key = event.wheelDelta !== undefined && event.wheelDelta < 0 ? '\x1b[5~' : '\x1b[6~';
+            this.handleInput(key);
+            return { handled: true, render: true };
+        }
+        if (event.type !== 'move' && event.type !== 'click')
+            return undefined;
+        if (event.type === 'click' && event.button !== 'left')
+            return undefined;
+        const layout = this.pointerLayout;
+        if (!layout)
+            return undefined;
+        const tabs = this.options.page.tabs();
+        const tabX = event.x - layout.contentX;
+        if (layout.tabRow !== undefined && event.y === layout.tabRow && tabs.length > 1) {
+            const tabIndex = tabIndexAt(tabs, layout.contentWidth, tabX);
+            const current = tabs.findIndex(tab => tab.id === this.options.page.activeTab());
+            if (event.type === 'move') {
+                const nextHover = tabIndex === undefined ? undefined : tabs[tabIndex]?.id;
+                if (nextHover === this.hoveredTab)
+                    return { handled: true, render: false };
+                this.hoveredTab = nextHover;
+                return { handled: true, render: true };
+            }
+            const target = tabIndex ?? (tabX < layout.contentWidth / 2
+                ? (current - 1 + tabs.length) % tabs.length
+                : (current + 1) % tabs.length);
+            if (this.page.selectTab) {
+                this.page.selectTab(tabs[target].id);
+                this.hoveredTab = undefined;
+                return { handled: true, render: true };
+            }
+            const delta = (target - Math.max(0, current) + tabs.length) % tabs.length;
+            const reverse = (Math.max(0, current) - target + tabs.length) % tabs.length;
+            const direction = delta <= reverse ? '\t' : '\x1b[Z';
+            const steps = Math.min(delta, reverse);
+            for (let index = 0; index < steps; index += 1)
+                this.options.page.handleInput(direction);
+            this.hoveredTab = undefined;
+            return { handled: true, render: true };
+        }
+        let hoverChanged = false;
+        if (event.type === 'move' && this.hoveredTab) {
+            this.hoveredTab = undefined;
+            hoverChanged = true;
+        }
+        if (event.y < layout.bodyStart)
+            return hoverChanged ? { handled: true, render: true } : undefined;
+        const handled = this.options.page.handleMouse?.({ ...event, x: tabX, y: event.y - layout.bodyStart });
+        return handled ?? (hoverChanged ? { handled: true, render: true } : undefined);
+    }
+    handleInput(data) {
+        if (this.disposed)
+            return;
+        if (matchesKey(data, 'ctrl+c')) {
+            this.options.close();
+            return;
+        }
+        const centered = this.page.presentation !== 'fullscreen' && centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const tabs = this.options.page.tabs();
+        const input = centered && tabs.length > 1 && !this.options.page.ownsNavigation
+            ? matchesKey(data, 'right') ? '\t' : matchesKey(data, 'left') ? '\x1b[Z' : data
+            : data;
+        if (this.options.page.handleInput(input)) {
+            this.options.changed();
+            return;
+        }
+        if (matchesKey(data, 'escape'))
+            this.options.close();
+    }
+    render(width) {
+        if (this.disposed)
+            return [];
+        const rows = this.page.presentation === 'fullscreen' ? this.options.tui.terminal.rows : pageRows(this.options.tui);
+        const page = this.options.page;
+        const tabs = page.tabs();
+        if (width < 1 || rows < 1 || !tabs.length)
+            return [];
+        const theme = this.options.theme();
+        const centered = this.page.presentation !== 'fullscreen' && centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const inner = centered ? centerDialogContentWidth(width) : contentWidth(width);
+        if (centered) {
+            const tabRows = tabs.length > 1 ? 1 : 0;
+            const bodyStart = centerDialogVerticalPad(rows) + 2 + tabRows;
+            this.pointerLayout = {
+                tabRow: tabRows ? bodyStart - 1 : undefined,
+                bodyStart,
+                contentX: CENTER_DIALOG_PAD,
+                contentWidth: inner,
+                centered
+            };
+            const body = [
+                ...(tabRows ? [tabStrip(tabs, page.activeTab(), inner, theme, 'top', this.hoveredTab)] : []),
+                ...page.render(inner, Math.max(0, centerDialogBodyRows(rows) - tabRows))
+            ];
+            return centerDialogFrame({ title: tabs.find(tab => tab.id === page.activeTab())?.title ?? 'Page', body, width, rows, theme });
+        }
+        this.pointerLayout = {
+            tabRow: 0,
+            bodyStart: 2,
+            contentX: CHROME_PAD,
+            contentWidth: contentWidth(width),
+            centered
+        };
+        const pageHint = page.hint();
+        const returnsToPage = pageHint.split(' · ').includes('Esc back');
+        const escapeHint = page.ownsNavigation ? 'Esc back/close' : returnsToPage ? 'Esc back' : 'Esc close';
+        const fullFooter = page.ownsNavigation ? `${escapeHint} · ${pageHint}` : [
+            pageHint,
+            tabs.length > 1 ? 'Tab/Shift+Tab sections' : '',
+            returnsToPage ? '' : escapeHint
+        ].filter(Boolean).join(' · ');
+        const footerWidth = Math.max(0, width - CHROME_PAD * 2);
+        const primaryHint = pageHint.split(' · ')[0] ?? '';
+        const compactFooter = [
+            primaryHint,
+            !page.ownsNavigation && tabs.length > 1 ? 'Tab/⇧Tab' : '',
+            escapeHint
+        ].filter(Boolean).join(' · ');
+        const navigationFooter = [!page.ownsNavigation && tabs.length > 1 ? 'Tab/⇧Tab' : '', escapeHint].filter(Boolean).join(' · ');
+        const footer = visibleWidth(fullFooter) <= footerWidth
+            ? fullFooter
+            : visibleWidth(compactFooter) <= footerWidth
+                ? compactFooter
+                : visibleWidth(navigationFooter) <= footerWidth ? navigationFooter : escapeHint;
+        return pageFrame({
+            title: '',
+            headerLine: tabStrip(tabs, page.activeTab(), inner, theme, 'top', this.hoveredTab),
+            body: page.render(inner, pageBodyRows(rows)),
+            footer,
+            width,
+            rows,
+            theme
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.options.page.dispose?.();
+    }
+}

package/dist/sdk/terminal/tui/pages/accountsPage.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The Accounts page: one row per account with its health and Pools as a second section. Opening
+ * an account shows its details and grouped actions in a wide inspector or a compact detail page;
+ * the actions themselves are the ones the `/accounts` menu of a native `pi` session uses.
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type AccountsCall, type AccountsUi, type SessionAccount } from "../../accountsMenu.js";
+import type { GroupedSelectOption } from "../dialogs.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface AccountsPageOptions {
+    theme: () => Theme;
+    call: AccountsCall;
+    /** The account this session runs on. */
+    session: () => SessionAccount | null;
+    ui: AccountsUi & {
+        selectGrouped?(title: string, options: readonly GroupedSelectOption[]): Promise<string | undefined>;
+    };
+    /** The session is switching accounts: the host ends it so the launcher can start it again. */
+    relaunch(): void;
+    changed(): void;
+}
+export declare class AccountsPage implements TerminalPage {
+    private readonly options;
+    readonly presentation = "fullscreen";
+    readonly ownsNavigation = true;
+    private overview;
+    private error;
+    private section;
+    private focus;
+    private detailOpen;
+    private detailAccountId;
+    private busy;
+    private disposed;
+    private compact;
+    private wideListWidth;
+    private actionRowsStart;
+    private readonly list;
+    private readonly actionList;
+    constructor(options: AccountsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly [{
+        readonly id: "accounts";
+        readonly title: "Accounts";
+    }, {
+        readonly id: "pools";
+        readonly title: "Pools";
+    }];
+    activeTab(): string;
+    selectTab(id: string): void;
+    hint(): string;
+    private reload;
+    /** Searching looks through accounts and pools together; otherwise the page shows the current section. */
+    private fill;
+    private accountRows;
+    private poolRows;
+    private account;
+    private detailAccount;
+    private selectGrouped;
+    private accountActionGroup;
+    private fillActions;
+    private detailLines;
+    /** Runs one thing at a time and always reads the accounts again afterwards. */
+    private guarded;
+    private closeDetails;
+    private openDetails;
+    private activateRow;
+    private activateAction;
+    private moveSection;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}