@north-light/crouter 0.3.172 → 0.3.174

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

@@ -0,0 +1,538 @@
+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 { isManagedProvider, promoteSubscription, readSubscriptionPool, renameSubscription, } from "../../../core/subscription-state.js";
+import { removeProviderRow } from "../../../core/provider-management.js";
+import { cliClient } from "../../api-client.js";
+import { fitTail, theme, visibleRange, } from "./panel.js";
+/** 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;
+    // 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";
+        };
+        this.reload();
+    }
+    // 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. */
+    reloadAfterAuthChange() {
+        this.reload();
+        void this.registry.refresh().then(() => {
+            this.reload();
+            this.notifyChange();
+        });
+    }
+    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 = readSubscriptionPool(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: pool.length > 0 || status.configured,
+                    source: status.source,
+                    sourceLabel: status.label,
+                });
+                pool.forEach((account, index) => rows.push({
+                    ...provider,
+                    label: account.label,
+                    preferred: index === 0,
+                    cooldownUntil: account.rateLimitedUntil,
+                    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;
+            this.reloadAfterAuthChange();
+            this.notifyChange();
+        };
+        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,
+        });
+        const oauth = this.runtime.getProvider(provider.providerId)?.auth.oauth;
+        if (!oauth) {
+            complete(`Unknown OAuth provider: ${provider.providerId}`);
+            return;
+        }
+        if (!provider.managed) {
+            // Collect tokens client-side (browser/TTY), then WRITE via the API so this
+            // process never touches auth.json. In 0.82 `provider.auth.oauth.login()`
+            // RETURNS the credential without persisting it (persistence is app-owned),
+            // which is exactly the collect-without-persist half this needs.
+            void oauth
+                .login(interaction)
+                .then(async (credentials) => {
+                if (!isActive())
+                    return;
+                if (!beginCommit())
+                    return;
+                // Forward non-standard credential keys (e.g. github-copilot's `enterpriseUrl`)
+                // so enterprise routing and token refresh retain the provider data they require.
+                // The named tokens and store `type` are handled separately; all other keys travel
+                // through `extra` and the handler writes them into auth.json.
+                const { type: _type, access, refresh, expires, ...extra } = credentials;
+                await cliClient().installCredential(provider.providerId, {
+                    kind: "oauth",
+                    access_token: access,
+                    refresh_token: refresh,
+                    expires_at: new Date(expires).toISOString(),
+                    ...(Object.keys(extra).length > 0 ? { extra } : {}),
+                });
+                if (isActive())
+                    complete(`Logged in to ${provider.name}`);
+            })
+                .catch(fail);
+            return;
+        }
+        // Snapshot the newest pool cooldown before OAuth so a later 429 remains authoritative.
+        const lastRateLimitedAt = Math.max(0, ...readSubscriptionPool(provider.providerId).map((entry) => entry.lastRateLimitedAt));
+        void oauth
+            .login(interaction)
+            .then(async (credential) => {
+            if (!isActive())
+                return;
+            if (!beginCommit())
+                return;
+            const accountId = typeof credential.accountId === "string" &&
+                credential.accountId.trim()
+                ? credential.accountId.trim()
+                : undefined;
+            // Collected via pi's managed login (client); the API persists it into the pool, where
+            // account identity selects an existing row or labels a newly seen account.
+            await cliClient().installCredential(provider.providerId, {
+                kind: "managed_account",
+                ...(label ? { label } : {}),
+                ...(label ? {} : { auto_label: true }),
+                ...(accountId ? { account_id: accountId } : {}),
+                access_token: credential.access,
+                refresh_token: credential.refresh,
+                expires_at: new Date(credential.expires).toISOString(),
+                last_rate_limited_at: lastRateLimitedAt,
+            });
+            if (isActive())
+                complete(`Logged in to ${provider.name}`);
+        })
+            .catch(fail);
+    }
+    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();
+        });
+    }
+    rename() {
+        const row = this.selectedRow();
+        if (!row?.managed || !row.label)
+            return;
+        this.mode = "list";
+        this.runMutation(async () => {
+            await renameSubscription(row.providerId, row.label, this.renameInput.getValue());
+            this.notice = `Renamed ${row.name} account`;
+            this.reload();
+        });
+    }
+    remove(row) {
+        this.runMutation(async () => {
+            this.notice = await removeProviderRow(this.agentDir, row);
+            this.reloadAfterAuthChange();
+        });
+    }
+    promote(row) {
+        this.runMutation(async () => {
+            await promoteSubscription(row.providerId, row.label);
+            this.notice = `Preferred ${row.name} account`;
+            this.reload();
+        });
+    }
+    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;
+                    this.renameInput.setValue("");
+                    this.renameInput.onSubmit = () => {
+                        const label = this.renameInput.getValue().trim();
+                        if (label)
+                            this.startLogin(provider, label);
+                    };
+                    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;
+        }
+        if (matchesKey(data, "enter")) {
+            if (row && !viewOnly)
+                this.startLogin(row, row.managed && row.label ? row.label : undefined);
+            else if (!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.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 {
+                        const health = row.cooldownUntil && row.cooldownUntil > Date.now()
+                            ? `cooldown ${Math.ceil((row.cooldownUntil - Date.now()) / 60000)}m`
+                            : "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/settings-shell.d.ts

@@ -0,0 +1,55 @@
+import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { TUI, type Component, type Focusable } from "@earendil-works/pi-tui";
+import { type BindingId, type BindingResolution } from "../../core/keybindings/index.js";
+export declare class SettingsShell implements Component, Focusable {
+    private readonly tui;
+    private readonly bindings;
+    private readonly terminalRows;
+    private readonly providers;
+    private readonly models;
+    private readonly keybindings;
+    private readonly brokerLimits;
+    private readonly keys;
+    private readonly destinations;
+    private index;
+    /** The rail owns the arrow keys until you step into a panel. */
+    private railFocused;
+    private _focused;
+    private cachedWidth;
+    private cachedHeight;
+    private cachedLines;
+    private keySaveInFlight;
+    onCancel?: () => void;
+    constructor(tui: TUI, agentDir: string, runtime: ModelRuntime, registry: ModelRegistry, bindings: BindingResolution<BindingId>, rawKeybindings: unknown, terminalRows: () => number, rawTmuxPassthrough?: unknown);
+    set focused(value: boolean);
+    get focused(): boolean;
+    private get current();
+    invalidate(): void;
+    private syncFocus;
+    private enterRail;
+    private enterPanel;
+    private go;
+    private matches;
+    private label;
+    /** Panels that have taken over the keyboard — a live text field, a modal, an
+     *  open picker — keep every key including Escape until they release it. */
+    private panelOwnsKeyboard;
+    /** `crtr.setup.tab-next`/`-previous` still carry the tab strip's horizontal
+     *  arrows. In the rail layout the horizontal arrows mean "into the panel" and
+     *  "back to the rail", so only the Tab gestures cycle destinations. */
+    private cyclesDestination;
+    handleInput(data: string): void;
+    /** Typing a letter on the rail jumps to the destination it starts. */
+    private jumpToInitial;
+    private routeToPanel;
+    private saveExaKey;
+    private close;
+    dispose(): void;
+    private renderRail;
+    /** Left hint plus the always-there navigation keys, the hint shedding its
+     *  optional half on a narrow terminal rather than pushing "close" off. */
+    private footer;
+    private panelHint;
+    render(width: number): string[];
+}
+export declare function runSettings(): Promise<void>;