Merge from vscode 31e03b8ffbb218a87e3941f2b63a249f061fe0e4 (#4986)

src/vs/workbench/api/browser/mainThreadDocuments.ts

@@ -17,6 +17,8 @@ import { ExtHostContext, ExtHostDocumentsShape, IExtHostContext, MainThreadDocum
 import { ITextEditorModel } from 'vs/workbench/common/editor';
 import { ITextFileService, TextFileModelChangeEvent } from 'vs/workbench/services/textfile/common/textfiles';
 import { IUntitledEditorService } from 'vs/workbench/services/untitled/common/untitledEditorService';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+import { toLocalResource } from 'vs/base/common/resources';
 
 export class BoundModelReferenceCollection {
 
@@ -69,6 +71,7 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 	private readonly _textFileService: ITextFileService;
 	private readonly _fileService: IFileService;
 	private readonly _untitledEditorService: IUntitledEditorService;
+	private readonly _environmentService: IWorkbenchEnvironmentService;
 
 	private _toDispose: IDisposable[];
 	private _modelToDisposeMap: { [modelUrl: string]: IDisposable; };
@@ -85,12 +88,14 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 		@IFileService fileService: IFileService,
 		@ITextModelService textModelResolverService: ITextModelService,
 		@IUntitledEditorService untitledEditorService: IUntitledEditorService,
+		@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService
 	) {
 		this._modelService = modelService;
 		this._textModelResolverService = textModelResolverService;
 		this._textFileService = textFileService;
 		this._fileService = fileService;
 		this._untitledEditorService = untitledEditorService;
+		this._environmentService = environmentService;
 
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocuments);
 		this._modelIsSynced = {};
@@ -214,10 +219,10 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 	}
 
 	private _handleUntitledScheme(uri: URI): Promise<boolean> {
-		const asFileUri = uri.with({ scheme: Schemas.file });
-		return this._fileService.resolve(asFileUri).then(stats => {
+		const asLocalUri = toLocalResource(uri, this._environmentService.configuration.remoteAuthority);
+		return this._fileService.resolve(asLocalUri).then(stats => {
 			// don't create a new file ontop of an existing file
-			return Promise.reject(new Error('file already exists on disk'));
+			return Promise.reject(new Error('file already exists'));
 		}, err => {
 			return this._doCreateUntitled(uri).then(resource => !!resource);
 		});

src/vs/workbench/api/browser/mainThreadDocumentsAndEditors.ts

@@ -29,6 +29,7 @@ import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editor
 import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
 import { IUntitledEditorService } from 'vs/workbench/services/untitled/common/untitledEditorService';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 
 namespace delta {
 
@@ -330,12 +331,12 @@ export class MainThreadDocumentsAndEditors {
 		@IUntitledEditorService untitledEditorService: IUntitledEditorService,
 		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
 		@IBulkEditService bulkEditService: IBulkEditService,
-		@IPanelService panelService: IPanelService
-
+		@IPanelService panelService: IPanelService,
+		@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService
 	) {
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentsAndEditors);
 
-		const mainThreadDocuments = new MainThreadDocuments(this, extHostContext, this._modelService, modeService, this._textFileService, fileService, textModelResolverService, untitledEditorService);
+		const mainThreadDocuments = new MainThreadDocuments(this, extHostContext, this._modelService, modeService, this._textFileService, fileService, textModelResolverService, untitledEditorService, environmentService);
 		extHostContext.set(MainContext.MainThreadDocuments, mainThreadDocuments);
 
 		const mainThreadTextEditors = new MainThreadTextEditors(this, extHostContext, codeEditorService, bulkEditService, this._editorService, this._editorGroupService);

src/vs/workbench/api/browser/mainThreadFileSystem.ts

@@ -10,6 +10,7 @@ import { FileWriteOptions, FileSystemProviderCapabilities, IFileChange, IFileSer
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { ExtHostContext, ExtHostFileSystemShape, IExtHostContext, IFileChangeDto, MainContext, MainThreadFileSystemShape } from '../common/extHost.protocol';
 import { ResourceLabelFormatter, ILabelService } from 'vs/platform/label/common/label';
+import { VSBuffer } from 'vs/base/common/buffer';
 
 @extHostNamedCustomer(MainContext.MainThreadFileSystem)
 export class MainThreadFileSystem implements MainThreadFileSystemShape {
@@ -105,10 +106,6 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
 
 	// --- forwarding calls
 
-	private static _asBuffer(data: Uint8Array): Buffer {
-		return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-	}
-
 	stat(resource: URI): Promise<IStat> {
 		return this._proxy.$stat(this._handle, resource).then(undefined, err => {
 			throw err;
@@ -116,11 +113,11 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
 	}
 
 	readFile(resource: URI): Promise<Uint8Array> {
-		return this._proxy.$readFile(this._handle, resource);
+		return this._proxy.$readFile(this._handle, resource).then(buffer => buffer.buffer);
 	}
 
 	writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
-		return this._proxy.$writeFile(this._handle, resource, RemoteFileSystemProvider._asBuffer(content), opts);
+		return this._proxy.$writeFile(this._handle, resource, VSBuffer.wrap(content), opts);
 	}
 
 	delete(resource: URI, opts: FileDeleteOptions): Promise<void> {
@@ -153,12 +150,12 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
 
 	read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
 		return this._proxy.$read(this._handle, fd, pos, length).then(readData => {
-			data.set(readData, offset);
+			data.set(readData.buffer, offset);
 			return readData.byteLength;
 		});
 	}
 
 	write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
-		return this._proxy.$write(this._handle, fd, pos, Buffer.from(data, offset, length));
+		return this._proxy.$write(this._handle, fd, pos, VSBuffer.wrap(data).slice(offset, offset + length));
 	}
 }

src/vs/workbench/api/browser/mainThreadSaveParticipant.ts

@@ -240,6 +240,7 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 
 	constructor(
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
 	) {
 		// Nothing
@@ -256,8 +257,9 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 
 		return new Promise<any>((resolve, reject) => {
 			const source = new CancellationTokenSource();
+			const editorOrModel = findEditor(model, this._codeEditorService) || model;
 			const timeout = this._configurationService.getValue<number>('editor.formatOnSaveTimeout', overrides);
-			const request = this._instantiationService.invokeFunction(formatDocumentWithSelectedProvider, model, FormattingMode.Silent, source.token);
+			const request = this._instantiationService.invokeFunction(formatDocumentWithSelectedProvider, editorOrModel, FormattingMode.Silent, source.token);
 
 			setTimeout(() => {
 				reject(localize('timeout.formatOnSave', "Aborted format on save after {0}ms", timeout));

src/vs/workbench/api/browser/mainThreadStatusBar.ts

@@ -3,47 +3,55 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IStatusbarService, StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/platform/statusbar/common/statusbar';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { IStatusbarService, StatusbarAlignment as MainThreadStatusBarAlignment, IStatusbarEntryAccessor } from 'vs/platform/statusbar/common/statusbar';
 import { MainThreadStatusBarShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
 import { ThemeColor } from 'vs/platform/theme/common/themeService';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { dispose } from 'vs/base/common/lifecycle';
 
 @extHostNamedCustomer(MainContext.MainThreadStatusBar)
 export class MainThreadStatusBar implements MainThreadStatusBarShape {
 
-	private readonly _entries: { [id: number]: IDisposable };
+	private readonly entries: Map<number, { accessor: IStatusbarEntryAccessor, alignment: MainThreadStatusBarAlignment, priority: number }> = new Map();
 
 	constructor(
-		extHostContext: IExtHostContext,
-		@IStatusbarService private readonly _statusbarService: IStatusbarService
-	) {
-		this._entries = Object.create(null);
-	}
+		_extHostContext: IExtHostContext,
+		@IStatusbarService private readonly statusbarService: IStatusbarService
+	) { }
 
 	dispose(): void {
-		for (const key in this._entries) {
-			this._entries[key].dispose();
-		}
+		this.entries.forEach(entry => entry.accessor.dispose());
+		this.entries.clear();
 	}
 
 	$setEntry(id: number, extensionId: ExtensionIdentifier, text: string, tooltip: string, command: string, color: string | ThemeColor, alignment: MainThreadStatusBarAlignment, priority: number): void {
+		const entry = { text, tooltip, command, color, extensionId };
 
-		// Dispose any old
-		this.$dispose(id);
+		// Reset existing entry if alignment or priority changed
+		let existingEntry = this.entries.get(id);
+		if (existingEntry && (existingEntry.alignment !== alignment || existingEntry.priority !== priority)) {
+			dispose(existingEntry.accessor);
+			this.entries.delete(id);
+			existingEntry = undefined;
+		}
 
-		// Add new
-		const entry = this._statusbarService.addEntry({ text, tooltip, command, color, extensionId }, alignment, priority);
-		this._entries[id] = entry;
+		// Create new entry if not existing
+		if (!existingEntry) {
+			this.entries.set(id, { accessor: this.statusbarService.addEntry(entry, alignment, priority), alignment, priority });
+		}
+
+		// Otherwise update
+		else {
+			existingEntry.accessor.update(entry);
+		}
 	}
 
 	$dispose(id: number) {
-		const disposeable = this._entries[id];
-		if (disposeable) {
-			disposeable.dispose();
+		const entry = this.entries.get(id);
+		if (entry) {
+			dispose(entry.accessor);
+			this.entries.delete(id);
 		}
-
-		delete this._entries[id];
 	}
 }

src/vs/workbench/api/browser/mainThreadWindow.ts

@@ -9,17 +9,22 @@ import { URI, UriComponents } from 'vs/base/common/uri';
 import { IWindowService, IWindowsService } from 'vs/platform/windows/common/windows';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { ExtHostContext, ExtHostWindowShape, IExtHostContext, MainContext, MainThreadWindowShape } from '../common/extHost.protocol';
+import { ITunnelService, RemoteTunnel } from 'vs/platform/remote/common/tunnel';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 
 @extHostNamedCustomer(MainContext.MainThreadWindow)
 export class MainThreadWindow implements MainThreadWindowShape {
 
 	private readonly proxy: ExtHostWindowShape;
 	private disposables: IDisposable[] = [];
+	private readonly _tunnels = new Map<number, Promise<RemoteTunnel>>();
 
 	constructor(
 		extHostContext: IExtHostContext,
 		@IWindowService private readonly windowService: IWindowService,
-		@IWindowsService private readonly windowsService: IWindowsService
+		@IWindowsService private readonly windowsService: IWindowsService,
+		@ITunnelService private readonly tunnelService: ITunnelService,
+		@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService
 	) {
 		this.proxy = extHostContext.getProxy(ExtHostContext.ExtHostWindow);
 
@@ -29,13 +34,54 @@ export class MainThreadWindow implements MainThreadWindowShape {
 
 	dispose(): void {
 		this.disposables = dispose(this.disposables);
+
+		for (const tunnel of this._tunnels.values()) {
+			tunnel.then(tunnel => tunnel.dispose());
+		}
+		this._tunnels.clear();
 	}
 
 	$getWindowVisibility(): Promise<boolean> {
 		return this.windowService.isFocused();
 	}
 
-	$openUri(uri: UriComponents): Promise<boolean> {
-		return this.windowsService.openExternal(URI.revive(uri).toString(true));
+	async $openUri(uriComponent: UriComponents): Promise<boolean> {
+		const uri = URI.revive(uriComponent);
+		if (!!this.environmentService.configuration.remoteAuthority) {
+			if (uri.scheme === 'http' || uri.scheme === 'https') {
+				const port = this.getLocalhostPort(uri);
+				if (typeof port === 'number') {
+					const tunnel = await this.getOrCreateTunnel(port);
+					if (tunnel) {
+						const tunneledUrl = uri.toString().replace(
+							new RegExp(`^${uri.scheme}://localhost:${port}/`),
+							`${uri.scheme}://localhost:${tunnel.tunnelLocalPort}/`);
+						return this.windowsService.openExternal(tunneledUrl);
+					}
+				}
+			}
+		}
+
+		return this.windowsService.openExternal(uri.toString(true));
+	}
+
+	private getLocalhostPort(uri: URI): number | undefined {
+		const match = /^localhost:(\d+)$/.exec(uri.authority);
+		if (match) {
+			return +match[1];
+		}
+		return undefined;
+	}
+
+	private getOrCreateTunnel(remotePort: number): Promise<RemoteTunnel> | undefined {
+		const existing = this._tunnels.get(remotePort);
+		if (existing) {
+			return existing;
+		}
+		const tunnel = this.tunnelService.openTunnel(remotePort);
+		if (tunnel) {
+			this._tunnels.set(remotePort, tunnel);
+		}
+		return tunnel;
 	}
 }

src/vs/workbench/api/common/apiCommands.ts

@@ -5,7 +5,7 @@
 
 import * as vscode from 'vscode';
 import { URI } from 'vs/base/common/uri';
-import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
 import { CommandsRegistry, ICommandService, ICommandHandler } from 'vs/platform/commands/common/commands';
 import { ITextEditorOptions } from 'vs/platform/editor/common/editor';
 import { EditorViewColumn } from 'vs/workbench/api/common/shared/editor';

src/vs/workbench/api/common/extHost.protocol.ts

@@ -46,6 +46,7 @@ import * as codeInset from 'vs/workbench/contrib/codeinset/common/codeInset';
 import * as callHierarchy from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
 import { IRelativePattern } from 'vs/base/common/glob';
 import { IRemoteConsoleLog } from 'vs/base/common/console';
+import { VSBuffer } from 'vs/base/common/buffer';
 
 // {{SQL CARBON EDIT}}
 import { ITreeItem as sqlITreeItem } from 'sql/workbench/common/views';
@@ -57,7 +58,7 @@ export interface IEnvironment {
 	appLanguage: string;
 	appUriScheme: string;
 	appSettingsHome?: URI;
-	extensionDevelopmentLocationURI?: URI | URI[];
+	extensionDevelopmentLocationURI?: URI[];
 	extensionTestsLocationURI?: URI;
 	globalStorageHome: URI;
 	userHome: URI;
@@ -791,8 +792,8 @@ export interface ExtHostWorkspaceShape {
 export interface ExtHostFileSystemShape {
 	$stat(handle: number, resource: UriComponents): Promise<files.IStat>;
 	$readdir(handle: number, resource: UriComponents): Promise<[string, files.FileType][]>;
-	$readFile(handle: number, resource: UriComponents): Promise<Buffer>;
-	$writeFile(handle: number, resource: UriComponents, content: Buffer, opts: files.FileWriteOptions): Promise<void>;
+	$readFile(handle: number, resource: UriComponents): Promise<VSBuffer>;
+	$writeFile(handle: number, resource: UriComponents, content: VSBuffer, opts: files.FileWriteOptions): Promise<void>;
 	$rename(handle: number, resource: UriComponents, target: UriComponents, opts: files.FileOverwriteOptions): Promise<void>;
 	$copy(handle: number, resource: UriComponents, target: UriComponents, opts: files.FileOverwriteOptions): Promise<void>;
 	$mkdir(handle: number, resource: UriComponents): Promise<void>;
@@ -801,8 +802,8 @@ export interface ExtHostFileSystemShape {
 	$unwatch(handle: number, session: number): void;
 	$open(handle: number, resource: UriComponents, opts: files.FileOpenOptions): Promise<number>;
 	$close(handle: number, fd: number): Promise<void>;
-	$read(handle: number, fd: number, pos: number, length: number): Promise<Buffer>;
-	$write(handle: number, fd: number, pos: number, data: Buffer): Promise<number>;
+	$read(handle: number, fd: number, pos: number, length: number): Promise<VSBuffer>;
+	$write(handle: number, fd: number, pos: number, data: VSBuffer): Promise<number>;
 }
 
 export interface ExtHostSearchShape {
@@ -820,8 +821,8 @@ export interface ExtHostExtensionServiceShape {
 	$deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): Promise<void>;
 
 	$test_latency(n: number): Promise<number>;
-	$test_up(b: Buffer): Promise<number>;
-	$test_down(size: number): Promise<Buffer>;
+	$test_up(b: VSBuffer): Promise<number>;
+	$test_down(size: number): Promise<VSBuffer>;
 }
 
 export interface FileSystemEvents {

src/vs/workbench/api/common/extHostApiCommands.ts

@@ -6,15 +6,15 @@
 import { URI } from 'vs/base/common/uri';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import * as vscode from 'vscode';
-import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
-import * as types from 'vs/workbench/api/node/extHostTypes';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import * as types from 'vs/workbench/api/common/extHostTypes';
 import { IRawColorInfo, WorkspaceEditDto } from 'vs/workbench/api/common/extHost.protocol';
 import { ISingleEditOperation } from 'vs/editor/common/model';
 import * as modes from 'vs/editor/common/modes';
 import * as search from 'vs/workbench/contrib/search/common/search';
 import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { CustomCodeAction } from 'vs/workbench/api/node/extHostLanguageFeatures';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { CustomCodeAction } from 'vs/workbench/api/common/extHostLanguageFeatures';
 import { ICommandsExecutor, OpenFolderAPICommand, DiffAPICommand, OpenAPICommand, RemoveFromRecentlyOpenedAPICommand, SetEditorLayoutAPICommand } from './apiCommands';
 import { EditorGroupLayout } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';

src/vs/workbench/api/common/extHostCommands.ts

@@ -5,11 +5,11 @@
 
 import { validateConstraint } from 'vs/base/common/types';
 import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
-import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
-import * as extHostTypeConverter from 'vs/workbench/api/node/extHostTypeConverters';
+import * as extHostTypes from 'vs/workbench/api/common/extHostTypes';
+import * as extHostTypeConverter from 'vs/workbench/api/common/extHostTypeConverters';
 import { cloneAndChange } from 'vs/base/common/objects';
-import { MainContext, MainThreadCommandsShape, ExtHostCommandsShape, ObjectIdentifier, IMainContext, CommandDto } from '../common/extHost.protocol';
-import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
+import { MainContext, MainThreadCommandsShape, ExtHostCommandsShape, ObjectIdentifier, IMainContext, CommandDto } from './extHost.protocol';
+import { ExtHostHeapService } from 'vs/workbench/api/common/extHostHeapService';
 import { isNonEmptyArray } from 'vs/base/common/arrays';
 import * as modes from 'vs/editor/common/modes';
 import * as vscode from 'vscode';

src/vs/workbench/api/common/extHostComments.ts

@@ -6,11 +6,11 @@
 import { asPromise } from 'vs/base/common/async';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import * as modes from 'vs/editor/common/modes';
-import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
-import * as extHostTypeConverter from 'vs/workbench/api/node/extHostTypeConverters';
-import * as types from 'vs/workbench/api/node/extHostTypes';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import * as extHostTypeConverter from 'vs/workbench/api/common/extHostTypeConverters';
+import * as types from 'vs/workbench/api/common/extHostTypes';
 import * as vscode from 'vscode';
-import { ExtHostCommentsShape, IMainContext, MainContext, MainThreadCommentsShape } from '../common/extHost.protocol';
+import { ExtHostCommentsShape, IMainContext, MainContext, MainThreadCommentsShape } from './extHost.protocol';
 import { CommandsConverter, ExtHostCommands } from './extHostCommands';
 import { IRange } from 'vs/editor/common/core/range';
 import { CancellationToken } from 'vs/base/common/cancellation';

src/vs/workbench/api/common/extHostConfiguration.ts

@@ -7,8 +7,8 @@ import { mixin, deepClone } from 'vs/base/common/objects';
 import { URI } from 'vs/base/common/uri';
 import { Event, Emitter } from 'vs/base/common/event';
 import * as vscode from 'vscode';
-import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
-import { ExtHostConfigurationShape, MainThreadConfigurationShape, IWorkspaceConfigurationChangeEventData, IConfigurationInitData } from '../common/extHost.protocol';
+import { ExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
+import { ExtHostConfigurationShape, MainThreadConfigurationShape, IWorkspaceConfigurationChangeEventData, IConfigurationInitData } from './extHost.protocol';
 import { ConfigurationTarget as ExtHostConfigurationTarget } from './extHostTypes';
 import { IConfigurationData, ConfigurationTarget, IConfigurationModel } from 'vs/platform/configuration/common/configuration';
 import { Configuration, ConfigurationChangeEvent, ConfigurationModel } from 'vs/platform/configuration/common/configurationModels';

src/vs/workbench/api/common/extHostDecorations.ts

@@ -6,7 +6,7 @@
 import * as vscode from 'vscode';
 import { URI } from 'vs/base/common/uri';
 import { MainContext, IMainContext, ExtHostDecorationsShape, MainThreadDecorationsShape, DecorationData, DecorationRequest, DecorationReply } from 'vs/workbench/api/common/extHost.protocol';
-import { Disposable } from 'vs/workbench/api/node/extHostTypes';
+import { Disposable } from 'vs/workbench/api/common/extHostTypes';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { asArray } from 'vs/base/common/arrays';

src/vs/workbench/api/common/extHostDiagnostics.ts

@@ -7,7 +7,7 @@ import { localize } from 'vs/nls';
 import { IMarkerData, MarkerSeverity } from 'vs/platform/markers/common/markers';
 import { URI } from 'vs/base/common/uri';
 import * as vscode from 'vscode';
-import { MainContext, MainThreadDiagnosticsShape, ExtHostDiagnosticsShape, IMainContext } from '../common/extHost.protocol';
+import { MainContext, MainThreadDiagnosticsShape, ExtHostDiagnosticsShape, IMainContext } from './extHost.protocol';
 import { DiagnosticSeverity } from './extHostTypes';
 import * as converter from './extHostTypeConverters';
 import { mergeSort } from 'vs/base/common/arrays';

src/vs/workbench/api/common/extHostDocumentContentProviders.ts

@@ -6,9 +6,9 @@
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { Disposable } from 'vs/workbench/api/node/extHostTypes';
+import { Disposable } from 'vs/workbench/api/common/extHostTypes';
 import * as vscode from 'vscode';
-import { MainContext, ExtHostDocumentContentProvidersShape, MainThreadDocumentContentProvidersShape, IMainContext } from '../common/extHost.protocol';
+import { MainContext, ExtHostDocumentContentProvidersShape, MainThreadDocumentContentProvidersShape, IMainContext } from './extHost.protocol';
 import { ExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors';
 import { Schemas } from 'vs/base/common/network';
 import { ILogService } from 'vs/platform/log/common/log';

src/vs/workbench/api/common/extHostDocumentData.ts

@@ -10,7 +10,7 @@ import { URI } from 'vs/base/common/uri';
 import { MirrorTextModel } from 'vs/editor/common/model/mirrorTextModel';
 import { ensureValidWordDefinition, getWordAtText } from 'vs/editor/common/model/wordHelper';
 import { MainThreadDocumentsShape } from 'vs/workbench/api/common/extHost.protocol';
-import { EndOfLine, Position, Range } from 'vs/workbench/api/node/extHostTypes';
+import { EndOfLine, Position, Range } from 'vs/workbench/api/common/extHostTypes';
 import * as vscode from 'vscode';
 
 const _modeId2WordDefinition = new Map<string, RegExp>();

src/vs/workbench/api/common/extHostDocumentSaveParticipant.ts

@@ -8,9 +8,9 @@ import { URI, UriComponents } from 'vs/base/common/uri';
 import { sequence } from 'vs/base/common/async';
 import { illegalState } from 'vs/base/common/errors';
 import { ExtHostDocumentSaveParticipantShape, MainThreadTextEditorsShape, ResourceTextEditDto } from 'vs/workbench/api/common/extHost.protocol';
-import { TextEdit } from 'vs/workbench/api/node/extHostTypes';
-import { Range, TextDocumentSaveReason, EndOfLine } from 'vs/workbench/api/node/extHostTypeConverters';
-import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
+import { TextEdit } from 'vs/workbench/api/common/extHostTypes';
+import { Range, TextDocumentSaveReason, EndOfLine } from 'vs/workbench/api/common/extHostTypeConverters';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import * as vscode from 'vscode';
 import { LinkedList } from 'vs/base/common/linkedList';

src/vs/workbench/api/common/extHostDocuments.ts

@@ -8,9 +8,9 @@ import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IModelChangedEvent } from 'vs/editor/common/model/mirrorTextModel';
 import { ExtHostDocumentsShape, IMainContext, MainContext, MainThreadDocumentsShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostDocumentData, setWordDefinitionFor } from 'vs/workbench/api/node/extHostDocumentData';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
-import * as TypeConverters from 'vs/workbench/api/node/extHostTypeConverters';
+import { ExtHostDocumentData, setWordDefinitionFor } from 'vs/workbench/api/common/extHostDocumentData';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import * as TypeConverters from 'vs/workbench/api/common/extHostTypeConverters';
 import * as vscode from 'vscode';
 
 export class ExtHostDocuments implements ExtHostDocumentsShape {

src/vs/workbench/api/common/extHostDocumentsAndEditors.ts

@@ -8,10 +8,10 @@ import { Emitter, Event } from 'vs/base/common/event';
 import { dispose } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { ExtHostDocumentsAndEditorsShape, IDocumentsAndEditorsDelta, IMainContext, MainContext } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostDocumentData } from 'vs/workbench/api/node/extHostDocumentData';
-import { ExtHostTextEditor } from 'vs/workbench/api/node/extHostTextEditor';
-import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
-import { Disposable } from 'vs/workbench/api/node/extHostTypes';
+import { ExtHostDocumentData } from 'vs/workbench/api/common/extHostDocumentData';
+import { ExtHostTextEditor } from 'vs/workbench/api/common/extHostTextEditor';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import { Disposable } from 'vs/workbench/api/common/extHostTypes';
 
 export class ExtHostDocumentsAndEditors implements ExtHostDocumentsAndEditorsShape {
 

src/vs/workbench/api/common/extHostExtensionActivator.ts

@@ -5,7 +5,7 @@
 
 import * as nls from 'vs/nls';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { ExtensionActivationError, MissingDependencyError } from 'vs/workbench/services/extensions/common/extensions';
 

src/vs/workbench/api/common/extHostFileSystem.ts

@@ -4,18 +4,19 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { MainContext, IMainContext, ExtHostFileSystemShape, MainThreadFileSystemShape, IFileChangeDto } from '../common/extHost.protocol';
+import { MainContext, IMainContext, ExtHostFileSystemShape, MainThreadFileSystemShape, IFileChangeDto } from './extHost.protocol';
 import * as vscode from 'vscode';
 import * as files from 'vs/platform/files/common/files';
 import { IDisposable, toDisposable, dispose } from 'vs/base/common/lifecycle';
-import { FileChangeType } from 'vs/workbench/api/node/extHostTypes';
-import * as typeConverter from 'vs/workbench/api/node/extHostTypeConverters';
-import { ExtHostLanguageFeatures } from 'vs/workbench/api/node/extHostLanguageFeatures';
+import { FileChangeType } from 'vs/workbench/api/common/extHostTypes';
+import * as typeConverter from 'vs/workbench/api/common/extHostTypeConverters';
+import { ExtHostLanguageFeatures } from 'vs/workbench/api/common/extHostLanguageFeatures';
 import { Schemas } from 'vs/base/common/network';
 import { ResourceLabelFormatter } from 'vs/platform/label/common/label';
 import { State, StateMachine, LinkComputer, Edge } from 'vs/editor/common/modes/linkComputer';
 import { commonPrefixLength } from 'vs/base/common/strings';
 import { CharCode } from 'vs/base/common/charCode';
+import { VSBuffer } from 'vs/base/common/buffer';
 
 class FsLinkProvider {
 
@@ -229,14 +230,12 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
 		return Promise.resolve(this.getProvider(handle).readDirectory(URI.revive(resource)));
 	}
 
-	$readFile(handle: number, resource: UriComponents): Promise<Buffer> {
-		return Promise.resolve(this.getProvider(handle).readFile(URI.revive(resource))).then(data => {
-			return Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-		});
+	$readFile(handle: number, resource: UriComponents): Promise<VSBuffer> {
+		return Promise.resolve(this.getProvider(handle).readFile(URI.revive(resource))).then(data => VSBuffer.wrap(data));
 	}
 
-	$writeFile(handle: number, resource: UriComponents, content: Buffer, opts: files.FileWriteOptions): Promise<void> {
-		return Promise.resolve(this.getProvider(handle).writeFile(URI.revive(resource), content, opts));
+	$writeFile(handle: number, resource: UriComponents, content: VSBuffer, opts: files.FileWriteOptions): Promise<void> {
+		return Promise.resolve(this.getProvider(handle).writeFile(URI.revive(resource), content.buffer, opts));
 	}
 
 	$delete(handle: number, resource: UriComponents, opts: files.FileDeleteOptions): Promise<void> {
@@ -288,23 +287,23 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
 		return Promise.resolve(provider.close(fd));
 	}
 
-	$read(handle: number, fd: number, pos: number, length: number): Promise<Buffer> {
+	$read(handle: number, fd: number, pos: number, length: number): Promise<VSBuffer> {
 		const provider = this.getProvider(handle);
 		if (!provider.read) {
 			throw new Error('FileSystemProvider does not implement "read"');
 		}
-		const data = Buffer.allocUnsafe(length);
-		return Promise.resolve(provider.read(fd, pos, data, 0, length)).then(read => {
+		const data = VSBuffer.alloc(length);
+		return Promise.resolve(provider.read(fd, pos, data.buffer, 0, length)).then(read => {
 			return data.slice(0, read); // don't send zeros
 		});
 	}
 
-	$write(handle: number, fd: number, pos: number, data: Buffer): Promise<number> {
+	$write(handle: number, fd: number, pos: number, data: VSBuffer): Promise<number> {
 		const provider = this.getProvider(handle);
 		if (!provider.write) {
 			throw new Error('FileSystemProvider does not implement "write"');
 		}
-		return Promise.resolve(provider.write(fd, pos, data, 0, data.length));
+		return Promise.resolve(provider.write(fd, pos, data.buffer, 0, data.byteLength));
 	}
 
 	private getProvider(handle: number): vscode.FileSystemProvider {

src/vs/workbench/api/common/extHostFileSystemEventService.ts

@@ -7,9 +7,9 @@ import { flatten } from 'vs/base/common/arrays';
 import { AsyncEmitter, Emitter, Event } from 'vs/base/common/event';
 import { IRelativePattern, parse } from 'vs/base/common/glob';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
 import * as vscode from 'vscode';
-import { ExtHostFileSystemEventServiceShape, FileSystemEvents, IMainContext, MainContext, ResourceFileEditDto, ResourceTextEditDto, MainThreadTextEditorsShape } from '../common/extHost.protocol';
+import { ExtHostFileSystemEventServiceShape, FileSystemEvents, IMainContext, MainContext, ResourceFileEditDto, ResourceTextEditDto, MainThreadTextEditorsShape } from './extHost.protocol';
 import * as typeConverter from './extHostTypeConverters';
 import { Disposable, WorkspaceEdit } from './extHostTypes';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';

src/vs/workbench/api/common/extHostHeapService.ts

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ExtHostHeapServiceShape } from '../common/extHost.protocol';
+import { ExtHostHeapServiceShape } from './extHost.protocol';
 
 export class ExtHostHeapService implements ExtHostHeapServiceShape {
 

src/vs/workbench/api/common/extHostLanguageFeatures.ts

@@ -6,16 +6,16 @@
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { mixin } from 'vs/base/common/objects';
 import * as vscode from 'vscode';
-import * as typeConvert from 'vs/workbench/api/node/extHostTypeConverters';
-import { Range, Disposable, CompletionList, SnippetString, CodeActionKind, SymbolInformation, DocumentSymbol } from 'vs/workbench/api/node/extHostTypes';
+import * as typeConvert from 'vs/workbench/api/common/extHostTypeConverters';
+import { Range, Disposable, CompletionList, SnippetString, CodeActionKind, SymbolInformation, DocumentSymbol } from 'vs/workbench/api/common/extHostTypes';
 import { ISingleEditOperation } from 'vs/editor/common/model';
 import * as modes from 'vs/editor/common/modes';
-import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
-import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
-import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/node/extHostCommands';
-import { ExtHostDiagnostics } from 'vs/workbench/api/node/extHostDiagnostics';
+import { ExtHostHeapService } from 'vs/workbench/api/common/extHostHeapService';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/common/extHostCommands';
+import { ExtHostDiagnostics } from 'vs/workbench/api/common/extHostDiagnostics';
 import { asPromise } from 'vs/base/common/async';
-import { MainContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, ObjectIdentifier, IRawColorInfo, IMainContext, IdObject, ISerializedRegExp, ISerializedIndentationRule, ISerializedOnEnterRule, ISerializedLanguageConfiguration, WorkspaceSymbolDto, SuggestResultDto, WorkspaceSymbolsDto, CodeActionDto, ISerializedDocumentFilter, WorkspaceEditDto, ISerializedSignatureHelpProviderMetadata, LinkDto, CodeLensDto, MainThreadWebviewsShape, CodeInsetDto, SuggestDataDto, LinksListDto, ChainedCacheId } from '../common/extHost.protocol';
+import { MainContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, ObjectIdentifier, IRawColorInfo, IMainContext, IdObject, ISerializedRegExp, ISerializedIndentationRule, ISerializedOnEnterRule, ISerializedLanguageConfiguration, WorkspaceSymbolDto, SuggestResultDto, WorkspaceSymbolsDto, CodeActionDto, ISerializedDocumentFilter, WorkspaceEditDto, ISerializedSignatureHelpProviderMetadata, LinkDto, CodeLensDto, MainThreadWebviewsShape, CodeInsetDto, SuggestDataDto, LinksListDto, ChainedCacheId } from './extHost.protocol';
 import { regExpLeadsToEndlessLoop, regExpFlags } from 'vs/base/common/strings';
 import { IPosition } from 'vs/editor/common/core/position';
 import { IRange, Range as EditorRange } from 'vs/editor/common/core/range';
@@ -25,7 +25,7 @@ import { ISelection, Selection } from 'vs/editor/common/core/selection';
 import { ILogService } from 'vs/platform/log/common/log';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
-import { ExtHostWebview } from 'vs/workbench/api/node/extHostWebview';
+import { ExtHostWebview } from 'vs/workbench/api/common/extHostWebview';
 import * as codeInset from 'vs/workbench/contrib/codeinset/common/codeInset';
 import { generateUuid } from 'vs/base/common/uuid';
 import * as callHierarchy from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';

src/vs/workbench/api/common/extHostLanguages.ts

@@ -3,9 +3,9 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { MainContext, MainThreadLanguagesShape, IMainContext } from '../common/extHost.protocol';
+import { MainContext, MainThreadLanguagesShape, IMainContext } from './extHost.protocol';
 import * as vscode from 'vscode';
-import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
 
 export class ExtHostLanguages {
 

src/vs/workbench/api/common/extHostLogService.ts

@@ -5,7 +5,6 @@
 
 import { join } from 'vs/base/common/path';
 import { ILogService, DelegatedLogService, LogLevel } from 'vs/platform/log/common/log';
-import { createSpdLogService } from 'vs/platform/log/node/spdlogService';
 import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
 import { URI } from 'vs/base/common/uri';
@@ -17,10 +16,10 @@ export class ExtHostLogService extends DelegatedLogService implements ILogServic
 	readonly logFile: URI;
 
 	constructor(
-		logLevel: LogLevel,
+		delegate: ILogService,
 		logsPath: string,
 	) {
-		super(createSpdLogService(ExtensionHostLogFileName, logLevel, logsPath));
+		super(delegate);
 		this._logsPath = logsPath;
 		this.logFile = URI.file(join(logsPath, `${ExtensionHostLogFileName}.log`));
 	}

src/vs/workbench/api/common/extHostMessageService.ts

@@ -5,7 +5,7 @@
 
 import Severity from 'vs/base/common/severity';
 import * as vscode from 'vscode';
-import { MainContext, MainThreadMessageServiceShape, MainThreadMessageOptions, IMainContext } from '../common/extHost.protocol';
+import { MainContext, MainThreadMessageServiceShape, MainThreadMessageOptions, IMainContext } from './extHost.protocol';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 
 function isMessageItem(item: any): item is vscode.MessageItem {

src/vs/workbench/api/common/extHostOutput.ts

@@ -0,0 +1,186 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainContext, MainThreadOutputServiceShape, IMainContext, ExtHostOutputServiceShape } from './extHost.protocol';
+import * as vscode from 'vscode';
+import { URI } from 'vs/base/common/uri';
+import { Event, Emitter } from 'vs/base/common/event';
+import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
+
+export abstract class AbstractExtHostOutputChannel extends Disposable implements vscode.OutputChannel {
+
+	readonly _id: Promise<string>;
+	private readonly _name: string;
+	protected readonly _proxy: MainThreadOutputServiceShape;
+	private _disposed: boolean;
+	private _offset: number;
+
+	protected readonly _onDidAppend: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidAppend: Event<void> = this._onDidAppend.event;
+
+	constructor(name: string, log: boolean, file: URI | undefined, proxy: MainThreadOutputServiceShape) {
+		super();
+
+		this._name = name;
+		this._proxy = proxy;
+		this._id = proxy.$register(this.name, log, file);
+		this._offset = 0;
+	}
+
+	get name(): string {
+		return this._name;
+	}
+
+	append(value: string): void {
+		this.validate();
+		this._offset += value ? Buffer.from(value).byteLength : 0;
+	}
+
+	update(): void {
+		this._id.then(id => this._proxy.$update(id));
+	}
+
+	appendLine(value: string): void {
+		this.validate();
+		this.append(value + '\n');
+	}
+
+	clear(): void {
+		this.validate();
+		const till = this._offset;
+		this._id.then(id => this._proxy.$clear(id, till));
+	}
+
+	show(columnOrPreserveFocus?: vscode.ViewColumn | boolean, preserveFocus?: boolean): void {
+		this.validate();
+		this._id.then(id => this._proxy.$reveal(id, !!(typeof columnOrPreserveFocus === 'boolean' ? columnOrPreserveFocus : preserveFocus)));
+	}
+
+	hide(): void {
+		this.validate();
+		this._id.then(id => this._proxy.$close(id));
+	}
+
+	protected validate(): void {
+		if (this._disposed) {
+			throw new Error('Channel has been closed');
+		}
+	}
+
+	dispose(): void {
+		super.dispose();
+
+		if (!this._disposed) {
+			this._id
+				.then(id => this._proxy.$dispose(id))
+				.then(() => this._disposed = true);
+		}
+	}
+}
+
+export class ExtHostPushOutputChannel extends AbstractExtHostOutputChannel {
+
+	constructor(name: string, proxy: MainThreadOutputServiceShape) {
+		super(name, false, undefined, proxy);
+	}
+
+	append(value: string): void {
+		super.append(value);
+		this._id.then(id => this._proxy.$append(id, value));
+		this._onDidAppend.fire();
+	}
+}
+
+class ExtHostLogFileOutputChannel extends AbstractExtHostOutputChannel {
+
+	constructor(name: string, file: URI, proxy: MainThreadOutputServiceShape) {
+		super(name, true, file, proxy);
+	}
+
+	append(value: string): void {
+		throw new Error('Not supported');
+	}
+}
+
+export interface IOutputChannelFactory {
+	createOutputChannel(name: string, logsLocation: URI, proxy: MainThreadOutputServiceShape): Promise<AbstractExtHostOutputChannel>;
+}
+
+export const PushOutputChannelFactory = new class implements IOutputChannelFactory {
+	async createOutputChannel(name: string, _logsLocation: URI, proxy: MainThreadOutputServiceShape): Promise<AbstractExtHostOutputChannel> {
+		return new ExtHostPushOutputChannel(name, proxy);
+	}
+};
+
+export class ExtHostOutputService implements ExtHostOutputServiceShape {
+
+	private readonly _factory: IOutputChannelFactory;
+	private readonly _logsLocation: URI;
+	private readonly _proxy: MainThreadOutputServiceShape;
+	private readonly _channels: Map<string, AbstractExtHostOutputChannel> = new Map<string, AbstractExtHostOutputChannel>();
+	private _visibleChannelDisposable: IDisposable;
+
+	constructor(factory: IOutputChannelFactory, logsLocation: URI, mainContext: IMainContext) {
+		this._factory = factory;
+		this._logsLocation = logsLocation;
+		this._proxy = mainContext.getProxy(MainContext.MainThreadOutputService);
+	}
+
+	$setVisibleChannel(channelId: string): void {
+		if (this._visibleChannelDisposable) {
+			this._visibleChannelDisposable = dispose(this._visibleChannelDisposable);
+		}
+		if (channelId) {
+			const channel = this._channels.get(channelId);
+			if (channel) {
+				this._visibleChannelDisposable = channel.onDidAppend(() => channel.update());
+			}
+		}
+	}
+
+	createOutputChannel(name: string): vscode.OutputChannel {
+		name = name.trim();
+		if (!name) {
+			throw new Error('illegal argument `name`. must not be falsy');
+		} else {
+			const extHostOutputChannel = this._factory.createOutputChannel(name, this._logsLocation, this._proxy);
+			extHostOutputChannel.then(channel => channel._id.then(id => this._channels.set(id, channel)));
+			return {
+				get name(): string {
+					return name;
+				},
+				append(value: string): void {
+					extHostOutputChannel.then(channel => channel.append(value));
+				},
+				appendLine(value: string): void {
+					extHostOutputChannel.then(channel => channel.appendLine(value));
+				},
+				clear(): void {
+					extHostOutputChannel.then(channel => channel.clear());
+				},
+				show(columnOrPreserveFocus?: vscode.ViewColumn | boolean, preserveFocus?: boolean): void {
+					extHostOutputChannel.then(channel => channel.show(columnOrPreserveFocus, preserveFocus));
+				},
+				hide(): void {
+					extHostOutputChannel.then(channel => channel.hide());
+				},
+				dispose(): void {
+					extHostOutputChannel.then(channel => channel.dispose());
+				}
+			};
+		}
+	}
+
+	createOutputChannelFromLogFile(name: string, file: URI): vscode.OutputChannel {
+		name = name.trim();
+		if (!name) {
+			throw new Error('illegal argument `name`. must not be falsy');
+		}
+		if (!file) {
+			throw new Error('illegal argument `file`. must not be falsy');
+		}
+		return new ExtHostLogFileOutputChannel(name, file, this._proxy);
+	}
+}

src/vs/workbench/api/common/extHostProgress.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ProgressOptions } from 'vscode';
-import { MainThreadProgressShape, ExtHostProgressShape } from '../common/extHost.protocol';
+import { MainThreadProgressShape, ExtHostProgressShape } from './extHost.protocol';
 import { ProgressLocation } from './extHostTypeConverters';
 import { Progress, IProgressStep } from 'vs/platform/progress/common/progress';
 import { localize } from 'vs/nls';

src/vs/workbench/api/common/extHostQuickOpen.ts

@@ -7,12 +7,12 @@ import { asPromise } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter } from 'vs/base/common/event';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { IExtHostWorkspaceProvider } from 'vs/workbench/api/node/extHostWorkspace';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { IExtHostWorkspaceProvider } from 'vs/workbench/api/common/extHostWorkspace';
 import { InputBox, InputBoxOptions, QuickInput, QuickInputButton, QuickPick, QuickPickItem, QuickPickOptions, WorkspaceFolder, WorkspaceFolderPickOptions } from 'vscode';
-import { ExtHostQuickOpenShape, IMainContext, MainContext, MainThreadQuickOpenShape, TransferQuickPickItems, TransferQuickInput, TransferQuickInputButton } from '../common/extHost.protocol';
+import { ExtHostQuickOpenShape, IMainContext, MainContext, MainThreadQuickOpenShape, TransferQuickPickItems, TransferQuickInput, TransferQuickInputButton } from './extHost.protocol';
 import { URI } from 'vs/base/common/uri';
-import { ThemeIcon, QuickInputButtons } from 'vs/workbench/api/node/extHostTypes';
+import { ThemeIcon, QuickInputButtons } from 'vs/workbench/api/common/extHostTypes';
 import { isPromiseCanceledError } from 'vs/base/common/errors';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { coalesce } from 'vs/base/common/arrays';

src/vs/workbench/api/common/extHostSCM.ts

@@ -8,8 +8,8 @@ import { Event, Emitter } from 'vs/base/common/event';
 import { debounce } from 'vs/base/common/decorators';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { asPromise } from 'vs/base/common/async';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { MainContext, MainThreadSCMShape, SCMRawResource, SCMRawResourceSplice, SCMRawResourceSplices, IMainContext, ExtHostSCMShape, CommandDto } from '../common/extHost.protocol';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { MainContext, MainThreadSCMShape, SCMRawResource, SCMRawResourceSplice, SCMRawResourceSplices, IMainContext, ExtHostSCMShape, CommandDto } from './extHost.protocol';
 import { sortedDiff } from 'vs/base/common/arrays';
 import { comparePaths } from 'vs/base/common/comparers';
 import * as vscode from 'vscode';

src/vs/workbench/api/common/extHostStatusBar.ts

@@ -6,7 +6,7 @@
 import { StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/platform/statusbar/common/statusbar';
 import { StatusBarAlignment as ExtHostStatusBarAlignment, Disposable, ThemeColor } from './extHostTypes';
 import { StatusBarItem, StatusBarAlignment } from 'vscode';
-import { MainContext, MainThreadStatusBarShape, IMainContext } from '../common/extHost.protocol';
+import { MainContext, MainThreadStatusBarShape, IMainContext } from './extHost.protocol';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 
 export class ExtHostStatusBarEntry implements StatusBarItem {

src/vs/workbench/api/common/extHostStorage.ts

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { MainContext, MainThreadStorageShape, IMainContext, ExtHostStorageShape } from '../common/extHost.protocol';
+import { MainContext, MainThreadStorageShape, IMainContext, ExtHostStorageShape } from './extHost.protocol';
 import { Emitter } from 'vs/base/common/event';
 
 export interface IStorageChangeEvent {

src/vs/workbench/api/common/extHostTextEditor.ts

@@ -10,9 +10,9 @@ import { TextEditorCursorStyle } from 'vs/editor/common/config/editorOptions';
 import { IRange } from 'vs/editor/common/core/range';
 import { ISingleEditOperation } from 'vs/editor/common/model';
 import { IResolvedTextEditorConfiguration, ITextEditorConfigurationUpdate, MainThreadTextEditorsShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostDocumentData } from 'vs/workbench/api/node/extHostDocumentData';
-import * as TypeConverters from 'vs/workbench/api/node/extHostTypeConverters';
-import { EndOfLine, Position, Range, Selection, SnippetString, TextEditorLineNumbersStyle, TextEditorRevealType } from 'vs/workbench/api/node/extHostTypes';
+import { ExtHostDocumentData } from 'vs/workbench/api/common/extHostDocumentData';
+import * as TypeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import { EndOfLine, Position, Range, Selection, SnippetString, TextEditorLineNumbersStyle, TextEditorRevealType } from 'vs/workbench/api/common/extHostTypes';
 import * as vscode from 'vscode';
 
 export class TextEditorDecorationType implements vscode.TextEditorDecorationType {

src/vs/workbench/api/common/extHostTextEditors.ts

@@ -6,10 +6,10 @@
 import { Emitter, Event } from 'vs/base/common/event';
 import * as arrays from 'vs/base/common/arrays';
 import { ExtHostEditorsShape, IEditorPropertiesChangeData, IMainContext, ITextDocumentShowOptions, ITextEditorPositionData, MainContext, MainThreadTextEditorsShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
-import { ExtHostTextEditor, TextEditorDecorationType } from 'vs/workbench/api/node/extHostTextEditor';
-import * as TypeConverters from 'vs/workbench/api/node/extHostTypeConverters';
-import { TextEditorSelectionChangeKind } from 'vs/workbench/api/node/extHostTypes';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { ExtHostTextEditor, TextEditorDecorationType } from 'vs/workbench/api/common/extHostTextEditor';
+import * as TypeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import { TextEditorSelectionChangeKind } from 'vs/workbench/api/common/extHostTypes';
 import * as vscode from 'vscode';
 
 export class ExtHostEditors implements ExtHostEditorsShape {

src/vs/workbench/api/common/extHostTreeViews.ts

@@ -9,11 +9,11 @@ import { basename } from 'vs/base/common/resources';
 import { URI } from 'vs/base/common/uri';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
-import { ExtHostTreeViewsShape, MainThreadTreeViewsShape } from '../common/extHost.protocol';
+import { ExtHostTreeViewsShape, MainThreadTreeViewsShape } from './extHost.protocol';
 import { ITreeItem, TreeViewItemHandleArg, ITreeItemLabel, IRevealOptions } from 'vs/workbench/common/views';
-import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/node/extHostCommands';
+import { ExtHostCommands, CommandsConverter } from 'vs/workbench/api/common/extHostCommands';
 import { asPromise } from 'vs/base/common/async';
-import { TreeItemCollapsibleState, ThemeIcon, MarkdownString } from 'vs/workbench/api/node/extHostTypes';
+import { TreeItemCollapsibleState, ThemeIcon, MarkdownString } from 'vs/workbench/api/common/extHostTypes';
 import { isUndefinedOrNull, isString } from 'vs/base/common/types';
 import { equals, coalesce } from 'vs/base/common/arrays';
 import { ILogService } from 'vs/platform/log/common/log';

src/vs/workbench/api/common/extHostTypeConverters.ts

@@ -22,7 +22,7 @@ import * as languageSelector from 'vs/editor/common/modes/languageSelector';
 import { WorkspaceEditDto, ResourceTextEditDto, ResourceFileEditDto } from 'vs/workbench/api/common/extHost.protocol';
 import { MarkerSeverity, IRelatedInformation, IMarkerData, MarkerTag } from 'vs/platform/markers/common/markers';
 import { ACTIVE_GROUP, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
 import { isString, isNumber } from 'vs/base/common/types';
 import * as marked from 'vs/base/common/marked/marked';
 import { parse } from 'vs/base/common/marshalling';

src/vs/workbench/api/common/extHostUrls.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { MainContext, IMainContext, ExtHostUrlsShape, MainThreadUrlsShape } from '../common/extHost.protocol';
+import { MainContext, IMainContext, ExtHostUrlsShape, MainThreadUrlsShape } from './extHost.protocol';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { toDisposable } from 'vs/base/common/lifecycle';
 import { onUnexpectedError } from 'vs/base/common/errors';

src/vs/workbench/api/common/extHostWebview.ts

@@ -5,10 +5,10 @@
 
 import { Emitter, Event } from 'vs/base/common/event';
 import { URI } from 'vs/base/common/uri';
-import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
 import { EditorViewColumn } from 'vs/workbench/api/common/shared/editor';
 import * as vscode from 'vscode';
-import { ExtHostWebviewsShape, IMainContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelViewState, WebviewInsetHandle } from '../common/extHost.protocol';
+import { ExtHostWebviewsShape, IMainContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelViewState, WebviewInsetHandle } from './extHost.protocol';
 import { Disposable } from './extHostTypes';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 

src/vs/workbench/api/common/extHostWindow.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Event, Emitter } from 'vs/base/common/event';
-import { ExtHostWindowShape, MainContext, MainThreadWindowShape, IMainContext } from '../common/extHost.protocol';
+import { ExtHostWindowShape, MainContext, MainThreadWindowShape, IMainContext } from './extHost.protocol';
 import { WindowState } from 'vscode';
 import { URI } from 'vs/base/common/uri';
 import { Schemas } from 'vs/base/common/network';
@@ -38,12 +38,19 @@ export class ExtHostWindow implements ExtHostWindowShape {
 		this._onDidChangeWindowState.fire(this._state);
 	}
 
-	openUri(uri: URI): Promise<boolean> {
-		if (isFalsyOrWhitespace(uri.scheme)) {
-			return Promise.reject('Invalid scheme - cannot be empty');
-		} else if (uri.scheme === Schemas.command) {
-			return Promise.reject(`Invalid scheme '${uri.scheme}'`);
+	openUri(stringOrUri: string | URI): Promise<boolean> {
+		if (typeof stringOrUri === 'string') {
+			try {
+				stringOrUri = URI.parse(stringOrUri);
+			} catch (e) {
+				return Promise.reject(`Invalid uri - '${stringOrUri}'`);
+			}
 		}
-		return this._proxy.$openUri(uri);
+		if (isFalsyOrWhitespace(stringOrUri.scheme)) {
+			return Promise.reject('Invalid scheme - cannot be empty');
+		} else if (stringOrUri.scheme === Schemas.command) {
+			return Promise.reject(`Invalid scheme '${stringOrUri.scheme}'`);
+		}
+		return this._proxy.$openUri(stringOrUri);
 	}
 }

src/vs/workbench/api/common/extHostWorkspace.ts

@@ -18,10 +18,10 @@ import { ILogService } from 'vs/platform/log/common/log';
 import { Severity } from 'vs/platform/notification/common/notification';
 import { IRawFileMatch2, resultIsMatch } from 'vs/workbench/services/search/common/search';
 import { Workspace, WorkspaceFolder } from 'vs/platform/workspace/common/workspace';
-import { Range, RelativePattern } from 'vs/workbench/api/node/extHostTypes';
+import { Range, RelativePattern } from 'vs/workbench/api/common/extHostTypes';
 import { ITextQueryBuilderOptions } from 'vs/workbench/contrib/search/common/queryBuilder';
 import * as vscode from 'vscode';
-import { ExtHostWorkspaceShape, IWorkspaceData, MainThreadMessageServiceShape, MainThreadWorkspaceShape, IMainContext, MainContext, IStaticWorkspaceData } from '../common/extHost.protocol';
+import { ExtHostWorkspaceShape, IWorkspaceData, MainThreadMessageServiceShape, MainThreadWorkspaceShape, IMainContext, MainContext, IStaticWorkspaceData } from './extHost.protocol';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { Barrier } from 'vs/base/common/async';
 

src/vs/workbench/api/electron-browser/extensionHost.contribution.ts

@@ -55,7 +55,7 @@ import '../browser/mainThreadWorkspace';
 import '../browser/mainThreadComments';
 import '../browser/mainThreadTask';
 import './mainThreadWebview';
-import 'vs/workbench/api/node/apiCommands';
+import 'vs/workbench/api/common/apiCommands';
 
 export class ExtensionPoints implements IWorkbenchContribution {
 

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -16,58 +16,60 @@ import { OverviewRulerLane } from 'vs/editor/common/model';
 import * as languageConfiguration from 'vs/editor/common/modes/languageConfiguration';
 import { score } from 'vs/editor/common/modes/languageSelector';
 import * as files from 'vs/platform/files/common/files';
-import { ExtHostContext, IInitData, IMainContext, MainContext, MainThreadKeytarShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostApiCommands } from 'vs/workbench/api/node/extHostApiCommands';
-import { ExtHostClipboard } from 'vs/workbench/api/node/extHostClipboard';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { ExtHostComments } from 'vs/workbench/api/node/extHostComments';
-import { ExtHostConfiguration, ExtHostConfigProvider } from 'vs/workbench/api/node/extHostConfiguration';
+import { ExtHostContext, IInitData, IMainContext, MainContext, MainThreadKeytarShape, IEnvironment, MainThreadWindowShape, MainThreadTelemetryShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostApiCommands } from 'vs/workbench/api/common/extHostApiCommands';
+import { ExtHostClipboard } from 'vs/workbench/api/common/extHostClipboard';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { ExtHostComments } from 'vs/workbench/api/common/extHostComments';
+import { ExtHostConfiguration, ExtHostConfigProvider } from 'vs/workbench/api/common/extHostConfiguration';
 // {{SQL CARBON EDIT}} - Remove ExtHostDebugService
 // import { ExtHostDebugService } from 'vs/workbench/api/node/extHostDebugService';
 // {{SQL CARBON EDIT}} - Import product
 import product from 'vs/platform/product/node/product';
-import { ExtHostDecorations } from 'vs/workbench/api/node/extHostDecorations';
-import { ExtHostDiagnostics } from 'vs/workbench/api/node/extHostDiagnostics';
-import { ExtHostDialogs } from 'vs/workbench/api/node/extHostDialogs';
-import { ExtHostDocumentContentProvider } from 'vs/workbench/api/node/extHostDocumentContentProviders';
-import { ExtHostDocumentSaveParticipant } from 'vs/workbench/api/node/extHostDocumentSaveParticipant';
-import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
-import { ExtensionActivatedByAPI } from 'vs/workbench/api/node/extHostExtensionActivator';
+import { ExtHostDecorations } from 'vs/workbench/api/common/extHostDecorations';
+import { ExtHostDiagnostics } from 'vs/workbench/api/common/extHostDiagnostics';
+import { ExtHostDialogs } from 'vs/workbench/api/common/extHostDialogs';
+import { ExtHostDocumentContentProvider } from 'vs/workbench/api/common/extHostDocumentContentProviders';
+import { ExtHostDocumentSaveParticipant } from 'vs/workbench/api/common/extHostDocumentSaveParticipant';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { ExtensionActivatedByAPI } from 'vs/workbench/api/common/extHostExtensionActivator';
 import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
-import { ExtHostFileSystem } from 'vs/workbench/api/node/extHostFileSystem';
-import { ExtHostFileSystemEventService } from 'vs/workbench/api/node/extHostFileSystemEventService';
-import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
-import { ExtHostLanguageFeatures, ISchemeTransformer } from 'vs/workbench/api/node/extHostLanguageFeatures';
-import { ExtHostLanguages } from 'vs/workbench/api/node/extHostLanguages';
-import { ExtHostLogService } from 'vs/workbench/api/node/extHostLogService';
-import { ExtHostMessageService } from 'vs/workbench/api/node/extHostMessageService';
-import { ExtHostOutputService } from 'vs/workbench/api/node/extHostOutputService';
-import { ExtHostProgress } from 'vs/workbench/api/node/extHostProgress';
-import { ExtHostQuickOpen } from 'vs/workbench/api/node/extHostQuickOpen';
-import { ExtHostSCM } from 'vs/workbench/api/node/extHostSCM';
+import { ExtHostFileSystem } from 'vs/workbench/api/common/extHostFileSystem';
+import { ExtHostFileSystemEventService } from 'vs/workbench/api/common/extHostFileSystemEventService';
+import { ExtHostHeapService } from 'vs/workbench/api/common/extHostHeapService';
+import { ExtHostLanguageFeatures, ISchemeTransformer } from 'vs/workbench/api/common/extHostLanguageFeatures';
+import { ExtHostLanguages } from 'vs/workbench/api/common/extHostLanguages';
+import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
+import { ExtHostMessageService } from 'vs/workbench/api/common/extHostMessageService';
+import { ExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+import { LogOutputChannelFactory } from 'vs/workbench/api/node/extHostOutputService';
+import { ExtHostProgress } from 'vs/workbench/api/common/extHostProgress';
+import { ExtHostQuickOpen } from 'vs/workbench/api/common/extHostQuickOpen';
+import { ExtHostSCM } from 'vs/workbench/api/common/extHostSCM';
 import { ExtHostSearch } from 'vs/workbench/api/node/extHostSearch';
-import { ExtHostStatusBar } from 'vs/workbench/api/node/extHostStatusBar';
-import { ExtHostStorage } from 'vs/workbench/api/node/extHostStorage';
+import { ExtHostStatusBar } from 'vs/workbench/api/common/extHostStatusBar';
+import { ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
 import { ExtHostTask } from 'vs/workbench/api/node/extHostTask';
 import { ExtHostTerminalService } from 'vs/workbench/api/node/extHostTerminalService';
-import { ExtHostEditors } from 'vs/workbench/api/node/extHostTextEditors';
-import { ExtHostTreeViews } from 'vs/workbench/api/node/extHostTreeViews';
-import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
-import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
-import { ExtHostUrls } from 'vs/workbench/api/node/extHostUrls';
-import { ExtHostWebviews } from 'vs/workbench/api/node/extHostWebview';
-import { ExtHostWindow } from 'vs/workbench/api/node/extHostWindow';
-import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
+import { ExtHostEditors } from 'vs/workbench/api/common/extHostTextEditors';
+import { ExtHostTreeViews } from 'vs/workbench/api/common/extHostTreeViews';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import * as extHostTypes from 'vs/workbench/api/common/extHostTypes';
+import { ExtHostUrls } from 'vs/workbench/api/common/extHostUrls';
+import { ExtHostWebviews } from 'vs/workbench/api/common/extHostWebview';
+import { ExtHostWindow } from 'vs/workbench/api/common/extHostWindow';
+import { ExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
 import { throwProposedApiError, checkProposedApiEnabled, nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { ProxyIdentifier } from 'vs/workbench/services/extensions/common/proxyIdentifier';
-import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import * as vscode from 'vscode';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { originalFSPath } from 'vs/base/common/resources';
 import { CLIServer } from 'vs/workbench/api/node/extHostCLIServer';
 import { withNullAsUndefined } from 'vs/base/common/types';
 import { values } from 'vs/base/common/collections';
+import { endsWith } from 'vs/base/common/strings';
 
 export interface IExtensionApiFactory {
 	(extension: IExtensionDescription, registry: ExtensionDescriptionRegistry, configProvider: ExtHostConfigProvider): typeof vscode;
@@ -126,7 +128,7 @@ export function createApiFactory(
 	const extHostWindow = rpcProtocol.set(ExtHostContext.ExtHostWindow, new ExtHostWindow(rpcProtocol));
 	rpcProtocol.set(ExtHostContext.ExtHostExtensionService, extensionService);
 	const extHostProgress = rpcProtocol.set(ExtHostContext.ExtHostProgress, new ExtHostProgress(rpcProtocol.getProxy(MainContext.MainThreadProgress)));
-	const extHostOutputService = rpcProtocol.set(ExtHostContext.ExtHostOutputService, new ExtHostOutputService(initData.logsLocation, rpcProtocol));
+	const extHostOutputService = rpcProtocol.set(ExtHostContext.ExtHostOutputService, new ExtHostOutputService(LogOutputChannelFactory, initData.logsLocation, rpcProtocol));
 	rpcProtocol.set(ExtHostContext.ExtHostStorage, extHostStorage);
 	if (initData.remoteAuthority) {
 		const cliServer = new CLIServer(extHostCommands);
@@ -880,34 +882,59 @@ class Extension<T> implements vscode.Extension<T> {
 	}
 }
 
+interface LoadFunction {
+	(request: string, parent: { filename: string; }, isMain: any): any;
+}
+
 interface INodeModuleFactory {
-	readonly nodeModuleName: string;
-	load(request: string, parent: { filename: string; }): any;
+	readonly nodeModuleName: string | string[];
+	load(request: string, parent: { filename: string; }, isMain: any, original: LoadFunction): any;
+	alternaiveModuleName?(name: string): string | undefined;
 }
 
 export class NodeModuleRequireInterceptor {
 	public static INSTANCE = new NodeModuleRequireInterceptor();
 
 	private readonly _factories: Map<string, INodeModuleFactory>;
+	private readonly _alternatives: ((moduleName: string) => string | undefined)[];
 
 	constructor() {
 		this._factories = new Map<string, INodeModuleFactory>();
-		this._installInterceptor(this._factories);
+		this._alternatives = [];
+		this._installInterceptor(this._factories, this._alternatives);
 	}
 
-	private _installInterceptor(factories: Map<string, INodeModuleFactory>): void {
+	private _installInterceptor(factories: Map<string, INodeModuleFactory>, alternatives: ((moduleName: string) => string | undefined)[]): void {
 		const node_module = <any>require.__$__nodeRequire('module');
 		const original = node_module._load;
 		node_module._load = function load(request: string, parent: { filename: string; }, isMain: any) {
+			for (let alternativeModuleName of alternatives) {
+				let alternative = alternativeModuleName(request);
+				if (alternative) {
+					request = alternative;
+					break;
+				}
+			}
 			if (!factories.has(request)) {
 				return original.apply(this, arguments);
 			}
-			return factories.get(request)!.load(request, parent);
+			return factories.get(request)!.load(request, parent, isMain, original);
 		};
 	}
 
 	public register(interceptor: INodeModuleFactory): void {
-		this._factories.set(interceptor.nodeModuleName, interceptor);
+		if (Array.isArray(interceptor.nodeModuleName)) {
+			for (let moduleName of interceptor.nodeModuleName) {
+				this._factories.set(moduleName, interceptor);
+			}
+		} else {
+			this._factories.set(interceptor.nodeModuleName, interceptor);
+		}
+		if (typeof interceptor.alternaiveModuleName === 'function') {
+			this._alternatives.push((moduleName) => {
+				return interceptor.alternaiveModuleName!(moduleName);
+			});
+		}
 	}
 }
 
@@ -957,11 +984,24 @@ interface IKeytarModule {
 }
 
 export class KeytarNodeModuleFactory implements INodeModuleFactory {
-	public readonly nodeModuleName = 'keytar';
+	public readonly nodeModuleName: string = 'keytar';
 
+	private alternativeNames: Set<string> | undefined;
 	private _impl: IKeytarModule;
 
-	constructor(mainThreadKeytar: MainThreadKeytarShape) {
+	constructor(mainThreadKeytar: MainThreadKeytarShape, environment: IEnvironment) {
+		if (environment.appRoot) {
+			let appRoot = environment.appRoot.fsPath;
+			if (process.platform === 'win32') {
+				appRoot = appRoot.replace(/\\/g, '/');
+			}
+			if (appRoot[appRoot.length - 1] === '/') {
+				appRoot = appRoot.substr(0, appRoot.length - 1);
+			}
+			this.alternativeNames = new Set();
+			this.alternativeNames.add(`${appRoot}/node_modules.asar/keytar`);
+			this.alternativeNames.add(`${appRoot}/node_modules/keytar`);
+		}
 		this._impl = {
 			getPassword: (service: string, account: string): Promise<string | null> => {
 				return mainThreadKeytar.$getPassword(service, account);
@@ -981,4 +1021,100 @@ export class KeytarNodeModuleFactory implements INodeModuleFactory {
 	public load(request: string, parent: { filename: string; }): any {
 		return this._impl;
 	}
+
+	public alternaiveModuleName(name: string): string | undefined {
+		const length = name.length;
+		// We need at least something like: `?/keytar` which requires
+		// more than 7 characters.
+		if (length <= 7 || !this.alternativeNames) {
+			return undefined;
+		}
+		const sep = length - 7;
+		if ((name.charAt(sep) === '/' || name.charAt(sep) === '\\') && endsWith(name, 'keytar')) {
+			name = name.replace(/\\/g, '/');
+			if (this.alternativeNames.has(name)) {
+				return 'keytar';
+			}
+		}
+		return undefined;
+	}
+}
+
+interface OpenOptions {
+	wait: boolean;
+	app: string | string[];
+}
+
+interface IOriginalOpen {
+	(target: string, options?: OpenOptions): Thenable<any>;
+}
+
+interface IOpenModule {
+	(target: string, options?: OpenOptions): Thenable<void>;
+}
+
+export class OpenNodeModuleFactory implements INodeModuleFactory {
+
+	public readonly nodeModuleName: string[] = ['open', 'opn'];
+
+	private _extensionId: string | undefined;
+	private _original: IOriginalOpen;
+	private _impl: IOpenModule;
+
+	constructor(mainThreadWindow: MainThreadWindowShape, private _mainThreadTelemerty: MainThreadTelemetryShape, private readonly _extensionPaths: TernarySearchTree<IExtensionDescription>) {
+		this._impl = (target, options) => {
+			const uri: URI = URI.parse(target);
+			// If we have options use the original method.
+			if (options) {
+				return this.callOriginal(target, options);
+			}
+			if (uri.scheme === 'http' || uri.scheme === 'https') {
+				return mainThreadWindow.$openUri(uri);
+			} else if (uri.scheme === 'mailto') {
+				return mainThreadWindow.$openUri(uri);
+			}
+			return this.callOriginal(target, options);
+		};
+	}
+
+	public load(request: string, parent: { filename: string; }, isMain: any, original: LoadFunction): any {
+		// get extension id from filename and api for extension
+		const extension = this._extensionPaths.findSubstr(URI.file(parent.filename).fsPath);
+		if (extension) {
+			this._extensionId = extension.identifier.value;
+			this.sendShimmingTelemetry();
+		}
+
+		this._original = original(request, parent, isMain);
+		return this._impl;
+	}
+
+	private callOriginal(target: string, options: OpenOptions | undefined): Thenable<any> {
+		this.sendNoForwardTelemetry();
+		return this._original(target, options);
+	}
+
+	private sendShimmingTelemetry(): void {
+		if (!this._extensionId) {
+			return;
+		}
+		/* __GDPR__
+			"shimming.open" : {
+				"extension": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		this._mainThreadTelemerty.$publicLog('shimming.open', { extension: this._extensionId });
+	}
+
+	private sendNoForwardTelemetry(): void {
+		if (!this._extensionId) {
+			return;
+		}
+		/* __GDPR__
+			"shimming.open.call.noForward" : {
+				"extension": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		this._mainThreadTelemerty.$publicLog('shimming.open.call.noForward', { extension: this._extensionId });
+	}
 }

src/vs/workbench/api/node/extHostCLIServer.ts

@@ -6,7 +6,7 @@
 import { generateRandomPipeName } from 'vs/base/parts/ipc/node/ipc.net';
 import * as http from 'http';
 import * as fs from 'fs';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
 import { IURIToOpen, IOpenSettings } from 'vs/platform/windows/common/windows';
 import { URI } from 'vs/base/common/uri';
 import { hasWorkspaceFileExtension } from 'vs/platform/workspaces/common/workspaces';

src/vs/workbench/api/node/extHostDebugService.ts

@@ -16,24 +16,24 @@ import {
 	IMainContext, IBreakpointsDeltaDto, ISourceMultiBreakpointDto, IFunctionBreakpointDto, IDebugSessionDto
 } from 'vs/workbench/api/common/extHost.protocol';
 import * as vscode from 'vscode';
-import { Disposable, Position, Location, SourceBreakpoint, FunctionBreakpoint, DebugAdapterServer, DebugAdapterExecutable } from 'vs/workbench/api/node/extHostTypes';
+import { Disposable, Position, Location, SourceBreakpoint, FunctionBreakpoint, DebugAdapterServer, DebugAdapterExecutable } from 'vs/workbench/api/common/extHostTypes';
 import { ExecutableDebugAdapter, SocketDebugAdapter } from 'vs/workbench/contrib/debug/node/debugAdapter';
 import { AbstractDebugAdapter } from 'vs/workbench/contrib/debug/common/abstractDebugAdapter';
-import { IExtHostWorkspaceProvider } from 'vs/workbench/api/node/extHostWorkspace';
+import { IExtHostWorkspaceProvider } from 'vs/workbench/api/common/extHostWorkspace';
 import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
 import { ITerminalSettings, IDebuggerContribution, IConfig, IDebugAdapter, IDebugAdapterServer, IDebugAdapterExecutable, IAdapterDescriptor } from 'vs/workbench/contrib/debug/common/debug';
 import { getTerminalLauncher, hasChildProcesses, prepareCommand } from 'vs/workbench/contrib/debug/node/terminals';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { AbstractVariableResolverService } from 'vs/workbench/services/configurationResolver/common/variableResolver';
-import { ExtHostConfiguration, ExtHostConfigProvider } from './extHostConfiguration';
+import { ExtHostConfiguration, ExtHostConfigProvider } from '../common/extHostConfiguration';
 import { convertToVSCPaths, convertToDAPaths, isDebuggerMainContribution } from 'vs/workbench/contrib/debug/common/debugUtils';
 import { ExtHostTerminalService } from 'vs/workbench/api/node/extHostTerminalService';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { IConfigurationResolverService } from 'vs/workbench/services/configurationResolver/common/configurationResolver';
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import { IProcessEnvironment } from 'vs/base/common/platform';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 

src/vs/workbench/api/node/extHostExtensionService.ts

@@ -16,15 +16,15 @@ import * as pfs from 'vs/base/node/pfs';
 import { ILogService } from 'vs/platform/log/common/log';
 // {{SQL CARBON EDIT}} - Remove createApiFactory initializeExtensionApi, and IExtensionApiFactory imports
 //import { createApiFactory, IExtensionApiFactory, NodeModuleRequireInterceptor, VSCodeNodeModuleFactory } from 'vs/workbench/api/node/extHost.api.impl';
-import { NodeModuleRequireInterceptor, VSCodeNodeModuleFactory, KeytarNodeModuleFactory } from 'vs/workbench/api/node/extHost.api.impl';
+import { NodeModuleRequireInterceptor, KeytarNodeModuleFactory, OpenNodeModuleFactory } from 'vs/workbench/api/node/extHost.api.impl';
 import { ExtHostExtensionServiceShape, IEnvironment, IInitData, IMainContext, MainContext, MainThreadExtensionServiceShape, MainThreadTelemetryShape, MainThreadWorkspaceShape, IStaticWorkspaceData } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
-import { ActivatedExtension, EmptyExtension, ExtensionActivatedByAPI, ExtensionActivatedByEvent, ExtensionActivationReason, ExtensionActivationTimes, ExtensionActivationTimesBuilder, ExtensionsActivator, IExtensionAPI, IExtensionContext, IExtensionMemento, IExtensionModule, HostExtension } from 'vs/workbench/api/node/extHostExtensionActivator';
-import { ExtHostLogService } from 'vs/workbench/api/node/extHostLogService';
-import { ExtHostStorage } from 'vs/workbench/api/node/extHostStorage';
-import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
+import { ExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
+import { ActivatedExtension, EmptyExtension, ExtensionActivatedByAPI, ExtensionActivatedByEvent, ExtensionActivationReason, ExtensionActivationTimes, ExtensionActivationTimesBuilder, ExtensionsActivator, IExtensionAPI, IExtensionContext, IExtensionMemento, IExtensionModule, HostExtension } from 'vs/workbench/api/common/extHostExtensionActivator';
+import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
+import { ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { ExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
 import { ExtensionActivationError } from 'vs/workbench/services/extensions/common/extensions';
-import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import { connectProxyResolver } from 'vs/workbench/services/extensions/node/proxyResolver';
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import * as errors from 'vs/base/common/errors';
@@ -35,6 +35,7 @@ import { IWorkspace } from 'vs/platform/workspace/common/workspace';
 import { Schemas } from 'vs/base/common/network';
 import { withNullAsUndefined } from 'vs/base/common/types';
 import { realpath } from 'vs/base/node/extpath';
+import { VSBuffer } from 'vs/base/common/buffer';
 
 class ExtensionMemento implements IExtensionMemento {
 
@@ -165,6 +166,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	private readonly _extHostContext: IMainContext;
 	private readonly _extHostWorkspace: ExtHostWorkspace;
 	private readonly _extHostConfiguration: ExtHostConfiguration;
+	private readonly _environment: IEnvironment;
 	private readonly _extHostLogService: ExtHostLogService;
 
 	private readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
@@ -190,6 +192,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		extHostContext: IMainContext,
 		extHostWorkspace: ExtHostWorkspace,
 		extHostConfiguration: ExtHostConfiguration,
+		environment: IEnvironment,
 		extHostLogService: ExtHostLogService
 	) {
 		this._nativeExit = nativeExit;
@@ -197,6 +200,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		this._extHostContext = extHostContext;
 		this._extHostWorkspace = extHostWorkspace;
 		this._extHostConfiguration = extHostConfiguration;
+		this._environment = environment;
 		this._extHostLogService = extHostLogService;
 
 		this._mainThreadWorkspaceProxy = this._extHostContext.getProxy(MainContext.MainThreadWorkspace);
@@ -246,12 +250,18 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	private async _initialize(): Promise<void> {
 		try {
 			const configProvider = await this._extHostConfiguration.getConfigProvider();
-
+			const extensionPaths = await this.getExtensionPathIndex();
 			// {{SQL CARBON EDIT}} - disable VSCodeNodeModuleFactory and use older initializeExtensionApi
-			// const extensionPaths = await this.getExtensionPathIndex();
 			// NodeModuleRequireInterceptor.INSTANCE.register(new VSCodeNodeModuleFactory(this._extensionApiFactory, extensionPaths, this._registry, configProvider));
 			await initializeExtensionApi(this, this._extensionApiFactory, this._registry, configProvider);
-			NodeModuleRequireInterceptor.INSTANCE.register(new KeytarNodeModuleFactory(this._extHostContext.getProxy(MainContext.MainThreadKeytar)));
+			NodeModuleRequireInterceptor.INSTANCE.register(new KeytarNodeModuleFactory(this._extHostContext.getProxy(MainContext.MainThreadKeytar), this._environment));
+			if (this._initData.remoteAuthority) {
+				NodeModuleRequireInterceptor.INSTANCE.register(new OpenNodeModuleFactory(
+					this._extHostContext.getProxy(MainContext.MainThreadWindow),
+					this._extHostContext.getProxy(MainContext.MainThreadTelemetry),
+					extensionPaths
+				));
+			}
 
 			// Do this when extension service exists, but extensions are not being activated yet.
 			await connectProxyResolver(this._extHostWorkspace, configProvider, this, this._extHostLogService, this._mainThreadTelemetryProxy);
@@ -608,7 +618,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	}
 
 	private _doHandleExtensionTests(): Promise<void> {
-		const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
+		const { extensionDevelopmentLocationURI: extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
 		if (!(extensionDevelopmentLocationURI && extensionTestsLocationURI && extensionTestsLocationURI.scheme === Schemas.file)) {
 			return Promise.resolve(undefined);
 		}
@@ -759,13 +769,12 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return n;
 	}
 
-	public async $test_up(b: Buffer): Promise<number> {
-		return b.length;
+	public async $test_up(b: VSBuffer): Promise<number> {
+		return b.byteLength;
 	}
 
-	public async $test_down(size: number): Promise<Buffer> {
-		const b = Buffer.alloc(size, Math.random() % 256);
-		return b;
+	public async $test_down(size: number): Promise<VSBuffer> {
+		return VSBuffer.wrap(Buffer.alloc(size, Math.random() % 256));
 	}
 
 }

src/vs/workbench/api/node/extHostOutputService.ts

@@ -3,101 +3,16 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { MainContext, MainThreadOutputServiceShape, IMainContext, ExtHostOutputServiceShape } from '../common/extHost.protocol';
+import { MainThreadOutputServiceShape } from '../common/extHost.protocol';
 import * as vscode from 'vscode';
 import { URI } from 'vs/base/common/uri';
 import { join } from 'vs/base/common/path';
 import { OutputAppender } from 'vs/workbench/services/output/node/outputAppender';
 import { toLocalISOString } from 'vs/base/common/date';
-import { Event, Emitter } from 'vs/base/common/event';
-import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { dirExists, mkdirp } from 'vs/base/node/pfs';
+import { AbstractExtHostOutputChannel, IOutputChannelFactory, ExtHostPushOutputChannel } from 'vs/workbench/api/common/extHostOutput';
 
-abstract class AbstractExtHostOutputChannel extends Disposable implements vscode.OutputChannel {
-
-	readonly _id: Promise<string>;
-	private readonly _name: string;
-	protected readonly _proxy: MainThreadOutputServiceShape;
-	private _disposed: boolean;
-	private _offset: number;
-
-	protected readonly _onDidAppend: Emitter<void> = this._register(new Emitter<void>());
-	readonly onDidAppend: Event<void> = this._onDidAppend.event;
-
-	constructor(name: string, log: boolean, file: URI | undefined, proxy: MainThreadOutputServiceShape) {
-		super();
-
-		this._name = name;
-		this._proxy = proxy;
-		this._id = proxy.$register(this.name, log, file);
-		this._offset = 0;
-	}
-
-	get name(): string {
-		return this._name;
-	}
-
-	append(value: string): void {
-		this.validate();
-		this._offset += value ? Buffer.from(value).byteLength : 0;
-	}
-
-	update(): void {
-		this._id.then(id => this._proxy.$update(id));
-	}
-
-	appendLine(value: string): void {
-		this.validate();
-		this.append(value + '\n');
-	}
-
-	clear(): void {
-		this.validate();
-		const till = this._offset;
-		this._id.then(id => this._proxy.$clear(id, till));
-	}
-
-	show(columnOrPreserveFocus?: vscode.ViewColumn | boolean, preserveFocus?: boolean): void {
-		this.validate();
-		this._id.then(id => this._proxy.$reveal(id, !!(typeof columnOrPreserveFocus === 'boolean' ? columnOrPreserveFocus : preserveFocus)));
-	}
-
-	hide(): void {
-		this.validate();
-		this._id.then(id => this._proxy.$close(id));
-	}
-
-	protected validate(): void {
-		if (this._disposed) {
-			throw new Error('Channel has been closed');
-		}
-	}
-
-	dispose(): void {
-		super.dispose();
-
-		if (!this._disposed) {
-			this._id
-				.then(id => this._proxy.$dispose(id))
-				.then(() => this._disposed = true);
-		}
-	}
-}
-
-class ExtHostPushOutputChannel extends AbstractExtHostOutputChannel {
-
-	constructor(name: string, proxy: MainThreadOutputServiceShape) {
-		super(name, false, undefined, proxy);
-	}
-
-	append(value: string): void {
-		super.append(value);
-		this._id.then(id => this._proxy.$append(id, value));
-		this._onDidAppend.fire();
-	}
-}
-
-class ExtHostOutputChannelBackedByFile extends AbstractExtHostOutputChannel {
+export class ExtHostOutputChannelBackedByFile extends AbstractExtHostOutputChannel {
 
 	private _appender: OutputAppender;
 
@@ -128,95 +43,23 @@ class ExtHostOutputChannelBackedByFile extends AbstractExtHostOutputChannel {
 	}
 }
 
-class ExtHostLogFileOutputChannel extends AbstractExtHostOutputChannel {
+export const LogOutputChannelFactory = new class implements IOutputChannelFactory {
 
-	constructor(name: string, file: URI, proxy: MainThreadOutputServiceShape) {
-		super(name, true, file, proxy);
-	}
+	_namePool = 1;
 
-	append(value: string): void {
-		throw new Error('Not supported');
-	}
-}
-
-let namePool = 1;
-async function createExtHostOutputChannel(name: string, outputDirPromise: Promise<string>, proxy: MainThreadOutputServiceShape): Promise<AbstractExtHostOutputChannel> {
-	try {
-		const outputDir = await outputDirPromise;
-		const fileName = `${namePool++}-${name}`;
-		const file = URI.file(join(outputDir, `${fileName}.log`));
-		const appender = new OutputAppender(fileName, file.fsPath);
-		return new ExtHostOutputChannelBackedByFile(name, appender, proxy);
-	} catch (error) {
-		// Do not crash if logger cannot be created
-		console.log(error);
-		return new ExtHostPushOutputChannel(name, proxy);
-	}
-}
-
-export class ExtHostOutputService implements ExtHostOutputServiceShape {
-
-	private readonly _outputDir: Promise<string>;
-	private _proxy: MainThreadOutputServiceShape;
-	private _channels: Map<string, AbstractExtHostOutputChannel> = new Map<string, AbstractExtHostOutputChannel>();
-	private _visibleChannelDisposable: IDisposable;
-
-	constructor(logsLocation: URI, mainContext: IMainContext) {
-		const outputDirPath = join(logsLocation.fsPath, `output_logging_${toLocalISOString(new Date()).replace(/-|:|\.\d+Z$/g, '')}`);
-		this._outputDir = dirExists(outputDirPath).then(exists => exists ? exists : mkdirp(outputDirPath).then(() => true)).then(() => outputDirPath);
-		this._proxy = mainContext.getProxy(MainContext.MainThreadOutputService);
-	}
-
-	$setVisibleChannel(channelId: string): void {
-		if (this._visibleChannelDisposable) {
-			this._visibleChannelDisposable = dispose(this._visibleChannelDisposable);
-		}
-		if (channelId) {
-			const channel = this._channels.get(channelId);
-			if (channel) {
-				this._visibleChannelDisposable = channel.onDidAppend(() => channel.update());
-			}
+	async createOutputChannel(name: string, logsLocation: URI, proxy: MainThreadOutputServiceShape): Promise<AbstractExtHostOutputChannel> {
+		try {
+			const outputDirPath = join(logsLocation.fsPath, `output_logging_${toLocalISOString(new Date()).replace(/-|:|\.\d+Z$/g, '')}`);
+			const outputDir = await dirExists(outputDirPath).then(exists => exists ? exists : mkdirp(outputDirPath).then(() => true)).then(() => outputDirPath);
+			const fileName = `${this._namePool++}-${name}`;
+			const file = URI.file(join(outputDir, `${fileName}.log`));
+			const appender = new OutputAppender(fileName, file.fsPath);
+			return new ExtHostOutputChannelBackedByFile(name, appender, proxy);
+		} catch (error) {
+			// Do not crash if logger cannot be created
+			console.log(error);
+			return new ExtHostPushOutputChannel(name, proxy);
 		}
 	}
+};
 
-	createOutputChannel(name: string): vscode.OutputChannel {
-		name = name.trim();
-		if (!name) {
-			throw new Error('illegal argument `name`. must not be falsy');
-		} else {
-			const extHostOutputChannel = createExtHostOutputChannel(name, this._outputDir, this._proxy);
-			extHostOutputChannel.then(channel => channel._id.then(id => this._channels.set(id, channel)));
-			return <vscode.OutputChannel>{
-				append(value: string): void {
-					extHostOutputChannel.then(channel => channel.append(value));
-				},
-				appendLine(value: string): void {
-					extHostOutputChannel.then(channel => channel.appendLine(value));
-				},
-				clear(): void {
-					extHostOutputChannel.then(channel => channel.clear());
-				},
-				show(columnOrPreserveFocus?: vscode.ViewColumn | boolean, preserveFocus?: boolean): void {
-					extHostOutputChannel.then(channel => channel.show(columnOrPreserveFocus, preserveFocus));
-				},
-				hide(): void {
-					extHostOutputChannel.then(channel => channel.hide());
-				},
-				dispose(): void {
-					extHostOutputChannel.then(channel => channel.dispose());
-				}
-			};
-		}
-	}
-
-	createOutputChannelFromLogFile(name: string, file: URI): vscode.OutputChannel {
-		name = name.trim();
-		if (!name) {
-			throw new Error('illegal argument `name`. must not be falsy');
-		}
-		if (!file) {
-			throw new Error('illegal argument `file`. must not be falsy');
-		}
-		return new ExtHostLogFileOutputChannel(name, file, this._proxy);
-	}
-}

src/vs/workbench/api/node/extHostTask.ts

@@ -14,8 +14,8 @@ import { win32 } from 'vs/base/node/processes';
 
 import { MainContext, MainThreadTaskShape, ExtHostTaskShape, IMainContext } from 'vs/workbench/api/common/extHost.protocol';
 
-import * as types from 'vs/workbench/api/node/extHostTypes';
-import { ExtHostWorkspace, IExtHostWorkspaceProvider } from 'vs/workbench/api/node/extHostWorkspace';
+import * as types from 'vs/workbench/api/common/extHostTypes';
+import { ExtHostWorkspace, IExtHostWorkspaceProvider } from 'vs/workbench/api/common/extHostWorkspace';
 import * as vscode from 'vscode';
 import {
 	TaskDefinitionDTO, TaskExecutionDTO, TaskPresentationOptionsDTO,
@@ -26,8 +26,8 @@ import {
 } from '../common/shared/tasks';
 // {{SQL CARBON EDIT}}
 // import { ExtHostVariableResolverService } from 'vs/workbench/api/node/extHostDebugService';
-import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
-import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { ExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
 import { ExtHostTerminalService, ExtHostTerminal } from 'vs/workbench/api/node/extHostTerminalService';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';

src/vs/workbench/api/node/extHostTerminalService.ts

@@ -11,7 +11,7 @@ import * as platform from 'vs/base/common/platform';
 import * as terminalEnvironment from 'vs/workbench/contrib/terminal/common/terminalEnvironment';
 import { Event, Emitter } from 'vs/base/common/event';
 import { ExtHostTerminalServiceShape, MainContext, MainThreadTerminalServiceShape, IMainContext, ShellLaunchConfigDto } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
+import { ExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
 import { ILogService } from 'vs/platform/log/common/log';
 import { EXT_HOST_CREATION_DELAY, IShellLaunchConfig } from 'vs/workbench/contrib/terminal/common/terminal';
 import { TerminalProcess } from 'vs/workbench/contrib/terminal/node/terminalProcess';