@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/sessions/browser/views/automationsView.js

@@ -0,0 +1,2143 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as automationsCards from '../media/automationsCards.css';
+import './automationsAccessibility.js';
+import { $ as $$1, trackFocus, append, DragAndDropObserver, addDisposableListener, EventType, isHTMLElement, getWindow, EventHelper, getActiveElement, isActiveElement, isAncestor, clearNode, isAncestorOfActiveElement, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { ButtonBar, Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, toDisposable, DisposableStore, MutableDisposable, DisposableMap, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service';
+import { CHAT_AUTOMATIONS_ENABLED_SETTING, ChatAutomationsEnabledContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
+import { IAutomationRunner } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner.service';
+import { IAutomationDialogService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationDialogService.service';
+import { AutomationBlueprintParseError, AUTOMATION_BLUEPRINT_FILE_SUFFIX, parseAutomationBlueprint, createAutomationBlueprintFileName, serializeAutomationBlueprint, automationToBlueprint } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationBlueprint';
+import { DAYS_OF_WEEK } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/schedule';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { AgentSessionApprovalModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel';
+import { isEqual, basename, joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IDialogService, IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { extractEditorsDropData } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { SessionStatusIcon } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionStatusIcon';
+import { AbstractCustomView } from '../../../../services/customView/browser/customView.js';
+import { ICustomViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { MenuItemAction, MenuRegistry, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { getChatSessionArchiveActionWording, ChatSessionArchiveActionWordingSettingId, getChatSessionArchiveActionPresentation } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/sessionArchiveActions';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { AutomationsCustomViewFocusContext, AutomationsHasItemsContext, SessionIsReadContext, SessionIsArchivedContext, SessionSupportsRenameContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { SessionsFlatList, SessionItemStatusContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+import { AUTOMATIONS_CUSTOM_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/automationsConstants';
+import { ARCHIVE_SESSION_COMMAND_ID, MARK_SESSION_READ_COMMAND_ID, MARK_SESSION_UNREAD_COMMAND_ID, RENAME_SESSION_COMMAND_ID, UNARCHIVE_SESSION_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import { readAutomationTemplates } from './automationTemplates.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+registerCss(automationsCards, 1);
+const $ = $$1;
+const STOP_AUTOMATION_RUN_SESSION_COMMAND_ID = "sessions.automations.stopRunSession";
+const SEEN_PLUGIN_AUTOMATION_TEMPLATES_STORAGE_KEY = "sessions.automations.seenPluginTemplateIds";
+const AutomationCardCanDeleteContext = new RawContextKey("sessionsAutomationCardCanDelete", false);
+const AutomationCardCanUpdateContext = new RawContextKey("sessionsAutomationCardCanUpdate", false);
+const AutomationCardEnabledContext = new RawContextKey("sessionsAutomationCardEnabled", false);
+function areAutomationTemplatesEqual(first, second) {
+    return first.length === second.length && first.every((template, index) => {
+        const other = second[index];
+        return template.id === other.id && template.name === other.name && template.description === other.description && template.prompt === other.prompt && template.enabled === other.enabled && template.schedule.interval === other.schedule.interval && template.schedule.scheduleHour === other.schedule.scheduleHour && template.schedule.scheduleMinute === other.schedule.scheduleMinute && template.schedule.scheduleDay === other.schedule.scheduleDay && template.source?.label === other.source?.label && ((!template.source && !other.source) || (!!template.source && !!other.source && isEqual(template.source.uri, other.source.uri)));
+    });
+}
+function setsEqual(first, second) {
+    return first.size === second.size && [...first].every(value => ( second.has(value)));
+}
+let AutomationsCardsWidget = class AutomationsCardsWidget extends Disposable {
+    constructor(
+        automationService,
+        agentPluginService,
+        sessionsManagementService,
+        instantiationService,
+        contextKeyService,
+        uriIdentityService
+    ) {
+        super();
+        this.automationService = automationService;
+        this.agentPluginService = agentPluginService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.uriIdentityService = uriIdentityService;
+        this.isMarkingAllRead = observableValue(this, false);
+        this.element = $(".automations-cards-widget");
+        this.element.tabIndex = -1;
+        const focusContext = AutomationsCustomViewFocusContext.bindTo(contextKeyService);
+        const focusTracker = this._register(trackFocus(this.element));
+        this._register(focusTracker.onDidFocus(() => focusContext.set(true)));
+        this._register(focusTracker.onDidBlur(() => focusContext.set(false)));
+        this._register(toDisposable(() => focusContext.reset()));
+        const scrollContent = append(this.element, $(".automations-cards-scroll-content"));
+        this.cardsSection = this._register(
+            instantiationService.createInstance(AutomationCardsSection, scrollContent, this.element)
+        );
+        this.historySection = this._register(instantiationService.createInstance(
+            AutomationHistorySection,
+            scrollContent,
+            this.element,
+            this.isMarkingAllRead
+        ));
+        this._register(autorun(reader => {
+            const catalogueState = this.automationService.catalogueState.read(reader);
+            const items = this.automationService.automations.read(reader);
+            const templates = readAutomationTemplates(this.agentPluginService.plugins.read(reader), reader);
+            this.cardsSection.render(items, catalogueState, templates);
+        }));
+        const sessionDeleted = observableSignalFromEvent(this, this.sessionsManagementService.onDidDeleteSession);
+        const sessionsChanged = observableSignalFromEvent(this, this.sessionsManagementService.onDidChangeSessions);
+        this._register(autorun(reader => {
+            if (this.isMarkingAllRead.read(reader)) {
+                return;
+            }
+            sessionDeleted.read(reader);
+            sessionsChanged.read(reader);
+            this.automationService.automations.read(reader);
+            const allRuns = this.automationService.runs.read(reader);
+            const sessionsByResource = ( new Map(this.sessionsManagementService.getSessions().map(
+                session => [this.uriIdentityService.extUri.getComparisonKey(session.resource), session]
+            )));
+            const sessions = ( new Map());
+            for (const run of allRuns) {
+                if (!run.sessionResource) {
+                    continue;
+                }
+                const session = sessionsByResource.get(this.uriIdentityService.extUri.getComparisonKey(run.sessionResource));
+                if (session) {
+                    sessions.set(run.id, session);
+                }
+            }
+            this.historySection.render(allRuns, sessions);
+        }));
+    }
+    layout(width, height) {
+        this.element.style.width = `${width}px`;
+        this.historySection.layout();
+    }
+    focus() {
+        this.element.focus();
+    }
+};
+AutomationsCardsWidget = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IAgentPluginService)), ( __param(2, ISessionsManagementService)), ( __param(3, IInstantiationService)), ( __param(4, IContextKeyService)), ( __param(5, IUriIdentityService))], AutomationsCardsWidget));
+let AutomationCardsSection = class AutomationCardsSection extends Disposable {
+    constructor(
+        parent,
+        focusRoot,
+        automationService,
+        automationRunner,
+        automationDialogService,
+        hoverService,
+        logService,
+        dialogService,
+        fileService,
+        storageService,
+        configurationService,
+        contextKeyService,
+        contextMenuService
+    ) {
+        super();
+        this.focusRoot = focusRoot;
+        this.automationService = automationService;
+        this.automationRunner = automationRunner;
+        this.automationDialogService = automationDialogService;
+        this.hoverService = hoverService;
+        this.logService = logService;
+        this.dialogService = dialogService;
+        this.fileService = fileService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.contextKeyService = contextKeyService;
+        this.contextMenuService = contextMenuService;
+        this.persistentCards = ( new Map());
+        this.latestAutomations = ( new Map());
+        this.emptyStateDisposables = this._register(( new DisposableStore()));
+        this.templateDisposables = this._register(( new DisposableStore()));
+        this.stateDisposables = this._register(( new DisposableStore()));
+        this.templateAriaId = generateUuid();
+        this.emptyStateRendered = false;
+        this.renderedTemplates = [];
+        this.builtInTemplatesUserToggled = false;
+        this.pluginTemplatesUserToggled = false;
+        this.currentPluginTemplateIds = ( new Set());
+        this.partialState = "ready";
+        this.focusRequestGeneration = 0;
+        this.seenPluginTemplateIds = this.readSeenPluginTemplateIds();
+        this._register(this.storageService.onDidChangeValue(
+            StorageScope.PROFILE,
+            SEEN_PLUGIN_AUTOMATION_TEMPLATES_STORAGE_KEY,
+            this._store
+        )(() => {
+            this.seenPluginTemplateIds = this.readSeenPluginTemplateIds();
+            this.updatePluginTemplateUnreadState(false);
+        }));
+        this.partialStateContainer = append(parent, $(".automations-cards-partial-state"));
+        this.partialStateContainer.setAttribute("role", "status");
+        this.partialStateContainer.setAttribute("aria-live", "polite");
+        this.partialStateContainer.style.display = "none";
+        this.partialLoadingIcon = append(this.partialStateContainer, $("span.automations-cards-partial-state-icon"));
+        this.partialLoadingIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.loading), "codicon-modifier-spin");
+        this.partialLoadingIcon.setAttribute("aria-hidden", "true");
+        this.partialErrorIcon = append(this.partialStateContainer, $("span.automations-cards-partial-state-icon"));
+        this.partialErrorIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.warning));
+        this.partialErrorIcon.setAttribute("aria-hidden", "true");
+        this.partialStateMessage = append(
+            this.partialStateContainer,
+            $("span.automations-cards-partial-state-message")
+        );
+        this.container = append(parent, $(".automations-cards-grid"));
+        this.container.style.display = "none";
+        this.emptyContainer = append(parent, $(".automations-cards-empty"));
+        this.emptyContainer.style.display = "none";
+        this.loadingContainer = append(parent, $(".automations-cards-state.automations-cards-loading"));
+        this.loadingContainer.style.display = "none";
+        this.loadingCreateButton = this.renderLoadingState();
+        this.unavailableContainer = append(parent, $(".automations-cards-state.automations-cards-unavailable"));
+        this.unavailableContainer.style.display = "none";
+        this.unavailableCreateButton = this.renderUnavailableState();
+        this.errorContainer = append(parent, $(".automations-cards-state.automations-cards-error"));
+        this.errorContainer.style.display = "none";
+        this.errorCreateButton = this.renderErrorState();
+        this.templatesContainer = append(parent, $(".automations-templates"));
+        this.templatesContainer.style.display = "none";
+        this.dropOverlay = append(this.focusRoot, $(".automations-drop-overlay"));
+        this.dropOverlay.setAttribute("role", "status");
+        this.dropOverlay.setAttribute("aria-live", "polite");
+        const dropIcon = append(this.dropOverlay, $("span.automations-drop-overlay-icon"));
+        dropIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.cloudUpload));
+        dropIcon.setAttribute("aria-hidden", "true");
+        const dropTitle = append(this.dropOverlay, $("span.automations-drop-overlay-title"));
+        dropTitle.textContent = ( localize(4660, "Drop to import automation"));
+        const dropDescription = append(this.dropOverlay, $("span.automations-drop-overlay-description"));
+        dropDescription.textContent = ( localize(4661, "You can review the Automation before creating it."));
+        this._register(new DragAndDropObserver(this.focusRoot, {
+            onDragEnter: event => this.updateDropOverlay(event),
+            onDragOver: event => this.updateDropOverlay(event),
+            onDragLeave: () => this.hideDropOverlay(),
+            onDragEnd: () => this.hideDropOverlay(),
+            onDrop: event => this.handleDrop(event)
+        }));
+        const focusTracker = this._register(trackFocus(this.focusRoot));
+        this._register(focusTracker.onDidBlur(() => this.clearPendingFocus()));
+        this._register(
+            addDisposableListener(this.focusRoot, EventType.FOCUS_OUT, event => {
+                if (event.relatedTarget && (!isHTMLElement(event.relatedTarget) || !this.focusRoot.contains(event.relatedTarget))) {
+                    this.clearPendingFocus();
+                }
+            })
+        );
+        this._register(addDisposableListener(
+            getWindow(this.focusRoot),
+            EventType.BLUR,
+            () => this.clearPendingFocus()
+        ));
+        this._register(
+            addDisposableListener(this.focusRoot, EventType.MOUSE_DOWN, () => this.clearPendingFocus())
+        );
+        this._register(
+            addDisposableListener(this.focusRoot, EventType.KEY_DOWN, () => this.clearPendingFocus())
+        );
+        this._register(toDisposable(() => {
+            this.clearPendingFocus();
+            for (const card of ( this.persistentCards.values())) {
+                card.disposables.dispose();
+                card.element.remove();
+            }
+            this.persistentCards.clear();
+            this.latestAutomations.clear();
+        }));
+    }
+    updateDropOverlay(event) {
+        const dropData = getAutomationDropData(event);
+        const canImport = dropData.kind === "resource" || dropData.kind === "file";
+        this.dropOverlay.classList.toggle("visible", canImport);
+        if (canImport && event.dataTransfer) {
+            event.dataTransfer.dropEffect = "copy";
+        }
+    }
+    hideDropOverlay() {
+        this.dropOverlay.classList.remove("visible");
+    }
+    handleDrop(event) {
+        const dropData = getAutomationDropData(event);
+        this.hideDropOverlay();
+        if (dropData.kind === "none") {
+            return;
+        }
+        EventHelper.stop(event, true);
+        if (dropData.kind === "invalid") {
+            const detail = dropData.reason === "multiple" ? ( localize(4662, "Drop one Automation blueprint file at a time.")) : ( localize(4663, "Only .automation.md files can be imported."));
+            void this.dialogService.error(( localize(4664, "Unable to import automation.")), detail);
+            return;
+        }
+        const readContent = dropData.kind === "resource" ? async () => ( (await this.fileService.readFile(dropData.resource)).value.toString()) : async () => ( VSBuffer.wrap(( new Uint8Array(await dropData.file.arrayBuffer()))).toString());
+        void importAutomationBlueprint(
+            readContent,
+            this.automationDialogService,
+            this.automationService,
+            this.configurationService,
+            this.dialogService,
+            this.logService
+        );
+    }
+    render(automations, catalogueState, templates) {
+        const activeElement = getActiveElement();
+        const contentOwnedFocus = isHTMLElement(activeElement) && (this.visibleContainer?.contains(activeElement) || this.templatesContainer.contains(activeElement));
+        const activeAutomationIds = ( new Set(automations.map(automation => automation.id)));
+        for (const [automationId, card] of this.persistentCards) {
+            if (( activeAutomationIds.has(automationId))) {
+                continue;
+            }
+            card.disposables.dispose();
+            card.element.remove();
+            this.persistentCards.delete(automationId);
+            this.latestAutomations.delete(automationId);
+        }
+        let index = 0;
+        for (const automation of automations) {
+            const prev = this.latestAutomations.get(automation.id);
+            this.latestAutomations.set(automation.id, automation);
+            let card = this.persistentCards.get(automation.id);
+            if (!card) {
+                card = this.renderCard(automation);
+                this.persistentCards.set(automation.id, card);
+            } else if (prev !== automation) {
+                this.updateCard(card, automation, prev);
+            }
+            const currentElement = this.container.children.item(index);
+            if (currentElement !== card.element) {
+                this.container.insertBefore(card.element, currentElement);
+            }
+            index++;
+        }
+        if (!this.builtInTemplatesUserToggled) {
+            const defaultExpanded = automations.length === 0;
+            if (this.builtInTemplatesExpanded !== defaultExpanded) {
+                this.builtInTemplatesExpanded = defaultExpanded;
+                if (this.builtInTemplatesSection) {
+                    this.builtInTemplatesSection.open = defaultExpanded;
+                }
+            }
+        }
+        if (!this.pluginTemplatesUserToggled) {
+            const defaultExpanded = automations.length === 0;
+            if (this.pluginTemplatesExpanded !== defaultExpanded) {
+                this.pluginTemplatesExpanded = defaultExpanded;
+                if (this.pluginTemplatesSection) {
+                    this.pluginTemplatesSection.open = defaultExpanded;
+                }
+            }
+        }
+        if (!areAutomationTemplatesEqual(this.renderedTemplates, templates)) {
+            this.renderTemplates(templates);
+            this.renderedTemplates = templates;
+        }
+        this.updatePluginTemplateUnreadState(
+            this.pluginTemplatesUserToggled || (catalogueState === "ready" && automations.length === 0)
+        );
+        const showTemplateSections = templates.length > 0;
+        this.templatesContainer.style.display = showTemplateSections ? "" : "none";
+        const nextContainer = automations.length === 0 ? this.getEmptyStateContainer(catalogueState) : this.container;
+        const previousContainer = this.visibleContainer;
+        if (previousContainer !== nextContainer) {
+            nextContainer.style.display = "";
+            this.visibleContainer = nextContainer;
+        }
+        this.renderPartialState(automations.length > 0 ? catalogueState : "ready");
+        if (!this.focusPendingAutomation() && contentOwnedFocus && isHTMLElement(activeElement)) {
+            if (!nextContainer.contains(activeElement) && !(showTemplateSections && this.isVisibleTemplateElement(activeElement))) {
+                this.focusVisibleState(automations, catalogueState);
+            } else if (!isActiveElement(activeElement)) {
+                activeElement.focus();
+            }
+        }
+        if (previousContainer && previousContainer !== nextContainer) {
+            previousContainer.style.display = "none";
+        }
+    }
+    isVisibleTemplateElement(element) {
+        if (!this.templatesContainer.contains(element)) {
+            return false;
+        }
+        const section = element.closest("details.automations-template-section");
+        const summary = element.closest("summary");
+        return !section || section.open || summary?.parentElement === section;
+    }
+    getEmptyStateContainer(catalogueState) {
+        switch (catalogueState) {
+        case "loading":
+            return this.loadingContainer;
+        case "unavailable":
+            return this.unavailableContainer;
+        case "error":
+            return this.errorContainer;
+        case "ready":
+            if (!this.emptyStateRendered) {
+                this.renderEmptyState();
+                this.emptyStateRendered = true;
+            }
+            return this.emptyContainer;
+        }
+    }
+    renderCard(automation) {
+        const disposables = ( new DisposableStore());
+        const wrapper = $(".automations-card-wrapper");
+        const card = append(wrapper, $(".automations-card"));
+        card.setAttribute("role", "group");
+        const cardContextKeyService = disposables.add(this.contextKeyService.createScoped(card));
+        const canDeleteContext = AutomationCardCanDeleteContext.bindTo(cardContextKeyService);
+        const canUpdateContext = AutomationCardCanUpdateContext.bindTo(cardContextKeyService);
+        const enabledContext = AutomationCardEnabledContext.bindTo(cardContextKeyService);
+        disposables.add(Gesture.addTarget(card));
+        const main = append(card, $("button.automations-card-main", {
+            type: "button"
+        }));
+        const nameRow = append(main, $(".automations-card-name"));
+        const nameTextEl = append(nameRow, $("span.automations-card-name-text"));
+        const disabledBadge = append(nameRow, $("span.automations-card-disabled-badge"));
+        disabledBadge.textContent = ( localize(4665, "Disabled"));
+        const metaEl = append(main, $(".automations-card-meta"));
+        const scheduleEl = append(metaEl, $("span.automations-card-meta-item.automations-card-schedule"));
+        const folderEl = append(metaEl, $("span.automations-card-meta-item.automations-card-folder"));
+        const folderHover = disposables.add(( new MutableDisposable()));
+        const promptEl = append(main, $(".automations-card-prompt"));
+        const actions = append(card, $(".automations-card-actions"));
+        actions.setAttribute("role", "group");
+        const buttonBar = disposables.add(( new ButtonBar(actions)));
+        const runNowLabel = ( localize(4666, "Run now"));
+        const runningLabel = ( localize(4667, "Running"));
+        const runBtn = this.createIconButton(
+            buttonBar,
+            Codicon.play,
+            runNowLabel,
+            this.automationService.canRunAutomation?.(automation.id) === false
+        );
+        runBtn.element.classList.add("automations-card-run-button");
+        disposables.add(runBtn.onDidClick(e => {
+            e?.stopPropagation();
+            const currentAutomation = this.latestAutomations.get(automation.id);
+            if (!currentAutomation || this.automationService.canRunAutomation?.(automation.id) === false) {
+                return;
+            }
+            runBtn.enabled = false;
+            runBtn.setAriaLabel(runningLabel);
+            runBtn.setTitle(runningLabel);
+            disposableTimeout(() => {
+                runBtn.enabled = this.automationService.canRunAutomation?.(automation.id) !== false;
+                runBtn.setAriaLabel(runNowLabel);
+                runBtn.setTitle(runNowLabel);
+            }, 10_000, disposables);
+            void this.runNow(currentAutomation);
+        }));
+        const moreActionsButton = this.createIconButton(buttonBar, Codicon.kebabVertical, ( localize(4668, "More Actions for {0}", automation.name)), false);
+        moreActionsButton.element.classList.add("automations-card-more-actions-button");
+        moreActionsButton.element.setAttribute("aria-haspopup", "menu");
+        moreActionsButton.element.setAttribute("aria-expanded", "false");
+        disposables.add(moreActionsButton.onDidClick(event => {
+            event?.stopPropagation();
+            const currentAutomation = this.latestAutomations.get(automation.id);
+            if (!currentAutomation) {
+                return;
+            }
+            actions.classList.add("menu-open");
+            moreActionsButton.element.setAttribute("aria-expanded", "true");
+            this.contextMenuService.showContextMenu({
+                menuId: Menus.AutomationCardContext,
+                menuActionOptions: {
+                    shouldForwardArgs: true,
+                    arg: currentAutomation
+                },
+                getAnchor: () => moreActionsButton.element,
+                contextKeyService: cardContextKeyService,
+                onHide: () => {
+                    actions.classList.remove("menu-open");
+                    moreActionsButton.element.setAttribute("aria-expanded", "false");
+                }
+            });
+        }));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            disposables.add(addDisposableListener(card, eventType, event => {
+                const target = event.initialTarget ?? event.target;
+                if (target instanceof Node && isAncestor(target, actions)) {
+                    return;
+                }
+                const currentAutomation = this.latestAutomations.get(automation.id);
+                if (!currentAutomation || this.automationService.canUpdateAutomation?.(automation.id) === false) {
+                    return;
+                }
+                void this.openEditDialog(currentAutomation);
+            }));
+        }
+        const entry = {
+            element: wrapper,
+            card,
+            main,
+            actions,
+            runButton: runBtn,
+            moreActionsButton,
+            canDeleteContext,
+            canUpdateContext,
+            enabledContext,
+            nameText: nameTextEl,
+            scheduleEl,
+            folderEl,
+            folderHover,
+            promptEl,
+            disabledBadge,
+            disposables
+        };
+        this.updateCard(entry, automation);
+        return entry;
+    }
+    updateCard(card, automation, previous) {
+        card.main.disabled = this.automationService.canUpdateAutomation?.(automation.id) === false;
+        card.runButton.enabled = this.automationService.canRunAutomation?.(automation.id) !== false;
+        card.canDeleteContext.set(this.automationService.canDeleteAutomation?.(automation.id) !== false);
+        card.canUpdateContext.set(this.automationService.canUpdateAutomation?.(automation.id) !== false);
+        card.enabledContext.set(automation.enabled);
+        const schedule = formatSchedule(automation.schedule);
+        const scheduleChanged = !previous || formatSchedule(previous.schedule) !== schedule;
+        const nameChanged = !previous || previous.name !== automation.name;
+        if (nameChanged || scheduleChanged) {
+            card.card.setAttribute("aria-label", ( localize(4669, "{0} — {1}", automation.name, schedule)));
+        }
+        if (nameChanged) {
+            card.main.setAttribute("aria-label", ( localize(4670, "Edit automation {0}", automation.name)));
+            card.actions.setAttribute("aria-label", ( localize(4671, "Actions for {0}", automation.name)));
+            const moreActionsLabel = ( localize(4668, "More Actions for {0}", automation.name));
+            card.moreActionsButton.setAriaLabel(moreActionsLabel);
+            card.moreActionsButton.setTitle(moreActionsLabel);
+            card.nameText.textContent = automation.name;
+        }
+        if (!previous || previous.enabled !== automation.enabled) {
+            card.disabledBadge.style.display = automation.enabled ? "none" : "";
+        }
+        if (scheduleChanged) {
+            card.scheduleEl.textContent = schedule;
+        }
+        const folderLabel = getAutomationTargetLabel(automation.target);
+        if (!previous || getAutomationTargetLabel(previous.target) !== folderLabel) {
+            card.folderEl.textContent = folderLabel;
+            card.folderHover.value = this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), card.folderEl, folderLabel);
+        }
+        if (!previous || previous.prompt !== automation.prompt) {
+            const maxLength = 120;
+            card.promptEl.textContent = automation.prompt.length > maxLength ? automation.prompt.slice(0, maxLength) + "…" : automation.prompt;
+        }
+    }
+    createIconButton(buttonBar, icon, tooltip, disabled) {
+        const button = buttonBar.addButton({
+            ariaLabel: tooltip,
+            disabled,
+            supportIcons: true,
+            title: tooltip
+        });
+        button.label = `$(${icon.id})`;
+        button.element.classList.add("automations-card-action-button");
+        return button;
+    }
+    async runNow(automation) {
+        if (!(await this.ensureEnabled())) {
+            return;
+        }
+        try {
+            const operation = this.automationRunner.runOnce(automation, "manual", 0, CancellationToken.None);
+            const dispatch = await operation.whenDispatched;
+            switch (dispatch.kind) {
+            case "started":
+                status(( localize(4672, "Started automation {0}", automation.name)));
+                break;
+            case "alreadyRunning":
+                status(( localize(4673, "Automation {0} is already running", automation.name)));
+                break;
+            case "notStarted":
+                status(( localize(4674, "Automation {0} did not start", automation.name)));
+                break;
+            }
+            await operation.whenCompleted;
+        } catch (error) {
+            this.logService.error("[AutomationsCards] Failed to run automation", error);
+            await this.dialogService.error(( localize(4675, "Failed to run automation.")), getErrorMessage(error));
+        }
+    }
+    renderEmptyState() {
+        const title = append(this.emptyContainer, $("h3.automations-cards-empty-title"));
+        title.textContent = ( localize(4676, "No automations yet"));
+        const desc = append(this.emptyContainer, $("p.automations-cards-empty-description"));
+        desc.textContent = ( localize(
+            4677,
+            "Create an automation to schedule an agent session to run on a cadence you choose."
+        ));
+        const createButton = this.emptyStateDisposables.add(( new Button(this.emptyContainer, {
+            ...defaultButtonStyles,
+            title: ( localize(4678, "Create Automation"))
+        })));
+        this.emptyCreateButton = createButton;
+        createButton.label = ( localize(4678, "Create Automation"));
+        createButton.element.classList.add("automations-cards-create-button");
+        this.emptyStateDisposables.add(createButton.onDidClick(() => this.openCreateDialog()));
+    }
+    renderTemplates(templates) {
+        this.templateDisposables.clear();
+        clearNode(this.templatesContainer);
+        const builtInTemplates = templates.filter(template => !template.source);
+        const pluginTemplates = templates.filter(template => !!template.source);
+        this.currentPluginTemplateIds = ( new Set(pluginTemplates.map(template => template.id)));
+        this.pluginTemplatesSection = undefined;
+        this.pluginTemplatesSummary = undefined;
+        this.pluginTemplatesUnreadIndicator = undefined;
+        this.builtInTemplatesSection = this.renderTemplateSection({
+            className: "automations-built-in-templates",
+            title: ( localize(4679, "Built-in Templates")),
+            description: ( localize(
+                4680,
+                "Choose a starting point, then review and customize it before creating."
+            )),
+            templates: builtInTemplates,
+            expanded: this.builtInTemplatesExpanded ?? false,
+            onDidToggle: expanded => {
+                if (expanded !== this.builtInTemplatesExpanded) {
+                    this.builtInTemplatesExpanded = expanded;
+                    this.builtInTemplatesUserToggled = true;
+                }
+            }
+        }).section;
+        if (pluginTemplates.length > 0) {
+            const rendered = this.renderTemplateSection({
+                className: "automations-plugin-templates",
+                title: ( localize(4681, "Templates from Plugins")),
+                description: ( localize(4682, "Templates provided by enabled plugins start disabled.")),
+                templates: pluginTemplates,
+                expanded: this.pluginTemplatesExpanded ?? false,
+                showUnreadIndicator: true,
+                onDidToggle: expanded => {
+                    this.pluginTemplatesExpanded = expanded;
+                    this.pluginTemplatesUserToggled = true;
+                    this.updatePluginTemplateUnreadState(expanded);
+                }
+            });
+            this.pluginTemplatesSection = rendered.section;
+            this.pluginTemplatesSummary = rendered.summary;
+            this.pluginTemplatesUnreadIndicator = rendered.unreadIndicator;
+        }
+    }
+    renderTemplateSection(options) {
+        const section = append(
+            this.templatesContainer,
+            $(`details.automations-template-section.${options.className}`)
+        );
+        section.open = options.expanded;
+        const summary = append(section, $("summary.automations-template-section-summary"));
+        const chevron = append(summary, $("span.automations-template-section-chevron"));
+        chevron.classList.add(...ThemeIcon.asClassNameArray(Codicon.chevronRight));
+        chevron.setAttribute("aria-hidden", "true");
+        const title = append(summary, $("span.automations-template-section-title"));
+        title.id = `${options.className}-${this.templateAriaId}`;
+        title.setAttribute("role", "heading");
+        title.setAttribute("aria-level", "3");
+        title.textContent = options.title;
+        const unreadIndicator = options.showUnreadIndicator ? append(summary, $("span.automations-template-section-unread")) : undefined;
+        unreadIndicator?.setAttribute("aria-hidden", "true");
+        const count = append(summary, $("span.automations-template-section-count"));
+        count.textContent = String(options.templates.length);
+        this.templateDisposables.add(
+            addDisposableListener(section, "toggle", () => options.onDidToggle(section.open))
+        );
+        const description = append(section, $("p.automations-templates-description"));
+        description.textContent = options.description;
+        const grid = append(section, $(".automations-templates-grid"));
+        grid.setAttribute("role", "group");
+        grid.setAttribute("aria-labelledby", title.id);
+        for (const template of options.templates) {
+            this.renderTemplateCard(grid, template);
+        }
+        return {
+            section,
+            summary,
+            unreadIndicator
+        };
+    }
+    updatePluginTemplateUnreadState(markExpandedAsSeen) {
+        if (!this.pluginTemplatesSection || !this.pluginTemplatesSummary || !this.pluginTemplatesUnreadIndicator) {
+            return;
+        }
+        if (this.pluginTemplatesSection.open && markExpandedAsSeen) {
+            this.markCurrentPluginTemplatesSeen();
+        }
+        const unreadCount = this.pluginTemplatesSection.open ? 0 : [...this.currentPluginTemplateIds].filter(id => !( this.seenPluginTemplateIds.has(id))).length;
+        this.pluginTemplatesUnreadIndicator.classList.toggle("visible", unreadCount > 0);
+        if (unreadCount === 0) {
+            this.pluginTemplatesSummary.removeAttribute("aria-label");
+        } else {
+            this.pluginTemplatesSummary.setAttribute("aria-label", unreadCount === 1 ? ( localize(4683, "Templates from Plugins, 1 new template")) : ( localize(4684, "Templates from Plugins, {0} new templates", unreadCount)));
+        }
+    }
+    markCurrentPluginTemplatesSeen() {
+        if (setsEqual(this.currentPluginTemplateIds, this.seenPluginTemplateIds)) {
+            return;
+        }
+        this.seenPluginTemplateIds = ( new Set(this.currentPluginTemplateIds));
+        this.storageService.store(
+            SEEN_PLUGIN_AUTOMATION_TEMPLATES_STORAGE_KEY,
+            JSON.stringify([...this.seenPluginTemplateIds].sort()),
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+    readSeenPluginTemplateIds() {
+        const raw = this.storageService.get(SEEN_PLUGIN_AUTOMATION_TEMPLATES_STORAGE_KEY, StorageScope.PROFILE);
+        if (!raw) {
+            return ( new Set());
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed) && parsed.every(id => typeof id === "string")) {
+                return ( new Set(parsed));
+            }
+        } catch (error) {
+            this.logService.warn("[Automations] Failed to read seen plugin Automation templates.", error);
+            return ( new Set());
+        }
+        this.logService.warn("[Automations] Ignoring invalid seen plugin Automation templates storage.");
+        return ( new Set());
+    }
+    renderLoadingState() {
+        this.loadingContainer.setAttribute("role", "status");
+        const icon = append(this.loadingContainer, $("span.automations-cards-state-icon"));
+        icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.loading), "codicon-modifier-spin");
+        icon.setAttribute("aria-hidden", "true");
+        const title = append(this.loadingContainer, $("h3.automations-cards-state-title"));
+        title.textContent = ( localize(4685, "Loading automations..."));
+        const description = append(this.loadingContainer, $("p.automations-cards-state-description"));
+        description.textContent = ( localize(4686, "You can create a new automation while existing automations load."));
+        return this.renderStateCreateButton(this.loadingContainer);
+    }
+    renderUnavailableState() {
+        const icon = append(this.unavailableContainer, $("span.automations-cards-state-icon"));
+        icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.debugDisconnect));
+        icon.setAttribute("aria-hidden", "true");
+        const title = append(this.unavailableContainer, $("h3.automations-cards-state-title"));
+        title.textContent = ( localize(4687, "Some automations are unavailable"));
+        const description = append(this.unavailableContainer, $("p.automations-cards-state-description"));
+        description.textContent = ( localize(
+            4688,
+            "One or more providers are disconnected, disabled, or do not support automations."
+        ));
+        return this.renderStateCreateButton(this.unavailableContainer);
+    }
+    renderErrorState() {
+        this.errorContainer.setAttribute("role", "alert");
+        const icon = append(this.errorContainer, $("span.automations-cards-state-icon"));
+        icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.error));
+        icon.setAttribute("aria-hidden", "true");
+        const title = append(this.errorContainer, $("h3.automations-cards-state-title"));
+        title.textContent = ( localize(4689, "Unable to load automations"));
+        const description = append(this.errorContainer, $("p.automations-cards-state-description"));
+        description.textContent = ( localize(4690, "The complete automation catalogue could not be read."));
+        return this.renderStateCreateButton(this.errorContainer);
+    }
+    renderStateCreateButton(container) {
+        const createButton = this.stateDisposables.add(( new Button(container, {
+            ...defaultButtonStyles,
+            title: ( localize(4678, "Create Automation"))
+        })));
+        createButton.label = ( localize(4678, "Create Automation"));
+        createButton.element.classList.add("automations-cards-state-create-button");
+        this.stateDisposables.add(createButton.onDidClick(() => this.openCreateDialog()));
+        return createButton;
+    }
+    renderPartialState(catalogueState) {
+        if (this.partialState === catalogueState) {
+            return;
+        }
+        this.partialState = catalogueState;
+        if (catalogueState === "ready") {
+            this.partialStateContainer.style.display = "none";
+            return;
+        }
+        const isError = catalogueState === "error";
+        const isLoading = catalogueState === "loading";
+        this.partialStateContainer.style.display = "";
+        this.partialStateContainer.classList.toggle("automations-cards-partial-state-error", isError);
+        this.partialLoadingIcon.style.display = isLoading ? "" : "none";
+        this.partialErrorIcon.style.display = isLoading ? "none" : "";
+        this.partialStateMessage.textContent = isError ? ( localize(4691, "Some automations could not be loaded.")) : catalogueState === "unavailable" ? ( localize(4692, "Some automations are unavailable.")) : ( localize(4693, "Loading additional automations..."));
+    }
+    renderTemplateCard(container, template) {
+        const card = append(container, $("button.automations-template-card", {
+            type: "button"
+        }));
+        const schedule = formatSchedule(template.schedule);
+        card.setAttribute("aria-label", template.source ? ( localize(
+            4694,
+            "Use template: {0}, {1}, from {2}",
+            template.name,
+            schedule,
+            template.source.label
+        )) : ( localize(4695, "Use template: {0}, {1}", template.name, schedule)));
+        const nameRow = append(card, $(".automations-template-card-name"));
+        const name = append(nameRow, $("span.automations-template-card-name-text"));
+        name.textContent = template.name;
+        this.templateDisposables.add(this.hoverService.setupDelayedHover(name, {
+            content: template.name
+        }));
+        const badge = append(nameRow, $("span.automations-template-card-badge"));
+        badge.textContent = template.source ? ( localize(4696, "Plugin")) : ( localize(4697, "Template"));
+        badge.setAttribute("aria-hidden", "true");
+        if (template.source) {
+            const source = append(card, $("span.automations-template-card-source"));
+            source.textContent = ( localize(4698, "From {0}", template.source.label));
+            this.templateDisposables.add(this.hoverService.setupDelayedHover(source, {
+                content: template.source.label
+            }));
+        }
+        const scheduleElement = append(card, $("span.automations-template-card-schedule"));
+        scheduleElement.textContent = schedule;
+        const description = append(card, $("span.automations-template-card-prompt"));
+        description.id = `automations-template-${this.templateAriaId}-${template.id}-description`;
+        description.textContent = template.description;
+        this.templateDisposables.add(this.hoverService.setupDelayedHover(description, {
+            content: template.prompt
+        }));
+        card.setAttribute("aria-describedby", description.id);
+        this.templateDisposables.add(addDisposableListener(card, EventType.CLICK, () => {
+            void this.openCreateDialog({
+                name: template.name,
+                prompt: template.prompt,
+                schedule: template.schedule,
+                ...(template.enabled !== undefined ? {
+                    enabled: template.enabled
+                } : {})
+            });
+        }));
+    }
+    async openCreateDialog(initialValues) {
+        this.clearPendingFocus();
+        if (!(await this.ensureEnabled())) {
+            return;
+        }
+        try {
+            const result = await this.automationDialogService.showAutomationDialog(initialValues ? {
+                initialValues
+            } : {});
+            if (!result || result.kind !== "create" || this._store.isDisposed) {
+                return;
+            }
+            const restoreFocus = isAncestorOfActiveElement(this.focusRoot);
+            const focusRequestGeneration = this.focusRequestGeneration;
+            if (!(await this.ensureEnabled())) {
+                return;
+            }
+            const created = await this.automationService.createAutomation(result.value, () => this.throwIfDisabled());
+            if (restoreFocus && focusRequestGeneration === this.focusRequestGeneration && !this._store.isDisposed && isAncestorOfActiveElement(this.focusRoot)) {
+                this.pendingFocusAutomationId = created.id;
+                this.focusPendingAutomation();
+            }
+            status(( localize(4699, "Created automation {0}", created.name)));
+        } catch (err) {
+            this.logService.error("[AutomationsCards] Failed to create automation", err);
+            await this.dialogService.error(( localize(4700, "Failed to create automation.")), getErrorMessage(err));
+        }
+    }
+    clearPendingFocus() {
+        this.pendingFocusAutomationId = undefined;
+        this.focusRequestGeneration++;
+    }
+    focusPendingAutomation() {
+        if (!this.pendingFocusAutomationId) {
+            return false;
+        }
+        if (this._store.isDisposed || !isAncestorOfActiveElement(this.focusRoot)) {
+            this.clearPendingFocus();
+            return false;
+        }
+        const card = this.persistentCards.get(this.pendingFocusAutomationId);
+        if (!card) {
+            return false;
+        }
+        this.pendingFocusAutomationId = undefined;
+        card.main.focus();
+        return true;
+    }
+    focusVisibleState(automations, catalogueState) {
+        if (automations.length > 0) {
+            (this.persistentCards.get(automations[0].id)?.main ?? this.focusRoot).focus();
+            return;
+        }
+        switch (catalogueState) {
+        case "loading":
+            this.loadingCreateButton.focus();
+            return;
+        case "unavailable":
+            this.unavailableCreateButton.focus();
+            return;
+        case "error":
+            this.errorCreateButton.focus();
+            return;
+        case "ready":
+            (this.emptyCreateButton?.element ?? this.focusRoot).focus();
+        }
+    }
+    async openEditDialog(automation) {
+        if (!(await this.ensureEnabled())) {
+            return;
+        }
+        try {
+            const result = await this.automationDialogService.showAutomationDialog({
+                existing: automation
+            });
+            if (!result || result.kind !== "update") {
+                return;
+            }
+            if (!(await this.ensureEnabled())) {
+                return;
+            }
+            const updateResult = await this.automationService.updateAutomationIfUnchanged(result.id, result.value, automation, () => this.throwIfDisabled());
+            if (updateResult.kind === "conflict") {
+                throw ( new Error(updateResult.current ? ( localize(
+                    4701,
+                    "This automation changed while the dialog was open. Reopen it to review the latest values."
+                )) : ( localize(4702, "This automation was deleted while the dialog was open."))));
+            }
+            status(( localize(4703, "Updated automation {0}", automation.name)));
+        } catch (err) {
+            this.logService.error("[AutomationsCards] Failed to update automation", err);
+            await this.dialogService.error(( localize(4704, "Failed to update automation.")), getErrorMessage(err));
+        }
+    }
+    isEnabled() {
+        return this.configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+    }
+    async ensureEnabled() {
+        if (this.isEnabled()) {
+            return true;
+        }
+        await showAutomationsDisabled(this.dialogService);
+        return false;
+    }
+    throwIfDisabled() {
+        if (!this.isEnabled()) {
+            throw ( new Error(( localize(4705, "Automations were disabled before the change could be saved."))));
+        }
+    }
+};
+AutomationCardsSection = ( __decorate([( __param(2, IAutomationService)), ( __param(3, IAutomationRunner)), ( __param(4, IAutomationDialogService)), ( __param(5, IHoverService)), ( __param(6, ILogService)), ( __param(7, IDialogService)), ( __param(8, IFileService)), ( __param(9, IStorageService)), ( __param(10, IConfigurationService)), ( __param(11, IContextKeyService)), ( __param(12, IContextMenuService))], AutomationCardsSection));
+let AutomationHistorySection = class AutomationHistorySection extends Disposable {
+    dispose() {
+        this.disposeAllGroups();
+        super.dispose();
+    }
+    constructor(
+        parent,
+        focusFallback,
+        isMarkingAllRead,
+        automationService,
+        sessionsService,
+        sessionsManagementService,
+        logService,
+        dialogService,
+        instantiationService
+    ) {
+        super();
+        this.focusFallback = focusFallback;
+        this.isMarkingAllRead = isMarkingAllRead;
+        this.automationService = automationService;
+        this.sessionsService = sessionsService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.logService = logService;
+        this.dialogService = dialogService;
+        this.instantiationService = instantiationService;
+        this.headerDisposables = this._register(( new DisposableStore()));
+        this.persistentGroups = ( new Map());
+        this.runFocusTargets = ( new Map());
+        this.renderedFocusableRunIds = [];
+        this.shouldRestoreFocus = false;
+        this.currentRuns = observableValue(this, []);
+        this.currentSessions = observableValue(this, ( new Map()));
+        this.container = append(parent, $(".automations-history"));
+        this.groupsContainer = append(this.container, $(".automations-history-groups"));
+        this.approvalModel = this._register(this.instantiationService.createInstance(AgentSessionApprovalModel));
+    }
+    render(runs, sessions) {
+        const sessionRuns = runs.filter(run => ( sessions.has(run.id)));
+        const visibleRuns = runs.filter(run => ( sessions.has(run.id)) || isTemporaryAutomationRun(run) || (!!run.sessionResource && !!this.sessionsManagementService.getSession(run.sessionResource)));
+        transaction(tx => {
+            this.currentRuns.set(sessionRuns, tx);
+            this.currentSessions.set(sessions, tx);
+        });
+        this.runFocusTargets.clear();
+        this.renderedFocusableRunIds = [];
+        if (visibleRuns.length === 0) {
+            this.container.style.display = "none";
+            this.disposeAllGroups();
+            this.restoreFocusAfterRender();
+            return;
+        }
+        this.container.style.display = "";
+        this.ensureHeader();
+        const groups = groupRunsByDate(visibleRuns);
+        const activeKeys = ( new Set(groups.map(group => group.key)));
+        for (const [key, entry] of this.persistentGroups) {
+            if (!( activeKeys.has(key))) {
+                entry.disposables.dispose();
+                entry.element.remove();
+                this.persistentGroups.delete(key);
+            }
+        }
+        let index = 0;
+        for (const group of groups) {
+            const sessionItems = this.resolveSessionItems(group.runs, sessions);
+            const temporaryRuns = group.runs.filter(run => !( sessions.has(run.id)));
+            let entry = this.persistentGroups.get(group.key);
+            if (entry) {
+                if (entry.header.textContent !== group.label) {
+                    entry.header.textContent = group.label;
+                }
+                this.updateTemporaryRuns(entry, temporaryRuns);
+                this.updateGroupSessions(entry, sessionItems);
+            } else {
+                entry = this.createGroup(group.key, group.label, temporaryRuns, sessionItems);
+            }
+            const currentElement = this.groupsContainer.children.item(index);
+            if (currentElement !== entry.element) {
+                this.groupsContainer.insertBefore(entry.element, currentElement);
+                if (entry.list) {
+                    this.layoutSessionList(entry.listContainer, entry.list);
+                }
+            }
+            index++;
+            for (const item of sessionItems) {
+                if (!entry.list) {
+                    continue;
+                }
+                this.renderedFocusableRunIds.push(item.run.id);
+                this.runFocusTargets.set(item.run.id, {
+                    list: entry.list,
+                    session: item.session
+                });
+            }
+        }
+        this.restoreFocusAfterRender();
+    }
+    layout() {
+        for (const entry of ( this.persistentGroups.values())) {
+            if (entry.list) {
+                this.layoutSessionList(entry.listContainer, entry.list);
+            }
+        }
+    }
+    ensureHeader() {
+        if (this.headerRow) {
+            return;
+        }
+        this.headerDisposables.clear();
+        this.headerRow = $$1(".automations-history-header");
+        this.container.insertBefore(this.headerRow, this.groupsContainer);
+        const headerLabel = append(this.headerRow, $("span"));
+        headerLabel.textContent = ( localize(4706, "History"));
+        this.markAllButton = this.headerDisposables.add(( new Button(this.headerRow, {
+            ...defaultButtonStyles,
+            secondary: true,
+            title: ( localize(4707, "Mark all as read"))
+        })));
+        this.markAllButton.label = ( localize(4707, "Mark all as read"));
+        this.markAllButton.element.classList.add("automations-mark-all-read");
+        this.headerDisposables.add(this.markAllButton.onDidClick(() => {
+            void this.markAllRunsRead(this.currentRuns.get());
+        }));
+        this.headerDisposables.add(autorun(reader => {
+            const runs = this.currentRuns.read(reader);
+            const sessions = this.currentSessions.read(reader);
+            const isMarkingAllRead = this.isMarkingAllRead.read(reader);
+            const hasUnread = ( runs.some(run => isUnreadAutomationRun(run, sessions.get(run.id), reader)));
+            this.markAllButton.element.style.display = hasUnread ? "" : "none";
+            this.markAllButton.enabled = hasUnread && !isMarkingAllRead;
+        }));
+    }
+    resolveSessionItems(runs, sessions) {
+        const items = [];
+        for (const run of runs) {
+            const session = sessions.get(run.id);
+            if (session) {
+                items.push({
+                    run,
+                    session
+                });
+            }
+        }
+        return items;
+    }
+    createGroup(key, label, temporaryRuns, items) {
+        const disposables = ( new DisposableStore());
+        const element = $(".automations-history-group");
+        const header = append(element, $(".automations-history-group-header"));
+        header.textContent = label;
+        const runsContainer = append(element, $(".automations-history-group-runs"));
+        const temporaryRowsContainer = append(runsContainer, $(".automations-temporary-runs"));
+        const listContainer = append(runsContainer, $(".automations-run-session-list"));
+        const runsBySession = ( new Map());
+        const entry = {
+            element,
+            header,
+            temporaryRowsContainer,
+            temporaryRows: disposables.add(( new DisposableMap())),
+            listContainer,
+            listDisposables: disposables.add(( new MutableDisposable())),
+            list: undefined,
+            runsBySession,
+            sessions: [],
+            disposables
+        };
+        this.persistentGroups.set(key, entry);
+        this.updateTemporaryRuns(entry, temporaryRuns);
+        this.updateGroupSessions(entry, items);
+        return entry;
+    }
+    ensureGroupList(entry) {
+        if (entry.list) {
+            return entry.list;
+        }
+        const disposables = ( new DisposableStore());
+        const list = disposables.add(
+            this.instantiationService.createInstance(SessionsFlatList, entry.listContainer, {
+                showSessionHover: false,
+                alwaysConsumeMouseWheel: false,
+                useCompactQuickChatRows: false,
+                toolbarMenuId: Menus.AutomationsHistoryItem,
+                contextMenuId: Menus.AutomationsHistoryItemContext,
+                markSessionReadOnOpen: false,
+                approvalModel: this.approvalModel,
+                onSessionOpen: resource => void this.openRunSession(resource),
+                onToolbarAction: (action, session) => this.handleSessionAction(action, session, entry.runsBySession),
+                onContextMenuAction: (action, session) => this.handleSessionAction(action, session, entry.runsBySession)
+            })
+        );
+        disposables.add(
+            list.onDidChangeContentHeight(() => this.layoutSessionList(entry.listContainer, list))
+        );
+        entry.list = list;
+        entry.listDisposables.value = disposables;
+        return list;
+    }
+    updateTemporaryRuns(entry, runs) {
+        const activeRunIds = ( new Set(runs.map(run => run.id)));
+        for (const runId of ( entry.temporaryRows.keys())) {
+            if (!( activeRunIds.has(runId))) {
+                entry.temporaryRows.deleteAndDispose(runId);
+            }
+        }
+        let index = 0;
+        for (const run of runs) {
+            const title = this.getAutomationName(run);
+            let row = entry.temporaryRows.get(run.id);
+            if (!row) {
+                row = this.createTemporaryRunRow(title);
+                entry.temporaryRows.set(run.id, row);
+            } else if (row.title.textContent !== title) {
+                row.title.textContent = title;
+                row.element.setAttribute("aria-label", ( localize(4708, "{0}, Working...", title)));
+            }
+            const currentElement = entry.temporaryRowsContainer.children.item(index);
+            if (currentElement !== row.element) {
+                entry.temporaryRowsContainer.insertBefore(row.element, currentElement);
+            }
+            index++;
+        }
+    }
+    createTemporaryRunRow(title) {
+        const disposables = ( new DisposableStore());
+        const element = $(".automations-temporary-run.session-item");
+        element.setAttribute("role", "group");
+        element.setAttribute("aria-label", ( localize(4708, "{0}, Working...", title)));
+        const icon = append(element, $(".session-icon"));
+        const statusIcon = disposables.add(this.instantiationService.createInstance(SessionStatusIcon, icon));
+        statusIcon.setStatus(SessionStatus.InProgress, true, false);
+        const main = append(element, $(".session-main"));
+        const titleRow = append(main, $(".session-title-row"));
+        const titleElement = append(titleRow, $("span.session-title"));
+        titleElement.textContent = title;
+        const detailsRow = append(main, $(".session-details-row"));
+        append(detailsRow, $("span.session-description")).textContent = ( localize(4709, "Working..."));
+        return {
+            element,
+            title: titleElement,
+            dispose: () => {
+                disposables.dispose();
+                element.remove();
+            }
+        };
+    }
+    updateGroupSessions(entry, items) {
+        entry.runsBySession.clear();
+        for (const item of items) {
+            entry.runsBySession.set(( item.session.resource.toString()), item.run);
+        }
+        const sessions = items.map(item => item.session);
+        if (entry.sessions.length === sessions.length && entry.sessions.every((session, index) => session === sessions[index])) {
+            return;
+        }
+        entry.sessions = sessions;
+        if (sessions.length === 0) {
+            entry.list = undefined;
+            entry.listDisposables.clear();
+            clearNode(entry.listContainer);
+            entry.listContainer.style.height = "";
+            return;
+        }
+        const list = this.ensureGroupList(entry);
+        list.setSessions(sessions);
+        this.layoutSessionList(entry.listContainer, list);
+    }
+    disposeAllGroups() {
+        for (const [key, entry] of this.persistentGroups) {
+            entry.disposables.dispose();
+            entry.element.remove();
+            this.persistentGroups.delete(key);
+        }
+        if (this.headerRow) {
+            this.headerRow.remove();
+            this.headerRow = undefined;
+            this.markAllButton = undefined;
+            this.headerDisposables.clear();
+        }
+    }
+    layoutSessionList(container, list) {
+        const height = list.getContentHeight();
+        const width = container.clientWidth;
+        container.style.height = `${height}px`;
+        list.layout(height, width);
+    }
+    async handleSessionAction(action, session, runsBySession) {
+        const run = runsBySession.get(( session.resource.toString()));
+        if (!run) {
+            return false;
+        }
+        switch (action.id) {
+        case STOP_AUTOMATION_RUN_SESSION_COMMAND_ID:
+            action.enabled = false;
+            await this.stopRunSession(session, this.getAutomationName(run), action);
+            return true;
+        case ARCHIVE_SESSION_COMMAND_ID:
+            await this.sessionsManagementService.archiveSession(session);
+            return true;
+        default:
+            return false;
+        }
+    }
+    getAutomationName(run) {
+        return this.automationService.automations.get().find(automation => automation.id === run.automationId)?.name ?? ( localize(4710, "Unknown"));
+    }
+    async openRunSession(resource) {
+        if (!this.sessionsManagementService.getSession(resource)) {
+            return;
+        }
+        try {
+            await this.sessionsService.openSession(resource, {
+                preserveFocus: false,
+                source: "automation"
+            });
+        } catch (error) {
+            this.logService.error("[AutomationsCards] Failed to open automation run", error);
+            await this.dialogService.error(( localize(4711, "Failed to open automation run.")), getErrorMessage(error));
+        }
+    }
+    async stopRunSession(session, automationName, action) {
+        try {
+            await this.sessionsManagementService.cancelCurrentRequest(session);
+            status(( localize(4712, "Stopped the session for {0}", automationName)));
+        } catch (error) {
+            action.enabled = true;
+            this.logService.error("[AutomationsCards] Failed to stop automation run session", error);
+            await this.dialogService.error(( localize(4713, "Failed to stop the automation run session.")), getErrorMessage(error));
+        }
+    }
+    restoreFocusAfterRender() {
+        if (!this.shouldRestoreFocus) {
+            return;
+        }
+        const target = this.pendingFocusRunId ? this.runFocusTargets.get(this.pendingFocusRunId) : undefined;
+        this.clearPendingFocus();
+        if (target) {
+            target.list.focusSession(target.session);
+        } else {
+            this.focusFallback.focus();
+        }
+    }
+    clearPendingFocus() {
+        this.pendingFocusRunId = undefined;
+        this.shouldRestoreFocus = false;
+    }
+    async markAllRunsRead(runs) {
+        this.isMarkingAllRead.set(true, undefined);
+        const sessions = ( new Map());
+        try {
+            for (const run of runs) {
+                if ((run.status === "completed" || run.status === "failed") && run.sessionResource) {
+                    const session = this.sessionsManagementService.getSession(run.sessionResource);
+                    if (session && !session.isRead.get()) {
+                        sessions.set(( session.resource.toString()), session);
+                    }
+                }
+            }
+            await this.sessionsManagementService.markAllRead([...( sessions.values())]);
+        } catch (error) {
+            this.logService.error("[AutomationsCards] Failed to mark automation runs read", error);
+            await this.dialogService.error(( localize(4714, "Failed to mark automation runs as read.")), getErrorMessage(error));
+        } finally {
+            this.isMarkingAllRead.set(false, undefined);
+        }
+    }
+};
+AutomationHistorySection = ( __decorate([( __param(3, IAutomationService)), ( __param(4, ISessionsService)), ( __param(5, ISessionsManagementService)), ( __param(6, ILogService)), ( __param(7, IDialogService)), ( __param(8, IInstantiationService))], AutomationHistorySection));
+function isUnreadAutomationRun(run, session, reader) {
+    return (run.status === "completed" || run.status === "failed") && !!session && !session.isRead.read(reader);
+}
+function isTemporaryAutomationRun(run) {
+    return run.status === "pending" || run.status === "running";
+}
+function formatSchedule(schedule) {
+    const {
+        interval,
+        scheduleHour,
+        scheduleMinute
+    } = schedule;
+    const time = formatHourMinute(scheduleHour, scheduleMinute);
+    switch (interval) {
+    case "hourly":
+        return localize(4715, "Hourly");
+    case "daily":
+        return localize(4716, "Daily at {0}", time);
+    case "weekly":
+        {
+            const day = DAYS_OF_WEEK[((schedule.scheduleDay % 7) + 7) % 7];
+            return localize(4717, "{0} at {1}", day, time);
+        }
+    case "manual":
+        return localize(4718, "Manual");
+    default:
+        return localize(4718, "Manual");
+    }
+}
+function formatHourMinute(hour, minute) {
+    const date = ( new Date(Date.UTC(
+        2000,
+        0,
+        1,
+        Math.max(0, Math.min(23, hour | 0)),
+        Math.max(0, Math.min(59, minute | 0))
+    )));
+    return date.toLocaleTimeString(undefined, {
+        hour: "numeric",
+        minute: "2-digit",
+        timeZone: "UTC"
+    });
+}
+function getAutomationTargetLabel(target) {
+    return target.kind === "workspace" ? basename(target.folderUri) : ( localize(4719, "No workspace"));
+}
+function groupRunsByDate(runs) {
+    const now = ( new Date());
+    const today = ( new Date(now.getFullYear(), now.getMonth(), now.getDate()));
+    const yesterday = ( new Date(today));
+    yesterday.setDate(yesterday.getDate() - 1);
+    const lastWeekStart = ( new Date(today));
+    lastWeekStart.setDate(lastWeekStart.getDate() - 7);
+    const groups = ( new Map());
+    for (const run of runs) {
+        const t = Date.parse(run.startedAt);
+        if (Number.isNaN(t)) {
+            continue;
+        }
+        const date = ( new Date(t));
+        const {
+            key,
+            label,
+            order
+        } = getDateBucket(date, today, yesterday, lastWeekStart);
+        let group = groups.get(key);
+        if (!group) {
+            group = {
+                key,
+                label,
+                order,
+                runs: []
+            };
+            groups.set(key, group);
+        }
+        group.runs.push(run);
+    }
+    return [...( groups.values())].sort((a, b) => a.order - b.order);
+}
+function getDateBucket(date, today, yesterday, lastWeekStart) {
+    if (date >= today) {
+        return {
+            key: "today",
+            label: ( localize(4720, "Today")),
+            order: 0
+        };
+    }
+    if (date >= yesterday) {
+        return {
+            key: "yesterday",
+            label: ( localize(4721, "Yesterday")),
+            order: 1
+        };
+    }
+    if (date >= lastWeekStart) {
+        return {
+            key: "week",
+            label: ( localize(4722, "Last week")),
+            order: 2
+        };
+    }
+    const monthLabel = date.toLocaleDateString(undefined, {
+        month: "long",
+        year: "numeric"
+    });
+    const monthIndex = date.getFullYear() * 12 + date.getMonth();
+    const order = 30000 - monthIndex;
+    return {
+        key: `month-${date.getFullYear()}-${date.getMonth()}`,
+        label: monthLabel,
+        order
+    };
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function getAutomationBlueprintErrorMessage(error) {
+    if (!(error instanceof AutomationBlueprintParseError)) {
+        return getErrorMessage(error);
+    }
+    switch (error.code) {
+    case "invalidFrontmatter":
+        return localize(4723, "The file must start with valid YAML frontmatter.");
+    case "unknownProperty":
+        return localize(4724, "The property '{0}' is not supported.", error.property ?? "");
+    case "invalidField":
+        return localize(4725, "The property '{0}' is missing or invalid.", error.property ?? "");
+    case "unsupportedVersion":
+        return localize(
+            4726,
+            "Automation blueprint version {0} is not supported.",
+            error.property ?? ""
+        );
+    case "invalidId":
+        return localize(4727, "The blueprint id '{0}' is invalid.", error.property ?? "");
+    case "unsupportedSchedule":
+        return localize(
+            4728,
+            "The cron expression '{0}' cannot be represented by the current Automation editor.",
+            error.property ?? ""
+        );
+    case "unsupportedTimeZone":
+        return localize(
+            4729,
+            "The time zone '{0}' is not supported. Use 'local' so the schedule follows the importing user's time zone.",
+            error.property ?? ""
+        );
+    case "missingPrompt":
+        return localize(4730, "The Automation prompt must follow the frontmatter.");
+    }
+}
+function normalizeAutomationBlueprintResource(resource) {
+    let name = basename(resource);
+    while (name.toLowerCase().endsWith(AUTOMATION_BLUEPRINT_FILE_SUFFIX)) {
+        name = name.slice(0, -AUTOMATION_BLUEPRINT_FILE_SUFFIX.length);
+    }
+    if (name.toLowerCase().endsWith(".md")) {
+        name = name.slice(0, -".md".length);
+    }
+    return joinPath(
+        dirname(resource),
+        `${name || "automation"}${AUTOMATION_BLUEPRINT_FILE_SUFFIX}`
+    );
+}
+function isAutomationBlueprintResource(resource) {
+    return resource.path.toLowerCase().endsWith(AUTOMATION_BLUEPRINT_FILE_SUFFIX);
+}
+function getAutomationDropData(event) {
+    const editors = extractEditorsDropData(event);
+    if (editors.length > 0) {
+        if (editors.length !== 1 || !editors[0].resource) {
+            return {
+                kind: "invalid",
+                reason: "multiple"
+            };
+        }
+        return isAutomationBlueprintResource(editors[0].resource) ? {
+            kind: "resource",
+            resource: editors[0].resource
+        } : {
+            kind: "invalid",
+            reason: "unsupported"
+        };
+    }
+    const files = [];
+    if (event.dataTransfer?.files) {
+        for (let index = 0; index < event.dataTransfer.files.length; index++) {
+            const file = event.dataTransfer.files.item(index);
+            if (file) {
+                files.push(file);
+            }
+        }
+    }
+    if (files.length === 0) {
+        return {
+            kind: "none"
+        };
+    }
+    if (files.length !== 1) {
+        return {
+            kind: "invalid",
+            reason: "multiple"
+        };
+    }
+    return files[0].name.toLowerCase().endsWith(AUTOMATION_BLUEPRINT_FILE_SUFFIX) ? {
+        kind: "file",
+        file: files[0]
+    } : {
+        kind: "invalid",
+        reason: "unsupported"
+    };
+}
+async function importAutomationBlueprint(
+    readContent,
+    automationDialogService,
+    automationService,
+    configurationService,
+    dialogService,
+    logService
+) {
+    const isEnabled = () => configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+    if (!isEnabled()) {
+        await showAutomationsDisabled(dialogService);
+        return;
+    }
+    let blueprint;
+    try {
+        blueprint = parseAutomationBlueprint(await readContent());
+    } catch (error) {
+        logService.error("[Automations] Failed to read Automation blueprint", error);
+        await dialogService.error(( localize(4731, "Failed to import automation.")), getAutomationBlueprintErrorMessage(error));
+        return;
+    }
+    const result = await automationDialogService.showAutomationDialog({
+        initialValues: {
+            name: blueprint.name,
+            prompt: blueprint.prompt,
+            schedule: blueprint.schedule,
+            enabled: false
+        }
+    });
+    if (!result || result.kind !== "create") {
+        return;
+    }
+    if (!isEnabled()) {
+        await showAutomationsDisabled(dialogService);
+        return;
+    }
+    try {
+        const automation = await automationService.createAutomation(result.value, () => {
+            if (!isEnabled()) {
+                throw ( new Error(( localize(
+                    4732,
+                    "Automations were disabled before the imported automation could be saved."
+                ))));
+            }
+        });
+        status(( localize(4733, "Imported automation {0}", automation.name)));
+    } catch (error) {
+        logService.error("[Automations] Failed to import Automation blueprint", error);
+        await dialogService.error(( localize(4734, "Failed to import automation.")), getErrorMessage(error));
+    }
+}
+async function showAutomationsDisabled(dialogService) {
+    await dialogService.info(( localize(4735, "Automations are disabled.")), ( localize(4736, "Enable “{0}” to make changes.", CHAT_AUTOMATIONS_ENABLED_SETTING)));
+}
+async function confirmAndDeleteAutomation(
+    automation,
+    automationService,
+    configurationService,
+    dialogService,
+    logService
+) {
+    if (automationService.canDeleteAutomation?.(automation.id) === false) {
+        return;
+    }
+    const isEnabled = () => configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+    if (!isEnabled()) {
+        await showAutomationsDisabled(dialogService);
+        return;
+    }
+    const confirmed = await dialogService.confirm({
+        message: ( localize(4737, "Delete automation \"{0}\"?", automation.name)),
+        detail: ( localize(4738, "This will permanently delete the automation and its run history.")),
+        primaryButton: ( localize(4739, "Delete"))
+    });
+    if (!confirmed.confirmed) {
+        return;
+    }
+    if (!isEnabled()) {
+        await showAutomationsDisabled(dialogService);
+        return;
+    }
+    try {
+        await automationService.deleteAutomation(automation.id, () => {
+            if (!isEnabled()) {
+                throw ( new Error(( localize(4740, "Automations were disabled before the automation could be deleted."))));
+            }
+        });
+        status(( localize(4741, "Deleted automation {0}", automation.name)));
+    } catch (error) {
+        logService.error("[AutomationsCards] Failed to delete automation", error);
+        await dialogService.error(( localize(4742, "Failed to delete automation.")), getErrorMessage(error));
+    }
+}
+let AutomationsCustomView = class AutomationsCustomView extends AbstractCustomView {
+    constructor(instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.title = constObservable(( localize(4743, "Automations")));
+        this.description = constObservable(( localize(
+            4744,
+            "Schedule agent sessions to run automatically on a cadence you choose."
+        )));
+    }
+    render(container) {
+        container.classList.add("automations-cards-content");
+        this._widget = this._register(this.instantiationService.createInstance(AutomationsCardsWidget));
+        container.appendChild(this._widget.element);
+    }
+    layout(width, height) {
+        this._widget?.layout(width, height);
+    }
+    focus() {
+        this._widget?.focus();
+    }
+};
+AutomationsCustomView = ( __decorate([( __param(0, IInstantiationService))], AutomationsCustomView));
+let AutomationsCustomViewContribution = class AutomationsCustomViewContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.automationsCustomView";
+    }
+    constructor(
+        customViewService,
+        actionViewItemService,
+        contextKeyService,
+        automationService,
+        configurationService
+    ) {
+        super();
+        this.historyItemActions = this._register(( new MutableDisposable()));
+        const registerHistoryItemActions = () => {
+            this.historyItemActions.value = registerAutomationHistoryItemActions(getChatSessionArchiveActionWording(configurationService));
+        };
+        registerHistoryItemActions();
+        this._register(configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(ChatSessionArchiveActionWordingSettingId)) {
+                registerHistoryItemActions();
+            }
+        }));
+        const hasItemsContext = AutomationsHasItemsContext.bindTo(contextKeyService);
+        this._register(autorun(reader => {
+            hasItemsContext.set(automationService.automations.read(reader).length > 0);
+        }));
+        this._register(customViewService.registerCustomView({
+            id: AUTOMATIONS_CUSTOM_VIEW_ID,
+            ctor: ( new SyncDescriptor(AutomationsCustomView)),
+            actions: {
+                style: "buttonBar",
+                menuId: Menus.CustomViewAutomations
+            }
+        }, {
+            restore: contextKeyService.getContextKeyValue(ChatAutomationsEnabledContext.key) === true
+        }));
+        const automationContextKeys = ( new Set([ChatAutomationsEnabledContext.key]));
+        this._register(contextKeyService.onDidChangeContext(event => {
+            if (event.affectsSome(automationContextKeys) && !contextKeyService.getContextKeyValue(ChatAutomationsEnabledContext.key) && customViewService.activeCustomView.get()?.id === AUTOMATIONS_CUSTOM_VIEW_ID) {
+                customViewService.hideCustomView();
+            }
+        }));
+        this._register(actionViewItemService.register(
+            Menus.CustomViewAutomations,
+            "sessionsView.newAutomation",
+            (action, options, instantiationService) => {
+                if (!(action instanceof MenuItemAction)) {
+                    return undefined;
+                }
+                return instantiationService.createInstance(AutomationHeaderButtonActionViewItem, undefined, action, options, false);
+            }
+        ));
+        this._register(actionViewItemService.register(
+            Menus.CustomViewAutomations,
+            "sessions.automations.import",
+            (action, options, instantiationService) => {
+                if (!(action instanceof MenuItemAction)) {
+                    return undefined;
+                }
+                return instantiationService.createInstance(AutomationHeaderButtonActionViewItem, undefined, action, options, true);
+            }
+        ));
+    }
+};
+AutomationsCustomViewContribution = ( __decorate([( __param(0, ICustomViewService)), ( __param(1, IActionViewItemService)), ( __param(2, IContextKeyService)), ( __param(3, IAutomationService)), ( __param(4, IConfigurationService))], AutomationsCustomViewContribution));
+function registerAutomationHistoryItemActions(archiveWording) {
+    const archivePresentation = getChatSessionArchiveActionPresentation(archiveWording);
+    return combinedDisposable(MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItem, {
+        command: {
+            id: STOP_AUTOMATION_RUN_SESSION_COMMAND_ID,
+            title: ( localize(4745, "Stop")),
+            icon: Codicon.stopCircle
+        },
+        group: "navigation",
+        order: 1,
+        when: ( ContextKeyExpr.or(( SessionItemStatusContext.isEqualTo(SessionStatus.InProgress)), ( SessionItemStatusContext.isEqualTo(SessionStatus.NeedsInput))))
+    }), MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
+        command: {
+            id: MARK_SESSION_READ_COMMAND_ID,
+            title: ( localize(4746, "Mark as Read"))
+        },
+        group: "0_read",
+        order: 1,
+        when: ( ContextKeyExpr.and(( SessionIsReadContext.negate()), ( SessionIsArchivedContext.negate())))
+    }), MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
+        command: {
+            id: MARK_SESSION_UNREAD_COMMAND_ID,
+            title: ( localize(4747, "Mark as Unread"))
+        },
+        group: "0_read",
+        order: 1,
+        when: ( ContextKeyExpr.and(SessionIsReadContext, ( SessionIsArchivedContext.negate())))
+    }), MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
+        command: {
+            id: RENAME_SESSION_COMMAND_ID,
+            title: ( localize(4748, "Rename..."))
+        },
+        group: "1_edit",
+        order: 1,
+        when: SessionSupportsRenameContext
+    }), MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
+        command: {
+            id: ARCHIVE_SESSION_COMMAND_ID,
+            title: archivePresentation.archive.title
+        },
+        group: "1_edit",
+        order: 2,
+        when: ( SessionIsArchivedContext.negate())
+    }), MenuRegistry.appendMenuItem(Menus.AutomationsHistoryItemContext, {
+        command: {
+            id: UNARCHIVE_SESSION_COMMAND_ID,
+            title: archivePresentation.unarchive.title
+        },
+        group: "1_edit",
+        order: 2,
+        when: SessionIsArchivedContext
+    }));
+}
+class AutomationHeaderButtonActionViewItem extends BaseActionViewItem {
+    constructor(context, action, options, secondary) {
+        super(context, action, options);
+        this.secondary = secondary;
+    }
+    render(container) {
+        this.element = container;
+        container.classList.add("chat-pill-item");
+        const button = this.button = this._register(( new Button(container, {
+            secondary: this.secondary,
+            ...defaultButtonStyles
+        })));
+        button.element.classList.add("monaco-text-button", "chat-pill-button");
+        this._register(button.onDidClick(() => {
+            if (this._action.enabled) {
+                this.actionRunner.run(this._action, this._context);
+            }
+        }));
+        this.updateLabel();
+        this.updateEnabled();
+    }
+    focus() {
+        if (this.button) {
+            this.button.element.tabIndex = 0;
+            this.button.focus();
+        }
+    }
+    blur() {
+        if (this.button) {
+            this.button.element.tabIndex = -1;
+            this.button.element.blur();
+        }
+    }
+    setFocusable(focusable) {
+        if (this.button) {
+            this.button.element.tabIndex = focusable ? 0 : -1;
+        }
+    }
+    updateEnabled() {
+        if (this.button) {
+            this.button.enabled = this._action.enabled;
+        }
+    }
+    updateLabel() {
+        if (!this.button) {
+            return;
+        }
+        reset(this.button.element, this._action.label);
+    }
+}
+registerAction2(class NewAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsView.newAutomation",
+            title: ( localize2(4749, "New Automation")),
+            precondition: ChatAutomationsEnabledContext,
+            menu: [{
+                id: Menus.CustomViewAutomations,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(ChatAutomationsEnabledContext, AutomationsHasItemsContext))
+            }]
+        });
+    }
+    async run(accessor) {
+        const automationDialogService = accessor.get(IAutomationDialogService);
+        const automationService = accessor.get(IAutomationService);
+        const configurationService = accessor.get(IConfigurationService);
+        const dialogService = accessor.get(IDialogService);
+        const logService = accessor.get(ILogService);
+        const isEnabled = () => configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+        if (!isEnabled()) {
+            await showAutomationsDisabled(dialogService);
+            return;
+        }
+        const result = await automationDialogService.showAutomationDialog({});
+        if (!result || result.kind !== "create") {
+            return;
+        }
+        if (!isEnabled()) {
+            await showAutomationsDisabled(dialogService);
+            return;
+        }
+        try {
+            await automationService.createAutomation(result.value, () => {
+                if (!isEnabled()) {
+                    throw ( new Error(( localize(4705, "Automations were disabled before the change could be saved."))));
+                }
+            });
+        } catch (err) {
+            logService.error("[Automations] Failed to create automation", err);
+            await dialogService.error(( localize(4700, "Failed to create automation.")), getErrorMessage(err));
+        }
+    }
+});
+registerAction2(class ImportAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.automations.import",
+            title: ( localize2(4750, "Import Automation")),
+            precondition: ChatAutomationsEnabledContext,
+            menu: [{
+                id: Menus.CustomViewAutomations,
+                group: "navigation",
+                order: 2,
+                when: ChatAutomationsEnabledContext
+            }]
+        });
+    }
+    async run(accessor) {
+        const configurationService = accessor.get(IConfigurationService);
+        const dialogService = accessor.get(IDialogService);
+        const fileDialogService = accessor.get(IFileDialogService);
+        const fileService = accessor.get(IFileService);
+        const logService = accessor.get(ILogService);
+        const automationDialogService = accessor.get(IAutomationDialogService);
+        const automationService = accessor.get(IAutomationService);
+        const isEnabled = () => configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+        if (!isEnabled()) {
+            await showAutomationsDisabled(dialogService);
+            return;
+        }
+        const resources = await fileDialogService.showOpenDialog({
+            title: ( localize(4751, "Import Automation")),
+            openLabel: ( localize(4752, "Import")),
+            canSelectFiles: true,
+            canSelectFolders: false,
+            canSelectMany: false,
+            filters: [{
+                name: ( localize(4753, "Automation Blueprint")),
+                extensions: ["automation.md"]
+            }]
+        });
+        const resource = resources?.[0];
+        if (!resource) {
+            return;
+        }
+        if (!isAutomationBlueprintResource(resource)) {
+            await dialogService.error(( localize(4664, "Unable to import automation.")), ( localize(4663, "Only .automation.md files can be imported.")));
+            return;
+        }
+        await importAutomationBlueprint(async () => ( (await fileService.readFile(resource)).value.toString()), automationDialogService, automationService, configurationService, dialogService, logService);
+    }
+});
+registerAction2(class DuplicateAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.automations.duplicate",
+            title: ( localize2(4754, "Duplicate")),
+            precondition: ChatAutomationsEnabledContext,
+            menu: [{
+                id: Menus.AutomationCardContext,
+                group: "navigation",
+                order: 2,
+                when: ChatAutomationsEnabledContext
+            }]
+        });
+    }
+    async run(accessor, automation) {
+        const automationDialogService = accessor.get(IAutomationDialogService);
+        const automationService = accessor.get(IAutomationService);
+        const configurationService = accessor.get(IConfigurationService);
+        const dialogService = accessor.get(IDialogService);
+        const logService = accessor.get(ILogService);
+        const isEnabled = () => configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+        if (!isEnabled()) {
+            await showAutomationsDisabled(dialogService);
+            return;
+        }
+        try {
+            const name = getDuplicateAutomationName(automation.name, automationService.automations.get());
+            const result = await automationDialogService.showAutomationDialog({
+                initialValues: {
+                    name,
+                    prompt: automation.prompt,
+                    schedule: automation.schedule,
+                    target: automation.target,
+                    ...(automation.sessionTemplate ? {
+                        sessionTemplate: automation.sessionTemplate
+                    } : {
+                        modelId: automation.modelId,
+                        mode: automation.mode,
+                        permissionLevel: automation.permissionLevel
+                    }),
+                    enabled: automation.enabled
+                }
+            });
+            if (!result || result.kind !== "create") {
+                return;
+            }
+            if (!isEnabled()) {
+                await showAutomationsDisabled(dialogService);
+                return;
+            }
+            const duplicate = await automationService.createAutomation(result.value, () => {
+                if (!isEnabled()) {
+                    throw ( new Error(( localize(4755, "Automations were disabled before the duplicate could be saved."))));
+                }
+            });
+            status(( localize(4756, "Created duplicate automation {0}", duplicate.name)));
+        } catch (error) {
+            logService.error("[Automations] Failed to duplicate automation", error);
+            await dialogService.error(( localize(4757, "Failed to duplicate automation.")), getErrorMessage(error));
+        }
+    }
+});
+registerAction2(class ExportAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.automations.export",
+            title: ( localize2(4758, "Export")),
+            precondition: ChatAutomationsEnabledContext,
+            menu: [{
+                id: Menus.AutomationCardContext,
+                group: "navigation",
+                order: 3,
+                when: ChatAutomationsEnabledContext
+            }]
+        });
+    }
+    async run(accessor, automation) {
+        const configurationService = accessor.get(IConfigurationService);
+        const dialogService = accessor.get(IDialogService);
+        const fileDialogService = accessor.get(IFileDialogService);
+        const fileService = accessor.get(IFileService);
+        const logService = accessor.get(ILogService);
+        if (configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) !== true) {
+            await showAutomationsDisabled(dialogService);
+            return;
+        }
+        let defaultUri = joinPath(
+            await fileDialogService.defaultFilePath(),
+            createAutomationBlueprintFileName(automation.name)
+        );
+        let resource;
+        while (true) {
+            const selectedResource = await fileDialogService.showSaveDialog({
+                title: ( localize(4759, "Export Automation")),
+                saveLabel: ( localize(4760, "Export")),
+                defaultUri,
+                filters: [{
+                    name: ( localize(4753, "Automation Blueprint")),
+                    extensions: ["md"]
+                }]
+            });
+            if (!selectedResource) {
+                return;
+            }
+            const normalizedResource = normalizeAutomationBlueprintResource(selectedResource);
+            if (isEqual(selectedResource, normalizedResource)) {
+                resource = selectedResource;
+                break;
+            }
+            await dialogService.error(( localize(4761, "Unable to export automation.")), ( localize(4762, "Use a file name ending in exactly one .automation.md suffix.")));
+            defaultUri = normalizedResource;
+        }
+        try {
+            const content = serializeAutomationBlueprint(automationToBlueprint(automation));
+            await fileService.writeFile(resource, VSBuffer.fromString(content));
+            status(( localize(4763, "Exported automation {0}", automation.name)));
+        } catch (error) {
+            logService.error("[Automations] Failed to export Automation blueprint", error);
+            await dialogService.error(( localize(4764, "Failed to export automation.")), getErrorMessage(error));
+        }
+    }
+});
+registerAction2(class DeleteAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.automations.delete",
+            title: ( localize2(4765, "Delete")),
+            precondition: ( ContextKeyExpr.and(ChatAutomationsEnabledContext, AutomationCardCanDeleteContext)),
+            menu: [{
+                id: Menus.AutomationCardContext,
+                group: "navigation",
+                order: 4,
+                when: ChatAutomationsEnabledContext
+            }]
+        });
+    }
+    async run(accessor, automation) {
+        await confirmAndDeleteAutomation(
+            automation,
+            accessor.get(IAutomationService),
+            accessor.get(IConfigurationService),
+            accessor.get(IDialogService),
+            accessor.get(ILogService)
+        );
+    }
+});
+registerAction2(class DisableAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.automations.disable",
+            title: ( localize2(4766, "Disable")),
+            precondition: ( ContextKeyExpr.and(ChatAutomationsEnabledContext, AutomationCardCanUpdateContext)),
+            menu: [{
+                id: Menus.AutomationCardContext,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(ChatAutomationsEnabledContext, AutomationCardEnabledContext))
+            }]
+        });
+    }
+    async run(accessor, automation) {
+        await setAutomationEnabled(accessor, automation, false);
+    }
+});
+registerAction2(class EnableAutomationAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.automations.enable",
+            title: ( localize2(4767, "Enable")),
+            precondition: ( ContextKeyExpr.and(ChatAutomationsEnabledContext, AutomationCardCanUpdateContext)),
+            menu: [{
+                id: Menus.AutomationCardContext,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(ChatAutomationsEnabledContext, ( AutomationCardEnabledContext.negate())))
+            }]
+        });
+    }
+    async run(accessor, automation) {
+        await setAutomationEnabled(accessor, automation, true);
+    }
+});
+async function setAutomationEnabled(accessor, automation, enabled) {
+    const automationService = accessor.get(IAutomationService);
+    if (automation.enabled === enabled || automationService.canUpdateAutomation?.(automation.id) === false) {
+        return;
+    }
+    const configurationService = accessor.get(IConfigurationService);
+    const dialogService = accessor.get(IDialogService);
+    const logService = accessor.get(ILogService);
+    const automationsEnabled = () => configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
+    if (!automationsEnabled()) {
+        await showAutomationsDisabled(dialogService);
+        return;
+    }
+    try {
+        const result = await automationService.updateAutomationIfUnchanged(automation.id, {
+            enabled
+        }, automation, () => {
+            if (!automationsEnabled()) {
+                throw ( new Error(enabled ? ( localize(4768, "Automations were disabled before the automation could be enabled.")) : ( localize(4769, "Automations were disabled before the automation could be updated."))));
+            }
+        });
+        if (result.kind === "conflict") {
+            throw ( new Error(result.current ? (enabled ? ( localize(4770, "This automation changed before it could be enabled. Try again.")) : ( localize(4771, "This automation changed before it could be disabled. Try again."))) : (enabled ? ( localize(4772, "This automation was deleted before it could be enabled.")) : ( localize(4773, "This automation was deleted before it could be disabled.")))));
+        }
+        status(enabled ? ( localize(4774, "Enabled automation {0}", automation.name)) : ( localize(4775, "Disabled automation {0}", automation.name)));
+    } catch (error) {
+        logService.error(
+            enabled ? "[Automations] Failed to enable automation" : "[Automations] Failed to disable automation",
+            error
+        );
+        await dialogService.error(enabled ? ( localize(4776, "Failed to enable automation.")) : ( localize(4777, "Failed to disable automation.")), getErrorMessage(error));
+    }
+}
+function getDuplicateAutomationName(name, automations) {
+    const existingNames = ( new Set(automations.map(automation => automation.name)));
+    const copyName = ( localize(4778, "{0} Copy", name));
+    if (!( existingNames.has(copyName))) {
+        return copyName;
+    }
+    for (let index = 2; ; index++) {
+        const indexedCopyName = ( localize(4779, "{0} Copy {1}", name, index));
+        if (!( existingNames.has(indexedCopyName))) {
+            return indexedCopyName;
+        }
+    }
+}
+
+export { AutomationsCardsWidget, AutomationsCustomView, AutomationsCustomViewContribution, SEEN_PLUGIN_AUTOMATION_TEMPLATES_STORAGE_KEY };