Update to 1.39.2

Also too the opportunity to rewrite the build script since there was a
change in the build steps (mainly how the product JSON is inserted) and
to get the build changes out of the patch. It also no longer relies on
external caching (we'll want to do this within CI instead).

.gitignore

 node_modules
 build
 release
+binaries

.travis.yml

@@ -6,7 +6,7 @@ services:
 
 before_install:
   - export MAJOR_VERSION="2"
-  - export VSCODE_VERSION="1.38.1"
+  - export VSCODE_VERSION="1.39.2"
   - export VERSION="$MAJOR_VERSION.$TRAVIS_BUILD_NUMBER"
   - export TAG="$VERSION-vsc$VSCODE_VERSION"
   - if [[ "$TRAVIS_BRANCH" == "master" ]]; then export MINIFY="true"; fi

package.json

 {
   "license": "MIT",
   "scripts": {
-    "ensure-in-vscode": "bash ./scripts/tasks.bash ensure-in-vscode",
-    "preinstall": "yarn ensure-in-vscode && cd ../../../ && yarn || true",
+    "runner": "cd ./scripts && node --max-old-space-size=32384 -r ts-node/register ./build.ts",
+    "preinstall": "yarn runner ensure-in-vscode && cd ../../../ && yarn || true",
     "postinstall": "rm -rf node_modules/@types/node",
-    "start": "yarn ensure-in-vscode && nodemon --watch ../../../out --verbose ../../../out/vs/server/main.js",
-    "watch": "yarn ensure-in-vscode && cd ../../../ && yarn watch",
-    "build": "bash ./scripts/tasks.bash build",
-    "package": "bash ./scripts/tasks.bash package",
-    "package-prebuilt": "bash ./scripts/tasks.bash package-prebuilt",
-    "binary": "bash ./scripts/tasks.bash binary",
-    "patch:generate": "yarn ensure-in-vscode && cd ../../../ && git diff --staged > ./src/vs/server/scripts/vscode.patch",
-    "patch:apply": "yarn ensure-in-vscode && cd ../../../ && git apply ./src/vs/server/scripts/vscode.patch"
+    "start": "yarn runner ensure-in-vscode && nodemon --watch ../../../out --verbose ../../../out/vs/server/main.js",
+    "watch": "yarn runner ensure-in-vscode && cd ../../../ && yarn watch",
+    "build": "yarn runner build",
+    "package": "yarn runner package",
+    "binary": "yarn runner binary",
+    "patch:generate": "yarn runner ensure-in-vscode && cd ../../../ && git diff --staged > ./src/vs/server/scripts/vscode.patch",
+    "patch:apply": "yarn runner ensure-in-vscode && cd ../../../ && git apply ./src/vs/server/scripts/vscode.patch"
   },
   "devDependencies": {
     "@coder/nbin": "^1.2.2",
+    "@types/fs-extra": "^8.0.1",
     "@types/pem": "^1.9.5",
     "@types/safe-compare": "^1.1.0",
     "@types/tar-fs": "^1.16.1",
     "@types/tar-stream": "^1.6.1",
-    "nodemon": "^1.19.1"
+    "fs-extra": "^8.1.0",
+    "nodemon": "^1.19.1",
+    "ts-node": "^8.4.1"
   },
   "resolutions": {
     "@types/node": "^10.12.12",
@@ -27,7 +29,7 @@
   },
   "dependencies": {
     "@coder/logger": "^1.1.8",
-    "@coder/node-browser": "^1.0.5",
+    "@coder/node-browser": "^1.0.6",
     "@coder/requirefs": "^1.0.6",
     "httpolyglot": "^0.1.2",
     "pem": "^1.14.2",

scripts/build-json.js

-// This builds the package and product JSON files for the final build.
-const crypto = require("crypto");
-const fs = require("fs");
-const path = require("path");
-const rootPath = path.resolve(__dirname, "..");
-const sourcePath = process.argv[2];
-const buildPath = process.argv[3];
-const vscodeVersion = process.argv[4];
-const codeServerVersion = process.argv[5];
-const util = require(path.join(sourcePath, "build/lib/util"));
-
-function computeChecksum(filename) {
-	return crypto.createHash("md5").update(fs.readFileSync(filename))
-		.digest("base64").replace(/=+$/, "");
-}
-
-const computeChecksums = (filenames) => {
-	const result = {};
-	filenames.forEach(function (filename) {
-		result[filename] = computeChecksum(path.join(buildPath, "out", filename));
-	});
-	return result;
-};
-
-const mergeAndWrite = (name, json = {}) => {
-	const aJson = JSON.parse(fs.readFileSync(path.join(sourcePath, `${name}.json`)));
-	const bJson = JSON.parse(fs.readFileSync(path.join(rootPath, "scripts", `${name}.json`)));
-
-	delete aJson.scripts;
-	delete aJson.dependencies;
-	delete aJson.devDependencies;
-	delete aJson.optionalDependencies;
-
-	fs.writeFileSync(path.join(buildPath, `${name}.json`), JSON.stringify({
-		...aJson,
-		...bJson,
-		...json,
-	}, null, 2));
-};
-
-
-const writeProduct = () => {
-	const checksums = computeChecksums([
-		"vs/workbench/workbench.web.api.js",
-		"vs/workbench/workbench.web.api.css",
-		"vs/code/browser/workbench/workbench.html",
-		"vs/code/browser/workbench/workbench.js",
-		"vs/server/src/node/cli.js",
-		"vs/server/src/node/uriTransformer.js",
-		"vs/server/src/login/index.html"
-	]);
-	const date = new Date().toISOString();
-	const commit = util.getVersion(rootPath);
-	mergeAndWrite("product", { commit, date, checksums });
-	mergeAndWrite("package", { codeServerVersion: `${codeServerVersion}-vsc${vscodeVersion}` });
-};
-
-writeProduct();

scripts/build.ts

+import { Binary } from "@coder/nbin";
+import * as cp from "child_process";
+// import * as crypto from "crypto";
+import * as fs from "fs-extra";
+import * as os from "os";
+import * as path from "path";
+import * as util from "util";
+
+enum Task {
+	/**
+	 * Use before running anything that only works inside VS Code.
+	 */
+	EnsureInVscode = "ensure-in-vscode",
+	Binary = "binary",
+	Package = "package",
+	Build = "build",
+}
+
+class Builder {
+	private readonly rootPath = path.resolve(__dirname, "..");
+	private readonly outPath = process.env.OUT || this.rootPath;
+	private _target?: "darwin" | "alpine" | "linux";
+	private task?: Task;
+
+	public run(task: Task | undefined, args: string[]): void {
+		this.task = task;
+		this.doRun(task, args).catch((error) => {
+			console.error(error.message);
+			process.exit(1);
+		});
+	}
+
+	/**
+	 * Writes to stdout with an optional newline.
+	 */
+	private log(message: string, skipNewline: boolean = false): void {
+		process.stdout.write(`[${this.task || "default"}] ${message}`);
+		if (!skipNewline) {
+			process.stdout.write("\n");
+		}
+	}
+
+	private async doRun(task: Task | undefined, args: string[]): Promise<void> {
+		if (!task) {
+			throw new Error("No task provided");
+		}
+
+		if (task === Task.EnsureInVscode) {
+			return process.exit(this.isInVscode(this.rootPath) ? 0 : 1);
+		}
+
+		// If we're inside VS Code assume we want to develop. In that case we should
+		// set an OUT directory and not build in this directory, otherwise when you
+		// build/watch VS Code the build directory will be included.
+		if (this.isInVscode(this.outPath)) {
+			throw new Error("Should not build inside VS Code; set the OUT environment variable");
+		}
+
+		this.ensureArgument("rootPath", this.rootPath);
+		this.ensureArgument("outPath", this.outPath);
+
+		const arch = this.ensureArgument("arch", os.arch().replace(/^x/, "x86_"));
+		const target = this.ensureArgument("target", await this.target());
+		const vscodeVersion = this.ensureArgument("vscodeVersion", args[0]);
+		const codeServerVersion = this.ensureArgument("codeServerVersion", args[1]);
+
+		const stagingPath = path.join(this.outPath, "build");
+		const vscodeSourcePath = path.join(stagingPath, `vscode-${vscodeVersion}-source`);
+		const binariesPath = path.join(this.outPath, "binaries");
+		const binaryName = `code-server${codeServerVersion}-vsc${vscodeVersion}-${target}-${arch}`;
+		const finalBuildPath = path.join(stagingPath, `${binaryName}-built`);
+
+		switch (task) {
+			case Task.Binary:
+				return this.binary(finalBuildPath, binariesPath, binaryName);
+			case Task.Package:
+				return this.package(vscodeSourcePath, binariesPath, binaryName);
+			case Task.Build:
+				return this.build(vscodeSourcePath, vscodeVersion, codeServerVersion, finalBuildPath);
+			default:
+				throw new Error(`No task matching "${task}"`);
+		}
+	}
+
+	/**
+	 * Get the target of the system.
+	 */
+	private async target(): Promise<"darwin" | "alpine" | "linux"> {
+		if (!this._target) {
+			if (process.env.OSTYPE && /^darwin/.test(process.env.OSTYPE)) {
+				this._target = "darwin";
+			} else {
+				// Alpine's ldd doesn't have a version flag but if you use an invalid flag
+				// (like --version) it outputs the version to stderr and exits with 1.
+				const result = await util.promisify(cp.exec)("ldd --version")
+					.catch((error) => ({ stderr: error.message, stdout: "" }));
+				if (/^musl/.test(result.stderr) || /^musl/.test(result.stdout)) {
+					this._target = "alpine";
+				} else {
+					this._target = "linux";
+				}
+			}
+		}
+		return this._target;
+	}
+
+	/**
+	 * Make sure the argument is set. Display the value if it is.
+	 */
+	private ensureArgument(name: string, arg?: string): string {
+		if (!arg) {
+			this.log(`${name} is missing`);
+			throw new Error("Usage: <vscodeVersion> <codeServerVersion>");
+		}
+		this.log(`${name} is "${arg}"`);
+		return arg;
+	}
+
+	/**
+	 * Return true if it looks like we're inside VS Code. This is used to prevent
+	 * accidentally building inside while developing or to prevent trying to run
+	 * `yarn` in VS Code when we aren't in VS Code.
+	 */
+	private isInVscode(pathToCheck: string): boolean {
+		let inside = false;
+		const maybeVsCode = path.join(pathToCheck, "../../../");
+		try {
+			// If it has a package.json with the right name it's probably VS Code.
+			inside = require(path.join(maybeVsCode, "package.json")).name === "code-oss-dev";
+		} catch (error) {}
+		this.log(
+			inside
+				? `Running inside VS Code ([${maybeVsCode}]${path.relative(maybeVsCode, pathToCheck)})`
+				: "Not running inside VS Code"
+		);
+		return inside;
+	}
+
+	/**
+	 * Build code-server within VS Code.
+	 */
+	private async build(vscodeSourcePath: string, vscodeVersion: string, codeServerVersion: string, finalBuildPath: string): Promise<void> {
+		const task = async <T>(message: string, fn: () => Promise<T>): Promise<T> => {
+			const time = Date.now();
+			this.log(`${message}...`, true);
+			try {
+				const t = await fn();
+				process.stdout.write(`took ${Date.now() - time}ms\n`);
+				return t;
+			} catch (error) {
+				process.stdout.write("failed\n");
+				throw error;
+			}
+		};
+
+		// Install dependencies (should be cached by CI).
+		// Ignore scripts since we'll install VS Code dependencies separately.
+		await task("Installing code-server dependencies", async () => {
+			await util.promisify(cp.exec)("yarn --ignore-scripts", { cwd: this.rootPath });
+			await util.promisify(cp.exec)("yarn postinstall", { cwd: this.rootPath });
+		});
+
+		// Download and prepare VS Code if necessary (should be cached by CI).
+		const exists = fs.existsSync(vscodeSourcePath);
+		if (exists) {
+			this.log("Using existing VS Code directory");
+		} else {
+			await task("Cloning VS Code", () => {
+				return util.promisify(cp.exec)(
+					"git clone https://github.com/microsoft/vscode"
+						+ ` --quiet --branch "${vscodeVersion}"`
+						+ ` --single-branch --depth=1 "${vscodeSourcePath}"`);
+			});
+
+			await task("Installing VS Code dependencies", () => {
+				return util.promisify(cp.exec)("yarn", { cwd: vscodeSourcePath });
+			});
+
+			await task("Building default extensions", () => {
+				return util.promisify(cp.exec)(
+					"yarn gulp compile-extensions-build --max-old-space-size=32384",
+					{ cwd: vscodeSourcePath },
+				);
+			});
+		}
+
+		// Clean before patching or it could fail if already patched.
+		await task("Patching VS Code", async () => {
+			await util.promisify(cp.exec)("git reset --hard", { cwd: vscodeSourcePath });
+			await util.promisify(cp.exec)("git clean -fd", { cwd: vscodeSourcePath });
+			await util.promisify(cp.exec)(`git apply ${this.rootPath}/scripts/vscode.patch`, { cwd: vscodeSourcePath });
+		});
+
+		const serverPath = path.join(vscodeSourcePath, "src/vs/server");
+		await task("Copying code-server into VS Code", async () => {
+			await fs.remove(serverPath);
+			await fs.mkdirp(serverPath);
+			await Promise.all(["main.js", "node_modules", "src", "typings"].map((fileName) => {
+				return fs.copy(path.join(this.rootPath, fileName), path.join(serverPath, fileName));
+			}));
+		});
+
+		await task("Building VS Code", () => {
+			return util.promisify(cp.exec)("yarn gulp compile-build --max-old-space-size=32384", { cwd: vscodeSourcePath });
+		});
+
+		await task("Optimizing VS Code", async () => {
+			await fs.copyFile(path.join(this.rootPath, "scripts/optimize.js"), path.join(vscodeSourcePath, "coder.js"));
+			await util.promisify(cp.exec)(`yarn gulp optimize --max-old-space-size=32384 --gulpfile ./coder.js`, { cwd: vscodeSourcePath });
+		});
+
+		const { productJson, packageJson } = await task("Generating final package.json and product.json", async () => {
+			const merge = async (name: string, extraJson: { [key: string]: string } = {}): Promise<{ [key: string]: string }> => {
+				const [aJson, bJson] = (await Promise.all([
+					fs.readFile(path.join(vscodeSourcePath, `${name}.json`), "utf8"),
+					fs.readFile(path.join(this.rootPath, `scripts/${name}.json`), "utf8"),
+				])).map((raw) => {
+					const json = JSON.parse(raw);
+					delete json.scripts;
+					delete json.dependencies;
+					delete json.devDependencies;
+					delete json.optionalDependencies;
+					return json;
+				});
+
+				return { ...aJson, ...bJson, ...extraJson };
+			};
+
+			const date = new Date().toISOString();
+			const commit = require(path.join(vscodeSourcePath, "build/lib/util")).getVersion(this.rootPath);
+
+			const [productJson, packageJson] = await Promise.all([
+				merge("product", { commit, date }),
+				merge("package", { codeServerVersion: `${codeServerVersion}-vsc${vscodeVersion}` }),
+			]);
+
+			// We could do this before the optimization but then it'd be copied into
+			// three files and unused in two which seems like a waste of bytes.
+			const apiPath = path.join(vscodeSourcePath, "out-vscode/vs/workbench/workbench.web.api.js");
+			await fs.writeFile(apiPath, (await fs.readFile(apiPath, "utf8")).replace('{ /*BUILD->INSERT_PRODUCT_CONFIGURATION*/}', JSON.stringify({
+				version: packageJson.version,
+				codeServerVersion: packageJson.codeServerVersion,
+				...productJson,
+			})));
+
+			return { productJson, packageJson };
+		});
+
+		if (process.env.MINIFY) {
+			await task("Minifying VS Code", () => {
+				return util.promisify(cp.exec)("yarn gulp minify --max-old-space-size=32384 --gulpfile ./coder.js", { cwd: vscodeSourcePath });
+			});
+		}
+
+		const finalServerPath = path.join(finalBuildPath, "out/vs/server");
+		await task("Copying into final build directory", async () => {
+			await fs.remove(finalBuildPath);
+			await fs.mkdirp(finalBuildPath);
+			await Promise.all([
+				fs.copy(path.join(vscodeSourcePath, "remote/node_modules"), path.join(finalBuildPath, "node_modules")),
+				fs.copy(path.join(vscodeSourcePath, ".build/extensions"), path.join(finalBuildPath, "extensions")),
+				fs.copy(path.join(vscodeSourcePath, `out-vscode${process.env.MINIFY ? "-min" : ""}`), path.join(finalBuildPath, "out")).then(() => {
+					return Promise.all([
+						fs.remove(path.join(finalServerPath, "node_modules")).then(() => {
+							return fs.copy(path.join(serverPath, "node_modules"), path.join(finalServerPath, "node_modules"));
+						}),
+						fs.copy(path.join(serverPath, "src/browser/workbench-build.html"), path.join(finalServerPath, "src/browser/workbench.html")),
+					]);
+				}),
+			]);
+		});
+
+		if (process.env.MINIFY) {
+			await task("Restricting to production dependencies", async () => {
+				await Promise.all(["package.json", "yarn.lock"].map((fileName) => {
+					Promise.all([
+						fs.copy(path.join(this.rootPath, fileName), path.join(finalServerPath, fileName)),
+						fs.copy(path.join(path.join(vscodeSourcePath, "remote"), fileName), path.join(finalBuildPath, fileName)),
+					]);
+				}));
+
+				await Promise.all([
+					util.promisify(cp.exec)("yarn --production --ignore-scripts", { cwd: finalServerPath }),
+					util.promisify(cp.exec)("yarn --production", { cwd: finalBuildPath }),
+				]);
+
+				await Promise.all(["package.json", "yarn.lock"].map((fileName) => {
+					return Promise.all([
+						fs.remove(path.join(finalServerPath, fileName)),
+						fs.remove(path.join(finalBuildPath, fileName)),
+					]);
+				}));
+			});
+		}
+
+		await task("Writing final package.json and product.json", () => {
+			return Promise.all([
+				fs.writeFile(path.join(finalBuildPath, "package.json"), JSON.stringify(packageJson, null, 2)),
+				fs.writeFile(path.join(finalBuildPath, "product.json"), JSON.stringify(productJson, null, 2)),
+			]);
+		});
+
+		// This is so it doesn't get cached along with VS Code (no point).
+		await task("Removing copied server", () => fs.remove(serverPath));
+
+		// Prepend code to the target which enables finding files within the binary.
+		const prependLoader = async (relativeFilePath: string): Promise<void> => {
+			const filePath = path.join(finalBuildPath, relativeFilePath);
+			const shim = `
+				if (!global.NBIN_LOADED) {
+					try {
+						const nbin = require("nbin");
+						nbin.shimNativeFs("${finalBuildPath}");
+						global.NBIN_LOADED = true;
+						const path = require("path");
+						const rg = require("vscode-ripgrep");
+						rg.binaryRgPath = rg.rgPath;
+						rg.rgPath = path.join(require("os").tmpdir(), "code-server", path.basename(rg.binaryRgPath));
+					} catch (error) { /*  Not in the binary. */ }
+				}
+			`;
+			await fs.writeFile(filePath, shim + (await fs.readFile(filePath, "utf8")));
+		};
+
+		await task("Prepending nbin loader", () => {
+			return Promise.all([
+				prependLoader("out/vs/server/main.js"),
+				prependLoader("out/bootstrap-fork.js"),
+				prependLoader("extensions/node_modules/typescript/lib/tsserver.js"),
+			]);
+		});
+
+		// TODO: fix onigasm dep
+		// # onigasm 2.2.2 has a bug that makes it broken for PHP files so use 2.2.1.
+		// # https://github.com/NeekSandhu/onigasm/issues/17
+		// function fix-onigasm() {
+		// 	local onigasmPath="${buildPath}/node_modules/onigasm-umd"
+		// 	rm -rf "${onigasmPath}"
+		// 	git clone "https://github.com/alexandrudima/onigasm-umd" "${onigasmPath}"
+		// 	cd "${onigasmPath}" && yarn && yarn add --dev onigasm@2.2.1 && yarn package
+		// 	mkdir "${onigasmPath}-temp"
+		// 	mv "${onigasmPath}/"{release,LICENSE} "${onigasmPath}-temp"
+		// 	rm -rf "${onigasmPath}"
+		// 	mv "${onigasmPath}-temp" "${onigasmPath}"
+		// }
+
+		this.log(`Final build: ${finalBuildPath}`);
+	}
+
+	/**
+	 * Bundles the built code into a binary.
+	 */
+	private async binary(targetPath: string, binariesPath: string, binaryName: string): Promise<void> {
+		const bin = new Binary({
+			mainFile: path.join(targetPath, "out/vs/server/main.js"),
+			target: await this.target(),
+		});
+
+		bin.writeFiles(path.join(targetPath, "**"));
+
+		await fs.mkdirp(binariesPath);
+
+		const binaryPath = path.join(binariesPath, binaryName);
+		await fs.writeFile(binaryPath, await bin.build());
+		await fs.chmod(binaryPath, "755");
+
+		this.log(`Binary: ${binaryPath}`);
+	}
+
+	/**
+	 * Package the binary into a release archive.
+	 */
+	private async package(vscodeSourcePath: string, binariesPath: string, binaryName: string): Promise<void> {
+		const releasePath = path.join(this.outPath, "release");
+		const archivePath = path.join(releasePath, binaryName);
+
+		await fs.remove(archivePath);
+		await fs.mkdirp(archivePath);
+
+		await fs.copyFile(path.join(binariesPath, binaryName), path.join(archivePath, "code-server"));
+		await fs.copyFile(path.join(this.rootPath, "README.md"), path.join(archivePath, "README.md"));
+		await fs.copyFile(path.join(vscodeSourcePath, "LICENSE.txt"), path.join(archivePath, "LICENSE.txt"));
+		await fs.copyFile(path.join(vscodeSourcePath, "ThirdPartyNotices.txt"), path.join(archivePath, "ThirdPartyNotices.txt"));
+
+		if ((await this.target()) === "darwin") {
+			await util.promisify(cp.exec)(`zip -r "${binaryName}.zip" "${binaryName}"`, { cwd: releasePath });
+			this.log(`Archive: ${archivePath}.zip`);
+		} else {
+			await util.promisify(cp.exec)(`tar -czf "${binaryName}.tar.gz" "${binaryName}"`, { cwd: releasePath });
+			this.log(`Archive: ${archivePath}.tar.gz`);
+		}
+	}
+}
+
+const builder = new Builder();
+builder.run(process.argv[2] as Task, process.argv.slice(3));

scripts/ci.bash

 #!/bin/bash
 set -euo pipefail
 
-# Build using a Docker container.
 function docker-build() {
 	local target="${TARGET:-}"
 	local image="codercom/nbin-${target}"
@@ -12,15 +11,15 @@ function docker-build() {
 	fi
 
 	local containerId
-	containerId=$(docker create --network=host --rm -it -v "$(pwd)"/.cache:/src/.cache "${image}")
+	# Use a mount so we can cache the results.
+	containerId=$(docker create --network=host --rm -it -v "$(pwd)":/src "${image}")
 	docker start "${containerId}"
-	docker exec "${containerId}" mkdir -p /src
 
-	# TODO: temporary as long as we are rebuilding modules.
+	# TODO: Might be better to move these dependencies to the images or create new
+	# ones on top of these.
 	if [[ "${image}" == "codercom/nbin-alpine" ]] ; then
 		docker exec "${containerId}" apk add libxkbfile-dev libsecret-dev
 	else
-		# TODO: at some point git existed but it seems to have disappeared.
 		docker exec "${containerId}" yum install -y libxkbfile-devel libsecret-devel git
 	fi
 
@@ -31,19 +30,15 @@ function docker-build() {
 			bash -c "cd /src && CI=true GITHUB_TOKEN=${token} MINIFY=${minify} yarn ${command} ${args}"
 	}
 
-	docker cp ./. "${containerId}":/src
 	docker-exec build
 	if [[ -n "${package}" ]] ; then
 		docker-exec binary
 		docker-exec package
-		mkdir -p release
-		docker cp "${containerId}":/src/release/. ./release/
 	fi
 
-	docker stop "${containerId}"
+	docker kill "${containerId}"
 }
 
-# Build locally.
 function local-build() {
 	function local-exec() {
 		local command="${1}" ; shift

scripts/nbin-shim.js

-// This file is prepended to loader/entry code (like our main.js or VS Code's
-// bootstrap-fork.js). {{ROOT_PATH}} is replaced during the build process.
-if (!global.NBIN_LOADED) {
-	try {
-		const nbin = require("nbin");
-		nbin.shimNativeFs("{{ROOT_PATH}}");
-		global.NBIN_LOADED = true;
-		const path = require("path");
-		const rg = require("vscode-ripgrep");
-		rg.binaryRgPath = rg.rgPath;
-		rg.rgPath = path.join(
-			require("os").tmpdir(),
-			`code-server/${path.basename(rg.binaryRgPath)}`
-		);
-	} catch (error) { /*  Not in the binary. */ }
-}

scripts/nbin.js

-const { Binary } = require("@coder/nbin");
-const fs = require("fs");
-const path = require("path");
-
-const source = process.argv[2];
-const target = process.argv[3];
-const binaryName = process.argv[4];
-
-const bin = new Binary({
-	mainFile: path.join(source, "out/vs/server/main.js"),
-	target: target,
-});
-
-bin.writeFiles(path.join(source, "**"));
-
-bin.build().then((binaryData) => {
-	const outputPath = path.join(source, binaryName);
-	fs.writeFileSync(outputPath, binaryData);
-	fs.chmodSync(outputPath, "755");
-}).catch((ex) => {
-	console.error(ex);
-	process.exit(1);
-});

scripts/optimize.js

+// This must be ran from VS Code's root.
+const gulp = require("gulp");
+const path = require("path");
+const _ = require("underscore");
+const buildfile = require("./src/buildfile");
+const common = require("./build/lib/optimize");
+const util = require("./build/lib/util");
+const deps = require("./build/dependencies");
+
+const vscodeEntryPoints = _.flatten([
+	buildfile.entrypoint("vs/workbench/workbench.web.api"),
+	buildfile.entrypoint("vs/server/src/node/cli"),
+	buildfile.base,
+	buildfile.workbenchWeb,
+	buildfile.workerExtensionHost,
+	buildfile.keyboardMaps,
+	buildfile.entrypoint('vs/platform/files/node/watcher/unix/watcherApp', ["vs/css", "vs/nls"]),
+	buildfile.entrypoint('vs/platform/files/node/watcher/nsfw/watcherApp', ["vs/css", "vs/nls"]),
+	buildfile.entrypoint('vs/workbench/services/extensions/node/extensionHostProcess', ["vs/css", "vs/nls"]),
+]);
+
+const vscodeResources = [
+	"out-build/vs/server/main.js",
+	"out-build/vs/server/src/node/uriTransformer.js",
+	"!out-build/vs/server/doc/**",
+	"out-build/vs/code/browser/workbench/**",
+	"out-build/vs/server/src/media/*",
+	"out-build/vs/workbench/services/extensions/worker/extensionHostWorkerMain.js",
+	"out-build/bootstrap.js",
+	"out-build/bootstrap-fork.js",
+	"out-build/bootstrap-amd.js",
+	"out-build/paths.js",
+	"out-build/vs/**/*.{svg,png}",
+	'!out-build/vs/code/electron-browser/**',
+	"out-build/vs/base/common/performance.js",
+	"out-build/vs/base/node/languagePacks.js",
+	"out-build/vs/base/browser/ui/octiconLabel/octicons/**",
+	"out-build/vs/base/browser/ui/codiconLabel/codicon/**",
+	"out-build/vs/workbench/browser/media/*-theme.css",
+	"out-build/vs/workbench/contrib/debug/**/*.json",
+	"out-build/vs/workbench/contrib/externalTerminal/**/*.scpt",
+	"out-build/vs/workbench/contrib/webview/browser/pre/*.js",
+	"out-build/vs/**/markdown.css",
+	"out-build/vs/workbench/contrib/tasks/**/*.json",
+	"out-build/vs/platform/files/**/*.md",
+	"!**/test/**"
+];
+
+const rootPath = __dirname;
+const nodeModules = ["electron", "original-fs"]
+	.concat(_.uniq(deps.getProductionDependencies(rootPath).map((d) => d.name)))
+	.concat(_.uniq(deps.getProductionDependencies(path.join(rootPath, "src/vs/server")).map((d) => d.name)))
+	.concat(Object.keys(process.binding("natives")).filter((n) => !/^_|\//.test(n)));
+
+gulp.task("optimize", gulp.series(
+	util.rimraf("out-vscode"),
+	common.optimizeTask({
+		src: "out-build",
+		entryPoints: vscodeEntryPoints,
+		resources: vscodeResources,
+		loaderConfig: common.loaderConfig(nodeModules),
+		out: "out-vscode",
+		inlineAmdImages: true,
+		bundleInfo: undefined
+	}),
+));
+
+gulp.task("minify", gulp.series(
+	util.rimraf("out-vscode-min"),
+	common.minifyTask("out-vscode")
+));

scripts/product.json

@@ -15,5 +15,7 @@
 	"win32ShellNameShort": "C&ode Server",
 	"darwinBundleIdentifier": "com.code.server",
 	"linuxIconName": "com.code.server",
-	"urlProtocol": "code-server"
+	"urlProtocol": "code-server",
+	"updateUrl": "https://api.github.com/repos/cdr/code-server/releases",
+	"quality": "latest"
 }

scripts/tasks.bash

-#!/bin/bash
-set -euox pipefail
-
-function log() {
-	local message="${1}" ; shift
-	local level="${1:-info}"
-	if [[ "${level}" == "error" ]] ; then
-		>&2 echo "${message}"
-	else
-		echo "${message}"
-	fi
-}
-
-# Copy code-server into VS Code along with its dependencies.
-function copy-server() {
-	local serverPath="${sourcePath}/src/vs/server"
-	rm -rf "${serverPath}"
-	mkdir -p "${serverPath}"
-
-	cp -r "${rootPath}/src" "${serverPath}"
-	cp -r "${rootPath}/typings" "${serverPath}"
-	cp "${rootPath}/main.js" "${serverPath}"
-	cp "${rootPath}/package.json" "${serverPath}"
-	cp "${rootPath}/yarn.lock" "${serverPath}"
-
-	if [[ -d "${rootPath}/node_modules" ]] ; then
-		cp -r "${rootPath}/node_modules" "${serverPath}"
-	else
-		# Ignore scripts to avoid also installing VS Code dependencies which has
-		# already been done.
-		cd "${serverPath}" && yarn --ignore-scripts
-		rm -r node_modules/@types/node # I keep getting type conflicts
-	fi
-
-	# TODO: Duplicate identifier issue. There must be a better way to fix this.
-	if [[ "${target}" == "darwin" ]] ; then
-		rm "${serverPath}/node_modules/fsevents/node_modules/safe-buffer/index.d.ts"
-	fi
-}
-
-# Prepend the nbin shim which enables finding files within the binary.
-function prepend-loader() {
-	local filePath="${buildPath}/${1}" ; shift
-	cat "${rootPath}/scripts/nbin-shim.js" "${filePath}" > "${filePath}.temp"
-	mv "${filePath}.temp" "${filePath}"
-	# Using : as the delimiter so the escaping here is easier to read.
-	# ${parameter/pattern/string}, so the pattern is /: (if the pattern starts
-	# with / it matches all instances) and the string is \\: (results in \:).
-	if [[ "${target}" == "darwin" ]] ; then
-		sed -i "" -e "s:{{ROOT_PATH}}:${buildPath//:/\\:}:g" "${filePath}"
-	else
-		sed -i "s:{{ROOT_PATH}}:${buildPath//:/\\:}:g" "${filePath}"
-	fi
-}
-
-# Copy code-server into VS Code then build it.
-function build-code-server() {
-	copy-server
-	cd "${sourcePath}" && yarn gulp compile-build --max-old-space-size=32384
-
-	local min=""
-	if [[ -n "${minify}" ]] ; then
-		min="-min"
-		yarn gulp minify-vscode --max-old-space-size=32384
-	else
-		yarn gulp optimize-vscode --max-old-space-size=32384
-	fi
-
-	rm -rf "${buildPath}"
-	mkdir -p "${buildPath}"
-
-	# Rebuild to make sure native modules work on the target system.
-	cp "${sourcePath}/remote/"{package.json,yarn.lock,.yarnrc} "${buildPath}"
-	cd "${buildPath}" && yarn --production --force --build-from-source
-	rm "${buildPath}/"{package.json,yarn.lock,.yarnrc}
-
-	cp -r "${sourcePath}/.build/extensions" "${buildPath}"
-	cp -r "${sourcePath}/out-vscode${min}" "${buildPath}/out"
-	node "${rootPath}/scripts/build-json.js" "${sourcePath}" "${buildPath}" "${vscodeVersion}" "${codeServerVersion}"
-
-	# Only keep production dependencies for the server.
-	cp "${rootPath}/"{package.json,yarn.lock} "${buildPath}/out/vs/server"
-	cd "${buildPath}/out/vs/server" && yarn --production --ignore-scripts
-	rm "${buildPath}/out/vs/server/"{package.json,yarn.lock}
-
-	# onigasm 2.2.2 has a bug that makes it broken for PHP files so use 2.2.1.
-	# https://github.com/NeekSandhu/onigasm/issues/17
-	local onigasmPath="${buildPath}/node_modules/onigasm-umd"
-	rm -rf "${onigasmPath}"
-	git clone "https://github.com/alexandrudima/onigasm-umd" "${onigasmPath}"
-	cd "${onigasmPath}" && yarn && yarn add --dev onigasm@2.2.1 && yarn package
-	mkdir "${onigasmPath}-temp"
-	mv "${onigasmPath}/"{release,LICENSE} "${onigasmPath}-temp"
-	rm -rf "${onigasmPath}"
-	mv "${onigasmPath}-temp" "${onigasmPath}"
-
-	prepend-loader "out/vs/server/main.js"
-	prepend-loader "out/bootstrap-fork.js"
-	prepend-loader "extensions/node_modules/typescript/lib/tsserver.js"
-
-	log "Final build: ${buildPath}"
-}
-
-# Download and extract a tar from a URL with either curl or wget depending on
-# which is available.
-function download-tar() {
-	local url="${1}" ; shift
-	if command -v wget &> /dev/null ; then
-		wget "${url}" --quiet -O - | tar -C "${stagingPath}" -xz
-	else
-		curl "${url}" --silent --fail | tar -C "${stagingPath}" -xz
-	fi
-}
-
-# Download a pre-built package. If it doesn't exist and we are in the CI, exit.
-# Otherwise the return will be whether it existed or not. The pre-built package
-# is provided to reduce CI build time.
-function download-pre-built() {
-	local archiveName="${1}" ; shift
-	local url="https://codesrv-ci.cdr.sh/${archiveName}"
-	if ! download-tar "${url}" ; then
-		if [[ -n "${ci}" ]] ; then
-			log "${url} does not exist" "error"
-			exit 1
-		fi
-		return 1
-	fi
-	return 0
-}
-
-# Fully build code-server.
-function build-task() {
-	mkdir -p "${stagingPath}"
-	if [[ ! -d "${sourcePath}" ]] ; then
-		if ! download-pre-built "vscode-${vscodeVersion}.tar.gz" ; then
-			git clone https://github.com/microsoft/vscode --quiet \
-				--branch "${vscodeVersion}" --single-branch --depth=1 \
-				"${sourcePath}"
-		fi
-	fi
-	cd "${sourcePath}"
-	git reset --hard && git clean -fd
-	git apply "${rootPath}/scripts/vscode.patch"
-	if [[ ! -d "${sourcePath}/node_modules" ]] ; then
-		if [[ -n "${ci}" ]] ; then
-			log "Pre-built VS Code ${vscodeVersion} has no node_modules" "error"
-			exit 1
-		fi
-		yarn
-	fi
-	if [[ ! -d "${sourcePath}/.build/extensions" ]] ; then
-		if [[ -n "${ci}" ]] ; then
-			log "Pre-built VS Code ${vscodeVersion} has no built extensions" "error"
-			exit 1
-		fi
-		yarn gulp compile-extensions-build --max-old-space-size=32384
-	fi
-	build-code-server
-}
-
-# Package the binary into a tar or zip for release.
-function package-task() {
-	local archivePath="${releasePath}/${binaryName}"
-	rm -rf "${archivePath}"
-	mkdir -p "${archivePath}"
-
-	cp "${buildPath}/${binaryName}" "${archivePath}/code-server"
-	cp "${rootPath}/README.md" "${archivePath}"
-	cp "${sourcePath}/LICENSE.txt" "${archivePath}"
-	cp "${sourcePath}/ThirdPartyNotices.txt" "${archivePath}"
-
-	cd "${releasePath}"
-	if [[ "${target}" == "darwin" ]] ; then
-		zip -r "${binaryName}.zip" "${binaryName}"
-		log "Archive: ${archivePath}.zip"
-	else
-		tar -czf "${binaryName}.tar.gz" "${binaryName}"
-		log "Archive: ${archivePath}.tar.gz"
-	fi
-}
-
-# Bundle built code into a binary.
-function binary-task() {
-	cd "${rootPath}"
-	node "${rootPath}/scripts/nbin.js" "${buildPath}" "${target}" "${binaryName}"
-	log "Binary: ${buildPath}/${binaryName}"
-}
-
-# Check if it looks like we are inside VS Code.
-function in-vscode () {
-	local dir="${1}" ; shift
-	local maybeVsCode
-	local dirName
-	maybeVsCode="$(cd "${dir}/../../.." ; pwd -P)"
-	dirName="$(basename "${maybeVsCode}")"
-	if [[ "${dirName}" != "vscode" ]] ; then
-		return 1
-	fi
-	if [[ ! -f "${maybeVsCode}/package.json" ]] ; then
-		return 1
-	fi
-	if ! grep '"name": "code-oss-dev"' "${maybeVsCode}/package.json" -q ; then
-		return 1
-	fi
-	return 0
-}
-
-function main() {
-	local rootPath
-	rootPath="$(cd "$(dirname "${0}")/.." ; pwd -P)"
-
-	local task="${1}" ; shift
-	if [[ "${task}" == "ensure-in-vscode" ]] ; then
-		if ! in-vscode "${rootPath}"; then
-			log "Not in VS Code" "error"
-			exit 1
-		fi
-		exit 0
-	fi
-
-	# This lets you build in a separate directory since building within this
-	# directory while developing makes it hard to keep developing since compiling
-	# will compile everything in the build directory as well.
-	local outPath="${OUT:-${rootPath}}"
-	local releasePath="${outPath}/release"
-	local stagingPath="${outPath}/build"
-
-	# If we're inside a VS Code directory, assume we want to develop. In that case
-	# we should set an OUT directory and not build in this directory.
-	if in-vscode "${outPath}" ; then
-		log "Set the OUT environment variable to something outside of VS Code" "error"
-		exit 1
-	fi
-
-	local vscodeVersion="${1}" ; shift
-	local sourceName="vscode-${vscodeVersion}-source"
-	local sourcePath="${stagingPath}/${sourceName}"
-
-	if [[ "${task}" == "package-prebuilt" ]] ; then
-		local archiveName="vscode-${vscodeVersion}.tar.gz"
-		cd "${sourcePath}"
-		git reset --hard && git clean -xfd -e '.build/extensions' -e 'node_modules'
-		cd "${stagingPath}"
-		tar -czf "${archiveName}" "${sourceName}"
-		mkdir -p "${releasePath}" && mv -f "${archiveName}" "${releasePath}"
-		exit 0
-	fi
-
-	local codeServerVersion="${1}" ; shift
-	local ci="${CI:-}"
-	local minify="${MINIFY:-}"
-
-	local arch
-	arch=$(uname -m)
-
-	local target="linux"
-	local ostype="${OSTYPE:-}"
-	if [[ "${ostype}" == "darwin"* ]] ; then
-		target="darwin"
-	else
-		# On Alpine there seems no way to get the version except to use an invalid
-		# command which will output the version to stderr and exit with 1.
-		local output
-		output=$(ldd --version 2>&1 || :)
-		if [[ "${output}" == "musl"* ]] ; then
-			target="alpine"
-		fi
-	fi
-
-	local binaryName="code-server${codeServerVersion}-vsc${vscodeVersion}-${target}-${arch}"
-	local buildPath="${stagingPath}/${binaryName}-built"
-
-	"${task}-task" "$@"
-}
-
-main "$@"

scripts/tsconfig.json

+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"noImplicitAny": true,
+		"experimentalDecorators": true,
+		"noImplicitReturns": true,
+		"noUnusedLocals": true,
+		"noImplicitThis": true,
+		"alwaysStrict": true,
+		"strictBindCallApply": true,
+		"strictNullChecks": true,
+		"forceConsistentCasingInFileNames": true,
+		"baseUrl": ".",
+		"target": "esnext"
+	}
+}

src/browser/api.ts

@@ -15,7 +15,7 @@ import { IInstantiationService, ServiceIdentifier } from "vs/platform/instantiat
 import { ServiceCollection } from "vs/platform/instantiation/common/serviceCollection";
 import { INotificationService } from "vs/platform/notification/common/notification";
 import { Registry } from "vs/platform/registry/common/platform";
-import { IStatusbarEntry, IStatusbarEntryAccessor, IStatusbarService, StatusbarAlignment } from "vs/platform/statusbar/common/statusbar";
+import { IStatusbarEntry, IStatusbarEntryAccessor, IStatusbarService, StatusbarAlignment } from "vs/workbench/services/statusbar/common/statusbar";
 import { IStorageService } from "vs/platform/storage/common/storage";
 import { ITelemetryService } from "vs/platform/telemetry/common/telemetry";
 import { IThemeService } from "vs/platform/theme/common/themeService";

src/browser/client.ts

@@ -3,16 +3,13 @@ import { URI } from "vs/base/common/uri";
 import { registerSingleton } from "vs/platform/instantiation/common/extensions";
 import { ServiceCollection } from "vs/platform/instantiation/common/serviceCollection";
 import { ILocalizationsService } from "vs/platform/localizations/common/localizations";
-import { LocalizationsService } from "vs/platform/localizations/electron-browser/localizationsService";
+import { LocalizationsService } from "vs/workbench/services/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 { 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";
 import { PersistentConnectionEventType } from "vs/platform/remote/common/remoteAgentConnection";
 
@@ -52,7 +49,6 @@ class NodeProxyService extends NodeProxyChannelClient implements INodeProxyServi
 registerSingleton(ILocalizationsService, LocalizationsService);
 registerSingleton(INodeProxyService, NodeProxyService);
 registerSingleton(ITelemetryService, TelemetryService);
-registerSingleton(IUpdateService, UpdateService);
 registerSingleton(IUploadService, UploadService, true);
 
 /**

src/browser/upload.ts

@@ -8,8 +8,8 @@ import { IFileService } from "vs/platform/files/common/files";
 import { createDecorator, IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { INotificationService, Severity } from "vs/platform/notification/common/notification";
 import { IProgress, IProgressService, IProgressStep, ProgressLocation } from "vs/platform/progress/common/progress";
-import { IWindowsService } from "vs/platform/windows/common/windows";
 import { IWorkspaceContextService } from "vs/platform/workspace/common/workspace";
+import { IWorkspacesService } from 'vs/platform/workspaces/common/workspaces';
 import { ExplorerItem } from "vs/workbench/contrib/files/common/explorerModel";
 import { IEditorGroup } from "vs/workbench/services/editor/common/editorGroupsService";
 import { IEditorService } from "vs/workbench/services/editor/common/editorService";
@@ -29,7 +29,7 @@ export class UploadService extends Disposable implements IUploadService {
 	public constructor(
 		@IInstantiationService instantiationService: IInstantiationService,
 		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService,
-		@IWindowsService private readonly windowsService: IWindowsService,
+		@IWorkspacesService private readonly workspacesService: IWorkspacesService,
 		@IEditorService private readonly editorService: IEditorService,
 	) {
 		super();
@@ -38,10 +38,10 @@ export class UploadService extends Disposable implements IUploadService {
 
 	public async handleDrop(event: DragEvent, resolveTargetGroup: () => IEditorGroup | undefined, afterDrop: (targetGroup: IEditorGroup | undefined) => void, targetIndex?: number): Promise<void> {
 		// TODO: should use the workspace for the editor it was dropped on?
-		const target =this.contextService.getWorkspace().folders[0].uri;
+		const target = this.contextService.getWorkspace().folders[0].uri;
 		const uris = (await this.upload.uploadDropped(event, target)).map((u) => URI.file(u));
 		if (uris.length > 0) {
-			await this.windowsService.addRecentlyOpened(uris.map((u) => ({ fileUri: u })));
+			await this.workspacesService.addRecentlyOpened(uris.map((u) => ({ fileUri: u })));
 		}
 		const editors = uris.map((uri) => ({
 			resource: uri,

src/browser/workbench-build.html

+<!-- Copyright (C) Microsoft Corporation. All rights reserved. -->
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+
+		<!-- Disable pinch zooming -->
+		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
+
+		<!-- Content Security Policy -->
+		<meta
+			http-equiv="Content-Security-Policy"
+			content="
+				default-src 'self';
+				img-src 'self' https: data: blob:;
+				media-src 'none';
+				script-src 'self' 'unsafe-eval' https: 'sha256-bpJydy1E+3Mx9MyBtkOIA3yyzM2wdyIz115+Sgq21+0=' 'sha256-meDZW3XhN5JmdjFUrWGhTouRKBiWYtXHltaKnqn/WMo=';
+				child-src 'self';
+				frame-src 'self';
+				worker-src 'self';
+				style-src 'self' 'unsafe-inline';
+				connect-src 'self' ws: wss: https:;
+				font-src 'self' blob:;
+				manifest-src 'self';
+		">
+
+		<!-- Workbench Configuration -->
+		<meta id="vscode-workbench-web-configuration" data-settings="{{WORKBENCH_WEB_CONFIGURATION}}">
+
+		<!-- Workarounds/Hacks (remote user data uri) -->
+		<meta id="vscode-remote-user-data-uri" data-settings="{{REMOTE_USER_DATA_URI}}">
+		<!-- NOTE@coder: Added the commit for use in caching, the product for the
+		extensions gallery URL, and nls for language support. -->
+		<meta id="vscode-remote-commit" data-settings="{{COMMIT}}">
+		<meta id="vscode-remote-product-configuration" data-settings="{{PRODUCT_CONFIGURATION}}">
+		<meta id="vscode-remote-nls-configuration" data-settings="{{NLS_CONFIGURATION}}">
+
+		<!-- Workbench Icon/Manifest/CSS -->
+		<link rel="icon" href="./favicon.ico" type="image/x-icon" />
+		<link rel="manifest" href="./manifest.json">
+		<link rel="apple-touch-icon" href="./static-{{COMMIT}}/out/vs/server/src/media/code-server.png" />
+		<link data-name="vs/workbench/workbench.web.api" rel="stylesheet" href="./static-{{COMMIT}}/out/vs/workbench/workbench.web.api.css">
+
+		<!-- Prefetch to avoid waterfall -->
+		<link rel="prefetch" href="./static-{{COMMIT}}/node_modules/semver-umd/lib/semver-umd.js">
+		<link rel="prefetch" href="./static-{{COMMIT}}/node_modules/@microsoft/applicationinsights-web/dist/applicationinsights-web.js">
+	</head>
+
+	<body aria-label="">
+	</body>
+
+	<!-- Startup (do not modify order of script tags!) -->
+	<!-- NOTE:coder: Modified to work against the current path and use the commit for caching. -->
+	<script>
+		// NOTE: Changes to inline scripts require update of content security policy
+		const basePath = window.location.pathname.replace(/\/+$/, '');
+		const base = window.location.origin  + basePath;
+		const el = document.getElementById('vscode-remote-commit');
+		const commit = el ? el.getAttribute('data-settings') : "";
+		const staticBase = base + '/static-' + commit;
+		let nlsConfig;
+		try {
+			nlsConfig = JSON.parse(document.getElementById('vscode-remote-nls-configuration').getAttribute('data-settings'));
+			if (nlsConfig._resolvedLanguagePackCoreLocation) {
+				const bundles = Object.create(null);
+				nlsConfig.loadBundle = (bundle, language, cb) => {
+					let result = bundles[bundle];
+					if (result) {
+						return cb(undefined, result);
+					}
+					// FIXME: Only works if path separators are /.
+					const path = nlsConfig._resolvedLanguagePackCoreLocation
+								+ '/' + bundle.replace(/\//g, '!') + '.nls.json';
+					fetch(`${base}/resource/?path=${encodeURIComponent(path)}`)
+						.then((response) => response.json())
+						.then((json) => {
+							bundles[bundle] = json;
+							cb(undefined, json);
+						})
+						.catch(cb);
+				};
+			}
+		} catch (error) { /* Probably fine. */ }
+		self.require = {
+			baseUrl: `${staticBase}/out`,
+			paths: {
+				'vscode-textmate': `${staticBase}/node_modules/vscode-textmate/release/main`,
+				'onigasm-umd': `${staticBase}/node_modules/onigasm-umd/release/main`,
+				'xterm': `${staticBase}/node_modules/xterm/lib/xterm.js`,
+				'xterm-addon-search': `${staticBase}/node_modules/xterm-addon-search/lib/xterm-addon-search.js`,
+				'xterm-addon-web-links': `${staticBase}/node_modules/xterm-addon-web-links/lib/xterm-addon-web-links.js`,
+				'semver-umd': `${staticBase}/node_modules/semver-umd/lib/semver-umd.js`,
+				'@microsoft/applicationinsights-web': `${staticBase}/node_modules/@microsoft/applicationinsights-web/dist/applicationinsights-web.js`,
+			},
+			'vs/nls': nlsConfig,
+		};
+	</script>
+	<script src="./static-{{COMMIT}}/out/vs/loader.js"></script>
+	<script src="./static-{{COMMIT}}/out/vs/workbench/workbench.web.api.nls.js"></script>
+	<script src="./static-{{COMMIT}}/out/vs/workbench/workbench.web.api.js"></script>
+	<!-- TODO@coder: This errors with multiple anonymous define calls (one is
+	workbench.js and one is semver-umd.js). For now use the same method found in
+	workbench-dev.html. Appears related to the timing of the script load events. -->
+	<!-- <script src="./static-{{COMMIT}}/out/vs/workbench/workbench.js"></script> -->
+	<script>
+		// NOTE: Changes to inline scripts require update of content security policy
+		require(['vs/code/browser/workbench/workbench'], function() {});
+	</script>
+</html>

src/browser/workbench.html

+<!-- Copyright (C) Microsoft Corporation. All rights reserved. -->
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+
+		<!-- Disable pinch zooming -->
+		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
+
+		<!-- Content Security Policy -->
+		<meta
+			http-equiv="Content-Security-Policy"
+			content="
+				default-src 'self';
+				img-src 'self' https: data: blob:;
+				media-src 'none';
+				script-src 'self' https://az416426.vo.msecnd.net 'unsafe-eval' https: 'unsafe-inline';
+				child-src 'self';
+				frame-src 'self' https://*.vscode-webview-test.com;
+				worker-src 'self';
+				style-src 'self' 'unsafe-inline';
+				connect-src 'self' ws: wss: https:;
+				font-src 'self' blob:;
+				manifest-src 'self';
+		">
+
+		<!-- Workbench Configuration -->
+		<meta id="vscode-workbench-web-configuration" data-settings="{{WORKBENCH_WEB_CONFIGURATION}}">
+
+		<!-- Workarounds/Hacks (remote user data uri) -->
+		<meta id="vscode-remote-user-data-uri" data-settings="{{REMOTE_USER_DATA_URI}}">
+		<!-- NOTE@coder: Added the commit for use in caching, the product for the
+		extensions gallery URL, and nls for language support. -->
+		<meta id="vscode-remote-commit" data-settings="{{COMMIT}}">
+		<meta id="vscode-remote-product-configuration" data-settings="{{PRODUCT_CONFIGURATION}}">
+		<meta id="vscode-remote-nls-configuration" data-settings="{{NLS_CONFIGURATION}}">
+
+		<!-- Workbench Icon/Manifest/CSS -->
+		<link rel="icon" href="./favicon.ico" type="image/x-icon" />
+		<link rel="manifest" href="./manifest.json">
+	</head>
+
+	<body aria-label="">
+	</body>
+
+	<!-- Startup (do not modify order of script tags!) -->
+	<script>
+		const basePath = window.location.pathname.replace(/\/+$/, '');
+		const base = window.location.origin  + basePath;
+		const el = document.getElementById('vscode-remote-commit');
+		const commit = el ? el.getAttribute('data-settings') : "";
+		const staticBase = base + '/static-' + commit;
+		self.require = {
+			baseUrl: `${staticBase}/out`,
+			paths: {
+				'vscode-textmate': `${staticBase}/node_modules/vscode-textmate/release/main`,
+				'onigasm-umd': `${staticBase}/node_modules/onigasm-umd/release/main`,
+				'xterm': `${staticBase}/node_modules/xterm/lib/xterm.js`,
+				'xterm-addon-search': `${staticBase}/node_modules/xterm-addon-search/lib/xterm-addon-search.js`,
+				'xterm-addon-web-links': `${staticBase}/node_modules/xterm-addon-web-links/lib/xterm-addon-web-links.js`,
+				'semver-umd': `${staticBase}/node_modules/semver-umd/lib/semver-umd.js`,
+				'@microsoft/applicationinsights-web': `${staticBase}/node_modules/@microsoft/applicationinsights-web/dist/applicationinsights-web.js`,
+			},
+		};
+	</script>
+	<script src="./static/out/vs/loader.js"></script>
+	<script>
+		require(['vs/code/browser/workbench/workbench'], function() {});
+	</script>
+</html>

src/node/channel.ts

@@ -12,8 +12,7 @@ import { ExtensionIdentifier, IExtensionDescription } from "vs/platform/extensio
 import { FileDeleteOptions, FileOpenOptions, FileOverwriteOptions, FileType, IStat, IWatchOptions } from "vs/platform/files/common/files";
 import { DiskFileSystemProvider } from "vs/platform/files/node/diskFileSystemProvider";
 import { ILogService } from "vs/platform/log/common/log";
-import pkg from "vs/platform/product/node/package";
-import product from "vs/platform/product/node/product";
+import product from "vs/platform/product/common/product";
 import { IRemoteAgentEnvironment } from "vs/platform/remote/common/remoteAgentEnvironment";
 import { ITelemetryService } from "vs/platform/telemetry/common/telemetry";
 import { INodeProxyService } from "vs/server/src/common/nodeProxy";
@@ -228,7 +227,7 @@ export class ExtensionEnvironmentChannel implements IServerChannel {
 		const scanMultiple = (isBuiltin: boolean, isUnderDevelopment: boolean, paths: string[]): Promise<IExtensionDescription[][]> => {
 			return Promise.all(paths.map((path) => {
 				return ExtensionScanner.scanExtensions(new ExtensionScannerInput(
-					pkg.version,
+					product.version,
 					product.commit,
 					locale,
 					!!process.env.VSCODE_DEV,
@@ -295,7 +294,7 @@ export class NodeProxyService implements INodeProxyService {
 	public readonly onClose = this._onClose.event;
 
 	public constructor() {
-		// TODO: close/down/up
+		// TODO: down/up
 		const { Server } = localRequire<typeof import("@coder/node-browser/out/server/server")>("@coder/node-browser/out/server/server");
 		this.server = new Server({
 			onMessage: this.$onMessage,

src/node/cli.ts

@@ -5,10 +5,9 @@ import { setUnexpectedErrorHandler } from "vs/base/common/errors";
 import { main as vsCli } from "vs/code/node/cliProcessMain";
 import { validatePaths } from "vs/code/node/paths";
 import { ParsedArgs } from "vs/platform/environment/common/environment";
-import { buildHelpMessage, buildVersionMessage, Option as VsOption, options as vsOptions } from "vs/platform/environment/node/argv";
+import { buildHelpMessage, buildVersionMessage, Option as VsOption, OPTIONS, OptionDescriptions } from "vs/platform/environment/node/argv";
 import { parseMainProcessArgv } from "vs/platform/environment/node/argvHelper";
-import pkg from "vs/platform/product/node/package";
-import product from "vs/platform/product/node/product";
+import product from "vs/platform/product/common/product";
 import { ipcMain } from "vs/server/src/node/ipc";
 import { enableCustomMarketplace } from "vs/server/src/node/marketplace";
 import { MainServer } from "vs/server/src/node/server";
@@ -24,7 +23,7 @@ interface Args extends ParsedArgs {
 	"cert-key"?: string;
 	format?: string;
 	host?: string;
-	open?: string;
+	open?: boolean;
 	port?: string;
 	socket?: string;
 }
@@ -35,14 +34,9 @@ interface Option extends VsOption {
 }
 
 const getArgs = (): Args => {
-	const options = vsOptions as Option[];
-	// The last item is _ which is like -- so our options need to come before it.
-	const last = options.pop()!;
-
 	// Remove options that won't work or don't make sense.
-	let i = options.length;
-	while (i--) {
-		switch (options[i].id) {
+	for (let key in OPTIONS) {
+		switch (key) {
 			case "add":
 			case "diff":
 			case "file-uri":
@@ -57,24 +51,21 @@ const getArgs = (): Args => {
 			case "prof-startup":
 			case "inspect-extensions":
 			case "inspect-brk-extensions":
-				options.splice(i, 1);
+				delete OPTIONS[key];
 				break;
 		}
 	}
 
-	options.push({ id: "base-path", type: "string", cat: "o", description: "Base path of the URL at which code-server is hosted (used for login redirects)." });
-	options.push({ id: "cert", type: "string", cat: "o", description: "Path to certificate. If the path is omitted, both this and --cert-key will be generated." });
-	options.push({ id: "cert-key", type: "string", cat: "o", description: "Path to the certificate's key if one was provided." });
-	options.push({ id: "extra-builtin-extensions-dir", type: "string", cat: "o", description: "Path to an extra builtin extension directory." });
-	options.push({ id: "extra-extensions-dir", type: "string", cat: "o", description: "Path to an extra user extension directory." });
-	options.push({ id: "format", type: "string", cat: "o", description: `Format for the version. ${buildAllowedMessage(FormatType)}.` });
-	options.push({ id: "host", type: "string", cat: "o", description: "Host for the server." });
-	options.push({ id: "auth", type: "string", cat: "o", description: `The type of authentication to use. ${buildAllowedMessage(AuthType)}.` });
-	options.push({ id: "open", type: "boolean", cat: "o", description: "Open in the browser on startup." });
-	options.push({ id: "port", type: "string", cat: "o", description: "Port for the main server." });
-	options.push({ id: "socket", type: "string", cat: "o", description: "Listen on a socket instead of host:port." });
-
-	options.push(last);
+	const options = OPTIONS as OptionDescriptions<Required<Args>>;
+	options["base-path"] = { type: "string", cat: "o", description: "Base path of the URL at which code-server is hosted (used for login redirects)." };
+	options["cert"] = { type: "string", cat: "o", description: "Path to certificate. If the path is omitted, both this and --cert-key will be generated." };
+	options["cert-key"] = { type: "string", cat: "o", description: "Path to the certificate's key if one was provided." };
+	options["format"] = { type: "string", cat: "o", description: `Format for the version. ${buildAllowedMessage(FormatType)}.` };
+	options["host"] = { type: "string", cat: "o", description: "Host for the server." };
+	options["auth"] = { type: "string", cat: "o", description: `The type of authentication to use. ${buildAllowedMessage(AuthType)}.` };
+	options["open"] = { type: "boolean", cat: "o", description: "Open in the browser on startup." };
+	options["port"] = { type: "string", cat: "o", description: "Port for the main server." };
+	options["socket"] = { type: "string", cat: "o", description: "Listen on a socket instead of host:port." };
 
 	const args = parseMainProcessArgv(process.argv);
 	if (!args["user-data-dir"]) {
@@ -84,6 +75,10 @@ const getArgs = (): Args => {
 		args["extensions-dir"] = path.join(args["user-data-dir"], "extensions");
 	}
 
+	if (!args.verbose && !args.log && process.env.LOG_LEVEL) {
+		args.log = process.env.LOG_LEVEL;
+	}
+
 	return validatePaths(args);
 };
 
@@ -161,19 +156,19 @@ const startCli = (): boolean | Promise<void> => {
 	const args = getArgs();
 	if (args.help) {
 		const executable = `${product.applicationName}${os.platform() === "win32" ? ".exe" : ""}`;
-		console.log(buildHelpMessage(product.nameLong, executable, pkg.codeServerVersion, undefined, false));
+		console.log(buildHelpMessage(product.nameLong, executable, product.codeServerVersion, OPTIONS, false));
 		return true;
 	}
 
 	if (args.version) {
 		if (args.format === "json") {
 			console.log(JSON.stringify({
-				codeServerVersion: pkg.codeServerVersion,
+				codeServerVersion: product.codeServerVersion,
 				commit: product.commit,
-				vscodeVersion: pkg.version,
+				vscodeVersion: product.version,
 			}));
 		} else {
-			buildVersionMessage(pkg.codeServerVersion, product.commit).split("\n").map((line) => logger.info(line));
+			buildVersionMessage(product.codeServerVersion, product.commit).split("\n").map((line) => logger.info(line));
 		}
 		return true;
 	}

src/node/marketplace.ts

@@ -5,7 +5,7 @@ import { CancellationToken } from "vs/base/common/cancellation";
 import { mkdirp } from "vs/base/node/pfs";
 import * as vszip from "vs/base/node/zip";
 import * as nls from "vs/nls";
-import product from "vs/platform/product/node/product";
+import product from "vs/platform/product/common/product";
 import { localRequire } from "vs/server/src/node/util";
 
 const tarStream = localRequire<typeof import("tar-stream")>("tar-stream/index");

src/node/nls.ts

@@ -3,7 +3,7 @@ import * as path from "path";
 import * as util from "util";
 import { getPathFromAmdModule } from "vs/base/common/amd";
 import * as lp from "vs/base/node/languagePacks";
-import product from "vs/platform/product/node/product";
+import product from "vs/platform/product/common/product";
 import { Translations } from "vs/workbench/services/extensions/common/extensionPoints";
 
 const configurations = new Map<string, Promise<lp.NLSConfiguration>>();
@@ -28,6 +28,12 @@ export const getNlsConfiguration = async (locale: string, userDataPath: string):
 			if (isInternalConfiguration(config)) {
 				config._languagePackSupport = true;
 			}
+			// If the configuration has no results keep trying since code-server
+			// doesn't restart when a language is installed so this result would
+			// persist (the plugin might not be installed yet or something).
+			if (config.locale !== "en" && config.locale !== "en-us" && Object.keys(config.availableLanguages).length === 0) {
+				configurations.delete(id);
+			}
 			resolve(config);
 		}));
 	}

src/node/server.ts

@@ -17,13 +17,12 @@ import { generateUuid } from "vs/base/common/uuid";
 import { getMachineId } from 'vs/base/node/id';
 import { NLSConfiguration } from "vs/base/node/languagePacks";
 import { mkdirp, rimraf } from "vs/base/node/pfs";
-import { ClientConnectionEvent, IPCServer, StaticRouter } from "vs/base/parts/ipc/common/ipc";
+import { ClientConnectionEvent, IPCServer } from "vs/base/parts/ipc/common/ipc";
+import { createChannelReceiver } from "vs/base/parts/ipc/node/ipc";
 import { LogsDataCleaner } from "vs/code/electron-browser/sharedProcess/contrib/logsDataCleaner";
 import { IConfigurationService } from "vs/platform/configuration/common/configuration";
 import { ConfigurationService } from "vs/platform/configuration/node/configurationService";
 import { ExtensionHostDebugBroadcastChannel } from "vs/platform/debug/common/extensionHostDebugIpc";
-import { IDialogService } from "vs/platform/dialogs/common/dialogs";
-import { DialogChannelClient } from "vs/platform/dialogs/node/dialogIpc";
 import { IEnvironmentService, ParsedArgs } from "vs/platform/environment/common/environment";
 import { EnvironmentService } from "vs/platform/environment/node/environmentService";
 import { ExtensionGalleryService } from "vs/platform/extensionManagement/common/extensionGalleryService";
@@ -38,13 +37,11 @@ import { InstantiationService } from "vs/platform/instantiation/common/instantia
 import { ServiceCollection } from "vs/platform/instantiation/common/serviceCollection";
 import { ILocalizationsService } from "vs/platform/localizations/common/localizations";
 import { LocalizationsService } from "vs/platform/localizations/node/localizations";
-import { LocalizationsChannel } from "vs/platform/localizations/node/localizationsIpc";
 import { getLogLevel, ILogService } from "vs/platform/log/common/log";
-import { LogLevelSetterChannel } from "vs/platform/log/common/logIpc";
+import { LoggerChannel } from "vs/platform/log/common/logIpc";
 import { SpdLogService } from "vs/platform/log/node/spdlogService";
-import { IProductService } from "vs/platform/product/common/product";
-import pkg from "vs/platform/product/node/package";
-import product from "vs/platform/product/node/product";
+import product from 'vs/platform/product/common/product';
+import { IProductService } from "vs/platform/product/common/productService";
 import { ConnectionType, ConnectionTypeRequest } from "vs/platform/remote/common/remoteAgentConnection";
 import { REMOTE_FILE_SYSTEM_CHANNEL_NAME } from "vs/platform/remote/common/remoteAgentFileSystemChannel";
 import { IRequestService } from "vs/platform/request/common/request";
@@ -56,14 +53,14 @@ import { ITelemetryServiceConfig, TelemetryService } from "vs/platform/telemetry
 import { combinedAppender, LogAppender, NullTelemetryService } from "vs/platform/telemetry/common/telemetryUtils";
 import { AppInsightsAppender } from "vs/platform/telemetry/node/appInsightsAppender";
 import { resolveCommonProperties } from "vs/platform/telemetry/node/commonProperties";
-import { UpdateChannel } from "vs/platform/update/node/updateIpc";
+import { UpdateChannel } from "vs/platform/update/electron-main/updateIpc";
+import { INodeProxyService, NodeProxyChannel } from "vs/server/src/common/nodeProxy";
+import { TelemetryChannel } from "vs/server/src/common/telemetry";
 import { ExtensionEnvironmentChannel, FileProviderChannel, NodeProxyService } from "vs/server/src/node/channel";
 import { Connection, ExtensionHostConnection, ManagementConnection } from "vs/server/src/node/connection";
 import { TelemetryClient } from "vs/server/src/node/insights";
 import { getLocaleFromConfig, getNlsConfiguration } from "vs/server/src/node/nls";
-import { NodeProxyChannel, INodeProxyService } from "vs/server/src/common/nodeProxy";
 import { Protocol } from "vs/server/src/node/protocol";
-import { TelemetryChannel } from "vs/server/src/common/telemetry";
 import { UpdateService } from "vs/server/src/node/update";
 import { AuthType, getMediaMime, getUriTransformer, localRequire, tmpdir } from "vs/server/src/node/util";
 import { RemoteExtensionLogFileName } from "vs/workbench/services/remote/common/remoteAgentService";
@@ -82,8 +79,9 @@ export enum HttpCode {
 }
 
 export interface Options {
-	WORKBENCH_WEB_CONGIGURATION: IWorkbenchConstructionOptions;
+	WORKBENCH_WEB_CONFIGURATION: IWorkbenchConstructionOptions & { folderUri?: UriComponents, workspaceUri?: UriComponents };
 	REMOTE_USER_DATA_URI: UriComponents | URI;
+	PRODUCT_CONFIGURATION: Partial<IProductService>;
 	NLS_CONFIGURATION: NLSConfiguration;
 }
 
@@ -280,7 +278,7 @@ export abstract class Server {
 		// without adding query parameters which have their own issues.
 		// REVIEW: Discuss whether this is the best option; this is sort of a quick
 		// hack almost to get caching in the meantime but it does work pretty well.
-		if (/^\/static-.+/.test(base)) {
+		if (/^\/static-/.test(base)) {
 			base = "/static";
 		}
 
@@ -361,7 +359,7 @@ export abstract class Server {
 			if (this.authenticate(request, data)) {
 				return {
 					redirect: "/",
-					headers: {"Set-Cookie": `password=${data.password}` }
+					headers: { "Set-Cookie": `password=${data.password}` }
 				};
 			}
 			console.error("Failed login attempt", JSON.stringify({
@@ -538,7 +536,7 @@ export class MainServer extends Server {
 	}
 
 	private async getRoot(request: http.IncomingMessage, parsedUrl: url.UrlWithParsedQuery): Promise<Response> {
-		const filePath = path.join(this.rootPath, "out/vs/code/browser/workbench/workbench.html");
+		const filePath = path.join(this.rootPath, "out/vs/server/src/browser/workbench.html");
 		let [content, startPath] = await Promise.all([
 			util.promisify(fs.readFile)(filePath, "utf8"),
 			this.getFirstValidPath([
@@ -567,17 +565,20 @@ export class MainServer extends Server {
 
 		const environment = this.services.get(IEnvironmentService) as IEnvironmentService;
 		const options: Options = {
-			WORKBENCH_WEB_CONGIGURATION: {
+			WORKBENCH_WEB_CONFIGURATION: {
 				workspaceUri: startPath && startPath.workspace ? transformer.transformOutgoing(startPath.uri) : undefined,
 				folderUri: startPath && !startPath.workspace ? transformer.transformOutgoing(startPath.uri) : undefined,
 				remoteAuthority,
-				productConfiguration: product,
+				logLevel: getLogLevel(environment),
+			},
+			REMOTE_USER_DATA_URI: transformer.transformOutgoing(URI.file(environment.userDataPath)),
+			PRODUCT_CONFIGURATION: {
+				extensionsGallery: product.extensionsGallery,
 			},
-			REMOTE_USER_DATA_URI: transformer.transformOutgoing((<EnvironmentService>environment).webUserDataHome),
 			NLS_CONFIGURATION: await getNlsConfiguration(environment.args.locale || await getLocaleFromConfig(environment.userDataPath), environment.userDataPath),
 		};
 
-		content = content.replace(/\/static\//g, `/static${product.commit ? `-${product.commit}` : ""}/`).replace("{{WEBVIEW_ENDPOINT}}", "");
+		content = content.replace(/{{COMMIT}}/g, product.commit || "");
 		for (const key in options) {
 			content = content.replace(`"{{${key}}}"`, `'${JSON.stringify(options[key as keyof Options])}'`);
 		}
@@ -698,17 +699,15 @@ export class MainServer extends Server {
 			...environmentService.extraBuiltinExtensionPaths,
 		);
 
-		this.ipc.registerChannel("loglevel", new LogLevelSetterChannel(logService));
+		this.ipc.registerChannel("logger", new LoggerChannel(logService));
 		this.ipc.registerChannel(ExtensionHostDebugBroadcastChannel.ChannelName, new ExtensionHostDebugBroadcastChannel());
 
-		const router = new StaticRouter((ctx: any) => ctx.clientId === "renderer");
 		this.services.set(ILogService, logService);
 		this.services.set(IEnvironmentService, environmentService);
 		this.services.set(IConfigurationService, new SyncDescriptor(ConfigurationService, [environmentService.machineSettingsResource]));
 		this.services.set(IRequestService, new SyncDescriptor(RequestService));
 		this.services.set(IFileService, fileService);
 		this.services.set(IProductService, { _serviceBrand: undefined, ...product });
-		this.services.set(IDialogService, new DialogChannelClient(this.ipc.getChannel("dialog", router)));
 		this.services.set(IExtensionGalleryService, new SyncDescriptor(ExtensionGalleryService));
 		this.services.set(IExtensionManagementService, new SyncDescriptor(ExtensionManagementService));
 
@@ -719,7 +718,7 @@ export class MainServer extends Server {
 					new LogAppender(logService),
 				),
 				commonProperties: resolveCommonProperties(
-					product.commit, pkg.codeServerVersion, await getMachineId(),
+					product.commit, product.codeServerVersion, await getMachineId(),
 					[], environmentService.installSourcePath, "code-server",
 				),
 				piiPaths: this.allowedRequestPaths,
@@ -730,32 +729,25 @@ export class MainServer extends Server {
 
 		await new Promise((resolve) => {
 			const instantiationService = new InstantiationService(this.services);
-			const localizationService = instantiationService.createInstance(LocalizationsService);
-			this.services.set(ILocalizationsService, localizationService);
-			const proxyService = instantiationService.createInstance(NodeProxyService);
-			this.services.set(INodeProxyService, proxyService);
-			this.ipc.registerChannel("localizations", new LocalizationsChannel(localizationService));
+			this.services.set(ILocalizationsService, instantiationService.createInstance(LocalizationsService));
+			this.services.set(INodeProxyService, instantiationService.createInstance(NodeProxyService));
+
 			instantiationService.invokeFunction(() => {
 				instantiationService.createInstance(LogsDataCleaner);
-
-				const extensionsService = this.services.get(IExtensionManagementService) as IExtensionManagementService;
 				const telemetryService = this.services.get(ITelemetryService) as ITelemetryService;
-
-				const extensionsChannel = new ExtensionManagementChannel(extensionsService, (context) => getUriTransformer(context.remoteAuthority));
-				const extensionsEnvironmentChannel = new ExtensionEnvironmentChannel(environmentService, logService, telemetryService, this.options.connectionToken || "");
-				const fileChannel = new FileProviderChannel(environmentService, logService);
-				const requestChannel = new RequestChannel(this.services.get(IRequestService) as IRequestService);
-				const telemetryChannel = new TelemetryChannel(telemetryService);
-				const updateChannel = new UpdateChannel(instantiationService.createInstance(UpdateService));
-				const nodeProxyChannel = new NodeProxyChannel(proxyService);
-
-				this.ipc.registerChannel("extensions", extensionsChannel);
-				this.ipc.registerChannel("remoteextensionsenvironment", extensionsEnvironmentChannel);
-				this.ipc.registerChannel("request", requestChannel);
-				this.ipc.registerChannel("telemetry", telemetryChannel);
-				this.ipc.registerChannel("nodeProxy", nodeProxyChannel);
-				this.ipc.registerChannel("update", updateChannel);
-				this.ipc.registerChannel(REMOTE_FILE_SYSTEM_CHANNEL_NAME, fileChannel);
+				this.ipc.registerChannel("extensions", new ExtensionManagementChannel(
+					this.services.get(IExtensionManagementService) as IExtensionManagementService,
+					(context) => getUriTransformer(context.remoteAuthority),
+				));
+				this.ipc.registerChannel("remoteextensionsenvironment", new ExtensionEnvironmentChannel(
+					environmentService, logService, telemetryService, this.options.connectionToken || "",
+				));
+				this.ipc.registerChannel("request", new RequestChannel(this.services.get(IRequestService) as IRequestService));
+				this.ipc.registerChannel("telemetry", new TelemetryChannel(telemetryService));
+				this.ipc.registerChannel("nodeProxy", new NodeProxyChannel(this.services.get(INodeProxyService) as INodeProxyService));
+				this.ipc.registerChannel("localizations", createChannelReceiver(this.services.get(ILocalizationsService) as ILocalizationsService));
+				this.ipc.registerChannel("update", new UpdateChannel(instantiationService.createInstance(UpdateService)));
+				this.ipc.registerChannel(REMOTE_FILE_SYSTEM_CHANNEL_NAME, new FileProviderChannel(environmentService, logService));
 				resolve(new ErrorTelemetry(telemetryService));
 			});
 		});

src/node/update.ts

@@ -11,9 +11,9 @@ import { IConfigurationService } from "vs/platform/configuration/common/configur
 import { IEnvironmentService } from "vs/platform/environment/common/environment";
 import { IFileService } from "vs/platform/files/common/files";
 import { ILogService } from "vs/platform/log/common/log";
-import pkg from "vs/platform/product/node/package";
+import product from "vs/platform/product/common/product";
 import { asJson, IRequestService } from "vs/platform/request/common/request";
-import { AvailableForDownload, State, StateType, UpdateType } from "vs/platform/update/common/update";
+import { AvailableForDownload, State, UpdateType } from "vs/platform/update/common/update";
 import { AbstractUpdateService } from "vs/platform/update/electron-main/abstractUpdateService";
 import { ipcMain } from "vs/server/src/node/ipc";
 import { extract } from "vs/server/src/node/marketplace";
@@ -43,25 +43,22 @@ export class UpdateService extends AbstractUpdateService {
 		}
 		if (latest) {
 			const latestMajor = parseInt(latest.name);
-			const currentMajor = parseInt(pkg.codeServerVersion);
+			const currentMajor = parseInt(product.codeServerVersion);
 			return !isNaN(latestMajor) && !isNaN(currentMajor) &&
-				currentMajor <= latestMajor && latest.name === pkg.codeServerVersion;
+				currentMajor <= latestMajor && latest.name === product.codeServerVersion;
 		}
 		return true;
 	}
 
-	protected buildUpdateFeedUrl(): string {
-		return "https://api.github.com/repos/cdr/code-server/releases/latest";
+	protected buildUpdateFeedUrl(quality: string): string {
+		return `${product.updateUrl}/${quality}`;
 	}
 
-	protected doQuitAndInstall(): void {
+	public async doQuitAndInstall(): Promise<void> {
 		ipcMain.relaunch();
 	}
 
 	protected async doCheckForUpdates(context: any): Promise<void> {
-		if (this.state.type !== StateType.Idle) {
-			return Promise.resolve();
-		}
 		this.setState(State.CheckingForUpdates(context));
 		try {
 			const update = await this.getLatestVersion();
@@ -81,15 +78,13 @@ export class UpdateService extends AbstractUpdateService {
 	private async getLatestVersion(): Promise<IUpdate | null> {
 		const data = await this.requestService.request({
 			url: this.url,
-			headers: {
-				"User-Agent": "code-server",
-			},
+			headers: { "User-Agent": "code-server" },
 		}, CancellationToken.None);
 		return asJson(data);
 	}
 
 	protected async doDownloadUpdate(state: AvailableForDownload): Promise<void> {
-		this.setState(State.Updating(state.update));
+		this.setState(State.Downloading(state.update));
 		const target = os.platform();
 		const releaseName = await this.buildReleaseName(state.update.version);
 		const url = "https://github.com/cdr/code-server/releases/download/"
@@ -125,8 +120,7 @@ export class UpdateService extends AbstractUpdateService {
 
 	private onRequestError(error: Error, showNotification?: boolean): void {
 		this.logService.error(error);
-		const message: string | undefined = showNotification ? (error.message || error.toString()) : undefined;
-		this.setState(State.Idle(UpdateType.Archive, message));
+		this.setState(State.Idle(UpdateType.Archive, showNotification ? (error.message || error.toString()) : undefined));
 	}
 
 	private async buildReleaseName(release: string): Promise<string> {
@@ -136,7 +130,7 @@ export class UpdateService extends AbstractUpdateService {
 				stderr: error.message,
 				stdout: "",
 			}));
-			if (result.stderr.indexOf("musl") !== -1 || result.stdout.indexOf("musl") !== -1) {
+			if (/^musl/.test(result.stderr) || /^musl/.test(result.stdout)) {
 				target = "alpine";
 			}
 		}

yarn.lock

@@ -18,10 +18,10 @@
     node-fetch "^2.3.0"
     ora "^3.2.0"
 
-"@coder/node-browser@^1.0.5":
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/@coder/node-browser/-/node-browser-1.0.5.tgz#58275041cbe11808574260bb2f41db3965388f88"
-  integrity sha512-9iN6RqJCErlp30Da/PJBGf8YT9phSTCtCgoufDQqSkSMmnV+Oho4nkFKPKB3jVb9RG5lqgi7oJpNMSXPluvlyw==
+"@coder/node-browser@^1.0.6":
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/@coder/node-browser/-/node-browser-1.0.6.tgz#8db01974322ec63b6df62b8b7b1b3b58dc4a034e"
+  integrity sha512-+DXWyXSiOZ6aU+V4XYa74jT+LeQE4UumWO0Mff6HAWzZmbBn3cqibmAx/qz99aBJfD3nQ1HGHf8/Ad/AgW/quw==
 
 "@coder/requirefs@^1.0.6":
   version "1.0.6"
@@ -30,6 +30,13 @@
   optionalDependencies:
     jszip "2.6.0"
 
+"@types/fs-extra@^8.0.1":
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/@types/fs-extra/-/fs-extra-8.0.1.tgz#a2378d6e7e8afea1564e44aafa2e207dadf77686"
+  integrity sha512-J00cVDALmi/hJOYsunyT52Hva5TnJeKP5yd1r+mH/ZU0mbYZflR0Z5kw5kITtKTRYMhm1JMClOFYdHnQszEvqw==
+  dependencies:
+    "@types/node" "*"
+
 "@types/node@*", "@types/node@^10.12.12":
   version "10.14.12"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-10.14.12.tgz#0eec3155a46e6c4db1f27c3e588a205f767d622f"
@@ -116,6 +123,11 @@ are-we-there-yet@~1.1.2:
     delegates "^1.0.0"
     readable-stream "^2.0.6"
 
+arg@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.1.tgz#485f8e7c390ce4c5f78257dbea80d4be11feda4c"
+  integrity sha512-SlmP3fEA88MBv0PypnXZ8ZfJhwmDeIE3SP71j37AiXQBXYosPV0x6uISAaHYSlSVhmHOVkomen0tbGk6Anlebw==
+
 arr-diff@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
@@ -236,6 +248,11 @@ buffer-fill@^1.0.0:
   resolved "https://registry.yarnpkg.com/buffer-fill/-/buffer-fill-1.0.0.tgz#f8f78b76789888ef39f205cd637f68e702122b2c"
   integrity sha1-+PeLdniYiO858gXNY39o5wISKyw=
 
+buffer-from@^1.0.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
+  integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
+
 cache-base@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
@@ -494,6 +511,11 @@ detect-libc@^1.0.2:
   resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-1.0.3.tgz#fa137c4bd698edf55cd5cd02ac559f91a4c4ba9b"
   integrity sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=
 
+diff@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.1.tgz#0c667cb467ebbb5cea7f14f135cc2dba7780a8ff"
+  integrity sha512-s2+XdvhPCOF01LRQBC8hf4vhbVmI2CGS5aZnxLJlT5FtdhPCDFq80q++zK2KlrVorVDdL5BOGZ/VfLrVtYNF+Q==
+
 dot-prop@^4.1.0:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-4.2.0.tgz#1f19e0c2e1aa0e32797c49799f2837ac6af69c57"
@@ -639,6 +661,15 @@ fs-extra@^7.0.1:
     jsonfile "^4.0.0"
     universalify "^0.1.0"
 
+fs-extra@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0"
+  integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
+  dependencies:
+    graceful-fs "^4.2.0"
+    jsonfile "^4.0.0"
+    universalify "^0.1.0"
+
 fs-minipass@^1.2.5:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.5.tgz#06c277218454ec288df77ada54a03b8702aacb9d"
@@ -737,7 +768,7 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.2:
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.15.tgz#ffb703e1066e8a0eeaa4c8b80ba9253eeefbfb00"
   integrity sha512-6uHUhOPEBgQ24HM+r6b/QwWfZq+yiFcipKFrOFiBEnWdy5sdzYoi+pJeQaPI5qOLRFqWmAXUPQNsielzdLoecA==
 
-graceful-fs@^4.1.6:
+graceful-fs@^4.1.6, graceful-fs@^4.2.0:
   version "4.2.2"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.2.tgz#6f0952605d0140c1cfdb138ed005775b92d67b02"
   integrity sha512-IItsdsea19BoLC7ELy13q1iJFNmd7ofZH5+X/pJr90/nRoPEX0DJo1dHDbgtYWOhJhcCgMDTOw84RZ72q6lB+Q==
@@ -1142,6 +1173,11 @@ make-dir@^1.0.0:
   dependencies:
     pify "^3.0.0"
 
+make-error@^1.1.1:
+  version "1.3.5"
+  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.5.tgz#efe4e81f6db28cadd605c70f29c831b58ef776c8"
+  integrity sha512-c3sIjNUow0+8swNwVpqoH4YCShKNFkMaw6oH1mNS2haDZQqkeZFlHS3dhoeEbKKmJB4vXpJucU6oH75aDYeE9g==
+
 map-cache@^0.2.2:
   version "0.2.2"
   resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
@@ -1792,6 +1828,14 @@ source-map-resolve@^0.5.0:
     source-map-url "^0.4.0"
     urix "^0.1.0"
 
+source-map-support@^0.5.6:
+  version "0.5.13"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932"
+  integrity sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
 source-map-url@^0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"
@@ -1802,6 +1846,11 @@ source-map@^0.5.6:
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
 
+source-map@^0.6.0:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
 split-string@^3.0.1, split-string@^3.0.2:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
@@ -1980,6 +2029,17 @@ touch@^3.1.0:
   dependencies:
     nopt "~1.0.10"
 
+ts-node@^8.4.1:
+  version "8.4.1"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-8.4.1.tgz#270b0dba16e8723c9fa4f9b4775d3810fd994b4f"
+  integrity sha512-5LpRN+mTiCs7lI5EtbXmF/HfMeCjzt7DH9CZwtkr6SywStrNQC723wG+aOWFiLNn7zT3kD/RnFqi3ZUfr4l5Qw==
+  dependencies:
+    arg "^4.1.0"
+    diff "^4.0.1"
+    make-error "^1.1.1"
+    source-map-support "^0.5.6"
+    yn "^3.0.0"
+
 undefsafe@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/undefsafe/-/undefsafe-2.0.2.tgz#225f6b9e0337663e0d8e7cfd686fc2836ccace76"
@@ -2132,3 +2192,8 @@ yallist@^3.0.0, yallist@^3.0.2:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.0.3.tgz#b4b049e314be545e3ce802236d6cd22cd91c3de9"
   integrity sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A==
+
+yn@^3.0.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==