@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/components/messages/ToolConfirmationMessage.js

@@ -0,0 +1,577 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useCallback, useState, useRef } from 'react';
+import { Box, Text } from 'ink';
+;
+import Polyfill from 'resize-observer-polyfill';
+const ResizeObserver = Polyfill.default || Polyfill.ResizeObserver || Polyfill;
+import { DiffRenderer } from './DiffRenderer.js';
+import { RenderInline } from '../../utils/InlineMarkdownRenderer.js';
+import { ToolConfirmationOutcome, ApprovalMode, hasRedirection, debugLogger, } from '@google/gemini-cli-core';
+import { useToolActions } from '../../contexts/ToolActionsContext.js';
+import { RadioButtonSelect, } from '../shared/RadioButtonSelect.js';
+import { MaxSizedBox } from '../shared/MaxSizedBox.js';
+import { sanitizeForDisplay, stripUnsafeCharacters, } from '../../utils/textUtils.js';
+import { useKeypress } from '../../hooks/useKeypress.js';
+import { theme } from '../../semantic-colors.js';
+import { themeManager } from '../../themes/theme-manager.js';
+import { useSettings } from '../../contexts/SettingsContext.js';
+import { Command } from '../../key/keyMatchers.js';
+import { formatCommand } from '../../key/keybindingUtils.js';
+import { AskUserDialog } from '../AskUserDialog.js';
+import { ExitPlanModeDialog } from '../ExitPlanModeDialog.js';
+import { WarningMessage } from './WarningMessage.js';
+import { colorizeCode } from '../../utils/CodeColorizer.js';
+import { getDeceptiveUrlDetails, toUnicodeUrl, } from '../../utils/urlSecurityUtils.js';
+import { useKeyMatchers } from '../../hooks/useKeyMatchers.js';
+import { isShellTool } from './ToolShared.js';
+export const ToolConfirmationMessage = ({ callId, confirmationDetails, config, getPreferredEditor, isFocused = true, availableTerminalHeight, terminalWidth, toolName, }) => {
+    const keyMatchers = useKeyMatchers();
+    const { confirm, isDiffingEnabled } = useToolActions();
+    const [mcpDetailsExpansionState, setMcpDetailsExpansionState] = useState({
+        callId,
+        expanded: false,
+    });
+    const [isCancelling, setIsCancelling] = useState(false);
+    const isMcpToolDetailsExpanded = mcpDetailsExpansionState.callId === callId
+        ? mcpDetailsExpansionState.expanded
+        : false;
+    const [measuredSecurityWarningsHeight, setMeasuredSecurityWarningsHeight] = useState(0);
+    const observerRef = useRef(null);
+    useEffect(() => () => {
+        observerRef.current?.disconnect();
+    }, []);
+    const deceptiveUrlWarnings = useMemo(() => {
+        const urls = [];
+        if (confirmationDetails.type === 'info' && confirmationDetails.urls) {
+            urls.push(...confirmationDetails.urls);
+        }
+        else if (confirmationDetails.type === 'exec') {
+            const commands = confirmationDetails.commands && confirmationDetails.commands.length > 0
+                ? confirmationDetails.commands
+                : [confirmationDetails.command];
+            for (const cmd of commands) {
+                const matches = cmd.match(/https?:\/\/[^\s"'`<>;&|()]+/g);
+                if (matches)
+                    urls.push(...matches);
+            }
+        }
+        const uniqueUrls = Array.from(new Set(urls));
+        return uniqueUrls
+            .map(getDeceptiveUrlDetails)
+            .filter((d) => d !== null);
+    }, [confirmationDetails]);
+    const deceptiveUrlWarningText = useMemo(() => {
+        if (deceptiveUrlWarnings.length === 0)
+            return null;
+        return `**Warning:** Deceptive URL(s) detected:\n\n${deceptiveUrlWarnings
+            .map((w) => `   **Original:** ${w.originalUrl}\n   **Actual Host (Punycode):** ${w.punycodeUrl}`)
+            .join('\n\n')}`;
+    }, [deceptiveUrlWarnings]);
+    const onSecurityWarningsRefChange = useCallback((node) => {
+        if (observerRef.current) {
+            observerRef.current.disconnect();
+            observerRef.current = null;
+        }
+        if (node) {
+            const observer = new ResizeObserver((entries) => {
+                const entry = entries[0];
+                if (entry) {
+                    const newHeight = Math.round(entry.contentRect.height);
+                    setMeasuredSecurityWarningsHeight((prev) => newHeight !== prev ? newHeight : prev);
+                }
+            });
+            observer.observe(node);
+            observerRef.current = observer;
+        }
+        else {
+            setMeasuredSecurityWarningsHeight((prev) => (prev !== 0 ? 0 : prev));
+        }
+    }, []);
+    const settings = useSettings();
+    const activeTheme = themeManager.getActiveTheme();
+    const allowPermanentApproval = settings.merged.security.enablePermanentToolApproval &&
+        !config.getDisableAlwaysAllow();
+    const handlesOwnUI = confirmationDetails.type === 'ask_user' ||
+        confirmationDetails.type === 'exit_plan_mode';
+    const isTrustedFolder = config.isTrustedFolder() && !config.getDisableAlwaysAllow();
+    const handleConfirm = useCallback((outcome, payload) => {
+        void confirm(callId, outcome, payload).catch((error) => {
+            debugLogger.error(`Failed to handle tool confirmation for ${callId}:`, error);
+        });
+    }, [confirm, callId]);
+    const mcpToolDetailsText = useMemo(() => {
+        if (confirmationDetails.type !== 'mcp') {
+            return null;
+        }
+        const detailsLines = [];
+        const hasNonEmptyToolArgs = confirmationDetails.toolArgs !== undefined &&
+            !(typeof confirmationDetails.toolArgs === 'object' &&
+                confirmationDetails.toolArgs !== null &&
+                Object.keys(confirmationDetails.toolArgs).length === 0);
+        if (hasNonEmptyToolArgs) {
+            let argsText;
+            try {
+                argsText = stripUnsafeCharacters(JSON.stringify(confirmationDetails.toolArgs, null, 2));
+            }
+            catch {
+                argsText = '[unserializable arguments]';
+            }
+            detailsLines.push('Invocation Arguments:');
+            detailsLines.push(argsText);
+        }
+        const description = confirmationDetails.toolDescription?.trim();
+        if (description) {
+            if (detailsLines.length > 0) {
+                detailsLines.push('');
+            }
+            detailsLines.push('Description:');
+            detailsLines.push(stripUnsafeCharacters(description));
+        }
+        if (confirmationDetails.toolParameterSchema !== undefined) {
+            let schemaText;
+            try {
+                schemaText = stripUnsafeCharacters(JSON.stringify(confirmationDetails.toolParameterSchema, null, 2));
+            }
+            catch {
+                schemaText = '[unserializable schema]';
+            }
+            if (detailsLines.length > 0) {
+                detailsLines.push('');
+            }
+            detailsLines.push('Input Schema:');
+            detailsLines.push(schemaText);
+        }
+        if (detailsLines.length === 0) {
+            return null;
+        }
+        return detailsLines.join('\n');
+    }, [confirmationDetails]);
+    const hasMcpToolDetails = !!mcpToolDetailsText;
+    const expandDetailsHintKey = formatCommand(Command.SHOW_MORE_LINES);
+    useKeypress((key) => {
+        if (!isFocused)
+            return false;
+        if (confirmationDetails.type === 'mcp' &&
+            hasMcpToolDetails &&
+            keyMatchers[Command.SHOW_MORE_LINES](key)) {
+            setMcpDetailsExpansionState({
+                callId,
+                expanded: !isMcpToolDetailsExpanded,
+            });
+            return true;
+        }
+        if (keyMatchers[Command.ESCAPE](key)) {
+            setIsCancelling(true);
+            return true;
+        }
+        if (keyMatchers[Command.QUIT](key)) {
+            return false;
+        }
+        return false;
+    }, { isActive: isFocused, priority: true });
+    // TODO(#23009): Remove this hack once we migrate to the new renderer.
+    // Why useEffect is used here instead of calling handleConfirm directly:
+    // There is a race condition where calling handleConfirm immediately upon
+    // keypress removes the tool UI component while the UI is in an expanded state.
+    // This simultaneously triggers setConstrainHeight, causing render two footers.
+    // By bridging the cancel action through state (isCancelling) and this useEffect,
+    // we delay handleConfirm until the next render cycle, ensuring setConstrainHeight
+    // resolves properly first.
+    useEffect(() => {
+        if (isCancelling) {
+            handleConfirm(ToolConfirmationOutcome.Cancel);
+        }
+    }, [isCancelling, handleConfirm]);
+    const handleSelect = useCallback((item) => handleConfirm(item), [handleConfirm]);
+    const getOptions = useCallback(() => {
+        const options = [];
+        if (confirmationDetails.type === 'edit') {
+            if (!confirmationDetails.isModifying) {
+                options.push({
+                    label: 'Allow once',
+                    value: ToolConfirmationOutcome.ProceedOnce,
+                    key: 'Allow once',
+                });
+                if (isTrustedFolder) {
+                    options.push({
+                        label: 'Allow for this session',
+                        value: ToolConfirmationOutcome.ProceedAlways,
+                        key: 'Allow for this session',
+                    });
+                    if (allowPermanentApproval) {
+                        options.push({
+                            label: 'Allow for this file in all future sessions',
+                            value: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                            key: 'Allow for this file in all future sessions',
+                        });
+                    }
+                }
+                // We hide "Modify with external editor" if IDE mode is active AND
+                // the IDE is actually capable of showing a diff (connected).
+                if (!config.getIdeMode() || !isDiffingEnabled) {
+                    options.push({
+                        label: 'Modify with external editor',
+                        value: ToolConfirmationOutcome.ModifyWithEditor,
+                        key: 'Modify with external editor',
+                    });
+                }
+                options.push({
+                    label: 'No, suggest changes (esc)',
+                    value: ToolConfirmationOutcome.Cancel,
+                    key: 'No, suggest changes (esc)',
+                });
+            }
+        }
+        else if (confirmationDetails.type === 'sandbox_expansion') {
+            options.push({
+                label: 'Allow once',
+                value: ToolConfirmationOutcome.ProceedOnce,
+                key: 'Allow once',
+            });
+            if (isTrustedFolder) {
+                options.push({
+                    label: 'Allow for this session',
+                    value: ToolConfirmationOutcome.ProceedAlways,
+                    key: 'Allow for this session',
+                });
+                if (allowPermanentApproval) {
+                    options.push({
+                        label: 'Allow for all future sessions',
+                        value: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        key: 'Allow for all future sessions',
+                    });
+                }
+            }
+            options.push({
+                label: 'No, suggest changes (esc)',
+                value: ToolConfirmationOutcome.Cancel,
+                key: 'No, suggest changes (esc)',
+            });
+        }
+        else if (confirmationDetails.type === 'exec') {
+            options.push({
+                label: 'Allow once',
+                value: ToolConfirmationOutcome.ProceedOnce,
+                key: 'Allow once',
+            });
+            if (isTrustedFolder) {
+                options.push({
+                    label: `Allow for this session`,
+                    value: ToolConfirmationOutcome.ProceedAlways,
+                    key: `Allow for this session`,
+                });
+                if (allowPermanentApproval) {
+                    options.push({
+                        label: `Allow this command for all future sessions`,
+                        value: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        key: `Allow for all future sessions`,
+                    });
+                }
+            }
+            options.push({
+                label: 'No, suggest changes (esc)',
+                value: ToolConfirmationOutcome.Cancel,
+                key: 'No, suggest changes (esc)',
+            });
+        }
+        else if (confirmationDetails.type === 'info') {
+            options.push({
+                label: 'Allow once',
+                value: ToolConfirmationOutcome.ProceedOnce,
+                key: 'Allow once',
+            });
+            if (isTrustedFolder) {
+                options.push({
+                    label: 'Allow for this session',
+                    value: ToolConfirmationOutcome.ProceedAlways,
+                    key: 'Allow for this session',
+                });
+                if (allowPermanentApproval) {
+                    options.push({
+                        label: 'Allow for all future sessions',
+                        value: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        key: 'Allow for all future sessions',
+                    });
+                }
+            }
+            options.push({
+                label: 'No, suggest changes (esc)',
+                value: ToolConfirmationOutcome.Cancel,
+                key: 'No, suggest changes (esc)',
+            });
+        }
+        else if (confirmationDetails.type === 'mcp') {
+            options.push({
+                label: 'Allow once',
+                value: ToolConfirmationOutcome.ProceedOnce,
+                key: 'Allow once',
+            });
+            if (isTrustedFolder) {
+                options.push({
+                    label: 'Allow tool for this session',
+                    value: ToolConfirmationOutcome.ProceedAlwaysTool,
+                    key: 'Allow tool for this session',
+                });
+                options.push({
+                    label: 'Allow all server tools for this session',
+                    value: ToolConfirmationOutcome.ProceedAlwaysServer,
+                    key: 'Allow all server tools for this session',
+                });
+                if (allowPermanentApproval) {
+                    options.push({
+                        label: 'Allow tool for all future sessions',
+                        value: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        key: 'Allow tool for all future sessions',
+                    });
+                }
+            }
+            options.push({
+                label: 'No, suggest changes (esc)',
+                value: ToolConfirmationOutcome.Cancel,
+                key: 'No, suggest changes (esc)',
+            });
+        }
+        return options;
+    }, [
+        confirmationDetails,
+        isTrustedFolder,
+        allowPermanentApproval,
+        config,
+        isDiffingEnabled,
+    ]);
+    const availableBodyContentHeight = useCallback(() => {
+        if (availableTerminalHeight === undefined) {
+            return undefined;
+        }
+        if (handlesOwnUI) {
+            return availableTerminalHeight;
+        }
+        // Calculate the vertical space (in lines) consumed by UI elements
+        // surrounding the main body content.
+        const PADDING_OUTER_Y = 0;
+        const HEIGHT_QUESTION = 1;
+        const MARGIN_QUESTION_TOP = 0;
+        const MARGIN_QUESTION_BOTTOM = 1;
+        const SECURITY_WARNING_BOTTOM_MARGIN = 1;
+        const SHOW_MORE_LINES_HEIGHT = 1;
+        const optionsCount = getOptions().length;
+        const securityWarningsHeight = deceptiveUrlWarningText
+            ? measuredSecurityWarningsHeight + SECURITY_WARNING_BOTTOM_MARGIN
+            : 0;
+        let extraInfoLines = 0;
+        if (confirmationDetails.type === 'sandbox_expansion') {
+            const { additionalPermissions } = confirmationDetails;
+            if (additionalPermissions?.network)
+                extraInfoLines++;
+            extraInfoLines += additionalPermissions?.fileSystem?.read?.length || 0;
+            extraInfoLines += additionalPermissions?.fileSystem?.write?.length || 0;
+        }
+        else if (confirmationDetails.type === 'exec') {
+            const executionProps = confirmationDetails;
+            const commandsToDisplay = executionProps.commands && executionProps.commands.length > 0
+                ? executionProps.commands
+                : [executionProps.command];
+            const containsRedirection = commandsToDisplay.some((cmd) => hasRedirection(cmd));
+            const isAutoEdit = config.getApprovalMode() === ApprovalMode.YOLO ||
+                config.getApprovalMode() === ApprovalMode.AUTO_EDIT;
+            if (containsRedirection && !isAutoEdit) {
+                extraInfoLines = 1; // Warning line
+            }
+        }
+        const surroundingElementsHeight = PADDING_OUTER_Y +
+            HEIGHT_QUESTION +
+            MARGIN_QUESTION_TOP +
+            MARGIN_QUESTION_BOTTOM +
+            SHOW_MORE_LINES_HEIGHT +
+            optionsCount +
+            securityWarningsHeight +
+            extraInfoLines;
+        return Math.max(availableTerminalHeight - surroundingElementsHeight, 2);
+    }, [
+        availableTerminalHeight,
+        handlesOwnUI,
+        getOptions,
+        measuredSecurityWarningsHeight,
+        deceptiveUrlWarningText,
+        confirmationDetails,
+        config,
+    ]);
+    const { question, bodyContent, options, securityWarnings, initialIndex } = useMemo(() => {
+        let bodyContent = null;
+        let securityWarnings = null;
+        let question = '';
+        const options = getOptions();
+        let initialIndex = 0;
+        if (isTrustedFolder && allowPermanentApproval) {
+            // It is safe to allow permanent approval for info, edit, and mcp tools
+            // in trusted folders because the generated policy rules are narrowed
+            // to specific files, patterns, or tools (rather than allowing all access).
+            const isSafeToPersist = confirmationDetails.type === 'info' ||
+                confirmationDetails.type === 'edit' ||
+                confirmationDetails.type === 'mcp';
+            if (isSafeToPersist &&
+                settings.merged.security.autoAddToPolicyByDefault) {
+                const alwaysAndSaveIndex = options.findIndex((o) => o.value === ToolConfirmationOutcome.ProceedAlwaysAndSave);
+                if (alwaysAndSaveIndex !== -1) {
+                    initialIndex = alwaysAndSaveIndex;
+                }
+            }
+        }
+        if (deceptiveUrlWarningText) {
+            securityWarnings = _jsx(WarningMessage, { text: deceptiveUrlWarningText });
+        }
+        const bodyHeight = availableBodyContentHeight();
+        if (confirmationDetails.type === 'ask_user') {
+            bodyContent = (_jsx(AskUserDialog, { questions: confirmationDetails.questions, onSubmit: (answers) => {
+                    handleConfirm(ToolConfirmationOutcome.ProceedOnce, { answers });
+                }, onCancel: () => {
+                    handleConfirm(ToolConfirmationOutcome.Cancel);
+                }, width: terminalWidth, availableHeight: bodyHeight }));
+            return {
+                question: '',
+                bodyContent,
+                options: [],
+                securityWarnings: null,
+                initialIndex: 0,
+            };
+        }
+        if (confirmationDetails.type === 'exit_plan_mode') {
+            bodyContent = (_jsx(ExitPlanModeDialog, { planPath: confirmationDetails.planPath, getPreferredEditor: getPreferredEditor, onApprove: (approvalMode) => {
+                    handleConfirm(ToolConfirmationOutcome.ProceedOnce, {
+                        approved: true,
+                        approvalMode,
+                    });
+                }, onFeedback: (feedback) => {
+                    handleConfirm(ToolConfirmationOutcome.ProceedOnce, {
+                        approved: false,
+                        feedback,
+                    });
+                }, onCancel: () => {
+                    handleConfirm(ToolConfirmationOutcome.Cancel);
+                }, width: terminalWidth, availableHeight: bodyHeight }));
+            return {
+                question: '',
+                bodyContent,
+                options: [],
+                securityWarnings: null,
+                initialIndex: 0,
+            };
+        }
+        if (confirmationDetails.type === 'edit') {
+            if (!confirmationDetails.isModifying) {
+                question = `Apply this change?`;
+                bodyContent = (_jsx(_Fragment, { children: _jsx(Box, { borderStyle: "round", borderColor: theme.border.default, paddingX: 1, paddingY: 0, marginBottom: 0, children: _jsx(DiffRenderer, { diffContent: stripUnsafeCharacters(confirmationDetails.fileDiff), filename: sanitizeForDisplay(confirmationDetails.fileName), availableTerminalHeight: bodyHeight !== undefined
+                                ? Math.max(bodyHeight - 2, 2)
+                                : undefined, terminalWidth: Math.max(terminalWidth, 1) - 4 }) }) }));
+            }
+        }
+        else if (confirmationDetails.type === 'sandbox_expansion') {
+            const { additionalPermissions, command } = confirmationDetails;
+            const readPaths = additionalPermissions?.fileSystem?.read || [];
+            const writePaths = additionalPermissions?.fileSystem?.write || [];
+            const network = additionalPermissions?.network;
+            const isShell = isShellTool(toolName);
+            const commandNames = isShell ? 'Shell' : toolName;
+            question = '';
+            bodyContent = (_jsxs(_Fragment, { children: [_jsx(Box, { borderStyle: "round", borderColor: theme.border.default, paddingX: 1, paddingY: 0, marginBottom: 0, children: colorizeCode({
+                            code: command.trim(),
+                            language: 'bash',
+                            maxWidth: Math.max(terminalWidth, 1) - 6,
+                            settings,
+                            theme: activeTheme,
+                            hideLineNumbers: true,
+                            availableHeight: bodyHeight !== undefined
+                                ? Math.max(bodyHeight - 2, 2)
+                                : undefined,
+                        }) }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["To run", ' ', _jsxs(Text, { color: isShell ? theme.status.warning : undefined, bold: isShell, children: ["[", sanitizeForDisplay(commandNames), "]"] }), ", allow access to the following?"] }), network && (_jsxs(Text, { children: [_jsx(Text, { color: isShell ? theme.status.warning : undefined, bold: true, children: "\u2022 Network:" }), ' ', "All Urls"] })), writePaths.length > 0 && (_jsxs(Text, { children: [_jsx(Text, { color: isShell ? theme.status.warning : undefined, bold: true, children: "\u2022 Write:" }), ' ', writePaths.map((p) => sanitizeForDisplay(p)).join(', ')] })), readPaths.length > 0 && (_jsxs(Text, { children: [_jsx(Text, { color: isShell ? theme.status.warning : undefined, bold: true, children: "\u2022 Read:" }), ' ', readPaths.map((p) => sanitizeForDisplay(p)).join(', ')] }))] })] }));
+        }
+        else if (confirmationDetails.type === 'exec') {
+            const executionProps = confirmationDetails;
+            const isShell = isShellTool(toolName);
+            const commandsToDisplay = executionProps.commands && executionProps.commands.length > 1
+                ? executionProps.commands
+                : [executionProps.command];
+            const containsRedirection = commandsToDisplay.some((cmd) => hasRedirection(cmd));
+            const isAutoEdit = config.getApprovalMode() === ApprovalMode.YOLO ||
+                config.getApprovalMode() === ApprovalMode.AUTO_EDIT;
+            let warnings = null;
+            if (containsRedirection && !isAutoEdit) {
+                const tipText = `To auto-accept, press ${formatCommand(Command.CYCLE_APPROVAL_MODE)}`;
+                warnings = (_jsx(Box, { flexDirection: "column", marginBottom: 0, children: _jsxs(Text, { color: theme.text.primary, children: ["Redirection detected.", ' ', _jsx(Text, { color: theme.text.secondary, children: tipText })] }) }));
+            }
+            const commandNames = isShell ? 'Shell' : toolName;
+            const allowQuestion = (_jsxs(Text, { children: ["Allow execution of", ' ', _jsxs(Text, { color: isShell ? theme.status.warning : undefined, bold: isShell, children: ["[", sanitizeForDisplay(commandNames), "]"] }), '?'] }));
+            question = (_jsxs(Box, { flexDirection: "column", children: [allowQuestion, warnings] }));
+            bodyContent = (_jsx(_Fragment, { children: _jsx(Box, { borderStyle: "round", borderColor: theme.border.default, paddingX: 1, paddingY: 0, marginBottom: 0, children: _jsx(MaxSizedBox, { maxHeight: bodyHeight !== undefined
+                            ? Math.max(bodyHeight - 2, 2)
+                            : undefined, maxWidth: Math.max(terminalWidth, 1) - 4, children: _jsx(Box, { flexDirection: "column", children: commandsToDisplay.map((cmd, idx) => (_jsx(Box, { flexDirection: "column", paddingBottom: idx < commandsToDisplay.length - 1 ? 1 : 0, children: colorizeCode({
+                                    code: cmd.trim(),
+                                    language: 'bash',
+                                    maxWidth: Math.max(terminalWidth, 1) - 6,
+                                    settings,
+                                    theme: activeTheme,
+                                    hideLineNumbers: true,
+                                    availableHeight: bodyHeight !== undefined
+                                        ? Math.max(bodyHeight - 2, 2)
+                                        : undefined,
+                                }) }, idx))) }) }) }) }));
+        }
+        else if (confirmationDetails.type === 'info') {
+            question = `Do you want to proceed?`;
+            const infoProps = confirmationDetails;
+            const displayUrls = infoProps.urls &&
+                !(infoProps.urls.length === 1 &&
+                    infoProps.urls[0] === infoProps.prompt);
+            bodyContent = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.text.link, children: _jsx(RenderInline, { text: infoProps.prompt, defaultColor: theme.text.link }) }), displayUrls && infoProps.urls && infoProps.urls.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.text.primary, children: "URLs to fetch:" }), infoProps.urls.map((urlString) => (_jsxs(Text, { children: [' ', "- ", _jsx(RenderInline, { text: toUnicodeUrl(urlString) })] }, urlString)))] }))] }));
+        }
+        else if (confirmationDetails.type === 'mcp') {
+            const mcpProps = confirmationDetails;
+            question = `Allow execution of MCP tool "${sanitizeForDisplay(mcpProps.toolName)}" from server "${sanitizeForDisplay(mcpProps.serverName)}"?`;
+            bodyContent = (_jsxs(Box, { flexDirection: "column", children: [_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.text.link, children: ["MCP Server: ", sanitizeForDisplay(mcpProps.serverName)] }), _jsxs(Text, { color: theme.text.link, children: ["Tool: ", sanitizeForDisplay(mcpProps.toolName)] })] }), hasMcpToolDetails && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.text.primary, children: "MCP Tool Details:" }), isMcpToolDetailsExpanded ? (_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.text.secondary, children: ["(press ", expandDetailsHintKey, " to collapse MCP tool details)"] }), _jsx(Box, { borderStyle: "round", borderColor: theme.border.default, paddingX: 1, paddingY: 0, marginBottom: 0, children: colorizeCode({
+                                            code: mcpToolDetailsText || '',
+                                            language: 'json',
+                                            maxWidth: Math.max(terminalWidth, 1) - 4,
+                                            settings,
+                                            theme: activeTheme,
+                                            hideLineNumbers: true,
+                                            availableHeight: bodyHeight !== undefined
+                                                ? Math.max(bodyHeight - 2, 2)
+                                                : undefined,
+                                        }) })] })) : (_jsxs(Text, { color: theme.text.secondary, children: ["(press ", expandDetailsHintKey, " to expand MCP tool details)"] }))] }))] }));
+        }
+        return { question, bodyContent, options, securityWarnings, initialIndex };
+    }, [
+        confirmationDetails,
+        getOptions,
+        availableBodyContentHeight,
+        terminalWidth,
+        handleConfirm,
+        deceptiveUrlWarningText,
+        isMcpToolDetailsExpanded,
+        hasMcpToolDetails,
+        mcpToolDetailsText,
+        expandDetailsHintKey,
+        getPreferredEditor,
+        isTrustedFolder,
+        allowPermanentApproval,
+        settings,
+        activeTheme,
+        config,
+        toolName,
+    ]);
+    const bodyOverflowDirection = confirmationDetails.type === 'mcp' && isMcpToolDetailsExpanded
+        ? 'bottom'
+        : 'top';
+    const renderRadioItem = useCallback((item, { titleColor }) => {
+        if (item.value === ToolConfirmationOutcome.ProceedAlwaysAndSave) {
+            return (_jsxs(Text, { color: titleColor, wrap: "truncate", children: [item.label, ' ', _jsx(Text, { color: theme.text.secondary, children: "~/.gemini/policies/auto-saved.toml" })] }));
+        }
+        return (_jsx(Text, { color: titleColor, wrap: "truncate", children: item.label }));
+    }, []);
+    if (confirmationDetails.type === 'edit') {
+        if (confirmationDetails.isModifying) {
+            return (_jsxs(Box, { width: terminalWidth, borderStyle: "round", borderColor: theme.border.default, justifyContent: "space-around", paddingTop: 1, paddingBottom: 1, overflow: "hidden", children: [_jsx(Text, { color: theme.text.primary, children: "Modify in progress: " }), _jsx(Text, { color: theme.status.success, children: "Save and close external editor to continue" })] }));
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingTop: 0, paddingBottom: 0, children: [!!confirmationDetails.systemMessage && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.status.warning, children: confirmationDetails.systemMessage }) })), handlesOwnUI ? (bodyContent) : (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 1, overflow: "hidden", marginBottom: !question && !securityWarnings ? 1 : 0, children: _jsx(MaxSizedBox, { maxHeight: availableBodyContentHeight(), maxWidth: terminalWidth, overflowDirection: bodyOverflowDirection, children: bodyContent }) }), securityWarnings && (_jsx(Box, { flexShrink: 0, marginBottom: 1, ref: onSecurityWarningsRefChange, children: securityWarnings })), !!question && (_jsx(Box, { marginBottom: 1, flexShrink: 0, children: typeof question === 'string' ? (_jsx(Text, { color: theme.text.primary, children: question })) : (question) })), _jsx(Box, { flexShrink: 0, children: _jsx(RadioButtonSelect, { items: options, onSelect: handleSelect, isFocused: isFocused, initialIndex: initialIndex, renderItem: renderRadioItem }) })] }))] }));
+};

package/dist/ui/components/messages/ToolGroupDisplay.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { CoreToolCallStatus } from '@google/gemini-cli-core';
+import { theme } from '../../semantic-colors.js';
+import { ToolStatusIndicator } from './ToolShared.js';
+import { useSettings } from '../../contexts/SettingsContext.js';
+export const ToolGroupDisplay = ({ item, isToolGroupBoundary, }) => {
+    const settings = useSettings();
+    const isCompactModeEnabled = settings.merged.ui?.compactToolOutput === true;
+    if (item.type !== 'tool_display_group') {
+        return null;
+    }
+    const { tools, borderColor, borderDimColor, borderTop, borderBottom } = item;
+    const visibleTools = tools.filter((t) => t.status !== CoreToolCallStatus.AwaitingApproval);
+    const noticeTools = visibleTools.filter((t) => t.format === 'notice');
+    const otherTools = visibleTools.filter((t) => t.format !== 'notice' && t.format !== 'hidden');
+    const hasOtherTools = otherTools.length > 0;
+    const isClosingSlice = tools.length === 0 && borderBottom;
+    // If no tools are visible and it's not an explicit closing slice, hide the group
+    if (visibleTools.length === 0 && !isClosingSlice) {
+        return null;
+    }
+    // Standard view behavior: If compact mode is enabled, non-notice tools
+    // are typically rendered without an outer box.
+    const shouldShowBox = (hasOtherTools || isClosingSlice) && !isCompactModeEnabled;
+    const boxBorderTop = borderTop || noticeTools.length > 0;
+    return (_jsxs(Box, { flexDirection: "column", children: [noticeTools.map((tool, index) => {
+                const isFirstInGroup = index === 0 && borderTop;
+                const isLastElementInGroup = index === noticeTools.length - 1 && !shouldShowBox && borderBottom;
+                return (_jsx(Box, { marginTop: isFirstInGroup ? 1 : index > 0 ? 1 : 0, marginBottom: isLastElementInGroup ? 1 : 0, children: _jsx(ToolDisplayMessage, { tool: tool }) }, `notice-${index}`));
+            }), shouldShowBox ? (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, borderDimColor: borderDimColor, borderTop: boxBorderTop, borderBottom: borderBottom, borderLeft: !isToolGroupBoundary, borderRight: !isToolGroupBoundary, marginTop: boxBorderTop ? 1 : 0, marginBottom: borderBottom ? 1 : 0, paddingX: 1, children: otherTools.map((tool, index) => (_jsx(ToolDisplayMessage, { tool: tool }, `tool-${index}`))) })) : otherTools.length > 0 ? (
+            // Compact mode or no tools to box
+            _jsx(Box, { flexDirection: "column", marginTop: noticeTools.length > 0 ? 1 : 0, marginBottom: borderBottom ? 1 : 0, children: otherTools.map((tool, index) => (_jsx(ToolDisplayMessage, { tool: tool }, `tool-${index}`))) })) : null] }));
+};
+const ToolDisplayMessage = ({ tool }) => {
+    const settings = useSettings();
+    const isCompactModeEnabled = settings.merged.ui?.compactToolOutput === true;
+    // Since ToolDisplayItem is ToolDisplay & { status, ... }, we check for identifying properties
+    // of ToolDisplay. If name or description is missing and there's no result, it might be "empty".
+    if (!tool.name && !tool.description && !tool.result && !tool.resultSummary) {
+        return (_jsxs(Box, { paddingLeft: 2, children: [_jsx(ToolStatusIndicator, { status: tool.status, name: tool.originalRequestName || 'unknown' }), _jsx(Text, { color: theme.status.error, children: " Error: Tool display missing" })] }));
+    }
+    const { status, format: preferredFormat, name, description, resultSummary, result, } = tool;
+    const format = preferredFormat || 'auto';
+    if (format === 'hidden') {
+        return null;
+    }
+    if (format === 'notice') {
+        // If the name is part of the description (typical for topic updates),
+        // suppress the bold name to avoid redundancy and match legacy UI.
+        const isRedundant = !!(name && description?.includes(`"${name}"`));
+        return (_jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [name && !isRedundant && (_jsxs(Text, { color: theme.text.primary, bold: true, wrap: "truncate-end", children: [name, ":"] })), description && (_jsx(Text, { color: theme.text.secondary, wrap: "wrap", children: description }))] }));
+    }
+    const isCompact = format === 'compact' || (format === 'auto' && isCompactModeEnabled);
+    if (isCompact) {
+        return (_jsxs(Box, { paddingLeft: 2, flexDirection: "row", flexWrap: "wrap", children: [_jsx(ToolStatusIndicator, { status: status, name: name || tool.originalRequestName || '' }), _jsxs(Text, { bold: true, color: theme.text.primary, children: [' ', name || tool.originalRequestName, ' '] }), description && _jsx(Text, { color: theme.text.secondary, children: description }), resultSummary && (_jsxs(Text, { color: theme.text.accent, children: [' ', "\u2192 ", resultSummary.replace(/\n/g, ' ')] }))] }));
+    }
+    // Box format (full)
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 0, children: [_jsxs(Box, { flexDirection: "row", paddingLeft: 1, children: [_jsx(ToolStatusIndicator, { status: status, name: name || tool.originalRequestName || '' }), _jsxs(Text, { bold: true, color: theme.text.primary, children: [' ', name || tool.originalRequestName, ' '] }), description && _jsx(Text, { color: theme.text.secondary, children: description })] }), resultSummary && !result && (_jsx(Box, { paddingLeft: 1, marginTop: 1, children: _jsx(Text, { color: theme.text.primary, children: resultSummary }) })), result && (_jsx(Box, { paddingLeft: 1, marginTop: 1, children: _jsx(ToolResultDisplayContent, { content: result, summary: resultSummary }) }))] }));
+};
+const ToolResultDisplayContent = ({ content, summary, }) => {
+    if (!content)
+        return null;
+    switch (content.type) {
+        case 'text':
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.text.primary, children: content.text }), summary && (_jsx(Box, { marginTop: 0, children: _jsx(Text, { color: theme.text.primary, children: summary }) }))] }));
+        case 'diff':
+            // Simplified diff display for now
+            return (_jsxs(Box, { flexDirection: "column", children: [summary && _jsx(Text, { color: theme.text.primary, children: summary }), _jsx(Text, { color: theme.text.secondary, children: `[Diff Display: ${content.beforeText.length} -> ${content.afterText.length} chars]` })] }));
+        case 'terminal':
+            return _jsx(Text, { color: theme.text.secondary, children: "[Terminal Output]" });
+        case 'agent':
+            return (_jsxs(Text, { color: theme.text.secondary, children: ["[Subagent: ", content.threadId, "]"] }));
+        default:
+            return null;
+    }
+};