@north-light/api 0.3.580 → 0.3.587

package/dist/commands/sys/panels/provider-panel.d.ts

@@ -0,0 +1,74 @@
+import { ModelRegistry, ModelRuntime } from '@earendil-works/pi-coding-agent';
+import { type TUI } from '@earendil-works/pi-tui';
+import { type SetupPanel } from '../../../core/tui/panel.js';
+type AuthStatus = ReturnType<ModelRegistry["getProviderAuthStatus"]>;
+type ProviderAuthType = "oauth" | "api_key";
+type ProviderRow = {
+    providerId: string;
+    name: string;
+    managed: boolean;
+    authType: ProviderAuthType;
+    label?: string;
+    preferred?: boolean;
+    cooldownUntil?: number;
+    /** Per-model-family cooldowns (family → epoch ms); the account stays usable for other families. */
+    modelCooldowns?: Record<string, number>;
+    configured?: boolean;
+    source?: AuthStatus["source"];
+    sourceLabel?: string;
+    accountId?: string;
+};
+/** Curated setup-catalog view over pi's OAuth providers + the model registry. */
+export declare function buildProviderCatalog(runtime: ModelRuntime, registry: ModelRegistry): ProviderRow[];
+/** Classifies a `startLogin` failure into a user-facing status line. */
+export declare function classifyLoginFailure(error: unknown, aborted: boolean): string;
+export declare class ProviderPanel implements SetupPanel {
+    private readonly tui;
+    private readonly agentDir;
+    private readonly runtime;
+    private readonly registry;
+    private readonly renameInput;
+    private rows;
+    private selected;
+    private mode;
+    private notice;
+    private catalog;
+    private catalogIndex;
+    private loginProvider;
+    private loginFlow;
+    private mutationInFlight;
+    /** Managed-provider pools as last read from the credential rows; reload() renders from this. */
+    private pools;
+    onChange?: () => void;
+    constructor(tui: TUI, agentDir: string, runtime: ModelRuntime, registry: ModelRegistry);
+    private notifyChange;
+    /** auth.json changed under us (a login landed, a provider was removed). pi 0.82
+     *  serves provider auth status from the runtime's SNAPSHOT rather than a live file
+     *  read, so the snapshot has to be re-taken before the roster can see the change.
+     *  `refresh()` is local-only here (the runtime is composed with model network access
+     *  off), so this is a credential re-list, not a catalog fetch. */
+    private reloadAfterAuthChange;
+    /** Re-reads every managed provider's account rows, then rebuilds the roster. */
+    private reloadPools;
+    private reload;
+    private selectedRow;
+    private openBrowser;
+    private openCatalog;
+    private startLogin;
+    /** True when the cursor sits on the `+ Add provider` row, where Enter opens the catalog. */
+    isAddRowSelected(): boolean;
+    isNestedFlowActive(): boolean;
+    dispose(): void;
+    private runMutation;
+    /** Prefilled label for a new managed account: `default` for the first one, then
+     *  `account-2`, `account-3`… so Enter alone never collides with an existing row
+     *  (pool labels compare case-insensitively). */
+    private suggestedAccountLabel;
+    private rename;
+    private remove;
+    private promote;
+    handleInput(data: string): boolean;
+    badge(): string;
+    render(width: number, height: number): string[];
+}
+export {};

package/dist/commands/sys/panels/provider-panel.js

@@ -0,0 +1,534 @@
+import { LoginDialogComponent, } from '@earendil-works/pi-coding-agent';
+import { Input, matchesKey, truncateToWidth, } from '@earendil-works/pi-tui';
+import { execFile } from 'node:child_process';
+import { dialogAuthInteraction } from '../../../core/auth-interaction.js';
+import { formatCooldowns, isManagedProvider, } from '../../../core/managed-providers.js';
+import { removeProviderRow } from '../../../core/provider-management.js';
+import { cliClient } from '../../api-client.js';
+import { loginProvider } from '../provider-login.js';
+import { fitTail, theme, visibleRange, } from '../../../core/tui/panel.js';
+/** A managed account as the API reports it. Token fields are not on the wire, so they stay empty. */
+function accountOf(account) {
+    const modelCooldowns = Object.fromEntries((account.model_cooldowns ?? []).map((c) => [c.family, Date.parse(c.rate_limited_until)]));
+    return {
+        label: account.label,
+        refresh: '',
+        access: '',
+        expires: Date.parse(account.expires_at),
+        rateLimitedUntil: Date.parse(account.rate_limited_until),
+        lastAttemptAt: 0,
+        lastRateLimitedAt: 0,
+        ...(account.auth_failure ? { authFailure: account.auth_failure } : {}),
+        ...(account.account_id ? { accountId: account.account_id } : {}),
+        ...(Object.keys(modelCooldowns).length ? { modelCooldowns } : {}),
+    };
+}
+/** Curated setup-catalog view over pi's OAuth providers + the model registry. */
+export function buildProviderCatalog(runtime, registry) {
+    const oauth = runtime
+        .getProviders()
+        .filter((provider) => provider.auth.oauth !== undefined);
+    const oauthIds = new Set(oauth.map((provider) => provider.id));
+    const seen = new Set();
+    return [
+        ...oauth.map((provider) => ({
+            providerId: provider.id,
+            name: provider.name,
+            managed: isManagedProvider(provider.id),
+            authType: "oauth",
+        })),
+        ...registry.getAll().map((model) => ({
+            providerId: model.provider,
+            name: registry.getProviderDisplayName(model.provider),
+            managed: isManagedProvider(model.provider),
+            authType: oauthIds.has(model.provider)
+                ? "oauth"
+                : "api_key",
+        })),
+    ].filter((provider) => !seen.has(provider.providerId) && Boolean(seen.add(provider.providerId)));
+}
+/** Classifies a `startLogin` failure into a user-facing status line. */
+export function classifyLoginFailure(error, aborted) {
+    if (aborted)
+        return "Login cancelled";
+    if (error instanceof Error && error.name === "AbortError")
+        return "Login cancelled";
+    return `Login error: ${error instanceof Error ? error.message : String(error)}`;
+}
+export class ProviderPanel {
+    tui;
+    agentDir;
+    runtime;
+    registry;
+    renameInput = new Input();
+    rows = [];
+    selected = 0;
+    mode = "list";
+    notice = "";
+    catalog = [];
+    catalogIndex = 0;
+    loginProvider;
+    loginFlow;
+    mutationInFlight = false;
+    /** Managed-provider pools as last read from the credential rows; reload() renders from this. */
+    pools = new Map();
+    // Wired by the host wizard to bust its render-line cache. The panel proxies pi's
+    // LoginDialogComponent (it is not a real pi TUI child), so the host only repaints on
+    // synchronous input. startLogin drives OAuth through async promise chains whose state
+    // transitions land between keystrokes; notifyChange() lets each one force a fresh frame.
+    onChange;
+    constructor(tui, agentDir, runtime, registry) {
+        this.tui = tui;
+        this.agentDir = agentDir;
+        this.runtime = runtime;
+        this.registry = registry;
+        this.renameInput.onSubmit = () => this.rename();
+        this.renameInput.onEscape = () => {
+            this.mode = "list";
+        };
+        void this.reloadPools()
+            .then(() => this.notifyChange())
+            .catch((error) => {
+            this.notice = error instanceof Error ? error.message : String(error);
+            this.notifyChange();
+        });
+    }
+    // Repaint the host after an async login transition: bust the wizard's cached lines
+    // (onChange) so render() recomputes the NEW state, then ask pi's loop to draw a frame.
+    notifyChange() {
+        this.onChange?.();
+        this.tui.requestRender();
+    }
+    /** auth.json changed under us (a login landed, a provider was removed). pi 0.82
+     *  serves provider auth status from the runtime's SNAPSHOT rather than a live file
+     *  read, so the snapshot has to be re-taken before the roster can see the change.
+     *  `refresh()` is local-only here (the runtime is composed with model network access
+     *  off), so this is a credential re-list, not a catalog fetch. */
+    async reloadAfterAuthChange() {
+        await this.reloadPools();
+        await this.registry.refresh();
+        this.reload();
+        this.notifyChange();
+    }
+    /** Re-reads every managed provider's account rows, then rebuilds the roster. */
+    async reloadPools() {
+        const next = new Map();
+        for (const status of (await cliClient().listModelAuth()).providers) {
+            if (status.managed)
+                next.set(status.provider, status.accounts.map(accountOf));
+        }
+        this.pools = next;
+        this.reload();
+    }
+    reload() {
+        const registry = this.registry;
+        const rows = [];
+        for (const provider of buildProviderCatalog(this.runtime, registry)) {
+            const status = registry.getProviderAuthStatus(provider.providerId);
+            if (provider.managed) {
+                const pool = this.pools.get(provider.providerId) ?? [];
+                if (pool.length === 0 && !status.source)
+                    continue;
+                // Every stored account carries a credential, so pool occupancy is what makes the
+                // provider configured.
+                rows.push({
+                    ...provider,
+                    configured: status.configured || pool.length > 0,
+                    source: status.source,
+                    sourceLabel: status.label,
+                });
+                pool.forEach((account, index) => rows.push({
+                    ...provider,
+                    label: account.label,
+                    preferred: index === 0,
+                    cooldownUntil: account.rateLimitedUntil,
+                    ...(account.modelCooldowns ? { modelCooldowns: account.modelCooldowns } : {}),
+                    accountId: account.accountId,
+                }));
+                continue;
+            }
+            if (!status.source)
+                continue;
+            rows.push({
+                ...provider,
+                configured: status.configured,
+                source: status.source,
+                sourceLabel: status.label,
+            });
+        }
+        this.rows = rows;
+        this.selected = Math.min(this.selected, Math.max(0, rows.length));
+    }
+    selectedRow() {
+        return this.rows[this.selected];
+    }
+    openBrowser(url) {
+        const command = process.platform === "darwin"
+            ? "open"
+            : process.platform === "win32"
+                ? "cmd"
+                : "xdg-open";
+        const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+        execFile(command, args, { timeout: 5_000 }, () => { });
+    }
+    openCatalog() {
+        this.catalog = buildProviderCatalog(this.runtime, this.registry);
+        this.catalogIndex = 0;
+        this.mode = "catalog";
+    }
+    startLogin(provider, label) {
+        this.loginProvider = provider;
+        let flow;
+        const complete = (message) => {
+            if (!flow.active || this.loginFlow !== flow)
+                return;
+            flow.active = false;
+            this.loginFlow = undefined;
+            this.mode = "list";
+            this.notice = message;
+            void this.reloadAfterAuthChange();
+        };
+        const dialog = new LoginDialogComponent(this.tui, provider.providerId, (success, message) => {
+            if (!success)
+                complete(message ? `Login failed: ${message}` : "Login cancelled");
+        }, provider.name);
+        flow = { dialog, active: true, committing: false };
+        this.loginFlow = flow;
+        this.mode = "login";
+        const handleDialogInput = dialog.handleInput.bind(dialog);
+        dialog.handleInput = (data) => {
+            if (!flow.committing)
+                handleDialogInput(data);
+        };
+        const isActive = () => flow.active && this.loginFlow === flow && !dialog.signal.aborted;
+        const beginCommit = () => {
+            if (!isActive())
+                return false;
+            flow.committing = true;
+            dialog.showDetails(["Saving credentials…"]);
+            return true;
+        };
+        const fail = (error) => {
+            complete(classifyLoginFailure(error, dialog.signal.aborted));
+        };
+        if (provider.authType === "api_key") {
+            void dialog
+                .showPrompt(`Enter API key for ${provider.name}:`, "sk-...")
+                .then(async (key) => {
+                if (!isActive())
+                    return;
+                if (!key.trim()) {
+                    complete("No key entered — login cancelled");
+                    return;
+                }
+                // Interactive collection stays client-side (TTY); the WRITE moves to the
+                // API (PUT /model-auth/{provider}) so this process never touches auth.json.
+                if (!beginCommit())
+                    return;
+                await cliClient().installCredential(provider.providerId, {
+                    kind: "api_key",
+                    api_key: key.trim(),
+                });
+                complete(`API key saved for ${provider.name}`);
+            })
+                .catch(fail);
+            return;
+        }
+        // pi 0.82 collapsed the six login callbacks into one AuthInteraction; the adapter
+        // onto LoginDialogComponent is shared with the attach viewer's /login overlay.
+        const interaction = dialogAuthInteraction(dialog, {
+            openBrowser: (url) => this.openBrowser(url),
+            onChange: () => this.notifyChange(),
+            isActive,
+        });
+        void loginProvider(this.runtime, provider.providerId, interaction, { label, beforeInstall: beginCommit })
+            .then((installed) => {
+            if (installed && isActive())
+                complete(`Logged in to ${provider.name}`);
+        })
+            .catch(fail);
+    }
+    /** True when the cursor sits on the `+ Add provider` row, where Enter opens the catalog. */
+    isAddRowSelected() {
+        return this.mode === "list" && this.selectedRow() === undefined;
+    }
+    isNestedFlowActive() {
+        return this.mode === "login";
+    }
+    dispose() {
+        const flow = this.loginFlow;
+        if (!flow)
+            return;
+        flow.active = false;
+        this.loginFlow = undefined;
+        flow.dialog.handleInput("\u001b");
+    }
+    runMutation(operation) {
+        if (this.mutationInFlight)
+            return;
+        this.mutationInFlight = true;
+        void operation()
+            .catch((error) => {
+            this.notice = error instanceof Error ? error.message : String(error);
+        })
+            .finally(() => {
+            this.mutationInFlight = false;
+            this.notifyChange();
+        });
+    }
+    /** Prefilled label for a new managed account: `default` for the first one, then
+     *  `account-2`, `account-3`… so Enter alone never collides with an existing row
+     *  (pool labels compare case-insensitively). */
+    suggestedAccountLabel(providerId) {
+        const taken = new Set((this.pools.get(providerId) ?? []).map((entry) => entry.label.toLowerCase()));
+        if (!taken.has("default"))
+            return "default";
+        let index = 2;
+        while (taken.has(`account-${index}`))
+            index += 1;
+        return `account-${index}`;
+    }
+    rename() {
+        const row = this.selectedRow();
+        if (!row?.managed || !row.label)
+            return;
+        this.mode = "list";
+        this.runMutation(async () => {
+            await cliClient().patchModelAuthAccount(row.providerId, row.label, {
+                label: this.renameInput.getValue(),
+            });
+            this.notice = `Renamed ${row.name} account`;
+            await this.reloadPools();
+        });
+    }
+    remove(row) {
+        this.runMutation(async () => {
+            this.notice = await removeProviderRow(cliClient(), row);
+            await this.reloadAfterAuthChange();
+        });
+    }
+    promote(row) {
+        this.runMutation(async () => {
+            await cliClient().patchModelAuthAccount(row.providerId, row.label, { preferred: true });
+            this.notice = `Preferred ${row.name} account`;
+            await this.reloadPools();
+        });
+    }
+    handleInput(data) {
+        if (this.mode === "login") {
+            this.loginFlow?.dialog.handleInput(data);
+            return true;
+        }
+        if (this.mutationInFlight)
+            return true;
+        if (this.mode === "rename" || this.mode === "label") {
+            this.renameInput.handleInput(data);
+            return true;
+        }
+        if (this.mode === "catalog") {
+            if (matchesKey(data, "escape")) {
+                this.mode = "list";
+                return true;
+            }
+            if (matchesKey(data, "j") || matchesKey(data, "down")) {
+                this.catalogIndex = Math.min(this.catalog.length - 1, this.catalogIndex + 1);
+                return true;
+            }
+            if (matchesKey(data, "k") || matchesKey(data, "up")) {
+                this.catalogIndex = Math.max(0, this.catalogIndex - 1);
+                return true;
+            }
+            if (matchesKey(data, "enter")) {
+                const provider = this.catalog[this.catalogIndex];
+                if (provider.managed) {
+                    this.loginProvider = provider;
+                    const suggested = this.suggestedAccountLabel(provider.providerId);
+                    this.renameInput.setValue(suggested);
+                    this.renameInput.onSubmit = () => {
+                        this.startLogin(provider, this.renameInput.getValue().trim() || suggested);
+                    };
+                    this.mode = "label";
+                }
+                else
+                    this.startLogin(provider);
+                return true;
+            }
+            return true;
+        }
+        if (this.mode === "remove") {
+            if (matchesKey(data, "y") || matchesKey(data, "enter")) {
+                const row = this.selectedRow();
+                if (row && (row.managed || row.configured)) {
+                    this.remove(row);
+                }
+            }
+            this.mode = "list";
+            return true;
+        }
+        if (matchesKey(data, "j") || matchesKey(data, "down")) {
+            this.selected = Math.min(this.rows.length, this.selected + 1);
+            return true;
+        }
+        if (matchesKey(data, "k") || matchesKey(data, "up")) {
+            this.selected = Math.max(0, this.selected - 1);
+            return true;
+        }
+        const row = this.selectedRow();
+        if (matchesKey(data, "p") && row?.managed && row.label) {
+            this.promote(row);
+            return true;
+        }
+        if (matchesKey(data, "r") && row?.managed && row.label) {
+            this.renameInput.setValue(row.label);
+            this.renameInput.onSubmit = () => this.rename();
+            this.mode = "rename";
+            return true;
+        }
+        if (matchesKey(data, "x") && (row?.managed || row?.configured)) {
+            this.mode = "remove";
+            return true;
+        }
+        if (matchesKey(data, "a")) {
+            this.openCatalog();
+            return true;
+        }
+        const viewOnly = row?.source === "environment" || row?.source === "runtime";
+        if (matchesKey(data, "l") && row && !viewOnly) {
+            if (row.managed && row.label)
+                this.startLogin(row, row.label);
+            else
+                this.startLogin(row);
+            return true;
+        }
+        // Enter only opens the catalog from the `+ Add provider` row. On an account
+        // row it falls through to the host (setup: next step) — re-login is `l`, and
+        // binding it to Enter too silently re-signed people in when they meant to move on.
+        if (matchesKey(data, "enter") && !row) {
+            this.openCatalog();
+            return true;
+        }
+        return false;
+    }
+    // `height` is the panel's row budget, supplied by the host page's live
+    // terminal-row callback. It can shrink to just a couple of rows, so every part
+    // of the panel below the mandatory content is chrome that collapses under
+    // pressure. For the roster/catalog list this
+    // is: the title/count header first, then the hint/notice/empty-state line, then the
+    // position indicator — never letting the selected row scroll out of view. The
+    // login/rename/label/remove modals have no list to window, so they apply the same
+    // budget via `fitTail`: their bodies always end on the actionable line (a live
+    // input, a confirm prompt, a login dialog's current prompt), so clipping from the
+    // head sheds chrome (title/count/older status lines) first and keeps that line.
+    badge() {
+        return String(this.rows.filter((row) => row.label === undefined).length);
+    }
+    render(width, height) {
+        const titleLine = theme.fg("accent", theme.bold("Providers"));
+        const countLine = theme.fg("dim", `${this.rows.filter((row) => row.label === undefined).length} configured`);
+        const contentBudget = Math.max(1, height);
+        let body;
+        if (this.mode === "login") {
+            body = fitTail(this.loginFlow?.dialog.render(width) ?? [], contentBudget);
+        }
+        else if (this.mode === "rename" || this.mode === "label") {
+            body = fitTail([
+                titleLine,
+                countLine,
+                "",
+                theme.fg("accent", this.mode === "rename"
+                    ? "Rename account"
+                    : `Name the ${this.loginProvider?.name ?? "provider"} account`),
+                ...(this.mode === "label"
+                    ? [
+                        theme.fg("dim", "Names this credential — keep work and personal accounts on one provider apart"),
+                    ]
+                    : []),
+                ...this.renameInput.render(Math.max(1, width - 8)),
+            ], contentBudget);
+        }
+        else if (this.mode === "remove") {
+            const target = this.selectedRow();
+            const label = target?.label ??
+                (target?.managed
+                    ? `${target.name} · all accounts`
+                    : (target?.name ?? "account"));
+            body = fitTail([
+                titleLine,
+                countLine,
+                "",
+                theme.fg("warning", `Remove ${label}? y/enter confirm · any other key cancel`),
+            ], contentBudget);
+        }
+        else {
+            // The title/count header is the first chrome to give way: only as many of its
+            // two lines are kept as fit while still reserving at least one row for the
+            // mandatory selected entry.
+            const header = [titleLine, countLine].slice(0, Math.max(0, contentBudget - 1));
+            const remaining = contentBudget - header.length; // always >= 1
+            body = [...header];
+            if (this.mode === "catalog") {
+                const items = this.catalog.length;
+                const clipped = items > remaining;
+                // Only trade a row for the position indicator when there's a spare row to trade;
+                // at `remaining === 1` the sole row goes to the mandatory selected entry instead.
+                const reserveIndicator = clipped && remaining >= 2;
+                const rowBudget = reserveIndicator ? remaining - 1 : remaining;
+                const { start, end } = visibleRange(items, this.catalogIndex, rowBudget);
+                let leftover = remaining - (end - start) - (reserveIndicator ? 1 : 0);
+                if (leftover > 0) {
+                    body.push(theme.fg("dim", "Select a provider to add · esc back"));
+                    leftover -= 1;
+                }
+                for (let index = start; index < end; index++) {
+                    const provider = this.catalog[index];
+                    body.push(`${index === this.catalogIndex ? theme.fg("accent", "▶") : " "} ${provider.name}`);
+                }
+                if (reserveIndicator)
+                    body.push(theme.fg("dim", `(${this.catalogIndex + 1}/${items})`));
+            }
+            else {
+                const totalEntries = this.rows.length + 1; // + the trailing "Add provider" sentinel
+                const clipped = totalEntries > remaining;
+                const reserveIndicator = clipped && remaining >= 2;
+                const rowBudget = reserveIndicator ? remaining - 1 : remaining;
+                const { start, end } = visibleRange(totalEntries, this.selected, rowBudget);
+                let leftover = remaining - (end - start) - (reserveIndicator ? 1 : 0);
+                const showEmpty = this.rows.length === 0 && leftover > 0;
+                if (showEmpty)
+                    leftover -= 1;
+                const showNotice = Boolean(this.notice) && leftover > 0;
+                if (showEmpty)
+                    body.push(theme.fg("warning", "No provider configured yet."));
+                for (let index = start; index < end; index++) {
+                    if (index === this.rows.length) {
+                        body.push(`${this.selected === this.rows.length ? theme.fg("accent", "▶") : " "} ${theme.fg("accent", "＋ Add provider")}`);
+                        continue;
+                    }
+                    const row = this.rows[index];
+                    const selected = index === this.selected ? theme.fg("accent", "▶") : " ";
+                    if (!row.label) {
+                        const state = row.managed
+                            ? `${this.rows.filter((item) => item.providerId === row.providerId && item.label).length} accounts`
+                            : row.source === "environment" || row.source === "runtime"
+                                ? `${row.source}${row.sourceLabel ? ` · ${row.sourceLabel}` : ""} (view only)`
+                                : "configured";
+                        body.push(`${selected} ${theme.fg("accent", row.name)}${theme.fg("dim", `  ${state}`)}`);
+                    }
+                    else {
+                        // Account-wide and per-model-family cooldowns, e.g. "opus cooldown 3d 4h".
+                        const health = formatCooldowns({ rateLimitedUntil: row.cooldownUntil ?? 0, modelCooldowns: row.modelCooldowns }) ?? "ready";
+                        const identity = row.accountId
+                            ? ` · ${row.accountId.length > 12 ? `${row.accountId.slice(0, 8)}…${row.accountId.slice(-4)}` : row.accountId}`
+                            : "";
+                        body.push(`${selected}   ${row.preferred ? theme.fg("success", "●") : " "} ${row.label}${theme.fg("dim", identity)}  ${theme.fg("dim", health)}${row.preferred ? theme.fg("accent", "  preferred") : ""}`);
+                    }
+                }
+                if (reserveIndicator)
+                    body.push(theme.fg("dim", `(${this.selected + 1}/${totalEntries})`));
+                if (showNotice)
+                    body.push(theme.fg("dim", this.notice));
+            }
+        }
+        return body.map((line) => truncateToWidth(line, width));
+    }
+}

package/dist/commands/sys/panels/terminal-panel.d.ts

@@ -0,0 +1,19 @@
+import { type SetupPanel } from '../../../core/tui/panel.js';
+import { type OptionAsAltPlan, type TerminalConfigEdit } from '../terminal-option.js';
+/** The macOS Option-as-Alt step: explains the setting for the detected terminal
+ *  and, only where crouter can write it safely, offers to apply it. The offer
+ *  starts UNCHECKED — nothing is written without the person ticking it, and the
+ *  exact lines are on screen while they decide. */
+export declare class TerminalPanel implements SetupPanel {
+    private readonly plan;
+    private readonly onChange;
+    private apply;
+    constructor(plan: OptionAsAltPlan, onChange: () => void);
+    badge(): string;
+    /** Whether this step can toggle anything — drives the footer wording. */
+    get canApply(): boolean;
+    /** The edit to perform at install time; undefined unless consented. */
+    get selectedEdit(): TerminalConfigEdit | undefined;
+    handleInput(data: string, matches?: (id: string, input: string) => boolean): boolean;
+    render(width: number): string[];
+}