@codingame/monaco-vscode-extensions-service-override
Version:
VSCode public API plugged on the monaco editor - extensions service-override
352 lines (348 loc) • 20.6 kB
JavaScript
import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
import { getLogs } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/browser/log';
import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
import { PersistentConnectionEventType } from '@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteAgentConnection';
import { RemoteAuthorityResolverError } from '@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteAuthorityResolver';
import { IRemoteAuthorityResolverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteAuthorityResolver.service';
import { IRemoteExtensionsScannerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteExtensionsScanner.service';
import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
import { IBrowserWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/browser/environmentService.service';
import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
import { WebWorkerExtensionHost } from './webWorkerExtensionHost.js';
import { FetchFileSystemProvider } from './webWorkerFileSystemProvider.js';
import { AbstractExtensionService, RemoteExtensions, LocalExtensions, isResolverExtension, ResolverExtensions, checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
import { ExtensionHostKind, extensionRunningPreferenceToString, extensionHostKindToString, ExtensionRunningPreference } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionHostKind';
import { IExtensionManifestPropertiesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
import { toExtensionDescription, ExtensionHostStartup, ExtensionHostExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
import '../common/extensionsProposedApi.js';
import { dedupExtensions } from '../common/extensionsUtil.js';
import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
import { IRemoteExplorerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteExplorerService.service';
import { IUserDataInitializationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userData/browser/userDataInit.service';
import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
import { AsyncIterableProducer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
var BrowserExtensionHostKindPicker_1;
let ExtensionService = class ExtensionService extends AbstractExtensionService {
constructor(
options,
extensionsProposedApi,
extensionHostFactory,
extensionHostKindPicker,
instantiationService,
notificationService,
_browserEnvironmentService,
telemetryService,
extensionEnablementService,
fileService,
productService,
extensionManagementService,
contextService,
configurationService,
extensionManifestPropertiesService,
_webExtensionsScannerService,
logService,
remoteAgentService,
remoteExtensionsScannerService,
lifecycleService,
remoteAuthorityResolverService,
_userDataInitializationService,
_userDataProfileService,
_workspaceTrustManagementService,
_remoteExplorerService,
dialogService
) {
super(
options,
extensionsProposedApi,
extensionHostFactory,
extensionHostKindPicker,
instantiationService,
notificationService,
_browserEnvironmentService,
telemetryService,
extensionEnablementService,
fileService,
productService,
extensionManagementService,
contextService,
configurationService,
extensionManifestPropertiesService,
logService,
remoteAgentService,
remoteExtensionsScannerService,
lifecycleService,
remoteAuthorityResolverService,
dialogService
);
this._browserEnvironmentService = _browserEnvironmentService;
this._webExtensionsScannerService = _webExtensionsScannerService;
this._userDataInitializationService = _userDataInitializationService;
this._userDataProfileService = _userDataProfileService;
this._workspaceTrustManagementService = _workspaceTrustManagementService;
this._remoteExplorerService = _remoteExplorerService;
lifecycleService.when(LifecyclePhase.Ready).then(async () => {
await this._initializeIfNeeded();
});
this._initFetchFileSystem();
}
_initFetchFileSystem() {
const provider = ( new FetchFileSystemProvider());
this._register(this._fileService.registerProvider(Schemas.http, provider));
this._register(this._fileService.registerProvider(Schemas.https, provider));
}
async _initialize() {
await this._userDataInitializationService.initializeInstalledExtensions(this._instantiationService);
await super._initialize();
}
async _scanWebExtensions() {
if (!this._scanWebExtensionsPromise) {
this._scanWebExtensionsPromise = (async () => {
const system = [], user = [], development = [];
try {
await Promise.all([
this._webExtensionsScannerService.scanSystemExtensions().then(extensions => system.push(...( extensions.map(e => toExtensionDescription(e))))),
this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, {
skipInvalidExtensions: true
}).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
this._webExtensionsScannerService.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
]);
} catch (error) {
this._logService.error(error);
}
return dedupExtensions(system, user, [], development, this._logService);
})();
}
return this._scanWebExtensionsPromise;
}
async _resolveExtensionsDefault(emitter) {
const [localExtensions, remoteExtensions] = await Promise.all([
this._scanWebExtensions(),
this._remoteExtensionsScannerService.scanExtensions()
]);
if (remoteExtensions.length) {
emitter.emitOne(( new RemoteExtensions(remoteExtensions)));
}
emitter.emitOne(( new LocalExtensions(localExtensions)));
}
_resolveExtensions() {
return new AsyncIterableProducer(emitter => this._doResolveExtensions(emitter));
}
async _doResolveExtensions(emitter) {
if (!this._browserEnvironmentService.expectsResolverExtension) {
return this._resolveExtensionsDefault(emitter);
}
const remoteAuthority = this._environmentService.remoteAuthority;
await this._workspaceTrustManagementService.workspaceResolved;
const localExtensions = await this._scanWebExtensions();
const resolverExtensions = localExtensions.filter(extension => isResolverExtension(extension));
if (resolverExtensions.length) {
emitter.emitOne(( new ResolverExtensions(resolverExtensions)));
}
let resolverResult;
try {
resolverResult = await this._resolveAuthorityInitial(remoteAuthority);
} catch (err) {
if (RemoteAuthorityResolverError.isHandled(err)) {
console.log(`Error handled: Not showing a notification for the error`);
}
this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
return this._resolveExtensionsDefault(emitter);
}
this._remoteAuthorityResolverService._setResolvedAuthority(resolverResult.authority, resolverResult.options);
this._remoteExplorerService.setTunnelInformation(resolverResult.tunnelInformation);
const connection = this._remoteAgentService.getConnection();
if (connection) {
this._register(connection.onDidStateChange(async e => {
if (e.type === PersistentConnectionEventType.ConnectionLost) {
this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
}
}));
this._register(connection.onReconnecting(() => this._resolveAuthorityAgain()));
}
return this._resolveExtensionsDefault(emitter);
}
async _onExtensionHostExit(code) {
await this._doStopExtensionHosts();
const automatedWindow = mainWindow;
if (typeof automatedWindow.codeAutomationExit === "function") {
automatedWindow.codeAutomationExit(code, await getLogs(this._fileService, this._environmentService));
}
}
async _resolveAuthority(remoteAuthority) {
return this._resolveAuthorityOnExtensionHosts(ExtensionHostKind.LocalWebWorker, remoteAuthority);
}
};
ExtensionService = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, INotificationService)), ( __param(6, IBrowserWorkbenchEnvironmentService)), ( __param(7, ITelemetryService)), ( __param(8, IWorkbenchExtensionEnablementService)), ( __param(9, IFileService)), ( __param(10, IProductService)), ( __param(11, IWorkbenchExtensionManagementService)), ( __param(12, IWorkspaceContextService)), ( __param(13, IConfigurationService)), ( __param(14, IExtensionManifestPropertiesService)), ( __param(15, IWebExtensionsScannerService)), ( __param(16, ILogService)), ( __param(17, IRemoteAgentService)), ( __param(18, IRemoteExtensionsScannerService)), ( __param(19, ILifecycleService)), ( __param(20, IRemoteAuthorityResolverService)), ( __param(21, IUserDataInitializationService)), ( __param(22, IUserDataProfileService)), ( __param(23, IWorkspaceTrustManagementService)), ( __param(24, IRemoteExplorerService)), ( __param(25, IDialogService))], ExtensionService));
let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
constructor(
_extensionsProposedApi,
_scanWebExtensions,
_getExtensionRegistrySnapshotWhenReady,
_instantiationService,
_remoteAgentService,
_remoteAuthorityResolverService,
_extensionEnablementService,
_logService
) {
this._extensionsProposedApi = _extensionsProposedApi;
this._scanWebExtensions = _scanWebExtensions;
this._getExtensionRegistrySnapshotWhenReady = _getExtensionRegistrySnapshotWhenReady;
this._instantiationService = _instantiationService;
this._remoteAgentService = _remoteAgentService;
this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
this._extensionEnablementService = _extensionEnablementService;
this._logService = _logService;
}
createExtensionHost(runningLocations, runningLocation, isInitialStart) {
switch (runningLocation.kind) {
case ExtensionHostKind.LocalProcess:
{
return null;
}
case ExtensionHostKind.LocalWebWorker:
{
const startup = (isInitialStart ? ExtensionHostStartup.EagerManualStart : ExtensionHostStartup.EagerAutoStart);
return this._instantiationService.createInstance(
WebWorkerExtensionHost,
runningLocation,
startup,
this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart)
);
}
case ExtensionHostKind.Remote:
{
const remoteAgentConnection = this._remoteAgentService.getConnection();
if (remoteAgentConnection) {
return this._instantiationService.createInstance(
RemoteExtensionHost,
runningLocation,
this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority)
);
}
return null;
}
}
}
_createLocalExtensionHostDataProvider(runningLocations, desiredRunningLocation, isInitialStart) {
return {
getInitData: async () => {
if (isInitialStart) {
const localExtensions = checkEnabledAndProposedAPI(
this._logService,
this._extensionEnablementService,
this._extensionsProposedApi,
await this._scanWebExtensions(),
true
);
const runningLocation = runningLocations.computeRunningLocation(localExtensions, [], false);
const myExtensions = filterExtensionDescriptions(
localExtensions,
runningLocation,
extRunningLocation => desiredRunningLocation.equals(extRunningLocation)
);
const extensions = ( new ExtensionHostExtensions(0, localExtensions, ( myExtensions.map(extension => extension.identifier))));
return {
extensions
};
} else {
const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
const myExtensions = runningLocations.filterByRunningLocation(snapshot.extensions, desiredRunningLocation);
const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
return {
extensions
};
}
}
};
}
_createRemoteExtensionHostDataProvider(runningLocations, remoteAuthority) {
return {
remoteAuthority: remoteAuthority,
getInitData: async () => {
const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
const remoteEnv = await this._remoteAgentService.getEnvironment();
if (!remoteEnv) {
throw ( new Error("Cannot provide init data for remote extension host!"));
}
const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, ExtensionHostKind.Remote);
const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
return {
connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
pid: remoteEnv.pid,
appRoot: remoteEnv.appRoot,
extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
globalStorageHome: remoteEnv.globalStorageHome,
workspaceStorageHome: remoteEnv.workspaceStorageHome,
extensions
};
}
};
}
};
BrowserExtensionHostFactory = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IRemoteAgentService)), ( __param(5, IRemoteAuthorityResolverService)), ( __param(6, IWorkbenchExtensionEnablementService)), ( __param(7, ILogService))], BrowserExtensionHostFactory));
let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class BrowserExtensionHostKindPicker {
constructor(_logService) {
this._logService = _logService;
}
pickExtensionHostKind(
extensionId,
extensionKinds,
isInstalledLocally,
isInstalledRemotely,
preference
) {
const result = BrowserExtensionHostKindPicker_1.pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference);
this._logService.trace(
`pickRunningLocation for ${extensionId.value}, extension kinds: [${extensionKinds.join(", ")}], isInstalledLocally: ${isInstalledLocally}, isInstalledRemotely: ${isInstalledRemotely}, preference: ${extensionRunningPreferenceToString(preference)} => ${extensionHostKindToString(result)}`
);
return result;
}
static pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
const result = [];
let canRunRemotely = false;
for (const extensionKind of extensionKinds) {
if (extensionKind === "ui" && isInstalledRemotely) {
if (preference === ExtensionRunningPreference.Remote) {
return ExtensionHostKind.Remote;
} else {
canRunRemotely = true;
}
}
if (extensionKind === "workspace" && isInstalledRemotely) {
if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Remote) {
return ExtensionHostKind.Remote;
} else {
result.push(ExtensionHostKind.Remote);
}
}
if (extensionKind === "web" && (isInstalledLocally || isInstalledRemotely)) {
if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Local) {
return ExtensionHostKind.LocalWebWorker;
} else {
result.push(ExtensionHostKind.LocalWebWorker);
}
}
}
if (canRunRemotely) {
result.push(ExtensionHostKind.Remote);
}
return (result.length > 0 ? result[0] : null);
}
};
BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([( __param(0, ILogService))], BrowserExtensionHostKindPicker));
export { BrowserExtensionHostFactory, BrowserExtensionHostKindPicker, ExtensionService };