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

package/vscode/src/vs/sessions/contrib/editor/browser/addTabActions.js

@@ -0,0 +1,170 @@
+
+import './emptyFileEditor.contribution.js';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IBrowserViewWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service';
+import { openNewSearchEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/searchEditor/browser/searchEditorActions';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IsSessionsWindowContext, IsAuxiliaryWindowContext, IsTopRightEditorGroupContext, EditorTabsVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { SinglePaneChangesTabAvailableContext, SinglePaneFilesTabAvailableContext, IsQuickChatSessionContext, SinglePaneFilesTabMissingContext, SinglePaneChangesTabMissingContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { SessionsCategories } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/categories';
+import { NEW_FILE_TAB_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { EmptyFileEditorInput } from './emptyFileEditorInput.js';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+const NEW_BROWSER_TAB_COMMAND_ID = "workbench.action.agentSessions.newBrowserTab";
+const NEW_SEARCH_TAB_COMMAND_ID = "workbench.action.agentSessions.newSearchTab";
+const NEW_CHANGES_TAB_COMMAND_ID = "workbench.action.agentSessions.newChangesTab";
+const addTabActionWhen = ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated())));
+const addTabLayoutWhen = ( ContextKeyExpr.and(addTabActionWhen, IsTopRightEditorGroupContext));
+const singleEditorTitleWhen = ( EditorTabsVisibleContext.negate());
+const changesTabActionWhen = ( ContextKeyExpr.and(addTabActionWhen, SinglePaneChangesTabAvailableContext));
+const filesTabActionWhen = ( ContextKeyExpr.and(addTabActionWhen, SinglePaneFilesTabAvailableContext));
+const searchTabActionWhen = ( ContextKeyExpr.and(addTabActionWhen, ( IsQuickChatSessionContext.negate())));
+class NewFileTabAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_FILE_TAB_COMMAND_ID,
+            title: ( localize2(4018, "Files")),
+            category: SessionsCategories.Sessions,
+            icon: Codicon.newFile,
+            f1: true,
+            precondition: filesTabActionWhen,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: filesTabActionWhen,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyE
+            },
+            menu: {
+                id: Menus.SessionsEditorTabsBarAddTab,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(addTabLayoutWhen, SinglePaneFilesTabAvailableContext, ( ContextKeyExpr.or(singleEditorTitleWhen, SinglePaneFilesTabMissingContext))))
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const sessionsService = accessor.get(ISessionsService);
+        const group = editorGroupsService.mainPart.activeGroup;
+        const workspace = sessionsService.activeSession.get()?.workspace.get();
+        await editorService.openEditor(instantiationService.createInstance(EmptyFileEditorInput, workspace), {
+            pinned: true,
+            index: group.count
+        }, group);
+    }
+}
+class NewBrowserTabAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_BROWSER_TAB_COMMAND_ID,
+            title: ( localize2(4019, "Browser")),
+            category: SessionsCategories.Sessions,
+            icon: Codicon.globe,
+            f1: true,
+            precondition: addTabActionWhen,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: addTabActionWhen,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyB
+            },
+            menu: {
+                id: Menus.SessionsEditorTabsBarAddTab,
+                group: "navigation",
+                order: 2,
+                when: addTabLayoutWhen
+            }
+        });
+    }
+    async run(accessor) {
+        const browserViewWorkbenchService = accessor.get(IBrowserViewWorkbenchService);
+        const editorService = accessor.get(IEditorService);
+        const browserInput = browserViewWorkbenchService.getOrCreateLazy({
+            id: generateUuid()
+        });
+        await editorService.openEditor(browserInput, {
+            pinned: true
+        });
+    }
+}
+class NewSearchTabAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SEARCH_TAB_COMMAND_ID,
+            title: ( localize2(4020, "Search")),
+            category: SessionsCategories.Sessions,
+            icon: Codicon.search,
+            f1: true,
+            precondition: searchTabActionWhen,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: searchTabActionWhen,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyF
+            },
+            menu: {
+                id: Menus.SessionsEditorTabsBarAddTab,
+                group: "navigation",
+                order: 3,
+                when: ( ContextKeyExpr.and(addTabLayoutWhen, ( IsQuickChatSessionContext.negate())))
+            }
+        });
+    }
+    async run(accessor) {
+        const instantiationService = accessor.get(IInstantiationService);
+        await instantiationService.invokeFunction(openNewSearchEditor, {
+            location: "new"
+        });
+    }
+}
+class NewChangesTabAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_CHANGES_TAB_COMMAND_ID,
+            title: ( localize2(4021, "Changes")),
+            category: SessionsCategories.Sessions,
+            icon: Codicon.gitCompare,
+            f1: false,
+            precondition: changesTabActionWhen,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: changesTabActionWhen,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyG,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.KeyG
+                }
+            },
+            menu: {
+                id: Menus.SessionsEditorTabsBarAddTab,
+                group: "navigation",
+                order: 0,
+                when: ( ContextKeyExpr.and(addTabLayoutWhen, SinglePaneChangesTabAvailableContext, ( ContextKeyExpr.or(singleEditorTitleWhen, SinglePaneChangesTabMissingContext))))
+            }
+        });
+    }
+    async run(accessor) {
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionChangesService = accessor.get(ISessionChangesService);
+        const session = sessionsService.activeSession.get();
+        if (session) {
+            const group = editorGroupsService.mainPart.activeGroup;
+            await sessionChangesService.openChangesEditor(session.resource, {
+                index: group.count
+            }, group);
+        }
+    }
+}
+
+export { NEW_BROWSER_TAB_COMMAND_ID, NEW_CHANGES_TAB_COMMAND_ID, NEW_SEARCH_TAB_COMMAND_ID, NewBrowserTabAction, NewChangesTabAction, NewFileTabAction, NewSearchTabAction };

package/vscode/src/vs/sessions/contrib/editor/browser/editor.contribution.d.ts

@@ -0,0 +1,14 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+/**
+ * Mirrors extension-contributed `editor/title` items into {@link Menus.SessionsEditorTitle}
+ * so they are not lost in the single-pane layout. See `LAYOUT.md` for details.
+ */
+export declare class EditorTitleMenuBridgeContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.sessions.editorTitleMenuBridge";
+    private static readonly _extensionSubmenuPrefix;
+    private readonly _mirrored;
+    constructor(layoutService: IAgentWorkbenchLayoutService);
+    private _sync;
+}

package/vscode/src/vs/sessions/contrib/editor/browser/editor.contribution.js

@@ -0,0 +1,425 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as tabs from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/modernUI/browser/media/tabs.css';
+import * as editorBreadcrumbs from './media/editorBreadcrumbs.css';
+import * as editorHeader from './media/editorHeader.css';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/themes/browser/modernTabColorCustomizations';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/editor/browser/diffEditor.sessions.contribution';
+import { NewFileTabAction, NewBrowserTabAction, NewSearchTabAction, NewChangesTabAction } from './addTabActions.js';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { registerAction2, Action2, MenuId, MenuRegistry, isIMenuItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IsSessionsWindowContext, IsAuxiliaryWindowContext, IsTopRightEditorGroupContext, MainEditorAreaVisibleContext, EditorPartModalContext, ActiveEditorContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { SinglePaneLayoutEnabledContext, EditorMaximizedContext, CustomViewVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IListService } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService.service';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { resolveCommandsContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorCommandsContext';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { CHANGES_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changes';
+import { prepareMoveCopyEditors } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editor';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { MOVE_MODAL_EDITOR_TO_MAIN_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { TERMINAL_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal';
+import { TEXT_FILE_EDITOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { SessionsCategories } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/categories';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+
+var EditorTitleMenuBridgeContribution_1;
+registerCss(tabs, 1);
+registerCss(editorBreadcrumbs, 1);
+registerCss(editorHeader, 1);
+const terminalPanelHiddenForMaximizedEditor = ( new WeakSet());
+const singlePaneDetailPanel = SinglePaneLayoutEnabledContext;
+const notSinglePaneDetailPanel = ( singlePaneDetailPanel.negate());
+const editorTitleActionsWhen = ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext));
+const singlePaneLayoutMaximizeOrder = 9;
+const singlePaneLayoutHideEditorOrder = 20;
+const singlePaneMaximizeKeybindingWhen = ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), singlePaneDetailPanel, MainEditorAreaVisibleContext));
+let SinglePaneAddTabContribution = class SinglePaneAddTabContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.singlePaneAddTab";
+    }
+    constructor(layoutService) {
+        super();
+        if (!layoutService.isSinglePaneLayoutEnabled) {
+            return;
+        }
+        this._register(registerAction2(NewFileTabAction));
+        this._register(registerAction2(NewBrowserTabAction));
+        this._register(registerAction2(NewSearchTabAction));
+        this._register(registerAction2(NewChangesTabAction));
+    }
+};
+SinglePaneAddTabContribution = ( __decorate([( __param(0, IAgentWorkbenchLayoutService))], SinglePaneAddTabContribution));
+registerWorkbenchContribution2(
+    SinglePaneAddTabContribution.ID,
+    SinglePaneAddTabContribution,
+    WorkbenchPhase.BlockStartup
+);
+class MaximizeMainEditorPartAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.maximizeMainEditorPart";
+    }
+    constructor() {
+        super({
+            id: MaximizeMainEditorPartAction.ID,
+            title: ( localize2(4030, "Maximize Editor Area")),
+            icon: Codicon.screenFull,
+            f1: false,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyE,
+                when: ( ContextKeyExpr.and(singlePaneMaximizeKeybindingWhen, ( EditorMaximizedContext.negate())))
+            },
+            menu: [{
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: singlePaneLayoutMaximizeOrder,
+                when: ( ContextKeyExpr.and(editorTitleActionsWhen, ( EditorMaximizedContext.negate()), singlePaneDetailPanel, MainEditorAreaVisibleContext))
+            }, {
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: 99,
+                when: ( ContextKeyExpr.and(editorTitleActionsWhen, ( EditorMaximizedContext.negate()), notSinglePaneDetailPanel))
+            }]
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const viewsService = accessor.get(IViewsService);
+        let hidTerminalPanel = false;
+        if (layoutService.isVisible(Parts.PANEL_PART) && viewsService.isViewVisible(TERMINAL_VIEW_ID)) {
+            layoutService.setPartHidden(true, Parts.PANEL_PART);
+            hidTerminalPanel = true;
+        }
+        if (hidTerminalPanel) {
+            terminalPanelHiddenForMaximizedEditor.add(layoutService);
+        } else {
+            terminalPanelHiddenForMaximizedEditor.delete(layoutService);
+        }
+        layoutService.setEditorMaximized(true);
+    }
+}
+registerAction2(MaximizeMainEditorPartAction);
+class RestoreMainEditorPartAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.restoreMainEditorPart";
+    }
+    constructor() {
+        super({
+            id: RestoreMainEditorPartAction.ID,
+            title: ( localize2(4031, "Restore Editor Area")),
+            icon: Codicon.screenNormal,
+            f1: false,
+            toggled: EditorMaximizedContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyE,
+                when: ( ContextKeyExpr.and(singlePaneMaximizeKeybindingWhen, EditorMaximizedContext))
+            },
+            menu: [{
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: singlePaneLayoutMaximizeOrder,
+                when: ( ContextKeyExpr.and(
+                    editorTitleActionsWhen,
+                    EditorMaximizedContext,
+                    singlePaneDetailPanel,
+                    MainEditorAreaVisibleContext
+                ))
+            }, {
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: 99,
+                when: ( ContextKeyExpr.and(editorTitleActionsWhen, EditorMaximizedContext, notSinglePaneDetailPanel))
+            }]
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const shouldRestoreTerminalPanel = ( terminalPanelHiddenForMaximizedEditor.has(layoutService));
+        layoutService.setEditorMaximized(false);
+        if (shouldRestoreTerminalPanel && !layoutService.isVisible(Parts.PANEL_PART)) {
+            layoutService.setPartHidden(false, Parts.PANEL_PART);
+        }
+        terminalPanelHiddenForMaximizedEditor.delete(layoutService);
+    }
+}
+registerAction2(RestoreMainEditorPartAction);
+class HideMainEditorPartAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.hideMainEditorPart";
+    }
+    constructor() {
+        super({
+            id: HideMainEditorPartAction.ID,
+            title: ( localize2(4032, "Hide Editor")),
+            icon: Codicon.rightPanelHide,
+            f1: false,
+            menu: {
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: singlePaneLayoutHideEditorOrder,
+                when: ( ContextKeyExpr.false())
+            }
+        });
+    }
+    run(accessor) {
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
+        layoutService.setPartHidden(true, Parts.EDITOR_PART);
+        layoutService.setPartHidden(false, Parts.SIDEBAR_PART);
+    }
+}
+registerAction2(HideMainEditorPartAction);
+class ShowMainEditorPartAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.showMainEditorPart";
+    }
+    constructor() {
+        super({
+            id: ShowMainEditorPartAction.ID,
+            title: ( localize2(4033, "Show Editor")),
+            icon: Codicon.rightPanelShow,
+            f1: false,
+            menu: {
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: singlePaneLayoutHideEditorOrder,
+                when: ( ContextKeyExpr.false())
+            }
+        });
+    }
+    run(accessor) {
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        layoutService.revealEditorPartExplicitly();
+        editorGroupsService.activeGroup.focus();
+    }
+}
+registerAction2(ShowMainEditorPartAction);
+class CloseMainEditorPartAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.closeMainEditorPart";
+    }
+    constructor() {
+        super({
+            id: CloseMainEditorPartAction.ID,
+            title: ( localize2(4034, "Close Editor Area")),
+            icon: Codicon.close,
+            f1: false,
+            menu: {
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: 100,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext, notSinglePaneDetailPanel))
+            }
+        });
+    }
+    async run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        await commandService.executeCommand("workbench.action.closeAllGroups");
+    }
+}
+registerAction2(CloseMainEditorPartAction);
+class OpenEditorInModalEditorAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.openEditorInModal";
+    }
+    constructor() {
+        super({
+            id: OpenEditorInModalEditorAction.ID,
+            title: ( localize2(4035, "Open in Modal Editor")),
+            icon: Codicon.openInWindow,
+            f1: false,
+            menu: {
+                id: MenuId.EditorTitleLayout,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), notSinglePaneDetailPanel))
+            }
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const configurationService = accessor.get(IConfigurationService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        const isMaximized = layoutService.isEditorMaximized();
+        await configurationService.updateValue("workbench.editor.useModal", "all");
+        const activeGroup = editorGroupsService.mainPart.activeGroup;
+        const multiFileDiffEditor = activeGroup.editors.find(editor => editor instanceof MultiDiffEditorInput);
+        if (multiFileDiffEditor) {
+            const view = viewsService.getViewWithId(CHANGES_VIEW_ID);
+            await view?.openChanges();
+            await activeGroup.closeEditor(multiFileDiffEditor);
+        }
+        const modalPart = await editorGroupsService.createModalEditorPart();
+        const editorsToMove = prepareMoveCopyEditors(activeGroup, activeGroup.editors.slice(), true);
+        activeGroup.moveEditors(editorsToMove, modalPart.activeGroup);
+        if (isMaximized && !modalPart.maximized) {
+            modalPart.toggleMaximized();
+        }
+        modalPart.activeGroup.focus();
+    }
+}
+registerAction2(OpenEditorInModalEditorAction);
+class OpenModalEditorInEditorAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.openModalEditorInEditor";
+    }
+    constructor() {
+        super({
+            id: OpenModalEditorInEditorAction.ID,
+            title: ( localize2(4036, "Open in Editor Area")),
+            icon: Codicon.openInWindow,
+            f1: false,
+            precondition: ( CustomViewVisibleContext.negate()),
+            menu: {
+                id: MenuId.ModalEditorTitle,
+                group: "navigation",
+                order: 98,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, EditorPartModalContext))
+            }
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const commandService = accessor.get(ICommandService);
+        const configurationService = accessor.get(IConfigurationService);
+        const editorGroupsService = accessor.get(IEditorGroupsService);
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const changesViewService = accessor.get(IChangesViewService);
+        const activeEditorPart = editorGroupsService.activeModalEditorPart;
+        const activeGroup = activeEditorPart?.activeGroup;
+        if (!activeEditorPart || !activeGroup) {
+            return;
+        }
+        const isMaximized = activeEditorPart.maximized;
+        await configurationService.updateValue("workbench.editor.useModal", "some");
+        layoutService.setPartHidden(false, Parts.EDITOR_PART);
+        const navigation = activeGroup.activeEditorPane?.options?.modal?.navigation;
+        if (navigation) {
+            const view = viewsService.getViewWithId(CHANGES_VIEW_ID);
+            const changes = changesViewService.activeSessionChangesObs.get();
+            if (changes && navigation.current < changes.length) {
+                await view?.openChanges(
+                    changes[navigation.current].modifiedUri ?? changes[navigation.current].originalUri
+                );
+                await activeGroup.closeEditor(activeGroup.editors[0]);
+            }
+        }
+        await commandService.executeCommand(MOVE_MODAL_EDITOR_TO_MAIN_COMMAND_ID);
+        if (isMaximized) {
+            layoutService.setEditorMaximized(true);
+        }
+        editorGroupsService.activeGroup.focus();
+    }
+}
+registerAction2(OpenModalEditorInEditorAction);
+class AddFileAsContextAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.addFileAsContext";
+    }
+    constructor() {
+        const precondition = ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), ( ActiveEditorContext.isEqualTo(TEXT_FILE_EDITOR_ID))));
+        super({
+            id: AddFileAsContextAction.ID,
+            title: ( localize2(4037, "Add File as Context")),
+            category: SessionsCategories.Sessions,
+            icon: Codicon.attach,
+            f1: true,
+            precondition,
+            menu: [{
+                id: Menus.SessionsEditorTitle,
+                group: "navigation",
+                order: 100000,
+                when: ( ContextKeyExpr.and(precondition, singlePaneDetailPanel))
+            }, {
+                id: MenuId.EditorTitle,
+                group: "navigation",
+                order: 100000,
+                when: ( ContextKeyExpr.and(precondition, notSinglePaneDetailPanel))
+            }]
+        });
+    }
+    run(accessor, ...args) {
+        const editorService = accessor.get(IEditorService);
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const resolvedContext = resolveCommandsContext(
+            args,
+            editorService,
+            accessor.get(IEditorGroupsService),
+            accessor.get(IListService)
+        );
+        const resources = resolvedContext.groupedEditors.flatMap(groupedEditor => groupedEditor.editors).map(editor => EditorResourceAccessor.getCanonicalUri(editor, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        })).filter(
+            uri => uri !== undefined && [Schemas.file, Schemas.vscodeRemote, Schemas.untitled].includes(uri.scheme)
+        );
+        if (resources.length === 0) {
+            return;
+        }
+        const sessionId = sessionsService.activeSession.get()?.sessionId;
+        sessionsPartService.getSessionView(sessionId)?.attach(resources);
+    }
+}
+registerAction2(AddFileAsContextAction);
+let EditorTitleMenuBridgeContribution = class EditorTitleMenuBridgeContribution extends Disposable {
+    static {
+        EditorTitleMenuBridgeContribution_1 = this;
+    }
+    static {
+        this.ID = "workbench.contrib.sessions.editorTitleMenuBridge";
+    }
+    static {
+        this._extensionSubmenuPrefix = "api:";
+    }
+    constructor(layoutService) {
+        super();
+        this._mirrored = this._register(( new DisposableStore()));
+        if (!layoutService.isSinglePaneLayoutEnabled) {
+            return;
+        }
+        this._sync();
+        this._register(MenuRegistry.onDidChangeMenu(e => {
+            if (( e.has(MenuId.EditorTitle))) {
+                this._sync();
+            }
+        }));
+    }
+    _sync() {
+        this._mirrored.clear();
+        for (const item of MenuRegistry.getMenuItems(MenuId.EditorTitle)) {
+            const isExtensionItem = isIMenuItem(item) ? !!item.command.source : item.submenu.id.startsWith(EditorTitleMenuBridgeContribution_1._extensionSubmenuPrefix);
+            if (isExtensionItem) {
+                this._mirrored.add(MenuRegistry.appendMenuItem(Menus.SessionsEditorTitle, item));
+            }
+        }
+    }
+};
+EditorTitleMenuBridgeContribution = EditorTitleMenuBridgeContribution_1 = ( __decorate([( __param(0, IAgentWorkbenchLayoutService))], EditorTitleMenuBridgeContribution));
+registerWorkbenchContribution2(
+    EditorTitleMenuBridgeContribution.ID,
+    EditorTitleMenuBridgeContribution,
+    WorkbenchPhase.BlockStartup
+);
+
+export { EditorTitleMenuBridgeContribution };

package/vscode/src/vs/sessions/contrib/editor/browser/emptyFileEditor.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/editor/browser/emptyFileEditor.contribution.js

@@ -0,0 +1,35 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/editor';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { EmptyFileEditor } from './emptyFileEditor.js';
+import { EmptyFileEditorInput, EmptyFileEditorSerializer } from './emptyFileEditorInput.js';
+
+let SinglePaneEmptyFileEditorContribution = class SinglePaneEmptyFileEditorContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.singlePaneEmptyFileEditor";
+    }
+    constructor(layoutService) {
+        super();
+        if (!layoutService.isSinglePaneLayoutEnabled) {
+            return;
+        }
+        this._register(( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+            EditorPaneDescriptor.create(EmptyFileEditor, EmptyFileEditor.ID, ( localize(4038, "File"))),
+            [( new SyncDescriptor(EmptyFileEditorInput))]
+        ));
+        this._register(( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(EmptyFileEditorInput.ID, EmptyFileEditorSerializer));
+    }
+};
+SinglePaneEmptyFileEditorContribution = ( __decorate([( __param(0, IAgentWorkbenchLayoutService))], SinglePaneEmptyFileEditorContribution));
+registerWorkbenchContribution2(
+    SinglePaneEmptyFileEditorContribution.ID,
+    SinglePaneEmptyFileEditorContribution,
+    WorkbenchPhase.BlockStartup
+);

package/vscode/src/vs/sessions/contrib/editor/browser/emptyFileEditor.d.ts

@@ -0,0 +1,18 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+export declare class EmptyFileEditor extends EditorPane {
+    private readonly commandService;
+    private readonly instantiationService;
+    static readonly ID = "workbench.editor.agentSessions.emptyFile";
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService, commandService: ICommandService, instantiationService: IInstantiationService);
+    protected createEditor(parent: HTMLElement): void;
+    private createSearchAction;
+    focus(): void;
+    layout(_dimension: Dimension): void;
+}