Add support for running extensions in the browser

Author: code-asher

main.js

@@ -4,4 +4,4 @@
 // while still allowing us to access files within the binary.
 process.env.NBIN_BYPASS = true;
 
-require("../../bootstrap-amd").load("vs/server/src/cli");
+require("../../bootstrap-amd").load("vs/server/src/node/cli");

package.json

@@ -27,10 +27,13 @@
   },
   "dependencies": {
     "@coder/logger": "^1.1.8",
+    "@coder/node-browser": "^1.0.0",
+    "@coder/requirefs": "^1.0.3",
     "httpolyglot": "^0.1.2",
     "pem": "^1.14.2",
     "safe-compare": "^1.1.4",
     "tar-fs": "^2.0.0",
-    "tar-stream": "^2.1.0"
+    "tar-stream": "^2.1.0",
+    "util": "^0.12.1"
   }
 }

scripts/build-json.js

@@ -45,8 +45,8 @@ const writeProduct = () => {
 		"vs/workbench/workbench.web.api.css",
 		"vs/code/browser/workbench/workbench.html",
 		"vs/code/browser/workbench/workbench.js",
-		"vs/server/src/cli.js",
-		"vs/server/src/uriTransformer.js",
+		"vs/server/src/node/cli.js",
+		"vs/server/src/node/uriTransformer.js",
 		"vs/server/src/login/index.html"
 	]);
 	const date = new Date().toISOString();

scripts/vscode.patch

@@ -1,5 +1,5 @@
 import * as vscode from "vscode";
-import { CoderApi, VSCodeApi } from "../typings/api";
+import { CoderApi, VSCodeApi } from "../../typings/api";
 import { createCSSRule } from "vs/base/browser/dom";
 import { Emitter, Event } from "vs/base/common/event";
 import { IDisposable } from "vs/base/common/lifecycle";

src/api.ts src/browser/api.tssrc/api.ts renamed to src/browser/api.ts

@@ -1,13 +1,18 @@
+import { Emitter } from "vs/base/common/event";
 import { URI } from "vs/base/common/uri";
 import { registerSingleton } from "vs/platform/instantiation/common/extensions";
 import { ServiceCollection } from "vs/platform/instantiation/common/serviceCollection";
-import { ITelemetryService } from "vs/platform/telemetry/common/telemetry";
 import { ILocalizationsService } from "vs/platform/localizations/common/localizations";
 import { LocalizationsService } from "vs/platform/localizations/electron-browser/localizationsService";
+import { ITelemetryService } from "vs/platform/telemetry/common/telemetry";
 import { IUpdateService } from "vs/platform/update/common/update";
 import { UpdateService } from "vs/platform/update/electron-browser/updateService";
-import { TelemetryChannelClient } from "vs/server/src/telemetry";
-import { IUploadService, UploadService } from 'vs/server/src/upload';
+import { coderApi, vscodeApi } from "vs/server/src/browser/api";
+import { IUploadService, UploadService } from "vs/server/src/browser/upload";
+import { INodeProxyService, NodeProxyChannelClient } from "vs/server/src/common/nodeProxy";
+import { TelemetryChannelClient } from "vs/server/src/common/telemetry";
+import "vs/workbench/contrib/localizations/browser/localizations.contribution";
+import "vs/workbench/contrib/update/electron-browser/update.contribution";
 import { IRemoteAgentService } from "vs/workbench/services/remote/common/remoteAgentService";
 
 class TelemetryService extends TelemetryChannelClient {
@@ -18,16 +23,28 @@ class TelemetryService extends TelemetryChannelClient {
 	}
 }
 
+class NodeProxyService extends NodeProxyChannelClient implements INodeProxyService {
+	private readonly _onClose = new Emitter<void>();
+	public readonly onClose = this._onClose.event;
+	private readonly _onDown = new Emitter<void>();
+	public readonly onDown = this._onDown.event;
+	private readonly _onUp = new Emitter<void>();
+	public readonly onUp = this._onUp.event;
+
+	public constructor(
+		@IRemoteAgentService remoteAgentService: IRemoteAgentService,
+	) {
+		// TODO: up/down/close
+		super(remoteAgentService.getConnection()!.getChannel("nodeProxy"));
+	}
+}
+
 registerSingleton(ILocalizationsService, LocalizationsService);
+registerSingleton(INodeProxyService, NodeProxyService);
 registerSingleton(ITelemetryService, TelemetryService);
 registerSingleton(IUpdateService, UpdateService);
 registerSingleton(IUploadService, UploadService, true);
 
-import "vs/workbench/contrib/update/electron-browser/update.contribution";
-import 'vs/workbench/contrib/localizations/browser/localizations.contribution';
-
-import { coderApi, vscodeApi } from "vs/server/src/api";
-
 /**
  * This is called by vs/workbench/browser/web.main.ts after the workbench has
  * been initialized so we can initialize our own client-side code.

src/client.ts src/browser/client.tssrc/client.ts renamed to src/browser/client.ts

@@ -0,0 +1,46 @@
+import { Emitter } from "vs/base/common/event";
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ExtHostNodeProxyShape, MainContext, MainThreadNodeProxyShape } from "vs/workbench/api/common/extHost.protocol";
+import { IExtHostRpcService } from "vs/workbench/api/common/extHostRpcService";
+
+export class ExtHostNodeProxy implements ExtHostNodeProxyShape {
+	_serviceBrand: any;
+
+	private readonly _onMessage = new Emitter<string>();
+	public readonly onMessage = this._onMessage.event;
+	private readonly _onClose = new Emitter<void>();
+	public readonly onClose = this._onClose.event;
+	private readonly _onDown = new Emitter<void>();
+	public readonly onDown = this._onDown.event;
+	private readonly _onUp = new Emitter<void>();
+	public readonly onUp = this._onUp.event;
+
+	private readonly proxy: MainThreadNodeProxyShape;
+
+	constructor(@IExtHostRpcService rpc: IExtHostRpcService) {
+		this.proxy = rpc.getProxy(MainContext.MainThreadNodeProxy);
+	}
+
+	public $onMessage(message: string): void {
+		this._onMessage.fire(message);
+	}
+
+	public $onClose(): void {
+		this._onClose.fire();
+	}
+
+	public $onUp(): void {
+		this._onUp.fire();
+	}
+
+	public $onDown(): void {
+		this._onDown.fire();
+	}
+
+	public send(message: string): void {
+		this.proxy.$send(message);
+	}
+}
+
+export interface IExtHostNodeProxy extends ExtHostNodeProxy { }
+export const IExtHostNodeProxy = createDecorator<IExtHostNodeProxy>('IExtHostNodeProxy');

src/browser/extHostNodeProxy.ts

@@ -0,0 +1,37 @@
+import { IDisposable } from "vs/base/common/lifecycle";
+import { INodeProxyService } from "vs/server/src/common/nodeProxy";
+import { ExtHostContext, IExtHostContext, MainContext, MainThreadNodeProxyShape } from "vs/workbench/api/common/extHost.protocol";
+import { extHostNamedCustomer } from "vs/workbench/api/common/extHostCustomers";
+
+@extHostNamedCustomer(MainContext.MainThreadNodeProxy)
+export class MainThreadNodeProxy implements MainThreadNodeProxyShape {
+	private disposed = false;
+	private disposables = <IDisposable[]>[];
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@INodeProxyService private readonly proxyService: INodeProxyService,
+	) {
+		if (!extHostContext.remoteAuthority) { // HACK: A terrible way to detect if running in the worker.
+			const proxy = extHostContext.getProxy(ExtHostContext.ExtHostNodeProxy);
+			this.disposables = [
+				this.proxyService.onMessage((message: string) => proxy.$onMessage(message)),
+				this.proxyService.onClose(() => proxy.$onClose()),
+				this.proxyService.onDown(() => proxy.$onDown()),
+				this.proxyService.onUp(() => proxy.$onUp()),
+			];
+		}
+	}
+
+	$send(message: string): void {
+		if (!this.disposed) {
+			this.proxyService.send(message);
+		}
+	}
+
+	dispose(): void {
+		this.disposables.forEach((d) => d.dispose());
+		this.disposables = [];
+		this.disposed = true;
+	}
+}

src/browser/mainThreadNodeProxy.ts

@@ -0,0 +1,47 @@
+import { Event } from "vs/base/common/event";
+import { IChannel, IServerChannel } from "vs/base/parts/ipc/common/ipc";
+import { createDecorator } from "vs/platform/instantiation/common/instantiation";
+import { ReadWriteConnection } from "vs/server/node_modules/@coder/node-browser/out/common/connection";
+
+export const INodeProxyService = createDecorator<INodeProxyService>("nodeProxyService");
+
+export interface INodeProxyService extends ReadWriteConnection {
+	_serviceBrand: any;
+	send(message: string): void;
+	onMessage: Event<string>;
+	onUp: Event<void>;
+	onClose: Event<void>;
+	onDown: Event<void>;
+}
+
+export class NodeProxyChannel implements IServerChannel {
+	constructor(private service: INodeProxyService) {}
+
+	listen(_: unknown, event: string): Event<any> {
+		switch (event) {
+			case "onMessage": return this.service.onMessage;
+		}
+		throw new Error(`Invalid listen ${event}`);
+	}
+
+	async call(_: unknown, command: string, args?: any): Promise<any> {
+		switch (command) {
+			case "send": return this.service.send(args[0]);
+		}
+		throw new Error(`Invalid call ${command}`);
+	}
+}
+
+export class NodeProxyChannelClient {
+	_serviceBrand: any;
+
+	public readonly onMessage: Event<string>;
+
+	constructor(private readonly channel: IChannel) {
+		this.onMessage = this.channel.listen<string>("onMessage");
+	}
+
+	public send(data: string): void {
+		this.channel.call("send", [data]);
+	}
+}