Merge pull request #1927 from cdr/dead-code

Remove dead code

src/node/app/api.ts

@@ -1,312 +0,0 @@
-import { field, logger } from "@coder/logger"
-import * as cp from "child_process"
-import * as fs from "fs-extra"
-import * as http from "http"
-import * as net from "net"
-import * as path from "path"
-import * as url from "url"
-import * as WebSocket from "ws"
-import {
-  Application,
-  ApplicationsResponse,
-  ClientMessage,
-  RecentResponse,
-  ServerMessage,
-  SessionError,
-  SessionResponse,
-} from "../../common/api"
-import { ApiEndpoint, HttpCode, HttpError } from "../../common/http"
-import { HttpProvider, HttpProviderOptions, HttpResponse, HttpServer, Route } from "../http"
-import { findApplications, findWhitelistedApplications, Vscode } from "./bin"
-import { VscodeHttpProvider } from "./vscode"
-
-interface VsRecents {
-  [key: string]: (string | { configURIPath: string })[]
-}
-
-type VsSettings = [string, string][]
-
-/**
- * API HTTP provider.
- */
-export class ApiHttpProvider extends HttpProvider {
-  private readonly ws = new WebSocket.Server({ noServer: true })
-
-  public constructor(
-    options: HttpProviderOptions,
-    private readonly server: HttpServer,
-    private readonly vscode: VscodeHttpProvider,
-    private readonly dataDir?: string,
-  ) {
-    super(options)
-  }
-
-  public async handleRequest(route: Route, request: http.IncomingMessage): Promise<HttpResponse> {
-    this.ensureAuthenticated(request)
-    if (!this.isRoot(route)) {
-      throw new HttpError("Not found", HttpCode.NotFound)
-    }
-
-    switch (route.base) {
-      case ApiEndpoint.applications:
-        this.ensureMethod(request)
-        return {
-          mime: "application/json",
-          content: {
-            applications: await this.applications(),
-          },
-        } as HttpResponse<ApplicationsResponse>
-      case ApiEndpoint.process:
-        return this.process(request)
-      case ApiEndpoint.recent:
-        this.ensureMethod(request)
-        return {
-          mime: "application/json",
-          content: await this.recent(),
-        } as HttpResponse<RecentResponse>
-    }
-
-    throw new HttpError("Not found", HttpCode.NotFound)
-  }
-
-  public async handleWebSocket(
-    route: Route,
-    request: http.IncomingMessage,
-    socket: net.Socket,
-    head: Buffer,
-  ): Promise<void> {
-    if (!this.authenticated(request)) {
-      throw new Error("not authenticated")
-    }
-    switch (route.base) {
-      case ApiEndpoint.status:
-        return this.handleStatusSocket(request, socket, head)
-      case ApiEndpoint.run:
-        return this.handleRunSocket(route, request, socket, head)
-    }
-
-    throw new HttpError("Not found", HttpCode.NotFound)
-  }
-
-  private async handleStatusSocket(request: http.IncomingMessage, socket: net.Socket, head: Buffer): Promise<void> {
-    const getMessageResponse = async (event: "health"): Promise<ServerMessage> => {
-      switch (event) {
-        case "health":
-          return { event, connections: await this.server.getConnections() }
-        default:
-          throw new Error("unexpected message")
-      }
-    }
-
-    await new Promise<WebSocket>((resolve) => {
-      this.ws.handleUpgrade(request, socket, head, (ws) => {
-        const send = (event: ServerMessage): void => {
-          ws.send(JSON.stringify(event))
-        }
-        ws.on("message", (data) => {
-          logger.trace("got message", field("message", data))
-          try {
-            const message: ClientMessage = JSON.parse(data.toString())
-            getMessageResponse(message.event).then(send)
-          } catch (error) {
-            logger.error(error.message, field("message", data))
-          }
-        })
-        resolve()
-      })
-    })
-  }
-
-  /**
-   * A socket that connects to the process.
-   */
-  private async handleRunSocket(
-    _route: Route,
-    request: http.IncomingMessage,
-    socket: net.Socket,
-    head: Buffer,
-  ): Promise<void> {
-    logger.debug("connecting to process")
-    const ws = await new Promise<WebSocket>((resolve, reject) => {
-      this.ws.handleUpgrade(request, socket, head, (socket) => {
-        socket.binaryType = "arraybuffer"
-
-        socket.on("error", (error) => {
-          socket.close(SessionError.FailedToStart)
-          logger.error("got error while connecting socket", field("error", error))
-          reject(error)
-        })
-
-        resolve(socket as WebSocket)
-      })
-    })
-
-    logger.debug("connected to process")
-
-    // Send ready message.
-    ws.send(
-      Buffer.from(
-        JSON.stringify({
-          protocol: "TODO",
-        }),
-      ),
-    )
-  }
-
-  /**
-   * Return whitelisted applications.
-   */
-  public async applications(): Promise<ReadonlyArray<Application>> {
-    return findWhitelistedApplications()
-  }
-
-  /**
-   * Return installed applications.
-   */
-  public async installedApplications(): Promise<ReadonlyArray<Application>> {
-    return findApplications()
-  }
-
-  /**
-   * Handle /process endpoint.
-   */
-  private async process(request: http.IncomingMessage): Promise<HttpResponse> {
-    this.ensureMethod(request, ["DELETE", "POST"])
-
-    const data = await this.getData(request)
-    if (!data) {
-      throw new HttpError("No data was provided", HttpCode.BadRequest)
-    }
-
-    const parsed: Application = JSON.parse(data)
-
-    switch (request.method) {
-      case "DELETE":
-        if (parsed.pid) {
-          await this.killProcess(parsed.pid)
-        } else if (parsed.path) {
-          await this.killProcess(parsed.path)
-        } else {
-          throw new Error("No pid or path was provided")
-        }
-        return {
-          mime: "application/json",
-          code: HttpCode.Ok,
-        }
-      case "POST": {
-        if (!parsed.exec) {
-          throw new Error("No exec was provided")
-        }
-        return {
-          mime: "application/json",
-          content: {
-            created: true,
-            pid: await this.spawnProcess(parsed.exec),
-          },
-        } as HttpResponse<SessionResponse>
-      }
-    }
-
-    throw new HttpError("Not found", HttpCode.NotFound)
-  }
-
-  /**
-   * Kill a process identified by pid or path if a web app.
-   */
-  public async killProcess(pid: number | string): Promise<void> {
-    if (typeof pid === "string") {
-      switch (pid) {
-        case Vscode.path:
-          await this.vscode.dispose()
-          break
-        default:
-          throw new Error(`Process "${pid}" does not exist`)
-      }
-    } else {
-      process.kill(pid)
-    }
-  }
-
-  /**
-   * Spawn a process and return the pid.
-   */
-  public async spawnProcess(exec: string): Promise<number> {
-    const proc = cp.spawn(exec, {
-      shell: process.env.SHELL || true,
-      env: {
-        ...process.env,
-      },
-    })
-
-    proc.on("error", (error) => logger.error("process errored", field("pid", proc.pid), field("error", error)))
-    proc.on("exit", () => logger.debug("process exited", field("pid", proc.pid)))
-
-    logger.debug("started process", field("pid", proc.pid))
-
-    return proc.pid
-  }
-
-  /**
-   * Return VS Code's recent paths.
-   */
-  public async recent(): Promise<RecentResponse> {
-    try {
-      if (!this.dataDir) {
-        throw new Error("data directory is not set")
-      }
-
-      const state: VsSettings = JSON.parse(await fs.readFile(path.join(this.dataDir, "User/state/global.json"), "utf8"))
-      const setting = Array.isArray(state) && state.find((item) => item[0] === "recently.opened")
-      if (!setting) {
-        return { paths: [], workspaces: [] }
-      }
-
-      const pathPromises: { [key: string]: Promise<string> } = {}
-      const workspacePromises: { [key: string]: Promise<string> } = {}
-      Object.values(JSON.parse(setting[1]) as VsRecents).forEach((recents) => {
-        recents.forEach((recent) => {
-          try {
-            const target = typeof recent === "string" ? pathPromises : workspacePromises
-            const pathname = url.parse(typeof recent === "string" ? recent : recent.configURIPath).pathname
-            if (pathname && !target[pathname]) {
-              target[pathname] = new Promise<string>((resolve) => {
-                fs.stat(pathname)
-                  .then(() => resolve(pathname))
-                  .catch(() => resolve())
-              })
-            }
-          } catch (error) {
-            logger.debug("invalid path", field("path", recent))
-          }
-        })
-      })
-
-      const [paths, workspaces] = await Promise.all([
-        Promise.all(Object.values(pathPromises)),
-        Promise.all(Object.values(workspacePromises)),
-      ])
-
-      return {
-        paths: paths.filter((p) => !!p),
-        workspaces: workspaces.filter((p) => !!p),
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error
-      }
-    }
-
-    return { paths: [], workspaces: [] }
-  }
-
-  /**
-   * For these, just return the error message since they'll be requested as
-   * JSON.
-   */
-  public async getErrorRoot(_route: Route, _title: string, _header: string, error: string): Promise<HttpResponse> {
-    return {
-      mime: "application/json",
-      content: JSON.stringify({ error }),
-    }
-  }
-}

src/node/app/bin.ts

@@ -1,30 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import { Application } from "../../common/api"
-
-const getVscodeVersion = (): string => {
-  try {
-    return require(path.resolve(__dirname, "../../../lib/vscode/package.json")).version
-  } catch (error) {
-    return "unknown"
-  }
-}
-
-export const Vscode: Application = {
-  categories: ["Editor"],
-  icon: fs.readFileSync(path.resolve(__dirname, "../../../lib/vscode/resources/linux/code.png")).toString("base64"),
-  installed: true,
-  name: "VS Code",
-  path: "/",
-  version: getVscodeVersion(),
-}
-
-export const findApplications = async (): Promise<ReadonlyArray<Application>> => {
-  const apps: Application[] = [Vscode]
-
-  return apps.sort((a, b): number => a.name.localeCompare(b.name))
-}
-
-export const findWhitelistedApplications = async (): Promise<ReadonlyArray<Application>> => {
-  return [Vscode]
-}

src/node/app/dashboard.ts

@@ -1,147 +0,0 @@
-import * as http from "http"
-import * as querystring from "querystring"
-import { Application } from "../../common/api"
-import { HttpCode, HttpError } from "../../common/http"
-import { normalize } from "../../common/util"
-import { HttpProvider, HttpProviderOptions, HttpResponse, Route } from "../http"
-import { ApiHttpProvider } from "./api"
-import { UpdateHttpProvider } from "./update"
-
-/**
- * Dashboard HTTP provider.
- */
-export class DashboardHttpProvider extends HttpProvider {
-  public constructor(
-    options: HttpProviderOptions,
-    private readonly api: ApiHttpProvider,
-    private readonly update: UpdateHttpProvider,
-  ) {
-    super(options)
-  }
-
-  public async handleRequest(route: Route, request: http.IncomingMessage): Promise<HttpResponse> {
-    if (!this.isRoot(route)) {
-      throw new HttpError("Not found", HttpCode.NotFound)
-    }
-
-    switch (route.base) {
-      case "/spawn": {
-        this.ensureAuthenticated(request)
-        this.ensureMethod(request, "POST")
-        const data = await this.getData(request)
-        const app = data ? querystring.parse(data) : {}
-        if (app.path) {
-          return { redirect: Array.isArray(app.path) ? app.path[0] : app.path }
-        }
-        if (!app.exec) {
-          throw new Error("No exec was provided")
-        }
-        this.api.spawnProcess(Array.isArray(app.exec) ? app.exec[0] : app.exec)
-        return { redirect: this.options.base }
-      }
-      case "/app":
-      case "/": {
-        this.ensureMethod(request)
-        if (!this.authenticated(request)) {
-          return { redirect: "/login", query: { to: this.options.base } }
-        }
-        return route.base === "/" ? this.getRoot(route) : this.getAppRoot(route)
-      }
-    }
-
-    throw new HttpError("Not found", HttpCode.NotFound)
-  }
-
-  public async getRoot(route: Route): Promise<HttpResponse> {
-    const base = this.base(route)
-    const apps = await this.api.installedApplications()
-    const response = await this.getUtf8Resource(this.rootPath, "src/browser/pages/home.html")
-    response.content = response.content
-      .replace(/{{UPDATE:NAME}}/, await this.getUpdate(base))
-      .replace(
-        /{{APP_LIST:EDITORS}}/,
-        this.getAppRows(
-          base,
-          apps.filter((app) => app.categories && app.categories.includes("Editor")),
-        ),
-      )
-      .replace(
-        /{{APP_LIST:OTHER}}/,
-        this.getAppRows(
-          base,
-          apps.filter((app) => !app.categories || !app.categories.includes("Editor")),
-        ),
-      )
-    return this.replaceTemplates(route, response)
-  }
-
-  public async getAppRoot(route: Route): Promise<HttpResponse> {
-    const response = await this.getUtf8Resource(this.rootPath, "src/browser/pages/app.html")
-    return this.replaceTemplates(route, response)
-  }
-
-  private getAppRows(base: string, apps: ReadonlyArray<Application>): string {
-    return apps.length > 0
-      ? apps.map((app) => this.getAppRow(base, app)).join("\n")
-      : `<div class="none">No applications found.</div>`
-  }
-
-  private getAppRow(base: string, app: Application): string {
-    return `<form class="block-row${app.exec ? " -x11" : ""}" method="post" action="${normalize(
-      `${base}${this.options.base}/spawn`,
-    )}">
-      <button class="item -row -link">
-        <input type="hidden" name="path" value="${app.path || ""}">
-        <input type="hidden" name="exec" value="${app.exec || ""}">
-        ${
-          app.icon
-            ? `<img class="icon" src="data:image/png;base64,${app.icon}"></img>`
-            : `<span class="icon -missing"></span>`
-        }
-        <span class="name">${app.name}</span>
-      </button>
-    </form>`
-  }
-
-  private async getUpdate(base: string): Promise<string> {
-    if (!this.update.enabled) {
-      return `<div class="block-row"><div class="item"><div class="sub">Updates are disabled</div></div></div>`
-    }
-
-    const humanize = (time: number): string => {
-      const d = new Date(time)
-      const pad = (t: number): string => (t < 10 ? "0" : "") + t
-      return (
-        `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
-        ` ${pad(d.getHours())}:${pad(d.getMinutes())}`
-      )
-    }
-
-    const update = await this.update.getUpdate()
-    if (this.update.isLatestVersion(update)) {
-      return `<div class="block-row">
-        <div class="item">
-          Latest: ${update.version}
-          <div class="sub">Up to date</div>
-        </div>
-        <div class="item">
-          ${humanize(update.checked)}
-          <a class="sub -link" href="${base}/update/check?to=${this.options.base}">Check now</a>
-        </div>
-        <div class="item" >Current: ${this.update.currentVersion}</div>
-      </div>`
-    }
-
-    return `<div class="block-row">
-      <div class="item">
-        Latest: ${update.version}
-        <div class="sub">Out of date</div>
-      </div>
-      <div class="item">
-        ${humanize(update.checked)}
-        <a class="sub -link" href="${base}/update?to=${this.options.base}">Update now</a>
-      </div>
-      <div class="item" >Current: ${this.update.currentVersion}</div>
-    </div>`
-  }
-}

src/node/app/proxy.ts

@@ -24,7 +24,7 @@ export class ProxyHttpProvider extends HttpProvider {
     const port = route.base.replace(/^\//, "")
     return {
       proxy: {
-        base: `${this.options.base}/${port}`,
+        strip: `${route.providerBase}/${port}`,
         port,
       },
     }
@@ -35,7 +35,7 @@ export class ProxyHttpProvider extends HttpProvider {
     const port = route.base.replace(/^\//, "")
     return {
       proxy: {
-        base: `${this.options.base}/${port}`,
+        strip: `${route.providerBase}/${port}`,
         port,
       },
     }

src/node/app/update.ts

@@ -1,21 +1,12 @@
 import { field, logger } from "@coder/logger"
-import * as cp from "child_process"
-import * as fs from "fs-extra"
 import * as http from "http"
 import * as https from "https"
-import * as os from "os"
 import * as path from "path"
 import * as semver from "semver"
-import { Readable, Writable } from "stream"
-import * as tar from "tar-fs"
 import * as url from "url"
-import * as util from "util"
-import * as zlib from "zlib"
 import { HttpCode, HttpError } from "../../common/http"
 import { HttpProvider, HttpProviderOptions, HttpResponse, Route } from "../http"
 import { settings as globalSettings, SettingsProvider, UpdateSettings } from "../settings"
-import { tmpdir } from "../util"
-import { ipcMain } from "../wrapper"
 
 export interface Update {
   checked: number
@@ -27,7 +18,7 @@ export interface LatestResponse {
 }
 
 /**
- * Update HTTP provider.
+ * HTTP provider for checking updates (does not download/install them).
  */
 export class UpdateHttpProvider extends HttpProvider {
   private update?: Promise<Update>
@@ -41,12 +32,6 @@ export class UpdateHttpProvider extends HttpProvider {
      * that fulfills `LatestResponse`.
      */
     private readonly latestUrl = "https://api.github.com/repos/cdr/code-server/releases/latest",
-    /**
-     * The URL for downloading a version of code-server. {{VERSION}} and
-     * {{RELEASE_NAME}} will be replaced (for example 2.1.0 and
-     * code-server-2.1.0-linux-x86_64.tar.gz).
-     */
-    private readonly downloadUrl = "https://github.com/cdr/code-server/releases/download/{{VERSION}}/{{RELEASE_NAME}}",
     /**
      * Update information will be stored here. If not provided, the global
      * settings will be used.
@@ -64,66 +49,30 @@ export class UpdateHttpProvider extends HttpProvider {
       throw new HttpError("Not found", HttpCode.NotFound)
     }
 
-    switch (route.base) {
-      case "/check":
-        this.getUpdate(true)
-        if (route.query && route.query.to) {
-          return {
-            redirect: Array.isArray(route.query.to) ? route.query.to[0] : route.query.to,
-            query: { to: undefined },
-          }
-        }
-        return this.getRoot(route, request)
-      case "/apply":
-        return this.tryUpdate(route, request)
-      case "/":
-        return this.getRoot(route, request)
+    if (!this.enabled) {
+      throw new Error("update checks are disabled")
     }
 
-    throw new HttpError("Not found", HttpCode.NotFound)
-  }
-
-  public async getRoot(
-    route: Route,
-    request: http.IncomingMessage,
-    errorOrUpdate?: Update | Error,
-  ): Promise<HttpResponse> {
-    if (request.headers["content-type"] === "application/json") {
-      if (!this.enabled) {
+    switch (route.base) {
+      case "/check":
+      case "/": {
+        const update = await this.getUpdate(route.base === "/check")
         return {
           content: {
-            isLatest: true,
+            ...update,
+            isLatest: this.isLatestVersion(update),
           },
         }
       }
-      const update = await this.getUpdate()
-      return {
-        content: {
-          ...update,
-          isLatest: this.isLatestVersion(update),
-        },
-      }
     }
-    const response = await this.getUtf8Resource(this.rootPath, "src/browser/pages/update.html")
-    response.content = response.content
-      .replace(
-        /{{UPDATE_STATUS}}/,
-        errorOrUpdate && !(errorOrUpdate instanceof Error)
-          ? `Updated to ${errorOrUpdate.version}`
-          : await this.getUpdateHtml(),
-      )
-      .replace(/{{ERROR}}/, errorOrUpdate instanceof Error ? `<div class="error">${errorOrUpdate.message}</div>` : "")
-    return this.replaceTemplates(route, response)
+
+    throw new HttpError("Not found", HttpCode.NotFound)
   }
 
   /**
    * Query for and return the latest update.
    */
   public async getUpdate(force?: boolean): Promise<Update> {
-    if (!this.enabled) {
-      throw new Error("updates are not enabled")
-    }
-
     // Don't run multiple requests at a time.
     if (!this.update) {
       this.update = this._getUpdate(force)
@@ -171,128 +120,6 @@ export class UpdateHttpProvider extends HttpProvider {
     }
   }
 
-  private async getUpdateHtml(): Promise<string> {
-    if (!this.enabled) {
-      return "Updates are disabled"
-    }
-
-    const update = await this.getUpdate()
-    if (this.isLatestVersion(update)) {
-      return "No update available"
-    }
-
-    return `<button type="submit" class="apply -button">Update to ${update.version}</button>`
-  }
-
-  public async tryUpdate(route: Route, request: http.IncomingMessage): Promise<HttpResponse> {
-    try {
-      const update = await this.getUpdate()
-      if (!this.isLatestVersion(update)) {
-        await this.downloadAndApplyUpdate(update)
-        return this.getRoot(route, request, update)
-      }
-      return this.getRoot(route, request)
-    } catch (error) {
-      // For JSON requests propagate the error. Otherwise catch it so we can
-      // show the error inline with the update button instead of an error page.
-      if (request.headers["content-type"] === "application/json") {
-        throw error
-      }
-      return this.getRoot(route, error)
-    }
-  }
-
-  public async downloadAndApplyUpdate(update: Update, targetPath?: string): Promise<void> {
-    const releaseName = await this.getReleaseName(update)
-    const url = this.downloadUrl.replace("{{VERSION}}", update.version).replace("{{RELEASE_NAME}}", releaseName)
-
-    let downloadPath = path.join(tmpdir, "updates", releaseName)
-    fs.mkdirp(path.dirname(downloadPath))
-
-    const response = await this.requestResponse(url)
-
-    try {
-      downloadPath = await this.extractTar(response, downloadPath)
-      logger.debug("Downloaded update", field("path", downloadPath))
-
-      // The archive should have a directory inside at the top level with the
-      // same name as the archive.
-      const directoryPath = path.join(downloadPath, path.basename(downloadPath))
-      await fs.stat(directoryPath)
-
-      if (!targetPath) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        targetPath = path.resolve(__dirname, "../../../")
-      }
-
-      // Move the old directory to prevent potential data loss.
-      const backupPath = path.resolve(targetPath, `../${path.basename(targetPath)}.${Date.now().toString()}`)
-      logger.debug("Replacing files", field("target", targetPath), field("backup", backupPath))
-      await fs.move(targetPath, backupPath)
-
-      // Move the new directory.
-      await fs.move(directoryPath, targetPath)
-
-      await fs.remove(downloadPath)
-
-      if (process.send) {
-        ipcMain().relaunch(update.version)
-      }
-    } catch (error) {
-      response.destroy(error)
-      throw error
-    }
-  }
-
-  private async extractTar(response: Readable, downloadPath: string): Promise<string> {
-    downloadPath = downloadPath.replace(/\.tar\.gz$/, "")
-    logger.debug("Extracting tar", field("path", downloadPath))
-
-    response.pause()
-    await fs.remove(downloadPath)
-
-    const decompress = zlib.createGunzip()
-    response.pipe(decompress as Writable)
-    response.on("error", (error) => decompress.destroy(error))
-    response.on("close", () => decompress.end())
-
-    const destination = tar.extract(downloadPath)
-    decompress.pipe(destination)
-    decompress.on("error", (error) => destination.destroy(error))
-    decompress.on("close", () => destination.end())
-
-    await new Promise((resolve, reject) => {
-      destination.on("finish", resolve)
-      destination.on("error", reject)
-      response.resume()
-    })
-
-    return downloadPath
-  }
-
-  /**
-   * Given an update return the name for the packaged archived.
-   */
-  public async getReleaseName(update: Update): Promise<string> {
-    let target: string = os.platform()
-    if (target === "linux") {
-      const result = await util
-        .promisify(cp.exec)("ldd --version")
-        .catch((error) => ({
-          stderr: error.message,
-          stdout: "",
-        }))
-      if (/musl/.test(result.stderr) || /musl/.test(result.stdout)) {
-        target = "alpine"
-      }
-    }
-    let arch = os.arch()
-    if (arch === "x64") {
-      arch = "x86_64"
-    }
-    return `code-server-${update.version}-${target}-${arch}.tar.gz`
-  }
-
   private async request(uri: string): Promise<Buffer> {
     const response = await this.requestResponse(uri)
     return new Promise((resolve, reject) => {

src/node/app/vscode.ts

@@ -14,7 +14,7 @@ import {
   WorkbenchOptions,
 } from "../../../lib/vscode/src/vs/server/ipc"
 import { HttpCode, HttpError } from "../../common/http"
-import { generateUuid } from "../../common/util"
+import { arrayify, generateUuid } from "../../common/util"
 import { Args } from "../cli"
 import { HttpProvider, HttpProviderOptions, HttpResponse, Route } from "../http"
 import { settings } from "../settings"
@@ -131,7 +131,7 @@ export class VscodeHttpProvider extends HttpProvider {
         if (!this.isRoot(route)) {
           throw new HttpError("Not found", HttpCode.NotFound)
         } else if (!this.authenticated(request)) {
-          return { redirect: "/login", query: { to: this.options.base } }
+          return { redirect: "/login", query: { to: route.providerBase } }
         }
         try {
           return await this.getRoot(request, route)
@@ -223,8 +223,7 @@ export class VscodeHttpProvider extends HttpProvider {
     }
     for (let i = 0; i < startPaths.length; ++i) {
       const startPath = startPaths[i]
-      const url =
-        startPath && (typeof startPath.url === "string" ? [startPath.url] : startPath.url || []).find((p) => !!p)
+      const url = arrayify(startPath && startPath.url).find((p) => !!p)
       if (startPath && url) {
         return {
           url,