@theia/debug 1.29.0-next.20 → 1.29.0-next.22

package/src/browser/debug-schema-updater.ts

@@ -16,13 +16,14 @@
 
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import { JsonSchemaRegisterContext, JsonSchemaContribution } from '@theia/core/lib/browser/json-schema-store';
-import { InMemoryResources, deepClone } from '@theia/core/lib/common';
+import { InMemoryResources, deepClone, nls } from '@theia/core/lib/common';
 import { IJSONSchema } from '@theia/core/lib/common/json-schema';
 import URI from '@theia/core/lib/common/uri';
 import { DebugService } from '../common/debug-service';
 import { debugPreferencesSchema } from './debug-preferences';
 import { inputsSchema } from '@theia/variable-resolver/lib/browser/variable-input-schema';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { defaultCompound } from '../common/debug-compound';
 
 @injectable()
 export class DebugSchemaUpdater implements JsonSchemaContribution {
@@ -73,24 +74,74 @@ export const launchSchemaId = 'vscode://schemas/launch';
 const launchSchema: IJSONSchema = {
     $id: launchSchemaId,
     type: 'object',
-    title: 'Launch',
+    title: nls.localizeByDefault('Launch'),
     required: [],
-    default: { version: '0.2.0', configurations: [] },
+    default: { version: '0.2.0', configurations: [], compounds: [] },
     properties: {
         version: {
             type: 'string',
-            description: 'Version of this file format.',
+            description: nls.localizeByDefault('Version of this file format.'),
             default: '0.2.0'
         },
         configurations: {
             type: 'array',
-            description: 'List of configurations. Add new configurations or edit existing ones by using IntelliSense.',
+            description: nls.localizeByDefault('List of configurations. Add new configurations or edit existing ones by using IntelliSense.'),
             items: {
                 defaultSnippets: [],
                 'type': 'object',
                 oneOf: []
             }
         },
+        compounds: {
+            type: 'array',
+            description: nls.localizeByDefault('List of compounds. Each compound references multiple configurations which will get launched together.'),
+            items: {
+                type: 'object',
+                required: ['name', 'configurations'],
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: nls.localizeByDefault('Name of compound. Appears in the launch configuration drop down menu.')
+                    },
+                    configurations: {
+                        type: 'array',
+                        default: [],
+                        items: {
+                            oneOf: [{
+                                type: 'string',
+                                description: nls.localizeByDefault('Please use unique configuration names.')
+                            }, {
+                                type: 'object',
+                                required: ['name'],
+                                properties: {
+                                    name: {
+                                        enum: [],
+                                        description: nls.localizeByDefault('Name of compound. Appears in the launch configuration drop down menu.')
+                                    },
+                                    folder: {
+                                        enum: [],
+                                        description: nls.localizeByDefault('Name of folder in which the compound is located.')
+                                    }
+                                }
+                            }]
+                        },
+                        description: nls.localizeByDefault('Names of configurations that will be started as part of this compound.')
+                    },
+                    stopAll: {
+                        type: 'boolean',
+                        default: false,
+                        description: nls.localizeByDefault('Controls whether manually terminating one session will stop all of the compound sessions.')
+                    },
+                    preLaunchTask: {
+                        type: 'string',
+                        default: '',
+                        description: nls.localizeByDefault('Task to run before any of the compound configurations start.')
+                    }
+                },
+                default: defaultCompound
+            },
+            default: [defaultCompound]
+        },
         inputs: inputsSchema.definitions!.inputs
     },
     allowComments: true,

package/src/browser/debug-session-contribution.ts

@@ -22,7 +22,7 @@ import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-servi
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging/ws-connection-provider';
 import { DebugSession } from './debug-session';
 import { BreakpointManager } from './breakpoint/breakpoint-manager';
-import { DebugSessionOptions } from './debug-session-options';
+import { DebugConfigurationSessionOptions, DebugSessionOptions } from './debug-session-options';
 import { OutputChannelManager, OutputChannel } from '@theia/output/lib/browser/output-channel';
 import { DebugPreferences } from './debug-preferences';
 import { DebugSessionConnection } from './debug-session-connection';
@@ -118,7 +118,7 @@ export class DefaultDebugSessionFactory implements DebugSessionFactory {
     @inject(WorkspaceService)
     protected readonly workspaceService: WorkspaceService;
 
-    get(sessionId: string, options: DebugSessionOptions, parentSession?: DebugSession): DebugSession {
+    get(sessionId: string, options: DebugConfigurationSessionOptions, parentSession?: DebugSession): DebugSession {
         const connection = new DebugSessionConnection(
             sessionId,
             () => new Promise<DebugChannel>(resolve =>

package/src/browser/debug-session-manager.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { DisposableCollection, Emitter, Event, MessageService, ProgressService, WaitUntilEvent } from '@theia/core';
+import { DisposableCollection, Emitter, Event, MessageService, nls, ProgressService, WaitUntilEvent } from '@theia/core';
 import { LabelProvider, ApplicationShell } from '@theia/core/lib/browser';
 import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import URI from '@theia/core/lib/common/uri';
@@ -29,7 +29,7 @@ import { BreakpointManager } from './breakpoint/breakpoint-manager';
 import { DebugConfigurationManager } from './debug-configuration-manager';
 import { DebugSession, DebugState } from './debug-session';
 import { DebugSessionContributionRegistry, DebugSessionFactory } from './debug-session-contribution';
-import { DebugSessionOptions, InternalDebugSessionOptions } from './debug-session-options';
+import { DebugCompoundRoot, DebugCompoundSessionOptions, DebugConfigurationSessionOptions, DebugSessionOptions, InternalDebugSessionOptions } from './debug-session-options';
 import { DebugStackFrame } from './model/debug-stack-frame';
 import { DebugThread } from './model/debug-thread';
 import { TaskIdentifier } from '@theia/task/lib/common';
@@ -191,7 +191,19 @@ export class DebugSessionManager {
         }
     }
 
-    async start(options: DebugSessionOptions): Promise<DebugSession | undefined> {
+    async start(options: DebugCompoundSessionOptions): Promise<boolean | undefined>;
+    async start(options: DebugConfigurationSessionOptions): Promise<DebugSession | undefined>;
+    async start(options: DebugSessionOptions): Promise<DebugSession | boolean | undefined>;
+    async start(name: string): Promise<DebugSession | boolean | undefined>;
+    async start(optionsOrName: DebugSessionOptions | string): Promise<DebugSession | boolean | undefined> {
+        if (typeof optionsOrName === 'string') {
+            const options = this.debugConfigurationManager.find(optionsOrName);
+            return !!options && this.start(options);
+        }
+        return optionsOrName.configuration ? this.startConfiguration(optionsOrName) : this.startCompound(optionsOrName);
+    }
+
+    protected async startConfiguration(options: DebugConfigurationSessionOptions): Promise<DebugSession | undefined> {
         return this.progressService.withProgress('Start...', 'debug', async () => {
             try {
                 if (!await this.saveAll()) {
@@ -200,7 +212,7 @@ export class DebugSessionManager {
                 await this.fireWillStartDebugSession();
                 const resolved = await this.resolveConfiguration(options);
 
-                if (!resolved) {
+                if (!resolved || !resolved.configuration) {
                     // As per vscode API: https://code.visualstudio.com/api/references/vscode-api#DebugConfigurationProvider
                     // "Returning the value 'undefined' prevents the debug session from starting.
                     // Returning the value 'null' prevents the debug session from starting and opens the
@@ -236,13 +248,70 @@ export class DebugSessionManager {
         });
     }
 
+    protected async startCompound(options: DebugCompoundSessionOptions): Promise<boolean | undefined> {
+        let configurations: DebugConfigurationSessionOptions[] = [];
+        try {
+            configurations = this.getCompoundConfigurations(options);
+        } catch (error) {
+            this.messageService.error(error.message);
+            return;
+        }
+
+        if (options.compound.preLaunchTask) {
+            const taskRun = await this.runTask(options.workspaceFolderUri, options.compound.preLaunchTask, true);
+            if (!taskRun) {
+                return undefined;
+            }
+        }
+
+        // Compound launch is a success only if each configuration launched successfully
+        const values = await Promise.all(configurations.map(configuration => this.startConfiguration(configuration)));
+        const result = values.every(success => !!success);
+        return result;
+    }
+
+    protected getCompoundConfigurations(options: DebugCompoundSessionOptions): DebugConfigurationSessionOptions[] {
+        const compound = options.compound;
+        if (!compound.configurations) {
+            throw new Error(nls.localizeByDefault('Compound must have "configurations" attribute set in order to start multiple configurations.'));
+        }
+
+        const compoundRoot = compound.stopAll ? new DebugCompoundRoot() : undefined;
+        const configurations: DebugConfigurationSessionOptions[] = [];
+        for (const configData of compound.configurations) {
+            const name = typeof configData === 'string' ? configData : configData.name;
+            if (name === compound.name) {
+                throw new Error(nls.localize('theia/debug/compound-cycle', "Launch configuration '{0}' contains a cycle with itself", name));
+            }
+
+            const workspaceFolderUri = typeof configData === 'string' ? options.workspaceFolderUri : configData.folder;
+            const matchingOptions = [...this.debugConfigurationManager.all]
+                .filter(option => option.name === name && !!option.configuration && option.workspaceFolderUri === workspaceFolderUri);
+            if (matchingOptions.length === 1) {
+                const match = matchingOptions[0];
+                if (DebugSessionOptions.isConfiguration(match)) {
+                    configurations.push({ ...match, compoundRoot, configuration: { ...match.configuration, noDebug: options.noDebug } });
+                } else {
+                    throw new Error(nls.localizeByDefault("Could not find launch configuration '{0}' in the workspace.", name));
+                }
+            } else {
+                throw new Error(matchingOptions.length === 0
+                    ? workspaceFolderUri
+                        ? nls.localizeByDefault("Can not find folder with name '{0}' for configuration '{1}' in compound '{2}'.", workspaceFolderUri, name, compound.name)
+                        : nls.localizeByDefault("Could not find launch configuration '{0}' in the workspace.", name)
+                    : nls.localizeByDefault("There are multiple launch configurations '{0}' in the workspace. Use folder name to qualify the configuration.", name));
+            }
+        }
+        return configurations;
+    }
+
     protected async fireWillStartDebugSession(): Promise<void> {
         await WaitUntilEvent.fire(this.onWillStartDebugSessionEmitter, {});
     }
 
     protected configurationIds = new Map<string, number>();
     protected async resolveConfiguration(
-        options: Readonly<DebugSessionOptions>
+        options: Readonly<DebugConfigurationSessionOptions>
     ): Promise<InternalDebugSessionOptions | undefined | null> {
         if (InternalDebugSessionOptions.is(options)) {
             return options;
@@ -275,10 +344,12 @@ export class DebugSessionManager {
         const key = configuration.name + workspaceFolderUri;
         const id = this.configurationIds.has(key) ? this.configurationIds.get(key)! + 1 : 0;
         this.configurationIds.set(key, id);
+
         return {
             id,
-            configuration,
-            workspaceFolderUri
+            ...options,
+            name: configuration.name,
+            configuration
         };
     }
 
@@ -301,7 +372,7 @@ export class DebugSessionManager {
         return this.debug.resolveDebugConfigurationWithSubstitutedVariables(configuration, workspaceFolderUri);
     }
 
-    protected async doStart(sessionId: string, options: DebugSessionOptions): Promise<DebugSession> {
+    protected async doStart(sessionId: string, options: DebugConfigurationSessionOptions): Promise<DebugSession> {
         const parentSession = options.configuration.parentSession && this._sessions.get(options.configuration.parentSession.id);
         const contrib = this.sessionContributionRegistry.get(options.configuration.type);
         const sessionFactory = contrib ? contrib.debugSessionFactory() : this.debugSessionFactory;

package/src/browser/debug-session-options.ts

@@ -14,44 +14,101 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { Emitter } from '@theia/core';
 import { DebugConfiguration } from '../common/debug-common';
+import { DebugCompound } from '../common/debug-compound';
+
+export class DebugCompoundRoot {
+    private stopped = false;
+    private stopEmitter = new Emitter<void>();
+    onDidSessionStop = this.stopEmitter.event;
+
+    stopSession(): void {
+        if (!this.stopped) { // avoid sending extraneous terminate events
+            this.stopped = true;
+            this.stopEmitter.fire();
+        }
+    }
+}
 
 export interface DebugSessionOptionsBase {
     workspaceFolderUri?: string,
-    providerType?: string // Applicable to dynamic configurations
 }
 
-export interface DebugSessionOptions extends DebugSessionOptionsBase {
-    configuration: DebugConfiguration
+export interface DebugConfigurationSessionOptions extends DebugSessionOptionsBase {
+    name: string; // derived from the configuration
+    configuration: DebugConfiguration;
+    compound?: never;
+    compoundRoot?: DebugCompoundRoot;
+    providerType?: string // Applicable to dynamic configurations
 }
 
-export interface DebugSessionOptionsData extends DebugSessionOptionsBase, DebugConfiguration {
+export type DynamicDebugConfigurationSessionOptions = DebugConfigurationSessionOptions & { providerType: string };
+
+export interface DebugCompoundSessionOptions extends DebugSessionOptionsBase {
+    name: string; // derived from the compound
+    configuration?: never;
+    compound: DebugCompound;
+    noDebug?: boolean,
 }
 
-export interface InternalDebugSessionOptions extends DebugSessionOptions {
-    id: number
+export type DebugSessionOptions = DebugConfigurationSessionOptions | DebugCompoundSessionOptions;
+
+export namespace DebugSessionOptions {
+    export function isConfiguration(options?: DebugSessionOptions): options is DebugConfigurationSessionOptions {
+        return !!options && 'configuration' in options && !!options.configuration;
+    }
+
+    export function isDynamic(options?: DebugSessionOptions): options is DynamicDebugConfigurationSessionOptions {
+        return isConfiguration(options) && 'providerType' in options && !!options.providerType;
+    }
+
+    export function isCompound(options?: DebugSessionOptions): options is DebugCompoundSessionOptions {
+        return !!options && 'compound' in options && !!options.compound;
+    }
 }
+
+/**
+ * Flat and partial version of a debug session options usable to find the options later in the manager.
+ * @deprecated Not needed anymore, the recommended way is to serialize/deserialize the options directly using `JSON.stringify` and `JSON.parse`.
+ */
+export type DebugSessionOptionsData = DebugSessionOptionsBase & (DebugConfiguration | DebugCompound);
+
+export type InternalDebugSessionOptions = DebugSessionOptions & { id: number };
+
 export namespace InternalDebugSessionOptions {
 
     const SEPARATOR = '__CONF__';
+    const SEPARATOR_CONFIGS = '__COMP__';
 
     export function is(options: DebugSessionOptions): options is InternalDebugSessionOptions {
         return 'id' in options;
     }
 
-    export function toValue(debugSessionOptions: DebugSessionOptions): string {
-        return debugSessionOptions.configuration.name + SEPARATOR +
-            debugSessionOptions.configuration.type + SEPARATOR +
-            debugSessionOptions.configuration.request + SEPARATOR +
-            debugSessionOptions.workspaceFolderUri + SEPARATOR +
-            debugSessionOptions.providerType;
+    /** @deprecated Please use `JSON.stringify` to serialize the options. */
+    export function toValue(options: DebugSessionOptions): string {
+        if (DebugSessionOptions.isCompound(options)) {
+            return options.compound.name + SEPARATOR +
+                options.workspaceFolderUri + SEPARATOR +
+                options.compound?.configurations.join(SEPARATOR_CONFIGS);
+        }
+        return options.configuration.name + SEPARATOR +
+            options.configuration.type + SEPARATOR +
+            options.configuration.request + SEPARATOR +
+            options.workspaceFolderUri + SEPARATOR +
+            options.providerType;
     }
 
+    /** @deprecated Please use `JSON.parse` to restore previously serialized debug session options. */
+    // eslint-disable-next-line deprecation/deprecation
     export function parseValue(value: string): DebugSessionOptionsData {
         const split = value.split(SEPARATOR);
-        if (split.length !== 5) {
-            throw new Error('Unexpected argument, the argument is expected to have been generated by the \'toValue\' function');
+        if (split.length === 5) {
+            return { name: split[0], type: split[1], request: split[2], workspaceFolderUri: split[3], providerType: split[4] };
+        }
+        if (split.length === 3) {
+            return { name: split[0], workspaceFolderUri: split[1], configurations: split[2].split(SEPARATOR_CONFIGS) };
         }
-        return {name: split[0], type: split[1], request: split[2], workspaceFolderUri: split[3], providerType: split[4]};
+        throw new Error('Unexpected argument, the argument is expected to have been generated by the \'toValue\' function');
     }
 }

package/src/browser/debug-session.tsx

@@ -33,7 +33,7 @@ import { DebugSourceBreakpoint } from './model/debug-source-breakpoint';
 import debounce = require('p-debounce');
 import URI from '@theia/core/lib/common/uri';
 import { BreakpointManager } from './breakpoint/breakpoint-manager';
-import { DebugSessionOptions, InternalDebugSessionOptions } from './debug-session-options';
+import { DebugConfigurationSessionOptions, InternalDebugSessionOptions } from './debug-session-options';
 import { DebugConfiguration, DebugConsoleMode } from '../common/debug-common';
 import { SourceBreakpoint, ExceptionBreakpoint } from './breakpoint/breakpoint-marker';
 import { TerminalWidgetOptions, TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
@@ -76,7 +76,7 @@ export class DebugSession implements CompositeTreeElement {
 
     constructor(
         readonly id: string,
-        readonly options: DebugSessionOptions,
+        readonly options: DebugConfigurationSessionOptions,
         readonly parentSession: DebugSession | undefined,
         protected readonly connection: DebugSessionConnection,
         protected readonly terminalServer: TerminalService,
@@ -117,6 +117,9 @@ export class DebugSession implements CompositeTreeElement {
             this.connection.on('capabilities', event => this.updateCapabilities(event.body.capabilities)),
             this.breakpoints.onDidChangeMarkers(uri => this.updateBreakpoints({ uri, sourceModified: true }))
         ]);
+        if (this.options.compoundRoot) {
+            this.toDispose.push(this.options.compoundRoot.onDidSessionStop(() => this.stop(false, () => { })));
+        }
     }
 
     get onDispose(): Event<void> {
@@ -352,6 +355,9 @@ export class DebugSession implements CompositeTreeElement {
                     console.error('Error on disconnect', e);
                 }
             }
+            if (!isRestart) {
+                this.options.compoundRoot?.stopSession();
+            }
             callback();
         }
     }

package/src/browser/view/debug-configuration-select.tsx

@@ -17,7 +17,7 @@
 import URI from '@theia/core/lib/common/uri';
 import * as React from '@theia/core/shared/react';
 import { DebugConfigurationManager } from '../debug-configuration-manager';
-import { DebugSessionOptions, InternalDebugSessionOptions } from '../debug-session-options';
+import { DebugSessionOptions } from '../debug-session-options';
 import { SelectComponent, SelectOption } from '@theia/core/lib/browser/widgets/select-component';
 import { QuickInputService } from '@theia/core/lib/browser';
 import { nls } from '@theia/core/lib/common/nls';
@@ -40,6 +40,7 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
     protected static readonly PICK = '__PICK__';
     protected static readonly NO_CONFIGURATION = '__NO_CONF__';
     protected static readonly ADD_CONFIGURATION = '__ADD_CONF__';
+    protected static readonly CONFIG_MARKER = '__CONFIG__';
 
     private readonly selectRef = React.createRef<SelectComponent>();
     private manager: DebugConfigurationManager;
@@ -65,7 +66,7 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
     override render(): React.ReactNode {
         return <SelectComponent
             options={this.renderOptions()}
-            defaultValue={this.currentValue}
+            defaultValue={this.state.currentValue}
             onChange={option => this.setCurrentConfiguration(option)}
             onFocus={() => this.refreshDebugConfigurations()}
             onBlur={() => this.refreshDebugConfigurations()}
@@ -75,7 +76,26 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
 
     protected get currentValue(): string {
         const { current } = this.manager;
-        return current ? InternalDebugSessionOptions.toValue(current) : DebugConfigurationSelect.NO_CONFIGURATION;
+        const matchingOption = this.getCurrentOption(current);
+        return matchingOption ? matchingOption.value! : current ? JSON.stringify(current) : DebugConfigurationSelect.NO_CONFIGURATION;
+    }
+
+    protected getCurrentOption(current: DebugSessionOptions | undefined): SelectOption | undefined {
+        if (!current || !this.selectRef.current) {
+            return;
+        }
+        const matchingOption = this.selectRef.current!.options.find(option =>
+            option.userData === DebugConfigurationSelect.CONFIG_MARKER
+            && this.matchesOption(JSON.parse(option.value!), current)
+        );
+        return matchingOption;
+    }
+
+    protected matchesOption(sessionOption: DebugSessionOptions, current: DebugSessionOptions): boolean {
+        const matchesNameAndWorkspace = sessionOption.name === current.name && sessionOption.workspaceFolderUri === current.workspaceFolderUri;
+        return DebugSessionOptions.isConfiguration(sessionOption) && DebugSessionOptions.isConfiguration(current)
+            ? matchesNameAndWorkspace && sessionOption.providerType === current.providerType
+            : matchesNameAndWorkspace;
     }
 
     protected readonly setCurrentConfiguration = (option: SelectOption) => {
@@ -88,12 +108,9 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
             const providerType = this.parsePickValue(value);
             this.selectDynamicConfigFromQuickPick(providerType);
         } else {
-            const { name, type, request, workspaceFolderUri, providerType } = InternalDebugSessionOptions.parseValue(value);
-            this.manager.current = this.manager.find(
-                { name, type, request },
-                workspaceFolderUri,
-                providerType === 'undefined' ? undefined : providerType
-            );
+            const data = JSON.parse(value) as DebugSessionOptions;
+            this.manager.current = data;
+            this.refreshDebugConfigurations();
         }
     };
 
@@ -151,13 +168,15 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
     protected refreshDebugConfigurations = async () => {
         const configsPerType = await this.manager.provideDynamicDebugConfigurations();
         const providerTypes = [];
-        for (const [ type, configurations ] of Object.entries(configsPerType)) {
+        for (const [type, configurations] of Object.entries(configsPerType)) {
             if (configurations.length > 0) {
                 providerTypes.push(type);
             }
         }
-        this.selectRef.current!.value = this.currentValue;
-        this.setState({ providerTypes, currentValue: this.currentValue });
+
+        const value = this.currentValue;
+        this.selectRef.current!.value = value;
+        this.setState({ providerTypes, currentValue: value });
     };
 
     protected renderOptions(): SelectOption[] {
@@ -165,10 +184,11 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
 
         // Add non dynamic debug configurations
         for (const config of this.manager.all) {
-            const value = InternalDebugSessionOptions.toValue(config);
+            const value = JSON.stringify(config);
             options.push({
                 value,
-                label: this.toName(config, this.props.isMultiRoot)
+                label: this.toName(config, this.props.isMultiRoot),
+                userData: DebugConfigurationSelect.CONFIG_MARKER
             });
         }
 
@@ -181,10 +201,11 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
                 });
             }
             for (const dynamicOption of recentDynamicOptions) {
-                const value = InternalDebugSessionOptions.toValue(dynamicOption);
+                const value = JSON.stringify(dynamicOption);
                 options.push({
                     value,
-                    label: this.toName(dynamicOption, this.props.isMultiRoot) + ' (' + dynamicOption.providerType + ')'
+                    label: this.toName(dynamicOption, this.props.isMultiRoot) + ' (' + dynamicOption.providerType + ')',
+                    userData: DebugConfigurationSelect.CONFIG_MARKER
                 });
             }
         }
@@ -225,10 +246,11 @@ export class DebugConfigurationSelect extends React.Component<DebugConfiguration
         return options;
     }
 
-    protected toName({ configuration, workspaceFolderUri }: DebugSessionOptions, multiRoot: boolean): string {
-        if (!workspaceFolderUri || !multiRoot) {
-            return configuration.name;
+    protected toName(options: DebugSessionOptions, multiRoot: boolean): string {
+        const name = options.configuration?.name ?? options.name;
+        if (!options.workspaceFolderUri || !multiRoot) {
+            return name;
         }
-        return `${configuration.name} (${new URI(workspaceFolderUri).path.base})`;
+        return `${name} (${new URI(options.workspaceFolderUri).path.base})`;
     }
 }

package/src/common/debug-compound.ts

@@ -0,0 +1,32 @@
+// *****************************************************************************
+// Copyright (C) 2022 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.
+//
+// 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { TaskIdentifier } from '@theia/task/lib/common';
+
+export const defaultCompound: DebugCompound = { name: 'Compound', configurations: [] };
+
+export interface DebugCompound {
+    name: string;
+    stopAll?: boolean;
+    preLaunchTask?: string | TaskIdentifier;
+    configurations: (string | { name: string, folder: string })[];
+}
+
+export namespace DebugCompound {
+    export function is(arg: unknown): arg is DebugCompound {
+        return !!arg && typeof arg === 'object' && 'name' in arg && 'configurations' in arg;
+    }
+}