@theia/plugin-ext 1.27.0-next.9 → 1.27.0

package/src/main/node/plugin-deployer-impl.ts

@@ -17,11 +17,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { injectable, optional, multiInject, inject, named } from '@theia/core/shared/inversify';
+import * as semver from 'semver';
 import {
     PluginDeployerResolver, PluginDeployerFileHandler, PluginDeployerDirectoryHandler,
     PluginDeployerEntry, PluginDeployer, PluginDeployerParticipant, PluginDeployerStartContext,
     PluginDeployerResolverInit, PluginDeployerFileHandlerContext,
-    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry
+    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions
 } from '../../common/plugin-protocol';
 import { PluginDeployerEntryImpl } from './plugin-deployer-entry-impl';
 import {
@@ -135,21 +136,26 @@ export class PluginDeployerImpl implements PluginDeployer {
         deployPlugins.log('Deploy plugins list');
     }
 
-    async undeploy(pluginId: string): Promise<void> {
+    async uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        await this.pluginDeployerHandler.uninstallPlugin(pluginId);
+    }
+
+    async undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         if (await this.pluginDeployerHandler.undeployPlugin(pluginId)) {
             this.onDidDeployEmitter.fire();
         }
     }
 
-    async deploy(plugin: UnresolvedPluginEntry): Promise<void> {
+    async deploy(plugin: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
         const deploy = this.measure('deploy');
-        await this.deployMultipleEntries([plugin]);
-        deploy.log(`Deploy plugin ${plugin}`);
+        const numDeployedPlugins = await this.deployMultipleEntries([plugin], options);
+        deploy.log(`Deploy plugin ${plugin.id}`);
+        return numDeployedPlugins;
     }
 
-    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[]): Promise<void> {
-        const pluginsToDeploy = await this.resolvePlugins(plugins);
-        await this.deployPlugins(pluginsToDeploy);
+    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[], options?: PluginDeployOptions): Promise<number> {
+        const pluginsToDeploy = await this.resolvePlugins(plugins, options);
+        return this.deployPlugins(pluginsToDeploy);
     }
 
     /**
@@ -161,51 +167,51 @@ export class PluginDeployerImpl implements PluginDeployer {
      * deployer.deployPlugins(await deployer.resolvePlugins(allPluginEntries));
      * ```
      */
-    async resolvePlugins(plugins: UnresolvedPluginEntry[]): Promise<PluginDeployerEntry[]> {
+    async resolvePlugins(plugins: UnresolvedPluginEntry[], options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
         const visited = new Set<string>();
-        const pluginsToDeploy = new Map<string, PluginDeployerEntry>();
+        const hasBeenVisited = (id: string) => visited.has(id) || (visited.add(id), false);
+        const pluginsToDeploy = new Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>();
+        const unversionedIdsHandled = new Map<PluginIdentifiers.UnversionedId, string[]>();
 
-        let queue: UnresolvedPluginEntry[] = [...plugins];
+        const queue: UnresolvedPluginEntry[] = [...plugins];
         while (queue.length) {
-            const dependenciesChunk: Array<{
+            const pendingDependencies: Array<{
                 dependencies: Map<string, string>
                 type: PluginType
             }> = [];
-            const workload: UnresolvedPluginEntry[] = [];
-            while (queue.length) {
-                const current = queue.shift()!;
-                if (visited.has(current.id)) {
-                    continue;
-                } else {
-                    workload.push(current);
-                }
-                visited.add(current.id);
-            }
-            queue = [];
-            await Promise.all(workload.map(async ({ id, type }) => {
-                if (type === undefined) {
-                    type = PluginType.System;
+            await Promise.all(queue.map(async entry => {
+                if (hasBeenVisited(entry.id)) {
+                    return;
                 }
+                const type = entry.type ?? PluginType.System;
                 try {
-                    const pluginDeployerEntries = await this.resolvePlugin(id, type);
-                    await this.applyFileHandlers(pluginDeployerEntries);
-                    await this.applyDirectoryFileHandlers(pluginDeployerEntries);
+                    const pluginDeployerEntries = await this.resolveAndHandle(entry.id, type, options);
                     for (const deployerEntry of pluginDeployerEntries) {
-                        const dependencies = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
-                        if (dependencies && !pluginsToDeploy.has(dependencies.metadata.model.id)) {
-                            pluginsToDeploy.set(dependencies.metadata.model.id, deployerEntry);
-                            if (dependencies.mapping) {
-                                dependenciesChunk.push({ dependencies: dependencies.mapping, type });
+                        const pluginData = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
+                        const versionedId = pluginData && PluginIdentifiers.componentsToVersionedId(pluginData.metadata.model);
+                        const unversionedId = versionedId && PluginIdentifiers.componentsToUnversionedId(pluginData.metadata.model);
+                        if (unversionedId && !pluginsToDeploy.has(versionedId)) {
+                            pluginsToDeploy.set(versionedId, deployerEntry);
+                            if (pluginData.mapping) {
+                                pendingDependencies.push({ dependencies: pluginData.mapping, type });
+                            }
+                            const otherVersions = unversionedIdsHandled.get(unversionedId) ?? [];
+                            otherVersions.push(pluginData.metadata.model.version);
+                            if (otherVersions.length === 1) {
+                                unversionedIdsHandled.set(unversionedId, otherVersions);
+                            } else {
+                                this.findBestVersion(unversionedId, otherVersions, pluginsToDeploy);
                             }
                         }
                     }
                 } catch (e) {
-                    console.error(`Failed to resolve plugins from '${id}'`, e);
+                    console.error(`Failed to resolve plugins from '${entry.id}'`, e);
                 }
             }));
-            for (const { dependencies, type } of dependenciesChunk) {
+            queue.length = 0;
+            for (const { dependencies, type } of pendingDependencies) {
                 for (const [dependency, deployableDependency] of dependencies) {
-                    if (!pluginsToDeploy.has(dependency)) {
+                    if (!unversionedIdsHandled.has(dependency as PluginIdentifiers.UnversionedId)) {
                         queue.push({
                             id: deployableDependency,
                             type
@@ -217,10 +223,50 @@ export class PluginDeployerImpl implements PluginDeployer {
         return [...pluginsToDeploy.values()];
     }
 
+    protected async resolveAndHandle(id: string, type: PluginType, options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
+        const entries = await this.resolvePlugin(id, type, options);
+        await this.applyFileHandlers(entries);
+        await this.applyDirectoryFileHandlers(entries);
+        return entries;
+    }
+
+    protected findBestVersion(unversionedId: PluginIdentifiers.UnversionedId, versions: string[], knownPlugins: Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>): void {
+        // If left better, return negative. Then best is index 0.
+        versions.map(version => ({ version, plugin: knownPlugins.get(PluginIdentifiers.idAndVersionToVersionedId({ version, id: unversionedId })) }))
+            .sort((left, right) => {
+                const leftPlugin = left.plugin;
+                const rightPlugin = right.plugin;
+                if (!leftPlugin && !rightPlugin) {
+                    return 0;
+                }
+                if (!rightPlugin) {
+                    return -1;
+                }
+                if (!leftPlugin) {
+                    return 1;
+                }
+                if (leftPlugin.type === PluginType.System && rightPlugin.type === PluginType.User) {
+                    return -1;
+                }
+                if (leftPlugin.type === PluginType.User && rightPlugin.type === PluginType.System) {
+                    return 1;
+                }
+                if (semver.gtr(left.version, right.version)) {
+                    return -1;
+                }
+                return 1;
+            }).forEach((versionedEntry, index) => {
+                if (index !== 0) {
+                    // Mark as not accepted to prevent deployment of all but the winner.
+                    versionedEntry.plugin?.accept();
+                }
+            });
+    }
+
     /**
      * deploy all plugins that have been accepted
      */
-    async deployPlugins(pluginsToDeploy: PluginDeployerEntry[]): Promise<any> {
+    async deployPlugins(pluginsToDeploy: PluginDeployerEntry[]): Promise<number> {
         const acceptedPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted());
         const acceptedFrontendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.FRONTEND));
         const acceptedBackendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.BACKEND));
@@ -237,12 +283,13 @@ export class PluginDeployerImpl implements PluginDeployer {
         const pluginPaths = acceptedBackendPlugins.map(pluginEntry => pluginEntry.path());
         this.logger.debug('local path to deploy on remote instance', pluginPaths);
 
-        await Promise.all([
+        const deployments = await Promise.all([
             // start the backend plugins
             this.pluginDeployerHandler.deployBackendPlugins(acceptedBackendPlugins),
             this.pluginDeployerHandler.deployFrontendPlugins(acceptedFrontendPlugins)
         ]);
         this.onDidDeployEmitter.fire(undefined);
+        return deployments.reduce<number>((accumulated, current) => accumulated += current ?? 0, 0);
     }
 
     /**
@@ -288,7 +335,7 @@ export class PluginDeployerImpl implements PluginDeployer {
     /**
      * Check a plugin ID see if there are some resolvers that can handle it. If there is a matching resolver, then we resolve the plugin
      */
-    public async resolvePlugin(pluginId: string, type: PluginType = PluginType.System): Promise<PluginDeployerEntry[]> {
+    public async resolvePlugin(pluginId: string, type: PluginType = PluginType.System, options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
         const pluginDeployerEntries: PluginDeployerEntry[] = [];
         const foundPluginResolver = this.pluginResolvers.find(pluginResolver => pluginResolver.accept(pluginId));
         // there is a resolver for the input
@@ -297,7 +344,7 @@ export class PluginDeployerImpl implements PluginDeployer {
             // create context object
             const context = new PluginDeployerResolverContextImpl(foundPluginResolver, pluginId);
 
-            await foundPluginResolver.resolve(context);
+            await foundPluginResolver.resolve(context, options);
 
             context.getPlugins().forEach(entry => {
                 entry.type = type;

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

@@ -39,6 +39,7 @@ import { PluginCliContribution } from './plugin-cli-contribution';
 import { PluginTheiaEnvironment } from '../common/plugin-theia-environment';
 import { PluginTheiaDeployerParticipant } from './plugin-theia-deployer-participant';
 import { WebviewBackendSecurityWarnings } from './webview-backend-security-warnings';
+import { PluginUninstallationManager } from './plugin-uninstallation-manager';
 
 export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginApiContribution).toSelf().inSingletonScope();
@@ -50,6 +51,8 @@ export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginDeployerContribution).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(PluginDeployerContribution);
 
+    bind(PluginUninstallationManager).toSelf().inSingletonScope();
+
     bind(PluginDeployerResolver).to(LocalDirectoryPluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(LocalFilePluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(GithubPluginDeployerResolver).inSingletonScope();

package/src/main/node/plugin-server-handler.ts

@@ -18,7 +18,7 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { PluginDeployerImpl } from './plugin-deployer-impl';
 import { PluginsKeyValueStorage } from './plugins-key-value-storage';
-import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry } from '../../common/plugin-protocol';
+import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions } from '../../common/plugin-protocol';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
 
 @injectable()
@@ -30,19 +30,27 @@ export class PluginServerHandler implements PluginServer {
     @inject(PluginsKeyValueStorage)
     protected readonly pluginsKeyValueStorage: PluginsKeyValueStorage;
 
-    deploy(pluginEntry: string, arg2?: PluginType | CancellationToken): Promise<void> {
+    async deploy(pluginEntry: string, arg2?: PluginType | CancellationToken, options?: PluginDeployOptions): Promise<void> {
         const type = typeof arg2 === 'number' ? arg2 as PluginType : undefined;
-        return this.doDeploy({
+        const successfulDeployments = await this.doDeploy({
             id: pluginEntry,
             type: type ?? PluginType.User
-        });
+        }, options);
+        if (successfulDeployments === 0) {
+            const optionText = options ? ` and options ${JSON.stringify(options)} ` : ' ';
+            throw new Error(`Deployment of extension with ID ${pluginEntry}${optionText}failed.`);
+        }
     }
 
-    protected doDeploy(pluginEntry: UnresolvedPluginEntry): Promise<void> {
-        return this.pluginDeployer.deploy(pluginEntry);
+    protected doDeploy(pluginEntry: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
+        return this.pluginDeployer.deploy(pluginEntry, options);
     }
 
-    undeploy(pluginId: string): Promise<void> {
+    uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        return this.pluginDeployer.uninstall(pluginId);
+    }
+
+    undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         return this.pluginDeployer.undeploy(pluginId);
     }
 

package/src/main/node/plugin-uninstallation-manager.ts

@@ -0,0 +1,74 @@
+// *****************************************************************************
+// 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 { Emitter, Event } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+import { PluginIdentifiers } from '../../common';
+
+@injectable()
+export class PluginUninstallationManager {
+    protected readonly onDidChangeUninstalledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
+
+    get onDidChangeUninstalledPlugins(): Event<readonly PluginIdentifiers.VersionedId[]> {
+        return this.onDidChangeUninstalledPluginsEmitter.event;
+    }
+
+    protected uninstalledPlugins: PluginIdentifiers.VersionedId[] = [];
+
+    protected fireDidChange(): void {
+        this.onDidChangeUninstalledPluginsEmitter.fire(Object.freeze(this.uninstalledPlugins.slice()));
+    }
+
+    markAsUninstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+        let didChange = false;
+        for (const id of pluginIds) { didChange = this.markOneAsUninstalled(id) || didChange; }
+        if (didChange) { this.fireDidChange(); }
+        return didChange;
+    }
+
+    protected markOneAsUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        if (!this.uninstalledPlugins.includes(pluginId)) {
+            this.uninstalledPlugins.push(pluginId);
+            return true;
+        }
+        return false;
+    }
+
+    markAsInstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+        let didChange = false;
+        for (const id of pluginIds) { didChange = this.markOneAsInstalled(id) || didChange; }
+        if (didChange) { this.fireDidChange(); }
+        return didChange;
+    }
+
+    protected markOneAsInstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        let index: number;
+        let didChange = false;
+        while ((index = this.uninstalledPlugins.indexOf(pluginId)) !== -1) {
+            this.uninstalledPlugins.splice(index, 1);
+            didChange = true;
+        }
+        return didChange;
+    }
+
+    isUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        return this.uninstalledPlugins.includes(pluginId);
+    }
+
+    getUninstalledPluginIds(): readonly PluginIdentifiers.VersionedId[] {
+        return Object.freeze(this.uninstalledPlugins.slice());
+    }
+}

package/src/plugin/{node/debug/debug.ts → debug/debug-ext.ts}

@@ -17,22 +17,19 @@ import { Emitter } from '@theia/core/lib/common/event';
 import { Path } from '@theia/core/lib/common/path';
 import * as theia from '@theia/plugin';
 import { URI } from '@theia/core/shared/vscode-uri';
-import { Breakpoint } from '../../../common/plugin-api-rpc-model';
-import { DebugConfigurationProviderTriggerKind, DebugExt, DebugMain, PLUGIN_RPC_CONTEXT as Ext, TerminalOptionsExt } from '../../../common/plugin-api-rpc';
-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,
-    DebugAdapterServer, DebugAdapterExecutable, DebugAdapterNamedPipeServer, DebugAdapterInlineImplementation
-} from '../../types-impl';
-import { resolveDebugAdapterExecutable } from './plugin-debug-adapter-executable-resolver';
+import { Breakpoint } from '../../common/plugin-api-rpc-model';
+import { DebugConfigurationProviderTriggerKind, DebugExt, DebugMain, PLUGIN_RPC_CONTEXT as Ext, TerminalOptionsExt } from '../../common/plugin-api-rpc';
+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 { PluginDebugAdapterSession } from './plugin-debug-adapter-session';
-import { connectInlineDebugAdapter, connectPipeDebugAdapter, connectSocketDebugAdapter, startDebugAdapter } from './plugin-debug-adapter-starter';
 import { PluginDebugAdapterTracker } from './plugin-debug-adapter-tracker';
 import uuid = require('uuid');
-import { DebugAdapter } from '@theia/debug/lib/node/debug-model';
+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';
 
 interface ConfigurationProviderRecord {
     handle: number;
@@ -42,10 +39,7 @@ interface ConfigurationProviderRecord {
 }
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-// TODO: rename file to `debug-ext.ts`
-/**
- * It is supposed to work at node only.
- */
+
 export class DebugExtImpl implements DebugExt {
     // debug sessions by sessionId
     private sessions = new Map<string, PluginDebugAdapterSession>();
@@ -60,6 +54,7 @@ export class DebugExtImpl implements DebugExt {
     private descriptorFactories = new Map<string, theia.DebugAdapterDescriptorFactory>();
     private trackerFactories: [string, theia.DebugAdapterTrackerFactory][] = [];
     private contributionPaths = new Map<string, string>();
+    private contributionTypes = new Map<string, theia.PluginType>();
 
     private connectionExt: ConnectionImpl;
     private commandRegistryExt: CommandRegistryImpl;
@@ -77,6 +72,9 @@ export class DebugExtImpl implements DebugExt {
 
     private readonly _breakpoints = new Map<string, theia.Breakpoint>();
 
+    private frontendAdapterCreator = new PluginDebugAdapterCreator();
+    private backendAdapterCreator = new NodeDebugAdapterCreator();
+
     get breakpoints(): theia.Breakpoint[] {
         return [...this._breakpoints.values()];
     }
@@ -102,11 +100,13 @@ export class DebugExtImpl implements DebugExt {
     /**
      * Registers contributions.
      * @param pluginFolder plugin folder path
+     * @param pluginType plugin type
      * @param contributions available debuggers contributions
      */
-    registerDebuggersContributions(pluginFolder: string, contributions: PluginPackageDebuggersContribution[]): void {
+    registerDebuggersContributions(pluginFolder: string, pluginType: theia.PluginType, contributions: PluginPackageDebuggersContribution[]): void {
         contributions.forEach(contribution => {
             this.contributionPaths.set(contribution.type, pluginFolder);
+            this.contributionTypes.set(contribution.type, pluginType);
             this.debuggersContributions.set(contribution.type, contribution);
             this.proxy.$registerDebuggerContribution({
                 type: contribution.type,
@@ -397,43 +397,7 @@ export class DebugExtImpl implements DebugExt {
     protected async createDebugAdapter(session: theia.DebugSession, debugConfiguration: theia.DebugConfiguration): Promise<DebugAdapter> {
         const executable = await this.resolveDebugAdapterExecutable(debugConfiguration);
         const descriptorFactory = this.descriptorFactories.get(session.type);
-        if (descriptorFactory) {
-            // 'createDebugAdapterDescriptor' is called at the start of a debug session to provide details about the debug adapter to use.
-            // These details must be returned as objects of type [DebugAdapterDescriptor](#DebugAdapterDescriptor).
-            // Currently two types of debug adapters are supported:
-            // - a debug adapter executable is specified as a command path and arguments (see [DebugAdapterExecutable](#DebugAdapterExecutable)),
-            // - a debug adapter server reachable via a communication port (see [DebugAdapterServer](#DebugAdapterServer)).
-            // If the method is not implemented the default behavior is this:
-            //   createDebugAdapter(session: DebugSession, executable: DebugAdapterExecutable) {
-            //      if (typeof session.configuration.debugServer === 'number') {
-            //         return new DebugAdapterServer(session.configuration.debugServer);
-            //      }
-            //      return executable;
-            //   }
-            //  @param session The [debug session](#DebugSession) for which the debug adapter will be used.
-            //  @param executable The debug adapter's executable information as specified in the package.json (or undefined if no such information exists).
-            const descriptor = await descriptorFactory.createDebugAdapterDescriptor(session, executable);
-            if (descriptor) {
-                if (DebugAdapterServer.is(descriptor)) {
-                    return connectSocketDebugAdapter(descriptor);
-                } else if (DebugAdapterExecutable.is(descriptor)) {
-                    return startDebugAdapter(descriptor);
-                } else if (DebugAdapterNamedPipeServer.is(descriptor)) {
-                    return connectPipeDebugAdapter(descriptor);
-                } else if (DebugAdapterInlineImplementation.is(descriptor)) {
-                    return connectInlineDebugAdapter(descriptor);
-                }
-            }
-        }
-
-        if ('debugServer' in debugConfiguration) {
-            return connectSocketDebugAdapter({ port: debugConfiguration.debugServer });
-        } else {
-            if (!executable) {
-                throw new Error('It is not possible to provide debug adapter executable.');
-            }
-            return startDebugAdapter(executable);
-        }
+        return this.getAdapterCreator(debugConfiguration).createDebugAdapter(session, debugConfiguration, executable, descriptorFactory);
     }
 
     protected async resolveDebugAdapterExecutable(debugConfiguration: theia.DebugConfiguration): Promise<theia.DebugAdapterExecutable | undefined> {
@@ -448,7 +412,7 @@ export class DebugExtImpl implements DebugExt {
             } else {
                 const contributionPath = this.contributionPaths.get(type);
                 if (contributionPath) {
-                    return resolveDebugAdapterExecutable(contributionPath, contribution);
+                    return this.getAdapterCreator(debugConfiguration).resolveDebugAdapterExecutable(contributionPath, contribution);
                 }
             }
         }
@@ -469,4 +433,9 @@ export class DebugExtImpl implements DebugExt {
             index: 0
         };
     }
+
+    private getAdapterCreator(debugConfiguration: theia.DebugConfiguration): PluginDebugAdapterCreator {
+        const pluginType = this.contributionTypes.get(debugConfiguration.type);
+        return pluginType === 'frontend' ? this.frontendAdapterCreator : this.backendAdapterCreator;
+    }
 }

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

@@ -0,0 +1,50 @@
+// *****************************************************************************
+// Copyright (C) 2022 Arm 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 * as theia from '@theia/plugin';
+import { DebugAdapter } from '@theia/debug/lib/common/debug-model';
+import { PluginPackageDebuggersContribution } from '../../common';
+import { DebugAdapterInlineImplementation } from '../types-impl';
+import { InlineDebugAdapter } from '@theia/debug/lib/common/inline-debug-adapter';
+
+export class PluginDebugAdapterCreator {
+    public async resolveDebugAdapterExecutable(_pluginPath: string, _debuggerContribution: PluginPackageDebuggersContribution): Promise<theia.DebugAdapterExecutable | undefined> {
+        // Node is required to run the default executable
+        return undefined;
+    }
+
+    public async createDebugAdapter(
+        session: theia.DebugSession,
+        _debugConfiguration: theia.DebugConfiguration,
+        executable: theia.DebugAdapterExecutable | undefined,
+        descriptorFactory: theia.DebugAdapterDescriptorFactory | undefined
+    ): Promise<DebugAdapter> {
+        if (descriptorFactory) {
+            const descriptor = await descriptorFactory.createDebugAdapterDescriptor(session, executable);
+            if (descriptor) {
+                if (DebugAdapterInlineImplementation.is(descriptor)) {
+                    return this.connectInlineDebugAdapter(descriptor);
+                }
+            }
+        }
+
+        throw new Error('It is not possible to provide debug adapter executable.');
+    }
+
+    public connectInlineDebugAdapter(adapter: DebugAdapterInlineImplementation): InlineDebugAdapter {
+        return new InlineDebugAdapter(adapter.implementation);
+    }
+}

package/src/plugin/{node/debug → debug}/plugin-debug-adapter-session.ts

@@ -14,10 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { DebugAdapterSessionImpl } from '@theia/debug/lib/node/debug-adapter-session';
+import { DebugAdapterSessionImpl } from '@theia/debug/lib/common/debug-adapter-session';
 import * as theia from '@theia/plugin';
-import { DebugAdapter } from '@theia/debug/lib/node/debug-model';
-import { Channel } from '@theia/debug/lib/common/debug-service';
+import { DebugAdapter } from '@theia/debug/lib/common/debug-model';
+import { DebugChannel } from '@theia/debug/lib/common/debug-service';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -43,7 +43,7 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
         this.configuration = theiaSession.configuration;
     }
 
-    override async start(channel: Channel): Promise<void> {
+    override async start(channel: DebugChannel): Promise<void> {
         if (this.tracker.onWillStartSession) {
             this.tracker.onWillStartSession();
         }

package/src/plugin/languages-utils.ts

@@ -24,9 +24,10 @@ export function serializeEnterRules(rules?: theia.OnEnterRule[]): SerializedOnEn
 
     return rules.map(r =>
     ({
-        action: r.action,
         beforeText: serializeRegExp(r.beforeText),
-        afterText: serializeRegExp(r.afterText)
+        afterText: serializeRegExp(r.afterText),
+        previousLineText: serializeRegExp(r.previousLineText),
+        action: r.action,
     } as SerializedOnEnterRule));
 }