@theia/plugin-ext-vscode 1.75.0-next.8 → 1.76.0-next.0

package/src/browser/plugin-vscode-commands-contribution.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Command, CommandContribution, CommandRegistry, environment, isOSX, CancellationTokenSource, MessageService, isArray } from '@theia/core';
+import { Command, CommandContribution, CommandRegistry, environment, isOSX, CancellationTokenSource, MessageService, isArray, ILogger } from '@theia/core';
 import {
     ApplicationShell,
     CommonCommands,
@@ -50,7 +50,7 @@ import { ViewColumn } from '@theia/plugin-ext/lib/plugin/types-impl';
 import { WorkspaceCommands } from '@theia/workspace/lib/browser';
 import { WorkspaceService, WorkspaceInput } from '@theia/workspace/lib/browser/workspace-service';
 import { DiffService } from '@theia/workspace/lib/browser/diff-service';
-import { inject, injectable, optional } from '@theia/core/shared/inversify';
+import { inject, injectable, optional, named } from '@theia/core/shared/inversify';
 import { Position } from '@theia/plugin-ext/lib/common/plugin-api-rpc';
 import { URI } from '@theia/core/shared/vscode-uri';
 import { PluginDeployOptions, PluginIdentifiers, PluginServer } from '@theia/plugin-ext/lib/common/plugin-protocol';
@@ -159,6 +159,88 @@ export interface HidDeviceData {
     readonly collections: [];
 }
 
+export type EditorGroupNavigationDirection = 'left' | 'right' | 'up' | 'down';
+
+export interface EditorGroupNavigationRect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+
+type EditorGroupNavigationScore = [
+    orthogonalRank: number,
+    orthogonalGap: number,
+    primaryDistance: number,
+    orthogonalCenterDistance: number,
+    orthogonalStart: number
+];
+
+function isInDirection(source: EditorGroupNavigationRect, candidate: EditorGroupNavigationRect, direction: EditorGroupNavigationDirection): boolean {
+    const sourceCenter = rectCenter(source);
+    const candidateCenter = rectCenter(candidate);
+    switch (direction) {
+        case 'left':
+            return candidateCenter.x < sourceCenter.x;
+        case 'right':
+            return candidateCenter.x > sourceCenter.x;
+        case 'up':
+            return candidateCenter.y < sourceCenter.y;
+        case 'down':
+            return candidateCenter.y > sourceCenter.y;
+    }
+}
+
+function score(source: EditorGroupNavigationRect, candidate: EditorGroupNavigationRect, direction: EditorGroupNavigationDirection): EditorGroupNavigationScore {
+    const horizontal = direction === 'left' || direction === 'right';
+    const sourceCenter = rectCenter(source);
+    const candidateCenter = rectCenter(candidate);
+    const orthogonalOverlap = horizontal
+        ? intervalOverlap(source.top, source.bottom, candidate.top, candidate.bottom)
+        : intervalOverlap(source.left, source.right, candidate.left, candidate.right);
+    return [
+        orthogonalOverlap > 0 ? 0 : 1,
+        Math.max(0, -orthogonalOverlap),
+        directionalDistance(source, candidate, direction),
+        horizontal ? Math.abs(sourceCenter.y - candidateCenter.y) : Math.abs(sourceCenter.x - candidateCenter.x),
+        horizontal ? candidate.top : candidate.left
+    ];
+}
+
+function compareScore(left: EditorGroupNavigationScore, right: EditorGroupNavigationScore): number {
+    return left[0] - right[0]
+        || left[1] - right[1]
+        || left[2] - right[2]
+        || left[3] - right[3]
+        || left[4] - right[4];
+}
+
+function directionalDistance(source: EditorGroupNavigationRect, candidate: EditorGroupNavigationRect, direction: EditorGroupNavigationDirection): number {
+    switch (direction) {
+        case 'left':
+            return Math.max(0, source.left - candidate.right);
+        case 'right':
+            return Math.max(0, candidate.left - source.right);
+        case 'up':
+            return Math.max(0, source.top - candidate.bottom);
+        case 'down':
+            return Math.max(0, candidate.top - source.bottom);
+    }
+}
+
+function rectCenter(rect: EditorGroupNavigationRect): { x: number, y: number } {
+    return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2
+    };
+}
+
+function intervalOverlap(start: number, end: number, candidateStart: number, candidateEnd: number): number {
+    return Math.min(end, candidateEnd) - Math.max(start, candidateStart);
+}
+
 @injectable()
 export class PluginVscodeCommandsContribution implements CommandContribution {
     @inject(CommandService)
@@ -206,6 +288,9 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
     @inject(ScmContribution)
     protected scmContribution: ScmContribution;
 
+    @inject(ILogger) @named('plugin-ext-vscode:PluginVscodeCommandsContribution')
+    protected readonly logger: ILogger;
+
     private async openWith(commandId: string, resource: URI, columnOrOptions?: ViewColumn | TextDocumentShowOptions, openerId?: string): Promise<boolean> {
         if (!resource) {
             throw new Error(`${commandId} command requires at least URI argument.`);
@@ -251,6 +336,105 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
         return false;
     }
 
+    protected navigateEditorGroup(direction: EditorGroupNavigationDirection): boolean {
+        const current = this.currentMainAreaTabBar();
+        const currentRect = current && this.getEditorGroupRect(current);
+        if (!current || current.titles.length === 0 || !currentRect) {
+            return false;
+        }
+
+        const candidates: TabBar<Widget>[] = [];
+        const candidateRects: EditorGroupNavigationRect[] = [];
+        for (const tabBar of this.shell.mainAreaTabBars) {
+            if (tabBar === current || tabBar.titles.length === 0) {
+                continue;
+            }
+            const candidateRect = this.getEditorGroupRect(tabBar);
+            if (candidateRect) {
+                candidates.push(tabBar);
+                candidateRects.push(candidateRect);
+            }
+        }
+        const index = this.findClosestEditorGroup(currentRect, candidateRects, direction);
+        return index === -1 ? false : this.activateEditorGroup(candidates[index]);
+    }
+
+    protected findClosestEditorGroup(source: EditorGroupNavigationRect, candidates: ReadonlyArray<EditorGroupNavigationRect>, direction: EditorGroupNavigationDirection): number {
+        let bestIndex = -1;
+        let bestScore: EditorGroupNavigationScore | undefined;
+        for (let index = 0; index < candidates.length; index++) {
+            const candidate = candidates[index];
+            if (!isInDirection(source, candidate, direction)) {
+                continue;
+            }
+            const candidateScore = score(source, candidate, direction);
+            if (!bestScore || compareScore(candidateScore, bestScore) < 0) {
+                bestIndex = index;
+                bestScore = candidateScore;
+            }
+        }
+        return bestIndex;
+    }
+
+    protected navigateEditorGroups(): boolean {
+        const current = this.currentMainAreaTabBar();
+        const tabBars = this.shell.mainAreaTabBars.filter(tabBar => tabBar.titles.length > 0);
+        if (!current || tabBars.length < 2) {
+            return false;
+        }
+        const currentIndex = tabBars.indexOf(current);
+        if (currentIndex === -1) {
+            return false;
+        }
+        const target = tabBars[(currentIndex + 1) % tabBars.length];
+        return this.activateEditorGroup(target);
+    }
+
+    protected currentMainAreaTabBar(): TabBar<Widget> | undefined {
+        const mainAreaTabBars = this.shell.mainAreaTabBars;
+        const currentTabBar = this.shell.currentTabBar;
+        if (currentTabBar && mainAreaTabBars.includes(currentTabBar)) {
+            return currentTabBar;
+        }
+        const currentEditor = this.editorManager.currentEditor || this.editorManager.activeEditor;
+        if (currentEditor) {
+            const tabBar = this.shell.getTabBarFor(currentEditor);
+            if (tabBar && mainAreaTabBars.includes(tabBar)) {
+                return tabBar;
+            }
+        }
+        return undefined;
+    }
+
+    protected getEditorGroupRect(tabBar: TabBar<Widget>): EditorGroupNavigationRect | undefined {
+        const title = tabBar.currentTitle || tabBar.titles[0];
+        const rects = [
+            tabBar.node.getBoundingClientRect(),
+            title?.owner.node.getBoundingClientRect()
+        ].filter((rect): rect is DOMRect => !!rect && rect.width > 0 && rect.height > 0);
+        if (rects.length === 0) {
+            return undefined;
+        }
+        const left = Math.min(...rects.map(rect => rect.left));
+        const right = Math.max(...rects.map(rect => rect.right));
+        const top = Math.min(...rects.map(rect => rect.top));
+        const bottom = Math.max(...rects.map(rect => rect.bottom));
+        return { left, right, top, bottom, width: right - left, height: bottom - top };
+    }
+
+    protected activateEditorGroup(tabBar: TabBar<Widget>): boolean {
+        let title = tabBar.currentTitle;
+        if (!title && tabBar.titles.length > 0) {
+            tabBar.currentIndex = 0;
+            title = tabBar.currentTitle;
+        }
+        if (!title) {
+            return false;
+        }
+        this.shell.activateWidget(title.owner.id);
+        return true;
+    }
+
     registerCommands(commands: CommandRegistry): void {
         commands.registerCommand(VscodeCommands.GET_CODE_EXCHANGE_ENDPOINTS, {
             execute: () => undefined // this is a dummy implementation: only used in the case of web apps, which is not supported yet.
@@ -268,7 +452,7 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
                     const message = nls.localizeByDefault("Unable to open '{0}'", resource.path);
                     const reason = nls.localizeByDefault('Error: {0}', error.message);
                     this.messageService.error(`${message}\n${reason}`);
-                    console.warn(error);
+                    this.logger.warn(error);
                 }
             }
         });
@@ -353,35 +537,44 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
             commands.registerCommand({ id: 'workbench.action.files.openFileFolder' }, {
                 execute: () => commands.executeCommand(WorkspaceCommands.OPEN.id)
             });
+            commands.registerAlias('workbench.action.files.openFileFolder', WorkspaceCommands.OPEN.id);
         }
 
         commands.registerCommand({ id: 'workbench.action.files.openFile' }, {
             execute: () => commands.executeCommand(WorkspaceCommands.OPEN_FILE.id)
         });
+        commands.registerAlias('workbench.action.files.openFile', WorkspaceCommands.OPEN_FILE.id);
         commands.registerCommand({ id: 'workbench.action.files.openFolder' }, {
             execute: () => commands.executeCommand(WorkspaceCommands.OPEN_FOLDER.id)
         });
+        commands.registerAlias('workbench.action.files.openFolder', WorkspaceCommands.OPEN_FOLDER.id);
         commands.registerCommand({ id: 'workbench.action.addRootFolder' }, {
             execute: () => commands.executeCommand(WorkspaceCommands.ADD_FOLDER.id)
         });
+        commands.registerAlias('workbench.action.addRootFolder', WorkspaceCommands.ADD_FOLDER.id);
         commands.registerCommand({ id: 'workbench.action.saveWorkspaceAs' }, {
             execute: () => commands.executeCommand(WorkspaceCommands.SAVE_WORKSPACE_AS.id)
         });
+        commands.registerAlias('workbench.action.saveWorkspaceAs', WorkspaceCommands.SAVE_WORKSPACE_AS.id);
         commands.registerCommand({ id: 'workbench.action.gotoLine' }, {
             execute: () => commands.executeCommand(EditorCommands.GOTO_LINE_COLUMN.id)
         });
+        commands.registerAlias('workbench.action.gotoLine', EditorCommands.GOTO_LINE_COLUMN.id);
         commands.registerCommand({ id: 'workbench.action.quickOpen' }, {
             execute: (prefix?: unknown) => this.quickInput.open(typeof prefix === 'string' ? prefix : '')
         });
         commands.registerCommand({ id: 'workbench.action.openSettings' }, {
             execute: (query?: string) => commands.executeCommand(CommonCommands.OPEN_PREFERENCES.id, query)
         });
+        commands.registerAlias('workbench.action.openSettings', CommonCommands.OPEN_PREFERENCES.id);
         commands.registerCommand({ id: 'workbench.action.openWorkspaceConfigFile' }, {
             execute: () => commands.executeCommand(WorkspaceCommands.OPEN_WORKSPACE_FILE.id)
         });
+        commands.registerAlias('workbench.action.openWorkspaceConfigFile', WorkspaceCommands.OPEN_WORKSPACE_FILE.id);
         commands.registerCommand({ id: 'workbench.files.action.refreshFilesExplorer' }, {
             execute: () => commands.executeCommand(FileNavigatorCommands.REFRESH_NAVIGATOR.id)
         });
+        commands.registerAlias('workbench.files.action.refreshFilesExplorer', FileNavigatorCommands.REFRESH_NAVIGATOR.id);
         commands.registerCommand(VscodeCommands.INSTALL_EXTENSION_FROM_ID_OR_URI, {
             execute: async (vsixUriOrExtensionId: TheiaURI | UriComponents | string) => {
                 if (typeof vsixUriOrExtensionId === 'string') {
@@ -443,6 +636,7 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
         commands.registerCommand({ id: 'workbench.action.closeActiveEditor' }, {
             execute: () => commands.executeCommand(CommonCommands.CLOSE_MAIN_TAB.id)
         });
+        commands.registerAlias('workbench.action.closeActiveEditor', CommonCommands.CLOSE_MAIN_TAB.id);
         commands.registerCommand({ id: 'workbench.action.closeOtherEditors' }, {
             execute: async (uri?: monaco.Uri) => {
                 let editor = this.editorManager.currentEditor || this.shell.currentWidget;
@@ -560,15 +754,53 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
         commands.registerCommand({ id: 'workbench.action.previousEditor' }, {
             execute: () => this.shell.activatePreviousTab()
         });
+        commands.registerCommand({
+            id: 'workbench.action.navigateLeft',
+            label: nls.localizeByDefault('Navigate to the View on the Left'),
+            category: nls.localizeByDefault('View')
+        }, {
+            execute: () => this.navigateEditorGroup('left')
+        });
+        commands.registerCommand({
+            id: 'workbench.action.navigateRight',
+            label: nls.localizeByDefault('Navigate to the View on the Right'),
+            category: nls.localizeByDefault('View')
+        }, {
+            execute: () => this.navigateEditorGroup('right')
+        });
+        commands.registerCommand({
+            id: 'workbench.action.navigateUp',
+            label: nls.localizeByDefault('Navigate to the View Above'),
+            category: nls.localizeByDefault('View')
+        }, {
+            execute: () => this.navigateEditorGroup('up')
+        });
+        commands.registerCommand({
+            id: 'workbench.action.navigateDown',
+            label: nls.localizeByDefault('Navigate to the View Below'),
+            category: nls.localizeByDefault('View')
+        }, {
+            execute: () => this.navigateEditorGroup('down')
+        });
+        commands.registerCommand({
+            id: 'workbench.action.navigateEditorGroups',
+            label: nls.localizeByDefault('Navigate Between Editor Groups'),
+            category: nls.localizeByDefault('View')
+        }, {
+            execute: () => this.navigateEditorGroups()
+        });
         commands.registerCommand({ id: 'workbench.action.navigateBack' }, {
             execute: () => commands.executeCommand(EditorCommands.GO_BACK.id)
         });
+        commands.registerAlias('workbench.action.navigateBack', EditorCommands.GO_BACK.id);
         commands.registerCommand({ id: 'workbench.action.navigateForward' }, {
             execute: () => commands.executeCommand(EditorCommands.GO_FORWARD.id)
         });
+        commands.registerAlias('workbench.action.navigateForward', EditorCommands.GO_FORWARD.id);
         commands.registerCommand({ id: 'workbench.action.navigateToLastEditLocation' }, {
             execute: () => commands.executeCommand(EditorCommands.GO_LAST_EDIT.id)
         });
+        commands.registerAlias('workbench.action.navigateToLastEditLocation', EditorCommands.GO_LAST_EDIT.id);
 
         commands.registerCommand({ id: 'openInTerminal' }, {
             execute: (resource: URI) => this.terminalContribution.openInTerminal(new TheiaURI(resource.toString()))
@@ -872,6 +1104,7 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
         }, {
             execute: () => commands.executeCommand(WorkspaceCommands.NEW_FOLDER.id)
         });
+        commands.registerAlias('explorer.newFolder', WorkspaceCommands.NEW_FOLDER.id);
         commands.registerCommand({
             id: 'workbench.action.terminal.sendSequence'
         }, {
@@ -907,16 +1140,19 @@ export class PluginVscodeCommandsContribution implements CommandContribution {
         }, {
             execute: () => commands.executeCommand(FileNavigatorCommands.FOCUS.id)
         });
+        commands.registerAlias('workbench.view.explorer', FileNavigatorCommands.FOCUS.id);
         commands.registerCommand({
             id: 'copyFilePath'
         }, {
             execute: () => commands.executeCommand(CommonCommands.COPY_PATH.id)
         });
+        commands.registerAlias('copyFilePath', CommonCommands.COPY_PATH.id);
         commands.registerCommand({
             id: 'copyRelativeFilePath'
         }, {
             execute: () => commands.executeCommand(WorkspaceCommands.COPY_RELATIVE_FILE_PATH.id)
         });
+        commands.registerAlias('copyRelativeFilePath', WorkspaceCommands.COPY_RELATIVE_FILE_PATH.id);
         commands.registerCommand({
             id: 'revealInExplorer'
         }, {

package/src/node/local-vsix-file-plugin-deployer-resolver.ts

@@ -15,12 +15,13 @@
 // *****************************************************************************
 
 import * as path from 'path';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { PluginDeployerResolverContext, PluginIdentifiers } from '@theia/plugin-ext';
 import { LocalPluginDeployerResolver } from '@theia/plugin-ext/lib/main/node/resolvers/local-plugin-deployer-resolver';
 import { PluginVSCodeEnvironment } from '../common/plugin-vscode-environment';
 import { isVSCodePluginFile } from './plugin-vscode-file-handler';
 import { existsInDeploymentDir, unpackToDeploymentDir, extractExtensionIdentityFromVsix } from './plugin-vscode-utils';
+import { ILogger } from '@theia/core';
 
 @injectable()
 export class LocalVSIXFilePluginDeployerResolver extends LocalPluginDeployerResolver {
@@ -29,6 +30,9 @@ export class LocalVSIXFilePluginDeployerResolver extends LocalPluginDeployerReso
 
     @inject(PluginVSCodeEnvironment) protected readonly environment: PluginVSCodeEnvironment;
 
+    @inject(ILogger) @named('plugin-ext-vscode:LocalVSIXFilePluginDeployerResolver')
+    protected override readonly logger: ILogger;
+
     protected get supportedScheme(): string {
         return LocalVSIXFilePluginDeployerResolver.LOCAL_FILE;
     }
@@ -47,10 +51,10 @@ export class LocalVSIXFilePluginDeployerResolver extends LocalPluginDeployerReso
             // Fallback to filename-based ID if package.json cannot be read
             // This maintains backward compatibility for edge cases
             const fallbackId = path.basename(localPath, LocalVSIXFilePluginDeployerResolver.FILE_EXTENSION);
-            console.warn(`[${pluginResolverContext.getOriginId()}]: Could not read extension identity from VSIX, falling back to filename: ${fallbackId}`);
+            this.logger.warn(`[${pluginResolverContext.getOriginId()}]: Could not read extension identity from VSIX, falling back to filename: ${fallbackId}`);
 
             if (await existsInDeploymentDir(this.environment, fallbackId)) {
-                console.log(`[${pluginResolverContext.getOriginId()}]: Target dir already exists in plugin deployment dir`);
+                this.logger.info(`[${pluginResolverContext.getOriginId()}]: Target dir already exists in plugin deployment dir`);
                 return;
             }
 

package/src/node/plugin-vscode-deployer-participant.ts

@@ -14,12 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject } from '@theia/core/shared/inversify';
+import { injectable, inject, named } from '@theia/core/shared/inversify';
 import * as fs from '@theia/core/shared/fs-extra';
 import { FileUri } from '@theia/core/lib/node';
 import { PluginVSCodeEnvironment } from '../common/plugin-vscode-environment';
 import { PluginDeployerParticipant, PluginDeployerStartContext } from '@theia/plugin-ext/lib/common/plugin-protocol';
 import { LocalVSIXFilePluginDeployerResolver } from './local-vsix-file-plugin-deployer-resolver';
+import { ILogger } from '@theia/core';
 
 @injectable()
 export class PluginVSCodeDeployerParticipant implements PluginDeployerParticipant {
@@ -27,6 +28,9 @@ export class PluginVSCodeDeployerParticipant implements PluginDeployerParticipan
     @inject(PluginVSCodeEnvironment)
     protected readonly environments: PluginVSCodeEnvironment;
 
+    @inject(ILogger) @named('plugin-ext-vscode:PluginVSCodeDeployerParticipant')
+    protected readonly logger: ILogger;
+
     async onWillStart(context: PluginDeployerStartContext): Promise<void> {
         const extensionDeploymentDirUri = await this.environments.getDeploymentDirUri();
         context.userEntries.push(extensionDeploymentDirUri.withScheme('local-dir').toString());
@@ -39,7 +43,7 @@ export class PluginVSCodeDeployerParticipant implements PluginDeployerParticipan
             for (const file of files) {
                 if (file.endsWith(LocalVSIXFilePluginDeployerResolver.FILE_EXTENSION)) {
                     const extensionUri = userExtensionDirUri.resolve(file).withScheme('local-file').toString();
-                    console.log(`found drop-in extension "${extensionUri}"`);
+                    this.logger.info(`found drop-in extension "${extensionUri}"`);
                     context.userEntries.push(extensionUri);
                 }
             }

package/src/node/plugin-vscode-directory-handler.ts

@@ -16,8 +16,8 @@
 
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
-import { inject, injectable } from '@theia/core/shared/inversify';
-import type { RecursivePartial, URI } from '@theia/core';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import { ILogger, type URI } from '@theia/core';
 import { Deferred, firstTrue } from '@theia/core/lib/common/promise-util';
 import {
     PluginDeployerDirectoryHandler, PluginDeployerEntry, PluginDeployerDirectoryHandlerContext,
@@ -26,6 +26,9 @@ import {
 import { PluginCliContribution } from '@theia/plugin-ext/lib/main/node/plugin-cli-contribution';
 import { TMP_DIR_PREFIX } from './plugin-vscode-utils';
 
+/** Fields read while resolving a VS Code extension directory */
+type PluginPackageResolveInput = Partial<Pick<PluginPackage, 'name' | 'version' | 'publisher' | 'engines'>>;
+
 @injectable()
 export class PluginVsCodeDirectoryHandler implements PluginDeployerDirectoryHandler {
 
@@ -33,8 +36,11 @@ export class PluginVsCodeDirectoryHandler implements PluginDeployerDirectoryHand
 
     @inject(PluginCliContribution) protected readonly pluginCli: PluginCliContribution;
 
+    @inject(ILogger) @named('plugin-ext-vscode:PluginVsCodeDirectoryHandler')
+    protected readonly logger: ILogger;
+
     async accept(plugin: PluginDeployerEntry): Promise<boolean> {
-        console.debug(`Resolving "${plugin.id()}" as a VS Code extension...`);
+        this.logger.debug(`Resolving "${plugin.id()}" as a VS Code extension...`);
         if (plugin.path().startsWith(TMP_DIR_PREFIX)) {
             // avoid adding corrupted plugins from temporary directories
             return false;
@@ -92,7 +98,7 @@ export class PluginVsCodeDirectoryHandler implements PluginDeployerDirectoryHand
 
     protected resolvePackage(plugin: PluginDeployerEntry, options?: {
         pluginPath: string
-        pck?: RecursivePartial<PluginPackage>
+        pck?: PluginPackageResolveInput
     }): boolean {
         const { pluginPath, pck } = options || {
             pluginPath: plugin.path(),
@@ -107,7 +113,7 @@ export class PluginVsCodeDirectoryHandler implements PluginDeployerDirectoryHand
             plugin.rootPath = plugin.path();
             plugin.updatePath(pluginPath);
         }
-        console.debug(`Resolved "${plugin.id()}" to a VS Code extension "${pck.name}@${pck.version}" with engines:`, pck.engines);
+        this.logger.debug(`Resolved "${plugin.id()}" to a VS Code extension "${pck.name}@${pck.version}" with engines:`, pck.engines);
         return true;
     }
 

package/src/node/plugin-vscode-file-handler.ts

@@ -16,11 +16,12 @@
 
 import { PluginDeployerFileHandler, PluginDeployerEntry, PluginDeployerFileHandlerContext } from '@theia/plugin-ext';
 import * as filenamify from 'filenamify';
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
 import * as fs from '@theia/core/shared/fs-extra';
 import { PluginVSCodeEnvironment } from '../common/plugin-vscode-environment';
 import { FileUri } from '@theia/core/lib/common/file-uri';
 import { unpackToDeploymentDir } from './plugin-vscode-utils';
+import { ILogger } from '@theia/core';
 
 export const isVSCodePluginFile = (pluginPath?: string) => Boolean(pluginPath && (pluginPath.endsWith('.vsix') || pluginPath.endsWith('.tgz')));
 
@@ -29,6 +30,9 @@ export class PluginVsCodeFileHandler implements PluginDeployerFileHandler {
     @inject(PluginVSCodeEnvironment)
     protected readonly environment: PluginVSCodeEnvironment;
 
+    @inject(ILogger) @named('plugin-ext-vscode:PluginVsCodeFileHandler')
+    protected readonly logger: ILogger;
+
     async accept(resolvedPlugin: PluginDeployerEntry): Promise<boolean> {
         return resolvedPlugin.isFile().then(file => {
             if (!file) {
@@ -42,7 +46,7 @@ export class PluginVsCodeFileHandler implements PluginDeployerFileHandler {
         const id = this.getNormalizedExtensionId(context.pluginEntry().id());
         const extensionDeploymentDir = await unpackToDeploymentDir(this.environment, context.pluginEntry().path(), id);
         context.pluginEntry().updatePath(extensionDeploymentDir);
-        console.log(`root path: ${context.pluginEntry().rootPath}`);
+        this.logger.info(`root path: ${context.pluginEntry().rootPath}`);
         const originalPath = context.pluginEntry().originalPath();
         if (originalPath && originalPath !== extensionDeploymentDir) {
             const tempDirUri = await this.environment.getTempDirUri();
@@ -50,7 +54,7 @@ export class PluginVsCodeFileHandler implements PluginDeployerFileHandler {
                 try {
                     await fs.remove(FileUri.fsPath(originalPath));
                 } catch (e) {
-                    console.error(`[${id}]: failed to remove temporary files: "${originalPath}"`, e);
+                    this.logger.error(`[${id}]: failed to remove temporary files: "${originalPath}"`, e);
                 }
             }
         }

package/src/node/scanner-vscode.ts

@@ -16,10 +16,11 @@
 
 import * as path from 'path';
 import { injectable } from '@theia/core/shared/inversify';
-import { PluginScanner, PluginEngine, PluginPackage, PluginModel, PluginLifecycle, PluginEntryPoint, buildFrontendModuleName, UIKind, PluginIdentifiers } from '@theia/plugin-ext';
+import { PluginScanner, PluginEngine, PluginPackage, PluginModel, PluginLifecycle, PluginIdentifiers, UIKind } from '@theia/plugin-ext';
 import { TheiaPluginScanner } from '@theia/plugin-ext/lib/hosted/node/scanners/scanner-theia';
 import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
 import { VSCodeExtensionUri } from '../common/plugin-vscode-uri';
+import { buildLifecycle, buildModelForVsCode } from '@theia/plugin-utils/lib/common/plugin-model';
 
 const uiKind = environment.electron.is() ? UIKind.Desktop : UIKind.Web;
 
@@ -33,49 +34,13 @@ export class VsCodePluginScanner extends TheiaPluginScanner implements PluginSca
     }
 
     override getModel(plugin: PluginPackage): PluginModel {
-        // publisher can be empty on vscode extension development
-        const publisher = plugin.publisher ?? PluginIdentifiers.UNPUBLISHED;
-
-        // Only one entrypoint is valid in vscode extensions
-        // Mimic choosing frontend (web extension) and backend (local/remote extension) as described here:
-        // https://code.visualstudio.com/api/advanced-topics/extension-host#preferred-extension-location
-        const entryPoint: PluginEntryPoint = {};
-
-        // Act like codespaces when run in the browser (UIKind === 'web' and extensionKind is ['ui'])
-        const preferFrontend = uiKind === UIKind.Web && (plugin.extensionKind?.length === 1 && plugin.extensionKind[0] === 'ui');
-
-        if (plugin.browser && (!plugin.main || preferFrontend)) {
-            // Use frontend if available and there is no backend or frontend is preferred
-            entryPoint.frontend = plugin.browser;
-        } else {
-            // Default to using backend
-            entryPoint.backend = plugin.main;
-        }
-        if (plugin.theiaPlugin?.headless) {
-            // Support the Theia-specific extension for headless plugins
-            entryPoint.headless = plugin.theiaPlugin?.headless;
-        }
-
-        const result: PluginModel = {
-            packagePath: plugin.packagePath,
+        const result = buildModelForVsCode({
+            ...plugin,
+            publisher: plugin.publisher ?? PluginIdentifiers.UNPUBLISHED,
             packageUri: this.pluginUriFactory.createUri(plugin).toString(),
-            // see id definition: https://github.com/microsoft/vscode/blob/15916055fe0cb9411a5f36119b3b012458fe0a1d/src/vs/platform/extensions/common/extensions.ts#L167-L169
-            id: `${publisher.toLowerCase()}.${plugin.name.toLowerCase()}`,
-            name: plugin.name,
-            publisher: publisher,
-            version: plugin.version,
-            displayName: plugin.displayName,
-            description: plugin.description,
-            engine: {
-                type: this.VSCODE_TYPE,
-                version: plugin.engines[this.VSCODE_TYPE]
-            },
-            entryPoint,
-            iconUrl: plugin.icon && PluginPackage.toPluginUrl(plugin, plugin.icon),
-            l10n: plugin.l10n,
-            readmeUrl: this.getReadmeUrl(plugin),
-            licenseUrl: this.getLicenseUrl(plugin)
-        };
+        }, { uiKind: uiKind === UIKind.Web ? 'web' : 'desktop' });
+        result.licenseUrl = this.getLicenseUrl(plugin);
+        result.readmeUrl = this.getReadmeUrl(plugin);
         this.applyTrustExtraction(plugin, result);
         return result;
     }
@@ -84,29 +49,21 @@ export class VsCodePluginScanner extends TheiaPluginScanner implements PluginSca
      * Maps extension dependencies to deployable extension dependencies.
      */
     override getDependencies(plugin: PluginPackage): Map<string, string> | undefined {
-        // Store the list of dependencies.
         const dependencies = new Map<string, string>();
-        // Iterate through the list of dependencies from `extensionDependencies` and `extensionPack`.
         for (const dependency of [plugin.extensionDependencies, plugin.extensionPack]) {
             if (dependency !== undefined) {
-                // Iterate over the list of dependencies present, and add them to the collection.
                 dependency.forEach((dep: string) => {
                     const dependencyId = dep.toLowerCase();
                     dependencies.set(dependencyId, VSCodeExtensionUri.fromId(dependencyId).toString());
                 });
             }
         }
-        // Return the map of dependencies if present, else `undefined`.
         return dependencies.size > 0 ? dependencies : undefined;
     }
 
     override getLifecycle(plugin: PluginPackage): PluginLifecycle {
         return {
-            startMethod: 'activate',
-            stopMethod: 'deactivate',
-            frontendModuleName: buildFrontendModuleName(plugin),
-
-            frontendInitPath: 'plugin-vscode-init-fe.js',
+            ...buildLifecycle(plugin, 'vscode'),
             backendInitPath: path.join(__dirname, 'plugin-vscode-init'),
         };
     }