@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/IdeIntegrationNudge.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { RadioButtonSelect, } from './components/shared/RadioButtonSelect.js';
+import { useKeypress } from './hooks/useKeypress.js';
+import { theme } from './semantic-colors.js';
+export function IdeIntegrationNudge({ ide, onComplete, }) {
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            onComplete({
+                userSelection: 'no',
+                isExtensionPreInstalled: false,
+            });
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const { displayName: ideName } = ide;
+    // Assume extension is already installed if the env variables are set.
+    const isExtensionPreInstalled = !!process.env['GEMINI_CLI_IDE_SERVER_PORT'] &&
+        !!process.env['GEMINI_CLI_IDE_WORKSPACE_PATH'];
+    const OPTIONS = [
+        {
+            label: 'Yes',
+            value: {
+                userSelection: 'yes',
+                isExtensionPreInstalled,
+            },
+            key: 'Yes',
+        },
+        {
+            label: 'No (esc)',
+            value: {
+                userSelection: 'no',
+                isExtensionPreInstalled,
+            },
+            key: 'No (esc)',
+        },
+        {
+            label: "No, don't ask again",
+            value: {
+                userSelection: 'dismiss',
+                isExtensionPreInstalled,
+            },
+            key: "No, don't ask again",
+        },
+    ];
+    const installText = isExtensionPreInstalled
+        ? `If you select Yes, the CLI will have access to your open files and display diffs directly in ${ideName ?? 'your editor'}.`
+        : `If you select Yes, we'll install an extension that allows the CLI to access your open files and display diffs directly in ${ideName ?? 'your editor'}.`;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.status.warning, padding: 1, width: "100%", marginLeft: 1, children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.status.warning, children: '> ' }), `Do you want to connect ${ideName ?? 'your editor'} to Gemini CLI?`] }), _jsx(Text, { color: theme.text.secondary, children: installText })] }), _jsx(RadioButtonSelect, { items: OPTIONS, onSelect: onComplete })] }));
+}

package/dist/ui/auth/ApiAuthDialog.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useEffect } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { TextInput } from '../components/shared/TextInput.js';
+import { useTextBuffer } from '../components/shared/text-buffer.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { clearApiKey, debugLogger } from '@google/gemini-cli-core';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { Command } from '../key/keyMatchers.js';
+import { useKeyMatchers } from '../hooks/useKeyMatchers.js';
+export function ApiAuthDialog({ onSubmit, onCancel, error, defaultValue = '', }) {
+    const keyMatchers = useKeyMatchers();
+    const { terminalWidth } = useUIState();
+    const viewportWidth = terminalWidth - 8;
+    const pendingPromise = useRef(null);
+    useEffect(() => () => {
+        pendingPromise.current?.cancel();
+    }, []);
+    const initialApiKey = defaultValue;
+    const buffer = useTextBuffer({
+        initialText: initialApiKey || '',
+        initialCursorOffset: initialApiKey?.length || 0,
+        viewport: {
+            width: viewportWidth,
+            height: 4,
+        },
+        inputFilter: (text) => text.replace(/[^a-zA-Z0-9_.-]/g, '').replace(/[\r\n]/g, ''),
+        singleLine: true,
+    });
+    const handleSubmit = (value) => {
+        onSubmit(value);
+    };
+    const handleClear = () => {
+        pendingPromise.current?.cancel();
+        let isCancelled = false;
+        const wrappedPromise = new Promise((resolve, reject) => {
+            clearApiKey().then(() => !isCancelled && resolve(), (error) => !isCancelled && reject(error));
+        });
+        pendingPromise.current = {
+            cancel: () => {
+                isCancelled = true;
+            },
+        };
+        return wrappedPromise
+            .then(() => {
+            buffer.setText('');
+        })
+            .catch((err) => {
+            debugLogger.debug('Failed to clear API key:', err);
+        });
+    };
+    useKeypress((key) => {
+        if (keyMatchers[Command.CLEAR_INPUT](key)) {
+            void handleClear();
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.ui.focus, flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "Enter Gemini API Key" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.text.primary, children: "Please enter your Gemini API key. It will be securely stored in your system keychain." }), _jsxs(Text, { color: theme.text.secondary, children: ["You can get an API key from", ' ', _jsx(Text, { color: theme.text.link, children: "https://aistudio.google.com/app/apikey" })] })] }), _jsx(Box, { marginTop: 1, flexDirection: "row", children: _jsx(Box, { borderStyle: "round", borderColor: theme.border.default, paddingX: 1, flexGrow: 1, children: _jsx(TextInput, { buffer: buffer, onSubmit: handleSubmit, onCancel: onCancel, placeholder: "Paste your API key here" }) }) }), error && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, children: error }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.secondary, children: "(Press Enter to submit, Esc to cancel, Ctrl+C to clear stored key)" }) })] }));
+}

package/dist/ui/auth/AuthDialog.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { RadioButtonSelect } from '../components/shared/RadioButtonSelect.js';
+import { SettingScope, } from '../../config/settings.js';
+import { AuthType, clearCachedCredentialFile, } from '@google/gemini-cli-core';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { AuthState } from '../types.js';
+import { validateAuthMethodWithSettings } from './useAuth.js';
+import { relaunchApp } from '../../utils/processUtils.js';
+export function AuthDialog({ config, settings, setAuthState, authError, onAuthError, setAuthContext, }) {
+    const [exiting, setExiting] = useState(false);
+    let items = [
+        {
+            label: 'Sign in with Google',
+            value: AuthType.LOGIN_WITH_GOOGLE,
+            key: AuthType.LOGIN_WITH_GOOGLE,
+        },
+        ...(process.env['CLOUD_SHELL'] === 'true'
+            ? [
+                {
+                    label: 'Use Cloud Shell user credentials',
+                    value: AuthType.COMPUTE_ADC,
+                    key: AuthType.COMPUTE_ADC,
+                },
+            ]
+            : process.env['GEMINI_CLI_USE_COMPUTE_ADC'] === 'true'
+                ? [
+                    {
+                        label: 'Use metadata server application default credentials',
+                        value: AuthType.COMPUTE_ADC,
+                        key: AuthType.COMPUTE_ADC,
+                    },
+                ]
+                : []),
+        {
+            label: 'Use Gemini API Key',
+            value: AuthType.USE_GEMINI,
+            key: AuthType.USE_GEMINI,
+        },
+        {
+            label: 'Vertex AI',
+            value: AuthType.USE_VERTEX_AI,
+            key: AuthType.USE_VERTEX_AI,
+        },
+    ];
+    if (settings.merged.security.auth.enforcedType) {
+        items = items.filter((item) => item.value === settings.merged.security.auth.enforcedType);
+    }
+    let defaultAuthType = null;
+    const defaultAuthTypeEnv = process.env['GEMINI_DEFAULT_AUTH_TYPE'];
+    if (defaultAuthTypeEnv &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        Object.values(AuthType).includes(defaultAuthTypeEnv)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        defaultAuthType = defaultAuthTypeEnv;
+    }
+    let initialAuthIndex = items.findIndex((item) => {
+        if (settings.merged.security.auth.selectedType) {
+            return item.value === settings.merged.security.auth.selectedType;
+        }
+        if (defaultAuthType) {
+            return item.value === defaultAuthType;
+        }
+        if (process.env['GEMINI_API_KEY']) {
+            return item.value === AuthType.USE_GEMINI;
+        }
+        return item.value === AuthType.LOGIN_WITH_GOOGLE;
+    });
+    if (settings.merged.security.auth.enforcedType) {
+        initialAuthIndex = 0;
+    }
+    const onSelect = useCallback(async (authType, scope) => {
+        if (exiting) {
+            return;
+        }
+        if (authType) {
+            const needsRestart = authType === AuthType.LOGIN_WITH_GOOGLE ||
+                (authType === AuthType.USE_VERTEX_AI &&
+                    process.env['CLOUD_SHELL'] === 'true');
+            if (needsRestart) {
+                setAuthContext({ requiresRestart: true });
+            }
+            else {
+                setAuthContext({});
+            }
+            await clearCachedCredentialFile();
+            settings.setValue(scope, 'security.auth.selectedType', authType);
+            if (authType === AuthType.LOGIN_WITH_GOOGLE &&
+                config.isBrowserLaunchSuppressed()) {
+                setExiting(true);
+                setTimeout(relaunchApp, 100);
+                return;
+            }
+            if (authType === AuthType.USE_GEMINI) {
+                // Always show the API key input dialog so the user can
+                // explicitly enter or confirm their key, regardless of
+                // whether GEMINI_API_KEY env var or a stored key exists.
+                setAuthState(AuthState.AwaitingApiKeyInput);
+                return;
+            }
+        }
+        setAuthState(AuthState.Unauthenticated);
+    }, [settings, config, setAuthState, exiting, setAuthContext]);
+    const handleAuthSelect = async (authMethod) => {
+        const error = await validateAuthMethodWithSettings(authMethod, settings).catch((e) => (e instanceof Error ? e.message : String(e)));
+        if (error) {
+            onAuthError(error);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            onSelect(authMethod, SettingScope.User);
+        }
+    };
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            // Prevent exit if there is an error message.
+            // This means they user is not authenticated yet.
+            if (authError) {
+                return true;
+            }
+            if (settings.merged.security.auth.selectedType === undefined) {
+                // Prevent exiting if no auth method is set
+                onAuthError('You must select an auth method to proceed. Press Ctrl+C twice to exit.');
+                return true;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            onSelect(undefined, SettingScope.User);
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    if (exiting) {
+        return (_jsx(Box, { borderStyle: "round", borderColor: theme.ui.focus, flexDirection: "row", padding: 1, width: "100%", alignItems: "flex-start", children: _jsx(Text, { color: theme.text.primary, children: "Logging in with Google... Restarting Gemini CLI to continue." }) }));
+    }
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.ui.focus, flexDirection: "row", padding: 1, width: "100%", alignItems: "flex-start", children: [_jsx(Text, { color: theme.text.accent, children: "? " }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "Get started" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.primary, children: "How would you like to authenticate for this project?" }) }), _jsx(Box, { marginTop: 1, children: _jsx(RadioButtonSelect, { items: items, initialIndex: initialAuthIndex, onSelect: handleAuthSelect, onHighlight: () => {
+                                onAuthError(null);
+                            } }) }), authError && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, children: authError }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.secondary, children: "(Use Enter to select)" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.primary, children: "Terms of Services and Privacy Notice for Gemini CLI" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.link, children: 'https://geminicli.com/docs/resources/tos-privacy/' }) })] })] }));
+}

package/dist/ui/auth/AuthInProgress.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+;
+import { CliSpinner } from '../components/CliSpinner.js';
+import { theme } from '../semantic-colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+export function AuthInProgress({ onTimeout, }) {
+    const [timedOut, setTimedOut] = useState(false);
+    useKeypress((key) => {
+        if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+            onTimeout();
+        }
+    }, { isActive: true });
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            setTimedOut(true);
+            onTimeout();
+        }, 180000);
+        return () => clearTimeout(timer);
+    }, [onTimeout]);
+    return (_jsx(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "column", padding: 1, width: "100%", children: timedOut ? (_jsx(Text, { color: theme.status.error, children: "Authentication timed out. Please try again." })) : (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(CliSpinner, { type: "dots" }), " Waiting for authentication... (Press Esc or Ctrl+C to cancel)"] }) })) }));
+}

package/dist/ui/auth/BannedAccountDialog.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from 'react';
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { RadioButtonSelect } from '../components/shared/RadioButtonSelect.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { openBrowserSecurely, shouldLaunchBrowser, } from '@google/gemini-cli-core';
+import { runExitCleanup } from '../../utils/cleanup.js';
+export function BannedAccountDialog({ accountSuspensionInfo, onExit, onChangeAuth, }) {
+    const [errorMessage, setErrorMessage] = useState(null);
+    const appealUrl = accountSuspensionInfo.appealUrl;
+    const appealLinkText = accountSuspensionInfo.appealLinkText ?? 'Open the Google Form';
+    const items = useMemo(() => {
+        const menuItems = [];
+        if (appealUrl) {
+            menuItems.push({
+                label: appealLinkText,
+                value: 'open_form',
+                key: 'open_form',
+            });
+        }
+        menuItems.push({
+            label: 'Change authentication',
+            value: 'change_auth',
+            key: 'change_auth',
+        }, {
+            label: 'Exit',
+            value: 'exit',
+            key: 'exit',
+        });
+        return menuItems;
+    }, [appealUrl, appealLinkText]);
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            void handleExit();
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const handleExit = useCallback(async () => {
+        await runExitCleanup();
+        onExit();
+    }, [onExit]);
+    const handleSelect = useCallback(async (choice) => {
+        if (choice === 'open_form' && appealUrl) {
+            if (!shouldLaunchBrowser()) {
+                setErrorMessage(`Please open this URL in a browser: ${appealUrl}`);
+                return;
+            }
+            try {
+                await openBrowserSecurely(appealUrl);
+            }
+            catch {
+                setErrorMessage(`Failed to open browser. Please visit: ${appealUrl}`);
+            }
+        }
+        else if (choice === 'change_auth') {
+            onChangeAuth();
+        }
+        else {
+            await handleExit();
+        }
+    }, [handleExit, onChangeAuth, appealUrl]);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: theme.status.error, children: "Error: Account Suspended" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: accountSuspensionInfo.message }) }), appealUrl && (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Appeal URL:" }) }), _jsx(Box, { children: _jsxs(Text, { color: theme.text.link, children: ["[", appealUrl, "]"] }) })] })), errorMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, children: errorMessage }) })), _jsx(Box, { marginTop: 1, children: _jsx(RadioButtonSelect, { items: items, onSelect: (choice) => void handleSelect(choice) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Escape to exit" }) })] }));
+}

package/dist/ui/auth/LoginRestartDialog.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { relaunchApp } from '../../utils/processUtils.js';
+export const LoginRestartDialog = ({ onDismiss, config, message, }) => {
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            onDismiss();
+            return true;
+        }
+        else if (key.name === 'r' || key.name === 'R') {
+            setTimeout(async () => {
+                if (process.send) {
+                    const remoteSettings = config.getRemoteAdminSettings();
+                    if (remoteSettings) {
+                        process.send({
+                            type: 'admin-settings-update',
+                            settings: remoteSettings,
+                        });
+                    }
+                }
+                await relaunchApp();
+            }, 100);
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const displayMessage = message ??
+        "You've successfully signed in with Google. Gemini CLI needs to be restarted.";
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.status.warning, paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.status.warning, children: displayMessage }), _jsx(Text, { color: theme.status.warning, children: "Press R to restart, or Esc to choose a different authentication method." })] }));
+};

package/dist/ui/auth/useAuth.js

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { AuthType, loadApiKey, debugLogger, isAccountSuspendedError, ProjectIdRequiredError, } from '@google/gemini-cli-core';
+import { getErrorMessage } from '@google/gemini-cli-core';
+import { AuthState } from '../types.js';
+import { validateAuthMethod } from '../../config/auth.js';
+export async function validateAuthMethodWithSettings(authType, settings) {
+    const enforcedType = settings.merged.security.auth.enforcedType;
+    if (enforcedType && enforcedType !== authType) {
+        return `Authentication is enforced to be ${enforcedType}, but you are currently using ${authType}.`;
+    }
+    if (settings.merged.security.auth.useExternal) {
+        return null;
+    }
+    // If using Gemini API key, we don't validate it here as we might need to prompt for it.
+    if (authType === AuthType.USE_GEMINI) {
+        return null;
+    }
+    return validateAuthMethod(authType);
+}
+export const useAuthCommand = (settings, config, initialAuthError = null, initialAccountSuspensionInfo = null) => {
+    const [authState, setAuthState] = useState(initialAuthError ? AuthState.Updating : AuthState.Unauthenticated);
+    const [authError, setAuthError] = useState(initialAuthError);
+    const [accountSuspensionInfo, setAccountSuspensionInfo] = useState(initialAccountSuspensionInfo);
+    const [apiKeyDefaultValue, setApiKeyDefaultValue] = useState(undefined);
+    const onAuthError = useCallback((error) => {
+        setAuthError(error);
+        if (error) {
+            setAuthState(AuthState.Updating);
+        }
+    }, [setAuthError, setAuthState]);
+    const reloadApiKey = useCallback(async () => {
+        const envKey = process.env['GEMINI_API_KEY'];
+        if (envKey !== undefined) {
+            setApiKeyDefaultValue(envKey);
+            return envKey;
+        }
+        const storedKey = (await loadApiKey()) ?? '';
+        setApiKeyDefaultValue(storedKey);
+        return storedKey;
+    }, []);
+    useEffect(() => {
+        if (authState === AuthState.AwaitingApiKeyInput) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            reloadApiKey();
+        }
+    }, [authState, reloadApiKey]);
+    useEffect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        (async () => {
+            if (authState !== AuthState.Unauthenticated) {
+                return;
+            }
+            const authType = settings.merged.security.auth.selectedType;
+            if (!authType) {
+                if (process.env['GEMINI_API_KEY']) {
+                    onAuthError('Existing API key detected (GEMINI_API_KEY). Select "Gemini API Key" option to use it.');
+                }
+                else {
+                    onAuthError('No authentication method selected.');
+                }
+                return;
+            }
+            if (authType === AuthType.USE_GEMINI) {
+                const key = await reloadApiKey(); // Use the unified function
+                if (!key) {
+                    setAuthState(AuthState.AwaitingApiKeyInput);
+                    return;
+                }
+            }
+            const error = await validateAuthMethodWithSettings(authType, settings).catch((e) => getErrorMessage(e));
+            if (error) {
+                onAuthError(error);
+                return;
+            }
+            const defaultAuthType = process.env['GEMINI_DEFAULT_AUTH_TYPE'];
+            if (defaultAuthType &&
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                !Object.values(AuthType).includes(defaultAuthType)) {
+                onAuthError(`Invalid value for GEMINI_DEFAULT_AUTH_TYPE: "${defaultAuthType}". ` +
+                    `Valid values are: ${Object.values(AuthType).join(', ')}.`);
+                return;
+            }
+            try {
+                await config.refreshAuth(authType);
+                debugLogger.log(`Authenticated via "${authType}".`);
+                setAuthError(null);
+                setAuthState(AuthState.Authenticated);
+            }
+            catch (e) {
+                const suspendedError = isAccountSuspendedError(e);
+                if (suspendedError) {
+                    setAccountSuspensionInfo({
+                        message: suspendedError.message,
+                        appealUrl: suspendedError.appealUrl,
+                        appealLinkText: suspendedError.appealLinkText,
+                    });
+                }
+                else if (e instanceof ProjectIdRequiredError) {
+                    // OAuth succeeded but account setup requires project ID
+                    // Show the error message directly without "Failed to login" prefix
+                    onAuthError(getErrorMessage(e));
+                }
+                else {
+                    onAuthError(`Failed to sign in. Message: ${getErrorMessage(e)}`);
+                }
+            }
+        })();
+    }, [
+        settings,
+        config,
+        authState,
+        setAuthState,
+        setAuthError,
+        onAuthError,
+        reloadApiKey,
+    ]);
+    return {
+        authState,
+        setAuthState,
+        authError,
+        onAuthError,
+        apiKeyDefaultValue,
+        reloadApiKey,
+        accountSuspensionInfo,
+        setAccountSuspensionInfo,
+    };
+};

package/dist/ui/colors.js

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { themeManager } from './themes/theme-manager.js';
+export const Colors = {
+    get type() {
+        return themeManager.getActiveTheme().colors.type;
+    },
+    get Foreground() {
+        return themeManager.getActiveTheme().colors.Foreground;
+    },
+    get Background() {
+        return themeManager.getColors().Background;
+    },
+    get LightBlue() {
+        return themeManager.getActiveTheme().colors.LightBlue;
+    },
+    get AccentBlue() {
+        return themeManager.getActiveTheme().colors.AccentBlue;
+    },
+    get AccentPurple() {
+        return themeManager.getActiveTheme().colors.AccentPurple;
+    },
+    get AccentCyan() {
+        return themeManager.getActiveTheme().colors.AccentCyan;
+    },
+    get AccentGreen() {
+        return themeManager.getActiveTheme().colors.AccentGreen;
+    },
+    get AccentYellow() {
+        return themeManager.getActiveTheme().colors.AccentYellow;
+    },
+    get AccentRed() {
+        return themeManager.getActiveTheme().colors.AccentRed;
+    },
+    get DiffAdded() {
+        return themeManager.getActiveTheme().colors.DiffAdded;
+    },
+    get DiffRemoved() {
+        return themeManager.getActiveTheme().colors.DiffRemoved;
+    },
+    get Comment() {
+        return themeManager.getActiveTheme().colors.Comment;
+    },
+    get Gray() {
+        return themeManager.getActiveTheme().colors.Gray;
+    },
+    get DarkGray() {
+        return themeManager.getColors().DarkGray;
+    },
+    get InputBackground() {
+        return themeManager.getColors().InputBackground;
+    },
+    get MessageBackground() {
+        return themeManager.getColors().MessageBackground;
+    },
+    get GradientColors() {
+        return themeManager.getActiveTheme().colors.GradientColors;
+    },
+};

package/dist/ui/commands/aboutCommand.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind, } from './types.js';
+import process from 'node:process';
+import { MessageType } from '../types.js';
+import { IdeClient, UserAccountManager, debugLogger, getVersion, } from '@google/gemini-cli-core';
+export const aboutCommand = {
+    name: 'about',
+    description: 'Show version info',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    isSafeConcurrent: true,
+    action: async (context) => {
+        const osVersion = process.platform;
+        let sandboxEnv = 'no sandbox';
+        if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') {
+            sandboxEnv = process.env['SANDBOX'];
+        }
+        else if (process.env['SANDBOX'] === 'sandbox-exec') {
+            sandboxEnv = `sandbox-exec (${process.env['SEATBELT_PROFILE'] || 'unknown'})`;
+        }
+        const modelVersion = context.services.agentContext?.config.getModel() || 'Unknown';
+        const cliVersion = await getVersion();
+        const selectedAuthType = context.services.settings.merged.security.auth.selectedType || '';
+        const gcpProject = process.env['GOOGLE_CLOUD_PROJECT'] || '';
+        const ideClient = await getIdeClientName(context);
+        const userAccountManager = new UserAccountManager();
+        const cachedAccount = userAccountManager.getCachedGoogleAccount();
+        debugLogger.log('AboutCommand: Retrieved cached Google account', {
+            cachedAccount,
+        });
+        const userEmail = cachedAccount ?? undefined;
+        const tier = context.services.agentContext?.config.getUserTierName();
+        const aboutItem = {
+            type: MessageType.ABOUT,
+            cliVersion,
+            osVersion,
+            sandboxEnv,
+            modelVersion,
+            selectedAuthType,
+            gcpProject,
+            ideClient,
+            userEmail,
+            tier,
+        };
+        context.ui.addItem(aboutItem);
+    },
+};
+async function getIdeClientName(context) {
+    if (!context.services.agentContext?.config.getIdeMode()) {
+        return '';
+    }
+    const ideClient = await IdeClient.getInstance();
+    return ideClient?.getDetectedIdeDisplayName() ?? '';
+}