Make a stateful extensions list component, with update statuses (#8301)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

packages/cli/src/ui/AppContainer.tsx

@@ -76,6 +76,8 @@ import { useAutoAcceptIndicator } from './hooks/useAutoAcceptIndicator.js';
 import { useWorkspaceMigration } from './hooks/useWorkspaceMigration.js';
 import { useSessionStats } from './contexts/SessionContext.js';
 import { useGitBranchName } from './hooks/useGitBranchName.js';
+import type { ExtensionUpdateState } from './state/extensions.js';
+import { checkForAllExtensionUpdates } from '../config/extension.js';
 
 const CTRL_EXIT_PROMPT_DURATION_MS = 1000;
 
@@ -136,6 +138,9 @@ export const AppContainer = (props: AppContainerProps) => {
   const [isTrustedFolder, setIsTrustedFolder] = useState<boolean | undefined>(
     config.isTrustedFolder(),
   );
+  const [extensionsUpdateState, setExtensionsUpdateState] = useState(
+    new Map<string, ExtensionUpdateState>(),
+  );
 
   // Helper to determine the effective model, considering the fallback state.
   const getEffectiveModel = useCallback(() => {
@@ -419,6 +424,7 @@ Logging in with Google... Please restart Gemini CLI to continue.
       },
       setDebugMessage,
       toggleCorgiMode: () => setCorgiMode((prev) => !prev),
+      setExtensionsUpdateState,
     }),
     [
       setAuthState,
@@ -429,6 +435,7 @@ Logging in with Google... Please restart Gemini CLI to continue.
       setDebugMessage,
       setShowPrivacyNotice,
       setCorgiMode,
+      setExtensionsUpdateState,
     ],
   );
 
@@ -450,6 +457,7 @@ Logging in with Google... Please restart Gemini CLI to continue.
     setIsProcessing,
     setGeminiMdFileCount,
     slashCommandActions,
+    extensionsUpdateState,
     isConfigInitialized,
   );
 
@@ -1040,6 +1048,7 @@ Logging in with Google... Please restart Gemini CLI to continue.
       updateInfo,
       showIdeRestartPrompt,
       isRestarting,
+      extensionsUpdateState,
       activePtyId,
       shellFocused,
     }),
@@ -1115,6 +1124,7 @@ Logging in with Google... Please restart Gemini CLI to continue.
       showIdeRestartPrompt,
       isRestarting,
       currentModel,
+      extensionsUpdateState,
       activePtyId,
       shellFocused,
     ],
@@ -1168,6 +1178,11 @@ Logging in with Google... Please restart Gemini CLI to continue.
     ],
   );
 
+  const extensions = config.getExtensions();
+  useEffect(() => {
+    checkForAllExtensionUpdates(extensions, setExtensionsUpdateState);
+  }, [extensions, setExtensionsUpdateState]);
+
   return (
     <UIStateContext.Provider value={uiState}>
       <UIActionsContext.Provider value={uiActions}>

packages/cli/src/ui/commands/extensionsCommand.test.ts

@@ -44,51 +44,20 @@ describe('extensionsCommand', () => {
       services: {
         config: {
           getExtensions: () => [],
+          getWorkingDir: () => '/test/dir',
         },
       },
     });
   });
 
   describe('list', () => {
-    it('should display "No active extensions." when none are found', async () => {
+    it('should add an EXTENSIONS_LIST item to the UI', async () => {
       if (!extensionsCommand.action) throw new Error('Action not defined');
       await extensionsCommand.action(mockContext, '');
 
       expect(mockContext.ui.addItem).toHaveBeenCalledWith(
         {
-          type: MessageType.INFO,
-          text: 'No active extensions.',
-        },
-        expect.any(Number),
-      );
-    });
-
-    it('should list active extensions when they are found', async () => {
-      const mockExtensions = [
-        { name: 'ext-one', version: '1.0.0', isActive: true },
-        { name: 'ext-two', version: '2.1.0', isActive: true },
-        { name: 'ext-three', version: '3.0.0', isActive: false },
-      ];
-      mockContext = createMockCommandContext({
-        services: {
-          config: {
-            getExtensions: () => mockExtensions,
-          },
-        },
-      });
-
-      if (!extensionsCommand.action) throw new Error('Action not defined');
-      await extensionsCommand.action(mockContext, '');
-
-      const expectedMessage =
-        'Active extensions:\n\n' +
-        `  - \u001b[36mext-one (v1.0.0)\u001b[0m\n` +
-        `  - \u001b[36mext-two (v2.1.0)\u001b[0m\n`;
-
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text: expectedMessage,
+          type: MessageType.EXTENSIONS_LIST,
         },
         expect.any(Number),
       );
@@ -127,7 +96,7 @@ describe('extensionsCommand', () => {
       );
     });
 
-    it('should update all extensions with --all', async () => {
+    it('should call setPendingItem and addItem in a finally block on success', async () => {
       mockUpdateAllUpdatableExtensions.mockResolvedValue([
         {
           name: 'ext-one',
@@ -141,23 +110,33 @@ describe('extensionsCommand', () => {
         },
       ]);
       await updateAction(mockContext, '--all');
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(null);
       expect(mockContext.ui.addItem).toHaveBeenCalledWith(
         {
-          type: MessageType.INFO,
-          text:
-            'Extension "ext-one" successfully updated: 1.0.0 → 1.0.1.\n' +
-            'Extension "ext-two" successfully updated: 2.0.0 → 2.0.1.\n' +
-            'Restart gemini-cli to see the changes.',
+          type: MessageType.EXTENSIONS_LIST,
         },
         expect.any(Number),
       );
     });
 
-    it('should handle errors when updating all extensions', async () => {
+    it('should call setPendingItem and addItem in a finally block on failure', async () => {
       mockUpdateAllUpdatableExtensions.mockRejectedValue(
         new Error('Something went wrong'),
       );
       await updateAction(mockContext, '--all');
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(null);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.EXTENSIONS_LIST,
+        },
+        expect.any(Number),
+      );
       expect(mockContext.ui.addItem).toHaveBeenCalledWith(
         {
           type: MessageType.ERROR,
@@ -174,14 +153,11 @@ describe('extensionsCommand', () => {
         updatedVersion: '1.0.1',
       });
       await updateAction(mockContext, 'ext-one');
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: MessageType.INFO,
-          text:
-            'Extension "ext-one" successfully updated: 1.0.0 → 1.0.1.\n' +
-            'Restart gemini-cli to see the changes.',
-        },
-        expect.any(Number),
+      expect(mockUpdateExtensionByName).toHaveBeenCalledWith(
+        'ext-one',
+        '/test/dir',
+        [],
+        expect.any(Function),
       );
     });
 
@@ -213,13 +189,13 @@ describe('extensionsCommand', () => {
         });
       await updateAction(mockContext, 'ext-one ext-two');
       expect(mockUpdateExtensionByName).toHaveBeenCalledTimes(2);
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(null);
       expect(mockContext.ui.addItem).toHaveBeenCalledWith(
         {
-          type: MessageType.INFO,
-          text:
-            'Extension "ext-one" successfully updated: 1.0.0 → 1.0.1.\n' +
-            'Extension "ext-two" successfully updated: 2.0.0 → 2.0.1.\n' +
-            'Restart gemini-cli to see the changes.',
+          type: MessageType.EXTENSIONS_LIST,
         },
         expect.any(Number),
       );

packages/cli/src/ui/commands/extensionsCommand.ts

@@ -18,65 +18,59 @@ import {
 } from './types.js';
 
 async function listAction(context: CommandContext) {
-  const activeExtensions = context.services.config
-    ?.getExtensions()
-    .filter((ext) => ext.isActive);
-  if (!activeExtensions || activeExtensions.length === 0) {
-    context.ui.addItem(
-      {
-        type: MessageType.INFO,
-        text: 'No active extensions.',
-      },
-      Date.now(),
-    );
-    return;
-  }
-
-  const extensionLines = activeExtensions.map(
-    (ext) => `  - \u001b[36m${ext.name} (v${ext.version})\u001b[0m`,
-  );
-  const message = `Active extensions:\n\n${extensionLines.join('\n')}\n`;
-
   context.ui.addItem(
     {
-      type: MessageType.INFO,
-      text: message,
+      type: MessageType.EXTENSIONS_LIST,
     },
     Date.now(),
   );
 }
 
-const updateOutput = (info: ExtensionUpdateInfo) =>
-  `Extension "${info.name}" successfully updated: ${info.originalVersion} → ${info.updatedVersion}.`;
-
 async function updateAction(context: CommandContext, args: string) {
   const updateArgs = args.split(' ').filter((value) => value.length > 0);
   const all = updateArgs.length === 1 && updateArgs[0] === '--all';
   const names = all ? undefined : updateArgs;
   let updateInfos: ExtensionUpdateInfo[] = [];
+
+  if (!all && names?.length === 0) {
+    context.ui.addItem(
+      {
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions update <extension-names>|--all',
+      },
+      Date.now(),
+    );
+    return;
+  }
+
   try {
+    context.ui.setPendingItem({
+      type: MessageType.EXTENSIONS_LIST,
+    });
     if (all) {
-      updateInfos = await updateAllUpdatableExtensions();
+      updateInfos = await updateAllUpdatableExtensions(
+        context.services.config!.getWorkingDir(),
+        context.services.config!.getExtensions(),
+        context.ui.extensionsUpdateState,
+        context.ui.setExtensionsUpdateState,
+      );
     } else if (names?.length) {
       for (const name of names) {
-        updateInfos.push(await updateExtensionByName(name));
+        updateInfos.push(
+          await updateExtensionByName(
+            name,
+            context.services.config!.getWorkingDir(),
+            context.services.config!.getExtensions(),
+            (updateState) => {
+              const newState = new Map(context.ui.extensionsUpdateState);
+              newState.set(name, updateState);
+              context.ui.setExtensionsUpdateState(newState);
+            },
+          ),
+        );
       }
-    } else {
-      context.ui.addItem(
-        {
-          type: MessageType.ERROR,
-          text: 'Usage: /extensions update <extension-names>|--all',
-        },
-        Date.now(),
-      );
-      return;
     }
 
-    // Filter to the actually updated ones.
-    updateInfos = updateInfos.filter(
-      (info) => info.originalVersion !== info.updatedVersion,
-    );
-
     if (updateInfos.length === 0) {
       context.ui.addItem(
         {
@@ -87,17 +81,6 @@ async function updateAction(context: CommandContext, args: string) {
       );
       return;
     }
-
-    context.ui.addItem(
-      {
-        type: MessageType.INFO,
-        text: [
-          ...updateInfos.map((info) => updateOutput(info)),
-          'Restart gemini-cli to see the changes.',
-        ].join('\n'),
-      },
-      Date.now(),
-    );
   } catch (error) {
     context.ui.addItem(
       {
@@ -106,6 +89,14 @@ async function updateAction(context: CommandContext, args: string) {
       },
       Date.now(),
     );
+  } finally {
+    context.ui.addItem(
+      {
+        type: MessageType.EXTENSIONS_LIST,
+      },
+      Date.now(),
+    );
+    context.ui.setPendingItem(null);
   }
 }
 

packages/cli/src/ui/commands/types.ts

@@ -4,13 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { type ReactNode } from 'react';
+import type { ReactNode } from 'react';
 import type { Content, PartListUnion } from '@google/genai';
 import type { HistoryItemWithoutId, HistoryItem } from '../types.js';
 import type { Config, GitService, Logger } from '@google/gemini-cli-core';
 import type { LoadedSettings } from '../../config/settings.js';
 import type { UseHistoryManagerReturn } from '../hooks/useHistoryManager.js';
 import type { SessionStatsState } from '../contexts/SessionContext.js';
+import type { ExtensionUpdateState } from '../state/extensions.js';
 
 // Grouped dependencies for clarity and easier mocking
 export interface CommandContext {
@@ -61,6 +62,10 @@ export interface CommandContext {
     toggleVimEnabled: () => Promise<boolean>;
     setGeminiMdFileCount: (count: number) => void;
     reloadCommands: () => void;
+    extensionsUpdateState: Map<string, ExtensionUpdateState>;
+    setExtensionsUpdateState: (
+      updateState: Map<string, ExtensionUpdateState>,
+    ) => void;
   };
   // Session-specific data
   session: {

packages/cli/src/ui/components/HistoryItemDisplay.tsx

@@ -22,6 +22,7 @@ import { ToolStatsDisplay } from './ToolStatsDisplay.js';
 import { SessionSummaryDisplay } from './SessionSummaryDisplay.js';
 import { Help } from './Help.js';
 import type { SlashCommand } from '../commands/types.js';
+import { ExtensionsList } from './views/ExtensionsList.js';
 
 interface HistoryItemDisplayProps {
   item: HistoryItem;
@@ -96,5 +97,6 @@ export const HistoryItemDisplay: React.FC<HistoryItemDisplayProps> = ({
     {item.type === 'compression' && (
       <CompressionMessage compression={item.compression} />
     )}
+    {item.type === 'extensions_list' && <ExtensionsList />}
   </Box>
 );

packages/cli/src/ui/components/views/ExtensionsList.test.tsx

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { vi } from 'vitest';
+import { useUIState } from '../../contexts/UIStateContext.js';
+import { ExtensionUpdateState } from '../../state/extensions.js';
+import { ExtensionsList } from './ExtensionsList.js';
+import { createMockCommandContext } from '../../../test-utils/mockCommandContext.js';
+
+vi.mock('../../contexts/UIStateContext.js');
+
+const mockUseUIState = vi.mocked(useUIState);
+
+const mockExtensions = [
+  { name: 'ext-one', version: '1.0.0', isActive: true },
+  { name: 'ext-two', version: '2.1.0', isActive: true },
+  { name: 'ext-disabled', version: '3.0.0', isActive: false },
+];
+
+describe('<ExtensionsList />', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  const mockUIState = (
+    extensions: unknown[],
+    extensionsUpdateState: Map<string, ExtensionUpdateState>,
+    disabledExtensions: string[] = [],
+  ) => {
+    mockUseUIState.mockReturnValue({
+      commandContext: createMockCommandContext({
+        services: {
+          config: {
+            getExtensions: () => extensions,
+          },
+          settings: {
+            merged: {
+              extensions: {
+                disabled: disabledExtensions,
+              },
+            },
+          },
+        },
+      }),
+      extensionsUpdateState,
+      // Add other required properties from UIState if needed by the component
+    } as never);
+  };
+
+  it('should render "No extensions installed." if there are no extensions', () => {
+    mockUIState([], new Map());
+    const { lastFrame } = render(<ExtensionsList />);
+    expect(lastFrame()).toContain('No extensions installed.');
+  });
+
+  it('should render a list of extensions with their version and status', () => {
+    mockUIState(mockExtensions, new Map(), ['ext-disabled']);
+    const { lastFrame } = render(<ExtensionsList />);
+    const output = lastFrame();
+    expect(output).toContain('ext-one (v1.0.0) - active');
+    expect(output).toContain('ext-two (v2.1.0) - active');
+    expect(output).toContain('ext-disabled (v3.0.0) - disabled');
+  });
+
+  it('should display "unknown state" if an extension has no update state', () => {
+    mockUIState([mockExtensions[0]], new Map());
+    const { lastFrame } = render(<ExtensionsList />);
+    expect(lastFrame()).toContain('(unknown state)');
+  });
+
+  const stateTestCases = [
+    {
+      state: ExtensionUpdateState.CHECKING_FOR_UPDATES,
+      expectedText: '(checking for updates)',
+    },
+    {
+      state: ExtensionUpdateState.UPDATING,
+      expectedText: '(updating)',
+    },
+    {
+      state: ExtensionUpdateState.UPDATE_AVAILABLE,
+      expectedText: '(update available)',
+    },
+    {
+      state: ExtensionUpdateState.UPDATED_NEEDS_RESTART,
+      expectedText: '(updated, needs restart)',
+    },
+    {
+      state: ExtensionUpdateState.ERROR,
+      expectedText: '(error checking for updates)',
+    },
+    {
+      state: ExtensionUpdateState.UP_TO_DATE,
+      expectedText: '(up to date)',
+    },
+  ];
+
+  for (const { state, expectedText } of stateTestCases) {
+    it(`should correctly display the state: ${state}`, () => {
+      const updateState = new Map([[mockExtensions[0].name, state]]);
+      mockUIState([mockExtensions[0]], updateState);
+      const { lastFrame } = render(<ExtensionsList />);
+      expect(lastFrame()).toContain(expectedText);
+    });
+  }
+});

packages/cli/src/ui/components/views/ExtensionsList.tsx

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Text } from 'ink';
+import { useUIState } from '../../contexts/UIStateContext.js';
+import { ExtensionUpdateState } from '../../state/extensions.js';
+
+export const ExtensionsList = () => {
+  const { commandContext, extensionsUpdateState } = useUIState();
+  const allExtensions = commandContext.services.config!.getExtensions();
+  const settings = commandContext.services.settings;
+  const disabledExtensions = settings.merged.extensions?.disabled ?? [];
+
+  if (allExtensions.length === 0) {
+    return <Text>No extensions installed.</Text>;
+  }
+
+  return (
+    <Box flexDirection="column" marginTop={1} marginBottom={1}>
+      <Text>Installed extensions:</Text>
+      <Box flexDirection="column" paddingLeft={2}>
+        {allExtensions.map((ext) => {
+          const state = extensionsUpdateState.get(ext.name);
+          const isActive = !disabledExtensions.includes(ext.name);
+          const activeString = isActive ? 'active' : 'disabled';
+
+          let stateColor = 'gray';
+          const stateText = state || 'unknown state';
+
+          switch (state) {
+            case ExtensionUpdateState.CHECKING_FOR_UPDATES:
+            case ExtensionUpdateState.UPDATING:
+              stateColor = 'cyan';
+              break;
+            case ExtensionUpdateState.UPDATE_AVAILABLE:
+            case ExtensionUpdateState.UPDATED_NEEDS_RESTART:
+              stateColor = 'yellow';
+              break;
+            case ExtensionUpdateState.ERROR:
+              stateColor = 'red';
+              break;
+            case ExtensionUpdateState.UP_TO_DATE:
+            case ExtensionUpdateState.NOT_UPDATABLE:
+              stateColor = 'green';
+              break;
+            default:
+              console.error(`Unhandled ExtensionUpdateState ${state}`);
+              break;
+          }
+
+          return (
+            <Box key={ext.name}>
+              <Text>
+                <Text color="cyan">{`${ext.name} (v${ext.version})`}</Text>
+                {` - ${activeString}`}
+                {<Text color={stateColor}>{` (${stateText})`}</Text>}
+              </Text>
+            </Box>
+          );
+        })}
+      </Box>
+    </Box>
+  );
+};

packages/cli/src/ui/contexts/UIStateContext.tsx

@@ -27,6 +27,7 @@ import type {
 import type { DOMElement } from 'ink';
 import type { SessionStatsState } from '../contexts/SessionContext.js';
 import type { UpdateObject } from '../utils/updateCheck.js';
+import type { ExtensionUpdateState } from '../state/extensions.js';
 
 export interface ProQuotaDialogRequest {
   failedModel: string;
@@ -108,6 +109,7 @@ export interface UIState {
   updateInfo: UpdateObject | null;
   showIdeRestartPrompt: boolean;
   isRestarting: boolean;
+  extensionsUpdateState: Map<string, ExtensionUpdateState>;
   activePtyId: number | undefined;
   shellFocused: boolean;
 }

packages/cli/src/ui/hooks/slashCommandProcessor.ts

@@ -33,6 +33,7 @@ import { CommandService } from '../../services/CommandService.js';
 import { BuiltinCommandLoader } from '../../services/BuiltinCommandLoader.js';
 import { FileCommandLoader } from '../../services/FileCommandLoader.js';
 import { McpPromptLoader } from '../../services/McpPromptLoader.js';
+import type { ExtensionUpdateState } from '../state/extensions.js';
 
 interface SlashCommandProcessorActions {
   openAuthDialog: () => void;
@@ -43,6 +44,9 @@ interface SlashCommandProcessorActions {
   quit: (messages: HistoryItem[]) => void;
   setDebugMessage: (message: string) => void;
   toggleCorgiMode: () => void;
+  setExtensionsUpdateState: (
+    updateState: Map<string, ExtensionUpdateState>,
+  ) => void;
 }
 
 /**
@@ -59,6 +63,7 @@ export const useSlashCommandProcessor = (
   setIsProcessing: (isProcessing: boolean) => void,
   setGeminiMdFileCount: (count: number) => void,
   actions: SlashCommandProcessorActions,
+  extensionsUpdateState: Map<string, ExtensionUpdateState>,
   isConfigInitialized: boolean,
 ) => {
   const session = useSessionStats();
@@ -101,16 +106,17 @@ export const useSlashCommandProcessor = (
     return l;
   }, [config]);
 
-  const [pendingCompressionItem, setPendingCompressionItem] =
-    useState<HistoryItemWithoutId | null>(null);
+  const [pendingItem, setPendingItem] = useState<HistoryItemWithoutId | null>(
+    null,
+  );
 
   const pendingHistoryItems = useMemo(() => {
     const items: HistoryItemWithoutId[] = [];
-    if (pendingCompressionItem != null) {
-      items.push(pendingCompressionItem);
+    if (pendingItem != null) {
+      items.push(pendingItem);
     }
     return items;
-  }, [pendingCompressionItem]);
+  }, [pendingItem]);
 
   const addMessage = useCallback(
     (message: Message) => {
@@ -182,12 +188,14 @@ export const useSlashCommandProcessor = (
         },
         loadHistory,
         setDebugMessage: actions.setDebugMessage,
-        pendingItem: pendingCompressionItem,
-        setPendingItem: setPendingCompressionItem,
+        pendingItem,
+        setPendingItem,
         toggleCorgiMode: actions.toggleCorgiMode,
         toggleVimEnabled,
         setGeminiMdFileCount,
         reloadCommands,
+        extensionsUpdateState,
+        setExtensionsUpdateState: actions.setExtensionsUpdateState,
       },
       session: {
         stats: session.stats,
@@ -205,12 +213,13 @@ export const useSlashCommandProcessor = (
       refreshStatic,
       session.stats,
       actions,
-      pendingCompressionItem,
-      setPendingCompressionItem,
+      pendingItem,
+      setPendingItem,
       toggleVimEnabled,
       sessionShellAllowlist,
       setGeminiMdFileCount,
       reloadCommands,
+      extensionsUpdateState,
     ],
   );
 

packages/cli/src/ui/state/extensions.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export enum ExtensionUpdateState {
+  CHECKING_FOR_UPDATES = 'checking for updates',
+  UPDATED_NEEDS_RESTART = 'updated, needs restart',
+  UPDATING = 'updating',
+  UPDATE_AVAILABLE = 'update available',
+  UP_TO_DATE = 'up to date',
+  ERROR = 'error checking for updates',
+  NOT_UPDATABLE = 'not updatable',
+}

packages/cli/src/ui/types.ts

@@ -155,6 +155,10 @@ export type HistoryItemCompression = HistoryItemBase & {
   compression: CompressionProps;
 };
 
+export type HistoryItemExtensionsList = HistoryItemBase & {
+  type: 'extensions_list';
+};
+
 // Using Omit<HistoryItem, 'id'> seems to have some issues with typescript's
 // type inference e.g. historyItem.type === 'tool_group' isn't auto-inferring that
 // 'tools' in historyItem.
@@ -173,7 +177,8 @@ export type HistoryItemWithoutId =
   | HistoryItemModelStats
   | HistoryItemToolStats
   | HistoryItemQuit
-  | HistoryItemCompression;
+  | HistoryItemCompression
+  | HistoryItemExtensionsList;
 
 export type HistoryItem = HistoryItemWithoutId & { id: number };
 
@@ -190,6 +195,7 @@ export enum MessageType {
   QUIT = 'quit',
   GEMINI = 'gemini',
   COMPRESSION = 'compression',
+  EXTENSIONS_LIST = 'extensions_list',
 }
 
 // Simplified message structure for internal feedback