@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/hooks/useExtensionUpdates.js

@@ -0,0 +1,172 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger, checkExhaustive, getErrorMessage, } from '@google/gemini-cli-core';
+import { ExtensionUpdateState, extensionUpdatesReducer, initialExtensionUpdatesState, } from '../state/extensions.js';
+import { useCallback, useEffect, useMemo, useReducer } from 'react';
+import { MessageType } from '../types.js';
+import { checkForAllExtensionUpdates, updateExtension, } from '../../config/extensions/update.js';
+function confirmationRequestsReducer(state, action) {
+    switch (action.type) {
+        case 'add':
+            return [...state, action.request];
+        case 'remove':
+            return state.filter((r) => r !== action.request);
+        default:
+            checkExhaustive(action);
+    }
+}
+export const useConfirmUpdateRequests = () => {
+    const [confirmUpdateExtensionRequests, dispatchConfirmUpdateExtensionRequests,] = useReducer(confirmationRequestsReducer, []);
+    const addConfirmUpdateExtensionRequest = useCallback((original) => {
+        const wrappedRequest = {
+            prompt: original.prompt,
+            onConfirm: (confirmed) => {
+                // Remove it from the outstanding list of requests by identity.
+                dispatchConfirmUpdateExtensionRequests({
+                    type: 'remove',
+                    request: wrappedRequest,
+                });
+                original.onConfirm(confirmed);
+            },
+        };
+        dispatchConfirmUpdateExtensionRequests({
+            type: 'add',
+            request: wrappedRequest,
+        });
+    }, [dispatchConfirmUpdateExtensionRequests]);
+    return {
+        addConfirmUpdateExtensionRequest,
+        confirmUpdateExtensionRequests,
+        dispatchConfirmUpdateExtensionRequests,
+    };
+};
+export const useExtensionUpdates = (extensionManager, addItem, enableExtensionReloading) => {
+    const [extensionsUpdateState, dispatchExtensionStateUpdate] = useReducer(extensionUpdatesReducer, initialExtensionUpdatesState);
+    const extensions = extensionManager.getExtensions();
+    useEffect(() => {
+        const extensionsToCheck = extensions.filter((extension) => {
+            const currentStatus = extensionsUpdateState.extensionStatuses.get(extension.name);
+            if (!currentStatus)
+                return true;
+            const currentState = currentStatus.status;
+            return !currentState || currentState === ExtensionUpdateState.UNKNOWN;
+        });
+        if (extensionsToCheck.length === 0)
+            return;
+        void checkForAllExtensionUpdates(extensionsToCheck, extensionManager, dispatchExtensionStateUpdate).catch((e) => {
+            debugLogger.warn(getErrorMessage(e));
+        });
+    }, [
+        extensions,
+        extensionManager,
+        extensionsUpdateState.extensionStatuses,
+        dispatchExtensionStateUpdate,
+    ]);
+    useEffect(() => {
+        if (extensionsUpdateState.batchChecksInProgress > 0) {
+            return;
+        }
+        const scheduledUpdate = extensionsUpdateState.scheduledUpdate;
+        if (scheduledUpdate) {
+            dispatchExtensionStateUpdate({
+                type: 'CLEAR_SCHEDULED_UPDATE',
+            });
+        }
+        function shouldDoUpdate(extension) {
+            if (scheduledUpdate) {
+                if (scheduledUpdate.all) {
+                    return true;
+                }
+                return scheduledUpdate.names?.includes(extension.name) === true;
+            }
+            else {
+                return extension.installMetadata?.autoUpdate === true;
+            }
+        }
+        // We only notify if we have unprocessed extensions in the UPDATE_AVAILABLE
+        // state.
+        const pendingUpdates = [];
+        const updatePromises = [];
+        for (const extension of extensions) {
+            const currentState = extensionsUpdateState.extensionStatuses.get(extension.name);
+            if (!currentState ||
+                currentState.status !== ExtensionUpdateState.UPDATE_AVAILABLE) {
+                continue;
+            }
+            const shouldUpdate = shouldDoUpdate(extension);
+            if (!shouldUpdate) {
+                if (!currentState.notified) {
+                    // Mark as processed immediately to avoid re-triggering.
+                    dispatchExtensionStateUpdate({
+                        type: 'SET_NOTIFIED',
+                        payload: { name: extension.name, notified: true },
+                    });
+                    pendingUpdates.push(extension.name);
+                }
+            }
+            else {
+                const updatePromise = updateExtension(extension, extensionManager, currentState.status, dispatchExtensionStateUpdate, enableExtensionReloading);
+                updatePromises.push(updatePromise);
+                updatePromise
+                    .then((result) => {
+                    if (!result)
+                        return;
+                    addItem({
+                        type: MessageType.INFO,
+                        text: `Extension "${extension.name}" successfully updated: ${result.originalVersion} → ${result.updatedVersion}.`,
+                    }, Date.now());
+                })
+                    .catch((error) => {
+                    addItem({
+                        type: MessageType.ERROR,
+                        text: getErrorMessage(error),
+                    }, Date.now());
+                });
+            }
+        }
+        if (pendingUpdates.length > 0) {
+            const s = pendingUpdates.length > 1 ? 's' : '';
+            addItem({
+                type: MessageType.INFO,
+                text: `You have ${pendingUpdates.length} extension${s} with an update available. Run "/extensions update ${pendingUpdates.join(' ')}".`,
+            }, Date.now());
+        }
+        if (scheduledUpdate) {
+            void Promise.allSettled(updatePromises).then((results) => {
+                const successfulUpdates = results
+                    .filter((r) => r.status === 'fulfilled')
+                    .map((r) => r.value)
+                    .filter((v) => v !== undefined);
+                scheduledUpdate.onCompleteCallbacks.forEach((callback) => {
+                    try {
+                        callback(successfulUpdates);
+                    }
+                    catch (e) {
+                        debugLogger.warn(getErrorMessage(e));
+                    }
+                });
+            });
+        }
+    }, [
+        extensions,
+        extensionManager,
+        extensionsUpdateState,
+        addItem,
+        enableExtensionReloading,
+    ]);
+    const extensionsUpdateStateComputed = useMemo(() => {
+        const result = new Map();
+        for (const [key, value,] of extensionsUpdateState.extensionStatuses.entries()) {
+            result.set(key, value.status);
+        }
+        return result;
+    }, [extensionsUpdateState]);
+    return {
+        extensionsUpdateState: extensionsUpdateStateComputed,
+        extensionsUpdateStateInternal: extensionsUpdateState.extensionStatuses,
+        dispatchExtensionStateUpdate,
+    };
+};

package/dist/ui/hooks/useFlickerDetector.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { measureElement } from 'ink';
+;
+import { useEffect } from 'react';
+import { useConfig } from '../contexts/ConfigContext.js';
+import { recordFlickerFrame } from '@google/gemini-cli-core';
+import { appEvents, AppEvent } from '../../utils/events.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+/**
+ * A hook that detects when the UI flickers (renders taller than the terminal).
+ * This is a sign of a rendering bug that should be fixed.
+ *
+ * @param rootUiRef A ref to the root UI element.
+ * @param terminalHeight The height of the terminal.
+ */
+export function useFlickerDetector(rootUiRef, terminalHeight) {
+    const config = useConfig();
+    const { constrainHeight } = useUIState();
+    useEffect(() => {
+        if (rootUiRef.current) {
+            const measurement = measureElement(rootUiRef.current);
+            if (measurement.height > terminalHeight) {
+                // If we are not constraining the height, we are intentionally
+                // overflowing the screen.
+                if (!constrainHeight) {
+                    return;
+                }
+                recordFlickerFrame(config);
+                appEvents.emit(AppEvent.Flicker);
+            }
+        }
+    });
+}

package/dist/ui/hooks/useFocus.js

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useStdin, useStdout } from 'ink';
+;
+import { useEffect, useState } from 'react';
+import { useKeypress } from './useKeypress.js';
+// ANSI escape codes to enable/disable terminal focus reporting
+export const ENABLE_FOCUS_REPORTING = '\x1b[?1004h';
+export const DISABLE_FOCUS_REPORTING = '\x1b[?1004l';
+// ANSI escape codes for focus events
+export const FOCUS_IN = '\x1b[I';
+export const FOCUS_OUT = '\x1b[O';
+export const useFocus = () => {
+    const { stdin } = useStdin();
+    const { stdout } = useStdout();
+    const [isFocused, setIsFocused] = useState(true);
+    const [hasReceivedFocusEvent, setHasReceivedFocusEvent] = useState(false);
+    useEffect(() => {
+        const handleData = (data) => {
+            const sequence = data.toString();
+            const lastFocusIn = sequence.lastIndexOf(FOCUS_IN);
+            const lastFocusOut = sequence.lastIndexOf(FOCUS_OUT);
+            if (lastFocusIn > lastFocusOut) {
+                setHasReceivedFocusEvent(true);
+                setIsFocused(true);
+            }
+            else if (lastFocusOut > lastFocusIn) {
+                setHasReceivedFocusEvent(true);
+                setIsFocused(false);
+            }
+        };
+        // Enable focus reporting
+        stdout?.write(ENABLE_FOCUS_REPORTING);
+        stdin?.on('data', handleData);
+        return () => {
+            // Disable focus reporting on cleanup
+            stdout?.write(DISABLE_FOCUS_REPORTING);
+            stdin?.removeListener('data', handleData);
+        };
+    }, [stdin, stdout]);
+    useKeypress((_) => {
+        if (!isFocused) {
+            // If the user has typed a key, and we cannot possibly be focused out.
+            // This is a workaround for some tmux use cases. It is still useful to
+            // listen for the true FOCUS_IN event as well as that will update the
+            // focus state earlier than waiting for a keypress.
+            setIsFocused(true);
+        }
+    }, { isActive: true });
+    return {
+        isFocused,
+        hasReceivedFocusEvent,
+    };
+};

package/dist/ui/hooks/useFolderTrust.js

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { FolderTrustChoice } from '../components/FolderTrustDialog.js';
+import { loadTrustedFolders, TrustLevel, isWorkspaceTrusted, } from '../../config/trustedFolders.js';
+import * as process from 'node:process';
+import { MessageType } from '../types.js';
+import { coreEvents, ExitCodes, isHeadlessMode, FolderTrustDiscoveryService, } from '@google/gemini-cli-core';
+import { runExitCleanup } from '../../utils/cleanup.js';
+export const useFolderTrust = (settings, onTrustChange, addItem) => {
+    const [isTrusted, setIsTrusted] = useState(undefined);
+    const [isFolderTrustDialogOpen, setIsFolderTrustDialogOpen] = useState(false);
+    const [discoveryResults, setDiscoveryResults] = useState(null);
+    const [isRestarting, setIsRestarting] = useState(false);
+    const startupMessageSent = useRef(false);
+    const folderTrust = settings.merged.security.folderTrust.enabled ?? true;
+    useEffect(() => {
+        let isMounted = true;
+        const { isTrusted: trusted } = isWorkspaceTrusted(settings.merged);
+        if (trusted === undefined || trusted === false) {
+            void FolderTrustDiscoveryService.discover(process.cwd())
+                .then((results) => {
+                if (isMounted) {
+                    setDiscoveryResults(results);
+                }
+            })
+                .catch(() => {
+                // Silently ignore discovery errors as they are handled within the service
+                // and reported via results.discoveryErrors if successful.
+            });
+        }
+        const showUntrustedMessage = () => {
+            if (trusted === false && !startupMessageSent.current) {
+                addItem({
+                    type: MessageType.INFO,
+                    text: 'This folder is untrusted, project settings, hooks, MCPs, and GEMINI.md files will not be applied for this folder.\nUse the `/permissions` command to change the trust level.',
+                }, Date.now());
+                startupMessageSent.current = true;
+            }
+        };
+        if (isHeadlessMode()) {
+            if (isMounted) {
+                setIsTrusted(trusted);
+                setIsFolderTrustDialogOpen(false);
+                onTrustChange(true);
+                showUntrustedMessage();
+            }
+        }
+        else if (isMounted) {
+            setIsTrusted(trusted);
+            setIsFolderTrustDialogOpen(trusted === undefined);
+            onTrustChange(trusted);
+            showUntrustedMessage();
+        }
+        return () => {
+            isMounted = false;
+        };
+    }, [folderTrust, onTrustChange, settings.merged, addItem]);
+    const handleFolderTrustSelect = useCallback(async (choice) => {
+        const trustLevelMap = {
+            [FolderTrustChoice.TRUST_FOLDER]: TrustLevel.TRUST_FOLDER,
+            [FolderTrustChoice.TRUST_PARENT]: TrustLevel.TRUST_PARENT,
+            [FolderTrustChoice.DO_NOT_TRUST]: TrustLevel.DO_NOT_TRUST,
+        };
+        const trustLevel = trustLevelMap[choice];
+        if (!trustLevel)
+            return;
+        const cwd = process.cwd();
+        const trustedFolders = loadTrustedFolders();
+        try {
+            await trustedFolders.setValue(cwd, trustLevel);
+        }
+        catch {
+            coreEvents.emitFeedback('error', 'Failed to save trust settings. Exiting Gemini CLI.');
+            setTimeout(async () => {
+                await runExitCleanup();
+                process.exit(ExitCodes.FATAL_CONFIG_ERROR);
+            }, 100);
+            return;
+        }
+        const currentIsTrusted = trustLevel === TrustLevel.TRUST_FOLDER ||
+            trustLevel === TrustLevel.TRUST_PARENT;
+        onTrustChange(currentIsTrusted);
+        setIsTrusted(currentIsTrusted);
+        const wasTrusted = isTrusted ?? false;
+        if (wasTrusted !== currentIsTrusted) {
+            setIsRestarting(true);
+            setIsFolderTrustDialogOpen(true);
+        }
+        else {
+            setIsFolderTrustDialogOpen(false);
+        }
+    }, [onTrustChange, isTrusted]);
+    return {
+        isTrusted,
+        isFolderTrustDialogOpen,
+        discoveryResults,
+        handleFolderTrustSelect,
+        isRestarting,
+    };
+};