automations: fix: remove delete action from run history rows (#333567)

automations: feat: remove delete action from run history rows

Temporarily hide the Delete affordance from Automation run-history
rows (both inline toolbar and context menu) while the AHP
run-deletion protocol is not yet available. Archive/Unarchive, Stop,
and read/unread actions remain unchanged. Ordinary Sessions surfaces
are unaffected.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 962fd6a6-f98e-4fe8-a288-bb3d8c257df3

Author: ulugbekna

src/vs/sessions/contrib/sessions/browser/views/automationsView.ts

@@ -50,14 +50,13 @@ import { IActionViewItemService } from '../../../../../platform/actions/browser/
 import { ChatSessionArchiveActionWording, ChatSessionArchiveActionWordingSettingId, getChatSessionArchiveActionPresentation, getChatSessionArchiveActionWording } from '../../../../../platform/chat/common/sessionArchiveActions.js';
 import { BaseActionViewItem, IActionViewItemOptions } from '../../../../../base/browser/ui/actionbar/actionViewItems.js';
 import { IAction } from '../../../../../base/common/actions.js';
-import { AutomationsCustomViewFocusContext, AutomationsHasItemsContext, SessionIsArchivedContext, SessionIsReadContext, SessionSupportsDeleteContext, SessionSupportsRenameContext } from '../../../../common/contextkeys.js';
+import { AutomationsCustomViewFocusContext, AutomationsHasItemsContext, SessionIsArchivedContext, SessionIsReadContext, SessionSupportsRenameContext } from '../../../../common/contextkeys.js';
 import { SessionsFlatList, SessionItemStatusContext } from './sessionsList.js';
 import { AUTOMATIONS_CUSTOM_VIEW_ID } from '../automationsConstants.js';
 import { ARCHIVE_SESSION_COMMAND_ID, MARK_SESSION_READ_COMMAND_ID, MARK_SESSION_UNREAD_COMMAND_ID, RENAME_SESSION_COMMAND_ID, UNARCHIVE_SESSION_COMMAND_ID } from '../../../../common/sessionCommands.js';
 
 const $ = DOM.$;
 const STOP_AUTOMATION_RUN_SESSION_COMMAND_ID = 'sessions.automations.stopRunSession';
-const DELETE_AUTOMATION_RUN_SESSION_COMMAND_ID = 'sessions.automations.deleteRunSession';
 const AutomationCardCanDeleteContext = new RawContextKey<boolean>('sessionsAutomationCardCanDelete', false);
 const AutomationCardCanDisableContext = new RawContextKey<boolean>('sessionsAutomationCardCanDisable', false);
 
@@ -870,9 +869,6 @@ class AutomationHistorySection extends Disposable {
 			case ARCHIVE_SESSION_COMMAND_ID:
 				await this.sessionsManagementService.archiveSession(session);
 				return true;
-			case DELETE_AUTOMATION_RUN_SESSION_COMMAND_ID:
-				await this.confirmDeleteRunSession(run, session, this.getAutomationName(run));
-				return true;
 			default:
 				return false;
 		}
@@ -912,54 +908,6 @@ class AutomationHistorySection extends Disposable {
 		}
 	}
 
-	private async confirmDeleteRunSession(run: IAutomationRun, session: ISession, automationName: string): Promise<void> {
-		// Capture focus before the confirmation dialog moves it.
-		const hadFocus = this.container.contains(DOM.getActiveElement());
-		const confirmed = await this.dialogService.confirm({
-			message: localize('confirmDeleteAutomationRunSession', "Delete the session for \"{0}\"?", automationName),
-			detail: localize('confirmDeleteAutomationRunSessionDetail', "This will permanently delete the session and remove this item from run history. This action cannot be undone."),
-			primaryButton: localize('delete', "Delete"),
-		});
-		if (!confirmed.confirmed) {
-			return;
-		}
-		const focusRunId = hadFocus ? this.getFocusRunIdAfterDeletion(run.id) : undefined;
-		try {
-			await this.sessionsManagementService.deleteSession(session);
-		} catch (error) {
-			this.clearPendingFocus();
-			this.logService.error('[AutomationsCards] Failed to delete automation run session', error);
-			await this.dialogService.error(
-				localize('automationRunSessionDeleteFailed', "Failed to delete the automation run session."),
-				getErrorMessage(error),
-			);
-			return;
-		}
-		if (hadFocus) {
-			this.pendingFocusRunId = focusRunId;
-			this.shouldRestoreFocus = true;
-		}
-		try {
-			await this.automationService.deleteRun(run.id);
-			this.restoreFocusAfterRender();
-			status(localize('automationRunSessionDeletedStatus', "Deleted the session for {0}", automationName));
-		} catch (error) {
-			this.restoreFocusAfterRender();
-			this.logService.error('[AutomationsCards] Failed to remove deleted automation run from history', error);
-			await this.dialogService.error(
-				localize('automationRunHistoryDeleteFailed', "The session was deleted, but its run history item could not be removed."),
-				getErrorMessage(error),
-			);
-		}
-	}
-
-	private getFocusRunIdAfterDeletion(runId: string): string | undefined {
-		const index = this.renderedFocusableRunIds.indexOf(runId);
-		return index >= 0
-			? this.renderedFocusableRunIds[index + 1] ?? this.renderedFocusableRunIds[index - 1]
-			: undefined;
-	}
-
 	private restoreFocusAfterRender(): void {
 		if (!this.shouldRestoreFocus) {
 			return;
@@ -1250,22 +1198,6 @@ function registerAutomationHistoryItemActions(archiveWording: ChatSessionArchive
 				SessionItemStatusContext.isEqualTo(SessionStatus.NeedsInput),
 			),
 		}),
-		MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItem, {
-			command: {
-				id: DELETE_AUTOMATION_RUN_SESSION_COMMAND_ID,
-				title: localize('deleteAutomationRunSessionAction', "Delete"),
-				icon: Codicon.trash,
-			},
-			group: 'navigation',
-			order: 3,
-			when: ContextKeyExpr.and(
-				SessionSupportsDeleteContext,
-				ContextKeyExpr.or(
-					SessionItemStatusContext.isEqualTo(SessionStatus.Completed),
-					SessionItemStatusContext.isEqualTo(SessionStatus.Error),
-				),
-			),
-		}),
 		MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
 			command: {
 				id: MARK_SESSION_READ_COMMAND_ID,
@@ -1311,21 +1243,6 @@ function registerAutomationHistoryItemActions(archiveWording: ChatSessionArchive
 			order: 2,
 			when: SessionIsArchivedContext,
 		}),
-		MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
-			command: {
-				id: DELETE_AUTOMATION_RUN_SESSION_COMMAND_ID,
-				title: localize('deleteAutomationRunSessionContextAction', "Delete"),
-			},
-			group: '2_delete',
-			order: 1,
-			when: ContextKeyExpr.and(
-				SessionSupportsDeleteContext,
-				ContextKeyExpr.or(
-					SessionItemStatusContext.isEqualTo(SessionStatus.Completed),
-					SessionItemStatusContext.isEqualTo(SessionStatus.Error),
-				),
-			),
-		}),
 	);
 }
 

src/vs/sessions/contrib/sessions/test/browser/automationsView.test.ts

@@ -1506,17 +1506,13 @@ suite('AutomationsCardsWidget', () => {
 				'vs.actions.separator',
 				'sessionsViewPane.renameSession',
 				'sessionsViewPane.archiveSession',
-				'vs.actions.separator',
-				'sessions.automations.deleteRunSession',
 			],
 			archiveLabel: 'Archive',
 			readActionIds: [
 				MARK_SESSION_UNREAD_COMMAND_ID,
 				'vs.actions.separator',
 				'sessionsViewPane.renameSession',
 				'sessionsViewPane.archiveSession',
-				'vs.actions.separator',
-				'sessions.automations.deleteRunSession',
 			],
 			commandCalls: [{
 				commandId: MARK_SESSION_READ_COMMAND_ID,
@@ -1597,34 +1593,6 @@ suite('AutomationsCardsWidget', () => {
 		});
 	});
 
-	test('history context menu deletion uses the run-only deletion flow', async () => {
-		const { automationService, contextMenuService, dialogService, sessionsManagementService, widget } = setup();
-		automationService.setAutomations([automation()]);
-		automationService.setRuns([run()]);
-		dialogService.confirmResult = { confirmed: true };
-		await waitForSessionActions();
-		const row = widget.element.querySelector<HTMLElement>('.automations-run-session-list .session-item');
-		assert.ok(row);
-
-		dispatchContextMenu(row);
-		const delegate = contextMenuService.delegate;
-		const deleteAction = delegate?.getActions().find(action => action.id === 'sessions.automations.deleteRunSession');
-		assert.ok(deleteAction);
-		await delegate?.actionRunner?.run(deleteAction, delegate.getActionsContext?.());
-		await automationService.deleteRunCompleted.p;
-		delegate?.onHide?.(false);
-
-		assert.deepStrictEqual({
-			deleteSessionCalls: sessionsManagementService.deleteSessionCalls,
-			deleteRunCalls: automationService.deleteRunCalls,
-			historyItemStillVisible: !!widget.element.querySelector('.automations-run-session-list .session-item'),
-		}, {
-			deleteSessionCalls: 1,
-			deleteRunCalls: 1,
-			historyItemStillVisible: false,
-		});
-	});
-
 	test('stops an active run without opening its session', async () => {
 		const { automationService, sessionsManagementService, sessionsService, widget } = setup();
 		sessionsManagementService.sessionStatus.set(SessionStatus.InProgress, undefined);
@@ -1672,37 +1640,6 @@ suite('AutomationsCardsWidget', () => {
 		});
 	});
 
-	test('deleting a run session confirms the permanent deletion without opening it', async () => {
-		const { automationService, dialogService, sessionsManagementService, sessionsService, widget } = setup();
-		automationService.setAutomations([automation()]);
-		automationService.setRuns([run()]);
-		dialogService.confirmResult = { confirmed: true };
-		await waitForSessionActions();
-
-		const deleteButton = getSessionAction(widget, 'Delete');
-		assert.ok(deleteButton);
-		deleteButton.click();
-		await automationService.deleteRunCompleted.p;
-
-		assert.deepStrictEqual({
-			confirmation: dialogService.confirmations[0],
-			deleteSessionCalls: sessionsManagementService.deleteSessionCalls,
-			deleteRunCalls: automationService.deleteRunCalls,
-			openCalls: sessionsService.openCalls,
-			historyItemStillVisible: !!widget.element.querySelector('.automations-run-session-list .session-item'),
-		}, {
-			confirmation: {
-				message: 'Delete the session for "Daily review"?',
-				detail: 'This will permanently delete the session and remove this item from run history. This action cannot be undone.',
-				primaryButton: 'Delete',
-			},
-			deleteSessionCalls: 1,
-			deleteRunCalls: 1,
-			openCalls: 0,
-			historyItemStillVisible: false,
-		});
-	});
-
 	test('archives a run session without opening it and hides the action', async () => {
 		const { automationService, sessionsManagementService, sessionsService, widget } = setup();
 		automationService.setAutomations([automation()]);
@@ -1718,93 +1655,27 @@ suite('AutomationsCardsWidget', () => {
 			archived: sessionsManagementService.archived.map(session => session.sessionId),
 			openCalls: sessionsService.openCalls,
 			archiveButtonVisible: !!getSessionAction(widget, 'Archive'),
-			deleteButtonVisible: !!getSessionAction(widget, 'Delete'),
 		}, {
 			archived: ['test/session-1'],
 			openCalls: 0,
 			archiveButtonVisible: false,
-			deleteButtonVisible: true,
-		});
-	});
-
-	test('deleting the focused run moves focus to the next run', async () => {
-		const { automationService, dialogService, widget } = setup();
-		automationService.setAutomations([automation()]);
-		automationService.setRuns([
-			run(),
-			run({ id: 'run-2', sessionResource: SECOND_SESSION_RESOURCE }),
-		]);
-		dialogService.confirmResult = { confirmed: true };
-		await waitForSessionActions();
-
-		const deleteButton = getSessionAction(widget, 'Delete');
-		assert.ok(deleteButton);
-		const list = widget.element.querySelector<HTMLElement>('.automations-run-session-list .monaco-list');
-		assert.ok(list);
-		list.focus();
-		deleteButton.click();
-		await automationService.deleteRunCompleted.p;
-		const remainingRow = widget.element.querySelector<HTMLElement>('.automations-run-session-list .monaco-list-row');
-
-		assert.deepStrictEqual({
-			historyItemCount: widget.element.querySelectorAll('.automations-run-session-list .session-item').length,
-			focusedNextRun: remainingRow?.classList.contains('focused'),
-		}, {
-			historyItemCount: 1,
-			focusedNextRun: true,
-		});
-	});
-
-	test('canceling run session deletion keeps the session', async () => {
-		const { automationService, dialogService, sessionsManagementService, widget } = setup();
-		automationService.setAutomations([automation()]);
-		automationService.setRuns([run()]);
-		await waitForSessionActions();
-
-		getSessionAction(widget, 'Delete')?.click();
-		await Promise.resolve();
-
-		assert.deepStrictEqual({
-			confirmations: dialogService.confirmations.length,
-			deleteSessionCalls: sessionsManagementService.deleteSessionCalls,
-			deleteButtonStillVisible: !!getSessionAction(widget, 'Delete'),
-		}, {
-			confirmations: 1,
-			deleteSessionCalls: 0,
-			deleteButtonStillVisible: true,
 		});
 	});
 
-	test('keeps run history when session deletion fails', async () => {
-		const { automationService, dialogService, sessionsManagementService, widget } = setup();
+	test('does not expose delete action on run history rows', async () => {
+		const { automationService, contextMenuService, widget } = setup();
 		automationService.setAutomations([automation()]);
 		automationService.setRuns([run()]);
-		dialogService.confirmResult = { confirmed: true };
-		sessionsManagementService.deleteError = new Error('delete failed');
 		await waitForSessionActions();
 
-		getSessionAction(widget, 'Delete')?.click();
-		await dialogService.errorCalled.p;
-
-		assert.deepStrictEqual({
-			deleteRunCalls: automationService.deleteRunCalls,
-			historyItemStillVisible: !!widget.element.querySelector('.automations-run-session-list .session-item'),
-			error: dialogService.errors,
-		}, {
-			deleteRunCalls: 0,
-			historyItemStillVisible: true,
-			error: [{ message: 'Failed to delete the automation run session.', detail: 'delete failed' }],
-		});
-	});
-
-	test('does not expose session deletion when the provider does not support it', async () => {
-		const { automationService, sessionsManagementService, widget } = setup();
-		sessionsManagementService.setSupportsDelete(false);
-		automationService.setAutomations([automation()]);
-		automationService.setRuns([run()]);
-		await waitForSessionActions();
+		assert.strictEqual(getSessionAction(widget, 'Delete'), undefined, 'delete absent from toolbar');
 
-		assert.strictEqual(getSessionAction(widget, 'Delete'), undefined);
+		const row = widget.element.querySelector<HTMLElement>('.automations-run-session-list .session-item');
+		assert.ok(row);
+		dispatchContextMenu(row);
+		const actionIds = (contextMenuService.delegate?.getActions() ?? []).map(a => a.id);
+		contextMenuService.delegate?.onHide?.(false);
+		assert.ok(!actionIds.includes('sessions.automations.deleteRunSession'), 'delete absent from context menu');
 	});
 
 	test('edit conflict is reported to the user', async () => {