@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/components/DialogManager.js

@@ -0,0 +1,162 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import { IdeIntegrationNudge } from '../IdeIntegrationNudge.js';
+import { LoopDetectionConfirmation } from './LoopDetectionConfirmation.js';
+import { FolderTrustDialog } from './FolderTrustDialog.js';
+import { ConsentPrompt } from './ConsentPrompt.js';
+import { ThemeDialog } from './ThemeDialog.js';
+import { SettingsDialog } from './SettingsDialog.js';
+import { AuthInProgress } from '../auth/AuthInProgress.js';
+import { AuthDialog } from '../auth/AuthDialog.js';
+import { BannedAccountDialog } from '../auth/BannedAccountDialog.js';
+import { ApiAuthDialog } from '../auth/ApiAuthDialog.js';
+import { EditorSettingsDialog } from './EditorSettingsDialog.js';
+import { PrivacyNotice } from '../privacy/PrivacyNotice.js';
+import { ProQuotaDialog } from './ProQuotaDialog.js';
+import { ValidationDialog } from './ValidationDialog.js';
+import { OverageMenuDialog } from './OverageMenuDialog.js';
+import { EmptyWalletDialog } from './EmptyWalletDialog.js';
+import { relaunchApp } from '../../utils/processUtils.js';
+import { SessionBrowser } from './SessionBrowser.js';
+import { PermissionsModifyTrustDialog } from './PermissionsModifyTrustDialog.js';
+import { ModelDialog } from './ModelDialog.js';
+import { VoiceModelDialog } from './VoiceModelDialog.js';
+import { theme } from '../semantic-colors.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { useQuotaState } from '../contexts/QuotaContext.js';
+import { useUIActions } from '../contexts/UIActionsContext.js';
+import { useConfig } from '../contexts/ConfigContext.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import process from 'node:process';
+import { AdminSettingsChangedDialog } from './AdminSettingsChangedDialog.js';
+import { IdeTrustChangeDialog } from './IdeTrustChangeDialog.js';
+import { NewAgentsNotification } from './NewAgentsNotification.js';
+import { AgentConfigDialog } from './AgentConfigDialog.js';
+import { PolicyUpdateDialog } from './PolicyUpdateDialog.js';
+import { LoginRestartDialog } from '../auth/LoginRestartDialog.js';
+// Props for DialogManager
+export const DialogManager = ({ addItem, terminalWidth, }) => {
+    const config = useConfig();
+    const settings = useSettings();
+    const uiState = useUIState();
+    const quotaState = useQuotaState();
+    const uiActions = useUIActions();
+    const { constrainHeight, terminalHeight, staticExtraHeight, terminalWidth: uiTerminalWidth, } = uiState;
+    if (uiState.adminSettingsChanged) {
+        return _jsx(AdminSettingsChangedDialog, {});
+    }
+    if (uiState.showIdeRestartPrompt) {
+        return _jsx(IdeTrustChangeDialog, { reason: uiState.ideTrustRestartReason });
+    }
+    if (uiState.newAgents) {
+        return (_jsx(NewAgentsNotification, { agents: uiState.newAgents, onSelect: uiActions.handleNewAgentsSelect }));
+    }
+    if (quotaState.proQuotaRequest) {
+        return (_jsx(ProQuotaDialog, { failedModel: quotaState.proQuotaRequest.failedModel, fallbackModel: quotaState.proQuotaRequest.fallbackModel, message: quotaState.proQuotaRequest.message, isTerminalQuotaError: quotaState.proQuotaRequest.isTerminalQuotaError, isModelNotFoundError: !!quotaState.proQuotaRequest.isModelNotFoundError, authType: quotaState.proQuotaRequest.authType, tierName: config?.getUserTierName(), onChoice: uiActions.handleProQuotaChoice }));
+    }
+    if (quotaState.validationRequest) {
+        return (_jsx(ValidationDialog, { validationLink: quotaState.validationRequest.validationLink, validationDescription: quotaState.validationRequest.validationDescription, learnMoreUrl: quotaState.validationRequest.learnMoreUrl, onChoice: uiActions.handleValidationChoice }));
+    }
+    if (quotaState.overageMenuRequest) {
+        return (_jsx(OverageMenuDialog, { failedModel: quotaState.overageMenuRequest.failedModel, fallbackModel: quotaState.overageMenuRequest.fallbackModel, resetTime: quotaState.overageMenuRequest.resetTime, creditBalance: quotaState.overageMenuRequest.creditBalance, onChoice: uiActions.handleOverageMenuChoice }));
+    }
+    if (quotaState.emptyWalletRequest) {
+        return (_jsx(EmptyWalletDialog, { failedModel: quotaState.emptyWalletRequest.failedModel, fallbackModel: quotaState.emptyWalletRequest.fallbackModel, resetTime: quotaState.emptyWalletRequest.resetTime, onGetCredits: quotaState.emptyWalletRequest.onGetCredits, onChoice: uiActions.handleEmptyWalletChoice }));
+    }
+    if (uiState.shouldShowIdePrompt) {
+        return (_jsx(IdeIntegrationNudge, { ide: uiState.currentIDE, onComplete: uiActions.handleIdePromptComplete }));
+    }
+    if (uiState.isFolderTrustDialogOpen) {
+        return (_jsx(FolderTrustDialog, { onSelect: uiActions.handleFolderTrustSelect, isRestarting: uiState.isRestarting, discoveryResults: uiState.folderDiscoveryResults }));
+    }
+    if (uiState.isPolicyUpdateDialogOpen) {
+        return (_jsx(PolicyUpdateDialog, { config: config, request: uiState.policyUpdateConfirmationRequest, onClose: () => uiActions.setIsPolicyUpdateDialogOpen(false) }));
+    }
+    if (uiState.loopDetectionConfirmationRequest) {
+        return (_jsx(LoopDetectionConfirmation, { onComplete: uiState.loopDetectionConfirmationRequest.onComplete }));
+    }
+    if (uiState.permissionConfirmationRequest) {
+        const files = uiState.permissionConfirmationRequest.files;
+        const filesList = files.map((f) => `- ${f}`).join('\n');
+        return (_jsx(ConsentPrompt, { prompt: `The following files are outside your workspace:\n\n${filesList}\n\nDo you want to allow this read?`, onConfirm: (allowed) => {
+                uiState.permissionConfirmationRequest?.onComplete({ allowed });
+            }, terminalWidth: terminalWidth }));
+    }
+    // commandConfirmationRequest and authConsentRequest are kept separate
+    // to avoid focus deadlocks and state race conditions between the
+    // synchronous command loop and the asynchronous auth flow.
+    if (uiState.commandConfirmationRequest) {
+        return (_jsx(ConsentPrompt, { prompt: uiState.commandConfirmationRequest.prompt, onConfirm: uiState.commandConfirmationRequest.onConfirm, terminalWidth: terminalWidth }));
+    }
+    if (uiState.authConsentRequest) {
+        return (_jsx(ConsentPrompt, { prompt: uiState.authConsentRequest.prompt, onConfirm: uiState.authConsentRequest.onConfirm, terminalWidth: terminalWidth }));
+    }
+    if (uiState.confirmUpdateExtensionRequests.length > 0) {
+        const request = uiState.confirmUpdateExtensionRequests[0];
+        return (_jsx(ConsentPrompt, { prompt: request.prompt, onConfirm: request.onConfirm, terminalWidth: terminalWidth }));
+    }
+    if (uiState.isThemeDialogOpen) {
+        return (_jsxs(Box, { flexDirection: "column", children: [uiState.themeError && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.status.error, children: uiState.themeError }) })), _jsx(ThemeDialog, { onSelect: uiActions.handleThemeSelect, onCancel: uiActions.closeThemeDialog, onHighlight: uiActions.handleThemeHighlight, settings: settings, availableTerminalHeight: constrainHeight ? terminalHeight - staticExtraHeight : undefined, terminalWidth: uiTerminalWidth })] }));
+    }
+    if (uiState.isSettingsDialogOpen) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(SettingsDialog, { onSelect: () => uiActions.closeSettingsDialog(), onRestartRequest: relaunchApp, availableTerminalHeight: terminalHeight - staticExtraHeight }) }));
+    }
+    if (uiState.isModelDialogOpen) {
+        return _jsx(ModelDialog, { onClose: uiActions.closeModelDialog });
+    }
+    if (uiState.isVoiceModelDialogOpen) {
+        return _jsx(VoiceModelDialog, { onClose: uiActions.closeVoiceModelDialog });
+    }
+    if (uiState.isAgentConfigDialogOpen &&
+        uiState.selectedAgentName &&
+        uiState.selectedAgentDisplayName &&
+        uiState.selectedAgentDefinition) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(AgentConfigDialog, { agentName: uiState.selectedAgentName, displayName: uiState.selectedAgentDisplayName, definition: uiState.selectedAgentDefinition, settings: settings, availableTerminalHeight: terminalHeight - staticExtraHeight, onClose: uiActions.closeAgentConfigDialog, onSave: async () => {
+                    // Reload agent registry to pick up changes
+                    const agentRegistry = config?.getAgentRegistry();
+                    if (agentRegistry) {
+                        await agentRegistry.reload();
+                    }
+                } }) }));
+    }
+    if (uiState.accountSuspensionInfo) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(BannedAccountDialog, { accountSuspensionInfo: uiState.accountSuspensionInfo, onExit: () => {
+                    process.exit(1);
+                }, onChangeAuth: () => {
+                    uiActions.clearAccountSuspension();
+                } }) }));
+    }
+    if (uiState.isAuthenticating) {
+        return (_jsx(AuthInProgress, { onTimeout: () => {
+                uiActions.onAuthError('Authentication cancelled.');
+            } }));
+    }
+    if (uiState.isAwaitingApiKeyInput) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(ApiAuthDialog, { onSubmit: uiActions.handleApiKeySubmit, onCancel: uiActions.handleApiKeyCancel, error: uiState.authError, defaultValue: uiState.apiKeyDefaultValue }, uiState.apiKeyDefaultValue) }));
+    }
+    if (uiState.isAwaitingLoginRestart) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(LoginRestartDialog, { onDismiss: uiActions.dismissLoginRestart, config: config, message: uiState.loginRestartMessage }) }));
+    }
+    if (uiState.isAuthDialogOpen) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(AuthDialog, { config: config, settings: settings, setAuthState: uiActions.setAuthState, authError: uiState.authError, onAuthError: uiActions.onAuthError, setAuthContext: uiActions.setAuthContext }) }));
+    }
+    if (uiState.isEditorDialogOpen) {
+        return (_jsxs(Box, { flexDirection: "column", children: [uiState.editorError && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.status.error, children: uiState.editorError }) })), _jsx(EditorSettingsDialog, { onSelect: uiActions.handleEditorSelect, settings: settings, onExit: uiActions.exitEditorDialog })] }));
+    }
+    if (uiState.showPrivacyNotice) {
+        return (_jsx(PrivacyNotice, { onExit: () => uiActions.exitPrivacyNotice(), config: config }));
+    }
+    if (uiState.isSessionBrowserOpen) {
+        return (_jsx(SessionBrowser, { config: config, onResumeSession: uiActions.handleResumeSession, onDeleteSession: uiActions.handleDeleteSession, onExit: uiActions.closeSessionBrowser }));
+    }
+    if (uiState.isPermissionsDialogOpen) {
+        return (_jsx(PermissionsModifyTrustDialog, { onExit: uiActions.closePermissionsDialog, addItem: addItem, targetDirectory: uiState.permissionsDialogProps?.targetDirectory }));
+    }
+    return null;
+};

package/dist/ui/components/EditorSettingsDialog.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { editorSettingsManager, } from '../editors/editorSettingsManager.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import { SettingScope, } from '../../config/settings.js';
+import { isEditorAvailable, EDITOR_DISPLAY_NAMES, coreEvents, } from '@google/gemini-cli-core';
+import { useKeypress } from '../hooks/useKeypress.js';
+export function EditorSettingsDialog({ onSelect, settings, onExit, }) {
+    const [selectedScope, setSelectedScope] = useState(SettingScope.User);
+    const [focusedSection, setFocusedSection] = useState('editor');
+    useKeypress((key) => {
+        if (key.name === 'tab') {
+            setFocusedSection((prev) => (prev === 'editor' ? 'scope' : 'editor'));
+            return true;
+        }
+        if (key.name === 'escape') {
+            onExit();
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const editorItems = editorSettingsManager.getAvailableEditorDisplays();
+    const currentPreference = settings.forScope(selectedScope).settings.general?.preferredEditor;
+    let editorIndex = currentPreference
+        ? editorItems.findIndex((item) => item.type === currentPreference)
+        : 0;
+    const isUnsupportedEditor = editorIndex === -1;
+    if (isUnsupportedEditor) {
+        editorIndex = 0;
+    }
+    useEffect(() => {
+        if (isUnsupportedEditor && currentPreference) {
+            coreEvents.emitFeedback('error', `Editor is not supported: ${currentPreference}`);
+        }
+    }, [isUnsupportedEditor, currentPreference]);
+    const scopeItems = [
+        {
+            label: 'User Settings',
+            value: SettingScope.User,
+            key: SettingScope.User,
+        },
+        {
+            label: 'Workspace Settings',
+            value: SettingScope.Workspace,
+            key: SettingScope.Workspace,
+        },
+    ];
+    const handleEditorSelect = (editorType) => {
+        if (editorType === 'not_set') {
+            onSelect(undefined, selectedScope);
+            return;
+        }
+        onSelect(editorType, selectedScope);
+    };
+    const handleScopeSelect = (scope) => {
+        setSelectedScope(scope);
+        setFocusedSection('editor');
+    };
+    let otherScopeModifiedMessage = '';
+    const otherScope = selectedScope === SettingScope.User
+        ? SettingScope.Workspace
+        : SettingScope.User;
+    if (settings.forScope(otherScope).settings.general?.preferredEditor !==
+        undefined) {
+        otherScopeModifiedMessage =
+            settings.forScope(selectedScope).settings.general?.preferredEditor !==
+                undefined
+                ? `(Also modified in ${otherScope})`
+                : `(Modified in ${otherScope})`;
+    }
+    let mergedEditorName = 'None';
+    if (settings.merged.general.preferredEditor &&
+        isEditorAvailable(settings.merged.general.preferredEditor)) {
+        mergedEditorName =
+            EDITOR_DISPLAY_NAMES[settings.merged.general.preferredEditor];
+    }
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "row", padding: 1, width: "100%", children: [_jsxs(Box, { flexDirection: "column", width: "45%", paddingRight: 2, children: [_jsxs(Text, { bold: focusedSection === 'editor', children: [focusedSection === 'editor' ? '> ' : '  ', "Select Editor", ' ', _jsx(Text, { color: theme.text.secondary, children: otherScopeModifiedMessage })] }), _jsx(RadioButtonSelect, { items: editorItems.map((item) => ({
+                            label: item.name,
+                            value: item.type,
+                            disabled: item.disabled,
+                            key: item.type,
+                        })), initialIndex: editorIndex, onSelect: handleEditorSelect, isFocused: focusedSection === 'editor', maxItemsToShow: editorItems.length }, selectedScope), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { bold: focusedSection === 'scope', children: [focusedSection === 'scope' ? '> ' : '  ', "Apply To"] }), _jsx(RadioButtonSelect, { items: scopeItems, initialIndex: 0, onSelect: handleScopeSelect, isFocused: focusedSection === 'scope' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.secondary, children: "(Use Enter to select, Tab to change focus, Esc to close)" }) })] }), _jsxs(Box, { flexDirection: "column", width: "55%", paddingLeft: 2, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "Editor Preference" }), _jsxs(Box, { flexDirection: "column", gap: 1, marginTop: 1, children: [_jsx(Text, { color: theme.text.secondary, children: "These editors are currently supported. Please note that some editors cannot be used in sandbox mode." }), _jsxs(Text, { color: theme.text.secondary, children: ["Your preferred editor is:", ' ', _jsx(Text, { color: mergedEditorName === 'None'
+                                            ? theme.status.error
+                                            : theme.text.link, bold: true, children: mergedEditorName }), "."] })] })] })] }));
+}

package/dist/ui/components/EmptyWalletDialog.js

@@ -0,0 +1,33 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import { theme } from '../semantic-colors.js';
+export function EmptyWalletDialog({ failedModel, fallbackModel, resetTime, onGetCredits, onChoice, }) {
+    const items = [
+        {
+            label: 'Get AI Credits - Open browser to purchase credits',
+            value: 'get_credits',
+            key: 'get_credits',
+        },
+    ];
+    if (fallbackModel) {
+        items.push({
+            label: `Switch to ${fallbackModel}`,
+            value: 'use_fallback',
+            key: 'use_fallback',
+        });
+    }
+    items.push({
+        label: 'Stop - Abort request',
+        value: 'stop',
+        key: 'stop',
+    });
+    const handleSelect = (choice) => {
+        if (choice === 'get_credits') {
+            onGetCredits?.();
+        }
+        onChoice(choice);
+    };
+    return (_jsxs(Box, { borderStyle: "round", flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.status.warning, children: ["Usage limit reached for ", failedModel, "."] }), resetTime && _jsxs(Text, { children: ["Access resets at ", resetTime, "."] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, color: theme.text.accent, children: "/stats" }), ' ', "model for usage details"] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, color: theme.text.accent, children: "/model" }), ' ', "to switch models."] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, color: theme.text.accent, children: "/auth" }), ' ', "to switch to API key."] })] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "To continue using this model now, purchase more AI Credits." }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Newly purchased AI credits may take a few minutes to update." }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How would you like to proceed?" }) }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: _jsx(RadioButtonSelect, { items: items, onSelect: handleSelect }) })] }));
+}

package/dist/ui/components/ExitPlanModeDialog.js

@@ -0,0 +1,179 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useCallback } from 'react';
+import { Box, Text, useStdin } from 'ink';
+;
+import { ApprovalMode, validatePlanPath, validatePlanContent, QuestionType, processSingleFileContent, debugLogger, } from '@google/gemini-cli-core';
+import { theme } from '../semantic-colors.js';
+import { useConfig } from '../contexts/ConfigContext.js';
+import { AskUserDialog } from './AskUserDialog.js';
+import { openFileInEditor } from '../utils/editorUtils.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { Command } from '../key/keyMatchers.js';
+import { formatCommand } from '../key/keybindingUtils.js';
+import { useKeyMatchers } from '../hooks/useKeyMatchers.js';
+import { appEvents, AppEvent, TransientMessageType, } from '../../utils/events.js';
+var PlanStatus;
+(function (PlanStatus) {
+    PlanStatus["Loading"] = "loading";
+    PlanStatus["Loaded"] = "loaded";
+    PlanStatus["Error"] = "error";
+})(PlanStatus || (PlanStatus = {}));
+var ApprovalOption;
+(function (ApprovalOption) {
+    ApprovalOption["Auto"] = "Yes, automatically accept edits";
+    ApprovalOption["Manual"] = "Yes, manually accept edits";
+})(ApprovalOption || (ApprovalOption = {}));
+/**
+ * A tiny component for loading and error states with consistent styling.
+ */
+const StatusMessage = ({ children }) => _jsx(Box, { paddingX: 1, children: children });
+function usePlanContent(planPath, config) {
+    const [version, setVersion] = useState(0);
+    const [state, setState] = useState({
+        status: PlanStatus.Loading,
+    });
+    const refresh = useCallback(() => {
+        setVersion((v) => v + 1);
+    }, []);
+    useEffect(() => {
+        let ignore = false;
+        setState({ status: PlanStatus.Loading });
+        const load = async () => {
+            try {
+                const pathError = await validatePlanPath(planPath, config.storage.getPlansDir(), config.getProjectRoot());
+                if (ignore)
+                    return;
+                if (pathError) {
+                    setState({ status: PlanStatus.Error, error: pathError });
+                    return;
+                }
+                const contentError = await validatePlanContent(planPath);
+                if (ignore)
+                    return;
+                if (contentError) {
+                    setState({ status: PlanStatus.Error, error: contentError });
+                    return;
+                }
+                const result = await processSingleFileContent(planPath, config.storage.getPlansDir(), config.getFileSystemService());
+                if (ignore)
+                    return;
+                if (result.error) {
+                    setState({ status: PlanStatus.Error, error: result.error });
+                    return;
+                }
+                if (typeof result.llmContent !== 'string') {
+                    setState({
+                        status: PlanStatus.Error,
+                        error: 'Plan file format not supported (binary or image).',
+                    });
+                    return;
+                }
+                const content = result.llmContent;
+                if (!content) {
+                    setState({ status: PlanStatus.Error, error: 'Plan file is empty.' });
+                    return;
+                }
+                setState({ status: PlanStatus.Loaded, content });
+            }
+            catch (err) {
+                if (ignore)
+                    return;
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                setState({ status: PlanStatus.Error, error: errorMessage });
+            }
+        };
+        void load();
+        return () => {
+            ignore = true;
+        };
+    }, [planPath, config, version]);
+    return { ...state, refresh };
+}
+export const ExitPlanModeDialog = ({ planPath, onApprove, onFeedback, onCancel, getPreferredEditor, width, availableHeight, }) => {
+    const keyMatchers = useKeyMatchers();
+    const config = useConfig();
+    const { stdin, setRawMode } = useStdin();
+    const planState = usePlanContent(planPath, config);
+    const { refresh } = planState;
+    const [showLoading, setShowLoading] = useState(false);
+    const handleOpenEditor = useCallback(async () => {
+        try {
+            await openFileInEditor(planPath, stdin, setRawMode, getPreferredEditor());
+            onFeedback('I have edited the plan or annotated it with feedback. Review the edited plan, update if necessary, and present it again for approval.');
+            refresh();
+        }
+        catch (err) {
+            debugLogger.error('Failed to open plan in editor:', err);
+        }
+    }, [planPath, stdin, setRawMode, getPreferredEditor, refresh, onFeedback]);
+    useKeypress((key) => {
+        if (keyMatchers[Command.OPEN_EXTERNAL_EDITOR](key)) {
+            void handleOpenEditor();
+            return true;
+        }
+        if (keyMatchers[Command.DEPRECATED_OPEN_EXTERNAL_EDITOR](key)) {
+            const cmdKey = formatCommand(Command.OPEN_EXTERNAL_EDITOR);
+            appEvents.emit(AppEvent.TransientMessage, {
+                message: `Use ${cmdKey} to open the external editor.`,
+                type: TransientMessageType.Hint,
+            });
+            return true;
+        }
+        return false;
+    }, { isActive: true, priority: true });
+    useEffect(() => {
+        if (planState.status !== PlanStatus.Loading) {
+            setShowLoading(false);
+            return;
+        }
+        const timer = setTimeout(() => {
+            setShowLoading(true);
+        }, 200);
+        return () => clearTimeout(timer);
+    }, [planState.status]);
+    if (planState.status === PlanStatus.Loading) {
+        if (!showLoading) {
+            return null;
+        }
+        return (_jsx(StatusMessage, { children: _jsx(Text, { color: theme.text.secondary, italic: true, children: "Loading plan..." }) }));
+    }
+    if (planState.status === PlanStatus.Error) {
+        return (_jsx(StatusMessage, { children: _jsxs(Text, { color: theme.status.error, children: ["Error reading plan: ", planState.error] }) }));
+    }
+    const planContent = planState.content?.trim();
+    if (!planContent) {
+        return (_jsx(StatusMessage, { children: _jsx(Text, { color: theme.status.error, children: "Error: Plan content is empty." }) }));
+    }
+    const editHint = formatCommand(Command.OPEN_EXTERNAL_EDITOR);
+    return (_jsx(Box, { flexDirection: "column", width: width, children: _jsx(AskUserDialog, { questions: [
+                {
+                    type: QuestionType.CHOICE,
+                    header: 'Approval',
+                    question: planContent,
+                    options: [
+                        {
+                            label: ApprovalOption.Auto,
+                            description: 'Approves plan and allows tools to run automatically',
+                        },
+                        {
+                            label: ApprovalOption.Manual,
+                            description: 'Approves plan but requires confirmation for each tool',
+                        },
+                    ],
+                    placeholder: 'Type your feedback...',
+                    multiSelect: false,
+                    unconstrainedHeight: false,
+                },
+            ], onSubmit: (answers) => {
+                const answer = answers['0'];
+                if (answer === ApprovalOption.Auto) {
+                    onApprove(ApprovalMode.AUTO_EDIT);
+                }
+                else if (answer === ApprovalOption.Manual) {
+                    onApprove(ApprovalMode.DEFAULT);
+                }
+                else if (answer) {
+                    onFeedback(answer);
+                }
+            }, onCancel: onCancel, width: width, availableHeight: availableHeight, extraParts: [`${editHint} to edit plan`] }) }));
+};

package/dist/ui/components/ExitWarning.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { useUIState } from '../contexts/UIStateContext.js';
+import { theme } from '../semantic-colors.js';
+export const ExitWarning = () => {
+    const uiState = useUIState();
+    return (_jsxs(_Fragment, { children: [uiState.dialogsVisible && uiState.ctrlCPressedOnce && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.warning, children: "Press Ctrl+C again to exit." }) })), uiState.dialogsVisible && uiState.ctrlDPressedOnce && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.warning, children: "Press Ctrl+D again to exit." }) }))] }));
+};

package/dist/ui/components/FolderTrustDialog.js

@@ -0,0 +1,118 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import { useEffect, useState, useCallback } from 'react';
+import { theme } from '../semantic-colors.js';
+import stripAnsi from 'strip-ansi';
+import { RadioButtonSelect, } from './shared/RadioButtonSelect.js';
+import { MaxSizedBox } from './shared/MaxSizedBox.js';
+import { Scrollable } from './shared/Scrollable.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import * as process from 'node:process';
+import * as path from 'node:path';
+import { relaunchApp } from '../../utils/processUtils.js';
+import { runExitCleanup } from '../../utils/cleanup.js';
+import { ExitCodes, } from '@google/gemini-cli-core';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { useAlternateBuffer } from '../hooks/useAlternateBuffer.js';
+import { OverflowProvider } from '../contexts/OverflowContext.js';
+import { ShowMoreLines } from './ShowMoreLines.js';
+import { StickyHeader } from './StickyHeader.js';
+export var FolderTrustChoice;
+(function (FolderTrustChoice) {
+    FolderTrustChoice["TRUST_FOLDER"] = "trust_folder";
+    FolderTrustChoice["TRUST_PARENT"] = "trust_parent";
+    FolderTrustChoice["DO_NOT_TRUST"] = "do_not_trust";
+})(FolderTrustChoice || (FolderTrustChoice = {}));
+export const FolderTrustDialog = ({ onSelect, isRestarting, discoveryResults, }) => {
+    const [exiting, setExiting] = useState(false);
+    const { terminalHeight, terminalWidth, constrainHeight } = useUIState();
+    const isAlternateBuffer = useAlternateBuffer();
+    const isExpanded = !constrainHeight;
+    useEffect(() => {
+        let timer;
+        if (isRestarting) {
+            timer = setTimeout(relaunchApp, 250);
+        }
+        return () => {
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [isRestarting]);
+    const handleExit = useCallback(() => {
+        setExiting(true);
+        // Give time for the UI to render the exiting message
+        setTimeout(async () => {
+            await runExitCleanup();
+            process.exit(ExitCodes.FATAL_CANCELLATION_ERROR);
+        }, 100);
+    }, []);
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            handleExit();
+            return true;
+        }
+        return false;
+    }, { isActive: !isRestarting });
+    const dirName = path.basename(process.cwd());
+    const parentFolder = path.basename(path.dirname(process.cwd()));
+    const options = [
+        {
+            label: `Trust folder (${dirName})`,
+            value: FolderTrustChoice.TRUST_FOLDER,
+            key: `Trust folder (${dirName})`,
+        },
+        {
+            label: `Trust parent folder (${parentFolder})`,
+            value: FolderTrustChoice.TRUST_PARENT,
+            key: `Trust parent folder (${parentFolder})`,
+        },
+        {
+            label: "Don't trust",
+            value: FolderTrustChoice.DO_NOT_TRUST,
+            key: "Don't trust",
+        },
+    ];
+    const hasDiscovery = discoveryResults &&
+        (discoveryResults.commands.length > 0 ||
+            discoveryResults.mcps.length > 0 ||
+            discoveryResults.hooks.length > 0 ||
+            discoveryResults.skills.length > 0 ||
+            discoveryResults.settings.length > 0);
+    const hasWarnings = discoveryResults && discoveryResults.securityWarnings.length > 0;
+    const hasErrors = discoveryResults &&
+        discoveryResults.discoveryErrors &&
+        discoveryResults.discoveryErrors.length > 0;
+    const dialogWidth = terminalWidth - 2;
+    const borderColor = theme.status.warning;
+    // Header: 3 lines
+    // Options: options.length + 2 lines for margins
+    // Footer: 1 line
+    // Safety margin: 2 lines
+    const overhead = 3 + options.length + 2 + 1 + 2;
+    const scrollableHeight = Math.max(4, terminalHeight - overhead);
+    const groups = [
+        { label: 'Commands', items: discoveryResults?.commands ?? [] },
+        { label: 'MCP Servers', items: discoveryResults?.mcps ?? [] },
+        { label: 'Hooks', items: discoveryResults?.hooks ?? [] },
+        { label: 'Skills', items: discoveryResults?.skills ?? [] },
+        { label: 'Agents', items: discoveryResults?.agents ?? [] },
+        { label: 'Setting overrides', items: discoveryResults?.settings ?? [] },
+    ].filter((g) => g.items.length > 0);
+    const discoveryContent = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.text.primary, children: "Trusting a folder allows Gemini CLI to load its local configurations, including custom commands, hooks, MCP servers, agent skills, and settings. These configurations could execute code on your behalf or change the behavior of the CLI." }) }), hasErrors && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.status.error, bold: true, children: "\u274C Discovery Errors:" }), discoveryResults.discoveryErrors.map((error, i) => (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.status.error, children: ["\u2022 ", stripAnsi(error)] }) }, i)))] })), hasWarnings && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.status.warning, bold: true, children: "\u26A0\uFE0F Security Warnings:" }), discoveryResults.securityWarnings.map((warning, i) => (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.status.warning, children: ["\u2022 ", stripAnsi(warning)] }) }, i)))] })), hasDiscovery && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.text.primary, bold: true, children: "This folder contains:" }), groups.map((group) => (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Text, { color: theme.text.primary, bold: true, children: ["\u2022 ", group.label, " (", group.items.length, "):"] }), group.items.map((item, idx) => (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.text.primary, children: ["- ", stripAnsi(item)] }) }, idx)))] }, group.label)))] }))] }));
+    const title = (_jsx(Text, { bold: true, color: theme.text.primary, children: "Do you trust the files in this folder?" }));
+    const selectOptions = (_jsx(RadioButtonSelect, { items: options, onSelect: onSelect, isFocused: !isRestarting }));
+    const renderContent = () => {
+        if (isAlternateBuffer) {
+            return (_jsxs(Box, { flexDirection: "column", width: dialogWidth, children: [_jsx(StickyHeader, { width: dialogWidth, isFirst: true, borderColor: borderColor, borderDimColor: false, children: title }), _jsxs(Box, { flexDirection: "column", borderLeft: true, borderRight: true, borderColor: borderColor, borderStyle: "round", borderTop: false, borderBottom: false, width: dialogWidth, children: [_jsx(Scrollable, { hasFocus: !isRestarting, height: scrollableHeight, width: dialogWidth - 2, children: _jsx(Box, { flexDirection: "column", paddingX: 1, children: discoveryContent }) }), _jsx(Box, { paddingX: 1, marginY: 1, children: selectOptions })] }), _jsx(Box, { height: 0, width: dialogWidth, borderLeft: true, borderRight: true, borderTop: false, borderBottom: true, borderColor: borderColor, borderStyle: "round" })] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: title }), _jsx(MaxSizedBox, { maxHeight: isExpanded ? undefined : Math.max(4, terminalHeight - 12), overflowDirection: "bottom", children: discoveryContent }), _jsx(Box, { marginTop: 1, children: selectOptions })] }));
+    };
+    const content = (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Box, { flexDirection: "column", marginLeft: 1, marginRight: 1, children: renderContent() }), _jsx(Box, { paddingX: 2, marginBottom: 1, children: _jsx(ShowMoreLines, { constrainHeight: constrainHeight }) }), isRestarting && (_jsx(Box, { marginLeft: 1, marginTop: 1, children: _jsx(Text, { color: theme.status.warning, children: "Gemini CLI is restarting to apply the trust changes..." }) })), exiting && (_jsx(Box, { marginLeft: 1, marginTop: 1, children: _jsx(Text, { color: theme.status.warning, children: "A folder trust level must be selected to continue. Exiting since escape was pressed." }) }))] }));
+    return _jsx(OverflowProvider, { children: content });
+};