Enable password authentication by default

Fixes #1062.

.gitignore

@@ -1,3 +1,5 @@
 node_modules
 build
 release
+binaries
+source

.travis.yml

@@ -1,49 +1,73 @@
 language: node_js
 node_js:
-- 10.16.0
+  - 10.16.0
 services:
-- docker
-matrix:
-  include:
-  - os: linux
-    dist: trusty
-    env:
-      - VSCODE_VERSION="1.38.1" MAJOR_VERSION="2" VERSION="$MAJOR_VERSION.$TRAVIS_BUILD_NUMBER" TARGET="linux"
-  - os: linux
-    dist: trusty
-    env:
-      - VSCODE_VERSION="1.38.1" MAJOR_VERSION="2" VERSION="$MAJOR_VERSION.$TRAVIS_BUILD_NUMBER" TARGET="alpine"
-  - os: osx
-    env:
-      - VSCODE_VERSION="1.38.1" MAJOR_VERSION="2" VERSION="$MAJOR_VERSION.$TRAVIS_BUILD_NUMBER"
+  - docker
+
 before_install:
-- if [[ "$TRAVIS_BRANCH" == "master" ]]; then export MINIFY="true"; fi
-- if [[ "$TRAVIS_BRANCH" == "master" ]]; then export PACKAGE="true"; fi
-script:
-- travis_wait 30 scripts/ci.bash
+  - export MAJOR_VERSION="2"
+  - 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
+  - if [[ "$TRAVIS_BRANCH" == "master" ]]; then export PACKAGE="true"; fi
+
+# Don't build on tags because we'll already have built the commit.
+jobs:
+  include:
+    - name: "Linux build"
+      os: linux
+      dist: trusty
+      env: TARGET="linux" PUSH_DOCKER="true"
+      if: tag IS blank
+      script: scripts/ci.bash
+    - name: "Alpine build"
+      os: linux
+      dist: trusty
+      env: TARGET="alpine"
+      if: tag IS blank
+      script: scripts/ci.bash
+    - name: "MacOS build"
+      os: osx
+      if: tag IS blank
+      script: travis_wait 40 scripts/ci.bash
+
+git:
+  depth: 3
+
 before_deploy:
-- echo "$VERSION-vsc$VSCODE_VERSION" "$TRAVIS_COMMIT"
-- git config --local user.name "$USER_NAME"
-- git config --local user.email "$USER_EMAIL"
-- git tag "$VERSION-vsc$VSCODE_VERSION" "$TRAVIS_COMMIT"
+  - echo "$TAG" "$TRAVIS_COMMIT"
+  - git config --local user.name "$USER_NAME"
+  - git config --local user.email "$USER_EMAIL"
+  - if ! git tag "$TAG" "$TRAVIS_COMMIT" ; then echo "$TAG already exists"; fi
+  - if [[ -n "$PUSH_DOCKER" ]] ; then echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin ; fi
+
 deploy:
-  provider: releases
-  file_glob: true
-  draft: true
-  tag_name: "$VERSION-vsc$VSCODE_VERSION"
-  target_commitish: "$TRAVIS_COMMIT"
-  name: "$VERSION-vsc$VSCODE_VERSION"
-  skip_cleanup: true
-  api_key:
-    secure: YL/x24KjYjgYXPcJWk3FV7FGxI79Mh6gBECQEcdlf3fkLEoKFVgzHBoUNWrFPzyR4tgLyWNAgcpD9Lkme1TRWTom7UPjXcwMNyLcLa+uec7ciSAnYD9ntLTpiCuPDD1u0LtRGclSi/EHQ+F8YVq+HZJpXTsJeAmOmihma3GVbGKSZr+BRum+0YZSG4w+o4TOlYzw/4bLWS52MogZcwpjd+hemBbgXLuGU2ziKv2vEKCZFbEeA16II4x1WLI4mutDdCeh7+3aLzGLwDa49NxtsVYNjyNFF75JhCTCNA55e2YMiLz9Uq69IXe/mi5F7xUaFfhIqqLNyKBnKeEOzu3dYnc+8n3LjnQ+00PmkF05nx9kBn3UfV1kwQGh6QbyDmTtBP07rtUMyI14aeQqHjxsaVRdMnwj9Q2DjXRr8UDqESZF0rmK3pHCXS2fBhIzLE8tLVW5Heiba2pQRFMHMZW+KBE97FzcFh7is90Ait3T8enfcd/PWFPYoBejDAdjwxwOkezh5N5ZkYquEfDYuWrFi6zRFCktsruaAcA+xGtTf9oilBBzUqu8Ie+YFWH5me83xakcblJWdaW/D2rLJAJH3m6LFm8lBqyUgDX5t/etob6CpDuYHu5D1J3XINOj/+aLAcadq6qlh70PMZS3zYffUu3JlzaD2amlSHIT8b5YXFc=
-  file:
-    - release/*.tar.gz
-    - release/*.zip
-  on:
-    repo: cdr/code-server
-    branch: master
+  - provider: releases
+    file_glob: true
+    draft: true
+    tag_name: "$TAG"
+    target_commitish: "$TRAVIS_COMMIT"
+    name: "$TAG"
+    skip_cleanup: true
+    api_key:
+      secure: YL/x24KjYjgYXPcJWk3FV7FGxI79Mh6gBECQEcdlf3fkLEoKFVgzHBoUNWrFPzyR4tgLyWNAgcpD9Lkme1TRWTom7UPjXcwMNyLcLa+uec7ciSAnYD9ntLTpiCuPDD1u0LtRGclSi/EHQ+F8YVq+HZJpXTsJeAmOmihma3GVbGKSZr+BRum+0YZSG4w+o4TOlYzw/4bLWS52MogZcwpjd+hemBbgXLuGU2ziKv2vEKCZFbEeA16II4x1WLI4mutDdCeh7+3aLzGLwDa49NxtsVYNjyNFF75JhCTCNA55e2YMiLz9Uq69IXe/mi5F7xUaFfhIqqLNyKBnKeEOzu3dYnc+8n3LjnQ+00PmkF05nx9kBn3UfV1kwQGh6QbyDmTtBP07rtUMyI14aeQqHjxsaVRdMnwj9Q2DjXRr8UDqESZF0rmK3pHCXS2fBhIzLE8tLVW5Heiba2pQRFMHMZW+KBE97FzcFh7is90Ait3T8enfcd/PWFPYoBejDAdjwxwOkezh5N5ZkYquEfDYuWrFi6zRFCktsruaAcA+xGtTf9oilBBzUqu8Ie+YFWH5me83xakcblJWdaW/D2rLJAJH3m6LFm8lBqyUgDX5t/etob6CpDuYHu5D1J3XINOj/+aLAcadq6qlh70PMZS3zYffUu3JlzaD2amlSHIT8b5YXFc=
+    file:
+      - release/*.tar.gz
+      - release/*.zip
+    on:
+      repo: cdr/code-server
+      branch: master
+
+  - provider: script
+    skip_cleanup: true
+    script: docker build -f ./scripts/ci.dockerfile -t codercom/code-server:"$TAG" -t codercom/code-server:v2 . && docker push codercom/code-server:"$TAG" && docker push codercom/code-server:v2
+    on:
+      repo: cdr/code-server
+      branch: master
+      condition: -n "$PUSH_DOCKER"
+
 cache:
   yarn: true
-  timeout: 1000
   directories:
-  - .cache
+    - source

Dockerfile

@@ -1,6 +1,7 @@
 FROM node:10.16.0
 ARG codeServerVersion=docker
 ARG vscodeVersion
+ARG githubToken
 
 # Install VS Code's deps. These are the only two it seems we need.
 RUN apt-get update && apt-get install -y \
@@ -14,11 +15,11 @@ WORKDIR /src
 COPY . .
 
 RUN yarn \
-	&& MINIFY=true yarn build "${vscodeVersion}" "${codeServerVersion}" \
+	&& MINIFY=true GITHUB_TOKEN="${githubToken}" yarn build "${vscodeVersion}" "${codeServerVersion}" \
 	&& yarn binary "${vscodeVersion}" "${codeServerVersion}" \
-	&& mv "/src/build/code-server${codeServerVersion}-vsc${vscodeVersion}-linux-x86_64-built/code-server${codeServerVersion}-vsc${vscodeVersion}-linux-x86_64" /src/build/code-server \
-	&& rm -r /src/build/vscode-* \
-	&& rm -r /src/build/code-server*-linux-*
+	&& mv "/src/binaries/code-server${codeServerVersion}-vsc${vscodeVersion}-linux-x86_64" /src/binaries/code-server \
+	&& rm -r /src/build \
+	&& rm -r /src/source
 
 # We deploy with ubuntu so that devs have a familiar environment.
 FROM ubuntu:18.04
@@ -37,7 +38,8 @@ RUN apt-get update && apt-get install -y \
 RUN locale-gen en_US.UTF-8
 # We cannot use update-locale because docker will not use the env variables
 # configured in /etc/default/locale so we need to set it manually.
-ENV LC_ALL=en_US.UTF-8
+ENV LC_ALL=en_US.UTF-8 \
+	SHELL=/bin/bash
 
 RUN adduser --gecos '' --disabled-password coder && \
 	echo "coder ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers.d/nopasswd
@@ -53,7 +55,7 @@ WORKDIR /home/coder/project
 # mount. So that they do not lose their data if they delete the container.
 VOLUME [ "/home/coder/project" ]
 
-COPY --from=0 /src/build/code-server /usr/local/bin/code-server
+COPY --from=0 /src/binaries/code-server /usr/local/bin/code-server
 EXPOSE 8080
 
 ENTRYPOINT ["dumb-init", "code-server", "--host", "0.0.0.0"]

README.md

@@ -4,8 +4,9 @@
 remote server, accessible through the browser.
 
 Try it out:
+
 ```bash
-docker run -it -p 127.0.0.1:8080:8080 -v "${HOME}/.local/share/code-server:/home/coder/.local/share/code-server" -v "$PWD:/home/coder/project" codercom/code-server
+docker run -it -p 127.0.0.1:8080:8080 -v "${HOME}/.local/share/code-server:/home/coder/.local/share/code-server" -v "$PWD:/home/coder/project" codercom/code-server:v2
 ```
 
 - **Consistent environment:** Code on your Chromebook, tablet, and laptop with a
@@ -18,10 +19,21 @@ docker run -it -p 127.0.0.1:8080:8080 -v "${HOME}/.local/share/code-server:/home
 ![Screenshot](/doc/assets/ide.gif)
 
 ## Getting Started
+
+### Requirements
+
+- Minimum GLIBC version of 2.17 and a minimum version of GLIBCXX of 3.4.15.
+  - This is the main requirement for building Visual Studio Code. We cannot go lower than this.
+- A 64-bit host with at least 1GB RAM and 2 cores.
+  - 1 core hosts would work but not optimally.
+- Docker (for Docker versions of `code-server`).
+
 ### Run over SSH
+
 Use [sshcode](https://github.com/codercom/sshcode) for a simple setup.
 
 ### Docker
+
 See the Docker one-liner mentioned above. Dockerfile is at [/Dockerfile](/Dockerfile).
 
 To debug Golang using the
@@ -31,11 +43,13 @@ arguments when launching code-server with Docker. See
 [#725](https://github.com/cdr/code-server/issues/725) for details.
 
 ### Digital Ocean
+
 [![Create a Droplet](./doc/assets/droplet.svg)](https://marketplace.digitalocean.com/apps/code-server?action=deploy)
 
 ### Binaries
+
 1. [Download a binary](https://github.com/cdr/code-server/releases). (Linux and
-    OS X supported. Windows coming soon)
+   OS X supported. Windows coming soon)
 2. Unpack the downloaded file then run the binary.
 3. In your browser navigate to `localhost:8080`.
 
@@ -43,23 +57,53 @@ arguments when launching code-server with Docker. See
 - For hosting on cloud platforms see [doc/deploy.md](doc/deploy.md).
 
 ### Build
-- If you also plan on developing, set the `OUT` environment variable. Otherwise
-  it will build in this directory which will cause issues because `yarn watch`
-  will try to compile the build directory as well.
-- Run `yarn build ${vscodeVersion} ${codeServerVersion}` in this directory (for
-  example: `yarn build 1.36.0 development`).
-- If you target the same VS Code version our Travis builds do everything will
-  work but if you target some other version it might not (we have to do some
-  patching to VS Code so different versions aren't always compatible).
-- You can run the built code with `node path/to/build/out/vs/server/main.js` or run
-  `yarn binary` with the same arguments in the previous step to package the
-  code into a single binary.
+
+See
+[VS Code prerequisites](https://github.com/Microsoft/vscode/wiki/How-to-Contribute#prerequisites)
+before building.
+
+```shell
+export OUT=/path/to/output/build                  # Optional if only building. Required if also developing.
+yarn build ${vscodeVersion} ${codeServerVersion}  # See travis.yml for the VS Code version to use.
+                                                  # The code-server version can be anything you want.
+node ~/path/to/output/build/out/vs/server/main.js # You can run the built JavaScript with Node.
+yarn binary ${vscodeVersion} ${codeServerVersion} # Or you can package it into a binary.
+```
+
+## Security
+
+### Authentication
+By default `code-server` enables password authentication using a randomly
+generated password. You can set the `PASSWORD` environment variable to use your
+own instead or use `--auth none` to disable password authentication.
+
+Do not expose `code-server` to the open internet without some form of
+authentication.
+
+### Encrypting traffic with HTTPS
+If you aren't doing SSL termination elsewhere you can directly give
+`code-server` a certificate with `code-server --cert` followed by the path to
+your certificate. Additionally, you can use certificate keys with `--cert-key`
+followed by the path to your key. If you pass `--cert` without any path
+`code-server` will generate a self-signed certificate.
+
+If `code-server` has been passed a certificate it will also respond to HTTPS
+requests and will redirect all HTTP requests to HTTPS. Otherwise it will respond
+only to HTTP requests.
+
+You can use [Let's Encrypt](https://letsencrypt.org/) to get an SSL certificate
+for free.
+
+Do not expose `code-server` to the open internet without SSL, whether built-in
+or through a proxy.
 
 ## Known Issues
+
 - Creating custom VS Code extensions and debugging them doesn't work.
 - Extension profiling and tips are currently disabled.
 
 ## Future
+
 - **Stay up to date!** Get notified about new releases of code-server.
   ![Screenshot](/doc/assets/release.gif)
 - Windows support.
@@ -67,26 +111,41 @@ arguments when launching code-server with Docker. See
 - Run VS Code unit tests against our builds to ensure features work as expected.
 
 ## Extensions
-At the moment we can't use the official VS Code Marketplace. We've created a
-custom extension marketplace focused around open-sourced extensions. However,
-you can manually download the extension to your extensions directory. It's also
-possible to set your own marketplace URLs by setting the `SERVICE_URL` and
-`ITEM_URL` environment variables.
+
+code-server does not provide access to the official
+[Visual Studio Marketplace](https://marketplace.visualstudio.com/vscode). Instead,
+Coder has created a custom extension marketplace that we manage for open-source
+extensions. If you want to use an extension with code-server that we do not have
+in our marketplace please look for a release in the extension’s repository,
+contact us to see if we have one in the works or, if you build an extension
+locally from open source, you can copy it to the `extensions` folder. If you
+build one locally from open-source please contribute it to the project and let
+us know so we can give you props! If you have your own custom marketplace, it is
+possible to point code-server to it by setting the `SERVICE_URL` and `ITEM_URL`
+environment variables.
 
 ## Telemetry
+
 Use the `--disable-telemetry` flag to completely disable telemetry. We use the
 data collected to improve code-server.
 
 ## Contributing
+
 ### Development
+
+See
+[VS Code prerequisites](https://github.com/Microsoft/vscode/wiki/How-to-Contribute#prerequisites)
+before developing.
+
 ```shell
 git clone https://github.com/microsoft/vscode
 cd vscode
-git checkout <see travis.yml for the VS Code version to use here>
+git checkout ${vscodeVersion} # See travis.yml for the version to use.
+yarn
 git clone https://github.com/cdr/code-server src/vs/server
 cd src/vs/server
-yarn patch:apply
 yarn
+yarn patch:apply
 yarn watch
 # Wait for the initial compilation to complete (it will say "Finished compilation").
 # Run the next command in another shell.
@@ -99,6 +158,7 @@ If you run into issues about a different version of Node being used, try running
 `vscode-ripgrep`.
 
 ### Upgrading VS Code
+
 We patch VS Code to provide and fix some functionality. As the web portion of VS
 Code matures, we'll be able to shrink and maybe even entirely eliminate our
 patch. In the meantime, however, upgrading the VS Code version requires ensuring
@@ -109,26 +169,30 @@ the patch in the VS Code source, then run `yarn patch:generate` in this
 directory.
 
 Our changes include:
+
 - Change the remote schema to `code-server`.
 - Allow multiple extension directories (both user and built-in).
 - Modify the loader, websocket, webview, service worker, and asset requests to
   use the URL of the page as a base (and TLS if necessary for the websocket).
-- Send client-side telemetry through the server and get the initial log level
-  from the server.
-- Add an upload service for use in editor windows and the explorer along with a
-  file prefix to ignore for temporary files created during upload.
+- Send client-side telemetry through the server.
+- Add an upload service along with a file prefix to ignore for temporary files
+  created during upload.
 - Make changing the display language work.
-- Make hiding or toggling the menu bar possible.
 - Make it possible for us to load code on the client.
-- Modify the build process to include our code.
+- Make extensions work in the browser.
+- Fix getting permanently disconnected when you sleep or hibernate for a while.
+- Make it possible to automatically update the binary.
 
 ## License
+
 [MIT](LICENSE)
 
 ## Enterprise
+
 Visit [our enterprise page](https://coder.com/enterprise) for more information
 about our enterprise offering.
 
 ## Commercialization
+
 If you would like to commercialize code-server, please contact
 contact@coder.com.

doc/examples/kubernetes.aws.yaml

@@ -58,7 +58,7 @@ spec:
         app: code-server
     spec:
       containers:
-      - image: codercom/code-server
+      - image: codercom/code-server:v2
         imagePullPolicy: Always
         name: code-servery
         ports:

doc/examples/kubernetes.yaml

@@ -35,7 +35,7 @@ spec:
         app: code-server
     spec:
       containers:
-      - image: codercom/code-server
+      - image: codercom/code-server:v2
         imagePullPolicy: Always
         name: code-server
         ports:

doc/quickstart.md

@@ -7,15 +7,6 @@
 ## Usage
 Run `code-server --help` to view available options.
 
-### Encrypting traffic with HTTPS
-To encrypt the traffic between the browser and server use `code-server --cert`
-followed by the path to your certificate. Additionally, you can use certificate
-keys with `--cert-key` followed by the path to your key. If you pass `--cert`
-without any path code-server will generate a self-signed certificate.
-
-You can use [Let's Encrypt](https://letsencrypt.org/) to get an SSL certificate
-for free.
-
 ### Nginx Reverse Proxy
 The trailing slashes are important.
 
@@ -59,27 +50,23 @@ In some cases you might need to run code-server automatically once the host star
 
 ```ini
 [Unit]
-
-Description=VSCode in a browser
-
+Description=Code Server IDE
 After=network.target
 
 [Service]
-
 Type=simple
-
-ExecStart=/usr/bin/code-server $(pwd)
-
-WorkingDirectory=$HOME/projects
-
-ExecStop=/sbin/start-stop-daemon --stop -x /usr/bin/code-server
-
+User=<USER>
+EnvironmentFile=$HOME/.profile
+WorkingDirectory=$HOME
 Restart=on-failure
+RestartSec=10
 
-User=1000
+ExecStart=<PATH TO BINARY> $(pwd)
+
+StandardOutput=file:/var/log/code-server-output.log
+StandardError=file:/var/log/code-server-error.log
 
 [Install]
-
 WantedBy=multi-user.target
 ```
 

main.js

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

package.json

@@ -1,25 +1,27 @@
 {
   "license": "MIT",
   "scripts": {
-    "ensure-in-vscode": "bash ./scripts/tasks.bash ensure-in-vscode",
-    "preinstall": "yarn 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"
+    "runner": "cd ./scripts && node --max-old-space-size=32384 -r ts-node/register ./build.ts",
+    "start": "nodemon --watch ../../../out --verbose ../../../out/vs/server/main.js",
+    "watch": "cd ../../../ && yarn watch",
+    "build": "yarn && yarn runner build",
+    "package": "yarn runner package",
+    "binary": "yarn runner binary",
+    "patch:generate": "cd ../../../ && git diff --staged > ./src/vs/server/scripts/vscode.patch",
+    "patch:apply": "cd ../../../ && git apply ./src/vs/server/scripts/vscode.patch"
   },
   "devDependencies": {
     "@coder/nbin": "^1.2.2",
+    "@types/fs-extra": "^8.0.1",
+    "@types/node": "^10.12.12",
     "@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",
+    "typescript": "3.6"
   },
   "resolutions": {
     "@types/node": "^10.12.12",
@@ -27,10 +29,13 @@
   },
   "dependencies": {
     "@coder/logger": "^1.1.8",
+    "@coder/node-browser": "^1.0.6",
+    "@coder/requirefs": "^1.0.6",
     "httpolyglot": "^0.1.2",
     "pem": "^1.14.2",
     "safe-compare": "^1.1.4",
     "tar-fs": "^2.0.0",
-    "tar-stream": "^2.1.0"
+    "tar-stream": "^2.1.0",
+    "util": "^0.12.1"
   }
 }

scripts/build-json.js

@@ -1,58 +0,0 @@
-// 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/cli.js",
-		"vs/server/src/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

@@ -0,0 +1,413 @@
+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 currentTask?: Task;
+
+	public run(task: Task | undefined, args: string[]): void {
+		this.currentTask = task;
+		this.doRun(task, args).catch((error) => {
+			console.error(error.message);
+			process.exit(1);
+		});
+	}
+
+	private async task<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;
+		}
+	}
+
+	/**
+	 * Writes to stdout with an optional newline.
+	 */
+	private log(message: string, skipNewline: boolean = false): void {
+		process.stdout.write(`[${this.currentTask || "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 vscodeSourcePath = path.join(this.outPath, "source", `vscode-${vscodeVersion}-source`);
+		const binariesPath = path.join(this.outPath, "binaries");
+		const binaryName = `code-server${codeServerVersion}-vsc${vscodeVersion}-${target}-${arch}`;
+		const finalBuildPath = path.join(this.outPath, "build", `${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 (os.platform() === "darwin" || (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 VS Code while developing which causes issues
+	 * because the watcher will try compiling those built files.
+	 */
+	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> {
+		// Install dependencies (should be cached by CI).
+		await this.task("Installing code-server dependencies", async () => {
+			await util.promisify(cp.exec)("yarn", { cwd: this.rootPath });
+		});
+
+		// Download and prepare VS Code if necessary (should be cached by CI).
+		if (fs.existsSync(vscodeSourcePath)) {
+			this.log("Using existing VS Code clone");
+		} else {
+			await this.task("Cloning VS Code", () => {
+				return util.promisify(cp.exec)(
+					"git clone https://github.com/microsoft/vscode"
+						+ ` --quiet --branch "${vscodeVersion}"`
+						+ ` --single-branch --depth=1 "${vscodeSourcePath}"`);
+			});
+		}
+
+		if (fs.existsSync(path.join(vscodeSourcePath, "node_modules"))) {
+			this.log("Using existing VS Code node_modules");
+		} else {
+			await this.task("Installing VS Code dependencies", () => {
+				return util.promisify(cp.exec)("yarn", { cwd: vscodeSourcePath });
+			});
+		}
+
+		if (fs.existsSync(path.join(vscodeSourcePath, ".build/extensions"))) {
+			this.log("Using existing built-in-extensions");
+		} else {
+			await this.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 this.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 this.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 this.task("Building VS Code", () => {
+			return util.promisify(cp.exec)("yarn gulp compile-build --max-old-space-size=32384", { cwd: vscodeSourcePath });
+		});
+
+		await this.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 this.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 this.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 this.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(finalServerPath, "src/browser/workbench-build.html"), path.join(finalServerPath, "src/browser/workbench.html")),
+					]);
+				}),
+			]);
+		});
+
+		if (process.env.MINIFY) {
+			await this.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([finalServerPath, finalBuildPath].map((cwd) => {
+					return util.promisify(cp.exec)("yarn --production", { cwd });
+				}));
+
+				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 this.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. There's no point
+		// since there isn't anything like an incremental build.
+		await this.task("Removing build files for smaller cache", () => {
+			return Promise.all([
+				fs.remove(serverPath),
+				fs.remove(path.join(vscodeSourcePath, "out-vscode")),
+				fs.remove(path.join(vscodeSourcePath, "out-vscode-min")),
+				fs.remove(path.join(vscodeSourcePath, "out-build")),
+			]);
+		});
+
+		// 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 this.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"),
+			]);
+		});
+
+		// 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
+		await this.task("Applying onigasm PHP fix", async () => {
+			const onigasmPath = path.join(finalBuildPath, "node_modules/onigasm-umd");
+			const onigasmTmpPath = `${onigasmPath}-temp`;
+			await Promise.all([
+				fs.remove(onigasmPath),
+				fs.mkdir(onigasmTmpPath),
+			]);
+			await util.promisify(cp.exec)(`git clone "https://github.com/alexandrudima/onigasm-umd" "${onigasmPath}"`);
+			await util.promisify(cp.exec)("yarn", { cwd: onigasmPath });
+			await util.promisify(cp.exec)("yarn add --dev onigasm@2.2.1", { cwd: onigasmPath });
+			await util.promisify(cp.exec)("yarn package", { cwd: onigasmPath });
+			await Promise.all(["release", "LICENSE", "package.json"].map((fileName) => {
+				return fs.copy(path.join(onigasmPath, fileName), path.join(onigasmTmpPath, fileName));
+			}));
+			await fs.remove(onigasmPath);
+			await fs.move(onigasmTmpPath, 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

@@ -1,7 +1,6 @@
 #!/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/ci.dockerfile

@@ -0,0 +1,38 @@
+# We deploy with ubuntu so that devs have a familiar environment.
+FROM ubuntu:18.04
+
+RUN apt-get update && apt-get install -y \
+	openssl \
+	net-tools \
+	git \
+	locales \
+	sudo \
+	dumb-init \
+	vim \
+	curl \
+	wget
+
+RUN locale-gen en_US.UTF-8
+# We cannot use update-locale because docker will not use the env variables
+# configured in /etc/default/locale so we need to set it manually.
+ENV LC_ALL=en_US.UTF-8 \
+	SHELL=/bin/bash
+
+RUN adduser --gecos '' --disabled-password coder && \
+	echo "coder ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers.d/nopasswd
+
+USER coder
+# We create first instead of just using WORKDIR as when WORKDIR creates, the
+# user is root.
+RUN mkdir -p /home/coder/project
+
+WORKDIR /home/coder/project
+
+# This ensures we have a volume mounted even if the user forgot to do bind
+# mount. So that they do not lose their data if they delete the container.
+VOLUME [ "/home/coder/project" ]
+
+COPY ./binaries/code-server* /usr/local/bin/code-server
+EXPOSE 8080
+
+ENTRYPOINT ["dumb-init", "code-server", "--host", "0.0.0.0"]

scripts/nbin-shim.js

@@ -1,16 +0,0 @@
-// 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

@@ -1,23 +0,0 @@
-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

@@ -0,0 +1,71 @@
+// 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/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,html}',
+	"!out-build/vs/code/browser/workbench/*.html",
+	'!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

@@ -1,276 +0,0 @@
-#!/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

@@ -0,0 +1,17 @@
+{
+	"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

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

@@ -1,14 +1,17 @@
+import { Emitter } from "vs/base/common/event";
 import { URI } from "vs/base/common/uri";
 import { registerSingleton } from "vs/platform/instantiation/common/extensions";
 import { ServiceCollection } from "vs/platform/instantiation/common/serviceCollection";
-import { ITelemetryService } from "vs/platform/telemetry/common/telemetry";
 import { ILocalizationsService } from "vs/platform/localizations/common/localizations";
-import { LocalizationsService } from "vs/platform/localizations/electron-browser/localizationsService";
-import { IUpdateService } from "vs/platform/update/common/update";
-import { UpdateService } from "vs/platform/update/electron-browser/updateService";
-import { TelemetryChannelClient } from "vs/server/src/telemetry";
-import { IUploadService, UploadService } from 'vs/server/src/upload';
+import { LocalizationsService } from "vs/workbench/services/localizations/electron-browser/localizationsService";
+import { ITelemetryService } from "vs/platform/telemetry/common/telemetry";
+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 { IRemoteAgentService } from "vs/workbench/services/remote/common/remoteAgentService";
+import { PersistentConnectionEventType } from "vs/platform/remote/common/remoteAgentConnection";
 
 class TelemetryService extends TelemetryChannelClient {
 	public constructor(
@@ -18,16 +21,36 @@ class TelemetryService extends TelemetryChannelClient {
 	}
 }
 
+class NodeProxyService extends NodeProxyChannelClient implements INodeProxyService {
+	private readonly _onClose = new Emitter<void>();
+	public readonly onClose = this._onClose.event;
+	private readonly _onDown = new Emitter<void>();
+	public readonly onDown = this._onDown.event;
+	private readonly _onUp = new Emitter<void>();
+	public readonly onUp = this._onUp.event;
+
+	public constructor(
+		@IRemoteAgentService remoteAgentService: IRemoteAgentService,
+	) {
+		super(remoteAgentService.getConnection()!.getChannel("nodeProxy"));
+		remoteAgentService.getConnection()!.onDidStateChange((state) => {
+			switch (state.type) {
+				case PersistentConnectionEventType.ConnectionGain:
+					return this._onUp.fire();
+				case PersistentConnectionEventType.ConnectionLost:
+					return this._onDown.fire();
+				case PersistentConnectionEventType.ReconnectionPermanentFailure:
+					return this._onClose.fire();
+			}
+		});
+	}
+}
+
 registerSingleton(ILocalizationsService, LocalizationsService);
+registerSingleton(INodeProxyService, NodeProxyService);
 registerSingleton(ITelemetryService, TelemetryService);
-registerSingleton(IUpdateService, UpdateService);
 registerSingleton(IUploadService, UploadService, true);
 
-import "vs/workbench/contrib/update/electron-browser/update.contribution";
-import 'vs/workbench/contrib/localizations/browser/localizations.contribution';
-
-import { coderApi, vscodeApi } from "vs/server/src/api";
-
 /**
  * This is called by vs/workbench/browser/web.main.ts after the workbench has
  * been initialized so we can initialize our own client-side code.

src/browser/extHostNodeProxy.ts

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

src/browser/login.html

@@ -6,6 +6,7 @@
 		<title>Authenticate: code-server</title>
 		<link rel="icon" href="./favicon.ico" type="image/x-icon" />
 		<link rel="manifest" href="./manifest.json">
+		<link rel="apple-touch-icon" href="./static/out/vs/server/src/media/code-server.png" />
 		<link href="./static/out/vs/server/src/media/login.css" rel="stylesheet">
 	</head>
 	<body>

src/browser/mainThreadNodeProxy.ts

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

src/browser/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

@@ -0,0 +1,109 @@
+<!-- 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

@@ -0,0 +1,70 @@
+<!-- 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/browser/worker.ts

@@ -0,0 +1,57 @@
+import { URI } from "vs/base/common/uri";
+import { IExtensionDescription } from "vs/platform/extensions/common/extensions";
+import { ILogService } from "vs/platform/log/common/log";
+import { Client } from "vs/server/node_modules/@coder/node-browser/out/client/client";
+import { fromTar } from "vs/server/node_modules/@coder/requirefs/out/requirefs";
+import { ExtensionActivationTimesBuilder } from "vs/workbench/api/common/extHostExtensionActivator";
+import { IExtHostNodeProxy } from "./extHostNodeProxy";
+
+export const loadCommonJSModule = async <T>(
+	module: IExtensionDescription,
+	activationTimesBuilder: ExtensionActivationTimesBuilder,
+	nodeProxy: IExtHostNodeProxy,
+	logService: ILogService,
+	vscode: any,
+): Promise<T> => {
+	const fetchUri = URI.from({
+		scheme: self.location.protocol.replace(":", ""),
+		authority: self.location.host,
+		path: `${self.location.pathname.replace(/\/static.*\/out\/vs\/workbench\/services\/extensions\/worker\/extensionHostWorkerMain.js$/, "")}/tar`,
+		query: `path=${encodeURIComponent(module.extensionLocation.path)}`,
+	});
+	const response = await fetch(fetchUri.toString(true));
+	if (response.status !== 200) {
+		throw new Error(`Failed to download extension "${module.extensionLocation.path}"`);
+	}
+	const client = new Client(nodeProxy, { logger: logService });
+	const init = await client.handshake();
+	const buffer = new Uint8Array(await response.arrayBuffer());
+	const rfs = fromTar(buffer);
+	(<any>self).global = self;
+	rfs.provide("vscode", vscode);
+	Object.keys(client.modules).forEach((key) => {
+		const mod = (client.modules as any)[key];
+		if (key === "process") {
+			(<any>self).process = mod;
+			(<any>self).process.env = init.env;
+			return;
+		}
+
+		rfs.provide(key, mod);
+		switch (key) {
+			case "buffer":
+				(<any>self).Buffer = mod.Buffer;
+				break;
+			case "timers":
+				(<any>self).setImmediate = mod.setImmediate;
+				break;
+		}
+	});
+
+	try {
+		activationTimesBuilder.codeLoadingStart();
+		return rfs.require(".");
+	} finally {
+		activationTimesBuilder.codeLoadingStop();
+	}
+};

src/common/nodeProxy.ts

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

src/media/manifest.json

@@ -6,8 +6,8 @@
 	"background-color": "#fff",
 	"description": "Run VS Code on a remote server.",
 	"icons": [{
-		"src": "static/code-server.png",
-		"sizes": "128x128",
+		"src": "./static/out/vs/server/src/media/code-server.png",
+		"sizes": "384x384",
 		"type": "image/png"
 	}]
 }

src/node/channel.ts

@@ -12,12 +12,12 @@ 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 { getTranslations } from "vs/server/src/nls";
-import { getUriTransformer } from "vs/server/src/util";
+import { INodeProxyService } from "vs/server/src/common/nodeProxy";
+import { getTranslations } from "vs/server/src/node/nls";
+import { getUriTransformer, localRequire } from "vs/server/src/node/util";
 import { ExtensionScanner, ExtensionScannerInput } from "vs/workbench/services/extensions/node/extensionPoints";
 
 /**
@@ -227,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,
@@ -274,3 +274,40 @@ export class ExtensionEnvironmentChannel implements IServerChannel {
 		this.telemetry.setEnabled(false);
 	}
 }
+
+export class NodeProxyService implements INodeProxyService {
+	public _serviceBrand = undefined;
+
+	public readonly server: import("@coder/node-browser/out/server/server").Server;
+
+	private readonly _onMessage = new Emitter<string>();
+	public readonly onMessage = this._onMessage.event;
+	private readonly _$onMessage = new Emitter<string>();
+	public readonly $onMessage = this._$onMessage.event;
+	public readonly _onDown = new Emitter<void>();
+	public readonly onDown = this._onDown.event;
+	public readonly _onUp = new Emitter<void>();
+	public readonly onUp = this._onUp.event;
+
+	// Unused because the server connection will never permanently close.
+	private readonly _onClose = new Emitter<void>();
+	public readonly onClose = this._onClose.event;
+
+	public constructor() {
+		// 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,
+			onClose: this.onClose,
+			onDown: this.onDown,
+			onUp: this.onUp,
+			send: (message: string): void => {
+				this._onMessage.fire(message);
+			}
+		});
+	}
+
+	public send(message: string): void {
+		this._$onMessage.fire(message);
+	}
+}

src/node/cli.ts

@@ -5,14 +5,13 @@ 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 { ipcMain } from "vs/server/src/ipc";
-import { enableCustomMarketplace } from "vs/server/src/marketplace";
-import { MainServer } from "vs/server/src/server";
-import { AuthType, buildAllowedMessage, enumToArray, FormatType, generateCertificate, generatePassword, localRequire, open, unpackExecutables } from "vs/server/src/util";
+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";
+import { AuthType, buildAllowedMessage, enumToArray, FormatType, generateCertificate, generatePassword, localRequire, open, unpackExecutables } from "vs/server/src/node/util";
 
 const { logger } = localRequire<typeof import("@coder/logger/out/index")>("@coder/logger/out/index");
 setUnexpectedErrorHandler((error) => logger.warn(error.message));
@@ -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);
 };
 
@@ -91,7 +86,7 @@ const startVscode = async (): Promise<void | void[]> => {
 	const args = getArgs();
 	const extra = args["_"] || [];
 	const options = {
-		auth: args.auth,
+		auth: args.auth || AuthType.Password,
 		basePath: args["base-path"],
 		cert: args.cert,
 		certKey: args["cert-key"],
@@ -100,9 +95,9 @@ const startVscode = async (): Promise<void | void[]> => {
 		password: process.env.PASSWORD,
 	};
 
-	if (options.auth && enumToArray(AuthType).filter((t) => t === options.auth).length === 0) {
+	if (enumToArray(AuthType).filter((t) => t === options.auth).length === 0) {
 		throw new Error(`'${options.auth}' is not a valid authentication type.`);
-	} else if (options.auth && !options.password) {
+	} else if (options.auth === "password" && !options.password) {
 		options.password = await generatePassword();
 	}
 
@@ -120,7 +115,7 @@ const startVscode = async (): Promise<void | void[]> => {
 
 	const server = new MainServer({
 		...options,
-		port: typeof args.port !== "undefined" && parseInt(args.port, 10) || 8080,
+		port: typeof args.port !== "undefined" ? parseInt(args.port, 10) : 8080,
 		socket: args.socket,
 	}, args);
 
@@ -130,10 +125,13 @@ const startVscode = async (): Promise<void | void[]> => {
 	]);
 	logger.info(`Server listening on ${serverAddress}`);
 
-	if (options.auth && !process.env.PASSWORD) {
+	if (options.auth === "password" && !process.env.PASSWORD) {
 		logger.info(`  - Password is ${options.password}`);
-		logger.info("  - To use your own password, set the PASSWORD environment variable");
-	} else if (options.auth) {
+		logger.info("    - To use your own password, set the PASSWORD environment variable");
+		if (!args.auth) {
+			logger.info("    - To disable use `--auth none`");
+		}
+	} else if (options.auth === "password") {
 		logger.info("  - Using custom password for authentication");
 	} else {
 		logger.info("  - No authentication");
@@ -151,7 +149,7 @@ const startVscode = async (): Promise<void | void[]> => {
 
 	if (!server.options.socket && args.open) {
 		// The web socket doesn't seem to work if browsing with 0.0.0.0.
-		const openAddress = `http://localhost:${server.options.port}`;
+		const openAddress = serverAddress.replace(/:\/\/0.0.0.0/, "://localhost");
 		await open(openAddress).catch(console.error);
 		logger.info(`  - Opened ${openAddress}`);
 	}
@@ -161,19 +159,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;
 	}
@@ -250,13 +248,19 @@ const main = async(): Promise<boolean | void | void[]> => {
 	return startCli() || new WrapperProcess().start();
 };
 
+const exit = process.exit;
+process.exit = function (code?: number) {
+	const err = new Error(`process.exit() was prevented: ${code || "unknown code"}.`);
+	console.warn(err.stack);
+} as (code?: number) => never;
+
 // It's possible that the pipe has closed (for example if you run code-server
 // --version | head -1). Assume that means we're done.
 if (!process.stdout.isTTY) {
-	process.stdout.on("error", () => process.exit());
+	process.stdout.on("error", () => exit());
 }
 
 main().catch((error) => {
 	logger.error(error.message);
-	process.exit(typeof error.code === "number" ? error.code : 1);
+	exit(typeof error.code === "number" ? error.code : 1);
 });

src/node/connection.ts

@@ -6,9 +6,9 @@ import { ISocket } from "vs/base/parts/ipc/common/ipc.net";
 import { NodeSocket } from "vs/base/parts/ipc/node/ipc.net";
 import { IEnvironmentService } from "vs/platform/environment/common/environment";
 import { ILogService } from "vs/platform/log/common/log";
-import { getNlsConfiguration } from "vs/server/src/nls";
-import { Protocol } from "vs/server/src/protocol";
-import { uriTransformerPath } from "vs/server/src/util";
+import { getNlsConfiguration } from "vs/server/src/node/nls";
+import { Protocol } from "vs/server/src/node/protocol";
+import { uriTransformerPath } from "vs/server/src/node/util";
 import { IExtHostReadyMessage } from "vs/workbench/services/extensions/common/extensionHostProtocol";
 
 export abstract class Connection {
@@ -123,6 +123,7 @@ export class ExtensionHostConnection extends Connection {
 					VSCODE_EXTHOST_WILL_SEND_SOCKET: "true",
 					VSCODE_HANDLES_UNCAUGHT_ERRORS: "true",
 					VSCODE_LOG_STACK: "false",
+					VSCODE_LOG_LEVEL: this.environment.verbose ? "trace" : this.environment.log,
 					VSCODE_NLS_CONFIG: JSON.stringify(config),
 				},
 				silent: true,

src/node/marketplace.ts

@@ -5,8 +5,8 @@ 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 { localRequire } from "vs/server/src/util";
+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");
 
@@ -79,52 +79,55 @@ export const buffer = (targetPath: string, filePath: string): Promise<Buffer> =>
 };
 
 const extractAssets = async (tarPath: string, match: RegExp, callback: (path: string, data: Buffer) => void): Promise<void> => {
-	const buffer = await util.promisify(fs.readFile)(tarPath);
-	return new Promise<void>(async (resolve, reject): Promise<void> => {
+	return new Promise<void>((resolve, reject): void => {
 		const extractor = tarStream.extract();
-		extractor.once("error", reject);
+		const fail = (error: Error) => {
+			extractor.destroy();
+			reject(error);
+		};
+		extractor.once("error", fail);
 		extractor.on("entry", async (header, stream, next) => {
 			const name = header.name;
 			if (match.test(name)) {
 				extractData(stream).then((data) => {
 					callback(name, data);
 					next();
-				}).catch(reject);
-				stream.resume();
+				}).catch(fail);
 			} else {
 				stream.on("end", () => next());
-				stream.resume();
+				stream.resume(); // Just drain it.
 			}
 		});
 		extractor.on("finish", resolve);
-		extractor.write(buffer);
-		extractor.end();
+		fs.createReadStream(tarPath).pipe(extractor);
 	});
 };
 
 const extractData = (stream: NodeJS.ReadableStream): Promise<Buffer> => {
 	return new Promise((resolve, reject): void => {
 		const fileData: Buffer[] = [];
-		stream.on("data", (data) => fileData.push(data));
-		stream.on("end", () => resolve(Buffer.concat(fileData)));
 		stream.on("error", reject);
+		stream.on("end", () => resolve(Buffer.concat(fileData)));
+		stream.on("data", (data) => fileData.push(data));
 	});
 };
 
 const extractTar = async (tarPath: string, targetPath: string, options: IExtractOptions = {}, token: CancellationToken): Promise<void> => {
-	const buffer = await util.promisify(fs.readFile)(tarPath);
-	return new Promise<void>(async (resolve, reject): Promise<void> => {
+	return new Promise<void>((resolve, reject): void => {
 		const sourcePathRegex = new RegExp(options.sourcePath ? `^${options.sourcePath}` : "");
 		const extractor = tarStream.extract();
-		extractor.once("error", reject);
+		const fail = (error: Error) => {
+			extractor.destroy();
+			reject(error);
+		};
+		extractor.once("error", fail);
 		extractor.on("entry", async (header, stream, next) => {
-			const rawName = path.normalize(header.name);
-
 			const nextEntry = (): void => {
+				stream.on("end", () => next());
 				stream.resume();
-				next();
 			};
 
+			const rawName = path.normalize(header.name);
 			if (token.isCancellationRequested || !sourcePathRegex.test(rawName)) {
 				return nextEntry();
 			}
@@ -138,20 +141,18 @@ const extractTar = async (tarPath: string, targetPath: string, options: IExtract
 			const dirName = path.dirname(fileName);
 			const targetDirName = path.join(targetPath, dirName);
 			if (targetDirName.indexOf(targetPath) !== 0) {
-				return reject(nls.localize("invalid file", "Error extracting {0}. Invalid file.", fileName));
+				return fail(new Error(nls.localize("invalid file", "Error extracting {0}. Invalid file.", fileName)));
 			}
 
-			return mkdirp(targetDirName, undefined, token).then(() => {
-				const fstream = fs.createWriteStream(targetFileName, { mode: header.mode });
-				fstream.once("close", () => next());
-				fstream.once("error", reject);
-				stream.pipe(fstream);
-				stream.resume();
-			});
+			await mkdirp(targetDirName, undefined, token);
+
+			const fstream = fs.createWriteStream(targetFileName, { mode: header.mode });
+			fstream.once("close", () => next());
+			fstream.once("error", fail);
+			stream.pipe(fstream);
 		});
 		extractor.once("finish", resolve);
-		extractor.write(buffer);
-		extractor.end();
+		fs.createReadStream(tarPath).pipe(extractor);
 	});
 };
 

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,15 +53,16 @@ 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 { ExtensionEnvironmentChannel, FileProviderChannel } from "vs/server/src/channel";
-import { Connection, ExtensionHostConnection, ManagementConnection } from "vs/server/src/connection";
-import { TelemetryClient } from "vs/server/src/insights";
-import { getLocaleFromConfig, getNlsConfiguration } from "vs/server/src/nls";
-import { Protocol } from "vs/server/src/protocol";
-import { TelemetryChannel } from "vs/server/src/telemetry";
-import { UpdateService } from "vs/server/src/update";
-import { AuthType, getMediaMime, getUriTransformer, localRequire, tmpdir } from "vs/server/src/util";
+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 { Protocol } from "vs/server/src/node/protocol";
+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";
 import { IWorkbenchConstructionOptions } from "vs/workbench/workbench.web.api";
 
@@ -81,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;
 }
 
@@ -111,7 +110,7 @@ export class HttpError extends Error {
 }
 
 export interface ServerOptions {
-	readonly auth?: AuthType;
+	readonly auth: AuthType;
 	readonly basePath?: string;
 	readonly connectionToken?: string;
 	readonly cert?: string;
@@ -125,7 +124,7 @@ export interface ServerOptions {
 
 export abstract class Server {
 	protected readonly server: http.Server | https.Server;
-	protected rootPath = path.resolve(__dirname, "../../../..");
+	protected rootPath = path.resolve(__dirname, "../../../../..");
 	protected serverRoot = path.join(this.rootPath, "/out/vs/server/src");
 	protected readonly allowedRequestPaths: string[] = [this.rootPath];
 	private listenPromise: Promise<string> | undefined;
@@ -134,7 +133,7 @@ export abstract class Server {
 
 	public constructor(options: ServerOptions) {
 		this.options = {
-			host: options.auth && options.cert ? "0.0.0.0" : "localhost",
+			host: options.auth === "password" && options.cert ? "0.0.0.0" : "localhost",
 			...options,
 			basePath: options.basePath ? options.basePath.replace(/\/+$/, "") : "",
 		};
@@ -196,7 +195,7 @@ export abstract class Server {
 
 	protected async getTarredResource(...parts: string[]): Promise<Response> {
 		const filePath = this.ensureAuthorizedFilePath(...parts);
-		return { stream: tarFs.pack(filePath), filePath, mime: "application/tar" };
+		return { stream: tarFs.pack(filePath), filePath, mime: "application/tar", cache: true };
 	}
 
 	protected ensureAuthorizedFilePath(...parts: string[]): string {
@@ -270,7 +269,7 @@ export abstract class Server {
 		base = path.normalize(base);
 		requestPath = path.normalize(requestPath || "/index.html");
 
-		if (base !== "/login" || !this.options.auth || requestPath !== "/index.html") {
+		if (base !== "/login" || this.options.auth !== "password" || requestPath !== "/index.html") {
 			this.ensureGet(request);
 		}
 
@@ -279,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";
 		}
 
@@ -301,7 +300,7 @@ export abstract class Server {
 				response.cache = true;
 				return response;
 			case "/login":
-				if (!this.options.auth || requestPath !== "/index.html") {
+				if (this.options.auth !== "password" || requestPath !== "/index.html") {
 					throw new HttpError("Not found", HttpCode.NotFound);
 				}
 				return this.tryLogin(request);
@@ -360,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({
@@ -376,7 +375,7 @@ export abstract class Server {
 	}
 
 	private async getLogin(error: string = "", payload?: LoginPayload): Promise<Response> {
-		const filePath = path.join(this.serverRoot, "login/index.html");
+		const filePath = path.join(this.serverRoot, "browser/login.html");
 		const content = (await util.promisify(fs.readFile)(filePath, "utf8"))
 			.replace("{{ERROR}}", error)
 			.replace("display:none", error ? "display:block" : "display:none")
@@ -422,7 +421,7 @@ export abstract class Server {
 	}
 
 	private authenticate(request: http.IncomingMessage, payload?: LoginPayload): boolean {
-		if (!this.options.auth) {
+		if (this.options.auth !== "password") {
 			return true;
 		}
 		const safeCompare = localRequire<typeof import("safe-compare")>("safe-compare/index");
@@ -444,6 +443,15 @@ export abstract class Server {
 	}
 }
 
+interface StartPath {
+	path?: string[] | string;
+	workspace?: boolean;
+}
+
+interface Settings {
+	lastVisited?: StartPath;
+}
+
 export class MainServer extends Server {
 	public readonly _onDidClientConnect = new Emitter<ClientConnectionEvent>();
 	public readonly onDidClientConnect = this._onDidClientConnect.event;
@@ -460,6 +468,8 @@ export class MainServer extends Server {
 	private _proxyServer?: Promise<net.Server>;
 	private readonly proxyTimeout = 5000;
 
+	private settings: Settings = {};
+
 	public constructor(options: ServerOptions, args: ParsedArgs) {
 		super(options);
 		this.servicesPromise = this.initializeServices(args);
@@ -526,38 +536,49 @@ 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");
-		let [content] = await Promise.all([
+		const filePath = path.join(this.serverRoot, "browser/workbench.html");
+		let [content, startPath] = await Promise.all([
 			util.promisify(fs.readFile)(filePath, "utf8"),
+			this.getFirstValidPath([
+				{ path: parsedUrl.query.workspace, workspace: true },
+				{ path: parsedUrl.query.folder },
+				(await this.readSettings()).lastVisited,
+				{ path: this.options.folderUri }
+			]),
 			this.servicesPromise,
 		]);
+
+		if (startPath) {
+			this.writeSettings({
+				lastVisited: {
+					path: startPath.uri.fsPath,
+					workspace: startPath.workspace
+				},
+			});
+		}
+
 		const logger = this.services.get(ILogService) as ILogService;
 		logger.info("request.url", `"${request.url}"`);
-		const environment = this.services.get(IEnvironmentService) as IEnvironmentService;
-		const locale = environment.args.locale || await getLocaleFromConfig(environment.userDataPath);
-		const cwd = process.env.VSCODE_CWD || process.cwd();
-		const workspacePath = parsedUrl.query.workspace as string | undefined;
-		const folderPath = !workspacePath ? parsedUrl.query.folder as string | undefined || this.options.folderUri : undefined;
+
 		const remoteAuthority = request.headers.host as string;
 		const transformer = getUriTransformer(remoteAuthority);
+
+		const environment = this.services.get(IEnvironmentService) as IEnvironmentService;
 		const options: Options = {
-			WORKBENCH_WEB_CONGIGURATION: {
-				workspaceUri: workspacePath
-					? transformer.transformOutgoing(URI.file(sanitizeFilePath(workspacePath, cwd)))
-					: undefined,
-				folderUri: folderPath
-					? transformer.transformOutgoing(URI.file(sanitizeFilePath(folderPath, cwd)))
-					: undefined,
+			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(
-				(this.services.get(IEnvironmentService) as EnvironmentService).webUserDataHome,
-			),
-			NLS_CONFIGURATION: await getNlsConfiguration(locale, environment.userDataPath),
+			REMOTE_USER_DATA_URI: transformer.transformOutgoing(URI.file(environment.userDataPath)),
+			PRODUCT_CONFIGURATION: {
+				extensionsGallery: product.extensionsGallery,
+			},
+			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])}'`);
 		}
@@ -565,6 +586,34 @@ export class MainServer extends Server {
 		return { content, filePath };
 	}
 
+	/**
+	 * Choose the first valid path.
+	 */
+	private async getFirstValidPath(startPaths: Array<StartPath | undefined>): Promise<{ uri: URI, workspace?: boolean} | undefined> {
+		const logger = this.services.get(ILogService) as ILogService;
+		const cwd = process.env.VSCODE_CWD || process.cwd();
+		for (let i = 0; i < startPaths.length; ++i) {
+			const startPath = startPaths[i];
+			if (!startPath) {
+				continue;
+			}
+			const paths = typeof startPath.path === "string" ? [startPath.path] : (startPath.path || []);
+			for (let j = 0; j < paths.length; ++j) {
+				const uri = URI.file(sanitizeFilePath(paths[j], cwd));
+				try {
+					const stat = await util.promisify(fs.stat)(uri.fsPath);
+					// Workspace must be a file.
+					if (!!startPath.workspace !== stat.isDirectory()) {
+						return { uri, workspace: startPath.workspace };
+					}
+				} catch (error) {
+					logger.warn(error.message);
+				}
+			}
+		}
+		return undefined;
+	}
+
 	private async connect(message: ConnectionTypeRequest, protocol: Protocol): Promise<void> {
 		if (product.commit && message.commit !== product.commit) {
 			throw new Error(`Version mismatch (${message.commit} instead of ${product.commit})`);
@@ -605,6 +654,11 @@ export class MainServer extends Server {
 					this._onDidClientConnect.fire({
 						protocol, onDidClientDisconnect: connection.onClose,
 					});
+					// TODO: Need a way to match clients with a connection. For now
+					// dispose everything which only works because no extensions currently
+					// utilize long-running proxies.
+					(this.services.get(INodeProxyService) as NodeProxyService)._onUp.fire();
+					connection.onClose(() => (this.services.get(INodeProxyService) as NodeProxyService)._onDown.fire());
 				} else {
 					const buffer = protocol.readEntireBuffer();
 					connection = new ExtensionHostConnection(
@@ -645,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));
 
@@ -666,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,
@@ -677,28 +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);
-			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));
-
-				this.ipc.registerChannel("extensions", extensionsChannel);
-				this.ipc.registerChannel("remoteextensionsenvironment", extensionsEnvironmentChannel);
-				this.ipc.registerChannel("request", requestChannel);
-				this.ipc.registerChannel("telemetry", telemetryChannel);
-				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));
 			});
 		});
@@ -785,4 +834,41 @@ export class MainServer extends Server {
 		}
 		return path;
 	}
+
+	/**
+	 * Return the file path for Coder settings.
+	 */
+	private get settingsPath(): string {
+		const environment = this.services.get(IEnvironmentService) as IEnvironmentService;
+		return path.join(environment.userDataPath, "coder.json");
+	}
+
+	/**
+	 * Read settings from the file. On a failure return last known settings and
+	 * log a warning.
+	 *
+	 */
+	private async readSettings(): Promise<Settings> {
+		try {
+			const raw = (await util.promisify(fs.readFile)(this.settingsPath, "utf8")).trim();
+			this.settings = raw ? JSON.parse(raw) : {};
+		} catch (error) {
+			if (error.code !== "ENOENT") {
+				(this.services.get(ILogService) as ILogService).warn(error.message);
+			}
+		}
+		return this.settings;
+	}
+
+	/**
+	 * Write settings combined with current settings. On failure log a warning.
+	 */
+	private async writeSettings(newSettings: Partial<Settings>): Promise<void> {
+		this.settings = { ...this.settings, ...newSettings };
+		try {
+			await util.promisify(fs.writeFile)(this.settingsPath, JSON.stringify(this.settings));
+		} catch (error) {
+			(this.services.get(ILogService) as ILogService).warn(error.message);
+		}
+	}
 }

src/node/update.ts

@@ -11,13 +11,13 @@ 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/ipc";
-import { extract } from "vs/server/src/marketplace";
-import { tmpdir } from "vs/server/src/util";
+import { ipcMain } from "vs/server/src/node/ipc";
+import { extract } from "vs/server/src/node/marketplace";
+import { tmpdir } from "vs/server/src/node/util";
 import * as zlib from "zlib";
 
 interface IUpdate {
@@ -37,27 +37,32 @@ export class UpdateService extends AbstractUpdateService {
 		super(null, configurationService, environmentService, requestService, logService);
 	}
 
-	public async isLatestVersion(): Promise<boolean | undefined> {
-		const latest = await this.getLatestVersion();
-		return !latest || latest.name === pkg.codeServerVersion;
+	public async isLatestVersion(latest?: IUpdate | null): Promise<boolean | undefined> {
+		if (!latest) {
+			latest = await this.getLatestVersion();
+		}
+		if (latest) {
+			const latestMajor = parseInt(latest.name);
+			const currentMajor = parseInt(product.codeServerVersion);
+			return !isNaN(latestMajor) && !isNaN(currentMajor) &&
+				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();
-			if (!update || !update.name || update.name === pkg.codeServerVersion) {
+			if (!update || this.isLatestVersion(update)) {
 				this.setState(State.Idle(UpdateType.Archive));
 			} else {
 				this.setState(State.AvailableForDownload({
@@ -73,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/"
@@ -117,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> {
@@ -128,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";
 			}
 		}

src/node/uriTransformer.js

@@ -5,20 +5,20 @@ module.exports = (remoteAuthority) => {
 		transformIncoming: (uri) => {
 			switch (uri.scheme) {
 				case "code-server": return { scheme: "file", path: uri.path };
-				case "file": return { scheme: "code-server-local", path: uri.path };
+				case "file": return { scheme: "code-server", path: uri.path };
 				default: return uri;
 			}
 		},
 		transformOutgoing: (uri) => {
 			switch (uri.scheme) {
-				case "code-server-local": return { scheme: "file", path: uri.path };
+				case "code-server": return { scheme: "file", path: uri.path };
 				case "file": return { scheme: "code-server", authority: remoteAuthority, path: uri.path };
 				default: return uri;
 			}
 		},
 		transformOutgoingScheme: (scheme) => {
 			switch (scheme) {
-				case "code-server-local": return "file";
+				case "code-server": return "file";
 				case "file": return "code-server";
 				default: return scheme;
 			}

src/node/util.ts

@@ -14,6 +14,7 @@ import { mkdirp } from "vs/base/node/pfs";
 
 export enum AuthType {
 	Password = "password",
+	None = "none",
 }
 
 export enum FormatType {
@@ -53,7 +54,7 @@ export const generateCertificate = async (): Promise<{ cert: string, certKey: st
 	return paths;
 };
 
-export const uriTransformerPath = getPathFromAmdModule(require, "vs/server/src/uriTransformer");
+export const uriTransformerPath = getPathFromAmdModule(require, "vs/server/src/node/uriTransformer");
 export const getUriTransformer = (remoteAuthority: string): URITransformer => {
 	const rawURITransformerFactory = <any>require.__$__nodeRequire(uriTransformerPath);
 	const rawURITransformer = <IRawURITransformer>rawURITransformerFactory(remoteAuthority);
@@ -127,7 +128,7 @@ export const enumToArray = (t: any): string[] => {
 
 export const buildAllowedMessage = (t: any): string => {
 	const values = enumToArray(t);
-	return `Allowed value${values.length === 1 ? " is" : "s are"} ${values.map((t) => `'${t}'`).join(",")}`;
+	return `Allowed value${values.length === 1 ? " is" : "s are"} ${values.map((t) => `'${t}'`).join(", ")}`;
 };
 
 /**
@@ -135,5 +136,5 @@ export const buildAllowedMessage = (t: any): string => {
  * at the root for Node modules.
  */
 export const localRequire = <T>(modulePath: string): T => {
-	return require.__$__nodeRequire(path.resolve(__dirname, "../node_modules", modulePath));
+	return require.__$__nodeRequire(path.resolve(__dirname, "../../node_modules", modulePath));
 };

yarn.lock

@@ -18,6 +18,25 @@
     node-fetch "^2.3.0"
     ora "^3.2.0"
 
+"@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"
+  resolved "https://registry.yarnpkg.com/@coder/requirefs/-/requirefs-1.0.6.tgz#d2d9b529d55e00da5b779aba0ac37c534a9fe55c"
+  integrity sha512-AEHfWXXJV1FGB0CjTVz+BhyS9G5xUlC0L1+/jDgGE9CuKK2obZzg3xdALFXadZhcpQGa2vXFEmrtkkW2xP6X2A==
+  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"
@@ -104,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"
@@ -224,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"
@@ -443,6 +472,13 @@ defaults@^1.0.3:
   dependencies:
     clone "^1.0.2"
 
+define-properties@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
+  integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==
+  dependencies:
+    object-keys "^1.0.12"
+
 define-property@^0.2.5:
   version "0.2.5"
   resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
@@ -475,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"
@@ -494,6 +535,31 @@ end-of-stream@^1.1.0, end-of-stream@^1.4.1:
   dependencies:
     once "^1.4.0"
 
+es-abstract@^1.12.0:
+  version "1.14.2"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.14.2.tgz#7ce108fad83068c8783c3cdf62e504e084d8c497"
+  integrity sha512-DgoQmbpFNOofkjJtKwr87Ma5EW4Dc8fWhD0R+ndq7Oc456ivUfGOOP6oAZTTKl5/CcNMP+EN+e3/iUzgE0veZg==
+  dependencies:
+    es-to-primitive "^1.2.0"
+    function-bind "^1.1.1"
+    has "^1.0.3"
+    has-symbols "^1.0.0"
+    is-callable "^1.1.4"
+    is-regex "^1.0.4"
+    object-inspect "^1.6.0"
+    object-keys "^1.1.1"
+    string.prototype.trimleft "^2.0.0"
+    string.prototype.trimright "^2.0.0"
+
+es-to-primitive@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.0.tgz#edf72478033456e8dda8ef09e00ad9650707f377"
+  integrity sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==
+  dependencies:
+    is-callable "^1.1.4"
+    is-date-object "^1.0.1"
+    is-symbol "^1.0.2"
+
 es6-promisify@^6.0.0:
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-6.0.1.tgz#6edaa45f3bd570ffe08febce66f7116be4b1cdb6"
@@ -595,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"
@@ -615,6 +690,11 @@ fsevents@^1.2.7:
     nan "^2.12.1"
     node-pre-gyp "^0.12.0"
 
+function-bind@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+  integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
+
 gauge@~2.7.3:
   version "2.7.4"
   resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
@@ -688,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==
@@ -698,6 +778,11 @@ has-flag@^3.0.0:
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
   integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
 
+has-symbols@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.0.tgz#ba1a8f1af2a0fc39650f5c850367704122063b44"
+  integrity sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=
+
 has-unicode@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
@@ -734,6 +819,13 @@ has-values@^1.0.0:
     is-number "^3.0.0"
     kind-of "^4.0.0"
 
+has@^1.0.1, has@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
+  integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
+  dependencies:
+    function-bind "^1.1.1"
+
 httpolyglot@^0.1.2:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/httpolyglot/-/httpolyglot-0.1.2.tgz#e4d347fe8984a62f467d4060df527f1851f6997b"
@@ -800,6 +892,11 @@ is-accessor-descriptor@^1.0.0:
   dependencies:
     kind-of "^6.0.0"
 
+is-arguments@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.0.4.tgz#3faf966c7cba0ff437fb31f6250082fcf0448cf3"
+  integrity sha512-xPh0Rmt8NE65sNzvyUmWgI1tz3mKq74lGA0mL8LYZcoIzKOzDh6HmrYm3d18k60nHerC8A9Km8kYu87zfSFnLA==
+
 is-binary-path@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
@@ -812,6 +909,11 @@ is-buffer@^1.1.5, is-buffer@~1.1.1:
   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
 
+is-callable@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.4.tgz#1e1adf219e1eeb684d691f9d6a05ff0d30a24d75"
+  integrity sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==
+
 is-ci@^1.0.10:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.2.1.tgz#e3779c8ee17fccf428488f6e281187f2e632841c"
@@ -833,6 +935,11 @@ is-data-descriptor@^1.0.0:
   dependencies:
     kind-of "^6.0.0"
 
+is-date-object@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
+  integrity sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=
+
 is-descriptor@^0.1.0:
   version "0.1.6"
   resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
@@ -880,6 +987,11 @@ is-fullwidth-code-point@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
   integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=
 
+is-generator-function@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.7.tgz#d2132e529bb0000a7f80794d4bdf5cd5e5813522"
+  integrity sha512-YZc5EwyO4f2kWCax7oegfuSr9mFz1ZvieNYBEjmukLxgXfBUbxAWGVF7GZf0zidYtoBl3WvC07YK0wT76a+Rtw==
+
 is-glob@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
@@ -938,6 +1050,13 @@ is-redirect@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-redirect/-/is-redirect-1.0.0.tgz#1d03dded53bd8db0f30c26e4f95d36fc7c87dc24"
   integrity sha1-HQPd7VO9jbDzDCbk+V02/HyH3CQ=
 
+is-regex@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
+  integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=
+  dependencies:
+    has "^1.0.1"
+
 is-retry-allowed@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz#11a060568b67339444033d0125a61a20d564fb34"
@@ -948,6 +1067,13 @@ is-stream@^1.0.0, is-stream@^1.1.0:
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
   integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
 
+is-symbol@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.2.tgz#a055f6ae57192caee329e7a860118b497a950f38"
+  integrity sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==
+  dependencies:
+    has-symbols "^1.0.0"
+
 is-windows@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
@@ -982,6 +1108,13 @@ jsonfile@^4.0.0:
   optionalDependencies:
     graceful-fs "^4.1.6"
 
+jszip@2.6.0:
+  version "2.6.0"
+  resolved "https://registry.yarnpkg.com/jszip/-/jszip-2.6.0.tgz#7fb3e9c2f11c8a9840612db5dabbc8cf3a7534b7"
+  integrity sha1-f7PpwvEciphAYS212rvIzzp1NLc=
+  dependencies:
+    pako "~1.0.0"
+
 kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
   version "3.2.2"
   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
@@ -1040,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"
@@ -1286,6 +1424,16 @@ object-copy@^0.1.0:
     define-property "^0.2.5"
     kind-of "^3.0.3"
 
+object-inspect@^1.6.0:
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.6.0.tgz#c70b6cbf72f274aab4c34c0c82f5167bf82cf15b"
+  integrity sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==
+
+object-keys@^1.0.12, object-keys@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
+  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
+
 object-visit@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
@@ -1293,6 +1441,16 @@ object-visit@^1.0.0:
   dependencies:
     isobject "^3.0.0"
 
+object.entries@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/object.entries/-/object.entries-1.1.0.tgz#2024fc6d6ba246aee38bdb0ffd5cfbcf371b7519"
+  integrity sha512-l+H6EQ8qzGRxbkHOd5I/aHRhHDKoQXQ8g0BYt4uSweQU1/J6dZUOyWh9a2Vky35YCKjzmgxOzta2hH6kf9HuXA==
+  dependencies:
+    define-properties "^1.1.3"
+    es-abstract "^1.12.0"
+    function-bind "^1.1.1"
+    has "^1.0.3"
+
 object.pick@^1.3.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
@@ -1359,6 +1517,11 @@ package-json@^4.0.0:
     registry-url "^3.0.3"
     semver "^5.1.0"
 
+pako@~1.0.0:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.10.tgz#4328badb5086a426aa90f541977d4955da5c9732"
+  integrity sha512-0DTvPVU3ed8+HNXOu5Bs+o//Mbdj9VNQMUOe9oKCwh8l0GNwpTDMKCWbRjgtD291AWnkAgkqA/LOnQS8AmS1tw==
+
 pascalcase@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
@@ -1665,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"
@@ -1675,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"
@@ -1707,6 +1883,22 @@ string-width@^1.0.1:
     is-fullwidth-code-point "^2.0.0"
     strip-ansi "^4.0.0"
 
+string.prototype.trimleft@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimleft/-/string.prototype.trimleft-2.1.0.tgz#6cc47f0d7eb8d62b0f3701611715a3954591d634"
+  integrity sha512-FJ6b7EgdKxxbDxc79cOlok6Afd++TTs5szo+zJTUyow3ycrRfJVE2pq3vcN53XexvKZu/DJMDfeI/qMiZTrjTw==
+  dependencies:
+    define-properties "^1.1.3"
+    function-bind "^1.1.1"
+
+string.prototype.trimright@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimright/-/string.prototype.trimright-2.1.0.tgz#669d164be9df9b6f7559fa8e89945b168a5a6c58"
+  integrity sha512-fXZTSV55dNBwv16uw+hh5jkghxSnc5oHq+5K/gXgizHwAvMetdAJlHqqoFC1FSDVPYWLkAKl2cxpUT41sV7nSg==
+  dependencies:
+    define-properties "^1.1.3"
+    function-bind "^1.1.1"
+
 string_decoder@^1.1.1:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
@@ -1837,6 +2029,22 @@ 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"
+
+typescript@3.6:
+  version "3.6.4"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.6.4.tgz#b18752bb3792bc1a0281335f7f6ebf1bbfc5b91d"
+  integrity sha512-unoCll1+l+YK4i4F8f22TaNVPRHcD9PA3yCuZ8g5e0qGqlVlJ/8FSateOLLSagn+Yg5+ZwuPkL8LFUc0Jcvksg==
+
 undefsafe@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/undefsafe/-/undefsafe-2.0.2.tgz#225f6b9e0337663e0d8e7cfd686fc2836ccace76"
@@ -1922,6 +2130,17 @@ util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
 
+util@^0.12.1:
+  version "0.12.1"
+  resolved "https://registry.yarnpkg.com/util/-/util-0.12.1.tgz#f908e7b633e7396c764e694dd14e716256ce8ade"
+  integrity sha512-MREAtYOp+GTt9/+kwf00IYoHZyjM8VU4aVrkzUlejyqaIjd2GztVl5V9hGXKlvBKE3gENn/FMfHE5v6hElXGcQ==
+  dependencies:
+    inherits "^2.0.3"
+    is-arguments "^1.0.4"
+    is-generator-function "^1.0.7"
+    object.entries "^1.1.0"
+    safe-buffer "^5.1.2"
+
 wcwidth@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/wcwidth/-/wcwidth-1.0.1.tgz#f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8"
@@ -1978,3 +2197,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==