Refactor missing tar endpoint.

Author: GirlBossRush

ci/dev/vscode.patch

@@ -986,17 +986,17 @@ index 0000000000000000000000000000000000000000..5dd5406befcb593ad6366d9e98f46485
 +export const IExtHostNodeProxy = createDecorator<IExtHostNodeProxy>('IExtHostNodeProxy');
 diff --git a/src/vs/server/browser/mainThreadNodeProxy.ts b/src/vs/server/browser/mainThreadNodeProxy.ts
 new file mode 100644
-index 0000000000000000000000000000000000000000..21a139288e5b8f56016491879d69d01da929decb
+index 0000000000000000000000000000000000000000..e11988d1b3263c4a2ede064c653653b038c8238c
 --- /dev/null
 +++ b/src/vs/server/browser/mainThreadNodeProxy.ts
-@@ -0,0 +1,55 @@
+@@ -0,0 +1,63 @@
 +import { VSBuffer } from 'vs/base/common/buffer';
 +import { IDisposable } from 'vs/base/common/lifecycle';
 +import { FileAccess } from 'vs/base/common/network';
 +import { URI, UriComponents } from 'vs/base/common/uri';
 +import { INodeProxyService } from 'vs/server/common/nodeProxy';
 +import { ExtHostContext, IExtHostContext, MainContext, MainThreadNodeProxyShape } from 'vs/workbench/api/common/extHost.protocol';
-+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
++import {extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 +
 +@extHostNamedCustomer(MainContext.MainThreadNodeProxy)
 +export class MainThreadNodeProxy implements MainThreadNodeProxyShape {
@@ -1025,14 +1025,22 @@ index 0000000000000000000000000000000000000000..21a139288e5b8f56016491879d69d01d
 +	}
 +
 +	async $fetchExtension(extensionUri: UriComponents): Promise<VSBuffer> {
++		// Use FileAccess to get the static base path.
++		const basePath = FileAccess.asBrowserUri("", require).path;
++
 +		const fetchUri = URI.from({
 +			scheme: window.location.protocol.replace(':', ''),
 +			authority: window.location.host,
-+			// Use FileAccess to get the static base path.
-+			path: FileAccess.asBrowserUri("", require).path,
-+			query: `tar=${encodeURIComponent(extensionUri.path)}`,
++			path: `${basePath}../../../extension/tar`,
++			query: `filePath=${encodeURIComponent(extensionUri.path)}`,
 +		});
-+		const response = await fetch(fetchUri.toString(true));
++
++		const response = await fetch(fetchUri.toString(true), {
++			headers: {
++				Accept: "application/x-tar, application/json;q=0.9"
++			}
++		});
++
 +		if (response.status !== 200) {
 +			throw new Error(`Failed to download extension "${module}"`);
 +		}

src/browser/views/vscode/index.handlebars

@@ -29,15 +29,15 @@
     <link rel="manifest" href="./code-server.webmanifest" crossorigin="use-credentials" />
 
     {{#if (prod)}}
-      <link data-name="vs/workbench/workbench.web.api" rel="stylesheet" href="{{assetPath base '/static/lib/vscode/out/vs/workbench/workbench.web.api.css'}}">
+      <link data-name="vs/workbench/workbench.web.api" rel="stylesheet" href="{{assetPath base '/vscode/lib/vscode/out/vs/workbench/workbench.web.api.css'}}">
     {{/if}}
 
     <link rel="apple-touch-icon" href="{{assetPath base '/static/media/pwa-icon-384.png'}}" />
     <meta name="apple-mobile-web-app-capable" content="yes" />
 
     <!-- Prefetch to avoid waterfall -->
     {{#if (prod)}}
-      <link rel="prefetch" href="{{assetPath base '/static/lib/vscode/node_modules/semver-umd/lib/semver-umd.js'}}">
+      <link rel="prefetch" href="{{assetPath base '/vscode/lib/vscode/node_modules/semver-umd/lib/semver-umd.js'}}">
     {{/if}}
 
     <meta id="coder-options" data-settings="{{{json coderOptions}}}" />
@@ -48,19 +48,19 @@
   <!-- Startup (do not modify order of script tags!) -->
   <script data-cfasync="false" src="{{assetPath base '/static/views/vscode/index.js'}}"></script>
   <script data-cfasync="false" src="{{assetPath base '/static/main.js'}}"></script>
-  <script data-cfasync="false" src="{{assetPath base '/static/lib/vscode/out/vs/loader.js'}}"></script>
+  <script data-cfasync="false" src="{{assetPath base '/vscode/lib/vscode/out/vs/loader.js'}}"></script>
 
   <script>
     globalThis.MonacoPerformanceMarks.push("willLoadWorkbenchMain", Date.now());
   </script>
 
   {{#if (prod)}}
-    <script data-cfasync="false" src="{{assetPath base '/static/lib/vscode/out/vs/workbench/workbench.web.api.nls.js'}}"></script>
-    <script data-cfasync="false" src="{{assetPath base '/static/lib/vscode/out/vs/workbench/workbench.web.api.js'}}"></script>
+    <script data-cfasync="false" src="{{assetPath base '/vscode/lib/vscode/out/vs/workbench/workbench.web.api.nls.js'}}"></script>
+    <script data-cfasync="false" src="{{assetPath base '/vscode/lib/vscode/out/vs/workbench/workbench.web.api.js'}}"></script>
   {{/if}}
 
   <script>
-    require.config({baseUrl: `${window.location.origin}/{{base}}/static/lib/vscode/out`});
+    require.config({baseUrl: `${window.location.origin}/{{base}}/vscode/lib/vscode/out`});
     require(["vs/code/browser/workbench/workbench"], function () {});
   </script>
 </html>

src/browser/views/vscode/index.ts

@@ -77,7 +77,7 @@ const initializeCodeServerEditor = () => {
 
   const amdLoaderConfig: CodeServerAmdLoaderConfigurationOptions = {
     // Without the full URL VS Code will try to load file://.
-    baseUrl: `${window.location.origin}${options.base}/static/lib/vscode/out`,
+    baseUrl: `${window.location.origin}${options.base}/vscode/lib/vscode/out`,
     recordStats: true,
     paths: {
       "vscode-textmate": `../node_modules/vscode-textmate/release/main`,

src/node/app.ts

@@ -8,7 +8,7 @@ import * as httpolyglot from "httpolyglot"
 import { resolve } from "path"
 import { normalize } from "../common/util"
 import { DefaultedArgs } from "./cli"
-import { rootPath } from "./constants"
+import { commit, rootPath } from "./constants"
 import { handleUpgrade } from "./wsRouter"
 
 /**
@@ -24,7 +24,7 @@ export const createApp = async (args: DefaultedArgs): Promise<[Express, Express,
     exphbs({
       defaultLayout: "",
       helpers: {
-        prod: () => prod,
+        prod: () => commit !== "development",
         assetPath: (base: string, path: string) => normalize(base + path),
         /**
          * Converts to JSON string and encodes entities for use in HTML.

src/node/routes/index.ts

@@ -132,14 +132,15 @@ export const register = async (
     }
 
     const status = err.status ?? err.statusCode ?? 500
+    const message = err.message || "An unknown server error occured"
 
     try {
       res.status(status).render("error/index", {
         ...commonTemplateVars(req),
         HOME_PATH: (typeof req.query.to === "string" && req.query.to) || "/",
         ERROR_TITLE: status,
         ERROR_HEADER: status,
-        ERROR_BODY: err.message,
+        ERROR_BODY: message,
       })
     } catch (error) {
       next(error)

src/node/routes/static.ts

@@ -1,15 +1,20 @@
-import { Router, static as _static } from "express"
+import { Router, static as createStaticRouteHandler } from "express"
 import { resolve } from "path"
-import { rootPath } from "../constants"
+import { commit, rootPath } from "../constants"
 
 export const router = Router()
 
 const staticPaths: Record<string, string> = {
   "/static": "dist",
-  "/static/lib": "lib",
   "/static/media": "src/browser/public/media",
 }
 
 for (const [publicRoute, sourcePath] of Object.entries(staticPaths)) {
-  router.use(publicRoute, _static(resolve(rootPath, sourcePath), { index: false }))
+  router.use(
+    publicRoute,
+    createStaticRouteHandler(resolve(rootPath, sourcePath), {
+      index: false,
+      cacheControl: commit !== "development",
+    }),
+  )
 }

src/node/routes/vscode.ts

@@ -1,9 +1,16 @@
+import { field, logger } from "@coder/logger"
 import * as crypto from "crypto"
-import { Router } from "express"
+import { RequestHandler, Router, static as createStaticRouteHandler } from "express"
 import { promises as fs } from "fs"
 import * as path from "path"
+import { resolve } from "path"
+import { ParsedQs } from "qs"
+import { Readable } from "stream"
+import * as tarFs from "tar-fs"
+import * as zlib from "zlib"
 import { WorkbenchOptions } from "../../../lib/vscode/src/vs/server/ipc"
-import { commit, version } from "../constants"
+import { HttpCode, HttpError } from "../../common/http"
+import { commit, rootPath, version } from "../constants"
 import { authenticated, commonTemplateVars, ensureAuthenticated, redirect } from "../http"
 import { getMediaMime, pathToFsPath } from "../util"
 import { VscodeProvider } from "../vscode"
@@ -96,3 +103,53 @@ wsRouter.ws("/", ensureAuthenticated, async (req) => {
   )
   await vscode.sendWebsocket(req.ws, req.query)
 })
+router.use(
+  "/lib",
+  createStaticRouteHandler(resolve(rootPath, "lib"), {
+    index: false,
+    cacheControl: commit !== "development",
+  }),
+)
+
+interface TarHandlerQueryParams extends ParsedQs {
+  filePath?: string | string[]
+}
+
+/**
+ * Packs and serves requested file with tar.
+ * This is commonly used to fetch an extension on the client.
+ *
+ * @remark See lib/vscode/src/vs/server/browser/mainThreadNodeProxy.ts#L35
+ */
+const tarHandler: RequestHandler<any, Buffer, null, TarHandlerQueryParams> = (req, res) => {
+  const filePath = Array.isArray(req.query.filePath) ? req.query.filePath[0] : req.query.filePath
+
+  if (!filePath) {
+    throw new HttpError("Missing 'filePath' query param", HttpCode.BadRequest)
+  }
+
+  const resourcePath = resolve(filePath)
+
+  let stream: Readable = tarFs.pack(pathToFsPath(filePath))
+
+  if (req.headers["accept-encoding"] && req.headers["accept-encoding"].includes("gzip")) {
+    logger.debug("gzipping tar", field("path", resourcePath))
+
+    const compress = zlib.createGzip()
+
+    stream.pipe(compress)
+    stream.on("error", (error) => compress.destroy(error))
+    stream.on("close", () => compress.end())
+
+    stream = compress
+
+    res.header("content-encoding", "gzip")
+  }
+
+  res.set("Content-Type", "application/x-tar")
+  stream.on("close", () => res.end())
+
+  return stream.pipe(res)
+}
+
+router.get("/extension/tar", tarHandler)