handle dev containers

Author: ethanndickson

src/commands.ts

@@ -491,7 +491,7 @@ export class Commands {
     } else {
       workspaceOwner = args[0] as string
       workspaceName = args[1] as string
-      workspaceAgent = args[2] as string
+      workspaceAgent = args[2] as string | undefined
       folderPath = args[3] as string | undefined
       openRecent = args[4] as boolean | undefined
     }
@@ -522,11 +522,11 @@ export class Commands {
 
     const workspaceOwner = args[0] as string
     const workspaceName = args[1] as string
-    const workspaceAgent = undefined // args[2] is reserved, but we do not support multiple agents yet.
+    const workspaceAgent = args[2] as string | undefined
     const devContainerName = args[3] as string
     const devContainerFolder = args[4] as string
 
-    await openDevContainer(baseUrl, workspaceOwner, workspaceName, workspaceAgent, devContainerName, devContainerFolder)
+    await this.openDevContainerInner(baseUrl, workspaceOwner, workspaceName, workspaceAgent, devContainerName, devContainerFolder)
   }
 
   /**
@@ -652,33 +652,61 @@ export class Commands {
       reuseWindow: !newWindow,
     })
   }
-}
 
-async function openDevContainer(
-  baseUrl: string,
-  workspaceOwner: string,
-  workspaceName: string,
-  workspaceAgent: string | undefined,
-  devContainerName: string,
-  devContainerFolder: string,
-) {
-  const remoteAuthority = toRemoteAuthority(baseUrl, workspaceOwner, workspaceName, workspaceAgent)
-
-  const devContainer = Buffer.from(JSON.stringify({ containerName: devContainerName }), "utf-8").toString("hex")
-  const devContainerAuthority = `attached-container+${devContainer}@${remoteAuthority}`
-
-  let newWindow = true
-  if (!vscode.workspace.workspaceFolders?.length) {
-    newWindow = false
-  }
+  private async openDevContainerInner(
+    baseUrl: string,
+    workspaceOwner: string,
+    workspaceName: string,
+    workspaceAgent: string | undefined,
+    devContainerName: string,
+    devContainerFolder: string,
+  ) {
+    let remoteAuthority = toRemoteAuthority(baseUrl, workspaceOwner, workspaceName, workspaceAgent)
+
+    if (workspaceAgent) {
+      let sshConfig
+      try {
+        // Fetch (or get defaults) for the SSH config.
+        sshConfig = await fetchSSHConfig(this.restClient, this.vscodeProposed)
+      } catch (error) {
+        const message = getErrorMessage(error, "no response from the server")
+        this.storage.writeToCoderOutputChannel(`Failed to open workspace: ${message}`)
+        this.vscodeProposed.window.showErrorMessage("Failed to open workspace", {
+          detail: message,
+          modal: true,
+          useCustom: true,
+        })
+        return
+      }
+
+      const coderConnectAddr = await maybeCoderConnectAddr(
+        workspaceAgent,
+        workspaceName,
+        workspaceOwner,
+        sshConfig.hostname_suffix,
+      )
+      if (coderConnectAddr) {
+        remoteAuthority = `ssh-remote+${coderConnectAddr}`
+      }
+    }
+
+    const devContainer = Buffer.from(JSON.stringify({ containerName: devContainerName }), "utf-8").toString("hex")
+    const devContainerAuthority = `attached-container+${devContainer}@${remoteAuthority}`
 
-  await vscode.commands.executeCommand(
-    "vscode.openFolder",
-    vscode.Uri.from({
-      scheme: "vscode-remote",
-      authority: devContainerAuthority,
-      path: devContainerFolder,
-    }),
-    newWindow,
-  )
+    let newWindow = true
+    if (!vscode.workspace.workspaceFolders?.length) {
+      newWindow = false
+    }
+
+    await vscode.commands.executeCommand(
+      "vscode.openFolder",
+      vscode.Uri.from({
+        scheme: "vscode-remote",
+        authority: devContainerAuthority,
+        path: devContainerFolder,
+      }),
+      newWindow,
+    )
+  }
 }
+

src/remote.ts

@@ -528,10 +528,32 @@ export class Remote {
       sshConfigResponse.hostname_suffix,
     )
     if (coderConnectAddr) {
-      await vscode.commands.executeCommand("vscode.newWindow", {
-        remoteAuthority: `ssh-remote+${coderConnectAddr}`,
-        reuseWindow: true,
-      })
+      // Find the path of the current workspace, which will have the same authority
+      const folderPath = this.vscodeProposed.workspace.workspaceFolders
+      ?.find(folder => folder.uri.authority === remoteAuthority)
+      ?.uri.path;
+      let newRemoteAuthority = `ssh-remote+${coderConnectAddr}`
+      if (parts.containerNameHex) {
+        newRemoteAuthority = `attached-container+${parts.containerNameHex}@${newRemoteAuthority}`
+      }
+
+      if (folderPath) {
+        await vscode.commands.executeCommand(
+          "vscode.openFolder",
+          vscode.Uri.from({
+            scheme: "vscode-remote",
+            authority: newRemoteAuthority,
+            path: folderPath,
+          }),
+          //`ForceNewWindow`
+          false,
+        )
+      } else {
+        await vscode.commands.executeCommand("vscode.newWindow", {
+          remoteAuthority: newRemoteAuthority,
+          reuseWindow: true,
+        })
+      }
     }
 
     // Returning the URL and token allows the plugin to authenticate its own

src/util.test.ts

@@ -9,6 +9,7 @@ it("ignore unrelated authorities", async () => {
     "vscode://ssh-remote+coder-vscode-test--foo--bar",
     "vscode://ssh-remote+coder-vscode-foo--bar",
     "vscode://ssh-remote+coder--foo--bar",
+    "vscode://attached-container+namehash@ssh-remote+dev.foo.admin.coder"
   ]
   for (const test of tests) {
     expect(parseRemoteAuthority(test)).toBe(null)
@@ -29,34 +30,47 @@ it("should error on invalid authorities", async () => {
 
 it("should parse authority", async () => {
   expect(parseRemoteAuthority("vscode://ssh-remote+coder-vscode--foo--bar")).toStrictEqual({
+    containerNameHex: undefined,
     agent: "",
     host: "coder-vscode--foo--bar",
     label: "",
     username: "foo",
     workspace: "bar",
   })
   expect(parseRemoteAuthority("vscode://ssh-remote+coder-vscode--foo--bar--baz")).toStrictEqual({
+    containerNameHex: undefined,
     agent: "baz",
     host: "coder-vscode--foo--bar--baz",
     label: "",
     username: "foo",
     workspace: "bar",
   })
   expect(parseRemoteAuthority("vscode://ssh-remote+coder-vscode.dev.coder.com--foo--bar")).toStrictEqual({
+    containerNameHex: undefined,
     agent: "",
     host: "coder-vscode.dev.coder.com--foo--bar",
     label: "dev.coder.com",
     username: "foo",
     workspace: "bar",
   })
   expect(parseRemoteAuthority("vscode://ssh-remote+coder-vscode.dev.coder.com--foo--bar--baz")).toStrictEqual({
+    containerNameHex: undefined,
     agent: "baz",
     host: "coder-vscode.dev.coder.com--foo--bar--baz",
     label: "dev.coder.com",
     username: "foo",
     workspace: "bar",
   })
   expect(parseRemoteAuthority("vscode://ssh-remote+coder-vscode.dev.coder.com--foo--bar.baz")).toStrictEqual({
+    containerNameHex: undefined,
+    agent: "baz",
+    host: "coder-vscode.dev.coder.com--foo--bar.baz",
+    label: "dev.coder.com",
+    username: "foo",
+    workspace: "bar",
+  })
+  expect(parseRemoteAuthority("vscode://attached-container+namehash@ssh-remote+coder-vscode.dev.coder.com--foo--bar.baz")).toStrictEqual({
+    containerNameHex: "namehash",
     agent: "baz",
     host: "coder-vscode.dev.coder.com--foo--bar.baz",
     label: "dev.coder.com",

src/util.ts

@@ -1,10 +1,12 @@
 import { lookup } from "dns"
 import ipRangeCheck from "ip-range-check"
+import { ssh } from "node-forge"
 import * as os from "os"
 import url from "url"
 import { promisify } from "util"
 
 export interface AuthorityParts {
+  containerNameHex: string | undefined
   agent: string | undefined
   host: string
   label: string
@@ -24,14 +26,26 @@ export const AuthorityPrefix = "coder-vscode"
  * Throw an error if the host is invalid.
  */
 export function parseRemoteAuthority(authority: string): AuthorityParts | null {
-  // The authority looks like: vscode://ssh-remote+<ssh host name>
-  const authorityParts = authority.split("+")
+  // The Dev Container authority looks like: vscode://attached-container+containerNameHex@ssh-remote+<ssh host name>
+  // The SSH authority looks like: vscode://ssh-remote+<ssh host name>
+  const authorityParts = authority.split("@")
+  let containerNameHex = undefined
+  let sshAuthority
+  if (authorityParts.length == 1) {
+    sshAuthority = authorityParts[0]
+  }  else if (authorityParts.length == 2 && authorityParts[0].includes("attached-container+")) {
+    sshAuthority = authorityParts[1]
+    containerNameHex = authorityParts[0].split("+")[1]
+  } else {
+    return null
+  }
+  const sshAuthorityParts = sshAuthority.split("+")
 
   // We create SSH host names in a format matching:
   // coder-vscode(--|.)<username>--<workspace>(--|.)<agent?>
   // The agent can be omitted; the user will be prompted for it instead.
   // Anything else is unrelated to Coder and can be ignored.
-  const parts = authorityParts[1].split("--")
+  const parts = sshAuthorityParts[1].split("--")
   if (parts.length <= 1 || (parts[0] !== AuthorityPrefix && !parts[0].startsWith(`${AuthorityPrefix}.`))) {
     return null
   }
@@ -56,8 +70,9 @@ export function parseRemoteAuthority(authority: string): AuthorityParts | null {
   }
 
   return {
+    containerNameHex: containerNameHex,
     agent: agent,
-    host: authorityParts[1],
+    host: sshAuthorityParts[1],
     label: parts[0].replace(/^coder-vscode\.?/, ""),
     username: parts[1],
     workspace: workspace,