Pass version and auth options through execCoder

This will make it so that we can try authentication when the command
fails (as opposed to during preflight) since the Coder CLI does not have
a command that lets you check authentication status.

Author: code-asher

src/download.ts

@@ -7,6 +7,15 @@ import * as nodeWhich from "which"
 import { requestResponse } from "./request"
 import { context, debug, extractTar, extractZip, getAssetUrl, onLine, outputChannel, wrapExit } from "./utils"
 
+/**
+ * Options for installing and authenticating the Coder CLI.
+ */
+export interface CoderOptions {
+  accessUri?: string
+  token?: string
+  version?: string
+}
+
 /**
  * Return "true" if the binary is found in $PATH.
  */
@@ -17,13 +26,13 @@ export const binaryExists = async (bin: string): Promise<boolean> => {
 }
 
 /**
- * Run a command with the Coder CLI after making sure it is installed.  On
- * success stdout is returned.  On failure the error will include stderr in the
- * message.
+ * Run a command with the Coder CLI after making sure it is installed and
+ * authenticated.  On success stdout is returned.  On failure the error will
+ * include stderr in the message.
  */
-export const execCoder = async (command: string): Promise<string> => {
+export const execCoder = async (command: string, opts?: CoderOptions): Promise<string> => {
   debug(`Run command: ${command}`)
-  const coderBinary = await preflight()
+  const coderBinary = await preflight(opts?.version)
   const output = await promisify(cp.exec)(coderBinary + " " + command)
   return output.stdout
 }
@@ -40,9 +49,6 @@ const coderInvocation = (): { cmd: string; args: string[] } => {
   return { cmd: process.platform === "win32" ? "coder.exe" : "coder", args: [] }
 }
 
-/** Only one preflight request at a time. */
-let _preflight: Promise<string> | undefined
-
 /**
  * Download the Coder CLI to the provided location and return that location.
  */
@@ -178,13 +184,13 @@ export const maybeInstall = async (version: string): Promise<string> => {
   }
 }
 
+/** Only one preflight request at a time. */
+let _preflight: Promise<string> | undefined
+
 /**
- * Check that Coder is installed and authenticated.  If not try installing and
- * authenticating.
+ * Check that Coder is installed.  If not try installing.
  *
  * Return the appropriate invocation for the binary.
- *
- * @TODO Implement authentication portion.
  */
 export const preflight = async (version = "latest"): Promise<string> => {
   if (!_preflight) {

src/extension.ts

@@ -43,7 +43,11 @@ export const uriHandler: vscode.UriHandler = {
     debug(`Handling URI: ${uri}`)
     switch (action) {
       case "open-workspace": {
-        return preflight(getQueryValue(query.version)).then(() => openWorkspace(resource))
+        return openWorkspace(resource, {
+          accessUri: getQueryValue(query.accessUri),
+          token: getQueryValue(query.token),
+          version: getQueryValue(query.version),
+        })
       }
       default:
         vscode.window.showErrorMessage(`Unknown action "${action}"`)

src/workspaces.ts

@@ -1,6 +1,6 @@
 import * as path from "path"
 import * as vscode from "vscode"
-import { execCoder } from "./download"
+import { CoderOptions, execCoder } from "./download"
 import { mediaDir } from "./utils"
 
 export class CoderWorkspacesProvider implements vscode.TreeDataProvider<CoderWorkspaceListItem> {
@@ -48,15 +48,22 @@ export const shutdownWorkspace = async (name: string): Promise<void> => {
  * Inject Coder hosts into the SSH config file.
  *
  * If `remote.SSH.configFile` is set use that otherwise use the default.
+ *
+ * If version and authentication details are provided use those with the binary.
  */
-const setupSSH = async (): Promise<void> => {
+const setupSSH = async (opts?: CoderOptions): Promise<void> => {
   const configFile = vscode.workspace.getConfiguration("remote.SSH").get("configFile")
-  await execCoder(`config-ssh ${configFile ? `--filepath ${configFile}` : ""}`)
+  await execCoder(`config-ssh ${configFile ? `--filepath ${configFile}` : ""}`, opts)
 }
 
-export const openWorkspace = async (name: string): Promise<void> => {
+/**
+ * Open the specified workspace.
+ *
+ * If version and authentication details are provided use those with the binary.
+ */
+export const openWorkspace = async (name: string, opts?: CoderOptions): Promise<void> => {
   try {
-    await setupSSH()
+    await setupSSH(opts)
     // If the provided workspace does not exist this is the point at which we
     // will find out because `coder sh` will exit with 1 causing the exec to
     // reject (piping should be avoided since the exit code is swallowed).