Merge branch 'main' into fix/chat-history-dialog

2026-07-12 19:10:55 -07:00 · 2026-02-24 09:56:07 -08:00
parent ca57f82769 baccda969d
commit 56674b094b
52 changed files with 5158 additions and 409 deletions
@@ -974,6 +974,60 @@ const SETTINGS_SCHEMA = {
          ref: 'AgentOverride',
        },
      },
+      browser: {
+        type: 'object',
+        label: 'Browser Agent',
+        category: 'Advanced',
+        requiresRestart: true,
+        default: {},
+        description: 'Settings specific to the browser agent.',
+        showInDialog: false,
+        properties: {
+          sessionMode: {
+            type: 'enum',
+            label: 'Browser Session Mode',
+            category: 'Advanced',
+            requiresRestart: true,
+            default: 'persistent',
+            description:
+              "Session mode: 'persistent', 'isolated', or 'existing'.",
+            showInDialog: false,
+            options: [
+              { value: 'persistent', label: 'Persistent' },
+              { value: 'isolated', label: 'Isolated' },
+              { value: 'existing', label: 'Existing' },
+            ],
+          },
+          headless: {
+            type: 'boolean',
+            label: 'Browser Headless',
+            category: 'Advanced',
+            requiresRestart: true,
+            default: false,
+            description: 'Run browser in headless mode.',
+            showInDialog: false,
+          },
+          profilePath: {
+            type: 'string',
+            label: 'Browser Profile Path',
+            category: 'Advanced',
+            requiresRestart: true,
+            default: undefined as string | undefined,
+            description:
+              'Path to browser profile directory for session persistence.',
+            showInDialog: false,
+          },
+          visualModel: {
+            type: 'string',
+            label: 'Browser Visual Model',
+            category: 'Advanced',
+            requiresRestart: true,
+            default: undefined as string | undefined,
+            description: 'Model override for the visual agent.',
+            showInDialog: false,
+          },
+        },
+      },
    },
  },

@@ -9,7 +9,11 @@ import { policiesCommand } from './policiesCommand.js';
 import { CommandKind } from './types.js';
 import { MessageType } from '../types.js';
 import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { type Config, PolicyDecision } from '@google/gemini-cli-core';
+import {
+  type Config,
+  PolicyDecision,
+  ApprovalMode,
+} from '@google/gemini-cli-core';

 describe('policiesCommand', () => {
  let mockContext: ReturnType<typeof createMockCommandContext>;
@@ -106,6 +110,7 @@ describe('policiesCommand', () => {
      expect(content).toContain(
        '### Yolo Mode Policies (combined with normal mode policies)',
      );
+      expect(content).toContain('### Plan Mode Policies');
      expect(content).toContain(
        '**DENY** tool: `dangerousTool` [Priority: 10]',
      );
@@ -114,5 +119,45 @@ describe('policiesCommand', () => {
      );
      expect(content).toContain('**ASK_USER** all tools');
    });
+
+    it('should show plan-only rules in plan mode section', async () => {
+      const mockRules = [
+        {
+          decision: PolicyDecision.ALLOW,
+          toolName: 'glob',
+          priority: 70,
+          modes: [ApprovalMode.PLAN],
+        },
+        {
+          decision: PolicyDecision.DENY,
+          priority: 60,
+          modes: [ApprovalMode.PLAN],
+        },
+        {
+          decision: PolicyDecision.ALLOW,
+          toolName: 'shell',
+          priority: 50,
+        },
+      ];
+      const mockPolicyEngine = {
+        getRules: vi.fn().mockReturnValue(mockRules),
+      };
+      mockContext.services.config = {
+        getPolicyEngine: vi.fn().mockReturnValue(mockPolicyEngine),
+      } as unknown as Config;
+
+      const listCommand = policiesCommand.subCommands![0];
+      await listCommand.action!(mockContext, '');
+
+      const call = vi.mocked(mockContext.ui.addItem).mock.calls[0];
+      const content = (call[0] as { text: string }).text;
+
+      // Plan-only rules appear under Plan Mode section
+      expect(content).toContain('### Plan Mode Policies');
+      // glob ALLOW is plan-only, should appear in plan section
+      expect(content).toContain('**ALLOW** tool: `glob` [Priority: 70]');
+      // shell ALLOW has no modes (applies to all), appears in normal section
+      expect(content).toContain('**ALLOW** tool: `shell` [Priority: 50]');
+    });
  });
 });
@@ -12,6 +12,7 @@ interface CategorizedRules {
  normal: PolicyRule[];
  autoEdit: PolicyRule[];
  yolo: PolicyRule[];
+  plan: PolicyRule[];
 }

 const categorizeRulesByMode = (
@@ -21,6 +22,7 @@ const categorizeRulesByMode = (
    normal: [],
    autoEdit: [],
    yolo: [],
+    plan: [],
  };
  const ALL_MODES = Object.values(ApprovalMode);
  rules.forEach((rule) => {
@@ -29,6 +31,7 @@ const categorizeRulesByMode = (
    if (modeSet.has(ApprovalMode.DEFAULT)) result.normal.push(rule);
    if (modeSet.has(ApprovalMode.AUTO_EDIT)) result.autoEdit.push(rule);
    if (modeSet.has(ApprovalMode.YOLO)) result.yolo.push(rule);
+    if (modeSet.has(ApprovalMode.PLAN)) result.plan.push(rule);
  });
  return result;
 };
@@ -82,6 +85,9 @@ const listPoliciesCommand: SlashCommand = {
    const uniqueYolo = categorized.yolo.filter(
      (rule) => !normalRulesSet.has(rule),
    );
+    const uniquePlan = categorized.plan.filter(
+      (rule) => !normalRulesSet.has(rule),
+    );

    let content = '**Active Policies**\n\n';
    content += formatSection('Normal Mode Policies', categorized.normal);
@@ -93,6 +99,7 @@ const listPoliciesCommand: SlashCommand = {
      'Yolo Mode Policies (combined with normal mode policies)',
      uniqueYolo,
    );
+    content += formatSection('Plan Mode Policies', uniquePlan);

    context.ui.addItem(
      {
@@ -375,20 +375,25 @@ describe('<ToolMessage />', () => {
    unmount();
  });

-  it('renders progress information appended to description for executing tools', async () => {
+  it('renders McpProgressIndicator with percentage and message for executing tools', async () => {
    const { lastFrame, waitUntilReady, unmount } = renderWithContext(
      <ToolMessage
        {...baseProps}
        status={CoreToolCallStatus.Executing}
+        progress={42}
+        progressTotal={100}
        progressMessage="Working on it..."
-        progressPercent={42}
      />,
      StreamingState.Responding,
    );
    await waitUntilReady();
-    expect(lastFrame()).toContain(
-      'A tool for testing (Working on it... - 42%)',
-    );
+    const output = lastFrame();
+    expect(output).toContain('42%');
+    expect(output).toContain('Working on it...');
+    expect(output).toContain('\u2588');
+    expect(output).toContain('\u2591');
+    expect(output).not.toContain('A tool for testing (Working on it... - 42%)');
+    expect(output).toMatchSnapshot();
    unmount();
  });

@@ -397,12 +402,37 @@ describe('<ToolMessage />', () => {
      <ToolMessage
        {...baseProps}
        status={CoreToolCallStatus.Executing}
-        progressPercent={75}
+        progress={75}
+        progressTotal={100}
      />,
      StreamingState.Responding,
    );
    await waitUntilReady();
-    expect(lastFrame()).toContain('A tool for testing (75%)');
+    const output = lastFrame();
+    expect(output).toContain('75%');
+    expect(output).toContain('\u2588');
+    expect(output).toContain('\u2591');
+    expect(output).not.toContain('A tool for testing (75%)');
+    expect(output).toMatchSnapshot();
+    unmount();
+  });
+
+  it('renders indeterminate progress when total is missing', async () => {
+    const { lastFrame, waitUntilReady, unmount } = renderWithContext(
+      <ToolMessage
+        {...baseProps}
+        status={CoreToolCallStatus.Executing}
+        progress={7}
+      />,
+      StreamingState.Responding,
+    );
+    await waitUntilReady();
+    const output = lastFrame();
+    expect(output).toContain('7');
+    expect(output).toContain('\u2588');
+    expect(output).toContain('\u2591');
+    expect(output).not.toContain('%');
+    expect(output).toMatchSnapshot();
    unmount();
  });
 });
@@ -13,6 +13,7 @@ import {
  ToolStatusIndicator,
  ToolInfo,
  TrailingIndicator,
+  McpProgressIndicator,
  type TextEmphasis,
  STATUS_INDICATOR_WIDTH,
  isThisShellFocusable as checkIsShellFocusable,
@@ -20,7 +21,7 @@ import {
  useFocusHint,
  FocusHint,
 } from './ToolShared.js';
-import { type Config } from '@google/gemini-cli-core';
+import { type Config, CoreToolCallStatus } from '@google/gemini-cli-core';
 import { ShellInputPrompt } from '../ShellInputPrompt.js';

 export type { TextEmphasis };
@@ -56,8 +57,9 @@ export const ToolMessage: React.FC<ToolMessageProps> = ({
  ptyId,
  config,
  progressMessage,
-  progressPercent,
  originalRequestName,
+  progress,
+  progressTotal,
 }) => {
  const isThisShellFocused = checkIsShellFocused(
    name,
@@ -92,8 +94,6 @@ export const ToolMessage: React.FC<ToolMessageProps> = ({
          status={status}
          description={description}
          emphasis={emphasis}
-          progressMessage={progressMessage}
-          progressPercent={progressPercent}
          originalRequestName={originalRequestName}
        />
        <FocusHint
@@ -114,6 +114,14 @@ export const ToolMessage: React.FC<ToolMessageProps> = ({
        paddingX={1}
        flexDirection="column"
      >
+        {status === CoreToolCallStatus.Executing && progress !== undefined && (
+          <McpProgressIndicator
+            progress={progress}
+            total={progressTotal}
+            message={progressMessage}
+            barWidth={20}
+          />
+        )}
        <ToolResultDisplay
          resultDisplay={resultDisplay}
          availableTerminalHeight={availableTerminalHeight}
@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { render } from '../../../test-utils/render.js';
+import { Text } from 'ink';
+import { McpProgressIndicator } from './ToolShared.js';
+
+vi.mock('../GeminiRespondingSpinner.js', () => ({
+  GeminiRespondingSpinner: () => <Text>MockSpinner</Text>,
+}));
+
+describe('McpProgressIndicator', () => {
+  it('renders determinate progress at 50%', async () => {
+    const { lastFrame, waitUntilReady } = render(
+      <McpProgressIndicator progress={50} total={100} barWidth={20} />,
+    );
+    await waitUntilReady();
+    const output = lastFrame();
+    expect(output).toMatchSnapshot();
+    expect(output).toContain('50%');
+  });
+
+  it('renders complete progress at 100%', async () => {
+    const { lastFrame, waitUntilReady } = render(
+      <McpProgressIndicator progress={100} total={100} barWidth={20} />,
+    );
+    await waitUntilReady();
+    const output = lastFrame();
+    expect(output).toMatchSnapshot();
+    expect(output).toContain('100%');
+  });
+
+  it('renders indeterminate progress with raw count', async () => {
+    const { lastFrame, waitUntilReady } = render(
+      <McpProgressIndicator progress={7} barWidth={20} />,
+    );
+    await waitUntilReady();
+    const output = lastFrame();
+    expect(output).toMatchSnapshot();
+    expect(output).toContain('7');
+    expect(output).not.toContain('%');
+  });
+
+  it('renders progress with a message', async () => {
+    const { lastFrame, waitUntilReady } = render(
+      <McpProgressIndicator
+        progress={30}
+        total={100}
+        message="Downloading..."
+        barWidth={20}
+      />,
+    );
+    await waitUntilReady();
+    const output = lastFrame();
+    expect(output).toMatchSnapshot();
+    expect(output).toContain('Downloading...');
+  });
+
+  it('clamps progress exceeding total to 100%', async () => {
+    const { lastFrame, waitUntilReady } = render(
+      <McpProgressIndicator progress={150} total={100} barWidth={20} />,
+    );
+    await waitUntilReady();
+    const output = lastFrame();
+    expect(output).toContain('100%');
+    expect(output).not.toContain('150%');
+  });
+});
@@ -187,8 +187,6 @@ type ToolInfoProps = {
  description: string;
  status: CoreToolCallStatus;
  emphasis: TextEmphasis;
-  progressMessage?: string;
-  progressPercent?: number;
  originalRequestName?: string;
 };

@@ -197,8 +195,6 @@ export const ToolInfo: React.FC<ToolInfoProps> = ({
  description,
  status: coreStatus,
  emphasis,
-  progressMessage,
-  progressPercent,
  originalRequestName,
 }) => {
  const status = mapCoreStatusToDisplayStatus(coreStatus);
@@ -220,24 +216,6 @@ export const ToolInfo: React.FC<ToolInfoProps> = ({
  // Hide description for completed Ask User tools (the result display speaks for itself)
  const isCompletedAskUser = isCompletedAskUserTool(name, status);

-  let displayDescription = description;
-  if (status === ToolCallStatus.Executing) {
-    const parts: string[] = [];
-    if (progressMessage) {
-      parts.push(progressMessage);
-    }
-    if (progressPercent !== undefined) {
-      parts.push(`${Math.round(progressPercent)}%`);
-    }
-
-    if (parts.length > 0) {
-      const progressInfo = parts.join(' - ');
-      displayDescription = description
-        ? `${description} (${progressInfo})`
-        : progressInfo;
-    }
-  }
-
  return (
    <Box overflow="hidden" height={1} flexGrow={1} flexShrink={1}>
      <Text strikethrough={status === ToolCallStatus.Canceled} wrap="truncate">
@@ -253,7 +231,7 @@ export const ToolInfo: React.FC<ToolInfoProps> = ({
        {!isCompletedAskUser && (
          <>
            {' '}
-            <Text color={theme.text.secondary}>{displayDescription}</Text>
+            <Text color={theme.text.secondary}>{description}</Text>
          </>
        )}
      </Text>
@@ -261,6 +239,54 @@ export const ToolInfo: React.FC<ToolInfoProps> = ({
  );
 };

+export interface McpProgressIndicatorProps {
+  progress: number;
+  total?: number;
+  message?: string;
+  barWidth: number;
+}
+
+export const McpProgressIndicator: React.FC<McpProgressIndicatorProps> = ({
+  progress,
+  total,
+  message,
+  barWidth,
+}) => {
+  const percentage =
+    total && total > 0
+      ? Math.min(100, Math.round((progress / total) * 100))
+      : null;
+
+  let rawFilled: number;
+  if (total && total > 0) {
+    rawFilled = Math.round((progress / total) * barWidth);
+  } else {
+    rawFilled = Math.floor(progress) % (barWidth + 1);
+  }
+
+  const filled = Math.max(
+    0,
+    Math.min(Number.isFinite(rawFilled) ? rawFilled : 0, barWidth),
+  );
+  const empty = Math.max(0, barWidth - filled);
+  const progressBar = '\u2588'.repeat(filled) + '\u2591'.repeat(empty);
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text color={theme.text.accent}>
+          {progressBar} {percentage !== null ? `${percentage}%` : `${progress}`}
+        </Text>
+      </Box>
+      {message && (
+        <Text color={theme.text.secondary} wrap="truncate">
+          {message}
+        </Text>
+      )}
+    </Box>
+  );
+};
+
 export const TrailingIndicator: React.FC = () => (
  <Text color={theme.text.primary} wrap="truncate">
    {' '}
@@ -92,6 +92,16 @@ exports[`<ToolMessage /> > renders DiffRenderer for diff results 1`] = `
 "
 `;

+exports[`<ToolMessage /> > renders McpProgressIndicator with percentage and message for executing tools 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────╮
+│ MockRespondingSpinnertest-tool A tool for testing                            │
+│                                                                              │
+│ ████████░░░░░░░░░░░░ 42%                                                     │
+│ Working on it...                                                             │
+│ Test result                                                                  │
+"
+`;
+
 exports[`<ToolMessage /> > renders basic tool information 1`] = `
 "╭──────────────────────────────────────────────────────────────────────────────╮
 │ ✓  test-tool A tool for testing                                              │
@@ -115,3 +125,21 @@ exports[`<ToolMessage /> > renders emphasis correctly 2`] = `
 │ Test result                                                                  │
 "
 `;
+
+exports[`<ToolMessage /> > renders indeterminate progress when total is missing 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────╮
+│ MockRespondingSpinnertest-tool A tool for testing                            │
+│                                                                              │
+│ ███████░░░░░░░░░░░░░ 7                                                       │
+│ Test result                                                                  │
+"
+`;
+
+exports[`<ToolMessage /> > renders only percentage when progressMessage is missing 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────╮
+│ MockRespondingSpinnertest-tool A tool for testing                            │
+│                                                                              │
+│ ███████████████░░░░░ 75%                                                     │
+│ Test result                                                                  │
+"
+`;
@@ -0,0 +1,22 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`McpProgressIndicator > renders complete progress at 100% 1`] = `
+"████████████████████ 100%
+"
+`;
+
+exports[`McpProgressIndicator > renders determinate progress at 50% 1`] = `
+"██████████░░░░░░░░░░ 50%
+"
+`;
+
+exports[`McpProgressIndicator > renders indeterminate progress with raw count 1`] = `
+"███████░░░░░░░░░░░░░ 7
+"
+`;
+
+exports[`McpProgressIndicator > renders progress with a message 1`] = `
+"██████░░░░░░░░░░░░░░ 30%
+Downloading...
+"
+`;
@@ -263,6 +263,41 @@ describe('toolMapping', () => {
      expect(result.borderBottom).toBe(false);
    });

+    it('maps raw progress and progressTotal from Executing calls', () => {
+      const toolCall: ExecutingToolCall = {
+        status: CoreToolCallStatus.Executing,
+        request: mockRequest,
+        tool: mockTool,
+        invocation: mockInvocation,
+        progressMessage: 'Downloading...',
+        progress: 5,
+        progressTotal: 10,
+      };
+
+      const result = mapToDisplay(toolCall);
+      const displayTool = result.tools[0];
+
+      expect(displayTool.progress).toBe(5);
+      expect(displayTool.progressTotal).toBe(10);
+      expect(displayTool.progressMessage).toBe('Downloading...');
+    });
+
+    it('leaves progress fields undefined for non-Executing calls', () => {
+      const toolCall: SuccessfulToolCall = {
+        status: CoreToolCallStatus.Success,
+        request: mockRequest,
+        tool: mockTool,
+        invocation: mockInvocation,
+        response: mockResponse,
+      };
+
+      const result = mapToDisplay(toolCall);
+      const displayTool = result.tools[0];
+
+      expect(displayTool.progress).toBeUndefined();
+      expect(displayTool.progressTotal).toBeUndefined();
+    });
+
    it('sets resultDisplay to undefined for pre-execution statuses', () => {
      const toolCall: ScheduledToolCall = {
        status: CoreToolCallStatus.Scheduled,
@@ -60,7 +60,8 @@ export function mapToDisplay(
    let ptyId: number | undefined = undefined;
    let correlationId: string | undefined = undefined;
    let progressMessage: string | undefined = undefined;
-    let progressPercent: number | undefined = undefined;
+    let progress: number | undefined = undefined;
+    let progressTotal: number | undefined = undefined;

    switch (call.status) {
      case CoreToolCallStatus.Success:
@@ -80,7 +81,8 @@ export function mapToDisplay(
        resultDisplay = call.liveOutput;
        ptyId = call.pid;
        progressMessage = call.progressMessage;
-        progressPercent = call.progressPercent;
+        progress = call.progress;
+        progressTotal = call.progressTotal;
        break;
      case CoreToolCallStatus.Scheduled:
      case CoreToolCallStatus.Validating:
@@ -105,7 +107,8 @@ export function mapToDisplay(
      ptyId,
      correlationId,
      progressMessage,
-      progressPercent,
+      progress,
+      progressTotal,
      approvalMode: call.approvalMode,
      originalRequestName: call.request.originalRequestName,
    };
@@ -109,8 +109,9 @@ export interface IndividualToolCallDisplay {
  correlationId?: string;
  approvalMode?: ApprovalMode;
  progressMessage?: string;
-  progressPercent?: number;
  originalRequestName?: string;
+  progress?: number;
+  progressTotal?: number;
 }

 export interface CompressionProps {