shortcutxl 0.2.0

package/dist/modes/interactive/components/footer.js

@@ -0,0 +1,309 @@
+import { truncateToWidth, visibleWidth } from '../../../tui/index.js';
+import { theme } from '../../../core/theme.js';
+/**
+ * Sanitize text for display in a single-line status.
+ * Removes newlines, tabs, carriage returns, and other control characters.
+ */
+function sanitizeStatusText(text) {
+    // Replace newlines, tabs, carriage returns with space, then collapse multiple spaces
+    return text
+        .replace(/[\r\n\t]/g, ' ')
+        .replace(/ +/g, ' ')
+        .trim();
+}
+/**
+ * Format token counts (similar to web-ui)
+ */
+function formatTokens(count) {
+    if (count < 1000)
+        return count.toString();
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    if (count < 10000000)
+        return `${(count / 1000000).toFixed(1)}M`;
+    return `${Math.round(count / 1000000)}M`;
+}
+// ANSI escape helpers for credit tier styling
+const ANSI = {
+    bold: '\x1b[1m',
+    brightWhite: '\x1b[97m',
+    cyan: '\x1b[36m',
+    brightCyan: '\x1b[96m',
+    reset: '\x1b[0m',
+    resetFg: '\x1b[39m',
+    resetBold: '\x1b[22m'
+};
+/**
+ * Style credit text based on usage tiers.
+ * Higher spend = more visually prominent = more "achievement" feel.
+ *
+ *   0       → dim (haven't started yet)
+ *   1-29    → normal (getting going)
+ *   30-99   → bold bright white (making progress)
+ *   100-299 → cyan (power user)
+ *   300+    → bright cyan + bold (legend)
+ */
+function styleCreditText(text, creditsUsed) {
+    if (creditsUsed <= 0)
+        return theme.fg('dim', text);
+    if (creditsUsed < 30)
+        return text;
+    if (creditsUsed < 100)
+        return `${ANSI.bold}${ANSI.brightWhite}${text}${ANSI.resetBold}${ANSI.resetFg}`;
+    if (creditsUsed < 300)
+        return `${ANSI.cyan}${text}${ANSI.resetFg}`;
+    return `${ANSI.bold}${ANSI.brightCyan}${text}${ANSI.resetBold}${ANSI.resetFg}`;
+}
+/**
+ * Count user queries (user messages) in the session.
+ */
+function countUserQueries(session) {
+    let count = 0;
+    for (const entry of session.sessionManager.getEntries()) {
+        if (entry.type === 'message' && entry.message.role === 'user') {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Footer component that shows pwd, token stats, and context usage.
+ * Computes token/context stats from session, gets git branch and extension statuses from provider.
+ *
+ * Shortcut credit users get a gamified footer:
+ * - Credits styled by spend tier (dim → normal → bold → cyan → bright cyan)
+ * - Context % colored by usage AND query count (orange at 50%/10q, red at 75%/15q)
+ * - Separator line on top
+ */
+export class FooterComponent {
+    session;
+    footerData;
+    constructor(session, footerData) {
+        this.session = session;
+        this.footerData = footerData;
+    }
+    /**
+     * No-op: git branch caching now handled by provider.
+     * Kept for compatibility with existing call sites in interactive-mode.
+     */
+    invalidate() {
+        // No-op: git branch is cached/invalidated by provider
+    }
+    /**
+     * Clean up resources.
+     * Git watcher cleanup now handled by provider.
+     */
+    dispose() {
+        // Git watcher cleanup handled by provider
+    }
+    render(width) {
+        const state = this.session.state;
+        // Calculate cumulative usage from ALL session entries (not just post-compaction messages)
+        let totalInput = 0;
+        let totalOutput = 0;
+        let totalCacheRead = 0;
+        let totalCacheWrite = 0;
+        let totalCost = 0;
+        for (const entry of this.session.sessionManager.getEntries()) {
+            if (entry.type === 'message' && entry.message.role === 'assistant') {
+                totalInput += entry.message.usage.input;
+                totalOutput += entry.message.usage.output;
+                totalCacheRead += entry.message.usage.cacheRead;
+                totalCacheWrite += entry.message.usage.cacheWrite;
+                totalCost += entry.message.usage.cost.total;
+            }
+        }
+        // Calculate context usage from session (handles compaction correctly).
+        // After compaction, tokens are unknown until the next LLM response.
+        const contextUsage = this.session.getContextUsage();
+        const contextPercentValue = contextUsage?.percent ?? 0;
+        const contextPercent = contextUsage?.percent !== null ? contextPercentValue.toFixed(1) : '?';
+        // Count user queries for context heat meter
+        const queryCount = countUserQueries(this.session);
+        // Build info line: session name only (no branch — user prefers minimal footer)
+        const sessionName = this.session.sessionManager.getSessionName();
+        const infoLine = sessionName || null;
+        // Build stats line
+        const statsParts = [];
+        // Track plain-text widths for each part (ANSI codes have zero visible width)
+        const isShortcutCredits = !!this.footerData.getCreditBalance();
+        // If a credit balance is available, show credits with tier styling.
+        // If the model uses credits but the balance fetch failed, show tokens only (no $cost).
+        // Otherwise show full token breakdown + cost.
+        const creditBalance = this.footerData.getCreditBalance();
+        if (creditBalance) {
+            const creditsUsed = this.footerData.getCreditsUsed();
+            if (creditBalance.isUnlimited) {
+                statsParts.push(theme.fg('dim', 'credits: ∞'));
+            }
+            else {
+                const creditsText = `credits used: ${creditsUsed}`;
+                statsParts.push(styleCreditText(creditsText, creditsUsed));
+            }
+        }
+        else if (this.footerData.usesCredits) {
+            // Credit-based model but balance unavailable — show tokens without $cost
+            if (totalInput)
+                statsParts.push(`↑${formatTokens(totalInput)}`);
+            if (totalOutput)
+                statsParts.push(`↓${formatTokens(totalOutput)}`);
+            if (totalCacheRead)
+                statsParts.push(`R${formatTokens(totalCacheRead)}`);
+            if (totalCacheWrite)
+                statsParts.push(`W${formatTokens(totalCacheWrite)}`);
+        }
+        else {
+            if (totalInput)
+                statsParts.push(`↑${formatTokens(totalInput)}`);
+            if (totalOutput)
+                statsParts.push(`↓${formatTokens(totalOutput)}`);
+            if (totalCacheRead)
+                statsParts.push(`R${formatTokens(totalCacheRead)}`);
+            if (totalCacheWrite)
+                statsParts.push(`W${formatTokens(totalCacheWrite)}`);
+            const usingSubscription = state.model
+                ? this.session.modelRegistry.isUsingOAuth(state.model)
+                : false;
+            if (totalCost || usingSubscription) {
+                const costStr = `$${totalCost.toFixed(3)}${usingSubscription ? ' (sub)' : ''}`;
+                statsParts.push(costStr);
+            }
+        }
+        // Colorize context percentage based on usage AND query count.
+        // For Shortcut credit users: more aggressive thresholds (50%/75%) + query-based triggers.
+        // For non-credit users: original thresholds (70%/90%).
+        let contextPercentStr;
+        const contextPercentDisplay = contextPercent === '?' ? '? context' : `${contextPercent}% context`;
+        if (isShortcutCredits) {
+            // Context colored only by context usage %
+            if (contextPercentValue >= 75) {
+                contextPercentStr = theme.fg('error', contextPercentDisplay);
+            }
+            else if (contextPercentValue >= 50) {
+                contextPercentStr = theme.fg('warning', contextPercentDisplay);
+            }
+            else {
+                contextPercentStr = contextPercentDisplay;
+            }
+        }
+        else {
+            // Non-credit users: original thresholds
+            const fullDisplay = `${contextPercentDisplay} (auto)`;
+            if (contextPercentValue > 90) {
+                contextPercentStr = theme.fg('error', fullDisplay);
+            }
+            else if (contextPercentValue > 70) {
+                contextPercentStr = theme.fg('warning', fullDisplay);
+            }
+            else {
+                contextPercentStr = fullDisplay;
+            }
+        }
+        statsParts.push(contextPercentStr);
+        // Add query count for Shortcut credit users
+        if (isShortcutCredits) {
+            const queriesText = `${queryCount} queries`;
+            // Queries colored only by query count
+            let styledQueries;
+            if (queryCount > 15) {
+                styledQueries = theme.fg('error', queriesText);
+            }
+            else if (queryCount > 10) {
+                styledQueries = theme.fg('warning', queriesText);
+            }
+            else {
+                styledQueries = queriesText;
+            }
+            statsParts.push(styledQueries);
+        }
+        let statsLeft = statsParts.join('  ');
+        // Add model name on the right side, plus thinking level if model supports it
+        const modelName = state.model?.id || 'no-model';
+        let statsLeftWidth = visibleWidth(statsLeft);
+        // If statsLeft is too wide, truncate it
+        if (statsLeftWidth > width) {
+            // Truncate statsLeft to fit width (no room for right side)
+            const plainStatsLeft = statsLeft.replace(/\x1b\[[0-9;]*m/g, '');
+            statsLeft = `${plainStatsLeft.substring(0, width - 3)}...`;
+            statsLeftWidth = visibleWidth(statsLeft);
+        }
+        // Calculate available space for padding (minimum 2 spaces between stats and model)
+        const minPadding = 2;
+        // Add thinking level indicator if model supports reasoning
+        let rightSideWithoutProvider = modelName;
+        if (state.model?.reasoning) {
+            const thinkingLevel = state.thinkingLevel || 'off';
+            rightSideWithoutProvider = `${modelName} • thinking: ${thinkingLevel}`;
+        }
+        // Prepend the provider in parentheses if there are multiple providers and there's enough room
+        let rightSide = rightSideWithoutProvider;
+        if (this.footerData.getAvailableProviderCount() > 1 && state.model) {
+            rightSide = `(${state.model.provider}) ${rightSideWithoutProvider}`;
+            if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
+                // Too wide, fall back
+                rightSide = rightSideWithoutProvider;
+            }
+        }
+        const rightSideWidth = visibleWidth(rightSide);
+        const totalNeeded = statsLeftWidth + minPadding + rightSideWidth;
+        let statsLine;
+        if (totalNeeded <= width) {
+            // Both fit - add padding to right-align model
+            const padding = ' '.repeat(width - statsLeftWidth - rightSideWidth);
+            statsLine = statsLeft + padding + rightSide;
+        }
+        else {
+            // Need to truncate right side
+            const availableForRight = width - statsLeftWidth - minPadding;
+            if (availableForRight > 3) {
+                // Truncate to fit (strip ANSI codes for length calculation, then truncate raw string)
+                const plainRightSide = rightSide.replace(/\x1b\[[0-9;]*m/g, '');
+                const truncatedPlain = plainRightSide.substring(0, availableForRight);
+                // For simplicity, just use plain truncated version (loses color, but fits)
+                const padding = ' '.repeat(width - statsLeftWidth - truncatedPlain.length);
+                statsLine = statsLeft + padding + truncatedPlain;
+            }
+            else {
+                // Not enough space for right side at all
+                statsLine = statsLeft;
+            }
+        }
+        // Apply dim to non-credit parts. For credit users, statsLeft already has its own
+        // styling (tier colors for credits, theme colors for context). Only dim the
+        // right side (model name + padding).
+        // For non-credit users, dim everything as before.
+        let styledStatsLeft;
+        let styledRemainder;
+        const remainder = statsLine.slice(statsLeft.length); // padding + rightSide
+        if (isShortcutCredits) {
+            // Credits line already has ANSI styling — pass through as-is
+            styledStatsLeft = statsLeft;
+            styledRemainder = theme.fg('dim', remainder);
+        }
+        else {
+            styledStatsLeft = theme.fg('dim', statsLeft);
+            styledRemainder = theme.fg('dim', remainder);
+        }
+        // Build lines: separator, optional info line, stats
+        const separator = theme.fg('dim', '─'.repeat(width));
+        const lines = [separator];
+        if (infoLine) {
+            lines.push(theme.fg('dim', infoLine));
+        }
+        lines.push(styledStatsLeft + styledRemainder);
+        // SHORTCUT PATCH: render each extension status on its own line (for dev trace paths)
+        const extensionStatuses = this.footerData.getExtensionStatuses();
+        if (extensionStatuses.size > 0) {
+            const sortedStatuses = Array.from(extensionStatuses.entries())
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([, text]) => sanitizeStatusText(text));
+            for (const status of sortedStatuses) {
+                lines.push(truncateToWidth(theme.fg('dim', status), width, theme.fg('dim', '...')));
+            }
+        }
+        return lines;
+    }
+}
+//# sourceMappingURL=footer.js.map

package/dist/modes/interactive/components/index.js

@@ -0,0 +1,33 @@
+// UI Components for extensions
+export { ArminComponent } from './armin.js';
+export { AssistantMessageComponent } from './assistant-message.js';
+export { BashExecutionComponent } from './bash-execution.js';
+export { BorderedLoader } from './bordered-loader.js';
+export { BranchSummaryMessageComponent } from './branch-summary-message.js';
+export { CompactionSummaryMessageComponent } from './compaction-summary-message.js';
+export { CustomEditor } from './custom-editor.js';
+export { CustomMessageComponent } from './custom-message.js';
+export { DaxnutsComponent } from './daxnuts.js';
+export { renderDiff } from './diff.js';
+export { DynamicBorder } from './dynamic-border.js';
+export { ExtensionEditorComponent } from './extension-editor.js';
+export { ExtensionInputComponent } from './extension-input.js';
+export { ExtensionSelectorComponent } from './extension-selector.js';
+export { FooterComponent } from './footer.js';
+export { appKey, appKeyHint, editorKey, keyHint, rawKeyHint } from './keybinding-hints.js';
+export { LoginDialogComponent } from './login-dialog.js';
+export { ModelSelectorComponent } from './model-selector.js';
+export { OAuthSelectorComponent } from './oauth-selector.js';
+// SHORTCUT PATCH: removed ScopedModelsSelectorComponent export — scoped models removed
+export { SessionSelectorComponent } from './session-selector.js';
+export { SettingsSelectorComponent } from './settings-selector.js';
+export { ShowImagesSelectorComponent } from './show-images-selector.js';
+export { SkillInvocationMessageComponent } from './skill-invocation-message.js';
+export { ThemeSelectorComponent } from './theme-selector.js';
+export { ThinkingSelectorComponent } from './thinking-selector.js';
+export { ToolExecutionComponent } from './tool-execution.js';
+export { TreeSelectorComponent } from './tree-selector.js';
+export { UserMessageSelectorComponent } from './user-message-selector.js';
+export { UserMessageComponent } from './user-message.js';
+export { truncateToVisualLines } from './visual-truncate.js';
+//# sourceMappingURL=index.js.map

package/dist/modes/interactive/components/keybinding-hints.js

@@ -0,0 +1,61 @@
+/**
+ * Utilities for formatting keybinding hints in the UI.
+ */
+import { getEditorKeybindings } from '../../../tui/index.js';
+import { theme } from '../../../core/theme.js';
+/**
+ * Format keys array as display string (e.g., ["ctrl+c", "escape"] -> "ctrl+c/escape").
+ */
+function formatKeys(keys) {
+    if (keys.length === 0)
+        return '';
+    if (keys.length === 1)
+        return keys[0];
+    return keys.join('/');
+}
+/**
+ * Get display string for an editor action.
+ */
+export function editorKey(action) {
+    return formatKeys(getEditorKeybindings().getKeys(action));
+}
+/**
+ * Get display string for an app action.
+ */
+export function appKey(keybindings, action) {
+    return formatKeys(keybindings.getKeys(action));
+}
+/**
+ * Format a keybinding hint with consistent styling: dim key, muted description.
+ * Looks up the key from editor keybindings automatically.
+ *
+ * @param action - Editor action name (e.g., "selectConfirm", "expandTools")
+ * @param description - Description text (e.g., "to expand", "cancel")
+ * @returns Formatted string with dim key and muted description
+ */
+export function keyHint(action, description) {
+    return theme.fg('dim', editorKey(action)) + theme.fg('muted', ` ${description}`);
+}
+/**
+ * Format a keybinding hint for app-level actions.
+ * Requires the KeybindingsManager instance.
+ *
+ * @param keybindings - KeybindingsManager instance
+ * @param action - App action name (e.g., "interrupt", "externalEditor")
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export function appKeyHint(keybindings, action, description) {
+    return theme.fg('dim', appKey(keybindings, action)) + theme.fg('muted', ` ${description}`);
+}
+/**
+ * Format a raw key string with description (for non-configurable keys like ↑↓).
+ *
+ * @param key - Raw key string
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export function rawKeyHint(key, description) {
+    return theme.fg('dim', key) + theme.fg('muted', ` ${description}`);
+}
+//# sourceMappingURL=keybinding-hints.js.map

package/dist/modes/interactive/components/layout.js

@@ -0,0 +1,64 @@
+import { Container } from '../../../tui/index.js';
+import { theme } from '../../../core/theme.js';
+/** Standard horizontal padding for content that uses its own background (e.g. custom messages). */
+export const CONTENT_PAD_X = 1;
+/** Standard vertical padding (0 = no extra blank lines above/below). */
+export const CONTENT_PAD_Y = 0;
+/** Visible character width of the message prefix (symbol + trailing space). */
+export const PREFIX_WIDTH = 2;
+// ── Prefix generators ────────────────────────────────────────────────
+export function userPrefix() {
+    return `${theme.fg('accent', '❯')} `;
+}
+export function assistantPrefix() {
+    return `${theme.fg('text', '●')} `;
+}
+export function toolPrefix(isPending, isError, blinkOn) {
+    if (isPending) {
+        return blinkOn ? `${theme.fg('warning', '●')} ` : `${theme.fg('dim', '●')} `;
+    }
+    return isError ? `${theme.fg('error', '●')} ` : `${theme.fg('success', '●')} `;
+}
+// ── Layout utilities ─────────────────────────────────────────────────
+/**
+ * Prefix the first visible line of rendered output with a symbol,
+ * and indent all subsequent lines to maintain alignment.
+ *
+ * Lines before the first visible content (e.g. spacer blanks) are left untouched.
+ */
+export function prefixLines(lines, prefix) {
+    const indent = ' '.repeat(PREFIX_WIDTH);
+    let firstDone = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (!firstDone) {
+            if (lines[i].trim()) {
+                lines[i] = prefix + lines[i];
+                firstDone = true;
+            }
+        }
+        else {
+            lines[i] = indent + lines[i];
+        }
+    }
+    return lines;
+}
+/**
+ * A Container that prefixes children's rendered output with a symbol.
+ *
+ * Use when only *part* of a component's output should be prefixed
+ * (e.g. UserMessage wraps the text portion but not the annotation above it).
+ */
+export class PrefixedContainer extends Container {
+    prefix;
+    constructor(prefix) {
+        super();
+        this.prefix = prefix;
+    }
+    setPrefix(prefix) {
+        this.prefix = prefix;
+    }
+    render(width) {
+        return prefixLines(super.render(width - PREFIX_WIDTH), this.prefix);
+    }
+}
+//# sourceMappingURL=layout.js.map

package/dist/modes/interactive/components/login-dialog.js

@@ -0,0 +1,148 @@
+import { getOAuthProviders } from '@mariozechner/pi-ai';
+import { Container, getEditorKeybindings, Input, Spacer, Text } from '../../../tui/index.js';
+import { exec } from 'child_process';
+import { theme } from '../../../core/theme.js';
+import { DynamicBorder } from './dynamic-border.js';
+import { keyHint } from './keybinding-hints.js';
+/**
+ * Login dialog component - replaces editor during OAuth login flow
+ */
+export class LoginDialogComponent extends Container {
+    onComplete;
+    contentContainer;
+    input;
+    tui;
+    abortController = new AbortController();
+    inputResolver;
+    inputRejecter;
+    // Focusable implementation - propagate to input for IME cursor positioning
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.input.focused = value;
+    }
+    constructor(tui, providerId, onComplete) {
+        super();
+        this.onComplete = onComplete;
+        this.tui = tui;
+        const providerInfo = getOAuthProviders().find((p) => p.id === providerId);
+        const providerName = providerInfo?.name || providerId;
+        // Top border
+        this.addChild(new DynamicBorder());
+        // Title
+        this.addChild(new Text(theme.fg('warning', `Login to ${providerName}`), 1, 0));
+        // Dynamic content area
+        this.contentContainer = new Container();
+        this.addChild(this.contentContainer);
+        // Input (always present, used when needed)
+        this.input = new Input();
+        this.input.onSubmit = () => {
+            if (this.inputResolver) {
+                this.inputResolver(this.input.getValue());
+                this.inputResolver = undefined;
+                this.inputRejecter = undefined;
+            }
+        };
+        this.input.onEscape = () => {
+            this.cancel();
+        };
+        // Bottom border
+        this.addChild(new DynamicBorder());
+    }
+    get signal() {
+        return this.abortController.signal;
+    }
+    cancel() {
+        this.abortController.abort();
+        if (this.inputRejecter) {
+            this.inputRejecter(new Error('Login cancelled'));
+            this.inputResolver = undefined;
+            this.inputRejecter = undefined;
+        }
+        this.onComplete(false, 'Login cancelled');
+    }
+    /**
+     * Called by onAuth callback - show URL and optional instructions
+     */
+    showAuth(url, instructions) {
+        this.contentContainer.clear();
+        this.contentContainer.addChild(new Spacer(1));
+        this.contentContainer.addChild(new Text(theme.fg('accent', url), 1, 0));
+        const clickHint = process.platform === 'darwin' ? 'Cmd+click to open' : 'Ctrl+click to open';
+        const hyperlink = `\x1b]8;;${url}\x07${clickHint}\x1b]8;;\x07`;
+        this.contentContainer.addChild(new Text(theme.fg('dim', hyperlink), 1, 0));
+        if (instructions) {
+            this.contentContainer.addChild(new Spacer(1));
+            this.contentContainer.addChild(new Text(theme.fg('warning', instructions), 1, 0));
+        }
+        // Try to open browser
+        // On Windows, 'start' needs an empty title ("") before the URL, otherwise
+        // it interprets the URL as a window title and opens a blank cmd window.
+        const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        const cmd = process.platform === 'win32' ? `${openCmd} "" "${url}"` : `${openCmd} "${url}"`;
+        exec(cmd);
+        this.tui.requestRender();
+    }
+    /**
+     * Show input for manual code/URL entry (for callback server providers)
+     */
+    showManualInput(prompt) {
+        this.contentContainer.addChild(new Spacer(1));
+        this.contentContainer.addChild(new Text(theme.fg('dim', prompt), 1, 0));
+        this.contentContainer.addChild(this.input);
+        this.contentContainer.addChild(new Text(`(${keyHint('selectCancel', 'to cancel')})`, 1, 0));
+        this.tui.requestRender();
+        return new Promise((resolve, reject) => {
+            this.inputResolver = resolve;
+            this.inputRejecter = reject;
+        });
+    }
+    /**
+     * Called by onPrompt callback - show prompt and wait for input
+     * Note: Does NOT clear content, appends to existing (preserves URL from showAuth)
+     */
+    showPrompt(message, placeholder) {
+        this.contentContainer.addChild(new Spacer(1));
+        this.contentContainer.addChild(new Text(theme.fg('text', message), 1, 0));
+        if (placeholder) {
+            this.contentContainer.addChild(new Text(theme.fg('dim', `e.g., ${placeholder}`), 1, 0));
+        }
+        this.contentContainer.addChild(this.input);
+        this.contentContainer.addChild(new Text(`(${keyHint('selectCancel', 'to cancel,')} ${keyHint('selectConfirm', 'to submit')})`, 1, 0));
+        this.input.setValue('');
+        this.tui.requestRender();
+        return new Promise((resolve, reject) => {
+            this.inputResolver = resolve;
+            this.inputRejecter = reject;
+        });
+    }
+    /**
+     * Show waiting message (for polling flows like GitHub Copilot)
+     */
+    showWaiting(message) {
+        this.contentContainer.addChild(new Spacer(1));
+        this.contentContainer.addChild(new Text(theme.fg('dim', message), 1, 0));
+        this.contentContainer.addChild(new Text(`(${keyHint('selectCancel', 'to cancel')})`, 1, 0));
+        this.tui.requestRender();
+    }
+    /**
+     * Called by onProgress callback
+     */
+    showProgress(message) {
+        this.contentContainer.addChild(new Text(theme.fg('dim', message), 1, 0));
+        this.tui.requestRender();
+    }
+    handleInput(data) {
+        const kb = getEditorKeybindings();
+        if (kb.matches(data, 'selectCancel')) {
+            this.cancel();
+            return;
+        }
+        // Pass to input
+        this.input.handleInput(data);
+    }
+}
+//# sourceMappingURL=login-dialog.js.map