@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/components/ModelQuotaDisplay.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+;
+import { ProgressBar } from './ProgressBar.js';
+import { theme } from '../semantic-colors.js';
+import { formatResetTime } from '../utils/formatters.js';
+import { getDisplayString } from '@google/gemini-cli-core';
+import { useConfig } from '../contexts/ConfigContext.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+const ModelUsageRow = ({ row, availableWidth }) => {
+    const { terminalWidth } = useUIState();
+    const nameColumnWidth = 12;
+    const percentageWidth = 4;
+    const resetColumnWidth = 26;
+    const usedPercentage = row.usedPercentage;
+    const nameLabel = row.name;
+    const percentageLabel = `${usedPercentage.toFixed(0)}%`.padEnd(percentageWidth);
+    const resetLabel = row.resetTime
+        ? formatResetTime(row.resetTime, 'column')
+            .slice(0, resetColumnWidth)
+            .padEnd(resetColumnWidth)
+        : ''.padEnd(resetColumnWidth);
+    // Calculate the exact width of all fixed adjacent siblings
+    const nameColWidth = nameColumnWidth;
+    const percentColWidth = percentageWidth + 1; // width + marginLeft
+    const resetColWidth = resetColumnWidth + 1; // width + marginLeft
+    const fixedSiblingWidth = nameColWidth + percentColWidth + resetColWidth;
+    const calcWidth = availableWidth ?? terminalWidth;
+    const defaultPadding = availableWidth != null ? 0 : 4;
+    // Subtract fixed sibling widths from total width.
+    // We keep a small buffer (e.g., 3) to prevent edge-case wrapping.
+    const buffer = 3;
+    const barWidth = Math.max(0, calcWidth - defaultPadding - fixedSiblingWidth - buffer);
+    let percentageColor = theme.text.primary;
+    if (usedPercentage >= 100) {
+        percentageColor = theme.status.error;
+    }
+    else if (usedPercentage >= 80) {
+        percentageColor = theme.status.warning;
+    }
+    return (_jsxs(Box, { flexDirection: "row", width: "100%", children: [_jsx(Box, { width: nameColumnWidth, children: _jsx(Text, { color: theme.text.primary, wrap: "truncate-end", children: nameLabel }) }), _jsx(Box, { flexGrow: 1, children: _jsx(ProgressBar, { value: usedPercentage, width: barWidth }) }), _jsx(Box, { width: 4, marginLeft: 1, children: _jsx(Text, { color: percentageColor, children: percentageLabel }) }), _jsx(Box, { width: resetColumnWidth, marginLeft: 1, children: _jsx(Text, { color: theme.text.secondary, children: resetLabel.trim() ? `Resets: ${resetLabel}` : '' }) })] }));
+};
+export const ModelQuotaDisplay = ({ buckets, availableWidth, modelsToShow = ['all'], title = 'Model usage', }) => {
+    const config = useConfig();
+    const modelsWithQuotas = useMemo(() => {
+        if (!buckets)
+            return [];
+        let filteredBuckets = buckets.filter((b) => b.modelId && b.remainingFraction != null);
+        if (modelsToShow.includes('current')) {
+            const currentModel = config.getActiveModel?.() ?? config.getModel?.();
+            filteredBuckets = filteredBuckets.filter((b) => b.modelId === currentModel);
+        }
+        else if (!modelsToShow.includes('all')) {
+            filteredBuckets = filteredBuckets.filter((b) => b.modelId && modelsToShow.includes(b.modelId));
+        }
+        const groupedByTier = new Map();
+        filteredBuckets.forEach((b) => {
+            const modelId = b.modelId;
+            const remainingFraction = b.remainingFraction;
+            if (!modelId || remainingFraction == null)
+                return;
+            const tier = config?.modelConfigService?.getModelDefinition(modelId)?.tier;
+            const groupKey = tier ?? modelId;
+            const existing = groupedByTier.get(groupKey);
+            if (!existing || remainingFraction < existing.remainingFraction) {
+                const tierDisplayNames = {
+                    pro: 'Pro',
+                    flash: 'Flash',
+                    'flash-lite': 'Flash Lite',
+                };
+                const name = tier
+                    ? (tierDisplayNames[tier] ?? tier)
+                    : getDisplayString(modelId, config);
+                groupedByTier.set(groupKey, {
+                    modelId,
+                    remainingFraction,
+                    resetTime: b.resetTime,
+                    name,
+                });
+            }
+        });
+        return Array.from(groupedByTier.entries()).map(([key, data]) => {
+            const usedFraction = 1 - data.remainingFraction;
+            const usedPercentage = usedFraction * 100;
+            return {
+                modelId: key,
+                name: data.name,
+                usedFraction,
+                usedPercentage,
+                resetTime: data.resetTime,
+            };
+        });
+    }, [buckets, config, modelsToShow]);
+    if (modelsWithQuotas.length === 0) {
+        return null;
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: theme.border.default }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: theme.text.primary, children: title }) }), modelsWithQuotas.map((row) => (_jsx(ModelUsageRow, { row: row, availableWidth: availableWidth }, row.modelId)))] })] }));
+};

package/dist/ui/components/ModelStatsDisplay.js

@@ -0,0 +1,157 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { formatDuration } from '../utils/formatters.js';
+import { calculateAverageLatency, calculateCacheHitRate, calculateErrorRate, } from '../utils/computeStats.js';
+import { useSessionStats, } from '../contexts/SessionContext.js';
+import { Table } from './Table.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+import { getDisplayString, isAutoModel, LlmRole, } from '@google/gemini-cli-core';
+import { QuotaStatsInfo } from './QuotaStatsInfo.js';
+export const ModelStatsDisplay = ({ selectedAuthType, userEmail, tier, currentModel, quotaStats, }) => {
+    const { stats } = useSessionStats();
+    const pooledRemaining = quotaStats?.remaining;
+    const pooledLimit = quotaStats?.limit;
+    const pooledResetTime = quotaStats?.resetTime;
+    const { models } = stats.metrics;
+    const settings = useSettings();
+    const showUserIdentity = settings.merged.ui.showUserIdentity;
+    const activeModels = Object.entries(models).filter(([, metrics]) => metrics.api.totalRequests > 0);
+    if (activeModels.length === 0) {
+        return (_jsx(Box, { borderStyle: "round", borderColor: theme.border.default, paddingTop: 1, paddingX: 2, children: _jsx(Text, { color: theme.text.primary, children: "No API calls have been made in this session." }) }));
+    }
+    const modelNames = activeModels.map(([name]) => name);
+    const hasThoughts = activeModels.some(([, metrics]) => metrics.tokens.thoughts > 0);
+    const hasTool = activeModels.some(([, metrics]) => metrics.tokens.tool > 0);
+    const hasCached = activeModels.some(([, metrics]) => metrics.tokens.cached > 0);
+    const allRoles = [
+        ...new Set(activeModels.flatMap(([, metrics]) => Object.keys(metrics.roles ?? {}))),
+    ]
+        .filter((role) => {
+        const validRoles = Object.values(LlmRole);
+        return validRoles.includes(role);
+    })
+        .sort((a, b) => {
+        if (a === b)
+            return 0;
+        if (a === LlmRole.MAIN)
+            return -1;
+        if (b === LlmRole.MAIN)
+            return 1;
+        return a.localeCompare(b);
+    });
+    // Helper to create a row with values for each model
+    const createRow = (metric, getValue, options = {}) => {
+        const row = {
+            metric,
+            isSection: options.isSection,
+            isSubtle: options.isSubtle,
+        };
+        activeModels.forEach(([name, metrics]) => {
+            row[name] = getValue(metrics);
+        });
+        return row;
+    };
+    const rows = [];
+    // API Section
+    rows.push({ metric: 'API', isSection: true });
+    rows.push(createRow('Requests', (m) => m.api.totalRequests.toLocaleString()));
+    rows.push(createRow('Errors', (m) => {
+        const errorRate = calculateErrorRate(m);
+        return (_jsxs(Text, { color: m.api.totalErrors > 0 ? theme.status.error : theme.text.primary, children: [m.api.totalErrors.toLocaleString(), " (", errorRate.toFixed(1), "%)"] }));
+    }));
+    rows.push(createRow('Avg Latency', (m) => formatDuration(calculateAverageLatency(m))));
+    // Spacer
+    rows.push({ metric: '' });
+    // Tokens Section
+    rows.push({ metric: 'Tokens', isSection: true });
+    rows.push(createRow('Total', (m) => (_jsx(Text, { color: theme.text.secondary, children: m.tokens.total.toLocaleString() }))));
+    rows.push(createRow('Input', (m) => (_jsx(Text, { color: theme.text.primary, children: m.tokens.input.toLocaleString() })), { isSubtle: true }));
+    if (hasCached) {
+        rows.push(createRow('Cache Reads', (m) => {
+            const cacheHitRate = calculateCacheHitRate(m);
+            return (_jsxs(Text, { color: theme.text.secondary, children: [m.tokens.cached.toLocaleString(), " (", cacheHitRate.toFixed(1), "%)"] }));
+        }, { isSubtle: true }));
+    }
+    if (hasThoughts) {
+        rows.push(createRow('Thoughts', (m) => (_jsx(Text, { color: theme.text.primary, children: m.tokens.thoughts.toLocaleString() })), { isSubtle: true }));
+    }
+    if (hasTool) {
+        rows.push(createRow('Tool', (m) => (_jsx(Text, { color: theme.text.primary, children: m.tokens.tool.toLocaleString() })), { isSubtle: true }));
+    }
+    rows.push(createRow('Output', (m) => (_jsx(Text, { color: theme.text.primary, children: m.tokens.candidates.toLocaleString() })), { isSubtle: true }));
+    // Roles Section
+    if (allRoles.length > 0) {
+        // Spacer
+        rows.push({ metric: '' });
+        rows.push({ metric: 'Roles', isSection: true });
+        allRoles.forEach((role) => {
+            // Role Header Row
+            const roleHeaderRow = {
+                metric: role,
+                isSection: true,
+                color: theme.text.primary,
+            };
+            // We don't populate model values for the role header row
+            rows.push(roleHeaderRow);
+            const addRoleMetric = (metric, getValue) => {
+                const row = {
+                    metric,
+                    isSubtle: true,
+                };
+                activeModels.forEach(([name, metrics]) => {
+                    const roleMetrics = metrics.roles?.[role];
+                    if (roleMetrics) {
+                        row[name] = getValue(roleMetrics);
+                    }
+                    else {
+                        row[name] = _jsx(Text, { color: theme.text.secondary, children: "-" });
+                    }
+                });
+                rows.push(row);
+            };
+            addRoleMetric('Requests', (r) => r.totalRequests.toLocaleString());
+            addRoleMetric('Input', (r) => (_jsx(Text, { color: theme.text.primary, children: r.tokens.input.toLocaleString() })));
+            addRoleMetric('Output', (r) => (_jsx(Text, { color: theme.text.primary, children: r.tokens.candidates.toLocaleString() })));
+            addRoleMetric('Cache Reads', (r) => (_jsx(Text, { color: theme.text.secondary, children: r.tokens.cached.toLocaleString() })));
+        });
+    }
+    const columns = [
+        {
+            key: 'metric',
+            header: 'Metric',
+            width: 28,
+            renderCell: (row) => (_jsx(Text, { bold: row.isSection, color: row.isSection ? theme.text.primary : theme.text.link, children: row.isSubtle ? `  ↳ ${row.metric}` : row.metric })),
+        },
+        ...modelNames.map((name) => ({
+            key: name,
+            header: getDisplayString(name),
+            flexGrow: 1,
+            renderCell: (row) => {
+                // Don't render anything for section headers in model columns
+                if (row.isSection)
+                    return null;
+                const val = row[name];
+                if (val === undefined || val === null)
+                    return null;
+                if (typeof val === 'string' || typeof val === 'number') {
+                    return _jsx(Text, { color: theme.text.primary, children: val });
+                }
+                return val;
+            },
+        })),
+    ];
+    const isAuto = currentModel && isAutoModel(currentModel);
+    const statsTitle = isAuto
+        ? `${getDisplayString(currentModel)} Stats For Nerds`
+        : 'Model Stats For Nerds';
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "column", paddingTop: 1, paddingX: 2, children: [_jsx(Text, { bold: true, color: theme.text.accent, children: statsTitle }), _jsx(Box, { height: 1 }), showUserIdentity && selectedAuthType && (_jsxs(Box, { children: [_jsx(Box, { width: 28, children: _jsx(Text, { color: theme.text.link, children: "Auth Method:" }) }), _jsx(Text, { color: theme.text.primary, children: selectedAuthType.startsWith('oauth')
+                            ? userEmail
+                                ? `Signed in with Google (${userEmail})`
+                                : 'Signed in with Google'
+                            : selectedAuthType })] })), showUserIdentity && tier && (_jsxs(Box, { children: [_jsx(Box, { width: 28, children: _jsx(Text, { color: theme.text.link, children: "Tier:" }) }), _jsx(Text, { color: theme.text.primary, children: tier })] })), isAuto &&
+                pooledRemaining !== undefined &&
+                pooledLimit !== undefined &&
+                pooledLimit > 0 && (_jsx(QuotaStatsInfo, { remaining: pooledRemaining, limit: pooledLimit, resetTime: pooledResetTime })), (showUserIdentity || isAuto) && _jsx(Box, { height: 1 }), _jsx(Table, { data: rows, columns: columns })] }));
+};

package/dist/ui/components/MultiFolderTrustDialog.js

@@ -0,0 +1,95 @@
+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 { useState } from 'react';
+import { theme } from '../semantic-colors.js';
+import { RadioButtonSelect, } from './shared/RadioButtonSelect.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { loadTrustedFolders, TrustLevel } from '../../config/trustedFolders.js';
+import { expandHomeDir } from '../utils/directoryUtils.js';
+import * as path from 'node:path';
+import { MessageType } from '../types.js';
+export var MultiFolderTrustChoice;
+(function (MultiFolderTrustChoice) {
+    MultiFolderTrustChoice[MultiFolderTrustChoice["YES"] = 0] = "YES";
+    MultiFolderTrustChoice[MultiFolderTrustChoice["YES_AND_REMEMBER"] = 1] = "YES_AND_REMEMBER";
+    MultiFolderTrustChoice[MultiFolderTrustChoice["NO"] = 2] = "NO";
+})(MultiFolderTrustChoice || (MultiFolderTrustChoice = {}));
+export const MultiFolderTrustDialog = ({ folders, onComplete, trustedDirs, errors: initialErrors, finishAddingDirectories, config, addItem, }) => {
+    const [submitted, setSubmitted] = useState(false);
+    const handleCancel = async () => {
+        setSubmitted(true);
+        const errors = [...initialErrors];
+        errors.push(`Operation cancelled. The following directories were not added:\n- ${folders.join('\n- ')}`);
+        await finishAddingDirectories(config, addItem, trustedDirs, errors);
+        onComplete();
+    };
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleCancel();
+            return true;
+        }
+        return false;
+    }, { isActive: !submitted });
+    const options = [
+        {
+            label: 'Yes',
+            value: MultiFolderTrustChoice.YES,
+            key: 'yes',
+        },
+        {
+            label: 'Yes, and remember the directories as trusted',
+            value: MultiFolderTrustChoice.YES_AND_REMEMBER,
+            key: 'yes-and-remember',
+        },
+        {
+            label: 'No',
+            value: MultiFolderTrustChoice.NO,
+            key: 'no',
+        },
+    ];
+    const handleSelect = async (choice) => {
+        setSubmitted(true);
+        if (!config) {
+            addItem({
+                type: MessageType.ERROR,
+                text: 'Configuration is not available.',
+            });
+            onComplete();
+            return;
+        }
+        const workspaceContext = config.getWorkspaceContext();
+        const trustedFolders = loadTrustedFolders();
+        const errors = [...initialErrors];
+        const added = [...trustedDirs];
+        if (choice === MultiFolderTrustChoice.NO) {
+            errors.push(`The following directories were not added because they were not trusted:\n- ${folders.join('\n- ')}`);
+        }
+        else {
+            for (const dir of folders) {
+                try {
+                    const expandedPath = path.resolve(expandHomeDir(dir));
+                    if (choice === MultiFolderTrustChoice.YES_AND_REMEMBER) {
+                        await trustedFolders.setValue(expandedPath, TrustLevel.TRUST_FOLDER);
+                    }
+                    workspaceContext.addDirectory(expandedPath);
+                    added.push(dir);
+                }
+                catch (e) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    const error = e;
+                    errors.push(`Error adding '${dir}': ${error.message}`);
+                }
+            }
+        }
+        await finishAddingDirectories(config, addItem, added, errors);
+        onComplete();
+    };
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.status.warning, padding: 1, marginLeft: 1, marginRight: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "Do you trust the following folders being added to this workspace?" }), _jsx(Text, { color: theme.text.secondary, children: folders.map((f) => `- ${f}`).join('\n') }), _jsx(Text, { color: theme.text.primary, children: "Trusting a folder allows Gemini to read and perform auto-edits when in auto-approval mode. This is a security feature to prevent accidental execution in untrusted directories." })] }), _jsx(RadioButtonSelect, { items: options, onSelect: handleSelect, isFocused: !submitted })] }), submitted && (_jsx(Box, { marginLeft: 1, marginTop: 1, children: _jsx(Text, { color: theme.text.primary, children: "Applying trust settings..." }) }))] }));
+};

package/dist/ui/components/NewAgentsNotification.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { RadioButtonSelect, } from './shared/RadioButtonSelect.js';
+import { CliSpinner } from './CliSpinner.js';
+export var NewAgentsChoice;
+(function (NewAgentsChoice) {
+    NewAgentsChoice["ACKNOWLEDGE"] = "acknowledge";
+    NewAgentsChoice["IGNORE"] = "ignore";
+})(NewAgentsChoice || (NewAgentsChoice = {}));
+export const NewAgentsNotification = ({ agents, onSelect, }) => {
+    const [isProcessing, setIsProcessing] = useState(false);
+    const options = [
+        {
+            label: 'Acknowledge and Enable',
+            value: NewAgentsChoice.ACKNOWLEDGE,
+            key: 'acknowledge',
+        },
+        {
+            label: 'Do not enable (Ask again next time)',
+            value: NewAgentsChoice.IGNORE,
+            key: 'ignore',
+        },
+    ];
+    const handleSelect = async (choice) => {
+        setIsProcessing(true);
+        try {
+            await onSelect(choice);
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    };
+    // Limit display to 5 agents to avoid overflow, show count for rest
+    const MAX_DISPLAYED_AGENTS = 5;
+    const displayAgents = agents.slice(0, MAX_DISPLAYED_AGENTS);
+    const remaining = agents.length - MAX_DISPLAYED_AGENTS;
+    return (_jsx(Box, { flexDirection: "column", width: "100%", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.status.warning, padding: 1, marginLeft: 1, marginRight: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "New Agents Discovered" }), _jsx(Text, { color: theme.text.primary, children: "The following agents were found in this project. Please review them:" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", padding: 1, children: [displayAgents.map((agent) => {
+                                    const mcpServers = agent.kind === 'local' ? agent.mcpServers : undefined;
+                                    const hasMcpServers = mcpServers && Object.keys(mcpServers).length > 0;
+                                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { bold: true, color: theme.text.primary, children: ["- ", agent.name, ":", ' '] }) }), _jsxs(Text, { color: theme.text.secondary, children: [' ', agent.description] })] }), hasMcpServers && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.text.secondary, children: ["(Includes MCP servers:", ' ', Object.keys(mcpServers).join(', '), ")"] }) }))] }, agent.name));
+                                }), remaining > 0 && (_jsxs(Text, { color: theme.text.secondary, children: ["... and ", remaining, " more."] }))] })] }), isProcessing ? (_jsxs(Box, { children: [_jsx(CliSpinner, {}), _jsx(Text, { color: theme.text.primary, children: " Processing..." })] })) : (_jsx(RadioButtonSelect, { items: options, onSelect: handleSelect, isFocused: true }))] }) }));
+};

package/dist/ui/components/Notifications.js

@@ -0,0 +1,107 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import { useEffect, useState, useMemo, useRef, useCallback } from 'react';
+import { useAppContext } from '../contexts/AppContext.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { theme } from '../semantic-colors.js';
+import { StreamingState } from '../types.js';
+import { UpdateNotification } from './UpdateNotification.js';
+import { persistentState } from '../../utils/persistentState.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { KeypressPriority } from '../contexts/KeypressContext.js';
+import { GEMINI_DIR, Storage, homedir, WarningPriority, } from '@google/gemini-cli-core';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+const settingsPath = path.join(homedir(), GEMINI_DIR, 'settings.json');
+const screenReaderNudgeFilePath = path.join(Storage.getGlobalTempDir(), 'seen_screen_reader_nudge.json');
+const MAX_STARTUP_WARNING_SHOW_COUNT = 3;
+export const Notifications = () => {
+    const { startupWarnings } = useAppContext();
+    const { initError, streamingState, updateInfo } = useUIState();
+    const isScreenReaderEnabled = false; // Ink v4
+    const showInitError = initError && streamingState !== StreamingState.Responding;
+    const [hasSeenScreenReaderNudge, setHasSeenScreenReaderNudge] = useState(() => persistentState.get('hasSeenScreenReaderNudge'));
+    const [dismissed, setDismissed] = useState(false);
+    // Track if we have already incremented the show count in this session
+    const hasIncrementedRef = useRef(false);
+    // Filter warnings based on persistent state count if low priority
+    const visibleWarnings = useMemo(() => {
+        if (dismissed)
+            return [];
+        const counts = persistentState.get('startupWarningCounts') || {};
+        return startupWarnings.filter((w) => {
+            if (w.priority === WarningPriority.Low) {
+                const count = counts[w.id] || 0;
+                return count < MAX_STARTUP_WARNING_SHOW_COUNT;
+            }
+            return true;
+        });
+    }, [startupWarnings, dismissed]);
+    const showStartupWarnings = visibleWarnings.length > 0;
+    // Increment counts for low priority warnings when shown
+    useEffect(() => {
+        if (visibleWarnings.length > 0 && !hasIncrementedRef.current) {
+            const counts = { ...(persistentState.get('startupWarningCounts') || {}) };
+            let changed = false;
+            visibleWarnings.forEach((w) => {
+                if (w.priority === WarningPriority.Low) {
+                    counts[w.id] = (counts[w.id] || 0) + 1;
+                    changed = true;
+                }
+            });
+            if (changed) {
+                persistentState.set('startupWarningCounts', counts);
+            }
+            hasIncrementedRef.current = true;
+        }
+    }, [visibleWarnings]);
+    const handleKeyPress = useCallback(() => {
+        if (showStartupWarnings) {
+            setDismissed(true);
+        }
+        return false;
+    }, [showStartupWarnings]);
+    useKeypress(handleKeyPress, {
+        isActive: showStartupWarnings,
+        priority: KeypressPriority.Critical,
+    });
+    useEffect(() => {
+        const checkLegacyScreenReaderNudge = async () => {
+            if (hasSeenScreenReaderNudge !== undefined)
+                return;
+            try {
+                await fs.access(screenReaderNudgeFilePath);
+                persistentState.set('hasSeenScreenReaderNudge', true);
+                setHasSeenScreenReaderNudge(true);
+                // Best effort cleanup of legacy file
+                await fs.unlink(screenReaderNudgeFilePath).catch(() => { });
+            }
+            catch {
+                setHasSeenScreenReaderNudge(false);
+            }
+        };
+        if (isScreenReaderEnabled) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            checkLegacyScreenReaderNudge();
+        }
+    }, [isScreenReaderEnabled, hasSeenScreenReaderNudge]);
+    const showScreenReaderNudge = isScreenReaderEnabled && hasSeenScreenReaderNudge === false;
+    useEffect(() => {
+        if (showScreenReaderNudge) {
+            persistentState.set('hasSeenScreenReaderNudge', true);
+        }
+    }, [showScreenReaderNudge]);
+    if (!showStartupWarnings &&
+        !showInitError &&
+        !updateInfo &&
+        !showScreenReaderNudge) {
+        return null;
+    }
+    return (_jsxs(_Fragment, { children: [showScreenReaderNudge && (_jsxs(Text, { children: ["You are currently in screen reader-friendly view. To switch out, open", ' ', settingsPath, " and remove the entry for ", '"screenReader"', ". This will disappear on next run."] })), updateInfo && _jsx(UpdateNotification, { message: updateInfo.message }), showStartupWarnings && (_jsx(Box, { marginY: 1, flexDirection: "column", children: visibleWarnings.map((warning, index) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 3, children: _jsx(Text, { color: theme.status.warning, children: "\u26A0 " }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { color: theme.status.warning, children: warning.message }) })] }, index))) })), showInitError && (_jsxs(Box, { borderStyle: "round", borderColor: theme.status.error, paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: theme.status.error, children: ["Initialization Error: ", initError] }), _jsxs(Text, { color: theme.status.error, children: [' ', "Please check API key and configuration."] })] }))] }));
+};

package/dist/ui/components/OverageMenuDialog.js

@@ -0,0 +1,32 @@
+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 OverageMenuDialog({ failedModel, fallbackModel, resetTime, creditBalance, onChoice, }) {
+    const items = [
+        {
+            label: 'Use AI Credits - Continue this request (Overage)',
+            value: 'use_credits',
+            key: 'use_credits',
+        },
+        {
+            label: 'Manage - View balance and purchase more credits',
+            value: 'manage',
+            key: 'manage',
+        },
+    ];
+    if (fallbackModel) {
+        items.push({
+            label: `Switch to ${fallbackModel}`,
+            value: 'use_fallback',
+            key: 'use_fallback',
+        });
+    }
+    items.push({
+        label: 'Stop - Abort request',
+        value: 'stop',
+        key: 'stop',
+    });
+    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: _jsxs(Text, { children: ["You have", ' ', _jsx(Text, { bold: true, color: theme.status.success, children: creditBalance }), ' ', "AI Credits available."] }) }), _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: onChoice }) })] }));
+}

package/dist/ui/components/PermissionsModifyTrustDialog.js

@@ -0,0 +1,61 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import * as process from 'node:process';
+import * as path from 'node:path';
+import { TrustLevel } from '../../config/trustedFolders.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { usePermissionsModifyTrust } from '../hooks/usePermissionsModifyTrust.js';
+import { theme } from '../semantic-colors.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import { relaunchApp } from '../../utils/processUtils.js';
+export function PermissionsModifyTrustDialog({ onExit, addItem, targetDirectory, }) {
+    const currentDirectory = targetDirectory ?? process.cwd();
+    const dirName = path.basename(currentDirectory);
+    const parentFolder = path.basename(path.dirname(currentDirectory));
+    const TRUST_LEVEL_ITEMS = [
+        {
+            label: `Trust this folder (${dirName})`,
+            value: TrustLevel.TRUST_FOLDER,
+            key: TrustLevel.TRUST_FOLDER,
+        },
+        {
+            label: `Trust parent folder (${parentFolder})`,
+            value: TrustLevel.TRUST_PARENT,
+            key: TrustLevel.TRUST_PARENT,
+        },
+        {
+            label: "Don't trust",
+            value: TrustLevel.DO_NOT_TRUST,
+            key: TrustLevel.DO_NOT_TRUST,
+        },
+    ];
+    const { cwd, currentTrustLevel, isInheritedTrustFromParent, isInheritedTrustFromIde, needsRestart, updateTrustLevel, commitTrustLevelChange, } = usePermissionsModifyTrust(onExit, addItem, currentDirectory);
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            onExit();
+            return true;
+        }
+        if (needsRestart && key.name === 'r') {
+            void (async () => {
+                const success = await commitTrustLevelChange();
+                if (success) {
+                    void relaunchApp();
+                }
+                else {
+                    onExit();
+                }
+            })();
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const index = TRUST_LEVEL_ITEMS.findIndex((item) => item.value === currentTrustLevel);
+    const initialIndex = index === -1 ? 0 : index;
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "column", padding: 1, children: [_jsxs(Box, { flexDirection: "column", paddingBottom: 1, children: [_jsxs(Text, { bold: true, children: ['> ', "Modify Trust Level"] }), _jsx(Box, { marginTop: 1 }), _jsxs(Text, { children: ["Folder: ", cwd] }), _jsxs(Text, { children: ["Current Level: ", _jsx(Text, { bold: true, children: currentTrustLevel || 'Not Set' })] }), isInheritedTrustFromParent && (_jsx(Text, { color: theme.text.secondary, children: "Note: This folder behaves as a trusted folder because one of the parent folders is trusted. It will remain trusted even if you set a different trust level here. To change this, you need to modify the trust setting in the parent folder." })), isInheritedTrustFromIde && (_jsx(Text, { color: theme.text.secondary, children: "Note: This folder behaves as a trusted folder because the connected IDE workspace is trusted. It will remain trusted even if you set a different trust level here." }))] }), _jsx(RadioButtonSelect, { items: TRUST_LEVEL_ITEMS, onSelect: updateTrustLevel, isFocused: true, initialIndex: initialIndex }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.secondary, children: "(Use Enter to select, Esc to close)" }) })] }), needsRestart && (_jsx(Box, { marginLeft: 1, marginTop: 1, children: _jsx(Text, { color: theme.status.warning, children: "To apply the trust changes, Gemini CLI must be restarted. Press 'r' to restart CLI now." }) }))] }));
+}