@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.d.ts

@@ -1,7 +1,7 @@
 import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
 import { Event } from '../../../../base/common/event.js';
-import { IExtensionManifest, IExtension } from '../../../../platform/extensions/common/extensions.js';
-import { InstallExtensionResult, InstallVSIXOptions, ILocalExtension, IGalleryExtension, InstallOptions, IExtensionManagementService, InstallExtensionEvent, UninstallExtensionEvent, DidUninstallExtensionEvent } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IExtensionManifest, IExtension, ExtensionType } from '../../../../platform/extensions/common/extensions.js';
+import { InstallExtensionResult, InstallVSIXOptions, ILocalExtension, IGalleryExtension, InstallOptions, Metadata, IExtensionManagementService, InstallExtensionEvent, UninstallExtensionEvent, DidUninstallExtensionEvent } from '../../../../platform/extensionManagement/common/extensionManagement.js';
 import { URI } from '../../../../base/common/uri.js';
 
 type DidChangeProfileEvent = {
@@ -114,5 +114,25 @@ interface IWorkbenchExtensionEnablementService {
      */
     updateExtensionsEnablementsWhenWorkspaceTrustChanges(): Promise<void>;
 }
+interface IScannedExtension extends IExtension {
+    readonly metadata?: Metadata;
+}
+type ScanOptions = {
+    readonly skipInvalidExtensions?: boolean;
+};
+declare const IWebExtensionsScannerService: ServiceIdentifier<IWebExtensionsScannerService>;
+interface IWebExtensionsScannerService {
+    readonly _serviceBrand: undefined;
+    scanSystemExtensions(): Promise<IExtension[]>;
+    scanUserExtensions(profileLocation: URI, options?: ScanOptions): Promise<IScannedExtension[]>;
+    scanExtensionsUnderDevelopment(): Promise<IExtension[]>;
+    scanExistingExtension(extensionLocation: URI, extensionType: ExtensionType, profileLocation: URI): Promise<IScannedExtension | null>;
+    addExtension(location: URI, metadata: Metadata, profileLocation: URI): Promise<IScannedExtension>;
+    addExtensionFromGallery(galleryExtension: IGalleryExtension, metadata: Metadata, profileLocation: URI): Promise<IScannedExtension>;
+    removeExtension(extension: IScannedExtension, profileLocation: URI): Promise<void>;
+    copyExtensions(fromProfileLocation: URI, toProfileLocation: URI, filter: (extension: IScannedExtension) => boolean): Promise<void>;
+    updateMetadata(extension: IScannedExtension, metaData: Partial<Metadata>, profileLocation: URI): Promise<IScannedExtension>;
+    scanExtensionManifest(extensionLocation: URI): Promise<IExtensionManifest | null>;
+}
 
-export { type DidChangeProfileEvent, type DidChangeProfileForServerEvent, type DidUninstallExtensionOnServerEvent, EnablementState, type IExtensionManagementServer, IProfileAwareExtensionManagementService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, type InstallExtensionOnServerEvent, type UninstallExtensionOnServerEvent };
+export { type DidChangeProfileEvent, type DidChangeProfileForServerEvent, type DidUninstallExtensionOnServerEvent, EnablementState, type IExtensionManagementServer, IProfileAwareExtensionManagementService, type IScannedExtension, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, type InstallExtensionOnServerEvent, type ScanOptions, type UninstallExtensionOnServerEvent };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.js

@@ -1,7 +1,10 @@
 import { refineServiceDecorator, createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
 const IProfileAwareExtensionManagementService = refineServiceDecorator(IExtensionManagementService);
 const IExtensionManagementServerService = ( createDecorator('extensionManagementServerService'));
+const getDefaultIconPath = () => ( ( FileAccess.asBrowserUri('vs/workbench/services/extensionManagement/common/media/defaultIcon.png')).toString(true));
 const IWorkbenchExtensionManagementService = refineServiceDecorator(IProfileAwareExtensionManagementService);
 const IWorkbenchExtensionEnablementService = ( createDecorator('extensionEnablementService'));
-export { IExtensionManagementServerService, IProfileAwareExtensionManagementService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService };
+const IWebExtensionsScannerService = ( createDecorator('IWebExtensionsScannerService'));
+export { IExtensionManagementServerService, IProfileAwareExtensionManagementService, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, getDefaultIconPath };

package/vscode/src/vs/workbench/services/extensionRecommendations/common/extensionRecommendations.js

@@ -0,0 +1,4 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IExtensionRecommendationsService = ( createDecorator('extensionRecommendationsService'));
+const IExtensionIgnoredRecommendationsService = ( createDecorator('IExtensionIgnoredRecommendationsService'));
+export { IExtensionIgnoredRecommendationsService, IExtensionRecommendationsService };

package/vscode/src/vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig.js

@@ -0,0 +1,255 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { distinct, flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/json.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { IFileService, FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { isWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IJSONEditingService } from '../../configuration/common/jsonEditing.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+const EXTENSIONS_CONFIG = '.vscode/extensions.json';
+const IWorkspaceExtensionsConfigService = ( createDecorator('IWorkspaceExtensionsConfigService'));
+let WorkspaceExtensionsConfigService = class WorkspaceExtensionsConfigService extends Disposable {
+    constructor(workspaceContextService, fileService, quickInputService, modelService, languageService, jsonEditingService) {
+        super();
+        this.workspaceContextService = workspaceContextService;
+        this.fileService = fileService;
+        this.quickInputService = quickInputService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.jsonEditingService = jsonEditingService;
+        this._onDidChangeExtensionsConfigs = this._register(( new Emitter()));
+        this.onDidChangeExtensionsConfigs = this._onDidChangeExtensionsConfigs.event;
+        this._register(workspaceContextService.onDidChangeWorkspaceFolders(e => this._onDidChangeExtensionsConfigs.fire()));
+        this._register(fileService.onDidFilesChange(e => {
+            const workspace = workspaceContextService.getWorkspace();
+            if ((workspace.configuration && e.affects(workspace.configuration))
+                || ( workspace.folders.some(folder => e.affects(folder.toResource(EXTENSIONS_CONFIG))))) {
+                this._onDidChangeExtensionsConfigs.fire();
+            }
+        }));
+    }
+    async getExtensionsConfigs() {
+        const workspace = this.workspaceContextService.getWorkspace();
+        const result = [];
+        const workspaceExtensionsConfigContent = workspace.configuration ? await this.resolveWorkspaceExtensionConfig(workspace.configuration) : undefined;
+        if (workspaceExtensionsConfigContent) {
+            result.push(workspaceExtensionsConfigContent);
+        }
+        result.push(...(await Promise.all(( workspace.folders.map(
+            workspaceFolder => this.resolveWorkspaceFolderExtensionConfig(workspaceFolder)
+        )))));
+        return result;
+    }
+    async getRecommendations() {
+        const configs = await this.getExtensionsConfigs();
+        return distinct(flatten(( configs.map(c => c.recommendations ? ( c.recommendations.map(c => c.toLowerCase())) : []))));
+    }
+    async getUnwantedRecommendations() {
+        const configs = await this.getExtensionsConfigs();
+        return distinct(flatten(( configs.map(c => c.unwantedRecommendations ? ( c.unwantedRecommendations.map(c => c.toLowerCase())) : []))));
+    }
+    async toggleRecommendation(extensionId) {
+        extensionId = extensionId.toLowerCase();
+        const workspace = this.workspaceContextService.getWorkspace();
+        const workspaceExtensionsConfigContent = workspace.configuration ? await this.resolveWorkspaceExtensionConfig(workspace.configuration) : undefined;
+        const workspaceFolderExtensionsConfigContents = ( new ResourceMap());
+        await Promise.all(( workspace.folders.map(async (workspaceFolder) => {
+            const extensionsConfigContent = await this.resolveWorkspaceFolderExtensionConfig(workspaceFolder);
+            workspaceFolderExtensionsConfigContents.set(workspaceFolder.uri, extensionsConfigContent);
+        })));
+        const isWorkspaceRecommended = workspaceExtensionsConfigContent && workspaceExtensionsConfigContent.recommendations?.some(r => r.toLowerCase() === extensionId);
+        const recommendedWorksapceFolders = workspace.folders.filter(workspaceFolder => workspaceFolderExtensionsConfigContents.get(workspaceFolder.uri)?.recommendations?.some(r => r.toLowerCase() === extensionId));
+        const isRecommended = isWorkspaceRecommended || recommendedWorksapceFolders.length > 0;
+        const workspaceOrFolders = isRecommended
+            ? await this.pickWorkspaceOrFolders(recommendedWorksapceFolders, isWorkspaceRecommended ? workspace : undefined, ( localizeWithPath(
+            'vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig',
+            'select for remove',
+            "Remove extension recommendation from"
+        )))
+            : await this.pickWorkspaceOrFolders(workspace.folders, workspace.configuration ? workspace : undefined, ( localizeWithPath(
+            'vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig',
+            'select for add',
+            "Add extension recommendation to"
+        )));
+        for (const workspaceOrWorkspaceFolder of workspaceOrFolders) {
+            if (isWorkspace(workspaceOrWorkspaceFolder)) {
+                await this.addOrRemoveWorkspaceRecommendation(extensionId, workspaceOrWorkspaceFolder, workspaceExtensionsConfigContent, !isRecommended);
+            }
+            else {
+                await this.addOrRemoveWorkspaceFolderRecommendation(extensionId, workspaceOrWorkspaceFolder, workspaceFolderExtensionsConfigContents.get(workspaceOrWorkspaceFolder.uri), !isRecommended);
+            }
+        }
+    }
+    async toggleUnwantedRecommendation(extensionId) {
+        const workspace = this.workspaceContextService.getWorkspace();
+        const workspaceExtensionsConfigContent = workspace.configuration ? await this.resolveWorkspaceExtensionConfig(workspace.configuration) : undefined;
+        const workspaceFolderExtensionsConfigContents = ( new ResourceMap());
+        await Promise.all(( workspace.folders.map(async (workspaceFolder) => {
+            const extensionsConfigContent = await this.resolveWorkspaceFolderExtensionConfig(workspaceFolder);
+            workspaceFolderExtensionsConfigContents.set(workspaceFolder.uri, extensionsConfigContent);
+        })));
+        const isWorkspaceUnwanted = workspaceExtensionsConfigContent && workspaceExtensionsConfigContent.unwantedRecommendations?.some(r => r === extensionId);
+        const unWantedWorksapceFolders = workspace.folders.filter(workspaceFolder => workspaceFolderExtensionsConfigContents.get(workspaceFolder.uri)?.unwantedRecommendations?.some(r => r === extensionId));
+        const isUnwanted = isWorkspaceUnwanted || unWantedWorksapceFolders.length > 0;
+        const workspaceOrFolders = isUnwanted
+            ? await this.pickWorkspaceOrFolders(unWantedWorksapceFolders, isWorkspaceUnwanted ? workspace : undefined, ( localizeWithPath(
+            'vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig',
+            'select for remove',
+            "Remove extension recommendation from"
+        )))
+            : await this.pickWorkspaceOrFolders(workspace.folders, workspace.configuration ? workspace : undefined, ( localizeWithPath(
+            'vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig',
+            'select for add',
+            "Add extension recommendation to"
+        )));
+        for (const workspaceOrWorkspaceFolder of workspaceOrFolders) {
+            if (isWorkspace(workspaceOrWorkspaceFolder)) {
+                await this.addOrRemoveWorkspaceUnwantedRecommendation(extensionId, workspaceOrWorkspaceFolder, workspaceExtensionsConfigContent, !isUnwanted);
+            }
+            else {
+                await this.addOrRemoveWorkspaceFolderUnwantedRecommendation(extensionId, workspaceOrWorkspaceFolder, workspaceFolderExtensionsConfigContents.get(workspaceOrWorkspaceFolder.uri), !isUnwanted);
+            }
+        }
+    }
+    async addOrRemoveWorkspaceFolderRecommendation(extensionId, workspaceFolder, extensionsConfigContent, add) {
+        const values = [];
+        if (add) {
+            values.push({ path: ['recommendations'], value: [...(extensionsConfigContent.recommendations || []), extensionId] });
+            if (extensionsConfigContent.unwantedRecommendations && ( extensionsConfigContent.unwantedRecommendations.some(e => e === extensionId))) {
+                values.push({ path: ['unwantedRecommendations'], value: extensionsConfigContent.unwantedRecommendations.filter(e => e !== extensionId) });
+            }
+        }
+        else if (extensionsConfigContent.recommendations) {
+            values.push({ path: ['recommendations'], value: extensionsConfigContent.recommendations.filter(e => e !== extensionId) });
+        }
+        if (values.length) {
+            return this.jsonEditingService.write(workspaceFolder.toResource(EXTENSIONS_CONFIG), values, true);
+        }
+    }
+    async addOrRemoveWorkspaceRecommendation(extensionId, workspace, extensionsConfigContent, add) {
+        const values = [];
+        if (extensionsConfigContent) {
+            if (add) {
+                values.push({ path: ['extensions', 'recommendations'], value: [...(extensionsConfigContent.recommendations || []), extensionId] });
+                if (extensionsConfigContent.unwantedRecommendations && ( extensionsConfigContent.unwantedRecommendations.some(e => e === extensionId))) {
+                    values.push({ path: ['extensions', 'unwantedRecommendations'], value: extensionsConfigContent.unwantedRecommendations.filter(e => e !== extensionId) });
+                }
+            }
+            else if (extensionsConfigContent.recommendations) {
+                values.push({ path: ['extensions', 'recommendations'], value: extensionsConfigContent.recommendations.filter(e => e !== extensionId) });
+            }
+        }
+        else if (add) {
+            values.push({ path: ['extensions'], value: { recommendations: [extensionId] } });
+        }
+        if (values.length) {
+            return this.jsonEditingService.write(workspace.configuration, values, true);
+        }
+    }
+    async addOrRemoveWorkspaceFolderUnwantedRecommendation(extensionId, workspaceFolder, extensionsConfigContent, add) {
+        const values = [];
+        if (add) {
+            values.push({ path: ['unwantedRecommendations'], value: [...(extensionsConfigContent.unwantedRecommendations || []), extensionId] });
+            if (extensionsConfigContent.recommendations && ( extensionsConfigContent.recommendations.some(e => e === extensionId))) {
+                values.push({ path: ['recommendations'], value: extensionsConfigContent.recommendations.filter(e => e !== extensionId) });
+            }
+        }
+        else if (extensionsConfigContent.unwantedRecommendations) {
+            values.push({ path: ['unwantedRecommendations'], value: extensionsConfigContent.unwantedRecommendations.filter(e => e !== extensionId) });
+        }
+        if (values.length) {
+            return this.jsonEditingService.write(workspaceFolder.toResource(EXTENSIONS_CONFIG), values, true);
+        }
+    }
+    async addOrRemoveWorkspaceUnwantedRecommendation(extensionId, workspace, extensionsConfigContent, add) {
+        const values = [];
+        if (extensionsConfigContent) {
+            if (add) {
+                values.push({ path: ['extensions', 'unwantedRecommendations'], value: [...(extensionsConfigContent.unwantedRecommendations || []), extensionId] });
+                if (extensionsConfigContent.recommendations && ( extensionsConfigContent.recommendations.some(e => e === extensionId))) {
+                    values.push({ path: ['extensions', 'recommendations'], value: extensionsConfigContent.recommendations.filter(e => e !== extensionId) });
+                }
+            }
+            else if (extensionsConfigContent.unwantedRecommendations) {
+                values.push({ path: ['extensions', 'unwantedRecommendations'], value: extensionsConfigContent.unwantedRecommendations.filter(e => e !== extensionId) });
+            }
+        }
+        else if (add) {
+            values.push({ path: ['extensions'], value: { unwantedRecommendations: [extensionId] } });
+        }
+        if (values.length) {
+            return this.jsonEditingService.write(workspace.configuration, values, true);
+        }
+    }
+    async pickWorkspaceOrFolders(workspaceFolders, workspace, placeHolder) {
+        const workspaceOrFolders = workspace ? [...workspaceFolders, workspace] : [...workspaceFolders];
+        if (workspaceOrFolders.length === 1) {
+            return workspaceOrFolders;
+        }
+        const folderPicks = ( workspaceFolders.map(workspaceFolder => {
+            return {
+                label: workspaceFolder.name,
+                description: ( localizeWithPath(
+                    'vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig',
+                    'workspace folder',
+                    "Workspace Folder"
+                )),
+                workspaceOrFolder: workspaceFolder,
+                iconClasses: getIconClasses(this.modelService, this.languageService, workspaceFolder.uri, FileKind.ROOT_FOLDER)
+            };
+        }));
+        if (workspace) {
+            folderPicks.push({ type: 'separator' });
+            folderPicks.push({
+                label: ( localizeWithPath(
+                    'vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig',
+                    'workspace',
+                    "Workspace"
+                )),
+                workspaceOrFolder: workspace,
+            });
+        }
+        const result = (await this.quickInputService.pick(folderPicks, { placeHolder, canPickMany: true })) || [];
+        return ( result.map(r => r.workspaceOrFolder));
+    }
+    async resolveWorkspaceExtensionConfig(workspaceConfigurationResource) {
+        try {
+            const content = await this.fileService.readFile(workspaceConfigurationResource);
+            const extensionsConfigContent = parse(( content.value.toString()))['extensions'];
+            return extensionsConfigContent ? this.parseExtensionConfig(extensionsConfigContent) : undefined;
+        }
+        catch (e) {  }
+        return undefined;
+    }
+    async resolveWorkspaceFolderExtensionConfig(workspaceFolder) {
+        try {
+            const content = await this.fileService.readFile(workspaceFolder.toResource(EXTENSIONS_CONFIG));
+            const extensionsConfigContent = parse(( content.value.toString()));
+            return this.parseExtensionConfig(extensionsConfigContent);
+        }
+        catch (e) {  }
+        return {};
+    }
+    parseExtensionConfig(extensionsConfigContent) {
+        return {
+            recommendations: distinct(( (extensionsConfigContent.recommendations || []).map(e => e.toLowerCase()))),
+            unwantedRecommendations: distinct(( (extensionsConfigContent.unwantedRecommendations || []).map(e => e.toLowerCase())))
+        };
+    }
+};
+WorkspaceExtensionsConfigService = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IQuickInputService)),
+    ( __param(3, IModelService)),
+    ( __param(4, ILanguageService)),
+    ( __param(5, IJSONEditingService))
+], WorkspaceExtensionsConfigService));
+export { EXTENSIONS_CONFIG, IWorkspaceExtensionsConfigService, WorkspaceExtensionsConfigService };

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.d.ts

@@ -0,0 +1,44 @@
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IExtension, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { IRemoteAuthorityResolverService, ResolverResult } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IRemoteExtensionsScannerService } from '../../../../platform/remote/common/remoteExtensionsScanner.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from '../../extensionManagement/common/extensionManagement.js';
+import { IExtensionHostKindPicker } from '../common/extensionHostKind.js';
+import { IExtensionService } from '../common/extensions.js';
+import { AbstractExtensionService, IExtensionHostFactory, ResolvedExtensions } from '../common/abstractExtensionService.js';
+import { IExtensionManifestPropertiesService } from '../common/extensionManifestPropertiesService.js';
+import { ExtensionsProposedApi } from '../common/extensionsProposedApi.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { IRemoteExplorerService } from '../../remote/common/remoteExplorerService.js';
+import { IUserDataInitializationService } from '../../userData/browser/userDataInit.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
+
+declare class ExtensionService extends AbstractExtensionService implements IExtensionService {
+    private readonly _browserEnvironmentService;
+    private readonly _webExtensionsScannerService;
+    private readonly _userDataInitializationService;
+    private readonly _userDataProfileService;
+    private readonly _workspaceTrustManagementService;
+    private readonly _remoteExplorerService;
+    constructor(extensionsProposedApi: ExtensionsProposedApi, extensionHostFactory: IExtensionHostFactory, extensionHostKindPicker: IExtensionHostKindPicker, instantiationService: IInstantiationService, notificationService: INotificationService, _browserEnvironmentService: IBrowserWorkbenchEnvironmentService, telemetryService: ITelemetryService, extensionEnablementService: IWorkbenchExtensionEnablementService, fileService: IFileService, productService: IProductService, extensionManagementService: IWorkbenchExtensionManagementService, contextService: IWorkspaceContextService, configurationService: IConfigurationService, extensionManifestPropertiesService: IExtensionManifestPropertiesService, _webExtensionsScannerService: IWebExtensionsScannerService, logService: ILogService, remoteAgentService: IRemoteAgentService, remoteExtensionsScannerService: IRemoteExtensionsScannerService, lifecycleService: ILifecycleService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, _userDataInitializationService: IUserDataInitializationService, _userDataProfileService: IUserDataProfileService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _remoteExplorerService: IRemoteExplorerService, dialogService: IDialogService);
+    protected _scanSingleExtension(extension: IExtension): Promise<IExtensionDescription | null>;
+    private _initFetchFileSystem;
+    protected _scanWebExtensions(): Promise<IExtensionDescription[]>;
+    protected _resolveExtensionsDefault(): Promise<ResolvedExtensions>;
+    protected _resolveExtensions(): Promise<ResolvedExtensions>;
+    protected _onExtensionHostExit(code: number): Promise<void>;
+    protected _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+
+export { ExtensionService };

package/vscode/src/vs/workbench/services/extensions/common/extensionDescriptionRegistry.d.ts

@@ -1,5 +1,5 @@
 import { Event } from '../../../../base/common/event.js';
-import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
 
 declare class DeltaExtensionsResult {
     readonly versionId: number;

package/vscode/src/vs/workbench/services/extensions/common/extensionHostProtocol.d.ts

@@ -1,5 +1,5 @@
 import { URI, UriDto, UriComponents } from '../../../../base/common/uri.js';
-import { IExtensionDescription, ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { ExtensionIdentifier, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
 import { LogLevel, ILoggerResource } from '../../../../platform/log/common/log.js';
 import { IRemoteConnectionData } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
 

package/vscode/src/vs/workbench/services/extensions/common/extensions.js

@@ -16,6 +16,7 @@ const nullExtensionDescription = ( Object.freeze({
     isUserBuiltin: false,
     isUnderDevelopment: false,
 }));
+const webWorkerExtHostConfig = 'extensions.webWorker';
 const IExtensionService = ( createDecorator('extensionService'));
 class MissingExtensionDependency {
     constructor(dependency) {
@@ -217,4 +218,4 @@ class NullExtensionService {
     canAddExtension() { return false; }
     canRemoveExtension() { return false; }
 }
-export { ActivationTimes, ExtensionHostExtensions, ExtensionPointContribution, IExtensionService, MissingExtensionDependency, NullExtensionService, checkProposedApiEnabled, isProposedApiEnabled, nullExtensionDescription, toExtension, toExtensionDescription };
+export { ActivationTimes, ExtensionHostExtensions, ExtensionPointContribution, IExtensionService, MissingExtensionDependency, NullExtensionService, checkProposedApiEnabled, isProposedApiEnabled, nullExtensionDescription, toExtension, toExtensionDescription, webWorkerExtHostConfig };

package/vscode/src/vs/workbench/services/localization/common/locale.js

@@ -0,0 +1,4 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ILocaleService = ( createDecorator('localizationService'));
+const IActiveLanguagePackService = ( createDecorator('activeLanguageService'));
+export { IActiveLanguagePackService, ILocaleService };

package/vscode/src/vs/workbench/services/log/common/logConstants.js

@@ -1,2 +1,3 @@
+const windowLogId = 'rendererLog';
 const showWindowLogActionId = 'workbench.action.showWindowLog';
-export { showWindowLogActionId };
+export { showWindowLogActionId, windowLogId };

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.d.ts

@@ -0,0 +1,68 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { RemoteTunnel, TunnelProtocol } from '../../../../platform/tunnel/common/tunnel.js';
+import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { IEditableData } from '../../../common/views.js';
+import { TunnelInformation, TunnelPrivacy } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { URI } from '../../../../base/common/uri.js';
+import { TunnelModel, TunnelProperties, Attributes, TunnelCloseReason, CandidatePort, TunnelSource } from './tunnelModel.js';
+
+declare enum TunnelType {
+    Candidate = "Candidate",
+    Detected = "Detected",
+    Forwarded = "Forwarded",
+    Add = "Add"
+}
+interface ITunnelItem {
+    tunnelType: TunnelType;
+    remoteHost: string;
+    remotePort: number;
+    localAddress?: string;
+    protocol: TunnelProtocol;
+    localUri?: URI;
+    localPort?: number;
+    name?: string;
+    closeable?: boolean;
+    source: {
+        source: TunnelSource;
+        description: string;
+    };
+    privacy: TunnelPrivacy;
+    processDescription?: string;
+    readonly label: string;
+}
+declare enum TunnelEditId {
+    None = 0,
+    New = 1,
+    Label = 2,
+    LocalPort = 3
+}
+
+declare const IRemoteExplorerService: ServiceIdentifier<IRemoteExplorerService>;
+interface IRemoteExplorerService {
+    readonly _serviceBrand: undefined;
+    onDidChangeTargetType: Event<string[]>;
+    targetType: string[];
+    readonly tunnelModel: TunnelModel;
+    onDidChangeEditable: Event<{
+        tunnel: ITunnelItem;
+        editId: TunnelEditId;
+    } | undefined>;
+    setEditable(tunnelItem: ITunnelItem | undefined, editId: TunnelEditId, data: IEditableData | null): void;
+    getEditableData(tunnelItem: ITunnelItem | undefined, editId?: TunnelEditId): IEditableData | undefined;
+    forward(tunnelProperties: TunnelProperties, attributes?: Attributes | null): Promise<RemoteTunnel | string | undefined>;
+    close(remote: {
+        host: string;
+        port: number;
+    }, reason: TunnelCloseReason): Promise<void>;
+    setTunnelInformation(tunnelInformation: TunnelInformation | undefined): void;
+    setCandidateFilter(filter: ((candidates: CandidatePort[]) => Promise<CandidatePort[]>) | undefined): IDisposable;
+    onFoundNewCandidates(candidates: CandidatePort[]): void;
+    restore(): Promise<void>;
+    enablePortsFeatures(): void;
+    onEnabledPortsFeatures: Event<void>;
+    portsFeaturesEnabled: boolean;
+    readonly namedProcesses: Map<number, string>;
+}
+
+export { IRemoteExplorerService, type ITunnelItem, TunnelEditId, TunnelType };