@theia/plugin-ext 1.42.0 → 1.43.0

package/src/main/browser/view/plugin-view-registry.ts

@@ -18,7 +18,7 @@ import { injectable, inject, postConstruct, optional } from '@theia/core/shared/
 import {
     ApplicationShell, ViewContainer as ViewContainerWidget, WidgetManager, QuickViewService,
     ViewContainerIdentifier, ViewContainerTitleOptions, Widget, FrontendApplicationContribution,
-    StatefulWidget, CommonMenus, TreeViewWelcomeWidget, codicon, ViewContainerPart, BaseWidget
+    StatefulWidget, CommonMenus, TreeViewWelcomeWidget, ViewContainerPart, BaseWidget
 } from '@theia/core/lib/browser';
 import { ViewContainer, View, ViewWelcome, PluginViewType } from '../../../common';
 import { PluginSharedStyle } from '../plugin-shared-style';
@@ -39,6 +39,7 @@ import { OutputWidget } from '@theia/output/lib/browser/output-widget';
 import { DebugConsoleContribution } from '@theia/debug/lib/browser/console/debug-console-contribution';
 import { TreeViewWidget } from './tree-view-widget';
 import { SEARCH_VIEW_CONTAINER_ID } from '@theia/search-in-workspace/lib/browser/search-in-workspace-factory';
+import { TEST_VIEW_CONTAINER_ID } from '@theia/test/lib/browser/view/test-view-contribution';
 import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 import { WebviewView, WebviewViewResolver } from '../webview-views/webview-views';
 import { WebviewWidget, WebviewWidgetIdentifier } from '../webview/webview';
@@ -46,6 +47,7 @@ import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { v4 } from 'uuid';
 import { nls } from '@theia/core';
 import { TheiaDockPanel } from '@theia/core/lib/browser/shell/theia-dock-panel';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export const PLUGIN_VIEW_FACTORY_ID = 'plugin-view';
 export const PLUGIN_VIEW_CONTAINER_FACTORY_ID = 'plugin-view-container';
@@ -102,6 +104,10 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
     private readonly viewDataState = new Map<string, object>();
 
     private readonly webviewViewResolvers = new Map<string, WebviewViewResolver>();
+    protected readonly onNewResolverRegisteredEmitter = new Emitter<{ readonly viewType: string }>();
+    readonly onNewResolverRegistered = this.onNewResolverRegisteredEmitter.event;
+
+    private readonly webviewViewRevivals = new Map<string, { readonly webview: WebviewView; readonly revival: Deferred<void> }>();
 
     private static readonly ID_MAPPINGS: Map<string, string> = new Map([
         // VS Code Viewlets
@@ -111,6 +117,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         [DebugWidget.ID, 'workbench.view.debug'],
         ['vsx-extensions-view-container', 'workbench.view.extensions'], // cannot use the id from 'vsx-registry' package because of circular dependency
         [PROBLEMS_WIDGET_ID, 'workbench.panel.markers'],
+        [TEST_VIEW_CONTAINER_ID, 'workbench.view.testing'],
         [OutputWidget.ID, 'workbench.panel.output'],
         [DebugConsoleContribution.options.id, 'workbench.panel.repl'],
         // Theia does not have a single terminal widget, but instead each terminal gets its own widget. Therefore "the terminal widget is active" doesn't make sense in Theia
@@ -136,6 +143,9 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             if (factoryId === SEARCH_VIEW_CONTAINER_ID && widget instanceof ViewContainerWidget) {
                 waitUntil(this.prepareViewContainer('search', widget));
             }
+            if (factoryId === TEST_VIEW_CONTAINER_ID && widget instanceof ViewContainerWidget) {
+                waitUntil(this.prepareViewContainer('test', widget));
+            }
             if (factoryId === DebugWidget.ID && widget instanceof DebugWidget) {
                 const viewContainer = widget['sessionWidget']['viewContainer'];
                 waitUntil(this.prepareViewContainer('debug', viewContainer));
@@ -161,11 +171,6 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 disposable.push(event.widget.onDidDispose(() => disposable.dispose()));
             }
         });
-        this.doRegisterViewContainer('test', 'left', {
-            label: nls.localizeByDefault('Test'),
-            iconClass: codicon('beaker'),
-            closeable: true
-        });
         this.contextKeyService.onDidChange(e => {
             for (const [, view] of this.views.values()) {
                 const clauseContext = this.viewClauseContexts.get(view.id);
@@ -382,47 +387,51 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
+    async resolveWebviewView(viewId: string, webview: WebviewView, cancellation: CancellationToken): Promise<void> {
+        const resolver = this.webviewViewResolvers.get(viewId);
+        if (resolver) {
+            return resolver.resolve(webview, cancellation);
+        }
+        const pendingRevival = this.webviewViewRevivals.get(viewId);
+        if (pendingRevival) {
+            return pendingRevival.revival.promise;
+        }
+        const pending = new Deferred<void>();
+        this.webviewViewRevivals.set(viewId, { webview, revival: pending });
+        return pending.promise;
+    }
+
     async registerWebviewView(viewId: string, resolver: WebviewViewResolver): Promise<Disposable> {
         if (this.webviewViewResolvers.has(viewId)) {
             throw new Error(`View resolver already registered for ${viewId}`);
         }
         this.webviewViewResolvers.set(viewId, resolver);
+        this.onNewResolverRegisteredEmitter.fire({ viewType: viewId });
 
-        const webviewView = await this.createNewWebviewView();
-        const token = CancellationToken.None;
-        this.getView(viewId).then(async view => {
-            if (view) {
-                if (view.isVisible) {
-                    await this.prepareView(view, webviewView.webview.identifier.id);
-                } else {
-                    const toDisposeOnDidExpandView = new DisposableCollection(this.onDidExpandView(async id => {
-                        if (id === viewId) {
-                            dispose();
-                            await this.prepareView(view, webviewView.webview.identifier.id);
-                        }
-                    }));
-                    const dispose = () => toDisposeOnDidExpandView.dispose();
-                    view.disposed.connect(dispose);
-                    toDisposeOnDidExpandView.push(Disposable.create(() => view.disposed.disconnect(dispose)));
-                }
-            }
-        });
+        const toDispose = new DisposableCollection(Disposable.create(() => this.webviewViewResolvers.delete(viewId)));
+        this.initView(viewId, toDispose);
 
-        resolver.resolve(webviewView, token);
+        const pendingRevival = this.webviewViewRevivals.get(viewId);
+        if (pendingRevival) {
+            resolver.resolve(pendingRevival.webview, CancellationToken.None).then(() => {
+                this.webviewViewRevivals.delete(viewId);
+                pendingRevival.revival.resolve();
+            });
+        }
 
-        return Disposable.create(() => {
-            this.webviewViewResolvers.delete(viewId);
-        });
+        return toDispose;
     }
 
-    async createNewWebviewView(): Promise<WebviewView> {
+    protected async createNewWebviewView(viewId: string): Promise<WebviewView> {
         const webview = await this.widgetManager.getOrCreateWidget<WebviewWidget>(
             WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: v4() });
         webview.setContentOptions({ allowScripts: true });
 
         let _description: string | undefined;
+        let _resolved = false;
+        let _pendingResolution: Promise<void> | undefined;
 
-        return {
+        const webviewView: WebviewView = {
             webview,
 
             get onDidChangeVisibility(): Event<boolean> { return webview.onDidChangeVisibility; },
@@ -442,9 +451,36 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             onDidChangeBadge: webview.onDidChangeBadge,
             onDidChangeBadgeTooltip: webview.onDidChangeBadgeTooltip,
 
-            dispose: webview.dispose,
+            dispose: () => {
+                _resolved = false;
+                webview.dispose();
+                toDispose.dispose();
+            },
+            resolve: async () => {
+                if (_resolved) {
+                    return;
+                }
+                if (_pendingResolution) {
+                    return _pendingResolution;
+                }
+                _pendingResolution = this.resolveWebviewView(viewId, webviewView, CancellationToken.None).then(() => {
+                    _resolved = true;
+                    _pendingResolution = undefined;
+                });
+                return _pendingResolution;
+            },
             show: webview.show
         };
+
+        const toDispose = this.onNewResolverRegistered(resolver => {
+            if (resolver.viewType === viewId) {
+                // Potentially re-activate if we have a new resolver
+                webviewView.resolve();
+            }
+        });
+
+        webviewView.resolve();
+        return webviewView;
     }
 
     registerViewWelcome(viewWelcome: ViewWelcome): Disposable {
@@ -526,7 +562,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return this.getView(viewId);
     }
 
-    protected async prepareView(widget: PluginViewWidget, webviewId?: string): Promise<void> {
+    protected async prepareView(widget: PluginViewWidget): Promise<void> {
         const data = this.views.get(widget.options.viewId);
         if (!data) {
             return;
@@ -536,6 +572,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             widget.title.label = view.name;
         }
         const currentDataWidget = widget.widgets[0];
+        const webviewId = currentDataWidget instanceof WebviewWidget ? currentDataWidget.identifier?.id : undefined;
         const viewDataWidget = await this.createViewDataWidget(view.id, webviewId);
         if (widget.isDisposed) {
             viewDataWidget?.dispose();
@@ -653,6 +690,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             case EXPLORER_VIEW_CONTAINER_ID: return 'explorer';
             case SCM_VIEW_CONTAINER_ID: return 'scm';
             case SEARCH_VIEW_CONTAINER_ID: return 'search';
+            case TEST_VIEW_CONTAINER_ID: return 'test';
             case undefined: return container.parent?.parent instanceof DebugWidget ? 'debug' : container.id;
             case PLUGIN_VIEW_CONTAINER_FACTORY_ID: return this.toViewContainerId(description.options);
             default: return container.id;
@@ -669,6 +707,9 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         if (viewContainerId === 'search') {
             return this.widgetManager.getWidget<ViewContainerWidget>(SEARCH_VIEW_CONTAINER_ID);
         }
+        if (viewContainerId === 'test') {
+            return this.widgetManager.getWidget<ViewContainerWidget>(TEST_VIEW_CONTAINER_ID);
+        }
         if (viewContainerId === 'debug') {
             const debug = await this.widgetManager.getWidget(DebugWidget.ID);
             if (debug instanceof DebugWidget) {
@@ -717,6 +758,12 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 await this.prepareViewContainer('search', search);
             }
         })().catch(console.error));
+        promises.push((async () => {
+            const test = await this.widgetManager.getWidget(TEST_VIEW_CONTAINER_ID);
+            if (test instanceof ViewContainerWidget) {
+                await this.prepareViewContainer('test', test);
+            }
+        })().catch(console.error));
         promises.push((async () => {
             const debug = await this.widgetManager.getWidget(DebugWidget.ID);
             if (debug instanceof DebugWidget) {
@@ -793,35 +840,37 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             this.viewDataProviders.delete(viewId);
             this.viewDataState.delete(viewId);
         }));
-        this.getView(viewId).then(async view => {
-            if (toDispose.disposed) {
-                return;
-            }
-            if (view) {
-                if (view.isVisible) {
-                    await this.prepareView(view);
-                } else {
-                    const toDisposeOnDidExpandView = new DisposableCollection(this.onDidExpandView(async id => {
-                        if (id === viewId) {
-                            unsubscribe();
-                            await this.prepareView(view);
-                        }
-                    }));
-                    const unsubscribe = () => toDisposeOnDidExpandView.dispose();
-                    view.disposed.connect(unsubscribe);
-                    toDisposeOnDidExpandView.push(Disposable.create(() => view.disposed.disconnect(unsubscribe)));
-                    toDispose.push(toDisposeOnDidExpandView);
-                }
-            }
-        });
+        this.initView(viewId, toDispose);
         return toDispose;
     }
 
+    protected async initView(viewId: string, toDispose: DisposableCollection): Promise<void> {
+        const view = await this.getView(viewId);
+        if (toDispose.disposed) {
+            return;
+        }
+        if (view) {
+            if (view.isVisible) {
+                await this.prepareView(view);
+            } else {
+                const toDisposeOnDidExpandView = new DisposableCollection(this.onDidExpandView(async id => {
+                    if (id === viewId) {
+                        unsubscribe();
+                        await this.prepareView(view);
+                    }
+                }));
+                const unsubscribe = () => toDisposeOnDidExpandView.dispose();
+                view.disposed.connect(unsubscribe);
+                toDisposeOnDidExpandView.push(Disposable.create(() => view.disposed.disconnect(unsubscribe)));
+                toDispose.push(toDisposeOnDidExpandView);
+            }
+        }
+    }
+
     protected async createViewDataWidget(viewId: string, webviewId?: string): Promise<Widget | undefined> {
         const view = this.views.get(viewId);
         if (view?.[1]?.type === PluginViewType.Webview) {
-            const webviewWidget = this.widgetManager.getWidget(WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: webviewId });
-            return webviewWidget;
+            return this.createWebviewWidget(viewId, webviewId);
         }
         const provider = this.viewDataProviders.get(viewId);
         if (!view || !provider) {
@@ -839,6 +888,15 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return widget;
     }
 
+    protected async createWebviewWidget(viewId: string, webviewId?: string): Promise<Widget | undefined> {
+        if (!webviewId) {
+            const webviewView = await this.createNewWebviewView(viewId);
+            webviewId = webviewView.webview.identifier.id;
+        }
+        const webviewWidget = this.widgetManager.getWidget(WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: webviewId });
+        return webviewWidget;
+    }
+
     protected storeViewDataStateOnDispose(viewId: string, widget: Widget & StatefulWidget): void {
         const dispose = widget.dispose.bind(widget);
         widget.dispose = () => {

package/src/main/browser/webview-views/webview-views-main.ts

@@ -83,7 +83,10 @@ export class WebviewViewsMainImpl implements WebviewViewsMain, Disposable {
                     webviewView.webview.options = options;
                 }
 
-                webviewView.onDidChangeVisibility(visible => {
+                webviewView.onDidChangeVisibility(async visible => {
+                    if (visible) {
+                        await webviewView.resolve();
+                    }
                     this.proxy.$onDidChangeWebviewViewVisibility(handle, visible);
                 });
 
@@ -93,7 +96,7 @@ export class WebviewViewsMainImpl implements WebviewViewsMain, Disposable {
                 });
 
                 try {
-                    this.proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
+                    await this.proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
                 } catch (error) {
                     this.logger.error(`Error resolving webview view '${viewType}': ${error}`);
                     webviewView.webview.setHTML('failed to load plugin webview view');

package/src/main/browser/webview-views/webview-views.ts

@@ -35,6 +35,7 @@ export interface WebviewView {
 
     dispose(): void;
     show(preserveFocus: boolean): void;
+    resolve(): Promise<void>;
 }
 
 export interface WebviewViewResolver {

package/src/main/node/plugin-service.ts

@@ -26,6 +26,7 @@ import { environment } from '@theia/core/shared/@theia/application-package/lib/e
 import { WsRequestValidatorContribution } from '@theia/core/lib/node/ws-request-validators';
 import { MaybePromise } from '@theia/core/lib/common';
 import { ApplicationPackage } from '@theia/core/shared/@theia/application-package';
+import { BackendRemoteService } from '@theia/core/lib/node/backend-remote-service';
 
 @injectable()
 export class PluginApiContribution implements BackendApplicationContribution, WsRequestValidatorContribution {
@@ -37,6 +38,9 @@ export class PluginApiContribution implements BackendApplicationContribution, Ws
     @inject(ApplicationPackage)
     protected readonly applicationPackage: ApplicationPackage;
 
+    @inject(BackendRemoteService)
+    protected readonly remoteService: BackendRemoteService;
+
     @postConstruct()
     protected init(): void {
         const webviewExternalEndpoint = this.webviewExternalEndpoint();
@@ -47,7 +51,14 @@ export class PluginApiContribution implements BackendApplicationContribution, Ws
     configure(app: express.Application): void {
         const webviewApp = express();
         webviewApp.use('/webview', express.static(path.join(this.applicationPackage.projectPath, 'lib', 'webview', 'pre')));
-        app.use(vhost(this.webviewExternalEndpointRegExp, webviewApp));
+        if (this.remoteService.isRemoteServer()) {
+            // Any request to `subdomain.localhost:port/webview/...` will get redirected to the remote system.
+            // However, it will get redirected directly to the `localhost:remotePort` address, losing the subdomain info.
+            // In this case, we simply serve the webviews on a path.
+            app.use(webviewApp);
+        } else {
+            app.use(vhost(this.webviewExternalEndpointRegExp, webviewApp));
+        }
     }
 
     allowWsUpgrade(request: http.IncomingMessage): MaybePromise<boolean> {

package/src/plugin/command-registry.ts

@@ -25,15 +25,11 @@ import { RPCProtocol } from '../common/rpc-protocol';
 import { Disposable } from './types-impl';
 import { DisposableCollection } from '@theia/core';
 import { KnownCommands } from './known-commands';
+import { ArgumentProcessor } from '../common/commands';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Handler = <T>(...args: any[]) => T | PromiseLike<T | undefined>;
 
-export interface ArgumentProcessor {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    processArgument(arg: any): any;
-}
-
 export class CommandRegistryImpl implements CommandRegistryExt {
 
     private proxy: CommandRegistryMain;

package/src/plugin/notebook/notebook-kernels.ts

@@ -483,11 +483,13 @@ class NotebookCellExecutionTask implements Disposable {
             });
     }
 
-    private async updateOutputItems(items: theia.NotebookCellOutputItem | theia.NotebookCellOutputItem[], output: theia.NotebookCellOutput, append: boolean): Promise<void> {
+    private async updateOutputItems(items: theia.NotebookCellOutputItem | theia.NotebookCellOutputItem[],
+        output: theia.NotebookCellOutput, append: boolean): Promise<void> {
         items = NotebookCellOutputConverter.ensureUniqueMimeTypes(Array.isArray(items) ? items : [items], true);
         return this.updateSoon({
             editType: CellExecutionUpdateType.OutputItems,
             items: items.map(NotebookCellOutputItem.from),
+            outputId: output instanceof NotebookCellOutput ? output.outputId : '',
             append
         });
     }

package/src/plugin/notebook/notebooks.ts

@@ -137,7 +137,6 @@ export class NotebooksExtImpl implements NotebooksExt {
         this.notebookSerializer.set(handle, serializer);
         this.notebookProxy.$registerNotebookSerializer(
             handle,
-            { id: plugin.model.id, location: plugin.pluginUri },
             viewType,
             typeConverters.NotebookDocumentContentOptions.from(options),
         );
@@ -347,8 +346,7 @@ export class NotebooksExtImpl implements NotebooksExt {
     }
 
     async showNotebookDocument(notebookOrUri: theia.NotebookDocument | TheiaURI, options?: theia.NotebookDocumentShowOptions): Promise<theia.NotebookEditor> {
-
-        if (URI.isUri(notebookOrUri)) {
+        if (TheiaURI.isUri(notebookOrUri)) {
             notebookOrUri = await this.openNotebookDocument(notebookOrUri as TheiaURI);
         }
 

package/src/plugin/plugin-context.ts

@@ -161,7 +161,6 @@ import {
     TerminalLocation,
     TerminalExitReason,
     TerminalProfile,
-    TerminalQuickFixType,
     InlayHint,
     InlayHintKind,
     InlayHintLabelPart,
@@ -199,7 +198,10 @@ import {
     DocumentPasteEdit,
     ExternalUriOpenerPriority,
     EditSessionIdentityMatch,
-    TerminalOutputAnchor
+    TerminalOutputAnchor,
+    TerminalQuickFixExecuteTerminalCommand,
+    TerminalQuickFixOpener,
+    TestResultState
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -228,13 +230,6 @@ import { ClipboardExt } from './clipboard-ext';
 import { WebviewsExtImpl } from './webviews';
 import { ExtHostFileSystemEventService } from './file-system-event-service-ext-impl';
 import { LabelServiceExtImpl } from '../plugin/label-service';
-import {
-    createRunProfile,
-    createTestRun,
-    testItemCollection,
-    createTestItem,
-    invalidateTestResults
-} from './stubs/tests-api';
 import { TimelineExtImpl } from './timeline';
 import { ThemingExtImpl } from './theming';
 import { CommentsExtImpl } from './comments';
@@ -252,6 +247,7 @@ import { NotebookRenderersExtImpl } from './notebook/notebook-renderers';
 import { NotebookKernelsExtImpl } from './notebook/notebook-kernels';
 import { NotebookDocumentsExtImpl } from './notebook/notebook-documents';
 import { NotebookEditorsExtImpl } from './notebook/notebook-editors';
+import { TestingExtImpl } from './tests';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -299,6 +295,7 @@ export function createAPIFactory(
     const customEditorExt = rpc.set(MAIN_RPC_CONTEXT.CUSTOM_EDITORS_EXT, new CustomEditorsExtImpl(rpc, documents, webviewExt, workspaceExt));
     const webviewViewsExt = rpc.set(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT, new WebviewViewsExtImpl(rpc, webviewExt));
     const telemetryExt = rpc.set(MAIN_RPC_CONTEXT.TELEMETRY_EXT, new TelemetryExtImpl());
+    const testingExt = rpc.set(MAIN_RPC_CONTEXT.TESTING_EXT, new TestingExtImpl(rpc, commandRegistry));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
     return function (plugin: InternalPlugin): typeof theia {
@@ -993,28 +990,10 @@ export function createAPIFactory(
             }
         };
 
-        // Tests API (@stubbed)
-        // The following implementation is temporarily `@stubbed` and marked as such under `theia.d.ts`
         const tests: typeof theia.tests = {
-            createTestController(
-                provider,
-                controllerLabel: string,
-                refreshHandler?: (
-                    token: theia.CancellationToken
-                ) => Thenable<void> | void
-            ) {
-                return {
-                    id: provider,
-                    label: controllerLabel,
-                    items: testItemCollection,
-                    refreshHandler,
-                    createRunProfile,
-                    createTestRun,
-                    createTestItem,
-                    invalidateTestResults,
-                    dispose: () => undefined,
-                };
-            },
+            createTestController(id, label: string) {
+                return testingExt.createTestController(id, label);
+            }
         };
         /* End of Tests API */
 
@@ -1391,8 +1370,10 @@ export function createAPIFactory(
             TerminalExitReason,
             DocumentPasteEdit,
             ExternalUriOpenerPriority,
-            TerminalQuickFixType,
-            EditSessionIdentityMatch
+            TerminalQuickFixExecuteTerminalCommand,
+            TerminalQuickFixOpener,
+            EditSessionIdentityMatch,
+            TestResultState
         };
     };
 }

package/src/plugin/telemetry-ext.ts

@@ -294,5 +294,5 @@ export function cleanData(data: Record<string, any>, cleanUpPatterns: RegExp[]):
             return updatedProperty;
         }
         return undefined;
-    }, new Set());
+    });
 }

package/src/plugin/terminal-ext.ts

@@ -18,11 +18,12 @@ import { Terminal, TerminalOptions, PseudoTerminalOptions, ExtensionTerminalOpti
 import { TerminalServiceExt, TerminalServiceMain, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { Event, Emitter } from '@theia/core/lib/common/event';
+import { MultiKeyMap } from '@theia/core/lib/common/collections';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import * as theia from '@theia/plugin';
 import * as Converter from './type-converters';
 import { Disposable, EnvironmentVariableMutatorType, TerminalExitReason, ThemeIcon } from './types-impl';
-import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
+import { NO_ROOT_URI, SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/shell-terminal-protocol';
 import { ProvidedTerminalLink } from '../common/plugin-api-rpc-model';
 import { ThemeIcon as MonacoThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 
@@ -68,7 +69,7 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     private readonly onDidChangeTerminalStateEmitter = new Emitter<Terminal>();
     readonly onDidChangeTerminalState: theia.Event<Terminal> = this.onDidChangeTerminalStateEmitter.event;
 
-    protected environmentVariableCollections: Map<string, EnvironmentVariableCollection> = new Map();
+    protected environmentVariableCollections: MultiKeyMap<string, EnvironmentVariableCollectionImpl> = new MultiKeyMap(2);
 
     constructor(rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN);
@@ -303,46 +304,53 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
      *--------------------------------------------------------------------------------------------*/
     // some code copied and modified from https://github.com/microsoft/vscode/blob/1.49.0/src/vs/workbench/api/common/extHostTerminalService.ts
 
-    getEnvironmentVariableCollection(extensionIdentifier: string): theia.EnvironmentVariableCollection {
-        let collection = this.environmentVariableCollections.get(extensionIdentifier);
+    getEnvironmentVariableCollection(extensionIdentifier: string, rootUri: string = NO_ROOT_URI): theia.GlobalEnvironmentVariableCollection {
+        const that = this;
+        let collection = this.environmentVariableCollections.get([extensionIdentifier, rootUri]);
         if (!collection) {
-            collection = new EnvironmentVariableCollection();
-            this.setEnvironmentVariableCollection(extensionIdentifier, collection);
+            collection = new class extends EnvironmentVariableCollectionImpl {
+                override getScoped(scope: theia.EnvironmentVariableScope): theia.EnvironmentVariableCollection {
+                    return that.getEnvironmentVariableCollection(extensionIdentifier, scope.workspaceFolder?.uri.toString());
+                }
+            }(true);
+            this.setEnvironmentVariableCollection(extensionIdentifier, rootUri, collection);
         }
         return collection;
     }
 
-    private syncEnvironmentVariableCollection(extensionIdentifier: string, collection: EnvironmentVariableCollection): void {
+    private syncEnvironmentVariableCollection(extensionIdentifier: string, rootUri: string, collection: EnvironmentVariableCollectionImpl): void {
         const serialized = [...collection.map.entries()];
-        this.proxy.$setEnvironmentVariableCollection(collection.persistent, {
-            extensionIdentifier,
-            collection: serialized.length === 0 ? undefined : serialized,
-            description: Converter.fromMarkdownOrString(collection.description)
-        });
+        this.proxy.$setEnvironmentVariableCollection(collection.persistent, extensionIdentifier,
+            rootUri,
+            {
+                mutators: serialized,
+                description: Converter.fromMarkdownOrString(collection.description)
+            });
     }
 
-    private setEnvironmentVariableCollection(extensionIdentifier: string, collection: EnvironmentVariableCollection): void {
-        this.environmentVariableCollections.set(extensionIdentifier, collection);
+    private setEnvironmentVariableCollection(pluginIdentifier: string, rootUri: string, collection: EnvironmentVariableCollectionImpl): void {
+        this.environmentVariableCollections.set([pluginIdentifier, rootUri], collection);
         collection.onDidChangeCollection(() => {
             // When any collection value changes send this immediately, this is done to ensure
             // following calls to createTerminal will be created with the new environment. It will
             // result in more noise by sending multiple updates when called but collections are
             // expected to be small.
-            this.syncEnvironmentVariableCollection(extensionIdentifier, collection);
+            this.syncEnvironmentVariableCollection(pluginIdentifier, rootUri, collection);
         });
     }
 
-    $initEnvironmentVariableCollections(collections: [string, SerializableEnvironmentVariableCollection][]): void {
+    $initEnvironmentVariableCollections(collections: [string, string, boolean, SerializableEnvironmentVariableCollection][]): void {
         collections.forEach(entry => {
             const extensionIdentifier = entry[0];
-            const collection = new EnvironmentVariableCollection(entry[1]);
-            this.setEnvironmentVariableCollection(extensionIdentifier, collection);
+            const rootUri = entry[1];
+            const collection = new EnvironmentVariableCollectionImpl(entry[2], entry[3]);
+            this.setEnvironmentVariableCollection(extensionIdentifier, rootUri, collection);
         });
     }
 
 }
 
-export class EnvironmentVariableCollection implements theia.EnvironmentVariableCollection {
+export class EnvironmentVariableCollectionImpl implements theia.GlobalEnvironmentVariableCollection {
     readonly map: Map<string, theia.EnvironmentVariableMutator> = new Map();
     private _description?: string | theia.MarkdownString;
     private _persistent: boolean = true;
@@ -363,25 +371,31 @@ export class EnvironmentVariableCollection implements theia.EnvironmentVariableC
     onDidChangeCollection: Event<void> = this.onDidChangeCollectionEmitter.event;
 
     constructor(
+        persistent: boolean,
         serialized?: SerializableEnvironmentVariableCollection
     ) {
-        this.map = new Map(serialized);
+        this._persistent = persistent;
+        this.map = new Map(serialized?.mutators);
+    }
+
+    getScoped(scope: theia.EnvironmentVariableScope): theia.EnvironmentVariableCollection {
+        throw new Error('Cannot get scoped from a regular env var collection');
     }
 
     get size(): number {
         return this.map.size;
     }
 
-    replace(variable: string, value: string): void {
-        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Replace });
+    replace(variable: string, value: string, options?: theia.EnvironmentVariableMutatorOptions): void {
+        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Replace, options: options ?? { applyAtProcessCreation: true } });
     }
 
-    append(variable: string, value: string): void {
-        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Append });
+    append(variable: string, value: string, options?: theia.EnvironmentVariableMutatorOptions): void {
+        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Append, options: options ?? { applyAtProcessCreation: true } });
     }
 
-    prepend(variable: string, value: string): void {
-        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Prepend });
+    prepend(variable: string, value: string, options?: theia.EnvironmentVariableMutatorOptions): void {
+        this._setIfDiffers(variable, { value, type: EnvironmentVariableMutatorType.Prepend, options: options ?? { applyAtProcessCreation: true } });
     }
 
     private _setIfDiffers(variable: string, mutator: theia.EnvironmentVariableMutator): void {