@theia/terminal-manager 1.67.0-next.86

package/lib/package.spec.js

@@ -0,0 +1,26 @@
+// *****************************************************************************
+// Copyright (C) 2017 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+/* note: this bogus test file is required so that
+   we are able to run mocha unit tests on this
+   package, without having any actual unit tests in it.
+   This way a coverage report will be generated,
+   showing 0% coverage, instead of no report.
+   This file can be removed once we have real unit
+   tests in place. */
+describe('terminal package', () => {
+    it('support code coverage statistics', () => true);
+});
+//# sourceMappingURL=package.spec.js.map

package/lib/package.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.spec.js","sourceRoot":"","sources":["../src/package.spec.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,0CAA0C;AAC1C,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAEhF;;;;;;qBAMqB;AAErB,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;AACvD,CAAC,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@theia/terminal-manager",
+  "version": "1.67.0-next.86+03f92ff1d97",
+  "description": "Theia - Terminal Manager Extension",
+  "keywords": [
+    "theia-extension"
+  ],
+  "homepage": "https://github.com/eclipse-theia/theia",
+  "license": "EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eclipse-theia/theia.git"
+  },
+  "files": [
+    "lib",
+    "src"
+  ],
+  "scripts": {
+    "build": "theiaext build",
+    "clean": "theiaext clean",
+    "compile": "theiaext compile",
+    "lint": "theiaext lint",
+    "test": "theiaext test",
+    "watch": "theiaext watch"
+  },
+  "dependencies": {
+    "@theia/core": "1.67.0-next.86+03f92ff1d97",
+    "@theia/preferences": "1.67.0-next.86+03f92ff1d97",
+    "@theia/terminal": "1.67.0-next.86+03f92ff1d97"
+  },
+  "theiaExtensions": [
+    {
+      "frontend": "lib/browser/terminal-manager-frontend-module"
+    }
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "03f92ff1d97dcb199de39b48e60a53535de22808"
+}

package/src/browser/terminal-manager-frontend-contribution.ts

@@ -0,0 +1,164 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { CommandRegistry, PreferenceService, DisposableCollection } from '@theia/core/lib/common';
+import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
+import { TerminalFrontendContribution, TerminalCommands } from '@theia/terminal/lib/browser/terminal-frontend-contribution';
+import { ApplicationShell, WidgetManager, FrontendApplicationContribution, FrontendApplication } from '@theia/core/lib/browser';
+import { TerminalManagerWidget } from './terminal-manager-widget';
+import { TerminalManagerFrontendViewContribution } from './terminal-manager-frontend-view-contribution';
+import { TerminalManagerPreferences } from './terminal-manager-preferences';
+/**
+ * Re-registers terminal commands (e.g. new terminal) to execute them via the terminal manager
+ * instead of creating new, separate terminals.
+ */
+@injectable()
+export class TerminalManagerFrontendContribution implements FrontendApplicationContribution {
+    @inject(TerminalFrontendContribution)
+    protected readonly terminalFrontendContribution: TerminalFrontendContribution;
+
+    @inject(TerminalManagerFrontendViewContribution)
+    protected readonly terminalManagerViewContribution: TerminalManagerFrontendViewContribution;
+
+    @inject(WidgetManager)
+    protected readonly widgetManager: WidgetManager;
+
+    @inject(ApplicationShell)
+    protected readonly shell: ApplicationShell;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(TerminalManagerPreferences)
+    protected readonly preferences: TerminalManagerPreferences;
+
+    @inject(CommandRegistry)
+    protected readonly commandRegistry: CommandRegistry;
+
+    protected commandHandlerDisposables = new DisposableCollection();
+
+    onStart(app: FrontendApplication): void {
+        this.preferenceService.ready.then(() => {
+            this.preferenceService.onPreferenceChanged(change => {
+                if (change.preferenceName === 'terminal.grouping.mode') {
+                    this.handleTabsDisplayChange(change.newValue as string);
+                }
+            });
+            if (this.preferences.get('terminal.grouping.mode') !== 'tree') {
+                console.debug('Terminal tab style is not tree. Use separate terminal views.');
+                return;
+            }
+            console.debug('Terminal tab style is tree. Override command handlers accordingly.');
+            this.registerHandlers();
+        });
+    }
+
+    protected handleTabsDisplayChange(newValue: string): void {
+        if (newValue === 'tree') {
+            this.registerHandlers();
+        } else {
+            this.unregisterHandlers();
+        }
+    }
+
+    protected unregisterHandlers(): void {
+        this.commandHandlerDisposables.dispose();
+        this.commandHandlerDisposables = new DisposableCollection();
+    }
+
+    protected registerHandlers(): void {
+        this.unregisterHandlers();
+        this.registerCommands();
+    }
+
+    protected registerCommands(): void {
+        this.commandHandlerDisposables.push(this.commandRegistry.registerHandler(TerminalCommands.NEW.id, {
+            execute: async () => {
+                // Only create a new terminal if the view was existing as opening it automatically create a terminal
+                const existing = this.terminalManagerViewContribution.tryGetWidget();
+                const managerWidget = await this.terminalManagerViewContribution.openView({ reveal: true });
+                if (managerWidget instanceof TerminalManagerWidget && existing) {
+                    const terminalWidget = await managerWidget.createTerminalWidget();
+                    managerWidget.addTerminalPage(terminalWidget);
+                }
+            }
+        }));
+
+        this.commandHandlerDisposables.push(this.commandRegistry.registerHandler(TerminalCommands.NEW_ACTIVE_WORKSPACE.id, {
+            execute: async () => {
+                // Only create a new terminal if the view was existing as opening it automatically create a terminal
+                const existing = this.terminalManagerViewContribution.tryGetWidget();
+                const managerWidget = await this.terminalManagerViewContribution.openView({ reveal: true });
+                if (managerWidget instanceof TerminalManagerWidget && existing) {
+                    const terminalWidget = await managerWidget.createTerminalWidget();
+                    managerWidget.addTerminalPage(terminalWidget);
+                }
+            }
+        }));
+
+        this.commandHandlerDisposables.push(this.commandRegistry.registerHandler(TerminalCommands.SPLIT.id, {
+            execute: async () => {
+                const managerWidget = await this.terminalManagerViewContribution.openView({ reveal: true });
+                if (managerWidget instanceof TerminalManagerWidget) {
+                    const terminalWidget = await managerWidget.createTerminalWidget();
+                    const { model } = managerWidget.treeWidget;
+                    const activeGroupId = model.activeGroupNode?.id;
+                    const activePageId = model.activePageNode?.id;
+
+                    if (activeGroupId) {
+                        managerWidget.addWidgetToTerminalGroup(terminalWidget, activeGroupId);
+                    } else if (activePageId) {
+                        managerWidget.addTerminalGroupToPage(terminalWidget, activePageId);
+                    } else {
+                        managerWidget.addTerminalPage(terminalWidget);
+                    }
+                }
+            },
+            isEnabled: w => w instanceof TerminalWidget || w instanceof TerminalManagerWidget,
+            isVisible: w => w instanceof TerminalWidget || w instanceof TerminalManagerWidget,
+        }));
+
+        this.commandHandlerDisposables.push(this.commandRegistry.registerHandler(TerminalCommands.TOGGLE_TERMINAL.id, {
+            execute: async () => {
+                const existing = this.terminalManagerViewContribution.tryGetWidget();
+                if (!existing || !(existing instanceof TerminalManagerWidget)) {
+                    const managerWidget = await this.terminalManagerViewContribution.openView({ activate: true });
+                    if (managerWidget instanceof TerminalManagerWidget && !this.shell.isExpanded('bottom')) {
+                        this.shell.expandPanel('bottom');
+                    }
+                    return;
+                }
+
+                if (!existing.isAttached) {
+                    await this.terminalManagerViewContribution.openView({ activate: true });
+                    if (!this.shell.isExpanded('bottom')) {
+                        this.shell.expandPanel('bottom');
+                    }
+                    return;
+                }
+
+                if (!this.shell.isExpanded('bottom')) {
+                    this.shell.expandPanel('bottom');
+                    this.shell.bottomPanel.activateWidget(existing);
+                    return;
+                }
+
+                const active = this.shell.activeWidget;
+                const isManagerOrChildActive = active === existing || Array.from(existing.terminalWidgets.values()).some(widget => widget === active);
+                if (isManagerOrChildActive) {
+                    this.shell.collapsePanel('bottom');
+                } else {
+                    this.shell.bottomPanel.activateWidget(existing);
+                }
+            }
+        }));
+    }
+}

package/src/browser/terminal-manager-frontend-module.ts

@@ -0,0 +1,64 @@
+// *****************************************************************************
+// Copyright (C) 2023 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContainerModule, interfaces } from '@theia/core/shared/inversify';
+import {
+    bindViewContribution,
+    WidgetFactory,
+    WidgetManager,
+    FrontendApplicationContribution,
+} from '@theia/core/lib/browser';
+import { TabBarToolbarContribution } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { TerminalManagerWidget } from './terminal-manager-widget';
+import { TerminalManagerFrontendViewContribution } from './terminal-manager-frontend-view-contribution';
+import { TerminalManagerFrontendContribution } from './terminal-manager-frontend-contribution';
+import { TerminalManagerPreferenceContribution, TerminalManagerPreferences, TerminalManagerPreferenceSchema } from './terminal-manager-preferences';
+import { TerminalManagerTreeWidget } from './terminal-manager-tree-widget';
+import '../../src/browser/terminal-manager.css';
+import { PreferenceContribution, PreferenceProxyFactory } from '@theia/core';
+
+export default new ContainerModule((bind: interfaces.Bind) => {
+    bindViewContribution(bind, TerminalManagerFrontendViewContribution);
+    bind(TabBarToolbarContribution).toService(TerminalManagerFrontendViewContribution);
+
+    // Bind the contribution for overridden terminal commands
+    bind(TerminalManagerFrontendContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(TerminalManagerFrontendContribution);
+
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TerminalManagerTreeWidget.ID,
+        createWidget: () => TerminalManagerTreeWidget.createWidget(container),
+    })).inSingletonScope();
+
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: TerminalManagerWidget.ID,
+        createWidget: async () => {
+            const child = container.createChild();
+            const widgetManager = container.get(WidgetManager);
+            const terminalManagerTreeWidget = await widgetManager.getOrCreateWidget<TerminalManagerTreeWidget>(TerminalManagerTreeWidget.ID);
+            child.bind(TerminalManagerTreeWidget).toConstantValue(terminalManagerTreeWidget);
+            return TerminalManagerWidget.createWidget(child);
+        },
+    }));
+
+    bind(TerminalManagerPreferences).toDynamicValue(ctx => {
+        const factory = ctx.container.get<PreferenceProxyFactory>(PreferenceProxyFactory);
+        return factory(TerminalManagerPreferenceSchema);
+    }).inSingletonScope();
+    bind(TerminalManagerPreferenceContribution).toConstantValue({ schema: TerminalManagerPreferenceSchema });
+    bind(PreferenceContribution).toService(TerminalManagerPreferenceContribution);
+});
+

package/src/browser/terminal-manager-frontend-view-contribution.ts

@@ -0,0 +1,309 @@
+// *****************************************************************************
+// Copyright (C) 2023 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import {
+    AbstractViewContribution,
+    codicon,
+    KeybindingContribution,
+    KeybindingRegistry,
+    MAXIMIZED_CLASS,
+    Widget,
+} from '@theia/core/lib/browser';
+import { CommandRegistry, Event, MenuModelRegistry } from '@theia/core';
+import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { BOTTOM_AREA_ID } from '@theia/core/lib/browser/shell/theia-dock-panel';
+import { TerminalManagerCommands, TerminalManagerTreeTypes, TERMINAL_MANAGER_TREE_CONTEXT_MENU } from './terminal-manager-types';
+import { TerminalManagerWidget } from './terminal-manager-widget';
+import { TerminalManagerTreeWidget } from './terminal-manager-tree-widget';
+import { ConfirmDialog, Dialog } from '@theia/core/lib/browser/dialogs';
+
+@injectable()
+export class TerminalManagerFrontendViewContribution extends AbstractViewContribution<TerminalManagerWidget>
+    implements TabBarToolbarContribution, KeybindingContribution {
+
+    constructor() {
+        super({
+            widgetId: TerminalManagerWidget.ID,
+            widgetName: 'Terminal Manager',
+            defaultWidgetOptions: {
+                area: 'bottom',
+            },
+        });
+    }
+
+    override registerCommands(commands: CommandRegistry): void {
+        super.registerCommands(commands);
+
+        commands.registerCommand(TerminalManagerCommands.MANAGER_NEW_TERMINAL_GROUP, {
+            execute: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => {
+                const nodeId = args[1];
+                if (TerminalManagerTreeTypes.isPageId(nodeId)) {
+                    this.createNewTerminalGroup(nodeId);
+                }
+            },
+            isVisible: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => args[0] instanceof TerminalManagerTreeWidget && TerminalManagerTreeTypes.isPageId(args[1]),
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_SHOW_TREE_TOOLBAR, {
+            execute: () => this.handleToggleTree(),
+            isVisible: widget => widget instanceof TerminalManagerWidget,
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_NEW_PAGE_BOTTOM_TOOLBAR, {
+            execute: () => this.createNewTerminalPage(),
+            isVisible: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => args[0] instanceof TerminalManagerWidget,
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_DELETE_TERMINAL, {
+            execute: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => TerminalManagerTreeTypes.isTerminalKey(args[1]) && this.deleteTerminalFromManager(args[1]),
+            isVisible: (...args: TerminalManagerTreeTypes.ContextMenuArgs) => {
+                const treeWidget = args[0];
+                const nodeId = args[1];
+                if (treeWidget instanceof TerminalManagerTreeWidget && TerminalManagerTreeTypes.isTerminalKey(nodeId)) {
+                    const { model } = treeWidget;
+                    const terminalNode = model.getNode(nodeId);
+                    return TerminalManagerTreeTypes.isTerminalNode(terminalNode);
+                }
+                return false;
+            },
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_DELETE_PAGE, {
+            execute: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => TerminalManagerTreeTypes.isPageId(args[1]) && this.deletePageFromManager(args[1]),
+            isVisible: (...args: TerminalManagerTreeTypes.ContextMenuArgs) => {
+                const widget = args[0];
+                return widget instanceof TerminalManagerTreeWidget && TerminalManagerTreeTypes.isPageId(args[1]) && widget.model.pages.size >= 1;
+            },
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_RENAME_TERMINAL, {
+            execute: (...args: TerminalManagerTreeTypes.ContextMenuArgs) => this.toggleRenameTerminalFromManager(args[1]),
+            isVisible: (...args: TerminalManagerTreeTypes.ContextMenuArgs) => args[0] instanceof TerminalManagerTreeWidget,
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_ADD_TERMINAL_TO_GROUP, {
+            execute: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => {
+                const nodeId = args[1];
+                if (TerminalManagerTreeTypes.isGroupId(nodeId)) {
+                    this.addTerminalToGroup(nodeId);
+                }
+            },
+            isVisible: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => args[0] instanceof TerminalManagerTreeWidget && TerminalManagerTreeTypes.isGroupId(args[1]),
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_DELETE_GROUP, {
+            execute: (
+                ...args: TerminalManagerTreeTypes.ContextMenuArgs
+            ) => TerminalManagerTreeTypes.isGroupId(args[1]) && this.deleteGroupFromManager(args[1]),
+            isVisible: (...args: TerminalManagerTreeTypes.ContextMenuArgs) => {
+                const treeWidget = args[0];
+                const groupId = args[1];
+                if (treeWidget instanceof TerminalManagerTreeWidget && TerminalManagerTreeTypes.isGroupId(groupId)) {
+                    const { model } = treeWidget;
+                    const groupNode = model.getNode(groupId);
+                    return TerminalManagerTreeTypes.isGroupNode(groupNode);
+                }
+                return false;
+            },
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_MAXIMIZE_BOTTOM_PANEL_TOOLBAR, {
+            execute: () => this.maximizeBottomPanel(),
+            isVisible: widget => widget instanceof Widget
+                && widget.parent?.id === BOTTOM_AREA_ID
+                && !this.shell.bottomPanel.hasClass(MAXIMIZED_CLASS),
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_MINIMIZE_BOTTOM_PANEL_TOOLBAR, {
+            execute: () => this.maximizeBottomPanel(),
+            isVisible: widget => widget instanceof Widget
+                && widget.parent?.id === BOTTOM_AREA_ID
+                && this.shell.bottomPanel.hasClass(MAXIMIZED_CLASS),
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_CLEAR_ALL, {
+            isVisible: widget => widget instanceof TerminalManagerWidget,
+            execute: async widget => {
+                if (widget instanceof TerminalManagerWidget) {
+                    const PRIMARY_BUTTON = 'Reset Layout';
+                    const dialogResponse = await this.confirmUserAction({
+                        title: 'Do you want to reset the terminal manager layout?',
+                        message: 'Once the layout is reset, it cannot be restored. Are you sure you would like to clear the layout?',
+                        primaryButtonText: PRIMARY_BUTTON,
+                    });
+                    if (dialogResponse === PRIMARY_BUTTON) {
+                        for (const id of widget.pagePanels.keys()) {
+                            widget.deletePage(id);
+                        }
+                    }
+                }
+            },
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_OPEN_VIEW, {
+            execute: () => this.openView({ activate: true }),
+        });
+        commands.registerCommand(TerminalManagerCommands.MANAGER_CLOSE_VIEW, {
+            isVisible: () => Boolean(this.tryGetWidget()),
+            isEnabled: () => Boolean(this.tryGetWidget()),
+            execute: () => this.closeView(),
+        });
+    }
+
+    protected async confirmUserAction(options: { title: string, message: string, primaryButtonText: string }): Promise<string | undefined> {
+        const dialog = new ConfirmDialog({
+            title: options.title,
+            msg: options.message,
+            ok: options.primaryButtonText,
+            cancel: Dialog.CANCEL,
+        });
+        const confirmed = await dialog.open();
+        return confirmed ? options.primaryButtonText : undefined;
+    }
+
+    protected maximizeBottomPanel(): void {
+        this.shell.bottomPanel.toggleMaximized();
+    }
+
+    protected async createNewTerminalPage(): Promise<void> {
+        const terminalManagerWidget = await this.widget;
+        const terminalWidget = await terminalManagerWidget.createTerminalWidget();
+        terminalManagerWidget.addTerminalPage(terminalWidget);
+    }
+
+    protected async createNewTerminalGroup(pageId: TerminalManagerTreeTypes.PageId): Promise<void> {
+        const terminalManagerWidget = await this.widget;
+        const terminalWidget = await terminalManagerWidget.createTerminalWidget();
+        terminalManagerWidget.addTerminalGroupToPage(terminalWidget, pageId);
+    }
+
+    protected async addTerminalToGroup(groupId: TerminalManagerTreeTypes.GroupId): Promise<void> {
+        const terminalManagerWidget = await this.widget;
+        const terminalWidget = await terminalManagerWidget.createTerminalWidget();
+        terminalManagerWidget.addWidgetToTerminalGroup(terminalWidget, groupId);
+    }
+
+    protected async handleToggleTree(): Promise<void> {
+        const terminalManagerWidget = await this.widget;
+        terminalManagerWidget.toggleTreeVisibility();
+    }
+
+    protected async deleteTerminalFromManager(terminalId: TerminalManagerTreeTypes.TerminalKey): Promise<void> {
+        const terminalManagerWidget = await this.widget;
+        terminalManagerWidget?.deleteTerminal(terminalId);
+    }
+
+    protected async deleteGroupFromManager(groupId: TerminalManagerTreeTypes.GroupId): Promise<void> {
+        const widget = await this.widget;
+        widget.deleteGroup(groupId);
+    }
+
+    protected async deletePageFromManager(pageId: TerminalManagerTreeTypes.PageId): Promise<void> {
+        const widget = await this.widget;
+        widget.deletePage(pageId);
+    }
+
+    protected async toggleRenameTerminalFromManager(entityId: TerminalManagerTreeTypes.TerminalManagerValidId): Promise<void> {
+        const widget = await this.widget;
+        widget.toggleRenameTerminal(entityId);
+    }
+
+    override registerMenus(menus: MenuModelRegistry): void {
+        super.registerMenus(menus);
+        menus.registerMenuAction(TERMINAL_MANAGER_TREE_CONTEXT_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_ADD_TERMINAL_TO_GROUP.id,
+            order: 'a',
+        });
+        menus.registerMenuAction(TERMINAL_MANAGER_TREE_CONTEXT_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_RENAME_TERMINAL.id,
+            order: 'b',
+        });
+        menus.registerMenuAction(TERMINAL_MANAGER_TREE_CONTEXT_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_DELETE_TERMINAL.id,
+            order: 'c',
+        });
+        menus.registerMenuAction(TERMINAL_MANAGER_TREE_CONTEXT_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_DELETE_PAGE.id,
+            order: 'c',
+        });
+        menus.registerMenuAction(TERMINAL_MANAGER_TREE_CONTEXT_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_DELETE_GROUP.id,
+            order: 'c',
+        });
+
+        menus.registerMenuAction(TerminalManagerTreeTypes.PAGE_NODE_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_NEW_TERMINAL_GROUP.id,
+            order: 'a',
+        });
+        menus.registerMenuAction(TerminalManagerTreeTypes.PAGE_NODE_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_DELETE_PAGE.id,
+            order: 'b',
+        });
+
+        menus.registerMenuAction(TerminalManagerTreeTypes.TERMINAL_NODE_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_DELETE_TERMINAL.id,
+            order: 'c',
+        });
+
+        menus.registerMenuAction(TerminalManagerTreeTypes.GROUP_NODE_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_ADD_TERMINAL_TO_GROUP.id,
+            order: 'a',
+        });
+        menus.registerMenuAction(TerminalManagerTreeTypes.GROUP_NODE_MENU, {
+            commandId: TerminalManagerCommands.MANAGER_DELETE_GROUP.id,
+            order: 'c',
+        });
+    }
+
+    registerToolbarItems(toolbar: TabBarToolbarRegistry): void {
+        toolbar.registerItem({
+            id: TerminalManagerCommands.MANAGER_NEW_PAGE_BOTTOM_TOOLBAR.id,
+            command: TerminalManagerCommands.MANAGER_NEW_PAGE_BOTTOM_TOOLBAR.id,
+        });
+        toolbar.registerItem({
+            id: TerminalManagerCommands.MANAGER_SHOW_TREE_TOOLBAR.id,
+            command: TerminalManagerCommands.MANAGER_SHOW_TREE_TOOLBAR.id,
+        });
+        toolbar.registerItem({
+            id: TerminalManagerCommands.MANAGER_CLEAR_ALL.id,
+            command: TerminalManagerCommands.MANAGER_CLEAR_ALL.id,
+        });
+        const bottomPanelMaximizationChanged = Event.map(Event.filter(this.shell.onDidToggleMaximized, widget => widget === this.shell.bottomPanel), () => undefined);
+        toolbar.registerItem({
+            id: TerminalManagerCommands.MANAGER_MAXIMIZE_BOTTOM_PANEL_TOOLBAR.id,
+            command: TerminalManagerCommands.MANAGER_MAXIMIZE_BOTTOM_PANEL_TOOLBAR.id,
+            icon: codicon('chevron-up'),
+            onDidChange: bottomPanelMaximizationChanged,
+        });
+        toolbar.registerItem({
+            id: TerminalManagerCommands.MANAGER_MINIMIZE_BOTTOM_PANEL_TOOLBAR.id,
+            command: TerminalManagerCommands.MANAGER_MINIMIZE_BOTTOM_PANEL_TOOLBAR.id,
+            icon: codicon('chevron-down'),
+            onDidChange: bottomPanelMaximizationChanged,
+        });
+    }
+
+    override registerKeybindings(registry: KeybindingRegistry): void {
+        registry.registerKeybinding({
+            command: TerminalManagerCommands.MANAGER_MINIMIZE_BOTTOM_PANEL_TOOLBAR.id,
+            keybinding: 'alt+q',
+        });
+    }
+}

package/src/browser/terminal-manager-preferences.ts

@@ -0,0 +1,52 @@
+// *****************************************************************************
+// Copyright (C) 2023 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls, PreferenceProxy, PreferenceSchema, PreferenceScope } from '@theia/core';
+
+export const TerminalManagerPreferenceSchema: PreferenceSchema = {
+    properties: {
+        'terminal.grouping.treeViewLocation': {
+            'type': 'string',
+            'enum': ['left', 'right'],
+            'description': nls.localize('theia/terminalManager/treeViewLocation', 'The location of the terminal manager\'s tree view.'
+                + ' Only applies when \'terminal.grouping.mode\' is set to \'tree\'.'),
+            'default': 'left',
+            'scope': PreferenceScope.Workspace,
+        },
+        'terminal.grouping.mode': {
+            'type': 'string',
+            'enum': ['tabbed', 'tree'],
+            'description': nls.localize('theia/terminalManager/tabsDisplay',
+                'Controls how terminals are displayed. \'tree\' shows multiple terminals in a single view with a tree view for management,'
+                + '\'tabbed\' shows each terminal in its own view in a separate tab.'),
+            'default': 'tabbed',
+            'scope': PreferenceScope.Workspace,
+        },
+    },
+};
+
+export type TerminalManagerTreeViewLocation = 'left' | 'right';
+export type TerminalGroupingMode = 'tabbed' | 'tree';
+
+export interface TerminalManagerConfiguration {
+    'terminal.grouping.treeViewLocation': TerminalManagerTreeViewLocation;
+    'terminal.grouping.mode': TerminalGroupingMode;
+}
+
+export const TerminalManagerPreferences = Symbol('TerminalManagerPreferences');
+export const TerminalManagerPreferenceContribution = Symbol('TerminalManagerPreferenceContribution');
+export type TerminalManagerPreferences = PreferenceProxy<TerminalManagerConfiguration>;
+