fix: persist SCM repository visibility state across restarts

src/vs/base/browser/ui/menu/menu.ts

@@ -25,6 +25,7 @@ import { DisposableStore } from '../../../common/lifecycle.js';
 import { isLinux, isMacintosh } from '../../../common/platform.js';
 import { ScrollbarVisibility, ScrollEvent } from '../../../common/scrollable.js';
 import * as strings from '../../../common/strings.js';
+import { hasKey } from '../../../common/types.js';
 import { AnchorAlignment, layout, LayoutAnchorPosition } from '../../../common/layout.js';
 
 export const MENU_MNEMONIC_REGEX = /\(&([^\s&])\)|(^|[^&])&([^\s&])/;
@@ -237,6 +238,22 @@ export class Menu extends ActionBar {
 			parent: this
 		};
 
+		// When a keepOpen action runs, refresh the checked/enabled state of all items
+		this._register(this.onDidRun(e => {
+			if (e.action && hasKey(e.action, 'keepOpen') && e.action.keepOpen) {
+				for (const item of this.viewItems) {
+					if (item instanceof BaseMenuActionViewItem) {
+						// Re-evaluate the action's state from context keys
+						if (hasKey(item.action, 'refreshState')) {
+							(item.action as { refreshState(): void }).refreshState();
+						}
+						// Update the visual state
+						item.refreshState();
+					}
+				}
+			}
+		}));
+
 		this.mnemonics = new Map<string, Array<BaseMenuActionViewItem>>();
 
 		// Scroll Logic
@@ -700,6 +717,15 @@ class BaseMenuActionViewItem extends BaseActionViewItem {
 		return this.mnemonic;
 	}
 
+	/**
+	 * Refreshes the checked and enabled visual state of this menu item.
+	 * Used when a keepOpen action runs and the menu stays visible.
+	 */
+	refreshState(): void {
+		this.updateChecked();
+		this.updateEnabled();
+	}
+
 	protected applyStyle(): void {
 		const isSelected = this.element && this.element.classList.contains('focused');
 		const fgColor = isSelected && this.menuStyle.selectionForegroundColor ? this.menuStyle.selectionForegroundColor : this.menuStyle.foregroundColor;

src/vs/platform/actions/common/actions.ts

@@ -25,6 +25,12 @@ export interface IMenuItem {
 	group?: 'navigation' | string;
 	order?: number;
 	isHiddenByDefault?: boolean;
+	/**
+	 * When true, the context menu will not close when this item is triggered.
+	 * This is useful for toggle actions in menus where the user may want to
+	 * change multiple items without having to reopen the menu.
+	 */
+	keepOpen?: boolean;
 }
 
 export interface ISubmenuItem {
@@ -583,6 +589,9 @@ export class MenuItemAction implements IAction {
 	readonly alt: MenuItemAction | undefined;
 
 	private readonly _options: IMenuActionOptions | undefined;
+	private readonly _contextKeyService: IContextKeyService;
+	private readonly _precondition: ContextKeyExpression | undefined;
+	private readonly _toggledCondition: ContextKeyExpression | undefined;
 
 	readonly id: string;
 	readonly label: string;
@@ -591,15 +600,23 @@ export class MenuItemAction implements IAction {
 	readonly enabled: boolean;
 	readonly checked?: boolean;
 
+	/**
+	 * When true, the context menu should not close when this item is triggered.
+	 */
+	keepOpen: boolean = false;
+
 	constructor(
 		item: ICommandAction,
 		alt: ICommandAction | undefined,
 		options: IMenuActionOptions | undefined,
 		readonly hideActions: IMenuItemHide | undefined,
 		readonly menuKeybinding: IAction | undefined,
 		@IContextKeyService contextKeyService: IContextKeyService,
-		@ICommandService private _commandService: ICommandService
+		@ICommandService private _commandService: ICommandService,
 	) {
+		this._contextKeyService = contextKeyService;
+		this._precondition = item.precondition;
+
 		this.id = item.id;
 		this.label = MenuItemAction.label(item, options);
 		this.tooltip = (typeof item.tooltip === 'string' ? item.tooltip : item.tooltip?.value) ?? '';
@@ -608,10 +625,12 @@ export class MenuItemAction implements IAction {
 
 		let icon: ThemeIcon | undefined;
 
+		this._toggledCondition = undefined;
 		if (item.toggled) {
 			const toggled = ((item.toggled as { condition: ContextKeyExpression }).condition ? item.toggled : { condition: item.toggled }) as {
 				condition: ContextKeyExpression; icon?: Icon; tooltip?: string | ILocalizedString; title?: string | ILocalizedString;
 			};
+			this._toggledCondition = toggled.condition;
 			this.checked = contextKeyService.contextMatchesRules(toggled.condition);
 			if (this.checked && toggled.tooltip) {
 				this.tooltip = typeof toggled.tooltip === 'string' ? toggled.tooltip : toggled.tooltip.value;
@@ -637,6 +656,17 @@ export class MenuItemAction implements IAction {
 
 	}
 
+	/**
+	 * Re-evaluates the `checked` and `enabled` state from the current context keys.
+	 * Used when the menu stays open after this action runs (keepOpen).
+	 */
+	refreshState(): void {
+		(this as unknown as { enabled: boolean }).enabled = !this._precondition || this._contextKeyService.contextMatchesRules(this._precondition);
+		(this as unknown as { checked: boolean | undefined }).checked = this._toggledCondition
+			? this._contextKeyService.contextMatchesRules(this._toggledCondition)
+			: undefined;
+	}
+
 	run(...args: unknown[]): Promise<void> {
 		let runArgs: unknown[] = [];
 

src/vs/platform/actions/common/menuService.ts

@@ -293,7 +293,9 @@ class MenuInfo extends MenuInfoSnapshot {
 					if (isMenuItem) {
 						// MenuItemAction
 						const menuKeybinding = createConfigureKeybindingAction(this._commandService, this._keybindingService, item.command.id, item.when);
-						(activeActions ??= []).push(new MenuItemAction(item.command, item.alt, options, menuHide, menuKeybinding, this._contextKeyService, this._commandService));
+						const menuItemAction = new MenuItemAction(item.command, item.alt, options, menuHide, menuKeybinding, this._contextKeyService, this._commandService);
+						menuItemAction.keepOpen = !!item.keepOpen;
+						(activeActions ??= []).push(menuItemAction);
 					} else {
 						// SubmenuItemAction
 						const groups = new MenuInfo(item.submenu, this._hiddenStates, this._collectContextKeysForSubmenus, this._commandService, this._keybindingService, this._contextKeyService).createActionGroups(options);

src/vs/platform/contextview/browser/contextMenuHandler.ts

@@ -15,6 +15,7 @@ import { IKeybindingService } from '../../keybinding/common/keybinding.js';
 import { INotificationService } from '../../notification/common/notification.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.js';
 import { defaultMenuStyles } from '../../theme/browser/defaultStyles.js';
+import { MenuItemAction } from '../../actions/common/actions.js';
 
 
 export interface IContextMenuHandlerOptions {
@@ -153,6 +154,10 @@ export class ContextMenuHandler {
 			this.telemetryService.publicLog2<WorkbenchActionExecutedEvent, WorkbenchActionExecutedClassification>('workbenchActionExecuted', { id: e.action.id, from: 'contextMenu' });
 		}
 
+		if (e.action instanceof MenuItemAction && e.action.keepOpen) {
+			return;
+		}
+
 		this.contextViewService.hideContextView(false);
 	}
 

src/vs/workbench/contrib/scm/browser/menus.ts

@@ -408,6 +408,11 @@ export class SCMMenus implements ISCMMenus, IDisposable {
 	}
 
 	dispose(): void {
+		this.titleMenu.dispose();
+		for (const [, item] of this.menus) {
+			item.dispose();
+		}
+		this.menus.clear();
 		this.disposables.dispose();
 	}
 }

src/vs/workbench/contrib/scm/browser/scmViewPane.ts

@@ -976,7 +976,7 @@ class RepositoryVisibilityAction extends Action2 {
 			f1: false,
 			precondition: ContextKeyExpr.or(ContextKeys.RepositoryVisibilityCount.notEqualsTo(1), ContextKeys.RepositoryVisibility(repository).isEqualTo(false)),
 			toggled: ContextKeys.RepositoryVisibility(repository).isEqualTo(true),
-			menu: { id: Menus.Repositories, group: '0_repositories' }
+			menu: { id: Menus.Repositories, group: '0_repositories', keepOpen: true }
 		});
 		this.repository = repository;
 	}

src/vs/workbench/contrib/scm/browser/scmViewService.ts

@@ -242,7 +242,7 @@ export class SCMViewService implements ISCMViewService {
 		@IStorageService private readonly storageService: IStorageService,
 		@IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService
 	) {
-		this.menus = instantiationService.createInstance(SCMMenus);
+		this.menus = this.disposables.add(instantiationService.createInstance(SCMMenus));
 
 		const explorerEnabledConfig = observableConfigValue<boolean>('scm.repositories.explorer', false, this.configurationService);
 		this.graphShowIncomingChangesConfig = observableConfigValue<boolean>('scm.graph.showIncomingChanges', true, this.configurationService);
@@ -357,32 +357,34 @@ export class SCMViewService implements ISCMViewService {
 		} satisfies ISCMRepositoryView;
 
 		let removed: Iterable<ISCMRepository> = Iterable.empty();
+		let newReposToReAdd: ISCMRepositoryView[] = [];
 
 		if (this.previousState && !this.didFinishLoadingRepositories.get()) {
+			// Hidden repositories are not part of the saved state, so skip
+			// the restoration logic for them. They are still added to the
+			// internal list but should not affect the visibility restoration.
+			if (repository.provider.isHidden) {
+				this.insertRepositoryView(this._repositories, repositoryView);
+				this._onDidChangeRepositories.fire({ added: Iterable.empty(), removed: Iterable.empty() });
+				return;
+			}
+
 			const index = this.previousState.all.indexOf(getProviderStorageKey(repository.provider));
 
 			if (index === -1) {
-				// This repository is not part of the previous state which means that it
-				// was either manually closed in the previous session, or the repository
-				// was added after the previous session. In this case, we should select
-				// all of the repositories.
-				const added: ISCMRepository[] = [];
-
-				this.insertRepositoryView(this._repositories, repositoryView);
-
+				// This repository is not part of the previous state which means
+				// it was added after the previous session. In multi-select mode
+				// (or if no repository is selected yet), add it as visible. In
+				// single-select mode with a selection, add it but not visible.
 				if (this.selectionModeConfig.get() === ISCMRepositorySelectionMode.Multiple || !this._repositories.find(r => r.selectionIndex !== -1)) {
-					// Multiple selection mode or single selection mode (select first repository)
-					this._repositories.forEach((repositoryView, index) => {
-						if (repositoryView.selectionIndex === -1) {
-							added.push(repositoryView.repository);
-						}
-						repositoryView.selectionIndex = index;
-					});
-
-					this._onDidChangeRepositories.fire({ added, removed: Iterable.empty() });
+					const maxSelectionIndex = this.getMaxSelectionIndex();
+					this.insertRepositoryView(this._repositories, { ...repositoryView, selectionIndex: maxSelectionIndex + 1 });
+					this._onDidChangeRepositories.fire({ added: [repositoryView.repository], removed: Iterable.empty() });
+				} else {
+					this.insertRepositoryView(this._repositories, repositoryView);
+					this._onDidChangeRepositories.fire({ added: Iterable.empty(), removed: Iterable.empty() });
 				}
 
-				this.didSelectRepository = false;
 				return;
 			}
 
@@ -396,7 +398,15 @@ export class SCMViewService implements ISCMViewService {
 			} else {
 				// First visible repository
 				if (!this.didSelectRepository) {
-					removed = [...this.visibleRepositories];
+					newReposToReAdd = this._repositories.filter(r =>
+						r.selectionIndex !== -1 &&
+						this.previousState!.all.indexOf(getProviderStorageKey(r.repository.provider)) === -1
+					);
+
+					removed = [...this.visibleRepositories].filter(r =>
+						this.previousState!.all.indexOf(getProviderStorageKey(r.provider)) !== -1
+					);
+
 					this._repositories.forEach(r => {
 						r.focused = false;
 						r.selectionIndex = -1;
@@ -411,7 +421,17 @@ export class SCMViewService implements ISCMViewService {
 			// Multiple selection mode or single selection mode (select first repository)
 			const maxSelectionIndex = this.getMaxSelectionIndex();
 			this.insertRepositoryView(this._repositories, { ...repositoryView, selectionIndex: maxSelectionIndex + 1 });
-			this._onDidChangeRepositories.fire({ added: [repositoryView.repository], removed });
+
+			if (newReposToReAdd.length > 0 && this.selectionModeConfig.get() === ISCMRepositorySelectionMode.Multiple) {
+				const addedRepos: ISCMRepository[] = [repositoryView.repository];
+				for (const r of newReposToReAdd) {
+					r.selectionIndex = this.getMaxSelectionIndex() + 1;
+					addedRepos.push(r.repository);
+				}
+				this._onDidChangeRepositories.fire({ added: addedRepos, removed });
+			} else {
+				this._onDidChangeRepositories.fire({ added: [repositoryView.repository], removed });
+			}
 		} else {
 			// Single selection mode (add subsequent repository)
 			this.insertRepositoryView(this._repositories, repositoryView);

src/vs/workbench/contrib/scm/common/scmService.ts

@@ -423,6 +423,12 @@ export class SCMService implements ISCMService {
 		return repository;
 	}
 
+	dispose(): void {
+		this.inputHistory.dispose();
+		this._onDidAddProvider.dispose();
+		this._onDidRemoveProvider.dispose();
+	}
+
 	getRepository(id: string): ISCMRepository | undefined;
 	getRepository(resource: URI): ISCMRepository | undefined;
 	getRepository(idOrResource: string | URI): ISCMRepository | undefined {