Add VSCODE_PROXY_URI to extension environment

This allows extensions to open windows to local ports via the proxy.

Closes #1510.

Author: code-asher

lib/vscode/src/vs/server/entry.ts

@@ -70,7 +70,7 @@ process.on('message', async (message: CodeServerMessage, socket) => {
 			}
 			break;
 		case 'socket':
-			vscode.handleWebSocket(socket, message.query, message.permessageDeflate);
+			vscode.handleWebSocket(socket, message.query, message.options);
 			break;
 	}
 });

lib/vscode/src/vs/server/node/connection.ts

@@ -114,6 +114,7 @@ export class ExtensionHostConnection extends Connection {
 		protocol: Protocol,
 		private readonly params: IRemoteExtensionHostStartParams,
 		private readonly environment: INativeEnvironmentService,
+		private readonly proxyUri: string
 	) {
 		super(protocol, 'exthost');
 
@@ -183,6 +184,7 @@ export class ExtensionHostConnection extends Connection {
 					VSCODE_LOG_LEVEL: process.env.LOG_LEVEL,
 					VSCODE_NLS_CONFIG: JSON.stringify(config),
 					VSCODE_PARENT_PID: String(process.pid),
+					VSCODE_PROXY_URI: this.proxyUri,
 				},
 				silent: true,
 			},

lib/vscode/src/vs/server/node/server.ts

@@ -9,7 +9,7 @@ import { getMachineId } from 'vs/base/node/id';
 import { ClientConnectionEvent, IPCServer, IServerChannel, ProxyChannel } from 'vs/base/parts/ipc/common/ipc';
 import { LogsDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/logsDataCleaner';
 import { main } from 'vs/code/node/cliProcessMain';
-import { Query, VscodeOptions, WorkbenchOptions } from 'vs/ipc';
+import { Query, SocketOptions, VscodeOptions, WorkbenchOptions } from 'vs/ipc';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ConfigurationService } from 'vs/platform/configuration/common/configurationService';
 import { ExtensionHostDebugBroadcastChannel } from 'vs/platform/debug/common/extensionHostDebugIpc';
@@ -46,6 +46,7 @@ import { TelemetryLogAppender } from 'vs/platform/telemetry/common/telemetryLogA
 import { TelemetryService } from 'vs/platform/telemetry/common/telemetryService';
 import { combinedAppender, NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
 import { AppInsightsAppender } from 'vs/platform/telemetry/node/appInsightsAppender';
+import { PtyHostService } from 'vs/platform/terminal/node/ptyHostService';
 import { TelemetryChannel } from 'vs/server/common/telemetry';
 import { ExtensionEnvironmentChannel, FileProviderChannel, TerminalProviderChannel } from 'vs/server/node/channel';
 import { Connection, ExtensionHostConnection, ManagementConnection } from 'vs/server/node/connection';
@@ -57,7 +58,6 @@ import { getUriTransformer } from 'vs/server/node/util';
 import { REMOTE_TERMINAL_CHANNEL_NAME } from 'vs/workbench/contrib/terminal/common/remoteTerminalChannel';
 import { REMOTE_FILE_SYSTEM_CHANNEL_NAME } from 'vs/workbench/services/remote/common/remoteAgentFileSystemChannel';
 import { RemoteExtensionLogFileName } from 'vs/workbench/services/remote/common/remoteAgentService';
-import { PtyHostService } from 'vs/platform/terminal/node/ptyHostService';
 
 const commit = product.commit || 'development';
 
@@ -79,7 +79,7 @@ export class Vscode {
 	public async initialize(options: VscodeOptions): Promise<WorkbenchOptions> {
 		const transformer = getUriTransformer(options.remoteAuthority);
 		if (!this.servicesPromise) {
-			this.servicesPromise = this.initializeServices(options.args);
+			this.servicesPromise = this.initializeServices(options);
 		}
 		await this.servicesPromise;
 		const environment = this.services.get(IEnvironmentService) as INativeEnvironmentService;
@@ -116,25 +116,25 @@ export class Vscode {
 		};
 	}
 
-	public async handleWebSocket(socket: net.Socket, query: Query, permessageDeflate: boolean): Promise<true> {
+	public async handleWebSocket(socket: net.Socket, query: Query, options: SocketOptions): Promise<true> {
 		if (!query.reconnectionToken) {
 			throw new Error('Reconnection token is missing from query parameters');
 		}
 		const protocol = new Protocol(socket, {
 			reconnectionToken: <string>query.reconnectionToken,
 			reconnection: query.reconnection === 'true',
 			skipWebSocketFrames: query.skipWebSocketFrames === 'true',
-			permessageDeflate,
+			permessageDeflate: options.permessageDeflate,
 		});
 		try {
-			await this.connect(await protocol.handshake(), protocol);
+			await this.connect(await protocol.handshake(), protocol, options.proxyUri);
 		} catch (error) {
 			protocol.destroy(error.message);
 		}
 		return true;
 	}
 
-	private async connect(message: ConnectionTypeRequest, protocol: Protocol): Promise<void> {
+	private async connect(message: ConnectionTypeRequest, protocol: Protocol, proxyUri: string): Promise<void> {
 		if (product.commit && message.commit !== product.commit) {
 			logger.warn(`Version mismatch (${message.commit} instead of ${product.commit})`);
 		}
@@ -185,6 +185,7 @@ export class Vscode {
 							...message.args,
 						},
 						this.services.get(IEnvironmentService) as INativeEnvironmentService,
+						proxyUri,
 					);
 				}
 				connections.set(token, connection);
@@ -211,9 +212,9 @@ export class Vscode {
 	// References:
 	// ../../electron-browser/sharedProcess/sharedProcessMain.ts#L148
 	// ../../../code/electron-main/app.ts
-	private async initializeServices(args: NativeParsedArgs): Promise<void> {
+	private async initializeServices(options: VscodeOptions): Promise<void> {
 		const productService = { _serviceBrand: undefined, ...product };
-		const environmentService = new NativeEnvironmentService(args, productService);
+		const environmentService = new NativeEnvironmentService(options.args, productService);
 
 		await Promise.all([
 			environmentService.extensionsPath,

src/node/routes/vscode.ts

@@ -227,5 +227,14 @@ wsRouter.ws("/", ensureAuthenticated, async (req) => {
 
   req.ws.write(responseHeaders.join("\r\n") + "\r\n\r\n")
 
-  await vscode.sendWebsocket(req.ws, req.query, useCompression)
+  await vscode.sendWebsocket(req.ws, req.query, {
+    permessageDeflate: useCompression,
+    // NOTE: Was going to use a domain proxy if one was set but maybe it makes
+    // sense to just use the path proxy for now unless it presents problems.
+    // TODO: We won't have the base path if code-server is being served behind a
+    // proxy that is rewriting the path. We will need to send the full path from
+    // the client when making this connection (possibly as a query param like
+    // the token, etc).
+    proxyUri: `${req.headers.host || ""}/proxy/{port}`,
+  })
 })

src/node/vscode.ts

@@ -120,12 +120,12 @@ export class VscodeProvider {
   /**
    * VS Code expects a raw socket. It will handle all the web socket frames.
    */
-  public async sendWebsocket(socket: net.Socket, query: ipc.Query, permessageDeflate: boolean): Promise<void> {
+  public async sendWebsocket(socket: net.Socket, query: ipc.Query, options: ipc.SocketOptions): Promise<void> {
     const vscode = await this._vscode
     // TLS sockets cannot be transferred to child processes so we need an
     // in-between. Non-TLS sockets will be returned as-is.
     const socketProxy = await this.socketProvider.createProxy(socket)
-    this.send({ type: "socket", query, permessageDeflate }, vscode, socketProxy)
+    this.send({ type: "socket", query, options }, vscode, socketProxy)
   }
 
   private send(message: ipc.CodeServerMessage, vscode?: cp.ChildProcess, socket?: net.Socket): void {

typings/ipc.d.ts

@@ -22,10 +22,15 @@ export interface InitMessage {
 
 export type Query = { [key: string]: string | string[] | undefined | Query | Query[] }
 
+export interface SocketOptions {
+  permessageDeflate: boolean
+  proxyUri: string
+}
+
 export interface SocketMessage {
   type: "socket"
   query: Query
-  permessageDeflate: boolean
+  options: SocketOptions
 }
 
 export interface CliMessage {