@theia/plugin-ext 1.70.0-next.6 → 1.70.0-next.61

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/browser/text-editor-main.ts

@@ -95,8 +95,16 @@ export class TextEditorMain implements Disposable {
             this.toDisposeOnEditor.push(this.editor.onSelectionChanged(_ => {
                 this.updateProperties();
             }));
-            this.toDisposeOnEditor.push(monacoEditor.onDidChangeModel(() => {
-                this.setEditor(undefined);
+            this.toDisposeOnEditor.push(monacoEditor.onDidChangeModel(e => {
+                // Ignore visibility-related model changes (null ↔ model) triggered by
+                // the setModel(null) workaround in MonacoEditor.handleVisibilityChanged().
+                // cf. https://github.com/eclipse-theia/theia/issues/14880
+                // Only react to genuine model swaps where both old and new models exist.
+                // In practice, this condition is never met because MonacoEditor instances
+                // are created with a fixed document and never swap to a different model.
+                if (e.oldModelUrl && e.newModelUrl) {
+                    this.setEditor(undefined);
+                }
             }));
             this.toDisposeOnEditor.push(monacoEditor.onDidChangeCursorSelection(e => {
                 this.updateProperties(e.source);

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

@@ -24,7 +24,9 @@ import { ViewContainer, View, ViewWelcome, PluginViewType } from '../../../commo
 import { PluginSharedStyle } from '../plugin-shared-style';
 import { DebugWidget } from '@theia/debug/lib/browser/view/debug-widget';
 import { PluginViewWidget, PluginViewWidgetIdentifier } from './plugin-view-widget';
-import { SCM_VIEW_CONTAINER_ID, ScmContribution } from '@theia/scm/lib/browser/scm-contribution';
+import { SCM_VIEW_CONTAINER_ID, SCM_WIDGET_FACTORY_ID, ScmContribution } from '@theia/scm/lib/browser/scm-contribution';
+import { ScmWidget } from '@theia/scm/lib/browser/scm-widget';
+import { ScmTreeWidget } from '@theia/scm/lib/browser/scm-tree-widget';
 import { EXPLORER_VIEW_CONTAINER_ID, FileNavigatorWidget, FILE_NAVIGATOR_ID } from '@theia/navigator/lib/browser';
 import { FileNavigatorContribution } from '@theia/navigator/lib/browser/navigator-contribution';
 import { DebugFrontendApplicationContribution } from '@theia/debug/lib/browser/debug-frontend-application-contribution';
@@ -187,6 +189,17 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 }));
                 disposable.push(event.widget.onDidDispose(() => disposable.dispose()));
             }
+            if (event.widget instanceof ScmWidget) {
+                const disposable = new DisposableCollection();
+                disposable.push(this.registerViewWelcome({
+                    view: 'scm',
+                    content: nls.localizeByDefault('None of the registered source control providers work in Restricted Mode.')
+                        + `\n[${nls.localizeByDefault('Manage Workspace Trust')}](command:workspace:manageTrust)`,
+                    when: '!isWorkspaceTrusted',
+                    order: 0
+                }));
+                disposable.push(event.widget.onDidDispose(() => disposable.dispose()));
+            }
         });
         this.contextKeyService.onDidChange(e => {
             for (const [, view] of this.views.values()) {
@@ -561,6 +574,10 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         switch (viewId) {
             case 'explorer':
                 return this.widgetManager.getWidget<TreeViewWelcomeWidget>(FILE_NAVIGATOR_ID);
+            case 'scm': {
+                const scmWidget = await this.widgetManager.getWidget<ScmWidget>(SCM_WIDGET_FACTORY_ID);
+                return scmWidget?.resourceWidget as ScmTreeWidget | undefined;
+            }
             default:
                 return this.widgetManager.getWidget<TreeViewWelcomeWidget>(PLUGIN_VIEW_DATA_FACTORY_ID, { id: viewId });
         }

package/src/main/browser/webview/pre/main.js

@@ -154,29 +154,29 @@ globalThis.acquireVsCodeApi = (function() {
 
     let state = ${state ? `JSON.parse(${JSON.stringify(state)})` : undefined};
 
-    const forwardConsoleLog = (level, msg, args) => {
+    const forwardConsoleLog = (level, msg, ...args) => {
         let message, optionalParams;
         try {
             if (msg) {
                 message = JSON.stringify(msg) ?? null;
             }
-            if (args) {
+            if (args.length > 0) {
                 optionalParams = JSON.stringify(args) ?? null;
             }
         } catch (e) {
             // Log non serializable objects inside of view
-            originalConsole[level](msg, args);
+            originalConsole[level](msg, ...args);
             return;
         }
         originalPostMessage({ command: 'onconsole', data: { level, message, optionalParams } }, targetOrigin);
     };
 
-    console.log = (message, args) => forwardConsoleLog('log', message, args);
-    console.info = (message, args) => forwardConsoleLog('info', message, args);
-    console.warn = (message, args) => forwardConsoleLog('warn', message, args);
-    console.error = (message, args) => forwardConsoleLog('error', message, args);
-    console.debug = (message, args) => forwardConsoleLog('debug', message, args);
-    console.trace = (message, args) => forwardConsoleLog('trace', message, args);
+    console.log = (message, ...args) => forwardConsoleLog('log', message, ...args);
+    console.info = (message, ...args) => forwardConsoleLog('info', message, ...args);
+    console.warn = (message, ...args) => forwardConsoleLog('warn', message, ...args);
+    console.error = (message, ...args) => forwardConsoleLog('error', message, ...args);
+    console.debug = (message, ...args) => forwardConsoleLog('debug', message, ...args);
+    console.trace = (message, ...args) => forwardConsoleLog('trace', message, ...args);
 
     return () => {
         if (acquired) {
@@ -199,9 +199,8 @@ globalThis.acquireVsCodeApi = (function() {
     };
 })();
 globalThis.acquireTheiaApi = acquireVsCodeApi;
-delete window.parent;
-delete window.top;
-delete window.frameElement;        
+window.parent = window;
+window.frameElement = null;
 `;
     }
 

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

@@ -475,7 +475,7 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget, Extract
     protected forwardConsoleLog(log: WebviewConsoleLog): void {
         const message = `[webview: ${this.identifier.id}] ${log.message ? JSON.parse(log.message) : undefined}`;
         if (log.optionalParams !== undefined) {
-            console[log.level](message, JSON.parse(log.optionalParams));
+            console[log.level](message, ...JSON.parse(log.optionalParams));
         } else {
             console[log.level](message);
         }

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-deployer-impl.ts

@@ -181,6 +181,7 @@ export class PluginDeployerImpl implements PluginDeployer {
         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[]>();
+        const errors: Error[] = [];
 
         const queue: UnresolvedPluginEntry[] = [...plugins];
         while (queue.length) {
@@ -215,6 +216,7 @@ export class PluginDeployerImpl implements PluginDeployer {
                     }
                 } catch (e) {
                     console.error(`Failed to resolve plugins from '${entry.id}'`, e);
+                    errors.push(e instanceof Error ? e : new Error(String(e)));
                 }
             }));
             queue.length = 0;
@@ -229,6 +231,9 @@ export class PluginDeployerImpl implements PluginDeployer {
                 }
             }
         }
+        if (pluginsToDeploy.size === 0 && errors.length > 0) {
+            throw errors[0];
+        }
         return [...pluginsToDeploy.values()];
     }