sandbox - let workspaces service use sandboxed IPC

.eslintrc.json

@@ -761,6 +761,54 @@
                     "*" // node modules
                 ]
             },
+            {
+                "target": "**/src/vs/workbench/workbench.common.main.ts",
+                "restrictions": [
+                    "vs/nls",
+                    "**/vs/base/**/{common,browser}/**",
+                    "**/vs/base/parts/**/{common,browser}/**",
+                    "**/vs/platform/**/{common,browser}/**",
+                    "**/vs/editor/**",
+                    "**/vs/workbench/**/{common,browser}/**"
+                ]
+            },
+            {
+                "target": "**/src/vs/workbench/workbench.web.main.ts",
+                "restrictions": [
+                    "vs/nls",
+                    "**/vs/base/**/{common,browser}/**",
+                    "**/vs/base/parts/**/{common,browser}/**",
+                    "**/vs/platform/**/{common,browser}/**",
+                    "**/vs/editor/**",
+                    "**/vs/workbench/**/{common,browser}/**",
+                    "**/vs/workbench/workbench.common.main"
+                ]
+            },
+            {
+                "target": "**/src/vs/workbench/workbench.sandbox.main.ts",
+                "restrictions": [
+                    "vs/nls",
+                    "**/vs/base/**/{common,browser,electron-sandbox}/**",
+                    "**/vs/base/parts/**/{common,browser,electron-sandbox}/**",
+                    "**/vs/platform/**/{common,browser,electron-sandbox}/**",
+                    "**/vs/editor/**",
+                    "**/vs/workbench/**/{common,browser,electron-sandbox}/**",
+                    "**/vs/workbench/workbench.common.main"
+                ]
+            },
+            {
+                "target": "**/src/vs/workbench/workbench.desktop.main.ts",
+                "restrictions": [
+                    "vs/nls",
+                    "**/vs/base/**/{common,browser,node,electron-sandbox,electron-browser}/**",
+                    "**/vs/base/parts/**/{common,browser,node,electron-sandbox,electron-browser}/**",
+                    "**/vs/platform/**/{common,browser,node,electron-sandbox,electron-browser}/**",
+                    "**/vs/editor/**",
+                    "**/vs/workbench/**/{common,browser,node,electron-sandbox,electron-browser}/**",
+                    "**/vs/workbench/workbench.common.main",
+                    "**/vs/workbench/workbench.sandbox.main"
+                ]
+            },
             {
                 "target": "**/extensions/**",
                 "restrictions": "**/*"

src/vs/base/parts/ipc/common/ipc.ts

@@ -10,7 +10,9 @@ import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cance
 import * as errors from 'vs/base/common/errors';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { getRandomElement } from 'vs/base/common/arrays';
-import { isFunction } from 'vs/base/common/types';
+import { isFunction, isUndefinedOrNull } from 'vs/base/common/types';
+import { revive } from 'vs/base/common/marshalling';
+import { isUpperAsciiLetter } from 'vs/base/common/strings';
 
 /**
  * An `IChannel` is an abstraction over a collection of commands.
@@ -919,3 +921,131 @@ export class StaticRouter<TContext = string> implements IClientRouter<TContext>
 		return await this.route(hub);
 	}
 }
+
+
+//#region createChannelReceiver / createChannelSender
+
+/**
+ * Use both `createChannelReceiver` and `createChannelSender`
+ * for automated process <=> process communication over methods
+ * and events. You do not need to spell out each method on both
+ * sides, a proxy will take care of this.
+ *
+ * Rules:
+ * - if marshalling is enabled, only `URI` and `RegExp` is converted
+ *   automatically for you
+ * - events must follow the naming convention `onUppercase`
+ * - `CancellationToken` is currently not supported
+ * - if a context is provided, you can use `AddFirstParameterToFunctions`
+ *   utility to signal this in the receiving side type
+ */
+
+export interface IBaseChannelOptions {
+
+	/**
+	 * Disables automatic marshalling of `URI`.
+	 * If marshalling is disabled, `UriComponents`
+	 * must be used instead.
+	 */
+	disableMarshalling?: boolean;
+}
+
+export interface IChannelReceiverOptions extends IBaseChannelOptions { }
+
+export function createChannelReceiver(service: unknown, options?: IChannelReceiverOptions): IServerChannel {
+	const handler = service as { [key: string]: unknown };
+	const disableMarshalling = options && options.disableMarshalling;
+
+	// Buffer any event that should be supported by
+	// iterating over all property keys and finding them
+	const mapEventNameToEvent = new Map<string, Event<unknown>>();
+	for (const key in handler) {
+		if (propertyIsEvent(key)) {
+			mapEventNameToEvent.set(key, Event.buffer(handler[key] as Event<unknown>, true));
+		}
+	}
+
+	return new class implements IServerChannel {
+
+		listen<T>(_: unknown, event: string): Event<T> {
+			const eventImpl = mapEventNameToEvent.get(event);
+			if (eventImpl) {
+				return eventImpl as Event<T>;
+			}
+
+			throw new Error(`Event not found: ${event}`);
+		}
+
+		call(_: unknown, command: string, args?: any[]): Promise<any> {
+			const target = handler[command];
+			if (typeof target === 'function') {
+
+				// Revive unless marshalling disabled
+				if (!disableMarshalling && Array.isArray(args)) {
+					for (let i = 0; i < args.length; i++) {
+						args[i] = revive(args[i]);
+					}
+				}
+
+				return target.apply(handler, args);
+			}
+
+			throw new Error(`Method not found: ${command}`);
+		}
+	};
+}
+
+export interface IChannelSenderOptions extends IBaseChannelOptions {
+
+	/**
+	 * If provided, will add the value of `context`
+	 * to each method call to the target.
+	 */
+	context?: unknown;
+}
+
+export function createChannelSender<T>(channel: IChannel, options?: IChannelSenderOptions): T {
+	const disableMarshalling = options && options.disableMarshalling;
+
+	return new Proxy({}, {
+		get(_target: T, propKey: PropertyKey) {
+			if (typeof propKey === 'string') {
+
+				// Event
+				if (propertyIsEvent(propKey)) {
+					return channel.listen(propKey);
+				}
+
+				// Function
+				return async function (...args: any[]) {
+
+					// Add context if any
+					let methodArgs: any[];
+					if (options && !isUndefinedOrNull(options.context)) {
+						methodArgs = [options.context, ...args];
+					} else {
+						methodArgs = args;
+					}
+
+					const result = await channel.call(propKey, methodArgs);
+
+					// Revive unless marshalling disabled
+					if (!disableMarshalling) {
+						return revive(result);
+					}
+
+					return result;
+				};
+			}
+
+			throw new Error(`Property not found: ${String(propKey)}`);
+		}
+	}) as T;
+}
+
+function propertyIsEvent(name: string): boolean {
+	// Assume a property is an event if it has a form of "onSomething"
+	return name[0] === 'o' && name[1] === 'n' && isUpperAsciiLetter(name.charCodeAt(2));
+}
+
+//#endregion

src/vs/base/parts/ipc/node/ipc.ts

@@ -1,133 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { Event } from 'vs/base/common/event';
-import { IServerChannel, IChannel } from 'vs/base/parts/ipc/common/ipc';
-import { revive } from 'vs/base/common/marshalling';
-import { isUndefinedOrNull } from 'vs/base/common/types';
-import { isUpperAsciiLetter } from 'vs/base/common/strings';
-
-/**
- * Use both `createChannelReceiver` and `createChannelSender`
- * for automated process <=> process communication over methods
- * and events. You do not need to spell out each method on both
- * sides, a proxy will take care of this.
- *
- * Rules:
- * - if marshalling is enabled, only `URI` and `RegExp` is converted
- *   automatically for you
- * - events must follow the naming convention `onUppercase`
- * - `CancellationToken` is currently not supported
- * - if a context is provided, you can use `AddFirstParameterToFunctions`
- *   utility to signal this in the receiving side type
- */
-
-export interface IBaseChannelOptions {
-
-	/**
-	 * Disables automatic marshalling of `URI`.
-	 * If marshalling is disabled, `UriComponents`
-	 * must be used instead.
-	 */
-	disableMarshalling?: boolean;
-}
-
-export interface IChannelReceiverOptions extends IBaseChannelOptions { }
-
-export function createChannelReceiver(service: unknown, options?: IChannelReceiverOptions): IServerChannel {
-	const handler = service as { [key: string]: unknown };
-	const disableMarshalling = options && options.disableMarshalling;
-
-	// Buffer any event that should be supported by
-	// iterating over all property keys and finding them
-	const mapEventNameToEvent = new Map<string, Event<unknown>>();
-	for (const key in handler) {
-		if (propertyIsEvent(key)) {
-			mapEventNameToEvent.set(key, Event.buffer(handler[key] as Event<unknown>, true));
-		}
-	}
-
-	return new class implements IServerChannel {
-
-		listen<T>(_: unknown, event: string): Event<T> {
-			const eventImpl = mapEventNameToEvent.get(event);
-			if (eventImpl) {
-				return eventImpl as Event<T>;
-			}
-
-			throw new Error(`Event not found: ${event}`);
-		}
-
-		call(_: unknown, command: string, args?: any[]): Promise<any> {
-			const target = handler[command];
-			if (typeof target === 'function') {
-
-				// Revive unless marshalling disabled
-				if (!disableMarshalling && Array.isArray(args)) {
-					for (let i = 0; i < args.length; i++) {
-						args[i] = revive(args[i]);
-					}
-				}
-
-				return target.apply(handler, args);
-			}
-
-			throw new Error(`Method not found: ${command}`);
-		}
-	};
-}
-
-export interface IChannelSenderOptions extends IBaseChannelOptions {
-
-	/**
-	 * If provided, will add the value of `context`
-	 * to each method call to the target.
-	 */
-	context?: unknown;
-}
-
-export function createChannelSender<T>(channel: IChannel, options?: IChannelSenderOptions): T {
-	const disableMarshalling = options && options.disableMarshalling;
-
-	return new Proxy({}, {
-		get(_target: T, propKey: PropertyKey) {
-			if (typeof propKey === 'string') {
-
-				// Event
-				if (propertyIsEvent(propKey)) {
-					return channel.listen(propKey);
-				}
-
-				// Function
-				return async function (...args: any[]) {
-
-					// Add context if any
-					let methodArgs: any[];
-					if (options && !isUndefinedOrNull(options.context)) {
-						methodArgs = [options.context, ...args];
-					} else {
-						methodArgs = args;
-					}
-
-					const result = await channel.call(propKey, methodArgs);
-
-					// Revive unless marshalling disabled
-					if (!disableMarshalling) {
-						return revive(result);
-					}
-
-					return result;
-				};
-			}
-
-			throw new Error(`Property not found: ${String(propKey)}`);
-		}
-	}) as T;
-}
-
-function propertyIsEvent(name: string): boolean {
-	// Assume a property is an event if it has a form of "onSomething"
-	return name[0] === 'o' && name[1] === 'n' && isUpperAsciiLetter(name.charCodeAt(2));
-}

src/vs/base/parts/ipc/test/common/ipc.test.ts

@@ -4,8 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import { IChannel, IServerChannel, IMessagePassingProtocol, IPCServer, ClientConnectionEvent, IPCClient } from 'vs/base/parts/ipc/common/ipc';
-import { createChannelReceiver, createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { IChannel, IServerChannel, IMessagePassingProtocol, IPCServer, ClientConnectionEvent, IPCClient, createChannelReceiver, createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { Emitter, Event } from 'vs/base/common/event';
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
 import { canceled } from 'vs/base/common/errors';

src/vs/code/electron-browser/issue/issueReporterMain.ts

@@ -15,8 +15,7 @@ import { debounce } from 'vs/base/common/decorators';
 import { Disposable } from 'vs/base/common/lifecycle';
 import * as platform from 'vs/base/common/platform';
 import { escape } from 'vs/base/common/strings';
-import { getDelayedChannel } from 'vs/base/parts/ipc/common/ipc';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { getDelayedChannel, createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { connect as connectNet } from 'vs/base/parts/ipc/node/ipc.net';
 import { normalizeGitHubUrl } from 'vs/platform/issue/common/issueReporterUtil';
 import { IssueReporterData as IssueReporterModelData, IssueReporterModel } from 'vs/code/electron-browser/issue/issueReporterModel';

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -35,8 +35,7 @@ import { ILocalizationsService } from 'vs/platform/localizations/common/localiza
 import { combinedDisposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
 import { DownloadService } from 'vs/platform/download/common/downloadService';
 import { IDownloadService } from 'vs/platform/download/common/download';
-import { IChannel, IServerChannel, StaticRouter } from 'vs/base/parts/ipc/common/ipc';
-import { createChannelSender, createChannelReceiver } from 'vs/base/parts/ipc/node/ipc';
+import { IChannel, IServerChannel, StaticRouter, createChannelSender, createChannelReceiver } from 'vs/base/parts/ipc/common/ipc';
 import { NodeCachedDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/nodeCachedDataCleaner';
 import { LanguagePackCachedDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/languagePackCachedDataCleaner';
 import { StorageDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/storageDataCleaner';

src/vs/code/electron-browser/workbench/preload.js

@@ -9,15 +9,6 @@
 
 	const { ipcRenderer } = require('electron');
 
-	/**
-	 * @param {string} channel
-	 */
-	function validateIPC(channel) {
-		if (!channel || !channel.startsWith('vscode:')) {
-			throw new Error(`Unsupported event IPC channel '${channel}'`);
-		}
-	}
-
 	// @ts-ignore
 	window.vscode = {
 
@@ -58,4 +49,17 @@
 			}
 		}
 	};
+
+	//#region Utilities
+
+	/**
+	 * @param {string} channel
+	 */
+	function validateIPC(channel) {
+		if (!channel || !channel.startsWith('vscode:')) {
+			throw new Error(`Unsupported event IPC channel '${channel}'`);
+		}
+	}
+
+	//#endregion
 }());

src/vs/code/electron-main/app.ts

@@ -32,8 +32,7 @@ import { NullTelemetryService, combinedAppender, LogAppender } from 'vs/platform
 import { TelemetryAppenderClient } from 'vs/platform/telemetry/node/telemetryIpc';
 import { TelemetryService, ITelemetryServiceConfig } from 'vs/platform/telemetry/common/telemetryService';
 import { resolveCommonProperties } from 'vs/platform/telemetry/node/commonProperties';
-import { getDelayedChannel, StaticRouter } from 'vs/base/parts/ipc/common/ipc';
-import { createChannelReceiver } from 'vs/base/parts/ipc/node/ipc';
+import { getDelayedChannel, StaticRouter, createChannelReceiver } from 'vs/base/parts/ipc/common/ipc';
 import product from 'vs/platform/product/common/product';
 import { ProxyAuthHandler } from 'vs/code/electron-main/auth';
 import { Disposable } from 'vs/base/common/lifecycle';

src/vs/code/electron-main/main.ts

@@ -13,7 +13,7 @@ import { mkdirp } from 'vs/base/node/pfs';
 import { validatePaths } from 'vs/code/node/paths';
 import { LifecycleMainService, ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
 import { Server, serve, connect } from 'vs/base/parts/ipc/node/ipc.net';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { ILaunchMainService } from 'vs/platform/launch/electron-main/launchMainService';
 import { ServicesAccessor, IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';

src/vs/platform/ipc/electron-sandbox/mainProcessService.ts

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Client } from 'vs/base/parts/ipc/electron-sandbox/ipc.electron-sandbox';
+import { Disposable } from 'vs/base/common/lifecycle';
+
+export const IMainProcessService2 = createDecorator<IMainProcessService2>('mainProcessService2');
+
+export interface IMainProcessService2 {
+
+	_serviceBrand: undefined;
+
+	readonly windowId: number;
+
+	getChannel(channelName: string): IChannel;
+}
+
+export class MainProcessService2 extends Disposable implements IMainProcessService2 {
+
+	_serviceBrand: undefined;
+
+	private mainProcessConnection: Client;
+
+	constructor(
+		public readonly windowId: number
+	) {
+		super();
+
+		this.mainProcessConnection = this._register(new Client(`window:${windowId}`));
+	}
+
+	getChannel(channelName: string): IChannel {
+		return this.mainProcessConnection.getChannel(channelName);
+	}
+}

src/vs/workbench/electron-browser/desktop.main.ts

@@ -31,6 +31,7 @@ import { IStorageService } from 'vs/platform/storage/common/storage';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { registerWindowDriver } from 'vs/platform/driver/electron-browser/driver';
 import { IMainProcessService, MainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
+import { IMainProcessService2, MainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
 import { RemoteAuthorityResolverService } from 'vs/platform/remote/electron-browser/remoteAuthorityResolverService';
 import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { RemoteAgentService } from 'vs/workbench/services/remote/electron-browser/remoteAgentServiceImpl';
@@ -169,10 +170,14 @@ class DesktopMain extends Disposable {
 		// CONTRIBUTE IT VIA WORKBENCH.DESKTOP.MAIN.TS AND registerSingleton().
 		// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-		// Main Process
+		// Main Process (legacy)
 		const mainProcessService = this._register(new MainProcessService(this.configuration.windowId));
 		serviceCollection.set(IMainProcessService, mainProcessService);
 
+		// Main Process (sandbox)
+		const mainProcessService2 = this._register(new MainProcessService2(this.configuration.windowId));
+		serviceCollection.set(IMainProcessService2, mainProcessService2);
+
 		// Environment
 		serviceCollection.set(IWorkbenchEnvironmentService, this.environmentService);
 

src/vs/workbench/services/electron/electron-browser/electronService.ts

@@ -7,7 +7,7 @@ import { IElectronService } from 'vs/platform/electron/node/electron';
 import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 
 export class ElectronService {

src/vs/workbench/services/issue/electron-browser/issueService.ts

@@ -5,7 +5,7 @@
 
 import { IIssueService } from 'vs/platform/issue/node/issue';
 import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
 export class IssueService {

src/vs/workbench/services/localizations/electron-browser/localizationsService.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { ILocalizationsService } from 'vs/platform/localizations/common/localizations';
 import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';

src/vs/workbench/services/menubar/electron-browser/menubarService.ts

@@ -5,7 +5,7 @@
 
 import { IMenubarService } from 'vs/platform/menubar/node/menubar';
 import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
 export class MenubarService {

src/vs/workbench/services/url/electron-browser/urlService.ts

@@ -11,7 +11,7 @@ import { URLService } from 'vs/platform/url/node/urlService';
 import { IOpenerService, IOpener, matchesScheme } from 'vs/platform/opener/common/opener';
 import product from 'vs/platform/product/common/product';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { IElectronService } from 'vs/platform/electron/node/electron';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';

src/vs/workbench/services/workspaces/electron-sandbox/workspacesService.ts

@@ -4,21 +4,18 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWorkspacesService } from 'vs/platform/workspaces/common/workspaces';
-import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
+import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
-import { createChannelSender } from 'vs/base/parts/ipc/node/ipc';
-import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
-import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';
+import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 
 export class NativeWorkspacesService {
 
 	_serviceBrand: undefined;
 
 	constructor(
-		@IMainProcessService mainProcessService: IMainProcessService,
-		@IWorkbenchEnvironmentService environmentService: INativeWorkbenchEnvironmentService
+		@IMainProcessService2 mainProcessService: IMainProcessService2
 	) {
-		return createChannelSender<IWorkspacesService>(mainProcessService.getChannel('workspaces'), { context: environmentService.configuration.windowId });
+		return createChannelSender<IWorkspacesService>(mainProcessService.getChannel('workspaces'), { context: mainProcessService.windowId });
 	}
 }
 

src/vs/workbench/workbench.desktop.main.ts

@@ -11,9 +11,10 @@
 // #######################################################################
 
 
-//#region --- workbench common
+//#region --- workbench common & sandbox
 
 import 'vs/workbench/workbench.common.main';
+import 'vs/workbench/workbench.sandbox.main';
 
 //#endregion
 
@@ -27,6 +28,7 @@ import 'vs/workbench/electron-browser/desktop.main';
 
 
 //#region --- workbench services
+
 import 'vs/workbench/services/dialogs/electron-browser/fileDialogService';
 import 'vs/workbench/services/integrity/node/integrityService';
 import 'vs/workbench/services/textMate/electron-browser/textMateService';
@@ -48,7 +50,6 @@ import 'vs/workbench/services/accessibility/electron-browser/accessibilityServic
 import 'vs/workbench/services/remote/node/tunnelService';
 import 'vs/workbench/services/backup/node/backupFileService';
 import 'vs/workbench/services/url/electron-browser/urlService';
-import 'vs/workbench/services/workspaces/electron-browser/workspacesService';
 import 'vs/workbench/services/workspaces/electron-browser/workspaceEditingService';
 import 'vs/workbench/services/userDataSync/electron-browser/storageKeysSyncRegistryService';
 import 'vs/workbench/services/userDataSync/electron-browser/userDataSyncMachinesService';

src/vs/workbench/workbench.sandbox.main.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+// #######################################################################
+// ###                                                                 ###
+// ### !!! PLEASE ADD COMMON IMPORTS INTO WORKBENCH.COMMON.MAIN.TS !!! ###
+// ###                                                                 ###
+// #######################################################################
+
+
+//#region --- workbench services
+
+import 'vs/workbench/services/workspaces/electron-sandbox/workspacesService';
+
+//#endregion

src/vs/workbench/workbench.web.main.ts

@@ -26,6 +26,7 @@ import 'vs/workbench/browser/web.main';
 
 
 //#region --- workbench services
+
 import 'vs/workbench/services/integrity/browser/integrityService';
 import 'vs/workbench/services/textMate/browser/textMateService';
 import 'vs/workbench/services/search/common/searchService';