@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/debug/browser/debugConfigurationManager.js

@@ -0,0 +1,621 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { sequence } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource, CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { debugConfigure } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { CONTEXT_DEBUG_CONFIGURATION_TYPE, DebugConfigurationProviderTriggerKind } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { launchSchema } from '../common/debugSchemas.js';
+import { getVisibleAndSorted } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+import { launchSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/common/history';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+
+const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
+jsonRegistry.registerSchema(launchSchemaId, launchSchema);
+const DEBUG_SELECTED_CONFIG_NAME_KEY = 'debug.selectedconfigname';
+const DEBUG_SELECTED_ROOT = 'debug.selectedroot';
+const DEBUG_SELECTED_TYPE = 'debug.selectedtype';
+const DEBUG_RECENT_DYNAMIC_CONFIGURATIONS = 'debug.recentdynamicconfigurations';
+let ConfigurationManager = class ConfigurationManager {
+    constructor(adapterManager, contextService, configurationService, quickInputService, instantiationService, storageService, extensionService, historyService, uriIdentityService, contextKeyService) {
+        this.adapterManager = adapterManager;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.quickInputService = quickInputService;
+        this.instantiationService = instantiationService;
+        this.storageService = storageService;
+        this.extensionService = extensionService;
+        this.historyService = historyService;
+        this.uriIdentityService = uriIdentityService;
+        this.getSelectedConfig = () => Promise.resolve(undefined);
+        this.selectedDynamic = false;
+        this._onDidSelectConfigurationName = ( new Emitter());
+        this.configProviders = [];
+        this.toDispose = [];
+        this.initLaunches();
+        this.setCompoundSchemaValues();
+        this.registerListeners();
+        const previousSelectedRoot = this.storageService.get(DEBUG_SELECTED_ROOT, 1 );
+        const previousSelectedType = this.storageService.get(DEBUG_SELECTED_TYPE, 1 );
+        const previousSelectedLaunch = this.launches.find(l => ( l.uri.toString()) === previousSelectedRoot);
+        const previousSelectedName = this.storageService.get(DEBUG_SELECTED_CONFIG_NAME_KEY, 1 );
+        this.debugConfigurationTypeContext = CONTEXT_DEBUG_CONFIGURATION_TYPE.bindTo(contextKeyService);
+        const dynamicConfig = previousSelectedType ? { type: previousSelectedType } : undefined;
+        if (previousSelectedLaunch && previousSelectedLaunch.getConfigurationNames().length) {
+            this.selectConfiguration(previousSelectedLaunch, previousSelectedName, undefined, dynamicConfig);
+        }
+        else if (this.launches.length > 0) {
+            this.selectConfiguration(undefined, previousSelectedName, undefined, dynamicConfig);
+        }
+    }
+    registerDebugConfigurationProvider(debugConfigurationProvider) {
+        this.configProviders.push(debugConfigurationProvider);
+        return {
+            dispose: () => {
+                this.unregisterDebugConfigurationProvider(debugConfigurationProvider);
+            }
+        };
+    }
+    unregisterDebugConfigurationProvider(debugConfigurationProvider) {
+        const ix = this.configProviders.indexOf(debugConfigurationProvider);
+        if (ix >= 0) {
+            this.configProviders.splice(ix, 1);
+        }
+    }
+    hasDebugConfigurationProvider(debugType, triggerKind) {
+        if (triggerKind === undefined) {
+            triggerKind = DebugConfigurationProviderTriggerKind.Initial;
+        }
+        const provider = this.configProviders.find(p => p.provideDebugConfigurations && (p.type === debugType) && (p.triggerKind === triggerKind));
+        return !!provider;
+    }
+    async resolveConfigurationByProviders(folderUri, type, config, token) {
+        const resolveDebugConfigurationForType = async (type, config) => {
+            if (type !== '*') {
+                await this.adapterManager.activateDebuggers('onDebugResolve', type);
+            }
+            for (const p of this.configProviders) {
+                if (p.type === type && p.resolveDebugConfiguration && config) {
+                    config = await p.resolveDebugConfiguration(folderUri, config, token);
+                }
+            }
+            return config;
+        };
+        let resolvedType = config.type ?? type;
+        let result = config;
+        for (let seen = ( new Set()); result && !( seen.has(resolvedType));) {
+            seen.add(resolvedType);
+            result = await resolveDebugConfigurationForType(resolvedType, result);
+            result = await resolveDebugConfigurationForType('*', result);
+            resolvedType = result?.type ?? type;
+        }
+        return result;
+    }
+    async resolveDebugConfigurationWithSubstitutedVariables(folderUri, type, config, token) {
+        const providers = this.configProviders.filter(p => p.type === type && p.resolveDebugConfigurationWithSubstitutedVariables)
+            .concat(this.configProviders.filter(p => p.type === '*' && p.resolveDebugConfigurationWithSubstitutedVariables));
+        let result = config;
+        await sequence(( providers.map(provider => async () => {
+            if (result) {
+                result = await provider.resolveDebugConfigurationWithSubstitutedVariables(folderUri, result, token);
+            }
+        })));
+        return result;
+    }
+    async provideDebugConfigurations(folderUri, type, token) {
+        await this.adapterManager.activateDebuggers('onDebugInitialConfigurations');
+        const results = await Promise.all(( this.configProviders.filter(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Initial && p.provideDebugConfigurations).map(p => p.provideDebugConfigurations(folderUri, token))));
+        return results.reduce((first, second) => first.concat(second), []);
+    }
+    async getDynamicProviders() {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const onDebugDynamicConfigurationsName = 'onDebugDynamicConfigurations';
+        const debugDynamicExtensionsTypes = this.extensionService.extensions.reduce((acc, e) => {
+            if (!e.activationEvents) {
+                return acc;
+            }
+            const explicitTypes = [];
+            let hasGenericEvent = false;
+            for (const event of e.activationEvents) {
+                if (event === onDebugDynamicConfigurationsName) {
+                    hasGenericEvent = true;
+                }
+                else if (event.startsWith(`${onDebugDynamicConfigurationsName}:`)) {
+                    explicitTypes.push(event.slice(onDebugDynamicConfigurationsName.length + 1));
+                }
+            }
+            if (explicitTypes.length) {
+                return acc.concat(explicitTypes);
+            }
+            if (hasGenericEvent) {
+                const debuggerType = e.contributes?.debuggers?.[0].type;
+                return debuggerType ? acc.concat(debuggerType) : acc;
+            }
+            return acc;
+        }, []);
+        return ( debugDynamicExtensionsTypes.map(type => {
+            return {
+                label: this.adapterManager.getDebuggerLabel(type),
+                getProvider: async () => {
+                    await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
+                    return this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
+                },
+                type,
+                pick: async () => {
+                    await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
+                    const token = ( new CancellationTokenSource());
+                    const picks = [];
+                    const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
+                    this.getLaunches().forEach(launch => {
+                        if (launch.workspace && provider) {
+                            picks.push(provider.provideDebugConfigurations(launch.workspace.uri, token.token).then(configurations => ( configurations.map(config => ({
+                                label: config.name,
+                                description: launch.name,
+                                config,
+                                buttons: [{
+                                        iconClass: ThemeIcon.asClassName(debugConfigure),
+                                        tooltip: ( nls.localize('editLaunchConfig', "Edit Debug Configuration in launch.json"))
+                                    }],
+                                launch
+                            })))));
+                        }
+                    });
+                    const disposables = ( new DisposableStore());
+                    const input = disposables.add(this.quickInputService.createQuickPick());
+                    input.busy = true;
+                    input.placeholder = ( nls.localize('selectConfiguration', "Select Launch Configuration"));
+                    const chosenPromise = ( new Promise(resolve => {
+                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
+                        disposables.add(input.onDidTriggerItemButton(async (context) => {
+                            resolve(undefined);
+                            const { launch, config } = context.item;
+                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
+                            await launch.writeConfiguration(config);
+                            await this.selectConfiguration(launch, config.name);
+                            this.removeRecentDynamicConfigurations(config.name, config.type);
+                        }));
+                    }));
+                    const nestedPicks = await Promise.all(picks);
+                    const items = flatten(nestedPicks);
+                    input.items = items;
+                    input.busy = false;
+                    input.show();
+                    const chosen = await chosenPromise;
+                    disposables.dispose();
+                    if (!chosen) {
+                        token.cancel();
+                        return;
+                    }
+                    return chosen;
+                }
+            };
+        }));
+    }
+    getAllConfigurations() {
+        const all = [];
+        for (const l of this.launches) {
+            for (const name of l.getConfigurationNames()) {
+                const config = l.getConfiguration(name) || l.getCompound(name);
+                if (config) {
+                    all.push({ launch: l, name, presentation: config.presentation });
+                }
+            }
+        }
+        return getVisibleAndSorted(all);
+    }
+    removeRecentDynamicConfigurations(name, type) {
+        const remaining = this.getRecentDynamicConfigurations().filter(c => c.name !== name || c.type !== type);
+        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), 1 , 1 );
+        if (this.selectedConfiguration.name === name && this.selectedType === type && this.selectedDynamic) {
+            this.selectConfiguration(undefined, undefined);
+        }
+        else {
+            this._onDidSelectConfigurationName.fire();
+        }
+    }
+    getRecentDynamicConfigurations() {
+        return JSON.parse(this.storageService.get(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, 1 , '[]'));
+    }
+    registerListeners() {
+        this.toDispose.push(Event.any(this.contextService.onDidChangeWorkspaceFolders, this.contextService.onDidChangeWorkbenchState)(() => {
+            this.initLaunches();
+            this.selectConfiguration(undefined);
+            this.setCompoundSchemaValues();
+        }));
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration('launch')) {
+                await this.selectConfiguration(undefined);
+                this.setCompoundSchemaValues();
+            }
+        }));
+        this.toDispose.push(this.adapterManager.onDidDebuggersExtPointRead(() => {
+            this.setCompoundSchemaValues();
+        }));
+    }
+    initLaunches() {
+        this.launches = ( this.contextService.getWorkspace().folders.map(
+            folder => this.instantiationService.createInstance(Launch, this, this.adapterManager, folder)
+        ));
+        if (this.contextService.getWorkbenchState() === 3 ) {
+            this.launches.push(this.instantiationService.createInstance(WorkspaceLaunch, this, this.adapterManager));
+        }
+        this.launches.push(this.instantiationService.createInstance(UserLaunch, this, this.adapterManager));
+        if (this.selectedLaunch && this.launches.indexOf(this.selectedLaunch) === -1) {
+            this.selectConfiguration(undefined);
+        }
+    }
+    setCompoundSchemaValues() {
+        const compoundConfigurationsSchema = launchSchema.properties['compounds'].items.properties['configurations'];
+        const launchNames = ( this.launches.map(l => l.getConfigurationNames(true))).reduce((first, second) => first.concat(second), []);
+        compoundConfigurationsSchema.items.oneOf[0].enum = launchNames;
+        compoundConfigurationsSchema.items.oneOf[1].properties.name.enum = launchNames;
+        const folderNames = ( this.contextService.getWorkspace().folders.map(f => f.name));
+        compoundConfigurationsSchema.items.oneOf[1].properties.folder.enum = folderNames;
+        jsonRegistry.registerSchema(launchSchemaId, launchSchema);
+    }
+    getLaunches() {
+        return this.launches;
+    }
+    getLaunch(workspaceUri) {
+        if (!URI.isUri(workspaceUri)) {
+            return undefined;
+        }
+        return this.launches.find(l => l.workspace && this.uriIdentityService.extUri.isEqual(l.workspace.uri, workspaceUri));
+    }
+    get selectedConfiguration() {
+        return {
+            launch: this.selectedLaunch,
+            name: this.selectedName,
+            getConfig: this.getSelectedConfig,
+            type: this.selectedType
+        };
+    }
+    get onDidSelectConfiguration() {
+        return this._onDidSelectConfigurationName.event;
+    }
+    getWorkspaceLaunch() {
+        if (this.contextService.getWorkbenchState() === 3 ) {
+            return this.launches[this.launches.length - 1];
+        }
+        return undefined;
+    }
+    async selectConfiguration(launch, name, config, dynamicConfig) {
+        if (typeof launch === 'undefined') {
+            const rootUri = this.historyService.getLastActiveWorkspaceRoot();
+            launch = this.getLaunch(rootUri);
+            if (!launch || launch.getConfigurationNames().length === 0) {
+                launch = this.launches.find(l => !!(l && l.getConfigurationNames().length)) || launch || this.launches[0];
+            }
+        }
+        const previousLaunch = this.selectedLaunch;
+        const previousName = this.selectedName;
+        const previousSelectedDynamic = this.selectedDynamic;
+        this.selectedLaunch = launch;
+        if (this.selectedLaunch) {
+            this.storageService.store(DEBUG_SELECTED_ROOT, ( this.selectedLaunch.uri.toString()), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_SELECTED_ROOT, 1 );
+        }
+        const names = launch ? launch.getConfigurationNames() : [];
+        this.getSelectedConfig = () => {
+            const selected = this.selectedName ? launch?.getConfiguration(this.selectedName) : undefined;
+            return Promise.resolve(selected || config);
+        };
+        let type = config?.type;
+        if (name && names.indexOf(name) >= 0) {
+            this.setSelectedLaunchName(name);
+        }
+        else if (dynamicConfig && dynamicConfig.type) {
+            type = dynamicConfig.type;
+            if (!config) {
+                const providers = (await this.getDynamicProviders()).filter(p => p.type === type);
+                this.getSelectedConfig = async () => {
+                    const activatedProviders = await Promise.all(( providers.map(p => p.getProvider())));
+                    const provider = activatedProviders.length > 0 ? activatedProviders[0] : undefined;
+                    if (provider && launch && launch.workspace) {
+                        const token = ( new CancellationTokenSource());
+                        const dynamicConfigs = await provider.provideDebugConfigurations(launch.workspace.uri, token.token);
+                        const dynamicConfig = dynamicConfigs.find(c => c.name === name);
+                        if (dynamicConfig) {
+                            return dynamicConfig;
+                        }
+                    }
+                    return undefined;
+                };
+            }
+            this.setSelectedLaunchName(name);
+            let recentDynamicProviders = this.getRecentDynamicConfigurations();
+            if (name && dynamicConfig.type) {
+                recentDynamicProviders.unshift({ name, type: dynamicConfig.type });
+                recentDynamicProviders = distinct(recentDynamicProviders, t => `${t.name} : ${t.type}`);
+                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), 1 , 1 );
+            }
+        }
+        else if (!this.selectedName || names.indexOf(this.selectedName) === -1) {
+            const nameToSet = names.length ? names[0] : undefined;
+            this.setSelectedLaunchName(nameToSet);
+        }
+        if (!config && launch && this.selectedName) {
+            config = launch.getConfiguration(this.selectedName);
+            type = config?.type;
+        }
+        this.selectedType = dynamicConfig?.type || config?.type;
+        this.selectedDynamic = !!dynamicConfig;
+        this.storageService.store(DEBUG_SELECTED_TYPE, dynamicConfig ? this.selectedType : undefined, 1 , 1 );
+        if (type) {
+            this.debugConfigurationTypeContext.set(type);
+        }
+        else {
+            this.debugConfigurationTypeContext.reset();
+        }
+        if (this.selectedLaunch !== previousLaunch || this.selectedName !== previousName || previousSelectedDynamic !== this.selectedDynamic) {
+            this._onDidSelectConfigurationName.fire();
+        }
+    }
+    setSelectedLaunchName(selectedName) {
+        this.selectedName = selectedName;
+        if (this.selectedName) {
+            this.storageService.store(DEBUG_SELECTED_CONFIG_NAME_KEY, this.selectedName, 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_SELECTED_CONFIG_NAME_KEY, 1 );
+        }
+    }
+    dispose() {
+        this.toDispose = dispose(this.toDispose);
+    }
+};
+ConfigurationManager = ( __decorate([
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, IHistoryService)),
+    ( __param(8, IUriIdentityService)),
+    ( __param(9, IContextKeyService))
+], ConfigurationManager));
+class AbstractLaunch {
+    constructor(configurationManager, adapterManager) {
+        this.configurationManager = configurationManager;
+        this.adapterManager = adapterManager;
+    }
+    getCompound(name) {
+        const config = this.getConfig();
+        if (!config || !config.compounds) {
+            return undefined;
+        }
+        return config.compounds.find(compound => compound.name === name);
+    }
+    getConfigurationNames(ignoreCompoundsAndPresentation = false) {
+        const config = this.getConfig();
+        if (!config || (!Array.isArray(config.configurations) && !Array.isArray(config.compounds))) {
+            return [];
+        }
+        else {
+            const configurations = [];
+            if (config.configurations) {
+                configurations.push(...config.configurations.filter(cfg => cfg && typeof cfg.name === 'string'));
+            }
+            if (ignoreCompoundsAndPresentation) {
+                return ( configurations.map(c => c.name));
+            }
+            if (config.compounds) {
+                configurations.push(...config.compounds.filter(compound => typeof compound.name === 'string' && compound.configurations && compound.configurations.length));
+            }
+            return ( getVisibleAndSorted(configurations).map(c => c.name));
+        }
+    }
+    getConfiguration(name) {
+        const config = objects.deepClone(this.getConfig());
+        if (!config || !config.configurations) {
+            return undefined;
+        }
+        const configuration = config.configurations.find(config => config && config.name === name);
+        if (configuration) {
+            if (this instanceof UserLaunch) {
+                configuration.__configurationTarget = 2 ;
+            }
+            else if (this instanceof WorkspaceLaunch) {
+                configuration.__configurationTarget = 5 ;
+            }
+            else {
+                configuration.__configurationTarget = 6 ;
+            }
+        }
+        return configuration;
+    }
+    async getInitialConfigurationContent(folderUri, type, useInitialConfigs, token) {
+        let content = '';
+        const adapter = type ? this.adapterManager.getEnabledDebugger(type) : await this.adapterManager.guessDebugger(true);
+        if (adapter) {
+            const initialConfigs = useInitialConfigs ?
+                await this.configurationManager.provideDebugConfigurations(folderUri, adapter.type, token || CancellationToken.None) :
+                [];
+            content = await adapter.getInitialConfigurationContent(initialConfigs);
+        }
+        return content;
+    }
+    get hidden() {
+        return false;
+    }
+}
+let Launch = class Launch extends AbstractLaunch {
+    constructor(configurationManager, adapterManager, workspace, fileService, textFileService, editorService, configurationService) {
+        super(configurationManager, adapterManager);
+        this.workspace = workspace;
+        this.fileService = fileService;
+        this.textFileService = textFileService;
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+    }
+    get uri() {
+        return resources.joinPath(this.workspace.uri, '/.vscode/launch.json');
+    }
+    get name() {
+        return this.workspace.name;
+    }
+    getConfig() {
+        return this.configurationService.inspect('launch', { resource: this.workspace.uri }).workspaceFolderValue;
+    }
+    async openConfigFile({ preserveFocus, type, suppressInitialConfigs }, token) {
+        const resource = this.uri;
+        let created = false;
+        let content = '';
+        try {
+            const fileContent = await this.fileService.readFile(resource);
+            content = ( fileContent.value.toString());
+        }
+        catch {
+            content = await this.getInitialConfigurationContent(this.workspace.uri, type, !suppressInitialConfigs, token);
+            if (!content) {
+                return { editor: null, created: false };
+            }
+            created = true;
+            try {
+                await this.textFileService.write(resource, content);
+            }
+            catch (error) {
+                throw new Error(nls.localize('DebugConfig.failed', "Unable to create 'launch.json' file inside the '.vscode' folder ({0}).", error.message));
+            }
+        }
+        const index = content.indexOf(`"${this.configurationManager.selectedConfiguration.name}"`);
+        let startLineNumber = 1;
+        for (let i = 0; i < index; i++) {
+            if (content.charAt(i) === '\n') {
+                startLineNumber++;
+            }
+        }
+        const selection = startLineNumber > 1 ? { startLineNumber, startColumn: 4 } : undefined;
+        const editor = await this.editorService.openEditor({
+            resource,
+            options: {
+                selection,
+                preserveFocus,
+                pinned: created,
+                revealIfVisible: true
+            },
+        }, ACTIVE_GROUP);
+        return ({
+            editor: editor ?? null,
+            created
+        });
+    }
+    async writeConfiguration(configuration) {
+        const fullConfig = objects.deepClone(this.getConfig());
+        if (!fullConfig.configurations) {
+            fullConfig.configurations = [];
+        }
+        fullConfig.configurations.push(configuration);
+        await this.configurationService.updateValue('launch', fullConfig, { resource: this.workspace.uri }, 6 );
+    }
+};
+Launch = ( __decorate([
+    ( __param(3, IFileService)),
+    ( __param(4, ITextFileService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IConfigurationService))
+], Launch));
+let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
+    constructor(configurationManager, adapterManager, editorService, configurationService, contextService) {
+        super(configurationManager, adapterManager);
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.contextService = contextService;
+    }
+    get workspace() {
+        return undefined;
+    }
+    get uri() {
+        return this.contextService.getWorkspace().configuration;
+    }
+    get name() {
+        return ( nls.localize('workspace', "workspace"));
+    }
+    getConfig() {
+        return this.configurationService.inspect('launch').workspaceValue;
+    }
+    async openConfigFile({ preserveFocus, type, useInitialConfigs }, token) {
+        const launchExistInFile = !!this.getConfig();
+        if (!launchExistInFile) {
+            const content = await this.getInitialConfigurationContent(undefined, type, useInitialConfigs, token);
+            if (content) {
+                await this.configurationService.updateValue('launch', json.parse(content), 5 );
+            }
+            else {
+                return { editor: null, created: false };
+            }
+        }
+        const editor = await this.editorService.openEditor({
+            resource: this.contextService.getWorkspace().configuration,
+            options: { preserveFocus }
+        }, ACTIVE_GROUP);
+        return ({
+            editor: editor ?? null,
+            created: false
+        });
+    }
+};
+WorkspaceLaunch = ( __decorate([
+    ( __param(2, IEditorService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IWorkspaceContextService))
+], WorkspaceLaunch));
+let UserLaunch = class UserLaunch extends AbstractLaunch {
+    constructor(configurationManager, adapterManager, configurationService, preferencesService) {
+        super(configurationManager, adapterManager);
+        this.configurationService = configurationService;
+        this.preferencesService = preferencesService;
+    }
+    get workspace() {
+        return undefined;
+    }
+    get uri() {
+        return this.preferencesService.userSettingsResource;
+    }
+    get name() {
+        return ( nls.localize('user settings', "user settings"));
+    }
+    get hidden() {
+        return true;
+    }
+    getConfig() {
+        return this.configurationService.inspect('launch').userValue;
+    }
+    async openConfigFile({ preserveFocus, type, useInitialContent }) {
+        const editor = await this.preferencesService.openUserSettings({ jsonEditor: true, preserveFocus, revealSetting: { key: 'launch' } });
+        return ({
+            editor: editor ?? null,
+            created: false
+        });
+    }
+};
+UserLaunch = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IPreferencesService))
+], UserLaunch));
+
+export { ConfigurationManager };

package/vscode/src/vs/workbench/contrib/debug/browser/debugConsoleQuickAccess.js

@@ -0,0 +1,60 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { PickerQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, SELECT_AND_START_ID } from './debugCommands.js';
+import { REPL_VIEW_ID, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+
+let DebugConsoleQuickAccess = class DebugConsoleQuickAccess extends PickerQuickAccessProvider {
+    constructor(_debugService, _viewsService, _commandService) {
+        super(DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, { canAcceptInBackground: true });
+        this._debugService = _debugService;
+        this._viewsService = _viewsService;
+        this._commandService = _commandService;
+    }
+    _getPicks(filter, disposables, token) {
+        const debugConsolePicks = [];
+        this._debugService.getModel().getSessions(true).filter(s => s.hasSeparateRepl()).forEach((session, index) => {
+            const pick = this._createPick(session, index, filter);
+            if (pick) {
+                debugConsolePicks.push(pick);
+            }
+        });
+        if (debugConsolePicks.length > 0) {
+            debugConsolePicks.push({ type: 'separator' });
+        }
+        const createTerminalLabel = ( localize("workbench.action.debug.startDebug", "Start a New Debug Session"));
+        debugConsolePicks.push({
+            label: `$(plus) ${createTerminalLabel}`,
+            ariaLabel: createTerminalLabel,
+            accept: () => this._commandService.executeCommand(SELECT_AND_START_ID)
+        });
+        return debugConsolePicks;
+    }
+    _createPick(session, sessionIndex, filter) {
+        const label = session.name;
+        const highlights = matchesFuzzy(filter, label, true);
+        if (highlights) {
+            return {
+                label,
+                highlights: { label: highlights },
+                accept: (keyMod, event) => {
+                    this._debugService.focusStackFrame(undefined, undefined, session, { explicit: true });
+                    if (!this._viewsService.isViewVisible(REPL_VIEW_ID)) {
+                        this._viewsService.openView(REPL_VIEW_ID, true);
+                    }
+                }
+            };
+        }
+        return undefined;
+    }
+};
+DebugConsoleQuickAccess = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IViewsService)),
+    ( __param(2, ICommandService))
+], DebugConsoleQuickAccess));
+
+export { DebugConsoleQuickAccess };