@theia/debug 1.29.0-next.6 → 1.29.0

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

@@ -30,7 +30,7 @@ import { LabelProvider, PreferenceScope, PreferenceService, QuickPickValue, Stor
 import { QuickPickService } from '@theia/core/lib/common/quick-pick-service';
 import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
 import { DebugConfigurationModel } from './debug-configuration-model';
-import { DebugSessionOptions } from './debug-session-options';
+import { DebugSessionOptions, DynamicDebugConfigurationSessionOptions } from './debug-session-options';
 import { DebugService } from '../common/debug-service';
 import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { DebugConfiguration } from '../common/debug-common';
@@ -41,6 +41,7 @@ import * as monaco from '@theia/monaco-editor-core';
 import { ICommandService } from '@theia/monaco-editor-core/esm/vs/platform/commands/common/commands';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { nls } from '@theia/core';
+import { DebugCompound } from '../common/debug-compound';
 
 export interface WillProvideDebugConfiguration extends WaitUntilEvent {
 }
@@ -94,7 +95,7 @@ export class DebugConfigurationManager {
 
     protected initialized: Promise<void>;
 
-    protected recentDynamicOptionsTracker: DebugSessionOptions[] = [];
+    protected recentDynamicOptionsTracker: DynamicDebugConfigurationSessionOptions[] = [];
 
     @postConstruct()
     protected async init(): Promise<void> {
@@ -141,10 +142,10 @@ export class DebugConfigurationManager {
     protected *getAll(): IterableIterator<DebugSessionOptions> {
         for (const model of this.models.values()) {
             for (const configuration of model.configurations) {
-                yield {
-                    configuration,
-                    workspaceFolderUri: model.workspaceFolderUri
-                };
+                yield this.configurationToOptions(configuration, model.workspaceFolderUri);
+            }
+            for (const compound of model.compounds) {
+                yield this.compoundToOptions(compound, model.workspaceFolderUri);
             }
         }
     }
@@ -159,7 +160,7 @@ export class DebugConfigurationManager {
     }
     protected *doGetSupported(debugTypes: Set<string>): IterableIterator<DebugSessionOptions> {
         for (const options of this.getAll()) {
-            if (debugTypes.has(options.configuration.type)) {
+            if (options.configuration && debugTypes.has(options.configuration.type)) {
                 yield options;
             }
         }
@@ -171,8 +172,7 @@ export class DebugConfigurationManager {
     }
 
     async getSelectedConfiguration(): Promise<DebugSessionOptions | undefined> {
-        // providerType applies to dynamic configurations only
-        if (!this._currentOptions?.providerType) {
+        if (!DebugSessionOptions.isDynamic(this._currentOptions)) {
             return this._currentOptions;
         }
 
@@ -188,7 +188,7 @@ export class DebugConfigurationManager {
             throw new Error(message);
         }
 
-        return { configuration, providerType };
+        return { name, configuration, providerType };
     }
 
     set current(option: DebugSessionOptions | undefined) {
@@ -197,7 +197,7 @@ export class DebugConfigurationManager {
     }
 
     protected updateRecentlyUsedDynamicConfigurationOptions(option: DebugSessionOptions | undefined): void {
-        if (option?.providerType) { // if it's a dynamic configuration option
+        if (DebugSessionOptions.isDynamic(option)) {
             // Removing an item already present in the list
             const index = this.recentDynamicOptionsTracker.findIndex(item => this.dynamicOptionsMatch(item, option));
             if (index > -1) {
@@ -212,32 +212,33 @@ export class DebugConfigurationManager {
         }
     }
 
-    protected dynamicOptionsMatch(one: DebugSessionOptions, other: DebugSessionOptions): boolean {
+    protected dynamicOptionsMatch(one: DynamicDebugConfigurationSessionOptions, other: DynamicDebugConfigurationSessionOptions): boolean {
         return one.providerType !== undefined
-        && one.configuration.name === other.configuration.name
-        && one.providerType === other.providerType;
+            && one.configuration.name === other.configuration.name
+            && one.providerType === other.providerType;
     }
 
-    get recentDynamicOptions(): readonly DebugSessionOptions[] {
+    get recentDynamicOptions(): readonly DynamicDebugConfigurationSessionOptions[] {
         return this.recentDynamicOptionsTracker;
     }
 
     protected updateCurrent(options: DebugSessionOptions | undefined = this._currentOptions): void {
-        this._currentOptions = options && this.find(options.configuration, options.workspaceFolderUri, options.providerType);
+        if (DebugSessionOptions.isCompound(options)) {
+            this._currentOptions = options && this.find(options.compound, options.workspaceFolderUri);
+        } else {
+            this._currentOptions = options && this.find(options.configuration, options.workspaceFolderUri, options.providerType);
+        }
 
         if (!this._currentOptions) {
             const model = this.getModel();
             if (model) {
                 const configuration = model.configurations[0];
                 if (configuration) {
-                    this._currentOptions = {
-                        configuration,
-                        workspaceFolderUri: model.workspaceFolderUri
-                    };
+                    this._currentOptions = this.configurationToOptions(configuration, model.workspaceFolderUri);
                 }
             }
         }
-        this.debugConfigurationTypeKey.set(this.current && this.current.configuration.type);
+        this.debugConfigurationTypeKey.set(this.current && this.current.configuration?.type);
         this.onDidChangeEmitter.fire(undefined);
     }
 
@@ -248,24 +249,57 @@ export class DebugConfigurationManager {
     /**
      * Find / Resolve DebugSessionOptions from a given target debug configuration
      */
-    find(targetConfiguration: DebugConfiguration, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined;
-    find(nameOrTargetConfiguration: string | DebugConfiguration, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined {
-        // providerType is only applicable to dynamic debug configurations
-        if (typeof nameOrTargetConfiguration === 'object' && providerType) {
-            return {
-                configuration: nameOrTargetConfiguration,
-                providerType
-            };
-        }
-        const name = typeof nameOrTargetConfiguration === 'string' ? nameOrTargetConfiguration : nameOrTargetConfiguration.name;
+    find(compound: DebugCompound, workspaceFolderUri?: string): DebugSessionOptions | undefined;
+    find(configuration: DebugConfiguration, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined;
+    find(name: string, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined;
+    find(nameOrConfigurationOrCompound: string | DebugConfiguration | DebugCompound, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions | undefined {
+        if (DebugConfiguration.is(nameOrConfigurationOrCompound) && providerType) {
+            // providerType is only applicable to dynamic debug configurations and may only be created if we have a configuration given
+            return this.configurationToOptions(nameOrConfigurationOrCompound, workspaceFolderUri, providerType);
+        }
+        const name = typeof nameOrConfigurationOrCompound === 'string' ? nameOrConfigurationOrCompound : nameOrConfigurationOrCompound.name;
+        const configuration = this.findConfiguration(name, workspaceFolderUri);
+        if (configuration) {
+            return this.configurationToOptions(configuration, workspaceFolderUri);
+        }
+        const compound = this.findCompound(name, workspaceFolderUri);
+        if (compound) {
+            return this.compoundToOptions(compound, workspaceFolderUri);
+        }
+    }
+
+    findConfigurations(name: string, workspaceFolderUri?: string): DebugConfiguration[] {
+        const matches = [];
         for (const model of this.models.values()) {
             if (model.workspaceFolderUri === workspaceFolderUri) {
                 for (const configuration of model.configurations) {
                     if (configuration.name === name) {
-                        return {
-                            configuration,
-                            workspaceFolderUri
-                        };
+                        matches.push(configuration);
+                    }
+                }
+            }
+        }
+        return matches;
+    }
+
+    findConfiguration(name: string, workspaceFolderUri?: string): DebugConfiguration | undefined {
+        for (const model of this.models.values()) {
+            if (model.workspaceFolderUri === workspaceFolderUri) {
+                for (const configuration of model.configurations) {
+                    if (configuration.name === name) {
+                        return configuration;
+                    }
+                }
+            }
+        }
+    }
+
+    findCompound(name: string, workspaceFolderUri?: string): DebugCompound | undefined {
+        for (const model of this.models.values()) {
+            if (model.workspaceFolderUri === workspaceFolderUri) {
+                for (const compound of model.compounds) {
+                    if (compound.name === name) {
+                        return compound;
                     }
                 }
             }
@@ -279,6 +313,14 @@ export class DebugConfigurationManager {
         }
     }
 
+    protected configurationToOptions(configuration: DebugConfiguration, workspaceFolderUri?: string, providerType?: string): DebugSessionOptions {
+        return { name: configuration.name, configuration, providerType, workspaceFolderUri };
+    }
+
+    protected compoundToOptions(compound: DebugCompound, workspaceFolderUri?: string): DebugSessionOptions {
+        return { name: compound.name, compound, workspaceFolderUri };
+    }
+
     async addConfiguration(): Promise<void> {
         let rootUri: URI | undefined = undefined;
         if (this.workspaceService.saved && this.workspaceService.tryGetRoots().length > 1) {
@@ -345,7 +387,8 @@ export class DebugConfigurationManager {
             });
         }
         const root = await this.quickPickService.show(items, {
-            placeholder: nls.localize('theia/debug/addConfigurationPlaceholder', 'Select workspace root to add configuration to')
+            placeholder: nls.localize('theia/debug/addConfigurationPlaceholder', 'Select workspace root to add configuration to'),
+            ignoreFocusOut: true
         });
         return root?.value;
     }
@@ -469,17 +512,26 @@ export class DebugConfigurationManager {
 
         // Between versions v1.26 and v1.27, the expected format of the data changed so that old stored data
         // may not contain the configuration key.
-        if (data.current && 'configuration' in data.current) {
+        if (DebugSessionOptions.isConfiguration(data.current)) {
+            // ensure options name is reflected from old configurations data
+            data.current.name = data.current.name ?? data.current.configuration?.name;
             this.current = this.find(data.current.configuration, data.current.workspaceFolderUri, data.current.providerType);
+        } else if (DebugSessionOptions.isCompound(data.current)) {
+            this.current = this.find(data.current.name, data.current.workspaceFolderUri);
         }
     }
 
-    protected resolveRecentDynamicOptionsFromData(options?: DebugSessionOptions[]): void {
+    protected resolveRecentDynamicOptionsFromData(options?: DynamicDebugConfigurationSessionOptions[]): void {
         if (!options || this.recentDynamicOptionsTracker.length !== 0) {
             return;
         }
 
-        this.recentDynamicOptionsTracker = options;
+        // ensure options name is reflected from old configurations data
+        const dynamicOptions = options.map(option => {
+            option.name = option.name ?? option.configuration.name;
+            return option;
+        }).filter(DebugSessionOptions.isDynamic);
+        this.recentDynamicOptionsTracker = dynamicOptions;
     }
 
     save(): void {
@@ -502,6 +554,6 @@ export class DebugConfigurationManager {
 export namespace DebugConfigurationManager {
     export interface Data {
         current?: DebugSessionOptions,
-        recentDynamicOptions?: DebugSessionOptions[]
+        recentDynamicOptions?: DynamicDebugConfigurationSessionOptions[]
     }
 }

package/src/browser/debug-configuration-model.ts

@@ -19,6 +19,7 @@ import { Emitter, Event } from '@theia/core/lib/common/event';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { DebugConfiguration } from '../common/debug-common';
 import { PreferenceService } from '@theia/core/lib/browser/preferences/preference-service';
+import { DebugCompound } from '../common/debug-compound';
 
 export class DebugConfigurationModel implements Disposable {
 
@@ -58,6 +59,10 @@ export class DebugConfigurationModel implements Disposable {
         return this.json.configurations;
     }
 
+    get compounds(): DebugCompound[] {
+        return this.json.compounds;
+    }
+
     async reconcile(): Promise<void> {
         this.json = this.parseConfigurations();
         this.onDidChangeEmitter.fire(undefined);
@@ -66,19 +71,22 @@ export class DebugConfigurationModel implements Disposable {
         const configurations: DebugConfiguration[] = [];
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const { configUri, value } = this.preferences.resolve<any>('launch', undefined, this.workspaceFolderUri);
-        if (value && typeof value === 'object' && 'configurations' in value) {
-            if (Array.isArray(value.configurations)) {
-                for (const configuration of value.configurations) {
-                    if (DebugConfiguration.is(configuration)) {
-                        configurations.push(configuration);
-                    }
+        if (value && typeof value === 'object' && Array.isArray(value.configurations)) {
+            for (const configuration of value.configurations) {
+                if (DebugConfiguration.is(configuration)) {
+                    configurations.push(configuration);
+                }
+            }
+        }
+        const compounds: DebugCompound[] = [];
+        if (value && typeof value === 'object' && Array.isArray(value.compounds)) {
+            for (const compound of value.compounds) {
+                if (DebugCompound.is(compound)) {
+                    compounds.push(compound);
                 }
             }
         }
-        return {
-            uri: configUri,
-            configurations
-        };
+        return { uri: configUri, configurations, compounds };
     }
 
 }
@@ -86,5 +94,6 @@ export namespace DebugConfigurationModel {
     export interface JsonContent {
         uri?: URI
         configurations: DebugConfiguration[]
+        compounds: DebugCompound[]
     }
 }

package/src/browser/debug-contribution.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { DebugProtocol } from 'vscode-debugprotocol';
+import { DebugProtocol } from '@vscode/debugprotocol';
 import { DebugSessionConnection } from './debug-session-connection';
 
 export const DebugContribution = Symbol('DebugContribution');

package/src/browser/debug-frontend-application-contribution.ts

@@ -1122,8 +1122,9 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             await this.configurations.addConfiguration();
             return;
         }
-        if (current) {
-            if (noDebug !== undefined) {
+
+        if (noDebug !== undefined) {
+            if (current.configuration) {
                 current = {
                     ...current,
                     configuration: {
@@ -1131,9 +1132,15 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
                         noDebug
                     }
                 };
+            } else {
+                current = {
+                    ...current,
+                    noDebug
+                };
             }
-            await this.manager.start(current);
         }
+
+        await this.manager.start(current);
     }
 
     get threads(): DebugThreadsWidget | undefined {

package/src/browser/debug-prefix-configuration.ts

@@ -113,7 +113,7 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
 
         for (const config of configurations) {
             items.push({
-                label: config.configuration.name,
+                label: config.name,
                 description: this.workspaceService.isMultiRootWorkspaceOpened
                     ? this.labelProvider.getName(new URI(config.workspaceFolderUri))
                     : '',
@@ -134,7 +134,7 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
             for (const configuration of dynamicConfigurations) {
                 items.push({
                     label: configuration.name,
-                    execute: () => this.runConfiguration({ configuration, providerType })
+                    execute: () => this.runConfiguration({ name: configuration.name, configuration, providerType })
                 });
             }
         }
@@ -170,7 +170,7 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
      */
     protected updateStatusBar(): void {
         const text: string = this.debugConfigurationManager.current
-            ? this.debugConfigurationManager.current.configuration.name
+            ? this.debugConfigurationManager.current.name
             : '';
         const icon = '$(codicon-debug-alt-small)';
         this.statusBar.setElement(this.statusBarId, {

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-connection.ts

@@ -16,7 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { DebugProtocol } from 'vscode-debugprotocol';
+import { DebugProtocol } from '@vscode/debugprotocol';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { Event, Emitter, DisposableCollection, Disposable, MaybePromise } from '@theia/core';
 import { OutputChannel } from '@theia/output/lib/browser/output-channel';

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;