@theia/plugin-ext 1.28.0-next.7 → 1.28.0

package/src/main/browser/menus/plugin-menu-command-adapter.ts

@@ -0,0 +1,259 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { CommandRegistry, Disposable, MenuCommandAdapter, MenuPath, SelectionService, UriSelection } from '@theia/core';
+import { ResourceContextKey } from '@theia/core/lib/browser/resource-context-key';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
+import { TreeWidgetSelection } from '@theia/core/lib/browser/tree/tree-widget-selection';
+import { ScmRepository } from '@theia/scm/lib/browser/scm-repository';
+import { ScmService } from '@theia/scm/lib/browser/scm-service';
+import { TimelineItem } from '@theia/timeline/lib/common/timeline-model';
+import { ScmCommandArg, TimelineCommandArg, TreeViewSelection } from '../../../common';
+import { PluginScmProvider, PluginScmResource, PluginScmResourceGroup } from '../scm-main';
+import { TreeViewWidget } from '../view/tree-view-widget';
+import { CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint } from './vscode-theia-menu-mappings';
+import { TAB_BAR_TOOLBAR_CONTEXT_MENU } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+
+export type ArgumentAdapter = (...args: unknown[]) => unknown[];
+
+export class ReferenceCountingSet<T> {
+    protected readonly references: Map<T, number>;
+    constructor(initialMembers?: Iterable<T>) {
+        this.references = new Map();
+        if (initialMembers) {
+            for (const member of initialMembers) {
+                this.add(member);
+            }
+        }
+    }
+
+    add(newMember: T): ReferenceCountingSet<T> {
+        const value = this.references.get(newMember) ?? 0;
+        this.references.set(newMember, value + 1);
+        return this;
+    }
+
+    /** @returns true if the deletion results in the removal of the element from the set */
+    delete(member: T): boolean {
+        const value = this.references.get(member);
+        if (value === undefined) { } else if (value <= 1) {
+            this.references.delete(member);
+            return true;
+        } else {
+            this.references.set(member, value - 1);
+        }
+        return false;
+    }
+
+    has(maybeMember: T): boolean {
+        return this.references.has(maybeMember);
+    }
+}
+
+@injectable()
+export class PluginMenuCommandAdapter implements MenuCommandAdapter {
+    @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
+    @inject(CodeEditorWidgetUtil) protected readonly codeEditorUtil: CodeEditorWidgetUtil;
+    @inject(ScmService) protected readonly scmService: ScmService;
+    @inject(SelectionService) protected readonly selectionService: SelectionService;
+    @inject(ResourceContextKey) protected readonly resourceContextKey: ResourceContextKey;
+
+    protected readonly commands = new ReferenceCountingSet<string>();
+    protected readonly argumentAdapters = new Map<string, ArgumentAdapter>();
+    protected readonly separator = ':)(:';
+
+    @postConstruct()
+    protected init(): void {
+        const toCommentArgs: ArgumentAdapter = (...args) => this.toCommentArgs(...args);
+        const firstArgOnly: ArgumentAdapter = (...args) => [args[0]];
+        const noArgs: ArgumentAdapter = () => [];
+        const toScmArgs: ArgumentAdapter = (...args) => this.toScmArgs(...args);
+        const selectedResource = () => this.getSelectedResources();
+        const widgetURI: ArgumentAdapter = widget => this.codeEditorUtil.is(widget) ? [this.codeEditorUtil.getResourceUri(widget)] : [];
+        (<Array<[ContributionPoint, ArgumentAdapter | undefined]>>[
+            ['comments/comment/context', toCommentArgs],
+            ['comments/comment/title', toCommentArgs],
+            ['comments/commentThread/context', toCommentArgs],
+            ['debug/callstack/context', firstArgOnly],
+            ['debug/toolBar', noArgs],
+            ['editor/context', selectedResource],
+            ['editor/title', widgetURI],
+            ['editor/title/context', selectedResource],
+            ['explorer/context', selectedResource],
+            ['scm/resourceFolder/context', toScmArgs],
+            ['scm/resourceGroup/context', toScmArgs],
+            ['scm/resourceState/context', toScmArgs],
+            ['scm/title', () => this.toScmArg(this.scmService.selectedRepository)],
+            ['timeline/item/context', (...args) => this.toTimelineArgs(...args)],
+            ['view/item/context', (...args) => this.toTreeArgs(...args)],
+            ['view/title', noArgs],
+        ]).forEach(([contributionPoint, adapter]) => {
+            if (adapter) {
+                const paths = codeToTheiaMappings.get(contributionPoint);
+                if (paths) {
+                    paths.forEach(([path]) => this.addArgumentAdapter(path, adapter));
+                }
+            }
+        });
+        this.addArgumentAdapter(TAB_BAR_TOOLBAR_CONTEXT_MENU, widgetURI);
+    }
+
+    canHandle(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): number {
+        if (this.commands.has(command) && this.getArgumentAdapterForMenu(menuPath)) {
+            return 500;
+        }
+        return -1;
+    }
+
+    executeCommand(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): Promise<unknown> {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.executeCommand(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isVisible(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isVisible(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isEnabled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isEnabled(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isToggled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isToggled(command, ...argumentAdapter(...commandArgs));
+    }
+
+    protected getAdapterOrThrow(menuPath: MenuPath): ArgumentAdapter {
+        const argumentAdapter = this.getArgumentAdapterForMenu(menuPath);
+        if (!argumentAdapter) {
+            throw new Error('PluginMenuCommandAdapter attempted to execute command for unregistered menu: ' + JSON.stringify(menuPath));
+        }
+        return argumentAdapter;
+    }
+
+    addCommand(commandId: string): Disposable {
+        this.commands.add(commandId);
+        return Disposable.create(() => this.commands.delete(commandId));
+    }
+
+    protected getArgumentAdapterForMenu(menuPath: MenuPath): ArgumentAdapter | undefined {
+        return this.argumentAdapters.get(menuPath.join(this.separator));
+    }
+
+    protected addArgumentAdapter(menuPath: MenuPath, adapter: ArgumentAdapter): void {
+        this.argumentAdapters.set(menuPath.join(this.separator), adapter);
+    }
+
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+
+    protected toCommentArgs(...args: any[]): any[] {
+        const arg = args[0];
+        if ('text' in arg) {
+            if ('commentUniqueId' in arg) {
+                return [{
+                    commentControlHandle: arg.thread.controllerHandle,
+                    commentThreadHandle: arg.thread.commentThreadHandle,
+                    text: arg.text,
+                    commentUniqueId: arg.commentUniqueId
+                }];
+            }
+            return [{
+                commentControlHandle: arg.thread.controllerHandle,
+                commentThreadHandle: arg.thread.commentThreadHandle,
+                text: arg.text
+            }];
+        }
+        return [{
+            commentControlHandle: arg.thread.controllerHandle,
+            commentThreadHandle: arg.thread.commentThreadHandle,
+            commentUniqueId: arg.commentUniqueId
+        }];
+    }
+
+    protected toScmArgs(...args: any[]): any[] {
+        const scmArgs: any[] = [];
+        for (const arg of args) {
+            const scmArg = this.toScmArg(arg);
+            if (scmArg) {
+                scmArgs.push(scmArg);
+            }
+        }
+        return scmArgs;
+    }
+
+    protected toScmArg(arg: any): ScmCommandArg | undefined {
+        if (arg instanceof ScmRepository && arg.provider instanceof PluginScmProvider) {
+            return {
+                sourceControlHandle: arg.provider.handle
+            };
+        }
+        if (arg instanceof PluginScmResourceGroup) {
+            return {
+                sourceControlHandle: arg.provider.handle,
+                resourceGroupHandle: arg.handle
+            };
+        }
+        if (arg instanceof PluginScmResource) {
+            return {
+                sourceControlHandle: arg.group.provider.handle,
+                resourceGroupHandle: arg.group.handle,
+                resourceStateHandle: arg.handle
+            };
+        }
+    }
+
+    protected toTimelineArgs(...args: any[]): any[] {
+        const timelineArgs: any[] = [];
+        const arg = args[0];
+        timelineArgs.push(this.toTimelineArg(arg));
+        timelineArgs.push(CodeUri.parse(arg.uri));
+        timelineArgs.push(arg.source ?? '');
+        return timelineArgs;
+    }
+
+    protected toTimelineArg(arg: TimelineItem): TimelineCommandArg {
+        return {
+            timelineHandle: arg.handle,
+            source: arg.source,
+            uri: arg.uri
+        };
+    }
+
+    protected toTreeArgs(...args: any[]): any[] {
+        const treeArgs: any[] = [];
+        for (const arg of args) {
+            if (TreeViewSelection.is(arg)) {
+                treeArgs.push(arg);
+            }
+        }
+        return treeArgs;
+    }
+
+    protected getSelectedResources(): [CodeUri | TreeViewSelection | undefined, CodeUri[] | undefined] {
+        const selection = this.selectionService.selection;
+        const firstMember = TreeWidgetSelection.is(selection) && selection.source instanceof TreeViewWidget && selection[0]
+            ? selection.source.toTreeViewSelection(selection[0])
+            : (UriSelection.getUri(selection) ?? this.resourceContextKey.get())?.['codeUri'];
+        const secondMember = TreeWidgetSelection.is(selection)
+            ? UriSelection.getUris(selection).map(uri => uri['codeUri'])
+            : undefined;
+        return [firstMember, secondMember];
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+}

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { MenuPath } from '@theia/core';
+import { SHELL_TABBAR_CONTEXT_MENU } from '@theia/core/lib/browser';
+import { Navigatable } from '@theia/core/lib/browser/navigatable';
+import { injectable } from '@theia/core/shared/inversify';
+import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
+import { DebugStackFramesWidget } from '@theia/debug/lib/browser/view/debug-stack-frames-widget';
+import { DebugThreadsWidget } from '@theia/debug/lib/browser/view/debug-threads-widget';
+import { EditorWidget, EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
+import { NAVIGATOR_CONTEXT_MENU } from '@theia/navigator/lib/browser/navigator-contribution';
+import { ScmTreeWidget } from '@theia/scm/lib/browser/scm-tree-widget';
+import { TIMELINE_ITEM_CONTEXT_MENU } from '@theia/timeline/lib/browser/timeline-tree-widget';
+import { COMMENT_CONTEXT, COMMENT_THREAD_CONTEXT, COMMENT_TITLE } from '../comments/comment-thread-widget';
+import { VIEW_ITEM_CONTEXT_MENU } from '../view/tree-view-widget';
+import { WebviewWidget } from '../webview/webview';
+
+export const PLUGIN_EDITOR_TITLE_MENU = ['plugin_editor/title'];
+export const PLUGIN_SCM_TITLE_MENU = ['plugin_scm/title'];
+export const PLUGIN_VIEW_TITLE_MENU = ['plugin_view/title'];
+
+export const implementedVSCodeContributionPoints = [
+    'comments/comment/context',
+    'comments/comment/title',
+    'comments/commentThread/context',
+    'debug/callstack/context',
+    'editor/context',
+    'editor/title',
+    'editor/title/context',
+    'explorer/context',
+    'scm/resourceFolder/context',
+    'scm/resourceGroup/context',
+    'scm/resourceState/context',
+    'scm/title',
+    'timeline/item/context',
+    'view/item/context',
+    'view/title'
+] as const;
+
+export type ContributionPoint = (typeof implementedVSCodeContributionPoints)[number];
+
+/** The values are combinations of MenuPath and `when` clause, if any */
+export const codeToTheiaMappings = new Map<ContributionPoint, Array<[MenuPath] | [MenuPath, string]>>([
+    ['comments/comment/context', [[COMMENT_CONTEXT]]],
+    ['comments/comment/title', [[COMMENT_TITLE]]],
+    ['comments/commentThread/context', [[COMMENT_THREAD_CONTEXT]]],
+    ['debug/callstack/context', [[DebugStackFramesWidget.CONTEXT_MENU], [DebugThreadsWidget.CONTEXT_MENU]]],
+    ['editor/context', [[EDITOR_CONTEXT_MENU]]],
+    ['editor/title', [[PLUGIN_EDITOR_TITLE_MENU]]],
+    ['editor/title/context', [[SHELL_TABBAR_CONTEXT_MENU, 'resourceSet']]],
+    ['explorer/context', [[NAVIGATOR_CONTEXT_MENU]]],
+    ['scm/resourceFolder/context', [[ScmTreeWidget.RESOURCE_FOLDER_CONTEXT_MENU]]],
+    ['scm/resourceGroup/context', [[ScmTreeWidget.RESOURCE_GROUP_CONTEXT_MENU]]],
+    ['scm/resourceState/context', [[ScmTreeWidget.RESOURCE_CONTEXT_MENU]]],
+    ['scm/title', [[PLUGIN_SCM_TITLE_MENU]]],
+    ['timeline/item/context', [[TIMELINE_ITEM_CONTEXT_MENU]]],
+    ['view/item/context', [[VIEW_ITEM_CONTEXT_MENU]]],
+    ['view/title', [[PLUGIN_VIEW_TITLE_MENU]]],
+]);
+
+type CodeEditorWidget = EditorWidget | WebviewWidget;
+@injectable()
+export class CodeEditorWidgetUtil {
+    is(arg: unknown): arg is CodeEditorWidget {
+        return arg instanceof EditorWidget || arg instanceof WebviewWidget;
+    }
+    getResourceUri(editor: CodeEditorWidget): CodeUri | undefined {
+        const resourceUri = Navigatable.is(editor) && editor.getResourceUri();
+        return resourceUri ? resourceUri['codeUri'] : undefined;
+    }
+}

package/src/main/browser/plugin-contribution-handler.ts

@@ -222,7 +222,9 @@ export class PluginContributionHandler {
                     pushContribution(`grammar.language.${language}.scope`, () => this.grammarsRegistry.mapLanguageIdToTextmateGrammar(language, grammar.scope));
                     pushContribution(`grammar.language.${language}.configuration`, () => this.grammarsRegistry.registerGrammarConfiguration(language, {
                         embeddedLanguages: this.convertEmbeddedLanguages(grammar.embeddedLanguages, logWarning),
-                        tokenTypes: this.convertTokenTypes(grammar.tokenTypes)
+                        tokenTypes: this.convertTokenTypes(grammar.tokenTypes),
+                        balancedBracketSelectors: grammar.balancedBracketScopes ?? ['*'],
+                        unbalancedBracketSelectors: grammar.balancedBracketScopes,
                     }));
                 }
                 // activate grammars only once everything else is loaded.

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -33,9 +33,8 @@ import { HostedPluginServer, hostedServicePath, PluginServer, pluginServerJsonRp
 import { ModalNotification } from './dialogs/modal-notification';
 import { PluginWidget } from './plugin-ext-widget';
 import { PluginFrontendViewContribution } from './plugin-frontend-view-contribution';
-import { PluginExtDeployCommandService } from './plugin-ext-deploy-command';
 import { EditorModelService } from './text-editor-model-service';
-import { CodeEditorWidgetUtil, MenusContributionPointHandler } from './menus/menus-contribution-handler';
+import { MenusContributionPointHandler } from './menus/menus-contribution-handler';
 import { PluginContributionHandler } from './plugin-contribution-handler';
 import { PluginViewRegistry, PLUGIN_VIEW_CONTAINER_FACTORY_ID, PLUGIN_VIEW_FACTORY_ID, PLUGIN_VIEW_DATA_FACTORY_ID } from './view/plugin-view-registry';
 import { TextContentResourceResolver } from './workspace-main';
@@ -78,6 +77,8 @@ import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-secu
 import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
 import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
 import { bindTreeViewDecoratorUtilities, TreeViewDecoratorService } from './view/tree-view-decorator-service';
+import { CodeEditorWidgetUtil } from './menus/vscode-theia-menu-mappings';
+import { PluginMenuCommandAdapter } from './menus/plugin-menu-command-adapter';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -131,7 +132,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
         createWidget: () => ctx.container.get(PluginWidget)
     }));
 
-    bind(PluginExtDeployCommandService).toSelf().inSingletonScope();
     bind(PluginServer).toDynamicValue(ctx => {
         const provider = ctx.container.get(WebSocketConnectionProvider);
         return provider.createProxy<PluginServer>(pluginServerJsonRpcPath);
@@ -213,6 +213,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(LabelProviderContribution).toService(PluginIconThemeService);
 
     bind(MenusContributionPointHandler).toSelf().inSingletonScope();
+    bind(PluginMenuCommandAdapter).toSelf().inSingletonScope();
     bind(CodeEditorWidgetUtil).toSelf().inSingletonScope();
     bind(KeybindingsContributionPointHandler).toSelf().inSingletonScope();
     bind(PluginContributionHandler).toSelf().inSingletonScope();

package/src/main/browser/plugin-frontend-contribution.ts

@@ -16,25 +16,16 @@
 
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { CommandRegistry, CommandContribution } from '@theia/core/lib/common';
-import { PluginExtDeployCommandService } from './plugin-ext-deploy-command';
 import { OpenUriCommandHandler } from './commands';
 import URI from '@theia/core/lib/common/uri';
 
 @injectable()
 export class PluginApiFrontendContribution implements CommandContribution {
 
-    @inject(PluginExtDeployCommandService)
-    protected readonly pluginExtDeployCommandService: PluginExtDeployCommandService;
-
     @inject(OpenUriCommandHandler)
     protected readonly openUriCommandHandler: OpenUriCommandHandler;
 
     registerCommands(commands: CommandRegistry): void {
-
-        commands.registerCommand(PluginExtDeployCommandService.COMMAND, {
-            execute: () => this.pluginExtDeployCommandService.deploy()
-        });
-
         commands.registerCommand(OpenUriCommandHandler.COMMAND_METADATA, {
             execute: (arg: URI) => this.openUriCommandHandler.execute(arg),
             isVisible: () => false

package/src/main/browser/plugin-shared-style.ts

@@ -111,7 +111,6 @@ export class PluginSharedStyle {
         const iconClass = 'plugin-icon-' + this.iconSequence++;
         const toDispose = new DisposableCollection();
         toDispose.push(this.insertRule('.' + iconClass, theme => `
-                display: inline-block;
                 background-position: 2px;
                 width: ${size}px;
                 height: ${size}px;

package/src/main/browser/scm-main.ts

@@ -430,4 +430,14 @@ export class ScmMainImpl implements ScmMain {
 
         repository.input.placeholder = placeholder;
     }
+
+    $setInputBoxVisible(sourceControlHandle: number, visible: boolean): void {
+        const repository = this.repositories.get(sourceControlHandle);
+
+        if (!repository) {
+            return;
+        }
+
+        repository.input.visible = visible;
+    }
 }

package/src/main/browser/view/tree-view-widget.tsx

@@ -399,14 +399,14 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     protected renderInlineCommand(node: ActionMenuNode, index: number, tabbable: boolean, arg: any): React.ReactNode {
         const { icon } = node;
-        if (!icon || !this.commands.isVisible(node.action.commandId, arg) || !node.action.when || !this.contextKeys.match(node.action.when)) {
+        if (!icon || !this.commands.isVisible(node.command, arg) || !node.when || !this.contextKeys.match(node.when)) {
             return false;
         }
         const className = [TREE_NODE_SEGMENT_CLASS, TREE_NODE_TAIL_CLASS, icon, ACTION_ITEM, 'theia-tree-view-inline-action'].join(' ');
         const tabIndex = tabbable ? 0 : undefined;
         return <div key={index} className={className} title={node.label} tabIndex={tabIndex} onClick={e => {
             e.stopPropagation();
-            this.commands.executeCommand(node.action.commandId, arg);
+            this.commands.executeCommand(node.command, arg);
         }} />;
     }
 

package/src/main/node/handlers/plugin-theia-file-handler.ts

@@ -14,7 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as path from 'path';
 import { PluginDeployerFileHandler, PluginDeployerEntry, PluginDeployerFileHandlerContext, PluginType } from '../../../common/plugin-protocol';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { getTempDir } from '../temp-dir-util';
@@ -22,7 +21,6 @@ import * as fs from '@theia/core/shared/fs-extra';
 import * as filenamify from 'filenamify';
 import { FileUri } from '@theia/core/lib/node/file-uri';
 import { PluginTheiaEnvironment } from '../../common/plugin-theia-environment';
-import URI from '@theia/core/lib/common/uri';
 
 @injectable()
 export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
@@ -37,7 +35,6 @@ export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
     }
 
     async handle(context: PluginDeployerFileHandlerContext): Promise<void> {
-        await this.ensureDiscoverability(context);
         const id = context.pluginEntry().id();
         const pluginDir = await this.getPluginDir(context);
         console.log(`[${id}]: trying to decompress into "${pluginDir}"...`);
@@ -51,29 +48,6 @@ export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
         context.pluginEntry().updatePath(pluginDir);
     }
 
-    /**
-     * Ensures that a user-installed plugin file is transferred to the user extension folder.
-     */
-    protected async ensureDiscoverability(context: PluginDeployerFileHandlerContext): Promise<void> {
-        if (context.pluginEntry().type === PluginType.User) {
-            const userExtensionsDir = await this.environment.getPluginsDirUri();
-            const currentPath = context.pluginEntry().path();
-            if (!userExtensionsDir.isEqualOrParent(new URI(currentPath)) && !userExtensionsDir.isEqualOrParent(new URI(context.pluginEntry().originalPath()))) {
-                try {
-                    const newPath = FileUri.fsPath(userExtensionsDir.resolve(path.basename(currentPath)));
-                    await fs.mkdirp(FileUri.fsPath(userExtensionsDir));
-                    await new Promise<void>((resolve, reject) => {
-                        fs.copyFile(currentPath, newPath, error => error ? reject(error) : resolve());
-                    });
-                    context.pluginEntry().updatePath(newPath);
-                    context.pluginEntry().storeValue('sourceLocations', [newPath]);
-                } catch (e) {
-                    console.error(`[${context.pluginEntry().id}]: Failed to copy to user directory. Future sessions may not have access to this plugin.`);
-                }
-            }
-        }
-    }
-
     protected async getPluginDir(context: PluginDeployerFileHandlerContext): Promise<string> {
         return FileUri.fsPath(this.systemPluginsDirUri.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
     }

package/src/main/node/plugin-ext-backend-module.ts

@@ -25,7 +25,6 @@ import {
     PluginDeployerDirectoryHandler, PluginServer, pluginServerJsonRpcPath, PluginDeployerParticipant
 } from '../../common/plugin-protocol';
 import { PluginDeployerImpl } from './plugin-deployer-impl';
-import { LocalFilePluginDeployerResolver } from './resolvers/local-file-plugin-deployer-resolver';
 import { LocalDirectoryPluginDeployerResolver } from './resolvers/local-directory-plugin-deployer-resolver';
 import { PluginTheiaFileHandler } from './handlers/plugin-theia-file-handler';
 import { PluginTheiaDirectoryHandler } from './handlers/plugin-theia-directory-handler';
@@ -54,7 +53,6 @@ export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginUninstallationManager).toSelf().inSingletonScope();
 
     bind(PluginDeployerResolver).to(LocalDirectoryPluginDeployerResolver).inSingletonScope();
-    bind(PluginDeployerResolver).to(LocalFilePluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(GithubPluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(HttpPluginDeployerResolver).inSingletonScope();
 

package/src/main/node/resolvers/local-plugin-deployer-resolver.ts

@@ -23,16 +23,14 @@ import URI from '@theia/core/lib/common/uri';
 
 @injectable()
 export abstract class LocalPluginDeployerResolver implements PluginDeployerResolver {
-    public async resolve(pluginResolverContext: PluginDeployerResolverContext): Promise<void> {
-        const localPath = await this.resolveLocalPluginPath(
-            pluginResolverContext,
-            this.supportedScheme);
+    async resolve(pluginResolverContext: PluginDeployerResolverContext): Promise<void> {
+        const localPath = await this.resolveLocalPluginPath(pluginResolverContext, this.supportedScheme);
         if (localPath) {
             await this.resolveFromLocalPath(pluginResolverContext, localPath);
         }
     }
 
-    public accept(pluginId: string): boolean {
+    accept(pluginId: string): boolean {
         return pluginId.startsWith(this.supportedScheme);
     }
 
@@ -40,9 +38,7 @@ export abstract class LocalPluginDeployerResolver implements PluginDeployerResol
 
     protected abstract resolveFromLocalPath(pluginResolverContext: PluginDeployerResolverContext, localPath: string): Promise<void>;
 
-    private async resolveLocalPluginPath(
-        pluginResolverContext: PluginDeployerResolverContext,
-        expectedScheme: string): Promise<string | null> {
+    private async resolveLocalPluginPath(pluginResolverContext: PluginDeployerResolverContext, expectedScheme: string): Promise<string | null> {
         const localUri = new URI(pluginResolverContext.getOriginId());
         if (localUri.scheme !== expectedScheme) {
             return null;

package/src/plugin/debug/debug-ext.ts

@@ -23,13 +23,15 @@ import { PluginPackageDebuggersContribution } from '../../common/plugin-protocol
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { CommandRegistryImpl } from '../command-registry';
 import { ConnectionImpl } from '../../common/connection';
-import { Disposable, Breakpoint as BreakpointExt, SourceBreakpoint, FunctionBreakpoint, Location, Range } from '../types-impl';
+import { DEBUG_SCHEME, SCHEME_PATTERN } from '@theia/debug/lib/common/debug-uri-utils';
+import { Disposable, Breakpoint as BreakpointExt, SourceBreakpoint, FunctionBreakpoint, Location, Range, URI as URIImpl } from '../types-impl';
 import { PluginDebugAdapterSession } from './plugin-debug-adapter-session';
 import { PluginDebugAdapterTracker } from './plugin-debug-adapter-tracker';
 import uuid = require('uuid');
 import { DebugAdapter } from '@theia/debug/lib/common/debug-model';
 import { PluginDebugAdapterCreator } from './plugin-debug-adapter-creator';
 import { NodeDebugAdapterCreator } from '../node/debug/plugin-node-debug-adapter-creator';
+import { DebugProtocol } from 'vscode-debugprotocol';
 
 interface ConfigurationProviderRecord {
     handle: number;
@@ -176,6 +178,27 @@ export class DebugExtImpl implements DebugExt {
         return this.proxy.$stopDebugging(session?.id);
     }
 
+    asDebugSourceUri(source: theia.DebugProtocolSource, session?: theia.DebugSession): theia.Uri {
+        return this.getDebugSourceUri(source, session?.id);
+    }
+
+    private getDebugSourceUri(raw: DebugProtocol.Source, sessionId?: string): theia.Uri {
+        if (raw.sourceReference && raw.sourceReference > 0) {
+            let query = 'ref=' + String(raw.sourceReference);
+            if (sessionId) {
+                query += `&session=${sessionId}`;
+            }
+            return URIImpl.from({ scheme: DEBUG_SCHEME, path: raw.path ?? '', query });
+        }
+        if (!raw.path) {
+            throw new Error('Unrecognized source type: ' + JSON.stringify(raw));
+        }
+        if (raw.path.match(SCHEME_PATTERN)) {
+            return URIImpl.parse(raw.path);
+        }
+        return URIImpl.file(raw.path);
+    }
+
     registerDebugAdapterDescriptorFactory(debugType: string, factory: theia.DebugAdapterDescriptorFactory): Disposable {
         if (this.descriptorFactories.has(debugType)) {
             throw new Error(`Descriptor factory for ${debugType} has been already registered`);
@@ -279,13 +302,13 @@ export class DebugExtImpl implements DebugExt {
         this.onDidChangeBreakpointsEmitter.fire({ added: a, removed: r, changed: c });
     }
 
-    protected toBreakpointExt({ functionName, location, enabled, condition, hitCondition, logMessage }: Breakpoint): BreakpointExt | undefined {
+    protected toBreakpointExt({ functionName, location, enabled, condition, hitCondition, logMessage, id }: Breakpoint): BreakpointExt | undefined {
         if (location) {
             const range = new Range(location.range.startLineNumber, location.range.startColumn, location.range.endLineNumber, location.range.endColumn);
-            return new SourceBreakpoint(new Location(URI.revive(location.uri), range), enabled, condition, hitCondition, logMessage);
+            return new SourceBreakpoint(new Location(URI.revive(location.uri), range), enabled, condition, hitCondition, logMessage, id);
         }
         if (functionName) {
-            return new FunctionBreakpoint(functionName!, enabled, condition, hitCondition, logMessage);
+            return new FunctionBreakpoint(functionName!, enabled, condition, hitCondition, logMessage, id);
         }
         return undefined;
     }
@@ -305,7 +328,9 @@ export class DebugExtImpl implements DebugExt {
                     return response.body;
                 }
                 return Promise.reject(new Error(response.message ?? 'custom request failed'));
-            }
+            },
+            getDebugProtocolBreakpoint: async (breakpoint: Breakpoint) =>
+                this.proxy.$getDebugProtocolBreakpoint(sessionId, breakpoint.id)
         };
 
         const tracker = await this.createDebugAdapterTracker(theiaSession);

package/src/plugin/debug/plugin-debug-adapter-session.ts

@@ -61,6 +61,10 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
         return this.theiaSession.customRequest(command, args);
     }
 
+    async getDebugProtocolBreakpoint(breakpoint: theia.Breakpoint): Promise<theia.DebugProtocolBreakpoint | undefined> {
+        return this.theiaSession.getDebugProtocolBreakpoint(breakpoint);
+    }
+
     protected override onDebugAdapterError(error: Error): void {
         if (this.tracker.onError) {
             this.tracker.onError(error);