Add proxy template paths.

cc @code-asher

Author: GirlBossRush

src/vs/base/common/product.ts

@@ -36,6 +36,7 @@ export interface IProductConfiguration {
 	readonly codeServerVersion?: string;
 	readonly authed?: boolean;
 	readonly logoutEndpointUrl: string;
+	readonly proxyEndpointUrlTemplate?: string;
 	readonly serviceWorker?: {
 		readonly url: string;
 		readonly scope: string;

src/vs/platform/remote/browser/remoteAuthorityResolverService.ts

@@ -7,7 +7,7 @@ import { Emitter } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { RemoteAuthorities } from 'vs/base/common/network';
 import { URI } from 'vs/base/common/uri';
-import { IRemoteAuthorityResolverService, IRemoteConnectionData, ResolvedAuthority, ResolverResult } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { IRemoteAuthorityResolverService, IRemoteConnectionData, ResolvedAuthority, ResolvedOptions, ResolverResult } from 'vs/platform/remote/common/remoteAuthorityResolver';
 
 export class RemoteAuthorityResolverService extends Disposable implements IRemoteAuthorityResolverService {
 
@@ -20,7 +20,11 @@ export class RemoteAuthorityResolverService extends Disposable implements IRemot
 	private readonly _connectionToken: string | undefined;
 	private readonly _connectionTokens: Map<string, string>;
 
-	constructor(connectionToken: string | undefined, resourceUriProvider: ((uri: URI) => URI) | undefined) {
+	constructor(
+		connectionToken: string | undefined,
+		resourceUriProvider: ((uri: URI) => URI) | undefined,
+		/** @coder */
+		private readonly proxyEndpointUrlTemplate?: string,) {
 		super();
 		this._cache = new Map<string, ResolverResult>();
 		this._connectionToken = connectionToken;
@@ -59,11 +63,34 @@ export class RemoteAuthorityResolverService extends Disposable implements IRemot
 
 	private _doResolveAuthority(authority: string): ResolverResult {
 		const connectionToken = this._connectionTokens.get(authority) || this._connectionToken;
+		let host = authority;
+		let port = 80;
+		let options: ResolvedOptions | undefined;
+
 		if (authority.indexOf(':') >= 0) {
 			const pieces = authority.split(':');
-			return { authority: { authority, host: pieces[0], port: parseInt(pieces[1], 10), connectionToken } };
+			host = pieces[0];
+			port = parseInt(pieces[1], 10);
+		}
+
+		/** @coder */
+		if (this.proxyEndpointUrlTemplate) {
+			options = {
+				extensionHostEnv: {
+					VSCODE_PROXY_URI: this.proxyEndpointUrlTemplate,
+				},
+			};
 		}
-		return { authority: { authority, host: authority, port: 80, connectionToken } };
+
+		return {
+			authority: {
+				authority,
+				host,
+				port,
+				connectionToken,
+			},
+			options,
+		};
 	}
 
 	_clearResolvedAuthority(authority: string): void {

src/vs/server/services/environmentService.ts

@@ -109,6 +109,10 @@ export class EnvironmentServerService extends NativeEnvironmentService implement
 					sizes: '512x512',
 				},
 			],
+
+			// Proxy
+			/** The URL constructor should be decoded here to retain the port template variable. */
+			proxyEndpointUrlTemplate: decodeURI(this.createRequestUrl(req, AssetPaths.ProxyUri).toString()),
 		};
 
 		if (!this.configuration.disableUpdateCheck) {

src/vs/server/services/net/abstractIncomingRequestService.ts

@@ -5,11 +5,11 @@
 
 import * as http from 'http';
 import * as net from 'net';
-import * as path from 'path';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IEnvironmentServerService } from 'vs/server/services/environmentService';
+import { getPathPrefix } from 'vs/server/services/net/common/http';
 
 export interface ParsedRequest extends http.IncomingMessage {
 	parsedUrl: URL;
@@ -40,7 +40,7 @@ export abstract class AbstractIncomingRequestService<E extends NetEventListener>
 
 		Object.assign(req, {
 			parsedUrl,
-			pathPrefix: path.join(path.dirname(parsedUrl.pathname), '/'),
+			pathPrefix: getPathPrefix(parsedUrl.pathname),
 		});
 
 		this.eventListener(req as ParsedRequest, ...args);

src/vs/server/services/net/common/http.ts

@@ -6,22 +6,23 @@
 import { randomBytes } from 'crypto';
 import { readFileSync } from 'fs';
 import { ServerResponse } from 'http';
-import { join } from 'path';
+import * as path from 'path';
 import { MatchResult } from 'path-to-regexp';
 import { UriComponents } from 'vs/base/common/uri';
 import { ParsedRequest } from 'vs/server/services/net/abstractIncomingRequestService';
 import * as Handlebars from 'handlebars';
 import { IWorkbenchConfigurationSerialized } from 'vs/platform/workspaces/common/workbench';
 
-export const APP_ROOT = join(__dirname, '..', '..', '..', '..', '..', '..');
-export const WORKBENCH_PATH = join(APP_ROOT, 'out', 'vs', 'code', 'browser', 'workbench');
+export const APP_ROOT = path.join(__dirname, '..', '..', '..', '..', '..', '..');
+export const WORKBENCH_PATH = path.join(APP_ROOT, 'out', 'vs', 'code', 'browser', 'workbench');
 export const SERVICE_WORKER_FILE_NAME = 'service-worker.js';
 
 export const AssetPaths = {
 	StaticBase: '/static',
-	Webview: join(APP_ROOT, 'out', 'vs', 'workbench', 'contrib', 'webview', 'browser', 'pre'),
-	Favicon: join(APP_ROOT, 'resources', 'web', 'favicon.ico'),
-	ServiceWorker: join(APP_ROOT, 'out', 'vs', 'code', 'browser', 'workbench', SERVICE_WORKER_FILE_NAME),
+	ProxyUri: '/proxy/{port}',
+	Webview: path.join(APP_ROOT, 'out', 'vs', 'workbench', 'contrib', 'webview', 'browser', 'pre'),
+	Favicon: path.join(APP_ROOT, 'resources', 'web', 'favicon.ico'),
+	ServiceWorker: path.join(APP_ROOT, 'out', 'vs', 'code', 'browser', 'workbench', SERVICE_WORKER_FILE_NAME),
 };
 
 /** Matching the given keys in `PollingURLCallbackProvider.QUERY_KEYS` */
@@ -142,3 +143,18 @@ export interface ClientTheme {
 	backgroundColor: string;
 	foregroundColor: string;
 }
+
+/**
+ * Returns the relative path prefix for a given URL path.
+ * @remark This is especially useful when creating URLs which have to remain
+ * relative to an initial request.
+ *
+ * @example
+ * ```ts
+ * const url = new URL('https://www.example.com/foo/bar/baz.js')
+ * getPathPrefix(url.pathname) // '/foo/bar/'
+ * ```
+ */
+export function getPathPrefix(pathname: string) {
+	return path.join(path.dirname(pathname), '/');
+}

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

@@ -66,7 +66,6 @@ import { HTMLFileSystemProvider } from 'vs/platform/files/browser/htmlFileSystem
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { safeStringify } from 'vs/base/common/objects';
 import { CodeServerClientAdditions } from './client';
-import { isWeb } from 'vs/base/common/platform';
 
 class BrowserMain extends Disposable {
 
@@ -100,17 +99,14 @@ class BrowserMain extends Disposable {
 		const instantiationService = workbench.startup();
 
 
-		if (isWeb) {
-			/** @coder Initialize our own client-side additions. */
-			if (!this.configuration.productConfiguration) {
-				throw new Error('`productConfiguration` not present in workbench config');
-			}
-
-			const codeServerClientAdditions = this._register(instantiationService.createInstance(CodeServerClientAdditions, this.configuration.productConfiguration));
-
-			await codeServerClientAdditions.startup();
+		/** @coder Initialize our own client-side additions. */
+		if (!this.configuration.productConfiguration) {
+			throw new Error('`productConfiguration` not present in workbench config');
 		}
 
+		const codeServerClientAdditions = this._register(instantiationService.createInstance(CodeServerClientAdditions, this.configuration.productConfiguration));
+
+		await codeServerClientAdditions.startup();
 
 		// Window
 		this._register(instantiationService.createInstance(BrowserWindow));
@@ -183,7 +179,12 @@ class BrowserMain extends Disposable {
 
 		// Remote
 		const connectionToken = environmentService.options.connectionToken || getCookieValue('vscode-tkn');
-		const remoteAuthorityResolverService = new RemoteAuthorityResolverService(connectionToken, this.configuration.resourceUriProvider);
+		const remoteAuthorityResolverService = new RemoteAuthorityResolverService(
+			connectionToken,
+			this.configuration.resourceUriProvider,
+			/** @coder */
+			this.configuration.productConfiguration?.proxyEndpointUrlTemplate,
+		);
 		serviceCollection.set(IRemoteAuthorityResolverService, remoteAuthorityResolverService);
 
 		// Signing