its working

Author: jsjoeio

src/node/routes/vscode.ts

@@ -1,12 +1,13 @@
 import { logger } from "@coder/logger"
 import * as express from "express"
+import * as path from "path"
 import { WebsocketRequest } from "../../../typings/pluginapi"
 import { logError } from "../../common/util"
 import { toVsCodeArgs } from "../cli"
 import { isDevMode } from "../constants"
 import { authenticated, ensureAuthenticated, redirect, self } from "../http"
 import { SocketProxyProvider } from "../socket"
-import { loadAMDModule } from "../util"
+import { isFile, loadAMDModule } from "../util"
 import { Router as WsRouter } from "../wsRouter"
 import { errorHandler } from "./errors"
 
@@ -33,42 +34,47 @@ export class CodeServerRouteWrapper {
       })
     }
 
-    const { query } = await req.settings.read()
+    const settings = await req.settings.read()
+    const lastOpened = settings.query || {}
 
-    if (!query && req.args["_"].length > 0) {
-      // TODO@jsjoeio - we alos need to check for workspace arg
-      const folder = req.args["_"][0]
-
-      await req.settings.write({
-        query: {
-          folder,
-        },
-      })
-
-      const to = self(req)
-      return redirect(req, res, to, {
-        folder,
-      })
+    // Ew means the workspace was closed so clear the last folder/workspace.
+    if (req.query.ew) {
+      delete lastOpened.folder
+      delete lastOpened.workspace
     }
-    if (query) {
-      // Ew means the workspace was closed so clear the last folder/workspace.
-      if (req.query.ew) {
-        delete query.folder
-        delete query.workspace
-      }
 
+    if (!req.query.folder && !req.query.workspace) {
       // Redirect to the last folder/workspace if nothing else is opened.
       if (
-        !req.query.folder &&
-        !req.query.workspace &&
-        (query.folder || query.workspace) &&
+        (lastOpened.folder || lastOpened.workspace) &&
         !req.args["ignore-last-opened"] // This flag disables this behavior.
       ) {
         const to = self(req)
         return redirect(req, res, to, {
-          folder: query.folder,
-          workspace: query.workspace,
+          folder: lastOpened.folder,
+          workspace: lastOpened.workspace,
         })
+      } else if (req.args._.length > 0) {
+        let folder = undefined
+        let workspace = undefined
+        const newQueries: any = {}
+        if (req.args._.length) {
+          const lastEntry = path.resolve(req.args._[req.args._.length - 1])
+          const entryIsFile = await isFile(lastEntry)
+          if (entryIsFile && path.extname(lastEntry) === ".code-workspace") {
+            workspace = lastEntry
+            newQueries.workspace = workspace
+          } else if (!entryIsFile) {
+            folder = lastEntry
+            newQueries.folder = folder
+          }
+
+          const to = self(req)
+          return redirect(req, res, to, {
+            folder,
+            workspace,
+          })
+        }
       }
     }
 

test/unit/node/routes/vscode.test.ts

@@ -1,19 +1,9 @@
 import { promises as fs } from "fs"
-import { Response } from "node-fetch"
 import * as path from "path"
 import { clean, tmpdir } from "../../../utils/helpers"
 import * as httpserver from "../../../utils/httpserver"
 import * as integration from "../../../utils/integration"
 
-interface WorkbenchConfig {
-  folderUri?: {
-    path: string
-  }
-  workspaceUri?: {
-    path: string
-  }
-}
-
 describe("vscode", () => {
   let codeServer: httpserver.HttpServer | undefined
 
@@ -52,52 +42,25 @@ describe("vscode", () => {
     }
   })
 
-  /**
-   * Get the workbench config from the provided response.
-   */
-  const getConfig = async (resp: Response): Promise<WorkbenchConfig> => {
-    expect(resp.status).toBe(200)
-    const html = await resp.text()
-    const match = html.match(/<meta id="vscode-workbench-web-configuration" data-settings="(.+)">/)
-    if (!match || !match[1]) {
-      throw new Error("Unable to find workbench configuration")
-    }
-    const config = match[1].replace(/&quot;/g, '"')
-    try {
-      return JSON.parse(config)
-    } catch (error) {
-      console.error("Failed to parse workbench configuration", config)
-      throw error
-    }
-  }
-
-  it("should have no default folder or workspace", async () => {
-    codeServer = await integration.setup(["--auth=none"], "")
-
-    const config = await getConfig(await codeServer.fetch("/"))
-    expect(config.folderUri).toBeUndefined()
-    expect(config.workspaceUri).toBeUndefined()
-  })
-
-  it("should have a default folder", async () => {
-    const defaultDir = await tmpdir(testName)
-    codeServer = await integration.setup(["--auth=none", defaultDir], "")
+  it("should redirect to the passed in workspace", async () => {
+    const workspace = path.join(await tmpdir(testName), "test.code-workspace")
+    await fs.writeFile(workspace, "")
+    codeServer = await integration.setup(["--auth=none", workspace], "")
 
-    // At first it will load the directory provided on the command line.
-    const config = await getConfig(await codeServer.fetch("/"))
-    expect(config.folderUri?.path).toBe(defaultDir)
-    expect(config.workspaceUri).toBeUndefined()
+    const resp = await codeServer.fetch("/")
+    const url = new URL(resp.url)
+    expect(url.pathname).toBe("/")
+    expect(url.search).toBe(`?workspace=${workspace}`)
   })
 
-  it("should have a default workspace", async () => {
-    const defaultWorkspace = path.join(await tmpdir(testName), "test.code-workspace")
-    await fs.writeFile(defaultWorkspace, "")
-    codeServer = await integration.setup(["--auth=none", defaultWorkspace], "")
+  it("should redirect to the passed in directory", async () => {
+    const folder = await tmpdir(testName)
+    codeServer = await integration.setup(["--auth=none", folder], "")
 
-    // At first it will load the workspace provided on the command line.
-    const config = await getConfig(await codeServer.fetch("/"))
-    expect(config.folderUri).toBeUndefined()
-    expect(config.workspaceUri?.path).toBe(defaultWorkspace)
+    const resp = await codeServer.fetch("/")
+    const url = new URL(resp.url)
+    expect(url.pathname).toBe("/")
+    expect(url.search).toBe(`?folder=${folder}`)
   })
 
   it("should redirect to last query folder/workspace", async () => {
@@ -136,7 +99,31 @@ describe("vscode", () => {
     await resp.text()
   })
 
-  it.only("should add the folder as a query param maintaining the slashes", async () => {
+  it("should add the workspace as a query param maintaining the slashes", async () => {
+    const workspace = path.join(await tmpdir(testName), "test.code-workspace")
+    await fs.writeFile(workspace, "")
+    codeServer = await integration.setup(["--auth=none", workspace], "")
+
+    let resp = await codeServer.fetch("/", undefined)
+
+    expect(resp.status).toBe(200)
+    const url = new URL(resp.url)
+    expect(url.search).toBe(`?workspace=${workspace}`)
+    await resp.text()
+  })
+
+  it("should do nothing when nothing is passed in", async () => {
+    codeServer = await integration.setup(["--auth=none"], "")
+
+    let resp = await codeServer.fetch("/", undefined)
+
+    expect(resp.status).toBe(200)
+    const url = new URL(resp.url)
+    expect(url.search).toBe("")
+    await resp.text()
+  })
+
+  it("should add the folder as a query param maintaining the slashes", async () => {
     const folder = await tmpdir(testName)
     codeServer = await integration.setup(["--auth=none", folder], "")
 
@@ -148,8 +135,6 @@ describe("vscode", () => {
     await resp.text()
   })
 
-  // TODO@jsjoeio - what about workspace?
-
   it("should not redirect when last opened is ignored", async () => {
     codeServer = await integration.setup(["--auth=none", "--ignore-last-opened"], "")