@theia/plugin-ext 1.70.0-next.28 → 1.70.0-next.43

package/src/hosted/node/scanners/scanner-theia.ts

@@ -177,9 +177,17 @@ export abstract class AbstractPluginScanner implements PluginScanner {
             licenseUrl: this.getLicenseUrl(plugin),
             readmeUrl: this.getReadmeUrl(plugin)
         };
+        this.applyTrustExtraction(plugin, result);
         return result;
     }
 
+    protected applyTrustExtraction(plugin: PluginPackage, result: PluginModel): void {
+        const untrustedWorkspacesSupport = plugin.capabilities?.untrustedWorkspaces?.supported;
+        if (untrustedWorkspacesSupport !== undefined) {
+            result.untrustedWorkspacesSupport = untrustedWorkspacesSupport;
+        }
+    }
+
     protected getReadmeUrl(plugin: PluginPackage): string | undefined {
         return this.getPluginRootFileUrl(plugin, ['readme.md', 'readme.txt', 'readme']);
     }

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

@@ -87,15 +87,6 @@ import { CodeActionTriggerKind } from '../../plugin/types-impl';
 import { IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { FileUploadService } from '@theia/filesystem/lib/common/upload/file-upload';
 
-/**
- * @monaco-uplift The public API declares these functions as (languageId: string, service).
- * Confirm that the functions delegate to a handler that accepts a LanguageSelector rather than just a string.
- * Relevant code in node_modules/@theia/monaco-editor-core/src/vs/editor/standalone/browser/standaloneLanguages.ts
- */
-interface RegistrationFunction<T> {
-    (languageId: MonacoLanguageSelector.LanguageSelector, service: T): Disposable;
-}
-
 @injectable()
 export class LanguagesMainImpl implements LanguagesMain, Disposable {
 
@@ -175,7 +166,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
 
     $registerCompletionSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], triggerCharacters: string[], supportsResolveDetails: boolean): void {
         this.register(handle,
-            (monaco.languages.registerCompletionItemProvider as RegistrationFunction<monaco.languages.CompletionItemProvider>)(this.toLanguageSelector(selector), {
+            monaco.languages.registerCompletionItemProvider(this.toLanguageSelector(selector), {
                 triggerCharacters,
                 provideCompletionItems: (model, position, context, token) => this.provideCompletionItems(handle, model, position, context, token),
                 resolveCompletionItem: supportsResolveDetails
@@ -214,19 +205,19 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDefinitionProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const definitionProvider = this.createDefinitionProvider(handle);
-        this.register(handle, (monaco.languages.registerDefinitionProvider as RegistrationFunction<monaco.languages.DefinitionProvider>)(languageSelector, definitionProvider));
+        this.register(handle, monaco.languages.registerDefinitionProvider(languageSelector, definitionProvider));
     }
 
     $registerDeclarationProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const declarationProvider = this.createDeclarationProvider(handle);
-        this.register(handle, (monaco.languages.registerDeclarationProvider as RegistrationFunction<monaco.languages.DeclarationProvider>)(languageSelector, declarationProvider));
+        this.register(handle, monaco.languages.registerDeclarationProvider(languageSelector, declarationProvider));
     }
 
     $registerReferenceProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const referenceProvider = this.createReferenceProvider(handle);
-        this.register(handle, (monaco.languages.registerReferenceProvider as RegistrationFunction<monaco.languages.ReferenceProvider>)(languageSelector, referenceProvider));
+        this.register(handle, monaco.languages.registerReferenceProvider(languageSelector, referenceProvider));
     }
 
     protected createReferenceProvider(handle: number): monaco.languages.ReferenceProvider {
@@ -257,8 +248,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerSignatureHelpProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], metadata: theia.SignatureHelpProviderMetadata): void {
         const languageSelector = this.toLanguageSelector(selector);
         const signatureHelpProvider = this.createSignatureHelpProvider(handle, metadata);
-        this.register(handle, (monaco.languages.registerSignatureHelpProvider as RegistrationFunction<monaco.languages.SignatureHelpProvider>)
-            (languageSelector, signatureHelpProvider));
+        this.register(handle, monaco.languages.registerSignatureHelpProvider(languageSelector, signatureHelpProvider));
     }
 
     $clearDiagnostics(id: string): void {
@@ -277,8 +267,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerImplementationProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const implementationProvider = this.createImplementationProvider(handle);
-        this.register(handle, (monaco.languages.registerImplementationProvider as RegistrationFunction<monaco.languages.ImplementationProvider>)
-            (languageSelector, implementationProvider));
+        this.register(handle, monaco.languages.registerImplementationProvider(languageSelector, implementationProvider));
     }
 
     protected createImplementationProvider(handle: number): monaco.languages.ImplementationProvider {
@@ -314,8 +303,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerTypeDefinitionProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const typeDefinitionProvider = this.createTypeDefinitionProvider(handle);
-        this.register(handle, (monaco.languages.registerTypeDefinitionProvider as RegistrationFunction<monaco.languages.TypeDefinitionProvider>)
-            (languageSelector, typeDefinitionProvider));
+        this.register(handle, monaco.languages.registerTypeDefinitionProvider(languageSelector, typeDefinitionProvider));
     }
 
     protected createTypeDefinitionProvider(handle: number): monaco.languages.TypeDefinitionProvider {
@@ -351,7 +339,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerHoverProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const hoverProvider = this.createHoverProvider(handle);
-        this.register(handle, (monaco.languages.registerHoverProvider as RegistrationFunction<monaco.languages.HoverProvider>)(languageSelector, hoverProvider));
+        this.register(handle, monaco.languages.registerHoverProvider(languageSelector, hoverProvider));
     }
 
     protected createHoverProvider(handle: number): monaco.languages.HoverProvider {
@@ -375,7 +363,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         const languageSelector = this.toLanguageSelector(selector);
         const evaluatableExpressionProvider = this.createEvaluatableExpressionProvider(handle);
         this.register(handle,
-            (StandaloneServices.get(ILanguageFeaturesService).evaluatableExpressionProvider.register as RegistrationFunction<EvaluatableExpressionProvider>)
+            (StandaloneServices.get(ILanguageFeaturesService).evaluatableExpressionProvider.register)
                 (languageSelector, evaluatableExpressionProvider));
     }
 
@@ -394,7 +382,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         const languageSelector = this.toLanguageSelector(selector);
         const inlineValuesProvider = this.createInlineValuesProvider(handle);
         this.register(handle,
-            (StandaloneServices.get(ILanguageFeaturesService).inlineValuesProvider.register as RegistrationFunction<InlineValuesProvider>)
+            (StandaloneServices.get(ILanguageFeaturesService).inlineValuesProvider.register)
                 (languageSelector, inlineValuesProvider));
     }
 
@@ -420,8 +408,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentHighlightProvider(handle: number, _pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const documentHighlightProvider = this.createDocumentHighlightProvider(handle);
-        this.register(handle, (monaco.languages.registerDocumentHighlightProvider as RegistrationFunction<monaco.languages.DocumentHighlightProvider>)
-            (languageSelector, documentHighlightProvider));
+        this.register(handle, monaco.languages.registerDocumentHighlightProvider(languageSelector, documentHighlightProvider));
     }
 
     protected createDocumentHighlightProvider(handle: number): monaco.languages.DocumentHighlightProvider {
@@ -476,7 +463,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentLinkProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const linkProvider = this.createLinkProvider(handle);
-        this.register(handle, (monaco.languages.registerLinkProvider as RegistrationFunction<monaco.languages.LinkProvider>)(languageSelector, linkProvider));
+        this.register(handle, monaco.languages.registerLinkProvider(languageSelector, linkProvider));
     }
 
     protected createLinkProvider(handle: number): monaco.languages.LinkProvider {
@@ -525,7 +512,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             lensProvider.onDidChange = emitter.event;
         }
 
-        this.register(handle, (monaco.languages.registerCodeLensProvider as RegistrationFunction<monaco.languages.CodeLensProvider>)(languageSelector, lensProvider));
+        this.register(handle, monaco.languages.registerCodeLensProvider(languageSelector, lensProvider));
     }
 
     protected createCodeLensProvider(handle: number): monaco.languages.CodeLensProvider {
@@ -567,7 +554,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerOutlineSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], displayName?: string): void {
         const languageSelector = this.toLanguageSelector(selector);
         const symbolProvider = this.createDocumentSymbolProvider(handle, displayName);
-        this.register(handle, (monaco.languages.registerDocumentSymbolProvider as RegistrationFunction<monaco.languages.DocumentSymbolProvider>)(languageSelector, symbolProvider));
+        this.register(handle, monaco.languages.registerDocumentSymbolProvider(languageSelector, symbolProvider));
     }
 
     protected createDocumentSymbolProvider(handle: number, displayName?: string): monaco.languages.DocumentSymbolProvider {
@@ -672,8 +659,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentFormattingSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const documentFormattingEditSupport = this.createDocumentFormattingSupport(handle, pluginInfo);
-        this.register(handle, (monaco.languages.registerDocumentFormattingEditProvider as RegistrationFunction<monaco.languages.DocumentFormattingEditProvider>)
-            (languageSelector, documentFormattingEditSupport));
+        this.register(handle, monaco.languages.registerDocumentFormattingEditProvider(languageSelector, documentFormattingEditSupport));
     }
 
     createDocumentFormattingSupport(handle: number, pluginInfo: PluginInfo): monaco.languages.DocumentFormattingEditProvider {
@@ -695,8 +681,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerRangeFormattingSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const rangeFormattingEditProvider = this.createRangeFormattingSupport(handle, pluginInfo);
-        this.register(handle, (monaco.languages.registerDocumentRangeFormattingEditProvider as RegistrationFunction<monaco.languages.DocumentRangeFormattingEditProvider>)
-            (languageSelector, rangeFormattingEditProvider));
+        this.register(handle, monaco.languages.registerDocumentRangeFormattingEditProvider(languageSelector, rangeFormattingEditProvider));
     }
 
     createRangeFormattingSupport(handle: number, pluginInfo: PluginInfo): monaco.languages.DocumentRangeFormattingEditProvider {
@@ -718,8 +703,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerOnTypeFormattingProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], autoFormatTriggerCharacters: string[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const onTypeFormattingProvider = this.createOnTypeFormattingProvider(handle, autoFormatTriggerCharacters);
-        this.register(handle, (monaco.languages.registerOnTypeFormattingEditProvider as RegistrationFunction<monaco.languages.OnTypeFormattingEditProvider>)
-            (languageSelector, onTypeFormattingProvider));
+        this.register(handle, monaco.languages.registerOnTypeFormattingEditProvider(languageSelector, onTypeFormattingProvider));
     }
 
     protected createOnTypeFormattingProvider(
@@ -747,11 +731,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         );
     }
 
-    createDocumentDropEditProvider(handle: number, _metadata?: DocumentDropEditProviderMetadata): DocumentDropEditProvider {
+    createDocumentDropEditProvider(handle: number, metadata?: DocumentDropEditProviderMetadata): DocumentDropEditProvider {
         return {
-            // @monaco-uplift id and dropMimeTypes should be supported by the monaco drop editor provider after 1.82.0
-            // id?: string;
-            // dropMimeTypes: metadata?.dropMimeTypes ?? ['*/*'],
+            dropMimeTypes: metadata?.dropMimeTypes ?? ['*/*'],
             provideDocumentDropEdits: async (model, position, dataTransfer, token) => this.provideDocumentDropEdits(handle, model, position, dataTransfer, token)
         };
     }
@@ -772,7 +754,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             provider.onDidChange = emitter.event;
         }
 
-        this.register(handle, (monaco.languages.registerFoldingRangeProvider as RegistrationFunction<monaco.languages.FoldingRangeProvider>)(languageSelector, provider));
+        this.register(handle, monaco.languages.registerFoldingRangeProvider(languageSelector, provider));
     }
 
     createFoldingRangeProvider(handle: number): monaco.languages.FoldingRangeProvider {
@@ -796,7 +778,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerSelectionRangeProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const provider = this.createSelectionRangeProvider(handle);
-        this.register(handle, (monaco.languages.registerSelectionRangeProvider as RegistrationFunction<monaco.languages.SelectionRangeProvider>)(languageSelector, provider));
+        this.register(handle, monaco.languages.registerSelectionRangeProvider(languageSelector, provider));
     }
 
     protected createSelectionRangeProvider(handle: number): monaco.languages.SelectionRangeProvider {
@@ -813,7 +795,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerDocumentColorProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const colorProvider = this.createColorProvider(handle);
-        this.register(handle, (monaco.languages.registerColorProvider as RegistrationFunction<monaco.languages.DocumentColorProvider>)(languageSelector, colorProvider));
+        this.register(handle, monaco.languages.registerColorProvider(languageSelector, colorProvider));
     }
 
     createColorProvider(handle: number): monaco.languages.DocumentColorProvider {
@@ -864,7 +846,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             this.register(eventHandle, emitter);
             inlayHintsProvider.onDidChangeInlayHints = emitter.event;
         }
-        this.register(handle, (monaco.languages.registerInlayHintsProvider as RegistrationFunction<monaco.languages.InlayHintsProvider>)(languageSelector, inlayHintsProvider));
+        this.register(handle, monaco.languages.registerInlayHintsProvider(languageSelector, inlayHintsProvider));
 
     }
 
@@ -923,11 +905,11 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                 context: monaco.languages.InlineCompletionContext,
                 token: CancellationToken
             ): Promise<IdentifiableInlineCompletions | undefined> => this.proxy.$provideInlineCompletions(handle, model.uri, position, context, token),
-            freeInlineCompletions: (completions: IdentifiableInlineCompletions): void => {
+            disposeInlineCompletions: (completions: IdentifiableInlineCompletions): void => {
                 this.proxy.$freeInlineCompletionsList(handle, completions.pid);
             }
         };
-        this.register(handle, (monaco.languages.registerInlineCompletionsProvider as RegistrationFunction<monaco.languages.InlineCompletionsProvider>)(languageSelector, provider));
+        this.register(handle, monaco.languages.registerInlineCompletionsProvider(languageSelector, provider));
     }
 
     $registerQuickFixProvider(
@@ -1005,7 +987,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     $registerRenameProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], supportsResolveLocation: boolean): void {
         const languageSelector = this.toLanguageSelector(selector);
         const renameProvider = this.createRenameProvider(handle, supportsResolveLocation);
-        this.register(handle, (monaco.languages.registerRenameProvider as RegistrationFunction<monaco.languages.RenameProvider>)(languageSelector, renameProvider));
+        this.register(handle, monaco.languages.registerRenameProvider(languageSelector, renameProvider));
     }
 
     protected createRenameProvider(handle: number, supportsResolveLocation: boolean): monaco.languages.RenameProvider {
@@ -1140,12 +1122,12 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             event = emitter.event;
         }
         const provider = this.createDocumentSemanticTokensProvider(handle, legend, event);
-        this.register(handle, (monaco.languages.registerDocumentSemanticTokensProvider as RegistrationFunction<monaco.languages.DocumentSemanticTokensProvider>)
-            (languageSelector, provider));
+        this.register(handle, monaco.languages.registerDocumentSemanticTokensProvider(languageSelector, provider));
     }
 
     protected createDocumentSemanticTokensProvider(handle: number, legend: theia.SemanticTokensLegend, event?: Event<void>): monaco.languages.DocumentSemanticTokensProvider {
         return {
+            onDidChange: event,
             releaseDocumentSemanticTokens: resultId => {
                 if (resultId) {
                     this.proxy.$releaseDocumentSemanticTokens(handle, parseInt(resultId, 10));
@@ -1193,14 +1175,14 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             event = emitter.event;
         }
         const provider = this.createDocumentRangeSemanticTokensProvider(handle, legend, event);
-        this.register(handle, (monaco.languages.registerDocumentRangeSemanticTokensProvider as RegistrationFunction<monaco.languages.DocumentRangeSemanticTokensProvider>)
-            (languageSelector, provider));
+        this.register(handle, monaco.languages.registerDocumentRangeSemanticTokensProvider(languageSelector, provider));
     }
 
     protected createDocumentRangeSemanticTokensProvider(
-        handle: number, legend: theia.SemanticTokensLegend, _onDidChangeEvent?: Event<void>
+        handle: number, legend: theia.SemanticTokensLegend, event?: Event<void>
     ): monaco.languages.DocumentRangeSemanticTokensProvider {
         return {
+            onDidChange: event,
             getLegend: () => legend,
             provideDocumentRangeSemanticTokens: async (model, range, token) => {
                 const encodedDto = await this.proxy.$provideDocumentRangeSemanticTokens(handle, model.uri, range, token);
@@ -1219,7 +1201,6 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                 }
                 throw new Error('Unexpected');
             },
-            // @monaco-uplift onDidChange property is not yet available with the current monaco version, probably with the next monaco update then
         };
     }
 
@@ -1251,7 +1232,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         const languageSelector = this.toLanguageSelector(selector);
         const linkedEditingRangeProvider = this.createLinkedEditingRangeProvider(handle);
         this.register(handle,
-            (monaco.languages.registerLinkedEditingRangeProvider as RegistrationFunction<monaco.languages.LinkedEditingRangeProvider>)(languageSelector, linkedEditingRangeProvider)
+            monaco.languages.registerLinkedEditingRangeProvider(languageSelector, linkedEditingRangeProvider)
         );
     }
 

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

@@ -26,7 +26,7 @@ import {
     noopWidgetStatusBarContribution,
     WidgetStatusBarContribution
 } from '@theia/core/lib/browser';
-import { MaybePromise, CommandContribution, ResourceResolver, bindRootContributionProvider, URI, generateUuid, PreferenceContribution } from '@theia/core/lib/common';
+import { MaybePromise, CommandContribution, ResourceResolver, bindRootContributionProvider, URI, generateUuid, PreferenceContribution, nls } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging';
 import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
 import { HostedPluginWatcher } from '../../hosted/browser/hosted-plugin-watcher';
@@ -91,8 +91,10 @@ import { WebviewSecondaryWindowSupport } from './webview/webview-secondary-windo
 import { CustomEditorUndoRedoHandler } from './custom-editors/custom-editor-undo-redo-handler';
 import { CustomEditorNavigationContribution } from './custom-editors/custom-editor-navigation-contribution';
 import { bindWebviewPreferences } from '../common/webview-preferences';
+import { bindPluginHostEnvironmentPreferences } from '../common/plugin-host-environment-preferences';
 import { WebviewFrontendPreferenceContribution } from './webview/webview-frontend-preference-contribution';
 import { PluginExtToolbarItemArgumentProcessor } from './plugin-ext-argument-processor';
+import { WorkspaceRestriction, WorkspaceRestrictionContribution } from '@theia/workspace/lib/browser/workspace-trust-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -183,6 +185,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     })).inSingletonScope();
 
     bindWebviewPreferences(bind);
+    bindPluginHostEnvironmentPreferences(bind);
     bind(WebviewFrontendPreferenceContribution).toSelf().inSingletonScope();
     bind(PreferenceContribution).toService(WebviewFrontendPreferenceContribution);
     bind(WebviewEnvironment).toSelf().inSingletonScope();
@@ -298,4 +301,31 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(PluginExtToolbarItemArgumentProcessor).toSelf().inSingletonScope();
     bind(ArgumentProcessorContribution).toService(PluginExtToolbarItemArgumentProcessor);
 
+    bind(WorkspaceRestrictionContribution).toDynamicValue(ctx => {
+        const hostedPlugin = ctx.container.get(HostedPluginSupport);
+        return {
+            getRestrictions(): WorkspaceRestriction[] {
+                if (hostedPlugin.disabledByTrust.size === 0) {
+                    return [];
+                }
+                return [{
+                    label: nls.localize('theia/plugin-ext/extensionsRestrictedMode',
+                        'Some extensions are disabled in Restricted Mode'),
+                    details: Array.from(hostedPlugin.disabledByTrust)
+                }];
+            },
+            requiresReloadOnTrustChange(newTrust: boolean): boolean {
+                if (newTrust) {
+                    // Granting trust: reload only if plugins were actually blocked.
+                    return hostedPlugin.disabledByTrust.size > 0;
+                }
+                // Revoking trust: reload only if any loaded plugin declares supported: false,
+                // meaning it must be stopped now that the workspace is no longer trusted.
+                return hostedPlugin.plugins.some(
+                    p => p.model.untrustedWorkspacesSupport === false
+                );
+            }
+        };
+    }).inSingletonScope();
+
 });

package/src/main/browser/plugin-ext-widget.tsx

@@ -17,7 +17,7 @@
 import * as React from '@theia/core/shared/react';
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import { Message } from '@theia/core/shared/@lumino/messaging';
-import { PluginMetadata } from '../../common/plugin-protocol';
+import { PluginIdentifiers, PluginMetadata } from '../../common/plugin-protocol';
 import { ReactWidget } from '@theia/core/lib/browser/widgets/react-widget';
 import { AlertMessage } from '@theia/core/lib/browser/widgets/alert-message';
 import { HostedPluginSupport, PluginProgressLocation } from '../../hosted/browser/hosted-plugin';
@@ -87,11 +87,18 @@ export class PluginWidget extends ReactWidget {
     }
 
     private renderPlugin(plugin: PluginMetadata): JSX.Element {
-        return <div key={plugin.model.name} className={this.createPluginClassName(plugin)}>
+        const unversionedId = PluginIdentifiers.componentsToUnversionedId(plugin.model);
+        const isRestrictedByTrust = this.pluginService.disabledByTrust.has(unversionedId);
+        return <div key={plugin.model.name} className={this.createPluginClassName(plugin, isRestrictedByTrust)}>
             <div className='column flexcontainer pluginInformationContainer'>
                 <div className='row flexcontainer'>
                     <div className={codicon('list-selection')}></div>
                     <div title={plugin.model.name} className='pluginName noWrapInfo'>{plugin.model.name}</div>
+                    {isRestrictedByTrust && (
+                        <span className='pluginRestrictedBadge' title={nls.localizeByDefault('Disabled in Restricted Mode')}>
+                            {nls.localizeByDefault('Restricted Mode')}
+                        </span>
+                    )}
                 </div>
                 <div className='row flexcontainer'>
                     <div className='pluginVersion'>{plugin.model.version}</div>
@@ -106,8 +113,11 @@ export class PluginWidget extends ReactWidget {
         </div>;
     }
 
-    protected createPluginClassName(plugin: PluginMetadata): string {
+    protected createPluginClassName(plugin: PluginMetadata, isRestrictedByTrust: boolean = false): string {
         const classNames = ['pluginHeaderContainer'];
+        if (isRestrictedByTrust) {
+            classNames.push('pluginDisabledByTrust');
+        }
         return classNames.join(' ');
     }
 

package/src/main/browser/style/plugin-sidebar.css

@@ -71,3 +71,16 @@
 .plugins-tab-icon::before {
   content: "\f0fe";
 }
+
+.theia-plugins .pluginHeaderContainer.pluginDisabledByTrust {
+  opacity: 0.6;
+}
+
+.theia-plugins .pluginRestrictedBadge {
+  font-size: var(--theia-ui-font-size0);
+  color: var(--theia-statusBarItem-prominentForeground);
+  background-color: var(--theia-statusBarItem-prominentBackground);
+  border-radius: 2px;
+  padding: calc(var(--theia-ui-padding) / 3 * 2);
+  white-space: nowrap;
+}

package/src/main/common/plugin-host-environment-preferences.ts

@@ -0,0 +1,48 @@
+// *****************************************************************************
+// Copyright (C) 2026 STMicroelectronics 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { interfaces } from '@theia/core/shared/inversify';
+import { PreferenceContribution, PreferenceSchema } from '@theia/core/lib/common/preferences';
+import { nls } from '@theia/core/lib/common/nls';
+
+export const SUPPORT_NODE_GLOBAL_NAVIGATOR_PREF = 'extensions.supportNodeGlobalNavigator';
+
+export const PluginHostEnvironmentPreferenceSchema: PreferenceSchema = {
+    properties: {
+        [SUPPORT_NODE_GLOBAL_NAVIGATOR_PREF]: {
+            type: 'boolean',
+            description: nls.localize('theia/plugin-ext/supportNodeGlobalNavigator',
+                'If enabled, the global navigator object in the extension host will be defined as provided by Node.js. '
+                + 'Extensions may use the presence of the navigator object as a hint that code is running in a browser. '
+                + 'Disabling this (the default) undefines the navigator in the extension host to preserve this assumption.'),
+            default: false,
+        }
+    }
+};
+
+/**
+ * Mutable state holder for the navigator preference, injected as a constant value
+ * so it can be safely resolved in connection-scoped containers (no async dependencies).
+ */
+export const PluginHostNavigatorState = Symbol('PluginHostNavigatorState');
+export interface PluginHostNavigatorState {
+    supportNodeGlobalNavigator: boolean;
+}
+
+export function bindPluginHostEnvironmentPreferences(bind: interfaces.Bind): void {
+    bind(PreferenceContribution).toConstantValue({ schema: PluginHostEnvironmentPreferenceSchema });
+    bind(PluginHostNavigatorState).toConstantValue({ supportNodeGlobalNavigator: false });
+}

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

@@ -47,6 +47,8 @@ import { RemoteCliContribution } from '@theia/core/lib/node/remote/remote-cli-co
 import { PluginRemoteCopyContribution } from './plugin-remote-copy-contribution';
 import { RemoteCopyContribution } from '@theia/core/lib/node/remote/remote-copy-contribution';
 import { bindWebviewPreferences } from '../common/webview-preferences';
+import { bindPluginHostEnvironmentPreferences } from '../common/plugin-host-environment-preferences';
+import { PluginHostNavigatorStateInitializer } from './plugin-host-navigator-state-initializer';
 
 export function bindMainBackend(bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void {
     bind(PluginApiContribution).toSelf().inSingletonScope();
@@ -104,5 +106,7 @@ export function bindMainBackend(bind: interfaces.Bind, unbind: interfaces.Unbind
 
     rebind(LocalizationServerImpl).to(PluginLocalizationServer).inSingletonScope();
     bindWebviewPreferences(bind);
-
+    bindPluginHostEnvironmentPreferences(bind);
+    bind(PluginHostNavigatorStateInitializer).toSelf().inSingletonScope();
+    bind(BackendApplicationContribution).toService(PluginHostNavigatorStateInitializer);
 }

package/src/main/node/plugin-host-navigator-state-initializer.ts

@@ -0,0 +1,47 @@
+// *****************************************************************************
+// Copyright (C) 2026 STMicroelectronics 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { PreferenceService } from '@theia/core/lib/common/preferences';
+import { BackendApplicationContribution } from '@theia/core/lib/node';
+import { PluginHostNavigatorState, SUPPORT_NODE_GLOBAL_NAVIGATOR_PREF } from '../common/plugin-host-environment-preferences';
+
+/**
+ * Keeps {@link PluginHostNavigatorState} in sync with the navigator preference.
+ *
+ * `PreferenceService` has async dependencies and cannot be injected in
+ * connection-scoped containers. This contribution runs in the root container
+ * and mutates the shared state object by reference so that
+ * `HostedPluginProcess` (connection-scoped) always sees the latest value.
+ */
+@injectable()
+export class PluginHostNavigatorStateInitializer implements BackendApplicationContribution {
+
+    @inject(PreferenceService)
+    protected readonly preferences: PreferenceService;
+
+    @inject(PluginHostNavigatorState)
+    protected readonly state: PluginHostNavigatorState;
+
+    onStart(): void {
+        this.state.supportNodeGlobalNavigator = this.preferences.get<boolean>(SUPPORT_NODE_GLOBAL_NAVIGATOR_PREF, false);
+        this.preferences.onPreferenceChanged(e => {
+            if (e.preferenceName === SUPPORT_NODE_GLOBAL_NAVIGATOR_PREF) {
+                this.state.supportNodeGlobalNavigator = this.preferences.get<boolean>(SUPPORT_NODE_GLOBAL_NAVIGATOR_PREF, false);
+            }
+        });
+    }
+}

package/src/plugin/file-system-event-service-ext-impl.ts

@@ -30,7 +30,7 @@
 
 import { Emitter, WaitUntilEvent, AsyncEmitter, WaitUntilData } from '@theia/core/lib/common/event';
 import { IRelativePattern, parse } from '@theia/core/lib/common/glob';
-import { UriComponents } from '@theia/core/shared/vscode-uri';
+import { UriComponents } from '../common/uri-components';
 import { Disposable, URI, WorkspaceEdit } from './types-impl';
 import { EditorsAndDocumentsExtImpl as ExtHostDocumentsAndEditors } from './editors-and-documents';
 import type * as vscode from '@theia/plugin';

package/src/plugin/file-system-ext-impl.ts

@@ -28,14 +28,13 @@
 /* eslint-disable @typescript-eslint/tslint/config */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { UriComponents } from '@theia/core/shared/vscode-uri';
+import { Schemes as Schemas, UriComponents } from '../common/uri-components';
 import { FileChangeType, FileSystemError, URI } from './types-impl';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { PLUGIN_RPC_CONTEXT, FileSystemExt, FileSystemMain, IFileChangeDto } from '../common/plugin-api-rpc';
 import * as vscode from '@theia/plugin';
 import * as files from '@theia/filesystem/lib/common/files';
 import * as typeConverter from './type-converters';
-import { Schemes as Schemas } from '../common/uri-components';
 import { State, StateMachine, LinkComputer, Edge } from '../common/link-computer';
 import { commonPrefixLength } from '@theia/core/lib/common/strings';
 import { CharCode } from '@theia/core/lib/common/char-code';

package/src/plugin/types-impl.ts

@@ -24,7 +24,8 @@
 import { UUID } from '@theia/core/shared/@lumino/coreutils';
 import { illegalArgument } from '../common/errors';
 import type * as theia from '@theia/plugin';
-import { URI as CodeURI, UriComponents } from '@theia/core/shared/vscode-uri';
+import { URI as CodeURI } from '@theia/core/shared/vscode-uri';
+import { UriComponents } from '../common/uri-components';
 import { relative } from '../common/paths-util';
 import { startsWithIgnoreCase } from '@theia/core/lib/common/strings';
 import { SymbolKind } from '../common/plugin-api-rpc-model';