@terminai/cli 0.21.0

package/dist/src/ui/AppContainer.js

@@ -0,0 +1,1751 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Portions Copyright 2025 TerminaI Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useMemo, useState, useCallback, useEffect, useRef, useLayoutEffect, } from 'react';
+import { measureElement, useInput } from 'ink';
+import { App } from './App.js';
+import { AppContext } from './contexts/AppContext.js';
+import { UIStateContext } from './contexts/UIStateContext.js';
+import { UIActionsContext, } from './contexts/UIActionsContext.js';
+import { ConfigContext } from './contexts/ConfigContext.js';
+import { ToolCallStatus, AuthState, } from './types.js';
+import { MessageType, StreamingState } from './types.js';
+import { IdeClient, ideContextStore, getErrorMessage, getAllGeminiMdFilenames, AuthType, clearCachedCredentialFile, recordExitFail, ShellExecutionService, saveApiKey, debugLogger, coreEvents, CoreEvent, refreshServerHierarchicalMemory, writeToStdout, disableMouseEvents, enterAlternateScreen, enableMouseEvents, disableLineWrapping, shouldEnterAlternateScreen, startupProfiler, SessionStartSource, SessionEndReason, fireSessionStartHook, fireSessionEndHook, generateSummary, sessionNotifier, } from '@terminai/core';
+import { validateAuthMethod } from '../config/auth.js';
+import process from 'node:process';
+import { useHistory } from './hooks/useHistoryManager.js';
+import { useMemoryMonitor } from './hooks/useMemoryMonitor.js';
+import { useThemeCommand } from './hooks/useThemeCommand.js';
+import { useAuthCommand } from './auth/useAuth.js';
+import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
+import { useEditorSettings } from './hooks/useEditorSettings.js';
+import { useSettingsCommand } from './hooks/useSettingsCommand.js';
+import { useModelCommand } from './hooks/useModelCommand.js';
+import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
+import { useVimMode } from './contexts/VimModeContext.js';
+import { useConsoleMessages } from './hooks/useConsoleMessages.js';
+import { useTerminalSize } from './hooks/useTerminalSize.js';
+import { calculatePromptWidths } from './components/InputPrompt.js';
+import { useApp, useStdout, useStdin } from 'ink';
+import { calculateMainAreaWidth } from './utils/ui-sizing.js';
+import ansiEscapes from 'ansi-escapes';
+import * as fs from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { computeWindowTitle } from '../utils/windowTitle.js';
+import { useTextBuffer } from './components/shared/text-buffer.js';
+import { useLogger } from './hooks/useLogger.js';
+import { useGeminiStream } from './hooks/useGeminiStream.js';
+import { useVim } from './hooks/vim.js';
+import { SettingScope, } from '../config/settings.js';
+import {} from '../core/initializer.js';
+import { useFocus } from './hooks/useFocus.js';
+import { useBracketedPaste } from './hooks/useBracketedPaste.js';
+import { useKeypress } from './hooks/useKeypress.js';
+import { keyMatchers, Command } from './keyMatchers.js';
+import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
+import { useFolderTrust } from './hooks/useFolderTrust.js';
+import { useIdeTrustListener } from './hooks/useIdeTrustListener.js';
+import {} from './IdeIntegrationNudge.js';
+import { appEvents, AppEvent } from '../utils/events.js';
+import {} from './utils/updateCheck.js';
+import { setUpdateHandler } from '../utils/handleAutoUpdate.js';
+import { registerCleanup, runExitCleanup } from '../utils/cleanup.js';
+import { RELAUNCH_EXIT_CODE } from '../utils/processUtils.js';
+import { useMessageQueue } from './hooks/useMessageQueue.js';
+import { useAutoAcceptIndicator } from './hooks/useAutoAcceptIndicator.js';
+import { useSessionStats } from './contexts/SessionContext.js';
+import { useGitBranchName } from './hooks/useGitBranchName.js';
+import { useConfirmUpdateRequests, useExtensionUpdates, } from './hooks/useExtensionUpdates.js';
+import { ShellFocusContext } from './contexts/ShellFocusContext.js';
+import {} from '../config/extension-manager.js';
+import { requestConsentInteractive } from '../config/extensions/consent.js';
+import { useSessionBrowser } from './hooks/useSessionBrowser.js';
+import { useSessionResume } from './hooks/useSessionResume.js';
+import { useIncludeDirsTrust } from './hooks/useIncludeDirsTrust.js';
+import { isWorkspaceTrusted } from '../config/trustedFolders.js';
+import { useAlternateBuffer } from './hooks/useAlternateBuffer.js';
+import { useSettings } from './contexts/SettingsContext.js';
+import { terminalCapabilityManager } from './utils/terminalCapabilityManager.js';
+import { useInputHistoryStore } from './hooks/useInputHistoryStore.js';
+import { enableBracketedPaste } from './utils/bracketedPaste.js';
+import { useBanner } from './hooks/useBanner.js';
+import { VoiceController } from '../voice/voiceController.js';
+import { deriveSpokenReply } from '../voice/spokenReply.js';
+import { resolveAutoTtsProvider } from '../voice/tts/auto.js';
+import { VoiceStateMachine } from '../voice/VoiceStateMachine.js';
+import { VoiceStateContext, } from './contexts/VoiceContext.js';
+import { ConversationStack } from '../voice/ConversationStack.js';
+import { StreamingWhisper } from '../voice/stt/StreamingWhisper.js';
+import { AudioRecorder } from '../voice/stt/AudioRecorder.js';
+import { AuthWizardDialogState } from './types.js';
+const WARNING_PROMPT_DURATION_MS = 1000;
+const QUEUE_ERROR_DISPLAY_DURATION_MS = 3000;
+function isToolExecuting(pendingHistoryItems) {
+    return pendingHistoryItems.some((item) => {
+        if (item && item.type === 'tool_group') {
+            return item.tools.some((tool) => ToolCallStatus.Executing === tool.status);
+        }
+        return false;
+    });
+}
+/**
+ * The fraction of the terminal width to allocate to the shell.
+ * This provides horizontal padding.
+ */
+const SHELL_WIDTH_FRACTION = 0.89;
+/**
+ * The number of lines to subtract from the available terminal height
+ * for the shell. This provides vertical padding and space for other UI elements.
+ */
+const SHELL_HEIGHT_PADDING = 10;
+const DEFAULT_VOICE_CONFIG = {
+    enabled: false,
+    pttKey: 'space',
+    sttProvider: 'auto',
+    ttsProvider: 'auto',
+    maxWords: 30,
+    whisper: {},
+};
+const VOICE_CACHE_DIR = join(homedir(), '.terminai', 'voice');
+function normalizePttKey(value) {
+    return value === 'ctrl+space' ? 'ctrl+space' : 'space';
+}
+function normalizeSttProvider(value) {
+    if (value === 'whispercpp' || value === 'none') {
+        return value;
+    }
+    return 'auto';
+}
+function normalizeTtsProvider(value) {
+    return value === 'none' ? 'none' : 'auto';
+}
+function readVoiceMetadata() {
+    try {
+        const raw = fs.readFileSync(join(VOICE_CACHE_DIR, 'metadata.json'), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (_error) {
+        return null;
+    }
+}
+function pickExistingPath(candidates) {
+    return candidates.find((p) => p && p.trim().length > 0 && fs.existsSync(p.trim()));
+}
+function resolveWhisperRuntime(settingsVoice) {
+    const metadata = readVoiceMetadata();
+    const defaultBinary = join(VOICE_CACHE_DIR, process.platform === 'win32' ? 'whisper.exe' : 'whisper');
+    const defaultModel = join(VOICE_CACHE_DIR, 'ggml-base.en.bin');
+    const binaryPath = pickExistingPath([
+        settingsVoice?.stt?.whispercpp?.binaryPath,
+        metadata?.paths?.whisperBinary,
+        metadata?.components?.whisper?.binaryPath || undefined,
+        defaultBinary,
+    ]);
+    const modelPath = pickExistingPath([
+        settingsVoice?.stt?.whispercpp?.modelPath,
+        metadata?.paths?.whisperModel,
+        metadata?.components?.whisper?.model || undefined,
+        defaultModel,
+    ]);
+    const device = settingsVoice?.stt?.whispercpp?.device;
+    return {
+        binaryPath: binaryPath || undefined,
+        modelPath: modelPath || undefined,
+        device,
+    };
+}
+function resolveVoiceConfig(settingsVoice, overrides) {
+    const whisper = resolveWhisperRuntime(settingsVoice);
+    const enabled = overrides?.enabled ??
+        settingsVoice?.enabled ??
+        DEFAULT_VOICE_CONFIG.enabled;
+    const pttKey = normalizePttKey(overrides?.pttKey ??
+        settingsVoice?.pushToTalk?.key ??
+        DEFAULT_VOICE_CONFIG.pttKey);
+    const sttProvider = normalizeSttProvider(overrides?.sttProvider ??
+        settingsVoice?.stt?.provider ??
+        DEFAULT_VOICE_CONFIG.sttProvider);
+    const ttsProvider = normalizeTtsProvider(overrides?.ttsProvider ??
+        settingsVoice?.tts?.provider ??
+        DEFAULT_VOICE_CONFIG.ttsProvider);
+    const maxWords = overrides?.maxWords ??
+        settingsVoice?.spokenReply?.maxWords ??
+        DEFAULT_VOICE_CONFIG.maxWords;
+    const resolvedStt = sttProvider === 'auto'
+        ? whisper.binaryPath && whisper.modelPath
+            ? 'whispercpp'
+            : 'none'
+        : sttProvider;
+    return {
+        enabled,
+        pttKey,
+        sttProvider: resolvedStt,
+        ttsProvider,
+        maxWords: Number.isFinite(maxWords)
+            ? Math.max(0, maxWords)
+            : DEFAULT_VOICE_CONFIG.maxWords,
+        whisper,
+    };
+}
+function isPttKey(key, pttKey) {
+    if (pttKey === 'space') {
+        return key.name === 'space' && !key.ctrl && !key.meta && !key.shift;
+    }
+    return ((key.name === 'space' && key.ctrl) ||
+        key.sequence === '\x00' ||
+        (key.name === 'undefined' && key.ctrl));
+}
+function getLatestGeminiResponse(history) {
+    for (let i = history.length - 1; i >= 0; i -= 1) {
+        const item = history[i];
+        if (item.type === 'gemini' || item.type === 'gemini_content') {
+            const endId = item.id;
+            let start = i;
+            while (start >= 0) {
+                const candidate = history[start];
+                if (candidate.type !== 'gemini' &&
+                    candidate.type !== 'gemini_content') {
+                    break;
+                }
+                start -= 1;
+            }
+            const parts = [];
+            for (let j = start + 1; j <= i; j += 1) {
+                const text = history[j].text ?? '';
+                parts.push(text);
+            }
+            return { text: parts.join(''), endId };
+        }
+    }
+    return null;
+}
+export const AppContainer = (props) => {
+    const { config, initializationResult, resumedSessionData } = props;
+    const historyManager = useHistory({
+        chatRecordingService: config.getGeminiClient()?.getChatRecordingService(),
+    });
+    useMemoryMonitor(historyManager);
+    useEffect(() => {
+        const handler = (event) => {
+            historyManager.addItem({
+                type: MessageType.INFO,
+                text: `[session:${event.sessionName}] ${event.message}`,
+            }, event.timestamp);
+        };
+        sessionNotifier.on('session-event', handler);
+        return () => {
+            sessionNotifier.off('session-event', handler);
+        };
+    }, [historyManager]);
+    const settings = useSettings();
+    const voiceConfig = useMemo(() => resolveVoiceConfig(settings.merged.voice, props.voiceOverrides), [settings.merged.voice, props.voiceOverrides]);
+    const voiceEnabled = voiceConfig.enabled;
+    const [voiceUiState, setVoiceUiState] = useState({
+        enabled: voiceEnabled,
+        state: 'IDLE',
+        amplitude: 0,
+    });
+    const ttsProvider = useMemo(() => {
+        if (!voiceEnabled) {
+            return null;
+        }
+        if (voiceConfig.ttsProvider === 'none') {
+            return null;
+        }
+        if (voiceConfig.ttsProvider === 'auto') {
+            return resolveAutoTtsProvider();
+        }
+        return null;
+    }, [voiceEnabled, voiceConfig.ttsProvider]);
+    const voiceStateMachine = useMemo(() => (voiceEnabled ? new VoiceStateMachine() : null), [voiceEnabled]);
+    const voiceController = useMemo(() => voiceEnabled ? new VoiceController(ttsProvider, voiceStateMachine) : null, [voiceEnabled, ttsProvider, voiceStateMachine]);
+    const voiceRecorderRef = useRef(null);
+    const whisperRef = useRef(null);
+    const transcriptRef = useRef({
+        partial: '',
+        final: '',
+    });
+    useEffect(() => {
+        setVoiceUiState((prev) => ({
+            ...prev,
+            enabled: voiceEnabled,
+            state: voiceEnabled ? prev.state : 'IDLE',
+            amplitude: voiceEnabled ? prev.amplitude : 0,
+        }));
+    }, [voiceEnabled]);
+    useEffect(() => {
+        if (!voiceStateMachine) {
+            return;
+        }
+        const handleStateChange = (payload) => {
+            setVoiceUiState((prev) => ({
+                ...prev,
+                state: payload.to,
+            }));
+        };
+        const handleActivity = (payload) => {
+            if (payload.level === undefined)
+                return;
+            setVoiceUiState((prev) => ({
+                ...prev,
+                amplitude: Math.max(0, Math.min(1, payload.level ?? 0)),
+            }));
+        };
+        voiceStateMachine.on('stateChange', handleStateChange);
+        voiceStateMachine.on('voiceActivity', handleActivity);
+        return () => {
+            voiceStateMachine.off('stateChange', handleStateChange);
+            voiceStateMachine.off('voiceActivity', handleActivity);
+        };
+    }, [voiceStateMachine]);
+    useEffect(() => {
+        if (!voiceStateMachine || !voiceController) {
+            return;
+        }
+        const handleDuck = (level = 0.2) => voiceController.duck(level);
+        const handleRestore = () => voiceController.restore();
+        const handleStop = () => voiceController.stopSpeaking();
+        voiceStateMachine.on('duckAudio', handleDuck);
+        voiceStateMachine.on('restoreAudio', handleRestore);
+        voiceStateMachine.on('stopTTS', handleStop);
+        return () => {
+            voiceStateMachine.off('duckAudio', handleDuck);
+            voiceStateMachine.off('restoreAudio', handleRestore);
+            voiceStateMachine.off('stopTTS', handleStop);
+        };
+    }, [voiceStateMachine, voiceController]);
+    useEffect(() => () => {
+        voiceController?.stopSpeaking();
+    }, [voiceController]);
+    const isAlternateBuffer = useAlternateBuffer();
+    const [corgiMode, setCorgiMode] = useState(false);
+    const [debugMessage, setDebugMessage] = useState('');
+    const [quittingMessages, setQuittingMessages] = useState(null);
+    const [showPrivacyNotice, setShowPrivacyNotice] = useState(false);
+    const [themeError, setThemeError] = useState(initializationResult.themeError);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [embeddedShellFocused, setEmbeddedShellFocused] = useState(false);
+    const [showDebugProfiler, setShowDebugProfiler] = useState(false);
+    const [customDialog, setCustomDialog] = useState(null);
+    const [copyModeEnabled, setCopyModeEnabled] = useState(false);
+    const [pendingRestorePrompt, setPendingRestorePrompt] = useState(false);
+    const [shellModeActive, setShellModeActive] = useState(false);
+    const [modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError] = useState(false);
+    const [historyRemountKey, setHistoryRemountKey] = useState(0);
+    const [updateInfo, setUpdateInfo] = useState(null);
+    const [isTrustedFolder, setIsTrustedFolder] = useState(isWorkspaceTrusted(settings.merged).isTrusted);
+    const [queueErrorMessage, setQueueErrorMessage] = useState(null);
+    const [defaultBannerText, setDefaultBannerText] = useState('');
+    const [warningBannerText, setWarningBannerText] = useState('');
+    const [bannerVisible, setBannerVisible] = useState(true);
+    const [viewMode, setViewMode] = useState('focus');
+    const bannerData = useMemo(() => ({
+        defaultText: defaultBannerText,
+        warningText: warningBannerText,
+    }), [defaultBannerText, warningBannerText]);
+    const { bannerText } = useBanner(bannerData, config);
+    const extensionManager = config.getExtensionLoader();
+    // We are in the interactive CLI, update how we request consent and settings.
+    extensionManager.setRequestConsent((description) => requestConsentInteractive(description, addConfirmUpdateExtensionRequest));
+    extensionManager.setRequestSetting();
+    const { addConfirmUpdateExtensionRequest, confirmUpdateExtensionRequests } = useConfirmUpdateRequests();
+    const { extensionsUpdateState, extensionsUpdateStateInternal, dispatchExtensionStateUpdate, } = useExtensionUpdates(extensionManager, historyManager.addItem, config.getEnableExtensionReloading());
+    const [isPermissionsDialogOpen, setPermissionsDialogOpen] = useState(false);
+    const [permissionsDialogProps, setPermissionsDialogProps] = useState(null);
+    const openPermissionsDialog = useCallback((props) => {
+        setPermissionsDialogOpen(true);
+        setPermissionsDialogProps(props ?? null);
+    }, []);
+    const closePermissionsDialog = useCallback(() => {
+        setPermissionsDialogOpen(false);
+        setPermissionsDialogProps(null);
+    }, []);
+    const toggleDebugProfiler = useCallback(() => setShowDebugProfiler((prev) => !prev), []);
+    // Helper to determine the effective model, considering the fallback state.
+    const getEffectiveModel = useCallback(() => config.getModel(), [config]);
+    const [currentModel, setCurrentModel] = useState(getEffectiveModel());
+    const [userTier, setUserTier] = useState(undefined);
+    const [isConfigInitialized, setConfigInitialized] = useState(false);
+    const logger = useLogger(config.storage);
+    const { inputHistory, addInput, initializeFromLogger } = useInputHistoryStore();
+    // Terminal and layout hooks
+    const { columns: terminalWidth, rows: terminalHeight } = useTerminalSize();
+    const { stdin, setRawMode } = useStdin();
+    const { stdout } = useStdout();
+    const app = useApp();
+    // Additional hooks moved from App.tsx
+    const { stats: sessionStats } = useSessionStats();
+    const branchName = useGitBranchName(config.getTargetDir());
+    // Layout measurements
+    const mainControlsRef = useRef(null);
+    // For performance profiling only
+    const rootUiRef = useRef(null);
+    const originalTitleRef = useRef(computeWindowTitle(basename(config.getTargetDir())));
+    const lastTitleRef = useRef(null);
+    const staticExtraHeight = 3;
+    useEffect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        (async () => {
+            // Note: the program will not work if this fails so let errors be
+            // handled by the global catch.
+            await config.initialize();
+            setConfigInitialized(true);
+            startupProfiler.flush(config);
+            // Fire SessionStart hook through MessageBus (only if hooks are enabled)
+            // Must be called AFTER config.initialize() to ensure HookRegistry is loaded
+            const hooksEnabled = config.getEnableHooks();
+            const hookMessageBus = config.getMessageBus();
+            if (hooksEnabled && hookMessageBus) {
+                const sessionStartSource = resumedSessionData
+                    ? SessionStartSource.Resume
+                    : SessionStartSource.Startup;
+                await fireSessionStartHook(hookMessageBus, sessionStartSource);
+            }
+            // Fire-and-forget: generate summary for previous session in background
+            generateSummary(config).catch((e) => {
+                debugLogger.warn('Background summary generation failed:', e);
+            });
+        })();
+        registerCleanup(async () => {
+            // Turn off mouse scroll.
+            disableMouseEvents();
+            const ideClient = await IdeClient.getInstance();
+            await ideClient.disconnect();
+            // Fire SessionEnd hook on cleanup (only if hooks are enabled)
+            const hooksEnabled = config.getEnableHooks();
+            const hookMessageBus = config.getMessageBus();
+            if (hooksEnabled && hookMessageBus) {
+                await fireSessionEndHook(hookMessageBus, SessionEndReason.Exit);
+            }
+        });
+    }, [config, resumedSessionData]);
+    useEffect(() => setUpdateHandler(historyManager.addItem, setUpdateInfo), [historyManager.addItem]);
+    // Subscribe to fallback mode and model changes from core
+    useEffect(() => {
+        const handleModelChanged = () => {
+            setCurrentModel(config.getModel());
+        };
+        coreEvents.on(CoreEvent.ModelChanged, handleModelChanged);
+        return () => {
+            coreEvents.off(CoreEvent.ModelChanged, handleModelChanged);
+        };
+    }, [getEffectiveModel, config]);
+    const { consoleMessages, clearConsoleMessages: clearConsoleMessagesState } = useConsoleMessages();
+    const mainAreaWidth = viewMode === 'focus'
+        ? Math.min(terminalWidth, 100)
+        : calculateMainAreaWidth(terminalWidth, settings);
+    // Derive widths for InputPrompt using shared helper
+    const { inputWidth, suggestionsWidth } = useMemo(() => {
+        const { inputWidth, suggestionsWidth } = calculatePromptWidths(mainAreaWidth);
+        return { inputWidth, suggestionsWidth };
+    }, [mainAreaWidth]);
+    const staticAreaMaxItemHeight = Math.max(terminalHeight * 4, 100);
+    const isValidPath = useCallback((filePath) => {
+        try {
+            return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+        }
+        catch (_e) {
+            return false;
+        }
+    }, []);
+    const maxInputHeight = Math.max(3, Math.floor(terminalHeight * 0.4));
+    const buffer = useTextBuffer({
+        initialText: '',
+        viewport: { height: maxInputHeight, width: inputWidth },
+        stdin,
+        setRawMode,
+        isValidPath,
+        shellModeActive,
+    });
+    // Initialize input history from logger (past sessions)
+    useEffect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        initializeFromLogger(logger);
+    }, [logger, initializeFromLogger]);
+    const refreshStatic = useCallback(() => {
+        if (!isAlternateBuffer) {
+            stdout.write(ansiEscapes.clearTerminal);
+        }
+        setHistoryRemountKey((prev) => prev + 1);
+    }, [setHistoryRemountKey, isAlternateBuffer, stdout]);
+    const handleEditorClose = useCallback(() => {
+        if (shouldEnterAlternateScreen(isAlternateBuffer, config.getScreenReader())) {
+            // The editor may have exited alternate buffer mode so we need to
+            // enter it again to be safe.
+            enterAlternateScreen();
+            enableMouseEvents();
+            disableLineWrapping();
+            app.rerender();
+        }
+        enableBracketedPaste();
+        terminalCapabilityManager.enableKittyProtocol();
+        refreshStatic();
+    }, [refreshStatic, isAlternateBuffer, app, config]);
+    useEffect(() => {
+        coreEvents.on(CoreEvent.ExternalEditorClosed, handleEditorClose);
+        return () => {
+            coreEvents.off(CoreEvent.ExternalEditorClosed, handleEditorClose);
+        };
+    }, [handleEditorClose]);
+    useEffect(() => {
+        if (!(settings.merged.ui?.hideBanner || config.getScreenReader()) &&
+            bannerVisible &&
+            bannerText) {
+            // The header should show a banner but the Header is rendered in static
+            // so we must trigger a static refresh for it to be visible.
+            refreshStatic();
+        }
+    }, [bannerVisible, bannerText, settings, config, refreshStatic]);
+    const { isThemeDialogOpen, openThemeDialog, closeThemeDialog, handleThemeSelect, handleThemeHighlight, } = useThemeCommand(settings, setThemeError, historyManager.addItem, initializationResult.themeError);
+    const { authState, setAuthState, authError, onAuthError, apiKeyDefaultValue, reloadApiKey, } = useAuthCommand(settings, config);
+    const [authWizardDialog, setAuthWizardDialog] = useState(null);
+    const { proQuotaRequest, handleProQuotaChoice } = useQuotaAndFallback({
+        config,
+        historyManager,
+        userTier,
+        setModelSwitchedFromQuotaError,
+    });
+    // Derive auth state variables for backward compatibility with UIStateContext
+    const isAuthDialogOpen = authState === AuthState.Updating;
+    const isAuthenticating = authState === AuthState.Unauthenticated;
+    useEffect(() => {
+        // Task 25: Show provider wizard before auth selection when auth is missing
+        if (isAuthDialogOpen &&
+            settings.merged.security?.auth?.selectedType === undefined &&
+            authWizardDialog === null) {
+            setAuthWizardDialog(AuthWizardDialogState.Provider);
+            return;
+        }
+        // Once an auth type is selected (or auth dialog closes), hide the wizard.
+        if (!isAuthDialogOpen || settings.merged.security?.auth?.selectedType) {
+            setAuthWizardDialog(null);
+        }
+    }, [
+        authWizardDialog,
+        isAuthDialogOpen,
+        settings.merged.security?.auth?.selectedType,
+    ]);
+    // Session browser and resume functionality
+    const isGeminiClientInitialized = config.getGeminiClient()?.isInitialized();
+    const { loadHistoryForResume } = useSessionResume({
+        config,
+        historyManager,
+        refreshStatic,
+        isGeminiClientInitialized,
+        setQuittingMessages,
+        resumedSessionData,
+        isAuthenticating,
+    });
+    const { isSessionBrowserOpen, openSessionBrowser, closeSessionBrowser, handleResumeSession, handleDeleteSession: handleDeleteSessionSync, } = useSessionBrowser(config, loadHistoryForResume);
+    // Wrap handleDeleteSession to return a Promise for UIActions interface
+    const handleDeleteSession = useCallback(async (session) => {
+        handleDeleteSessionSync(session);
+    }, [handleDeleteSessionSync]);
+    // Create handleAuthSelect wrapper for backward compatibility
+    const handleAuthSelect = useCallback(async (authType, scope) => {
+        if (authType) {
+            await clearCachedCredentialFile();
+            settings.setValue(scope, 'security.auth.selectedType', authType);
+            try {
+                await config.refreshAuth(authType);
+                setAuthState(AuthState.Authenticated);
+            }
+            catch (e) {
+                onAuthError(`Failed to authenticate: ${e instanceof Error ? e.message : String(e)}`);
+                return;
+            }
+            if (authType === AuthType.LOGIN_WITH_GOOGLE &&
+                config.isBrowserLaunchSuppressed()) {
+                await runExitCleanup();
+                writeToStdout(`
+----------------------------------------------------------------
+Logging in with Google... Restarting terminaI to continue.
+----------------------------------------------------------------
+          `);
+                process.exit(RELAUNCH_EXIT_CODE);
+            }
+        }
+        setAuthState(AuthState.Authenticated);
+    }, [settings, config, setAuthState, onAuthError]);
+    const handleApiKeySubmit = useCallback(async (apiKey) => {
+        try {
+            onAuthError(null);
+            if (!apiKey.trim() && apiKey.length > 1) {
+                onAuthError('API key cannot be empty string with length greater than 1.');
+                return;
+            }
+            await saveApiKey(apiKey);
+            await reloadApiKey();
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            setAuthState(AuthState.Authenticated);
+        }
+        catch (e) {
+            onAuthError(`Failed to save API key: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }, [setAuthState, onAuthError, reloadApiKey, config]);
+    const handleApiKeyCancel = useCallback(() => {
+        // Go back to auth method selection
+        setAuthState(AuthState.Updating);
+    }, [setAuthState]);
+    // Sync user tier from config when authentication changes
+    useEffect(() => {
+        // Only sync when not currently authenticating
+        if (authState === AuthState.Authenticated) {
+            setUserTier(config.getUserTier());
+        }
+    }, [config, authState]);
+    // Check for enforced auth type mismatch
+    useEffect(() => {
+        if (settings.merged.security?.auth?.enforcedType &&
+            settings.merged.security?.auth.selectedType &&
+            settings.merged.security?.auth.enforcedType !==
+                settings.merged.security?.auth.selectedType) {
+            onAuthError(`Authentication is enforced to be ${settings.merged.security?.auth.enforcedType}, but you are currently using ${settings.merged.security?.auth.selectedType}.`);
+        }
+        else if (settings.merged.security?.auth?.selectedType &&
+            !settings.merged.security?.auth?.useExternal) {
+            // We skip validation for Gemini API key here because it might be stored
+            // in the keychain, which we can't check synchronously.
+            // The useAuth hook handles validation for this case.
+            if (settings.merged.security.auth.selectedType === AuthType.USE_GEMINI) {
+                return;
+            }
+            const error = validateAuthMethod(settings.merged.security.auth.selectedType);
+            if (error) {
+                onAuthError(error);
+            }
+        }
+    }, [
+        settings.merged.security?.auth?.selectedType,
+        settings.merged.security?.auth?.enforcedType,
+        settings.merged.security?.auth?.useExternal,
+        onAuthError,
+    ]);
+    const [editorError, setEditorError] = useState(null);
+    const { isEditorDialogOpen, openEditorDialog, handleEditorSelect, exitEditorDialog, } = useEditorSettings(settings, setEditorError, historyManager.addItem);
+    const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } = useSettingsCommand();
+    const { isModelDialogOpen, openModelDialog, closeModelDialog } = useModelCommand();
+    const { toggleVimEnabled } = useVimMode();
+    const slashCommandActions = useMemo(() => ({
+        openAuthDialog: () => setAuthState(AuthState.Updating),
+        openThemeDialog,
+        openEditorDialog,
+        openPrivacyNotice: () => setShowPrivacyNotice(true),
+        openSettingsDialog,
+        openSessionBrowser,
+        openModelDialog,
+        openPermissionsDialog,
+        quit: (messages) => {
+            setQuittingMessages(messages);
+            setTimeout(async () => {
+                await runExitCleanup();
+                process.exit(0);
+            }, 100);
+        },
+        setDebugMessage,
+        toggleCorgiMode: () => setCorgiMode((prev) => !prev),
+        toggleDebugProfiler,
+        dispatchExtensionStateUpdate,
+        addConfirmUpdateExtensionRequest,
+        setViewMode,
+    }), [
+        setAuthState,
+        openThemeDialog,
+        openEditorDialog,
+        openSettingsDialog,
+        openSessionBrowser,
+        openModelDialog,
+        setQuittingMessages,
+        setDebugMessage,
+        setShowPrivacyNotice,
+        setCorgiMode,
+        dispatchExtensionStateUpdate,
+        openPermissionsDialog,
+        addConfirmUpdateExtensionRequest,
+        toggleDebugProfiler,
+        setViewMode,
+    ]);
+    const { handleSlashCommand, slashCommands, pendingHistoryItems: pendingSlashCommandHistoryItems, commandContext, shellConfirmationRequest, confirmationRequest, } = useSlashCommandProcessor(config, settings, historyManager.addItem, historyManager.clearItems, historyManager.loadHistory, refreshStatic, toggleVimEnabled, setIsProcessing, slashCommandActions, extensionsUpdateStateInternal, isConfigInitialized, setBannerVisible, setCustomDialog);
+    const performMemoryRefresh = useCallback(async () => {
+        historyManager.addItem({
+            type: MessageType.INFO,
+            text: 'Refreshing hierarchical memory (terminaI.md or other context files)...',
+        }, Date.now());
+        try {
+            const { memoryContent, fileCount } = await refreshServerHierarchicalMemory(config);
+            historyManager.addItem({
+                type: MessageType.INFO,
+                text: `Memory refreshed successfully. ${memoryContent.length > 0
+                    ? `Loaded ${memoryContent.length} characters from ${fileCount} file(s).`
+                    : 'No memory content found.'}`,
+            }, Date.now());
+            if (config.getDebugMode()) {
+                debugLogger.log(`[DEBUG] Refreshed memory content in config: ${memoryContent.substring(0, 200)}...`);
+            }
+        }
+        catch (error) {
+            const errorMessage = getErrorMessage(error);
+            historyManager.addItem({
+                type: MessageType.ERROR,
+                text: `Error refreshing memory: ${errorMessage}`,
+            }, Date.now());
+            debugLogger.warn('Error refreshing memory:', error);
+        }
+    }, [config, historyManager]);
+    const cancelHandlerRef = useRef(() => { });
+    const getPreferredEditor = useCallback(() => settings.merged.general?.preferredEditor, [settings.merged.general?.preferredEditor]);
+    const onCancelSubmit = useCallback((shouldRestorePrompt) => {
+        if (shouldRestorePrompt) {
+            setPendingRestorePrompt(true);
+        }
+        else {
+            setPendingRestorePrompt(false);
+            cancelHandlerRef.current(false);
+        }
+    }, []);
+    useEffect(() => {
+        if (pendingRestorePrompt) {
+            const lastHistoryUserMsg = historyManager.history.findLast((h) => h.type === 'user');
+            const lastUserMsg = inputHistory.at(-1);
+            if (!lastHistoryUserMsg ||
+                (typeof lastHistoryUserMsg.text === 'string' &&
+                    lastHistoryUserMsg.text === lastUserMsg)) {
+                cancelHandlerRef.current(true);
+                setPendingRestorePrompt(false);
+            }
+        }
+    }, [pendingRestorePrompt, inputHistory, historyManager.history]);
+    const { streamingState, submitQuery, initError, pendingHistoryItems: pendingGeminiHistoryItems, thought, cancelOngoingRequest, handleApprovalModeChange, activePtyId, loopDetectionConfirmationRequest, lastOutputTime, interactivePasswordPrompt, isFullScreen, clearInteractivePasswordPrompt, } = useGeminiStream(config.getGeminiClient(), historyManager.history, historyManager.addItem, config, settings, setDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onCancelSubmit, setEmbeddedShellFocused, terminalWidth, terminalHeight, embeddedShellFocused);
+    const lastSpokenGeminiIdRef = useRef(0);
+    const responseInProgressRef = useRef(false);
+    const conversationStack = useMemo(() => new ConversationStack(), []);
+    useEffect(() => {
+        if (!voiceEnabled) {
+            responseInProgressRef.current = false;
+        }
+    }, [voiceEnabled]);
+    useEffect(() => {
+        if (streamingState === StreamingState.Responding ||
+            streamingState === StreamingState.WaitingForConfirmation) {
+            responseInProgressRef.current = true;
+            return;
+        }
+        if (!voiceEnabled ||
+            !voiceController ||
+            !responseInProgressRef.current ||
+            streamingState !== StreamingState.Idle) {
+            return;
+        }
+        const latest = getLatestGeminiResponse(historyManager.history);
+        if (!latest || latest.endId <= lastSpokenGeminiIdRef.current) {
+            return;
+        }
+        lastSpokenGeminiIdRef.current = latest.endId;
+        responseInProgressRef.current = false;
+        conversationStack.setLastResponse(latest.text);
+        const { spokenText } = deriveSpokenReply(latest.text, voiceConfig.maxWords);
+        if (spokenText) {
+            void voiceController.speak(spokenText).catch((error) => {
+                debugLogger.warn(`Voice TTS failed: ${getErrorMessage(error)}`);
+            });
+        }
+    }, [
+        streamingState,
+        historyManager.history,
+        voiceEnabled,
+        voiceConfig.maxWords,
+        voiceController,
+        conversationStack,
+    ]);
+    // Auto-accept indicator
+    const showAutoAcceptIndicator = useAutoAcceptIndicator({
+        config,
+        addItem: historyManager.addItem,
+        onApprovalModeChange: handleApprovalModeChange,
+    });
+    const submitWithConversation = useCallback((query) => {
+        const intent = conversationStack.parseIntent(query);
+        const action = conversationStack.handleIntent(intent);
+        switch (action.action) {
+            case 'CANCEL_LAST_ACTION':
+                historyManager.addItem({
+                    type: MessageType.INFO,
+                    text: 'Cancelled the last request.',
+                }, Date.now());
+                return;
+            case 'REPLACE_INPUT':
+                void submitQuery(action.text);
+                return;
+            case 'SPEAK_LAST_RESPONSE': {
+                const repeatText = action.text;
+                if (!repeatText) {
+                    historyManager.addItem({
+                        type: MessageType.INFO,
+                        text: 'No prior response to repeat.',
+                    }, Date.now());
+                    return;
+                }
+                if (voiceEnabled && voiceController) {
+                    const spoken = deriveSpokenReply(repeatText, voiceConfig.maxWords).spokenText;
+                    if (spoken) {
+                        void voiceController.speak(spoken).catch((error) => {
+                            debugLogger.warn(`Voice repeat failed: ${getErrorMessage(error)}`);
+                        });
+                    }
+                }
+                else {
+                    historyManager.addItem({ type: MessageType.INFO, text: repeatText }, Date.now());
+                }
+                return;
+            }
+            case 'PROCESS_NORMALLY':
+            default:
+                void submitQuery(action.text);
+        }
+    }, [
+        conversationStack,
+        historyManager,
+        submitQuery,
+        voiceController,
+        voiceEnabled,
+        voiceConfig.maxWords,
+    ]);
+    const { messageQueue, addMessage, clearQueue, getQueuedMessagesText, popAllMessages, } = useMessageQueue({
+        isConfigInitialized,
+        streamingState,
+        submitQuery: submitWithConversation,
+    });
+    useEffect(() => {
+        if (!voiceEnabled || !voiceController) {
+            return;
+        }
+        if (!confirmationRequest?.prompt) {
+            return;
+        }
+        if (typeof confirmationRequest.prompt !== 'string') {
+            return;
+        }
+        const { spokenText } = deriveSpokenReply(confirmationRequest.prompt, voiceConfig.maxWords);
+        if (!spokenText) {
+            return;
+        }
+        void voiceController.speak(spokenText).catch((error) => {
+            debugLogger.warn(`Voice confirmation failed: ${getErrorMessage(error)}`);
+        });
+    }, [
+        confirmationRequest,
+        voiceController,
+        voiceEnabled,
+        voiceConfig.maxWords,
+    ]);
+    cancelHandlerRef.current = useCallback((shouldRestorePrompt = true) => {
+        const pendingHistoryItems = [
+            ...pendingSlashCommandHistoryItems,
+            ...pendingGeminiHistoryItems,
+        ];
+        if (isToolExecuting(pendingHistoryItems)) {
+            buffer.setText(''); // Just clear the prompt
+            return;
+        }
+        const lastUserMessage = inputHistory.at(-1);
+        let textToSet = shouldRestorePrompt ? lastUserMessage || '' : '';
+        const queuedText = getQueuedMessagesText();
+        if (queuedText) {
+            textToSet = textToSet ? `${textToSet}\n\n${queuedText}` : queuedText;
+            clearQueue();
+        }
+        if (textToSet || !shouldRestorePrompt) {
+            buffer.setText(textToSet);
+        }
+    }, [
+        buffer,
+        inputHistory,
+        getQueuedMessagesText,
+        clearQueue,
+        pendingSlashCommandHistoryItems,
+        pendingGeminiHistoryItems,
+    ]);
+    const handleFinalSubmit = useCallback((submittedValue) => {
+        // Switch from zen/focus mode to standard after first input
+        if (viewMode === 'focus') {
+            setViewMode('standard');
+        }
+        addMessage(submittedValue);
+        addInput(submittedValue); // Track input for up-arrow history
+    }, [addMessage, addInput, viewMode, setViewMode]);
+    useEffect(() => {
+        if (!voiceStateMachine || !voiceEnabled) {
+            voiceRecorderRef.current?.stop();
+            whisperRef.current?.stopStreaming();
+            voiceRecorderRef.current = null;
+            whisperRef.current = null;
+            return;
+        }
+        if (voiceConfig.sttProvider !== 'whispercpp') {
+            return;
+        }
+        if (!voiceConfig.whisper.modelPath || !voiceConfig.whisper.binaryPath) {
+            debugLogger.warn('Voice STT unavailable: whisper binary/model not found in settings or /voice install.');
+            setWarningMessage((prev) => prev ?? 'Voice transcription unavailable.');
+            return;
+        }
+        const recorder = new AudioRecorder({
+            device: voiceConfig.whisper.device,
+        });
+        const whisper = new StreamingWhisper({
+            modelPath: voiceConfig.whisper.modelPath,
+            binary: voiceConfig.whisper.binaryPath,
+        });
+        voiceRecorderRef.current = recorder;
+        whisperRef.current = whisper;
+        transcriptRef.current = { partial: '', final: '' };
+        const handleTranscription = (chunk) => {
+            if (!chunk.text) {
+                return;
+            }
+            transcriptRef.current.partial = chunk.text;
+            if (chunk.isFinal) {
+                transcriptRef.current.final = chunk.text;
+            }
+        };
+        const handleWhisperError = (error) => {
+            debugLogger.warn(`Voice STT error: ${getErrorMessage(error)}`);
+            setWarningMessage((prev) => prev ?? 'Voice transcription unavailable.');
+        };
+        const handleStartRecording = () => {
+            transcriptRef.current = { partial: '', final: '' };
+            if (!whisper.isRunning()) {
+                whisper.startStreaming();
+            }
+            recorder.start();
+        };
+        const handleStopRecording = () => {
+            recorder.stop();
+        };
+        const handleTranscribe = () => {
+            recorder.stop();
+            if (whisper.isRunning()) {
+                whisper.stopStreaming();
+            }
+            const text = (transcriptRef.current.final || transcriptRef.current.partial).trim();
+            if (!text) {
+                debugLogger.warn('Voice STT produced no transcript.');
+                return;
+            }
+            voiceStateMachine.transition({ type: 'TRANSCRIPTION_READY', text });
+        };
+        const handleSendToLLM = (text) => {
+            const trimmed = text.trim();
+            if (!trimmed)
+                return;
+            handleFinalSubmit(trimmed);
+        };
+        recorder.on('error', handleWhisperError);
+        recorder.on('end', () => whisper.stopStreaming());
+        whisper.on('error', handleWhisperError);
+        whisper.on('transcription', handleTranscription);
+        whisper.on('close', () => recorder.stop());
+        voiceStateMachine.on('startRecording', handleStartRecording);
+        voiceStateMachine.on('stopRecording', handleStopRecording);
+        voiceStateMachine.on('transcribe', handleTranscribe);
+        voiceStateMachine.on('sendToLLM', handleSendToLLM);
+        return () => {
+            voiceStateMachine.off('startRecording', handleStartRecording);
+            voiceStateMachine.off('stopRecording', handleStopRecording);
+            voiceStateMachine.off('transcribe', handleTranscribe);
+            voiceStateMachine.off('sendToLLM', handleSendToLLM);
+            recorder.removeAllListeners();
+            whisper.removeAllListeners();
+            recorder.stop();
+            whisper.stopStreaming();
+            voiceRecorderRef.current = null;
+            whisperRef.current = null;
+        };
+    }, [
+        voiceStateMachine,
+        voiceEnabled,
+        voiceConfig.sttProvider,
+        voiceConfig.whisper.binaryPath,
+        voiceConfig.whisper.modelPath,
+        voiceConfig.whisper.device,
+        handleFinalSubmit,
+    ]);
+    const handleClearScreen = useCallback(() => {
+        historyManager.clearItems();
+        clearConsoleMessagesState();
+        if (!isAlternateBuffer) {
+            console.clear();
+        }
+        refreshStatic();
+    }, [
+        historyManager,
+        clearConsoleMessagesState,
+        refreshStatic,
+        isAlternateBuffer,
+    ]);
+    const { handleInput: vimHandleInput } = useVim(buffer, handleFinalSubmit);
+    /**
+     * Determines if the input prompt should be active and accept user input.
+     * Input is disabled during:
+     * - Initialization errors
+     * - Slash command processing
+     * - Tool confirmations (WaitingForConfirmation state)
+     * - Any future streaming states not explicitly allowed
+     */
+    const isInputActive = !initError &&
+        !isProcessing &&
+        !!slashCommands &&
+        (streamingState === StreamingState.Idle ||
+            streamingState === StreamingState.Responding) &&
+        !proQuotaRequest;
+    const [controlsHeight, setControlsHeight] = useState(0);
+    useLayoutEffect(() => {
+        if (mainControlsRef.current) {
+            const fullFooterMeasurement = measureElement(mainControlsRef.current);
+            if (fullFooterMeasurement.height > 0 &&
+                fullFooterMeasurement.height !== controlsHeight) {
+                setControlsHeight(fullFooterMeasurement.height);
+            }
+        }
+    }, [buffer, terminalWidth, terminalHeight, controlsHeight]);
+    // Compute available terminal height based on controls measurement
+    const availableTerminalHeight = Math.max(0, terminalHeight - controlsHeight - staticExtraHeight - 2);
+    config.setShellExecutionConfig({
+        terminalWidth: Math.floor(terminalWidth * SHELL_WIDTH_FRACTION),
+        terminalHeight: Math.max(Math.floor(availableTerminalHeight - SHELL_HEIGHT_PADDING), 1),
+        pager: settings.merged.tools?.shell?.pager,
+        showColor: settings.merged.tools?.shell?.showColor,
+    });
+    const isFocused = useFocus();
+    useBracketedPaste();
+    // Context file names computation
+    const contextFileNames = useMemo(() => {
+        const fromSettings = settings.merged.context?.fileName;
+        return fromSettings
+            ? Array.isArray(fromSettings)
+                ? fromSettings
+                : [fromSettings]
+            : getAllGeminiMdFilenames();
+    }, [settings.merged.context?.fileName]);
+    // Initial prompt handling
+    const initialPrompt = useMemo(() => config.getQuestion(), [config]);
+    const initialPromptSubmitted = useRef(false);
+    const geminiClient = config.getGeminiClient();
+    useEffect(() => {
+        if (activePtyId) {
+            try {
+                ShellExecutionService.resizePty(activePtyId, Math.floor(terminalWidth * SHELL_WIDTH_FRACTION), Math.max(Math.floor(availableTerminalHeight - SHELL_HEIGHT_PADDING), 1));
+            }
+            catch (e) {
+                // This can happen in a race condition where the pty exits
+                // right before we try to resize it.
+                if (!(e instanceof Error &&
+                    e.message.includes('Cannot resize a pty that has already exited'))) {
+                    throw e;
+                }
+            }
+        }
+    }, [terminalWidth, availableTerminalHeight, activePtyId]);
+    useEffect(() => {
+        if (initialPrompt &&
+            isConfigInitialized &&
+            !initialPromptSubmitted.current &&
+            !isAuthenticating &&
+            !isAuthDialogOpen &&
+            !isThemeDialogOpen &&
+            !isEditorDialogOpen &&
+            !showPrivacyNotice &&
+            geminiClient?.isInitialized?.()) {
+            handleFinalSubmit(initialPrompt);
+            initialPromptSubmitted.current = true;
+        }
+    }, [
+        initialPrompt,
+        isConfigInitialized,
+        handleFinalSubmit,
+        isAuthenticating,
+        isAuthDialogOpen,
+        isThemeDialogOpen,
+        isEditorDialogOpen,
+        showPrivacyNotice,
+        geminiClient,
+    ]);
+    const [idePromptAnswered, setIdePromptAnswered] = useState(false);
+    const [currentIDE, setCurrentIDE] = useState(null);
+    useEffect(() => {
+        const getIde = async () => {
+            const ideClient = await IdeClient.getInstance();
+            const currentIde = ideClient.getCurrentIde();
+            setCurrentIDE(currentIde || null);
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        getIde();
+    }, []);
+    const shouldShowIdePrompt = Boolean(currentIDE &&
+        !config.getIdeMode() &&
+        !settings.merged.ide?.hasSeenNudge &&
+        !idePromptAnswered);
+    const [showErrorDetails, setShowErrorDetails] = useState(false);
+    const [showFullTodos, setShowFullTodos] = useState(false);
+    const [renderMarkdown, setRenderMarkdown] = useState(true);
+    const [ctrlCPressCount, setCtrlCPressCount] = useState(0);
+    const ctrlCTimerRef = useRef(null);
+    const [ctrlDPressCount, setCtrlDPressCount] = useState(0);
+    const ctrlDTimerRef = useRef(null);
+    const [constrainHeight, setConstrainHeight] = useState(true);
+    const [ideContextState, setIdeContextState] = useState();
+    const [showEscapePrompt, setShowEscapePrompt] = useState(false);
+    const [showIdeRestartPrompt, setShowIdeRestartPrompt] = useState(false);
+    const [warningMessage, setWarningMessage] = useState(null);
+    const { isFolderTrustDialogOpen, handleFolderTrustSelect, isRestarting } = useFolderTrust(settings, setIsTrustedFolder, historyManager.addItem);
+    const { needsRestart: ideNeedsRestart, restartReason: ideTrustRestartReason, } = useIdeTrustListener();
+    const isInitialMount = useRef(true);
+    useIncludeDirsTrust(config, isTrustedFolder, historyManager, setCustomDialog);
+    useEffect(() => {
+        let timeoutId;
+        const handleWarning = (message) => {
+            setWarningMessage(message);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            timeoutId = setTimeout(() => {
+                setWarningMessage(null);
+            }, WARNING_PROMPT_DURATION_MS);
+        };
+        const handleSelectionWarning = () => {
+            handleWarning('Press Ctrl-S to enter selection mode to copy text.');
+        };
+        const handlePasteTimeout = () => {
+            handleWarning('Paste Timed out. Possibly due to slow connection.');
+        };
+        appEvents.on(AppEvent.SelectionWarning, handleSelectionWarning);
+        appEvents.on(AppEvent.PasteTimeout, handlePasteTimeout);
+        return () => {
+            appEvents.off(AppEvent.SelectionWarning, handleSelectionWarning);
+            appEvents.off(AppEvent.PasteTimeout, handlePasteTimeout);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        };
+    }, []);
+    useEffect(() => {
+        if (ideNeedsRestart) {
+            // IDE trust changed, force a restart.
+            setShowIdeRestartPrompt(true);
+        }
+    }, [ideNeedsRestart]);
+    useEffect(() => {
+        if (queueErrorMessage) {
+            const timer = setTimeout(() => {
+                setQueueErrorMessage(null);
+            }, QUEUE_ERROR_DISPLAY_DURATION_MS);
+            return () => clearTimeout(timer);
+        }
+        return undefined;
+    }, [queueErrorMessage, setQueueErrorMessage]);
+    useEffect(() => {
+        if (isInitialMount.current) {
+            isInitialMount.current = false;
+            return;
+        }
+        const handler = setTimeout(() => {
+            refreshStatic();
+        }, 300);
+        return () => {
+            clearTimeout(handler);
+        };
+    }, [terminalWidth, refreshStatic]);
+    useEffect(() => {
+        const unsubscribe = ideContextStore.subscribe(setIdeContextState);
+        setIdeContextState(ideContextStore.get());
+        return unsubscribe;
+    }, []);
+    useEffect(() => {
+        const openDebugConsole = () => {
+            setShowErrorDetails(true);
+            setConstrainHeight(false);
+        };
+        appEvents.on(AppEvent.OpenDebugConsole, openDebugConsole);
+        return () => {
+            appEvents.off(AppEvent.OpenDebugConsole, openDebugConsole);
+        };
+    }, [config]);
+    useEffect(() => {
+        if (ctrlCTimerRef.current) {
+            clearTimeout(ctrlCTimerRef.current);
+            ctrlCTimerRef.current = null;
+        }
+        if (ctrlCPressCount > 2) {
+            recordExitFail(config);
+        }
+        if (ctrlCPressCount > 1) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleSlashCommand('/quit', undefined, undefined, false);
+        }
+        else {
+            ctrlCTimerRef.current = setTimeout(() => {
+                setCtrlCPressCount(0);
+                ctrlCTimerRef.current = null;
+            }, WARNING_PROMPT_DURATION_MS);
+        }
+    }, [ctrlCPressCount, config, setCtrlCPressCount, handleSlashCommand]);
+    useEffect(() => {
+        if (ctrlDTimerRef.current) {
+            clearTimeout(ctrlDTimerRef.current);
+            ctrlCTimerRef.current = null;
+        }
+        if (ctrlDPressCount > 2) {
+            recordExitFail(config);
+        }
+        if (ctrlDPressCount > 1) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleSlashCommand('/quit', undefined, undefined, false);
+        }
+        else {
+            ctrlDTimerRef.current = setTimeout(() => {
+                setCtrlDPressCount(0);
+                ctrlDTimerRef.current = null;
+            }, WARNING_PROMPT_DURATION_MS);
+        }
+    }, [ctrlDPressCount, config, setCtrlDPressCount, handleSlashCommand]);
+    const handleEscapePromptChange = useCallback((showPrompt) => {
+        setShowEscapePrompt(showPrompt);
+    }, []);
+    const handleIdePromptComplete = useCallback((result) => {
+        if (result.userSelection === 'yes') {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleSlashCommand('/ide install');
+            settings.setValue(SettingScope.User, 'hasSeenIdeIntegrationNudge', true);
+        }
+        else if (result.userSelection === 'dismiss') {
+            settings.setValue(SettingScope.User, 'hasSeenIdeIntegrationNudge', true);
+        }
+        setIdePromptAnswered(true);
+    }, [handleSlashCommand, settings]);
+    const { elapsedTime, currentLoadingPhrase } = useLoadingIndicator(streamingState, settings.merged.ui?.customWittyPhrases, !!activePtyId && !embeddedShellFocused, lastOutputTime);
+    const handleGlobalKeypress = useCallback((key) => {
+        const voiceKeyPressed = voiceEnabled && isPttKey(key, voiceConfig.pttKey);
+        if (voiceKeyPressed && voiceStateMachine) {
+            const currentState = voiceStateMachine.getState();
+            if (voiceController?.isSpeaking()) {
+                voiceStateMachine.transition({ type: 'USER_VOICE_DETECTED' });
+                voiceController.stopSpeaking();
+            }
+            if (currentState === 'LISTENING') {
+                voiceStateMachine.transition({ type: 'PTT_RELEASE' });
+            }
+            else {
+                voiceStateMachine.transition({ type: 'PTT_PRESS' });
+            }
+        }
+        else if (voiceController?.isSpeaking()) {
+            if (key.insertable || key.name === 'escape') {
+                voiceController.stopSpeaking();
+            }
+        }
+        if (copyModeEnabled) {
+            setCopyModeEnabled(false);
+            enableMouseEvents();
+            // We don't want to process any other keys if we're in copy mode.
+            return;
+        }
+        // Debug log keystrokes if enabled
+        if (settings.merged.general?.debugKeystrokeLogging) {
+            debugLogger.log('[DEBUG] Keystroke:', JSON.stringify(key));
+        }
+        if (isAlternateBuffer && keyMatchers[Command.TOGGLE_COPY_MODE](key)) {
+            setCopyModeEnabled(true);
+            disableMouseEvents();
+            return;
+        }
+        if (keyMatchers[Command.QUIT](key)) {
+            // If the user presses Ctrl+C, we want to cancel any ongoing requests.
+            // This should happen regardless of the count.
+            cancelOngoingRequest?.();
+            setCtrlCPressCount((prev) => prev + 1);
+            return;
+        }
+        else if (keyMatchers[Command.EXIT](key)) {
+            if (buffer.text.length > 0) {
+                return;
+            }
+            setCtrlDPressCount((prev) => prev + 1);
+            return;
+        }
+        let enteringConstrainHeightMode = false;
+        if (!constrainHeight) {
+            enteringConstrainHeightMode = true;
+            setConstrainHeight(true);
+        }
+        if (keyMatchers[Command.SHOW_ERROR_DETAILS](key)) {
+            setShowErrorDetails((prev) => !prev);
+        }
+        else if (keyMatchers[Command.SHOW_FULL_TODOS](key)) {
+            setShowFullTodos((prev) => !prev);
+        }
+        else if (keyMatchers[Command.TOGGLE_MARKDOWN](key)) {
+            setRenderMarkdown((prev) => {
+                const newValue = !prev;
+                // Force re-render of static content
+                refreshStatic();
+                return newValue;
+            });
+        }
+        else if (keyMatchers[Command.TOGGLE_IDE_CONTEXT_DETAIL](key) &&
+            config.getIdeMode() &&
+            ideContextState) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            handleSlashCommand('/ide status');
+        }
+        else if (keyMatchers[Command.SHOW_MORE_LINES](key) &&
+            !enteringConstrainHeightMode) {
+            setConstrainHeight(false);
+        }
+        else if (keyMatchers[Command.TOGGLE_SHELL_INPUT_FOCUS](key)) {
+            if (activePtyId || embeddedShellFocused) {
+                setEmbeddedShellFocused((prev) => !prev);
+            }
+        }
+    }, [
+        constrainHeight,
+        setConstrainHeight,
+        setShowErrorDetails,
+        config,
+        ideContextState,
+        setCtrlCPressCount,
+        buffer.text.length,
+        setCtrlDPressCount,
+        handleSlashCommand,
+        cancelOngoingRequest,
+        activePtyId,
+        embeddedShellFocused,
+        settings.merged.general?.debugKeystrokeLogging,
+        refreshStatic,
+        setCopyModeEnabled,
+        copyModeEnabled,
+        isAlternateBuffer,
+        voiceController,
+        voiceConfig.pttKey,
+        voiceEnabled,
+        voiceStateMachine,
+    ]);
+    useKeypress(handleGlobalKeypress, { isActive: true });
+    // Update terminal title with Gemini CLI status and thoughts
+    useEffect(() => {
+        // Respect both showStatusInTitle and hideWindowTitle settings
+        if (!settings.merged.ui?.showStatusInTitle ||
+            settings.merged.ui?.hideWindowTitle)
+            return;
+        let title;
+        if (streamingState === StreamingState.Idle) {
+            title = originalTitleRef.current;
+        }
+        else {
+            const statusText = thought?.subject
+                ?.replace(/[\r\n]+/g, ' ')
+                .substring(0, 80);
+            title = statusText || originalTitleRef.current;
+        }
+        // Pad the title to a fixed width to prevent taskbar icon resizing.
+        const paddedTitle = title.padEnd(80, ' ');
+        // Only update the title if it's different from the last value we set
+        if (lastTitleRef.current !== paddedTitle) {
+            lastTitleRef.current = paddedTitle;
+            stdout.write(`\x1b]2;${paddedTitle}\x07`);
+        }
+        // Note: We don't need to reset the window title on exit because Gemini CLI is already doing that elsewhere
+    }, [
+        streamingState,
+        thought,
+        settings.merged.ui?.showStatusInTitle,
+        settings.merged.ui?.hideWindowTitle,
+        stdout,
+    ]);
+    useEffect(() => {
+        const handleUserFeedback = (payload) => {
+            let type;
+            switch (payload.severity) {
+                case 'error':
+                    type = MessageType.ERROR;
+                    break;
+                case 'warning':
+                    type = MessageType.WARNING;
+                    break;
+                case 'info':
+                    type = MessageType.INFO;
+                    break;
+                default:
+                    throw new Error(`Unexpected severity for user feedback: ${payload.severity}`);
+            }
+            historyManager.addItem({
+                type,
+                text: payload.message,
+            }, Date.now());
+            // If there is an attached error object, log it to the debug drawer.
+            if (payload.error) {
+                debugLogger.warn(`[Feedback Details for "${payload.message}"]`, payload.error);
+            }
+        };
+        coreEvents.on(CoreEvent.UserFeedback, handleUserFeedback);
+        // Flush any messages that happened during startup before this component
+        // mounted.
+        coreEvents.drainBacklogs();
+        return () => {
+            coreEvents.off(CoreEvent.UserFeedback, handleUserFeedback);
+        };
+    }, [historyManager]);
+    const filteredConsoleMessages = useMemo(() => {
+        if (config.getDebugMode()) {
+            return consoleMessages;
+        }
+        return consoleMessages.filter((msg) => msg.type !== 'debug');
+    }, [consoleMessages, config]);
+    // Computed values
+    const errorCount = useMemo(() => filteredConsoleMessages
+        .filter((msg) => msg.type === 'error')
+        .reduce((total, msg) => total + msg.count, 0), [filteredConsoleMessages]);
+    const nightly = props.version.includes('nightly');
+    const dialogsVisible = shouldShowIdePrompt ||
+        isFolderTrustDialogOpen ||
+        !!shellConfirmationRequest ||
+        !!confirmationRequest ||
+        !!customDialog ||
+        confirmUpdateExtensionRequests.length > 0 ||
+        !!loopDetectionConfirmationRequest ||
+        isThemeDialogOpen ||
+        isSettingsDialogOpen ||
+        isModelDialogOpen ||
+        isPermissionsDialogOpen ||
+        isAuthenticating ||
+        isAuthDialogOpen ||
+        isEditorDialogOpen ||
+        showPrivacyNotice ||
+        showIdeRestartPrompt ||
+        !!proQuotaRequest ||
+        isSessionBrowserOpen ||
+        isAuthDialogOpen ||
+        authState === AuthState.AwaitingApiKeyInput;
+    const pendingHistoryItems = useMemo(() => [...pendingSlashCommandHistoryItems, ...pendingGeminiHistoryItems], [pendingSlashCommandHistoryItems, pendingGeminiHistoryItems]);
+    const [isSpotlightOpen, setSpotlightOpen] = useState(false);
+    useInput((input, key) => {
+        if (input === 'k' && key.ctrl) {
+            setSpotlightOpen((prev) => !prev);
+        }
+    });
+    const [geminiMdFileCount, setGeminiMdFileCount] = useState(config.getGeminiMdFileCount());
+    useEffect(() => {
+        const handleMemoryChanged = (result) => {
+            setGeminiMdFileCount(result.fileCount);
+        };
+        coreEvents.on(CoreEvent.MemoryChanged, handleMemoryChanged);
+        return () => {
+            coreEvents.off(CoreEvent.MemoryChanged, handleMemoryChanged);
+        };
+    }, []);
+    useEffect(() => {
+        let isMounted = true;
+        const fetchBannerTexts = async () => {
+            const [defaultBanner, warningBanner] = await Promise.all([
+                config.getBannerTextNoCapacityIssues(),
+                config.getBannerTextCapacityIssues(),
+            ]);
+            if (isMounted) {
+                setDefaultBannerText(defaultBanner);
+                setWarningBannerText(warningBanner);
+                setBannerVisible(true);
+                const authType = config.getContentGeneratorConfig()?.authType;
+                if (authType === AuthType.USE_GEMINI ||
+                    authType === AuthType.USE_VERTEX_AI) {
+                    setDefaultBannerText('TerminaI is powered by Gemini 1.5 Pro and Flash. \nEnable "Preview features" in /settings. \nLearn more at https://goo.gle/enable-preview-features');
+                }
+            }
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        fetchBannerTexts();
+        return () => {
+            isMounted = false;
+        };
+    }, [config, refreshStatic]);
+    const uiState = useMemo(() => ({
+        history: historyManager.history,
+        historyManager,
+        isThemeDialogOpen,
+        themeError,
+        isAuthenticating,
+        isConfigInitialized,
+        authError,
+        authWizardDialog,
+        isAuthDialogOpen,
+        isAwaitingApiKeyInput: authState === AuthState.AwaitingApiKeyInput,
+        apiKeyDefaultValue,
+        editorError,
+        isEditorDialogOpen,
+        showPrivacyNotice,
+        corgiMode,
+        debugMessage,
+        quittingMessages,
+        isSettingsDialogOpen,
+        isSessionBrowserOpen,
+        isModelDialogOpen,
+        isPermissionsDialogOpen,
+        permissionsDialogProps,
+        slashCommands,
+        pendingSlashCommandHistoryItems,
+        commandContext,
+        shellConfirmationRequest,
+        confirmationRequest,
+        confirmUpdateExtensionRequests,
+        loopDetectionConfirmationRequest,
+        geminiMdFileCount,
+        streamingState,
+        initError,
+        pendingGeminiHistoryItems,
+        thought,
+        shellModeActive,
+        userMessages: inputHistory,
+        buffer,
+        inputWidth,
+        suggestionsWidth,
+        isInputActive,
+        shouldShowIdePrompt,
+        isFolderTrustDialogOpen: isFolderTrustDialogOpen ?? false,
+        isTrustedFolder,
+        constrainHeight,
+        showErrorDetails,
+        showFullTodos,
+        filteredConsoleMessages,
+        ideContextState,
+        renderMarkdown,
+        ctrlCPressedOnce: ctrlCPressCount >= 1,
+        ctrlDPressedOnce: ctrlDPressCount >= 1,
+        showEscapePrompt,
+        isFocused,
+        elapsedTime,
+        currentLoadingPhrase,
+        historyRemountKey,
+        messageQueue,
+        queueErrorMessage,
+        showAutoAcceptIndicator,
+        currentModel,
+        userTier,
+        proQuotaRequest,
+        contextFileNames,
+        errorCount,
+        availableTerminalHeight,
+        mainAreaWidth,
+        staticAreaMaxItemHeight,
+        staticExtraHeight,
+        dialogsVisible,
+        pendingHistoryItems,
+        nightly,
+        branchName,
+        sessionStats,
+        terminalWidth,
+        terminalHeight,
+        mainControlsRef,
+        rootUiRef,
+        currentIDE,
+        updateInfo,
+        showIdeRestartPrompt,
+        ideTrustRestartReason,
+        isRestarting,
+        extensionsUpdateState,
+        activePtyId,
+        embeddedShellFocused,
+        showDebugProfiler,
+        customDialog,
+        copyModeEnabled,
+        warningMessage,
+        bannerData,
+        bannerVisible,
+        terminalBackgroundColor: config.getTerminalBackground(),
+        interactivePasswordPrompt,
+        isFullScreen,
+        viewMode,
+        isSpotlightOpen,
+    }), [
+        isSpotlightOpen,
+        isThemeDialogOpen,
+        themeError,
+        isAuthenticating,
+        isConfigInitialized,
+        authError,
+        authWizardDialog,
+        isAuthDialogOpen,
+        editorError,
+        isEditorDialogOpen,
+        showPrivacyNotice,
+        corgiMode,
+        debugMessage,
+        quittingMessages,
+        isSettingsDialogOpen,
+        isSessionBrowserOpen,
+        isModelDialogOpen,
+        isPermissionsDialogOpen,
+        permissionsDialogProps,
+        slashCommands,
+        pendingSlashCommandHistoryItems,
+        commandContext,
+        shellConfirmationRequest,
+        confirmationRequest,
+        confirmUpdateExtensionRequests,
+        loopDetectionConfirmationRequest,
+        geminiMdFileCount,
+        streamingState,
+        initError,
+        pendingGeminiHistoryItems,
+        thought,
+        shellModeActive,
+        inputHistory,
+        buffer,
+        inputWidth,
+        suggestionsWidth,
+        isInputActive,
+        shouldShowIdePrompt,
+        isFolderTrustDialogOpen,
+        isTrustedFolder,
+        constrainHeight,
+        showErrorDetails,
+        showFullTodos,
+        filteredConsoleMessages,
+        ideContextState,
+        renderMarkdown,
+        ctrlCPressCount,
+        ctrlDPressCount,
+        showEscapePrompt,
+        isFocused,
+        elapsedTime,
+        currentLoadingPhrase,
+        historyRemountKey,
+        messageQueue,
+        queueErrorMessage,
+        showAutoAcceptIndicator,
+        userTier,
+        proQuotaRequest,
+        contextFileNames,
+        errorCount,
+        availableTerminalHeight,
+        mainAreaWidth,
+        staticAreaMaxItemHeight,
+        staticExtraHeight,
+        dialogsVisible,
+        pendingHistoryItems,
+        nightly,
+        branchName,
+        sessionStats,
+        terminalWidth,
+        terminalHeight,
+        mainControlsRef,
+        rootUiRef,
+        currentIDE,
+        updateInfo,
+        showIdeRestartPrompt,
+        ideTrustRestartReason,
+        isRestarting,
+        currentModel,
+        extensionsUpdateState,
+        activePtyId,
+        historyManager,
+        embeddedShellFocused,
+        showDebugProfiler,
+        customDialog,
+        apiKeyDefaultValue,
+        authState,
+        copyModeEnabled,
+        warningMessage,
+        bannerData,
+        bannerVisible,
+        interactivePasswordPrompt,
+        isFullScreen,
+        viewMode,
+        config,
+    ]);
+    const exitPrivacyNotice = useCallback(() => setShowPrivacyNotice(false), [setShowPrivacyNotice]);
+    const uiActions = useMemo(() => ({
+        handleThemeSelect,
+        closeThemeDialog,
+        handleThemeHighlight,
+        handleAuthSelect,
+        setAuthState,
+        onAuthError,
+        handleEditorSelect,
+        exitEditorDialog,
+        exitPrivacyNotice,
+        closeSettingsDialog,
+        closeModelDialog,
+        openPermissionsDialog,
+        closePermissionsDialog,
+        setShellModeActive,
+        vimHandleInput,
+        handleIdePromptComplete,
+        handleFolderTrustSelect,
+        setConstrainHeight,
+        onEscapePromptChange: handleEscapePromptChange,
+        refreshStatic,
+        handleFinalSubmit,
+        handleClearScreen,
+        handleProQuotaChoice,
+        openSessionBrowser,
+        closeSessionBrowser,
+        handleResumeSession,
+        handleDeleteSession,
+        setQueueErrorMessage,
+        popAllMessages,
+        handleApiKeySubmit,
+        handleApiKeyCancel,
+        setBannerVisible,
+        setEmbeddedShellFocused,
+        clearInteractivePasswordPrompt,
+        setViewMode,
+        setSpotlightOpen,
+        setAuthWizardDialog,
+    }), [
+        setSpotlightOpen,
+        handleThemeSelect,
+        closeThemeDialog,
+        handleThemeHighlight,
+        handleAuthSelect,
+        setAuthState,
+        onAuthError,
+        handleEditorSelect,
+        exitEditorDialog,
+        exitPrivacyNotice,
+        closeSettingsDialog,
+        closeModelDialog,
+        openPermissionsDialog,
+        closePermissionsDialog,
+        setShellModeActive,
+        vimHandleInput,
+        handleIdePromptComplete,
+        handleFolderTrustSelect,
+        setConstrainHeight,
+        handleEscapePromptChange,
+        refreshStatic,
+        handleFinalSubmit,
+        handleClearScreen,
+        handleProQuotaChoice,
+        openSessionBrowser,
+        closeSessionBrowser,
+        handleResumeSession,
+        handleDeleteSession,
+        setQueueErrorMessage,
+        popAllMessages,
+        handleApiKeySubmit,
+        handleApiKeyCancel,
+        setBannerVisible,
+        setEmbeddedShellFocused,
+        clearInteractivePasswordPrompt,
+        setViewMode,
+        setAuthWizardDialog,
+    ]);
+    return (_jsx(UIStateContext.Provider, { value: uiState, children: _jsx(UIActionsContext.Provider, { value: uiActions, children: _jsx(ConfigContext.Provider, { value: config, children: _jsx(AppContext.Provider, { value: {
+                        version: props.version,
+                        startupWarnings: props.startupWarnings || [],
+                    }, children: _jsx(VoiceStateContext.Provider, { value: voiceUiState, children: _jsx(ShellFocusContext.Provider, { value: isFocused, children: _jsx(App, {}) }) }) }) }) }) }));
+};
+//# sourceMappingURL=AppContainer.js.map