impl: ability to customize the link to workspace creation in Dashboard

Some clients (Netflix in this specific case) rely on mainly their own dashboard
tools instead of the Coder one. Two main reasons that were mentioned by Netflix:
- aggregate many dev tools in a unified internal console
- specific platform/security needs that their own UI handles better

For this reason they would like the actions open up the Coder Dashboard
(only Create workspace for now) to be fully customizable, and allow clients
to override the URL.
For `Create workspace` we now have a config that defaults $lastDeploymentUrl/templates,
but it can be replaced with a relative URL to $lastDeploymentUrl or a complete new URL.
For now the decision is to not allow configuration from UI since Netflix is the
only target for this change, and they deploy at scale a templated settings.json.

Author: fioan89

README.md

@@ -360,6 +360,12 @@ storage paths. The options can be configured from the plugin's main Workspaces p
 - `Header command` command that outputs additional HTTP headers. Each line of output must be in the format key=value.
   The environment variable CODER_URL will be available to the command process.
 
+- `lastDeploymentURL` the last Coder deployment URL that Coder Toolbox successfully authenticated to.
+
+- `workspaceCreatePath` specifies the dashboard page’s relative path (to `lastDeploymentURL`) or full URL where users
+  can create new workspaces. Helpful for customers that have their own in-house dashboards. Defaults to `/templates` if
+  missing.
+
 ### TLS settings
 
 The following options control the secure communication behavior of the plugin with Coder deployment and its available

src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt

@@ -224,7 +224,14 @@ class CoderRemoteProvider(
     override val additionalPluginActions: StateFlow<List<ActionDescription>> = MutableStateFlow(
         listOf(
             Action(context, "Create workspace") {
-                context.desktop.browse(client?.url?.withPath("/templates").toString()) {
+                val wsCreatePath = context.settingsStore.workspaceCreatePath
+                val url = if (wsCreatePath.startsWith("http://") || wsCreatePath.startsWith("https://")) {
+                    wsCreatePath
+                } else {
+                    client?.url?.withPath(wsCreatePath).toString()
+                }
+
+                context.desktop.browse(url) {
                     context.ui.showErrorInfoPopup(it)
                 }
             },

src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt

@@ -137,6 +137,10 @@ interface ReadOnlyCoderSettings {
      */
     val sshConfigOptions: String?
 
+    /**
+     * A relative path or full URL to the dashboard page used for creating workspaces.
+     */
+    val workspaceCreatePath: String
 
     /**
      * The path where network information for SSH hosts are stored

src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt

@@ -80,6 +80,9 @@ class CoderSettingsStore(
             .normalize()
             .toString()
 
+    override val workspaceCreatePath: String
+        get() = store[WORKSPACE_CREATE_PATH] ?: "/templates"
+
     /**
      * Where the specified deployment should put its data.
      */

src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt

@@ -46,5 +46,7 @@ internal const val SSH_CONFIG_OPTIONS = "sshConfigOptions"
 
 internal const val NETWORK_INFO_DIR = "networkInfoDir"
 
+internal const val WORKSPACE_CREATE_PATH = "workspaceCreatePath"
+
 internal const val SSH_AUTO_CONNECT_PREFIX = "ssh_auto_connect_"
 

src/test/kotlin/com/coder/toolbox/util/URLExtensionsTest.kt

@@ -9,21 +9,21 @@ internal class URLExtensionsTest {
     @Test
     fun testToURL() {
         assertEquals(
-            URL("https", "localhost", 8080, "/path"),
-            "https://localhost:8080/path".toURL(),
+            expected = URI.create("https://localhost:8080/path").toURL(),
+            actual = "https://localhost:8080/path".toURL(),
         )
     }
 
     @Test
     fun testWithPath() {
         assertEquals(
-            URL("https", "localhost", 8080, "/foo/bar"),
-            URL("https", "localhost", 8080, "/").withPath("/foo/bar"),
+            expected = "https://localhost:8080/foo/bar".toURL(),
+            actual = "https://localhost:8080/".toURL().withPath("/foo/bar"),
         )
 
         assertEquals(
-            URL("https", "localhost", 8080, "/foo/bar"),
-            URL("https", "localhost", 8080, "/old/path").withPath("/foo/bar"),
+            expected = "https://localhost:8080/foo/bar".toURL(),
+            actual = "https://localhost:8080/old/path".toURL().withPath("/foo/bar"),
         )
     }