Handle case where user is already logged into another deployment (#11)

* Fix util cleanup not waiting

Also extracted the common string into a constant

* Extract common zip temp path constant

* Move vscode-related code out of utils

This lets it be shared by code that runs outside VS Code (like test
setup).

* Update Node types

The previous types did not have definitions for `assert.match`.

Remove "preferably" from the readme.  You really should use 16 or
greater otherwise it does not generate the same lockfile.

* Mock config file location in tests

This lets us read/write in tests without messing with the real
configuration.

* Check if logged in another deployment

* Replace manual env handling with new set/resetEnv

* Bump version to 0.0.5

Author: code-asher

README.md

@@ -6,7 +6,7 @@
 
 ## Development
 
-- Install Node (preferably >= 16)
+- Install Node >= 16
 - Clone the repository locally
 - Run `npm install`
 

package-lock.json

@@ -5,7 +5,7 @@
   "description": "Connect VS Code to your Coder Workspaces",
   "repository": "https://github.com/cdr/vscode-coder",
   "preview": true,
-  "version": "0.0.4",
+  "version": "0.0.5",
   "engines": {
     "vscode": "^1.54.0"
   },
@@ -159,7 +159,7 @@
     "@types/adm-zip": "^0.4.34",
     "@types/glob": "^7.1.3",
     "@types/mocha": "^8.0.4",
-    "@types/node": "^12.11.7",
+    "@types/node": "^16.11.21",
     "@types/tar-fs": "^2.0.1",
     "@types/vscode": "^1.54.0",
     "@types/which": "^2.0.1",

package.json

@@ -1,10 +1,51 @@
-// import * as assert from "assert"
+import * as assert from "assert"
+import { promises as fs } from "fs"
+import * as path from "path"
 import * as vscode from "vscode"
-// import * as auth from "./download"
+import * as auth from "./auth"
+import * as utils from "./utils"
 
 suite("Authenticate", () => {
   vscode.window.showInformationMessage("Start authenticate tests.")
 
-  // TODO: Implement.
-  test("authenticate")
+  const tmpPath = "tests/auth"
+  suiteSetup(async () => {
+    // Cleanup anything left over from the last run.
+    await utils.clean(tmpPath)
+  })
+
+  teardown(() => utils.resetEnv())
+
+  const assertDirs = (dir: string) => {
+    assert.match(auth.getConfigDir("linux"), new RegExp(path.join(dir, ".config$")))
+    assert.match(auth.getConfigDir("freebsd"), new RegExp(path.join(dir, ".config$")))
+    assert.match(auth.getConfigDir("win32"), new RegExp(path.join(dir, "AppData/Roaming$")))
+    assert.match(auth.getConfigDir("darwin"), new RegExp(path.join(dir, "Library/Application Support$")))
+  }
+
+  test("getConfigDir", async () => {
+    // Make sure local config mocks work.
+    const tmpDir = await utils.tmpdir(tmpPath)
+    utils.setEnv("HOME", tmpDir)
+    assertDirs(tmpDir)
+
+    // Make sure the global mock also works.  For example the Linux temp config
+    // directory looks like: /tmp/coder/tests/config/tmp-Dzfqwl/home/.config
+    // This runs after the local mock to make sure environment variables are
+    // being restored correctly.
+    utils.resetEnv()
+    assertDirs("tests/config/.+/home")
+  })
+
+  test("currentUri", async () => {
+    const tmpDir = await utils.tmpdir(tmpPath)
+    utils.setEnv("HOME", tmpDir)
+
+    const accessUri = "https://coder-workspaces-test"
+    assert.strictEqual(await auth.currentUri(), undefined)
+    const dir = path.join(auth.getConfigDir(), "coder")
+    await fs.mkdir(dir, { recursive: true })
+    await fs.writeFile(path.join(dir, "url"), accessUri)
+    assert.strictEqual(await auth.currentUri(), accessUri)
+  })
 })

src/auth.test.ts

@@ -2,19 +2,18 @@ import { promises as fs } from "fs"
 import * as os from "os"
 import * as path from "path"
 import * as vscode from "vscode"
-import { debug } from "./utils"
+import { debug } from "./logs"
 
-const getConfigDir = (): string => {
+export const getConfigDir = (platform = process.platform): string => {
   // The CLI uses localConfig from https://github.com/kirsle/configdir.
-  switch (process.platform) {
+  switch (platform) {
     case "win32":
       return process.env.APPDATA || path.join(os.homedir(), "AppData/Roaming")
     case "darwin":
       return path.join(os.homedir(), "Library/Application Support")
-    case "linux":
+    default:
       return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config")
   }
-  throw new Error(`Unsupported platform ${process.platform}`)
 }
 
 /**
@@ -58,6 +57,25 @@ const doAuthenticate = async (accessUrl?: string, token?: string): Promise<void>
   await Promise.all([fs.writeFile(path.join(dir, "session"), token), fs.writeFile(path.join(dir, "url"), accessUrl)])
 }
 
+/**
+ * Return current login URI, if any.
+ */
+export const currentUri = async (): Promise<string | undefined> => {
+  // TODO: Like authentication this unfortunately relies on internal knowledge
+  // since there does not appear to be a command to get the current login
+  // status.
+  const dir = path.join(getConfigDir(), "coder")
+  try {
+    return (await fs.readFile(path.join(dir, "url"), "utf8")).trim()
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
+    if (error.code === "ENOENT") {
+      return undefined
+    }
+    throw error
+  }
+}
+
 /** Only allow one at a time. */
 let promise: Promise<void> | undefined
 

src/auth.ts

@@ -1,8 +1,9 @@
 import { promises as fs } from "fs"
 import * as path from "path"
 import * as vscode from "vscode"
+import { debug } from "./logs"
 import { requestResponse } from "./request"
-import { debug, extractTar, extractZip, getAssetUrl } from "./utils"
+import { extractTar, extractZip, getAssetUrl } from "./utils"
 
 /**
  * Inner function for `download` so it can wrap with a singleton promise.

src/download.ts

@@ -2,23 +2,25 @@ import * as assert from "assert"
 import * as cp from "child_process"
 import * as vscode from "vscode"
 import * as exec from "./exec"
+import * as utils from "./utils"
 
 suite("Exec", () => {
   vscode.window.showInformationMessage("Start exec tests.")
 
-  teardown(() => {
-    delete process.env.CODER_MOCK_STATE
-  })
+  teardown(() => utils.resetEnv())
 
   test("execCoder", async () => {
     assert.strictEqual(await exec.execCoder("--help"), "help\n")
 
     // This will attempt to authenticate first, which will fail.
-    process.env.CODER_MOCK_STATE = "fail"
+    utils.setEnv("CODER_MOCK_STATE", "fail")
     await assert.rejects(exec.execCoder("--help"), {
       name: "Error",
       message: /Command failed: .+ --help\nstderr message from fail state\n/,
     })
+
+    // TODO: Test what happens when you are already logged in once we figure out
+    // how to test notifications and user input.
   })
 
   test("onLine", async () => {

src/exec.test.ts

@@ -2,10 +2,25 @@ import * as cp from "child_process"
 import * as path from "path"
 import * as stream from "stream"
 import { promisify } from "util"
+import * as vscode from "vscode"
 import * as nodeWhich from "which"
-import { authenticate } from "./auth"
+import { authenticate, currentUri } from "./auth"
 import { download } from "./download"
-import { context, debug } from "./utils"
+import { debug } from "./logs"
+
+let _context: vscode.ExtensionContext | undefined
+
+/**
+ * Get or set the extension context.
+ */
+export const context = (ctx?: vscode.ExtensionContext): vscode.ExtensionContext => {
+  if (ctx) {
+    _context = ctx
+  } else if (!_context) {
+    throw new Error("Context has not been set; has the extension been activated?")
+  }
+  return _context
+}
 
 /**
  * How to invoke the Coder CLI.
@@ -52,6 +67,27 @@ export const execCoder = async (command: string, opts?: CoderOptions): Promise<s
     throw new Error(`${error.message.trim()}. Please [install manually](https://coder.com/docs/cli/installation).`)
   }
 
+  if (opts?.accessUri) {
+    const uri = await currentUri()
+    if (!uri) {
+      // Not authenticated to anything.
+      await authenticate(opts?.accessUri, opts?.token)
+    } else if (opts?.accessUri !== uri) {
+      // Authenticated to a different deployment.
+      const target = opts?.accessUri.replace(/https?:\/\//, "")
+      const current = uri.replace(/https?:\/\//, "")
+      const action = await vscode.window.showInformationMessage(
+        `This workspace is hosted at ${target} but you are already logged into ${current}. Logging into ${target} will log you out of ${current}.`,
+        "Cancel",
+        `Log into ${target}`,
+      )
+      if (!action || action === "Cancel") {
+        throw new Error("Login canceled")
+      }
+      await authenticate(opts?.accessUri, opts?.token)
+    }
+  }
+
   try {
     const output = await promisify(cp.exec)(coderBinary + " " + command)
     return output.stdout

src/exec.ts

@@ -2,15 +2,16 @@
 
 import * as qs from "querystring"
 import * as vscode from "vscode"
+import { context } from "./exec"
 import { CoderHelpProvider } from "./help"
-
 import {
   coderWorkspaceInspectDocumentProvider,
   coderWorkspaceLogsDocumentProvider,
+  debug,
   handleInspectCommand,
   handleShowLogsCommand,
 } from "./logs"
-import { context, debug, getQueryValue, split } from "./utils"
+import { getQueryValue, split } from "./utils"
 import {
   CoderWorkspacesProvider,
   rebuildWorkspace,

src/extension.ts

@@ -3,7 +3,7 @@ import * as path from "path"
 import * as vscode from "vscode"
 import { download } from "./download"
 import { binaryExists, onLine, wrapExit } from "./exec"
-import { outputChannel } from "./utils"
+import { outputChannel } from "./logs"
 
 /**
  * Install the Coder CLI using the provided command.

src/install.ts

@@ -0,0 +1,10 @@
+// import * as assert from "assert"
+import * as vscode from "vscode"
+// import * as logs from "./logs"
+
+suite("Logs", () => {
+  vscode.window.showInformationMessage("Start log tests.")
+
+  // TODO: Implement.
+  test("debug")
+})

src/logs.test.ts

@@ -3,6 +3,14 @@ import * as yaml from "yaml"
 import { execCoder } from "./exec"
 import { CoderWorkspace } from "./workspaces"
 
+export const outputChannel = vscode.window.createOutputChannel("Coder")
+
+export const debug = (line: string): void => {
+  if (process.env.CODER_DEBUG) {
+    outputChannel.appendLine(line)
+  }
+}
+
 export const handleShowLogsCommand = async ({ workspace }: { workspace: CoderWorkspace }): Promise<void> => {
   const uri = vscode.Uri.parse("coder-logs:" + workspace.name)
   const doc = await vscode.workspace.openTextDocument(uri)

src/logs.ts

@@ -1,5 +1,6 @@
 import { runTests } from "@vscode/test-electron"
 import * as path from "path"
+import * as utils from "../utils"
 
 // Place the mock binary into PATH.
 process.env.PATH = `${path.resolve(__dirname, "../../fixtures")}${path.delimiter}${process.env.PATH}`
@@ -14,6 +15,12 @@ if (process.platform === "win32") {
 
 async function main() {
   try {
+    // Cleanup anything left over from the last run.
+    const tmpPath = "tests/config"
+    await utils.clean(tmpPath)
+    const temp = await utils.tmpdir(tmpPath)
+    process.env.HOME = path.join(temp, "home")
+
     // The folder containing the Extension Manifest package.json
     // Passed to `--extensionDevelopmentPath`
     const extensionDevelopmentPath = path.resolve(__dirname, "../..")

src/test/runTest.ts

@@ -7,9 +7,10 @@ import * as utils from "./utils"
 suite("Utils", () => {
   vscode.window.showInformationMessage("Start util tests.")
 
-  suiteSetup(() => {
+  const tmpPath = "tests/utils"
+  suiteSetup(async () => {
     // Cleanup anything left over from the last run.
-    utils.clean("tests/utils")
+    await utils.clean(tmpPath)
   })
 
   test("split", () => {
@@ -20,7 +21,7 @@ suite("Utils", () => {
 
   test("extract", async () => {
     for (const ext of [".tar.gz", ".zip"]) {
-      const temp = await utils.tmpdir("tests/utils")
+      const temp = await utils.tmpdir(tmpPath)
       const stream = fs.createReadStream(path.resolve(__dirname, `../fixtures/archive${ext}`))
 
       await (ext === ".tar.gz" ? utils.extractTar(stream, temp) : utils.extractZip(stream, temp))
@@ -48,4 +49,13 @@ suite("Utils", () => {
     assert.strictEqual(utils.getQueryValue(["bar"]), "bar")
     assert.strictEqual(utils.getQueryValue(["bazzle", "qux"]), "bazzle")
   })
+
+  test("set/resetEnv", () => {
+    const key = "CODER_WORKSPACES_FOO"
+    assert.strictEqual(process.env[key], undefined)
+    utils.setEnv(key, "baz")
+    assert.strictEqual(process.env[key], "baz")
+    utils.resetEnv()
+    assert.strictEqual(process.env[key], undefined)
+  })
 })