diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 8a55c79..323b3d5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -20,9 +20,9 @@ jobs:
           - windows-latest
     runs-on: ${{ matrix.platform }}
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v5
 
-      - uses: actions/setup-java@v4
+      - uses: actions/setup-java@v5
         with:
           distribution: zulu
           java-version: 21
@@ -50,11 +50,11 @@ jobs:
     steps:
       # Check out current repository
       - name: Fetch Sources
-        uses: actions/checkout@v4.2.2
+        uses: actions/checkout@v5
 
       # Setup Java 21 environment for the next steps
       - name: Setup Java
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: zulu
           java-version: 21
@@ -101,7 +101,7 @@ jobs:
 
       # Check out current repository
       - name: Fetch Sources
-        uses: actions/checkout@v4.2.2
+        uses: actions/checkout@v5
 
       # Remove old release drafts by using GitHub CLI
       - name: Remove Old Release Drafts
@@ -113,7 +113,7 @@ jobs:
             | xargs -I '{}' gh api -X DELETE repos/${{ github.repository }}/releases/{}
 
       - name: Download Build Artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: zip-artifacts
           path: artifacts/
@@ -121,7 +121,7 @@ jobs:
         run: ls -R artifacts/
 
       - name: Download Release Notes
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: release-notes
           path: notes/
diff --git a/.github/workflows/jetbrains-compliance.yml b/.github/workflows/jetbrains-compliance.yml
index d1d2019..ff28fe5 100644
--- a/.github/workflows/jetbrains-compliance.yml
+++ b/.github/workflows/jetbrains-compliance.yml
@@ -13,10 +13,10 @@ jobs:
     
     steps:
     - name: Checkout code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       
     - name: Set up JDK 21
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         java-version: '21'
         distribution: 'temurin'
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 44fb3be..6918c4e 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -15,13 +15,13 @@ jobs:
 
       # Check out current repository
       - name: Fetch Sources
-        uses: actions/checkout@v4.2.2
+        uses: actions/checkout@v5
         with:
           ref: ${{ github.event.release.tag_name }}
 
       # Setup Java 21 environment for the next steps
       - name: Setup Java
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: zulu
           java-version: 21
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69ccd25..826e038 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,66 @@
 
 ### Added
 
+- improved diagnose support
+
+## 0.6.3 - 2025-08-25
+
+### Added
+
+- progress reporting while handling URIs
+
+### Changed
+
+- workspaces status is now refresh every time Coder Toolbox becomes visible
+
+### Fixed
+
+- support for downloading the CLI when proxy is configured
+
+## 0.6.2 - 2025-08-14
+
+### Changed
+
+- content-type is now enforced when downloading the CLI to accept only binary responses
+
+## 0.6.1 - 2025-08-11
+
+### Added
+
+- support for skipping CLI signature verification
+
+### Changed
+
+- URL validation is stricter in the connection screen and URI protocol handler
+- support for verbose logging a sanitized version of the REST API request and responses
+
+### Fixed
+
+- remote IDE reconnects automatically after plugin upgrade
+
+## 0.6.0 - 2025-07-25
+
+### Changed
+
+- improved workflow when network connection is flaky
+
+## 0.5.2 - 2025-07-22
+
+### Fixed
+
+- fix class cast exception during signature verification
+- the correct CLI signature for Windows is now downloaded
+
+## 0.5.1 - 2025-07-21
+
+### Added
+
+- support for certificate based authentication
+
+## 0.5.0 - 2025-07-17
+
+### Added
+
 - support for matching workspace agent in the URI via the agent name
 - support for checking if CLI is signed
 
diff --git a/JETBRAINS_COMPLIANCE.md b/JETBRAINS_COMPLIANCE.md
index 306d684..91162ed 100644
--- a/JETBRAINS_COMPLIANCE.md
+++ b/JETBRAINS_COMPLIANCE.md
@@ -39,8 +39,6 @@ This configuration includes JetBrains-specific rules that check for:
 - **ForbiddenImport**: Detects potentially bundled libraries
 - **Standard code quality rules**: Complexity, naming, performance, etc.
 
-
-
 ## CI/CD Integration
 
 The GitHub Actions workflow `.github/workflows/jetbrains-compliance.yml` runs compliance checks on every PR and push.
@@ -55,8 +53,6 @@ The GitHub Actions workflow `.github/workflows/jetbrains-compliance.yml` runs co
 open build/reports/detekt/detekt.html
 ```
 
-
-
 ## Understanding Results
 
 ### Compliance Check Results
diff --git a/README.md b/README.md
index 41d430d..74e9cd5 100644
--- a/README.md
+++ b/README.md
@@ -109,6 +109,69 @@ If `ide_product_code` and `ide_build_number` is missing, Toolbox will only open
 page. Coder Toolbox will attempt to start the workspace if it’s not already running; however, for the most reliable
 experience, it’s recommended to ensure the workspace is running prior to initiating the connection.
 
+## GPG Signature Verification
+
+The Coder Toolbox plugin starting with version *0.5.0* implements a comprehensive GPG signature verification system to
+ensure the authenticity and integrity of downloaded Coder CLI binaries. This security feature helps protect users from
+running potentially malicious or tampered binaries.
+
+### How It Works
+
+1. **Binary Download**: When connecting to a Coder deployment, the plugin downloads the appropriate Coder CLI binary for
+   the user's operating system and architecture from the deployment's `/bin/` endpoint.
+
+2. **Signature Download**: After downloading the binary, the plugin attempts to download the corresponding `.asc`
+   signature file from the same location. The signature file is named according to the binary (e.g.,
+   `coder-linux-amd64.asc` for `coder-linux-amd64`).
+
+3. **Fallback Signature Sources**: If the signature is not available from the deployment, the plugin can optionally fall
+   back to downloading signatures from `releases.coder.com`. This is controlled by the `fallbackOnCoderForSignatures`
+   setting.
+
+4. **GPG Verification**: The plugin uses the BouncyCastle library to verify the detached GPG signature against the
+   downloaded binary using Coder's trusted public key.
+
+5. **User Interaction**: If signature verification fails or signatures are unavailable, the plugin presents security
+   warnings to users, allowing them to accept the risk and continue or abort the operation.
+
+### Verification Process
+
+The verification process involves several components:
+
+- **`GPGVerifier`**: Handles the core GPG signature verification logic using BouncyCastle
+- **`VerificationResult`**: Represents the outcome of verification (Valid, Invalid, Failed, SignatureNotFound)
+- **`CoderDownloadService`**: Manages downloading both binaries and their signatures
+- **`CoderCLIManager`**: Orchestrates the download and verification workflow
+
+### Configuration Options
+
+Users can control signature verification behavior through plugin settings:
+
+- **`disableSignatureVerification`**: When enabled, skips all signature verification. This is useful for clients running
+  custom CLI builds, or customers with old deployment versions that don't have a signature published on
+  `releases.coder.com`.
+- **`fallbackOnCoderForSignatures`**: When enabled, allows downloading signatures from `releases.coder.com` if not
+  available from the deployment.
+
+### Security Considerations
+
+- The plugin embeds Coder's trusted public key in the plugin resources
+- Verification uses detached signatures, which are more secure than attached signatures
+- Users are warned about security risks when verification fails
+- The system gracefully handles cases where signatures are unavailable
+- All verification failures are logged for debugging purposes
+
+### Error Handling
+
+The system handles various failure scenarios:
+
+- **Missing signatures**: Prompts user to accept risk or abort
+- **Invalid signatures**: Warns user about potential tampering and prompts user to accept risk or abort
+- **Verification failures**: Prompts user to accept risk or abort
+
+This signature verification system ensures that users can trust the Coder CLI binaries they download through the plugin,
+protecting against supply chain attacks and ensuring binary integrity.
+
 ## Configuring and Testing workspace polling with HTTP & SOCKS5 Proxy
 
 This section explains how to set up a local proxy and verify that
@@ -157,6 +220,27 @@ mitmweb --ssl-insecure --set stream_large_bodies="10m" --mode socks5
 >
 in: https://youtrack.jetbrains.com/issue/TBX-14532/Missing-proxy-authentication-settings#focus=Comments-27-12265861.0-0
 
+### Mitmproxy returns 502 Bad Gateway to the client
+
+When running traffic through mitmproxy, you may encounter 502 Bad Gateway errors that mention HTTP/2 protocol error: *
+*Received header value surrounded by whitespace**.
+This happens because some upstream servers (including dev.coder.com) send back headers such as Content-Security-Policy
+with leading or trailing spaces.
+While browsers and many HTTP clients accept these headers, mitmproxy enforces the stricter HTTP/2 and HTTP/1.1 RFCs,
+which forbid whitespace around header values.
+As a result, mitmproxy rejects the response and surfaces a 502 to the client.
+
+The workaround is to disable HTTP/2 in mitmproxy and force HTTP/1.1 on both the client and upstream sides. This avoids
+the strict header validation path and allows
+mitmproxy to pass responses through unchanged. You can do this by starting mitmproxy with:
+
+```bash
+mitmproxy --set http2=false --set upstream_http_version=HTTP/1.1
+```
+
+This ensures coder toolbox http client ↔ mitmproxy ↔ server connections all run over HTTP/1.1, preventing the whitespace
+error.
+
 ## Debugging and Reporting issues
 
 Enabling debug logging is essential for diagnosing issues with the Toolbox plugin, especially when SSH
@@ -194,6 +278,64 @@ via Toolbox App Menu > About > Show log files.
 Alternatively, you can generate a ZIP file using the Workspace action menu, available either on the main
 Workspaces page in Coder or within the individual workspace view, under the option labeled _Collect logs_.
 
+### HTTP Request Logging
+
+The Coder Toolbox plugin includes comprehensive HTTP request logging capabilities to help diagnose API communication
+issues with Coder deployments.
+This feature allows you to monitor all HTTP requests and responses made by the plugin.
+
+#### Configuring HTTP Logging
+
+You can configure HTTP logging verbosity through the Coder Settings page:
+
+1. Navigate to the Coder Workspaces page
+2. Click on the deployment action menu (three dots)
+3. Select "Settings"
+4. Find the "HTTP logging level" dropdown
+
+#### Available Logging Levels
+
+The plugin supports four levels of HTTP logging verbosity:
+
+- **None**: No HTTP request/response logging (default)
+- **Basic**: Logs HTTP method, URL, and response status code
+- **Headers**: Logs basic information plus sanitized request and response headers
+- **Body**: Logs headers plus request and response body content
+
+#### Log Output Format
+
+HTTP logs follow this format:
+
+```
+request --> GET https://your-coder-deployment.com/api/v2/users/me
+User-Agent: Coder Toolbox/1.0.0 (darwin; amd64)
+Coder-Session-Token: <redacted>
+
+response <-- 200 https://your-coder-deployment.com/api/v2/users/me
+Content-Type: application/json
+Content-Length: 245
+
+{"id":"12345678-1234-1234-1234-123456789012","username":"coder","email":"coder@example.com"}
+```
+
+#### Use Cases
+
+HTTP logging is particularly useful for:
+
+- **API Debugging**: Diagnosing issues with Coder API communication
+- **Authentication Problems**: Troubleshooting token or certificate authentication issues
+- **Network Issues**: Identifying connectivity problems with Coder deployments
+- **Performance Analysis**: Monitoring request/response times and payload sizes
+
+#### Troubleshooting with HTTP Logs
+
+When reporting issues, include HTTP logs to help diagnose:
+
+1. **Authentication Failures**: Check for 401/403 responses and token headers
+2. **Network Connectivity**: Look for connection timeouts or DNS resolution issues
+3. **API Compatibility**: Verify request/response formats match expected API versions
+4. **Proxy Issues**: Monitor proxy authentication and routing problems
+
 ## Coder Settings
 
 The Coder Settings allows users to control CLI download behavior, SSH configuration, TLS parameters, and data
diff --git a/gradle.properties b/gradle.properties
index 9513b30..3b06eb4 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,3 +1,3 @@
-version=0.5.0
+version=0.6.4
 group=com.coder.toolbox
-name=coder-toolbox
+name=coder-toolbox
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 28820b1..1bbf2b9 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -5,16 +5,16 @@ coroutines = "1.10.2"
 serialization = "1.8.1"
 okhttp = "4.12.0"
 dependency-license-report = "2.9"
-marketplace-client = "2.0.47"
+marketplace-client = "2.0.49"
 gradle-wrapper = "0.15.0"
 exec = "1.12"
 moshi = "1.15.2"
 ksp = "2.1.20-2.0.1"
 retrofit = "3.0.0"
-changelog = "2.2.1"
+changelog = "2.4.0"
 gettext = "0.7.0"
-plugin-structure = "3.310"
-mockk = "1.14.4"
+plugin-structure = "3.315"
+mockk = "1.14.5"
 detekt = "1.23.8"
 bouncycastle = "1.81"
 
diff --git a/src/main/kotlin/com/coder/toolbox/CoderRemoteEnvironment.kt b/src/main/kotlin/com/coder/toolbox/CoderRemoteEnvironment.kt
index 08f5a07..d4531a6 100644
--- a/src/main/kotlin/com/coder/toolbox/CoderRemoteEnvironment.kt
+++ b/src/main/kotlin/com/coder/toolbox/CoderRemoteEnvironment.kt
@@ -24,6 +24,7 @@ import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentDescription
 import com.jetbrains.toolbox.api.remoteDev.states.RemoteEnvironmentState
 import com.jetbrains.toolbox.api.ui.actions.ActionDescription
 import com.squareup.moshi.Moshi
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -68,13 +69,20 @@ class CoderRemoteEnvironment(
     private val proxyCommandHandle = SshCommandProcessHandle(context)
     private var pollJob: Job? = null
 
+    init {
+        if (context.settingsStore.shouldAutoConnect(id)) {
+            context.logger.info("resuming SSH connection to $id — last session was still active.")
+            startSshConnection()
+        }
+    }
+
     fun asPairOfWorkspaceAndAgent(): Pair<Workspace, WorkspaceAgent> = Pair(workspace, agent)
 
     private fun getAvailableActions(): List<ActionDescription> {
         val actions = mutableListOf<Action>()
         if (wsRawStatus.canStop()) {
             actions.add(Action(context.i18n.ptrl("Open web terminal")) {
-                context.cs.launch {
+                context.cs.launch(CoroutineName("Open Web Terminal Action")) {
                     context.desktop.browse(client.url.withPath("/${workspace.ownerName}/$name/terminal").toString()) {
                         context.ui.showErrorInfoPopup(it)
                     }
@@ -83,7 +91,7 @@ class CoderRemoteEnvironment(
         }
         actions.add(
             Action(context.i18n.ptrl("Open in dashboard")) {
-                context.cs.launch {
+                context.cs.launch(CoroutineName("Open in Dashboard Action")) {
                     context.desktop.browse(
                         client.url.withPath("/@${workspace.ownerName}/${workspace.name}").toString()
                     ) {
@@ -93,7 +101,7 @@ class CoderRemoteEnvironment(
             })
 
         actions.add(Action(context.i18n.ptrl("View template")) {
-            context.cs.launch {
+            context.cs.launch(CoroutineName("View Template Action")) {
                 context.desktop.browse(client.url.withPath("/templates/${workspace.templateName}").toString()) {
                     context.ui.showErrorInfoPopup(it)
                 }
@@ -103,14 +111,14 @@ class CoderRemoteEnvironment(
         if (wsRawStatus.canStart()) {
             if (workspace.outdated) {
                 actions.add(Action(context.i18n.ptrl("Update and start")) {
-                    context.cs.launch {
+                    context.cs.launch(CoroutineName("Update and Start Action")) {
                         val build = client.updateWorkspace(workspace)
                         update(workspace.copy(latestBuild = build), agent)
                     }
                 })
             } else {
                 actions.add(Action(context.i18n.ptrl("Start")) {
-                    context.cs.launch {
+                    context.cs.launch(CoroutineName("Start Action")) {
                         val build = client.startWorkspace(workspace)
                         update(workspace.copy(latestBuild = build), agent)
 
@@ -121,14 +129,14 @@ class CoderRemoteEnvironment(
         if (wsRawStatus.canStop()) {
             if (workspace.outdated) {
                 actions.add(Action(context.i18n.ptrl("Update and restart")) {
-                    context.cs.launch {
+                    context.cs.launch(CoroutineName("Update and Restart Action")) {
                         val build = client.updateWorkspace(workspace)
                         update(workspace.copy(latestBuild = build), agent)
                     }
                 })
             }
             actions.add(Action(context.i18n.ptrl("Stop")) {
-                context.cs.launch {
+                context.cs.launch(CoroutineName("Stop Action")) {
                     tryStopSshConnection()
 
                     val build = client.stopWorkspace(workspace)
@@ -158,10 +166,11 @@ class CoderRemoteEnvironment(
     override fun beforeConnection() {
         context.logger.info("Connecting to $id...")
         isConnected.update { true }
+        context.settingsStore.updateAutoConnect(this.id, true)
         pollJob = pollNetworkMetrics()
     }
 
-    private fun pollNetworkMetrics(): Job = context.cs.launch {
+    private fun pollNetworkMetrics(): Job = context.cs.launch(CoroutineName("Network Metrics Poller")) {
         context.logger.info("Starting the network metrics poll job for $id")
         while (isActive) {
             context.logger.debug("Searching SSH command's PID for workspace $id...")
@@ -180,12 +189,9 @@ class CoderRemoteEnvironment(
             }
             context.logger.debug("Loading metrics from ${metricsFile.absolutePath} for $id")
             try {
-                val metrics = networkMetricsMarshaller.fromJson(metricsFile.readText())
-                if (metrics == null) {
-                    return@launch
-                }
+                val metrics = networkMetricsMarshaller.fromJson(metricsFile.readText()) ?: return@launch
                 context.logger.debug("$id metrics: $metrics")
-                additionalEnvironmentInformation.put(context.i18n.ptrl("Network Status"), metrics.toPretty())
+                additionalEnvironmentInformation[context.i18n.ptrl("Network Status")] = metrics.toPretty()
             } catch (e: Exception) {
                 context.logger.error(
                     e,
@@ -203,6 +209,10 @@ class CoderRemoteEnvironment(
         pollJob?.cancel()
         this.connectionRequest.update { false }
         isConnected.update { false }
+        if (isManual) {
+            // if the user manually disconnects the ssh connection we should not connect automatically
+            context.settingsStore.updateAutoConnect(this.id, false)
+        }
         context.logger.info("Disconnected from $id")
     }
 
@@ -218,7 +228,7 @@ class CoderRemoteEnvironment(
         actionsList.update {
             getAvailableActions()
         }
-        context.cs.launch {
+        context.cs.launch(CoroutineName("Workspace Status Updater")) {
             state.update {
                 wsRawStatus.toRemoteEnvironmentState(context)
             }
@@ -253,7 +263,7 @@ class CoderRemoteEnvironment(
      */
     fun startSshConnection(): Boolean {
         if (wsRawStatus.ready() && !isConnected.value) {
-            context.cs.launch {
+            context.cs.launch(CoroutineName("SSH Connection Trigger")) {
                 connectionRequest.update {
                     true
                 }
@@ -275,7 +285,7 @@ class CoderRemoteEnvironment(
     }
 
     override val deleteActionFlow: StateFlow<(() -> Unit)?> = MutableStateFlow {
-        context.cs.launch {
+        context.cs.launch(CoroutineName("Delete Workspace Action")) {
             try {
                 client.removeWorkspace(workspace)
                 // mark the env as deleting otherwise we will have to
@@ -284,7 +294,7 @@ class CoderRemoteEnvironment(
                     WorkspaceAndAgentStatus.DELETING.toRemoteEnvironmentState(context)
                 }
 
-                context.cs.launch {
+                context.cs.launch(CoroutineName("Workspace Deletion Poller")) {
                     withTimeout(5.minutes) {
                         var workspaceStillExists = true
                         while (context.cs.isActive && workspaceStillExists) {
diff --git a/src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt b/src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt
index 3e3172a..cf9e04e 100644
--- a/src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt
+++ b/src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt
@@ -7,12 +7,14 @@ import com.coder.toolbox.sdk.ex.APIResponseException
 import com.coder.toolbox.sdk.v2.models.WorkspaceStatus
 import com.coder.toolbox.util.CoderProtocolHandler
 import com.coder.toolbox.util.DialogUi
+import com.coder.toolbox.util.toURL
 import com.coder.toolbox.util.waitForTrue
 import com.coder.toolbox.util.withPath
 import com.coder.toolbox.views.Action
 import com.coder.toolbox.views.CoderCliSetupWizardPage
 import com.coder.toolbox.views.CoderSettingsPage
 import com.coder.toolbox.views.NewEnvironmentPage
+import com.coder.toolbox.views.state.CoderCliSetupContext
 import com.coder.toolbox.views.state.CoderCliSetupWizardState
 import com.coder.toolbox.views.state.WizardStep
 import com.jetbrains.toolbox.api.core.ui.icons.SvgIcon
@@ -24,6 +26,7 @@ import com.jetbrains.toolbox.api.remoteDev.RemoteProvider
 import com.jetbrains.toolbox.api.ui.actions.ActionDelimiter
 import com.jetbrains.toolbox.api.ui.actions.ActionDescription
 import com.jetbrains.toolbox.api.ui.components.UiPage
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.Channel
@@ -35,7 +38,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.selects.onTimeout
 import kotlinx.coroutines.selects.select
 import java.net.URI
-import java.util.UUID
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.TimeSource
@@ -54,8 +56,8 @@ class CoderRemoteProvider(
 
     private val settings = context.settingsStore.readOnly()
 
-    // Create our services from the Toolbox ones.
     private val triggerSshConfig = Channel<Boolean>(Channel.CONFLATED)
+    private val triggerProviderVisible = Channel<Boolean>(Channel.CONFLATED)
     private val settingsPage: CoderSettingsPage = CoderSettingsPage(context, triggerSshConfig)
     private val dialogUi = DialogUi(context)
 
@@ -66,139 +68,140 @@ class CoderRemoteProvider(
     private var firstRun = true
     private val isInitialized: MutableStateFlow<Boolean> = MutableStateFlow(false)
     private val coderHeaderPage = NewEnvironmentPage(context.i18n.pnotr(context.deploymentUrl.toString()))
-    private val linkHandler = CoderProtocolHandler(context, dialogUi, isInitialized)
-
-    override val loadingEnvironmentsDescription: LocalizableString = context.i18n.ptrl("Loading workspaces...")
-    override val environments: MutableStateFlow<LoadableState<List<CoderRemoteEnvironment>>> = MutableStateFlow(
-        LoadableState.Loading
-    )
-
     private val visibilityState = MutableStateFlow(
         ProviderVisibilityState(
             applicationVisible = false,
             providerVisible = false
         )
     )
+    private val linkHandler = CoderProtocolHandler(context, dialogUi, settingsPage, visibilityState, isInitialized)
+
+    override val loadingEnvironmentsDescription: LocalizableString = context.i18n.ptrl("Loading workspaces...")
+    override val environments: MutableStateFlow<LoadableState<List<CoderRemoteEnvironment>>> = MutableStateFlow(
+        LoadableState.Loading
+    )
+
+    private val errorBuffer = mutableListOf<Throwable>()
 
     /**
      * With the provided client, start polling for workspaces.  Every time a new
      * workspace is added, reconfigure SSH using the provided cli (including the
      * first time).
      */
-    private fun poll(client: CoderRestClient, cli: CoderCLIManager): Job = context.cs.launch {
-        var lastPollTime = TimeSource.Monotonic.markNow()
-        while (isActive) {
-            try {
-                context.logger.debug("Fetching workspace agents from ${client.url}")
-                val resolvedEnvironments = client.workspaces().flatMap { ws ->
-                    // Agents are not included in workspaces that are off
-                    // so fetch them separately.
-                    when (ws.latestBuild.status) {
-                        WorkspaceStatus.RUNNING -> ws.latestBuild.resources
-                        else -> emptyList()
-                    }.ifEmpty {
-                        client.resources(ws)
-                    }.flatMap { resource ->
-                        resource.agents?.distinctBy {
-                            // There can be duplicates with coder_agent_instance.
-                            // TODO: Can we just choose one or do they hold
-                            //       different information?
-                            it.name
-                        }?.map { agent ->
-                            // If we have an environment already, update that.
-                            val env = CoderRemoteEnvironment(context, client, cli, ws, agent)
-                            lastEnvironments.firstOrNull { it == env }?.let {
-                                it.update(ws, agent)
-                                it
-                            } ?: env
-                        } ?: emptyList()
-                    }
-                }.toSet()
+    private fun poll(client: CoderRestClient, cli: CoderCLIManager): Job =
+        context.cs.launch(CoroutineName("Workspace Poller")) {
+            var lastPollTime = TimeSource.Monotonic.markNow()
+            while (isActive) {
+                try {
+                    context.logger.debug("Fetching workspace agents from ${client.url}")
+                    val resolvedEnvironments = client.workspaces().flatMap { ws ->
+                        // Agents are not included in workspaces that are off
+                        // so fetch them separately.
+                        when (ws.latestBuild.status) {
+                            WorkspaceStatus.RUNNING -> ws.latestBuild.resources
+                            else -> emptyList()
+                        }.ifEmpty {
+                            client.resources(ws)
+                        }.flatMap { resource ->
+                            resource.agents?.distinctBy {
+                                // There can be duplicates with coder_agent_instance.
+                                // TODO: Can we just choose one or do they hold
+                                //       different information?
+                                it.name
+                            }?.map { agent ->
+                                // If we have an environment already, update that.
+                                val env = CoderRemoteEnvironment(context, client, cli, ws, agent)
+                                lastEnvironments.firstOrNull { it == env }?.let {
+                                    it.update(ws, agent)
+                                    it
+                                } ?: env
+                            } ?: emptyList()
+                        }
+                    }.toSet()
 
-                // In case we logged out while running the query.
-                if (!isActive) {
-                    return@launch
-                }
+                    // In case we logged out while running the query.
+                    if (!isActive) {
+                        return@launch
+                    }
 
-                // Reconfigure if environments changed.
-                if (lastEnvironments.size != resolvedEnvironments.size || lastEnvironments != resolvedEnvironments) {
-                    context.logger.info("Workspaces have changed, reconfiguring CLI: $resolvedEnvironments")
-                    cli.configSsh(resolvedEnvironments.map { it.asPairOfWorkspaceAndAgent() }.toSet())
-                }
+                    // Reconfigure if environments changed.
+                    if (lastEnvironments.size != resolvedEnvironments.size || lastEnvironments != resolvedEnvironments) {
+                        context.logger.info("Workspaces have changed, reconfiguring CLI: $resolvedEnvironments")
+                        cli.configSsh(resolvedEnvironments.map { it.asPairOfWorkspaceAndAgent() }.toSet())
+                    }
 
-                environments.update {
-                    LoadableState.Value(resolvedEnvironments.toList())
-                }
-                if (!isInitialized.value) {
-                    context.logger.info("Environments for ${client.url} are now initialized")
-                    isInitialized.update {
-                        true
+                    environments.update {
+                        LoadableState.Value(resolvedEnvironments.toList())
+                    }
+                    if (!isInitialized.value) {
+                        context.logger.info("Environments for ${client.url} are now initialized")
+                        isInitialized.update {
+                            true
+                        }
+                    }
+                    lastEnvironments.apply {
+                        clear()
+                        addAll(resolvedEnvironments.sortedBy { it.id })
                     }
-                }
-                lastEnvironments.apply {
-                    clear()
-                    addAll(resolvedEnvironments.sortedBy { it.id })
-                }
 
-                if (WorkspaceConnectionManager.shouldEstablishWorkspaceConnections) {
-                    WorkspaceConnectionManager.allConnected().forEach { wsId ->
-                        val env = lastEnvironments.firstOrNull() { it.id == wsId }
-                        if (env != null && !env.isConnected()) {
-                            context.logger.info("Establishing lost SSH connection for workspace with id $wsId")
-                            if (!env.startSshConnection()) {
-                                context.logger.info("Can't establish lost SSH connection for workspace with id $wsId")
+                    if (WorkspaceConnectionManager.shouldEstablishWorkspaceConnections) {
+                        WorkspaceConnectionManager.allConnected().forEach { wsId ->
+                            val env = lastEnvironments.firstOrNull() { it.id == wsId }
+                            if (env != null && !env.isConnected()) {
+                                context.logger.info("Establishing lost SSH connection for workspace with id $wsId")
+                                if (!env.startSshConnection()) {
+                                    context.logger.info("Can't establish lost SSH connection for workspace with id $wsId")
+                                }
                             }
                         }
+                        WorkspaceConnectionManager.reset()
                     }
-                    WorkspaceConnectionManager.reset()
-                }
 
-                WorkspaceConnectionManager.collectStatuses(lastEnvironments)
-            } catch (_: CancellationException) {
-                context.logger.debug("${client.url} polling loop canceled")
-                break
-            } catch (ex: Exception) {
-                val elapsed = lastPollTime.elapsedNow()
-                if (elapsed > POLL_INTERVAL * 2) {
-                    context.logger.info("wake-up from an OS sleep was detected, going to re-initialize the http client...")
-                    client.setupSession()
-                } else {
-                    context.logger.error(ex, "workspace polling error encountered, trying to auto-login")
-                    if (ex is APIResponseException && ex.isTokenExpired) {
-                        WorkspaceConnectionManager.shouldEstablishWorkspaceConnections = true
-                    }
-                    close()
-                    // force auto-login
-                    firstRun = true
-                    context.envPageManager.showPluginEnvironmentsPage()
+                    WorkspaceConnectionManager.collectStatuses(lastEnvironments)
+                } catch (_: CancellationException) {
+                    context.logger.debug("${client.url} polling loop canceled")
                     break
+                } catch (ex: Exception) {
+                    val elapsed = lastPollTime.elapsedNow()
+                    if (elapsed > POLL_INTERVAL * 2) {
+                        context.logger.info("wake-up from an OS sleep was detected")
+                    } else {
+                        context.logger.error(ex, "workspace polling error encountered")
+                        if (ex is APIResponseException && ex.isTokenExpired) {
+                            WorkspaceConnectionManager.shouldEstablishWorkspaceConnections = true
+                            close()
+                            context.envPageManager.showPluginEnvironmentsPage()
+                            errorBuffer.add(ex)
+                            break
+                        }
+                    }
                 }
-            }
 
-            // TODO: Listening on a web socket might be better?
-            select<Unit> {
-                onTimeout(POLL_INTERVAL) {
-                    context.logger.trace("workspace poller waked up by the $POLL_INTERVAL timeout")
-                }
-                triggerSshConfig.onReceive { shouldTrigger ->
-                    if (shouldTrigger) {
-                        context.logger.trace("workspace poller waked up because it should reconfigure the ssh configurations")
-                        cli.configSsh(lastEnvironments.map { it.asPairOfWorkspaceAndAgent() }.toSet())
+                select {
+                    onTimeout(POLL_INTERVAL) {
+                        context.logger.debug("workspace poller waked up by the $POLL_INTERVAL timeout")
+                    }
+                    triggerSshConfig.onReceive { shouldTrigger ->
+                        if (shouldTrigger) {
+                            context.logger.debug("workspace poller waked up because it should reconfigure the ssh configurations")
+                            cli.configSsh(lastEnvironments.map { it.asPairOfWorkspaceAndAgent() }.toSet())
+                        }
+                    }
+                    triggerProviderVisible.onReceive { isCoderProviderVisible ->
+                        if (isCoderProviderVisible) {
+                            context.logger.debug("workspace poller waked up by Coder Toolbox which is currently visible, fetching latest workspace statuses")
+                        }
                     }
                 }
+                lastPollTime = TimeSource.Monotonic.markNow()
             }
-            lastPollTime = TimeSource.Monotonic.markNow()
         }
-    }
 
     /**
      * Stop polling, clear the client and environments, then go back to the
      * first page.
      */
     private fun logout() {
-        // Keep the URL and token to make it easy to log back in, but set
-        // rememberMe to false so we do not try to automatically log in.
-        context.secrets.rememberMe = false
         WorkspaceConnectionManager.reset()
         close()
     }
@@ -220,7 +223,7 @@ class CoderRemoteProvider(
     override val additionalPluginActions: StateFlow<List<ActionDescription>> = MutableStateFlow(
         listOf(
             Action(context.i18n.ptrl("Create workspace")) {
-                context.cs.launch {
+                context.cs.launch(CoroutineName("Create Workspace Action")) {
                     context.desktop.browse(client?.url?.withPath("/templates").toString()) {
                         context.ui.showErrorInfoPopup(it)
                     }
@@ -245,7 +248,7 @@ class CoderRemoteProvider(
         environments.value = LoadableState.Value(emptyList())
         isInitialized.update { false }
         client = null
-        CoderCliSetupWizardState.resetSteps()
+        CoderCliSetupWizardState.goToFirstStep()
     }
 
     override val svgIcon: SvgIcon =
@@ -297,6 +300,11 @@ class CoderRemoteProvider(
         visibilityState.update {
             visibility
         }
+        if (visibility.providerVisible) {
+            context.cs.launch(CoroutineName("Notify Plugin Visibility")) {
+                triggerProviderVisible.send(true)
+            }
+        }
     }
 
     /**
@@ -305,17 +313,8 @@ class CoderRemoteProvider(
     override suspend fun handleUri(uri: URI) {
         try {
             linkHandler.handle(
-                uri, shouldDoAutoSetup(),
-                {
-                    coderHeaderPage.isBusyCreatingNewEnvironment.update {
-                        true
-                    }
-                },
-                {
-                    coderHeaderPage.isBusyCreatingNewEnvironment.update {
-                        false
-                    }
-                }
+                uri,
+                shouldDoAutoSetup()
             ) { restClient, cli ->
                 // stop polling and de-initialize resources
                 close()
@@ -331,23 +330,16 @@ class CoderRemoteProvider(
                 isInitialized.waitForTrue()
             }
         } catch (ex: Exception) {
-            context.logger.error(ex, "")
             val textError = if (ex is APIResponseException) {
                 if (!ex.reason.isNullOrBlank()) {
                     ex.reason
                 } else ex.message
             } else ex.message
-
-            context.ui.showSnackbar(
-                UUID.randomUUID().toString(),
-                context.i18n.ptrl("Error encountered while handling Coder URI"),
-                context.i18n.pnotr(textError ?: ""),
-                context.i18n.ptrl("Dismiss")
+            context.logAndShowError(
+                "Error encountered while handling Coder URI",
+                textError ?: ""
             )
-        } finally {
-            coderHeaderPage.isBusyCreatingNewEnvironment.update {
-                false
-            }
+            context.envPageManager.showPluginEnvironmentsPage()
         }
     }
 
@@ -360,22 +352,26 @@ class CoderRemoteProvider(
     override fun getOverrideUiPage(): UiPage? {
         // Show the setup page if we have not configured the client yet.
         if (client == null) {
-            val errorBuffer = mutableListOf<Throwable>()
             // When coming back to the application, initializeSession immediately.
-            val autoSetup = shouldDoAutoSetup()
-            context.secrets.lastToken.let { lastToken ->
-                context.secrets.lastDeploymentURL.let { lastDeploymentURL ->
-                    if (autoSetup && lastDeploymentURL.isNotBlank() && (lastToken.isNotBlank() || !settings.requireTokenAuth)) {
-                        try {
-                            CoderCliSetupWizardState.goToStep(WizardStep.CONNECT)
-                            return CoderCliSetupWizardPage(context, settingsPage, visibilityState, true, ::onConnect)
-                        } catch (ex: Exception) {
-                            errorBuffer.add(ex)
-                        }
+            if (shouldDoAutoSetup()) {
+                try {
+                    CoderCliSetupContext.apply {
+                        url = context.secrets.lastDeploymentURL.toURL()
+                        token = context.secrets.lastToken
                     }
+                    CoderCliSetupWizardState.goToStep(WizardStep.CONNECT)
+                    return CoderCliSetupWizardPage(
+                        context, settingsPage, visibilityState,
+                        initialAutoSetup = true,
+                        jumpToMainPageOnError = false,
+                        onConnect = ::onConnect
+                    )
+                } catch (ex: Exception) {
+                    errorBuffer.add(ex)
+                } finally {
+                    firstRun = false
                 }
             }
-            firstRun = false
 
             // Login flow.
             val setupWizardPage =
@@ -384,26 +380,35 @@ class CoderRemoteProvider(
             errorBuffer.forEach {
                 setupWizardPage.notify("Error encountered", it)
             }
+            errorBuffer.clear()
             // and now reset the errors, otherwise we show it every time on the screen
             return setupWizardPage
         }
         return null
     }
 
-    private fun shouldDoAutoSetup(): Boolean = firstRun && context.secrets.rememberMe == true
+    /**
+     * Auto-login only on first the firs run if there is a url & token configured or the auth
+     * should be done via certificates.
+     */
+    private fun shouldDoAutoSetup(): Boolean = firstRun && (context.secrets.canAutoLogin || !settings.requireTokenAuth)
 
     private fun onConnect(client: CoderRestClient, cli: CoderCLIManager) {
         // Store the URL and token for use next time.
         context.secrets.lastDeploymentURL = client.url.toString()
         context.secrets.lastToken = client.token ?: ""
         context.secrets.storeTokenFor(client.url, context.secrets.lastToken)
-        // Currently we always remember, but this could be made an option.
-        context.secrets.rememberMe = true
+        context.logger.info("Deployment URL and token were stored and will be available for automatic connection")
         this.client = client
-        pollJob?.cancel()
+        pollJob?.let {
+            it.cancel()
+            context.logger.info("Workspace poll job with reference ${pollJob} was canceled")
+        }
         environments.showLoadingMessage()
         coderHeaderPage.setTitle(context.i18n.pnotr(client.url.toString()))
+        context.logger.info("Displaying ${client.url} in the UI")
         pollJob = poll(client, cli)
+        context.logger.info("Workspace poll job created with reference $pollJob")
         context.envPageManager.showPluginEnvironmentsPage()
     }
 
diff --git a/src/main/kotlin/com/coder/toolbox/CoderToolboxContext.kt b/src/main/kotlin/com/coder/toolbox/CoderToolboxContext.kt
index 4291321..baac820 100644
--- a/src/main/kotlin/com/coder/toolbox/CoderToolboxContext.kt
+++ b/src/main/kotlin/com/coder/toolbox/CoderToolboxContext.kt
@@ -88,4 +88,9 @@ data class CoderToolboxContext(
             i18n.ptrl("OK")
         )
     }
+
+    fun popupPluginMainPage() {
+        this.ui.showWindow()
+        this.envPageManager.showPluginEnvironmentsPage(true)
+    }
 }
diff --git a/src/main/kotlin/com/coder/toolbox/cli/CoderCLIManager.kt b/src/main/kotlin/com/coder/toolbox/cli/CoderCLIManager.kt
index 177ba81..9b058e5 100644
--- a/src/main/kotlin/com/coder/toolbox/cli/CoderCLIManager.kt
+++ b/src/main/kotlin/com/coder/toolbox/cli/CoderCLIManager.kt
@@ -12,14 +12,14 @@ import com.coder.toolbox.cli.gpg.GPGVerifier
 import com.coder.toolbox.cli.gpg.VerificationResult
 import com.coder.toolbox.cli.gpg.VerificationResult.Failed
 import com.coder.toolbox.cli.gpg.VerificationResult.Invalid
+import com.coder.toolbox.plugin.PluginManager
+import com.coder.toolbox.sdk.CoderHttpClientBuilder
+import com.coder.toolbox.sdk.interceptors.Interceptors
 import com.coder.toolbox.sdk.v2.models.Workspace
 import com.coder.toolbox.sdk.v2.models.WorkspaceAgent
 import com.coder.toolbox.settings.SignatureFallbackStrategy.ALLOW
-import com.coder.toolbox.util.CoderHostnameVerifier
 import com.coder.toolbox.util.InvalidVersionException
 import com.coder.toolbox.util.SemVer
-import com.coder.toolbox.util.coderSocketFactory
-import com.coder.toolbox.util.coderTrustManagers
 import com.coder.toolbox.util.escape
 import com.coder.toolbox.util.escapeSubcommand
 import com.coder.toolbox.util.safeHost
@@ -29,7 +29,6 @@ import com.squareup.moshi.JsonDataException
 import com.squareup.moshi.Moshi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import okhttp3.OkHttpClient
 import org.zeroturnaround.exec.ProcessExecutor
 import retrofit2.Retrofit
 import java.io.EOFException
@@ -37,7 +36,6 @@ import java.io.FileNotFoundException
 import java.net.URL
 import java.nio.file.Files
 import java.nio.file.Path
-import javax.net.ssl.X509TrustManager
 
 /**
  * Version output from the CLI's version command.
@@ -148,13 +146,14 @@ class CoderCLIManager(
     val coderConfigPath: Path = context.settingsStore.dataDir(deploymentURL).resolve("config")
 
     private fun createDownloadService(): CoderDownloadService {
-        val okHttpClient = OkHttpClient.Builder()
-            .sslSocketFactory(
-                coderSocketFactory(context.settingsStore.tls),
-                coderTrustManagers(context.settingsStore.tls.caPath)[0] as X509TrustManager
-            )
-            .hostnameVerifier(CoderHostnameVerifier(context.settingsStore.tls.altHostname))
-            .build()
+        val interceptors = buildList {
+            add((Interceptors.userAgent(PluginManager.pluginInfo.version)))
+            add(Interceptors.logging(context))
+        }
+        val okHttpClient = CoderHttpClientBuilder.build(
+            context,
+            interceptors
+        )
 
         val retrofit = Retrofit.Builder()
             .baseUrl(deploymentURL.toString())
@@ -181,6 +180,12 @@ class CoderCLIManager(
                 }
             }
 
+            if (context.settingsStore.disableSignatureVerification) {
+                downloader.commit()
+                context.logger.info("Skipping over CLI signature verification, it is disabled by the user")
+                return true
+            }
+
             var signatureResult = withContext(Dispatchers.IO) {
                 downloader.downloadSignature(showTextProgress)
             }
@@ -277,8 +282,8 @@ class CoderCLIManager(
             }
 
             else -> {
-                UnsignedBinaryExecutionDeniedException((result as Failed).error.message)
-                val failure = result as DownloadResult.Failed
+                val failure = result as Failed
+                UnsignedBinaryExecutionDeniedException(result.error.message)
                 context.logger.error(failure.error, "Failed to verify signature for ${cliResult.dst}")
             }
         }
@@ -310,6 +315,7 @@ class CoderCLIManager(
     ) {
         context.logger.info("Configuring SSH config at ${context.settingsStore.sshConfigPath}")
         writeSSHConfig(modifySSHConfig(readSSHConfig(), wsWithAgents, feats))
+        context.logger.info("Finished configuring SSH config")
     }
 
     /**
@@ -467,7 +473,7 @@ class CoderCLIManager(
      */
     private fun writeSSHConfig(contents: String?) {
         if (contents != null) {
-            if (!context.settingsStore.sshConfigPath.isNullOrBlank()) {
+            if (context.settingsStore.sshConfigPath.isNotBlank()) {
                 val sshConfPath = Path.of(context.settingsStore.sshConfigPath)
                 sshConfPath.parent.toFile().mkdirs()
                 sshConfPath.toFile().writeText(contents)
@@ -492,9 +498,9 @@ class CoderCLIManager(
                 throw MissingVersionException("No version found in output")
             }
             return SemVer.parse(json.version)
-        } catch (exception: JsonDataException) {
+        } catch (_: JsonDataException) {
             throw MissingVersionException("No version found in output")
-        } catch (exception: EOFException) {
+        } catch (_: EOFException) {
             throw MissingVersionException("No version found in output")
         }
     }
@@ -532,7 +538,7 @@ class CoderCLIManager(
         val buildVersion =
             try {
                 SemVer.parse(rawBuildVersion)
-            } catch (e: InvalidVersionException) {
+            } catch (_: InvalidVersionException) {
                 context.logger.info("Got invalid build version: $rawBuildVersion")
                 return null
             }
diff --git a/src/main/kotlin/com/coder/toolbox/cli/downloader/CoderDownloadService.kt b/src/main/kotlin/com/coder/toolbox/cli/downloader/CoderDownloadService.kt
index 03e3a4d..574184c 100644
--- a/src/main/kotlin/com/coder/toolbox/cli/downloader/CoderDownloadService.kt
+++ b/src/main/kotlin/com/coder/toolbox/cli/downloader/CoderDownloadService.kt
@@ -51,6 +51,13 @@ class CoderDownloadService(
 
         return when (response.code()) {
             HTTP_OK -> {
+                val contentType = response.headers()["Content-Type"]?.lowercase()
+                if (contentType?.startsWith("application/octet-stream") != true) {
+                    throw ResponseException(
+                        "Invalid content type '$contentType' when downloading CLI from $remoteBinaryURL. Expected application/octet-stream.",
+                        response.code()
+                    )
+                }
                 context.logger.info("Downloading binary to temporary $cliTempDst")
                 response.saveToDisk(cliTempDst, showTextProgress, buildVersion)?.makeExecutable()
                 DownloadResult.Downloaded(remoteBinaryURL, cliTempDst)
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/CoderHttpClientBuilder.kt b/src/main/kotlin/com/coder/toolbox/sdk/CoderHttpClientBuilder.kt
new file mode 100644
index 0000000..f80d60c
--- /dev/null
+++ b/src/main/kotlin/com/coder/toolbox/sdk/CoderHttpClientBuilder.kt
@@ -0,0 +1,56 @@
+package com.coder.toolbox.sdk
+
+import com.coder.toolbox.CoderToolboxContext
+import com.coder.toolbox.util.CoderHostnameVerifier
+import com.coder.toolbox.util.coderSocketFactory
+import com.coder.toolbox.util.coderTrustManagers
+import com.jetbrains.toolbox.api.remoteDev.connection.ProxyAuth
+import okhttp3.Credentials
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import javax.net.ssl.X509TrustManager
+
+object CoderHttpClientBuilder {
+    fun build(
+        context: CoderToolboxContext,
+        interceptors: List<Interceptor>
+    ): OkHttpClient {
+        val settings = context.settingsStore.readOnly()
+
+        val socketFactory = coderSocketFactory(settings.tls)
+        val trustManagers = coderTrustManagers(settings.tls.caPath)
+        var builder = OkHttpClient.Builder()
+
+        if (context.proxySettings.getProxy() != null) {
+            context.logger.info("proxy: ${context.proxySettings.getProxy()}")
+            builder.proxy(context.proxySettings.getProxy())
+        } else if (context.proxySettings.getProxySelector() != null) {
+            context.logger.info("proxy selector: ${context.proxySettings.getProxySelector()}")
+            builder.proxySelector(context.proxySettings.getProxySelector()!!)
+        }
+
+        // Note: This handles only HTTP/HTTPS proxy authentication.
+        // SOCKS5 proxy authentication is currently not supported due to limitations described in:
+        // https://youtrack.jetbrains.com/issue/TBX-14532/Missing-proxy-authentication-settings#focus=Comments-27-12265861.0-0
+        builder.proxyAuthenticator { _, response ->
+            val proxyAuth = context.proxySettings.getProxyAuth()
+            if (proxyAuth == null || proxyAuth !is ProxyAuth.Basic) {
+                return@proxyAuthenticator null
+            }
+            val credentials = Credentials.basic(proxyAuth.username, proxyAuth.password)
+            response.request.newBuilder()
+                .header("Proxy-Authorization", credentials)
+                .build()
+        }
+
+        builder.sslSocketFactory(socketFactory, trustManagers[0] as X509TrustManager)
+            .hostnameVerifier(CoderHostnameVerifier(settings.tls.altHostname))
+            .retryOnConnectionFailure(true)
+
+        interceptors.forEach { interceptor ->
+            builder.addInterceptor(interceptor)
+
+        }
+        return builder.build()
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt b/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt
index 9aa3dfb..803472c 100644
--- a/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt
+++ b/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt
@@ -3,9 +3,11 @@ package com.coder.toolbox.sdk
 import com.coder.toolbox.CoderToolboxContext
 import com.coder.toolbox.sdk.convertors.ArchConverter
 import com.coder.toolbox.sdk.convertors.InstantConverter
+import com.coder.toolbox.sdk.convertors.LoggingConverterFactory
 import com.coder.toolbox.sdk.convertors.OSConverter
 import com.coder.toolbox.sdk.convertors.UUIDConverter
 import com.coder.toolbox.sdk.ex.APIResponseException
+import com.coder.toolbox.sdk.interceptors.Interceptors
 import com.coder.toolbox.sdk.v2.CoderV2RestFacade
 import com.coder.toolbox.sdk.v2.models.ApiErrorResponse
 import com.coder.toolbox.sdk.v2.models.BuildInfo
@@ -15,18 +17,11 @@ import com.coder.toolbox.sdk.v2.models.User
 import com.coder.toolbox.sdk.v2.models.Workspace
 import com.coder.toolbox.sdk.v2.models.WorkspaceAgent
 import com.coder.toolbox.sdk.v2.models.WorkspaceBuild
+import com.coder.toolbox.sdk.v2.models.WorkspaceBuildReason
 import com.coder.toolbox.sdk.v2.models.WorkspaceResource
 import com.coder.toolbox.sdk.v2.models.WorkspaceStatus
 import com.coder.toolbox.sdk.v2.models.WorkspaceTransition
-import com.coder.toolbox.util.CoderHostnameVerifier
-import com.coder.toolbox.util.coderSocketFactory
-import com.coder.toolbox.util.coderTrustManagers
-import com.coder.toolbox.util.getArch
-import com.coder.toolbox.util.getHeaders
-import com.coder.toolbox.util.getOS
-import com.jetbrains.toolbox.api.remoteDev.connection.ProxyAuth
 import com.squareup.moshi.Moshi
-import okhttp3.Credentials
 import okhttp3.OkHttpClient
 import retrofit2.Response
 import retrofit2.Retrofit
@@ -34,7 +29,6 @@ import retrofit2.converter.moshi.MoshiConverterFactory
 import java.net.HttpURLConnection
 import java.net.URL
 import java.util.UUID
-import javax.net.ssl.X509TrustManager
 
 /**
  * An HTTP client that can make requests to the Coder API.
@@ -47,7 +41,6 @@ open class CoderRestClient(
     val token: String?,
     private val pluginVersion: String = "development",
 ) {
-    private val settings = context.settingsStore.readOnly()
     private lateinit var moshi: Moshi
     private lateinit var httpClient: OkHttpClient
     private lateinit var retroRestClient: CoderV2RestFacade
@@ -59,7 +52,7 @@ open class CoderRestClient(
         setupSession()
     }
 
-    fun setupSession() {
+    private fun setupSession() {
         moshi =
             Moshi.Builder()
                 .add(ArchConverter())
@@ -67,69 +60,31 @@ open class CoderRestClient(
                 .add(OSConverter())
                 .add(UUIDConverter())
                 .build()
-
-        val socketFactory = coderSocketFactory(settings.tls)
-        val trustManagers = coderTrustManagers(settings.tls.caPath)
-        var builder = OkHttpClient.Builder()
-
-        if (context.proxySettings.getProxy() != null) {
-            context.logger.debug("proxy: ${context.proxySettings.getProxy()}")
-            builder.proxy(context.proxySettings.getProxy())
-        } else if (context.proxySettings.getProxySelector() != null) {
-            context.logger.debug("proxy selector: ${context.proxySettings.getProxySelector()}")
-            builder.proxySelector(context.proxySettings.getProxySelector()!!)
-        }
-
-        // Note: This handles only HTTP/HTTPS proxy authentication.
-        // SOCKS5 proxy authentication is currently not supported due to limitations described in:
-        // https://youtrack.jetbrains.com/issue/TBX-14532/Missing-proxy-authentication-settings#focus=Comments-27-12265861.0-0
-        builder.proxyAuthenticator { _, response ->
-            val proxyAuth = context.proxySettings.getProxyAuth()
-            if (proxyAuth == null || proxyAuth !is ProxyAuth.Basic) {
-                return@proxyAuthenticator null
-            }
-            val credentials = Credentials.basic(proxyAuth.username, proxyAuth.password)
-            response.request.newBuilder()
-                .header("Proxy-Authorization", credentials)
-                .build()
-        }
-
-        if (token != null) {
-            builder = builder.addInterceptor {
-                it.proceed(
-                    it.request().newBuilder().addHeader("Coder-Session-Token", token).build()
-                )
+        val interceptors = buildList {
+            if (context.settingsStore.requireTokenAuth) {
+                if (token.isNullOrBlank()) {
+                    throw IllegalStateException("Token is required for $url deployment")
+                }
+                add(Interceptors.tokenAuth(token))
             }
+            add((Interceptors.userAgent(pluginVersion)))
+            add(Interceptors.externalHeaders(context, url))
+            add(Interceptors.logging(context))
         }
 
-        httpClient =
-            builder
-                .sslSocketFactory(socketFactory, trustManagers[0] as X509TrustManager)
-                .hostnameVerifier(CoderHostnameVerifier(settings.tls.altHostname))
-                .retryOnConnectionFailure(true)
-                .addInterceptor {
-                    it.proceed(
-                        it.request().newBuilder().addHeader(
-                            "User-Agent",
-                            "Coder Toolbox/$pluginVersion (${getOS()}; ${getArch()})",
-                        ).build(),
-                    )
-                }
-                .addInterceptor {
-                    var request = it.request()
-                    val headers = getHeaders(url, settings.headerCommand)
-                    if (headers.isNotEmpty()) {
-                        val reqBuilder = request.newBuilder()
-                        headers.forEach { h -> reqBuilder.addHeader(h.key, h.value) }
-                        request = reqBuilder.build()
-                    }
-                    it.proceed(request)
-                }
-                .build()
+        httpClient = CoderHttpClientBuilder.build(
+            context,
+            interceptors
+        )
 
         retroRestClient =
             Retrofit.Builder().baseUrl(url.toString()).client(httpClient)
-                .addConverterFactory(MoshiConverterFactory.create(moshi))
+                .addConverterFactory(
+                    LoggingConverterFactory.wrap(
+                        context,
+                        MoshiConverterFactory.create(moshi)
+                    )
+                )
                 .build().create(CoderV2RestFacade::class.java)
     }
 
@@ -268,7 +223,12 @@ open class CoderRestClient(
      * @throws [APIResponseException].
      */
     suspend fun startWorkspace(workspace: Workspace): WorkspaceBuild {
-        val buildRequest = CreateWorkspaceBuildRequest(null, WorkspaceTransition.START)
+        val buildRequest = CreateWorkspaceBuildRequest(
+            null,
+            WorkspaceTransition.START,
+            null,
+            WorkspaceBuildReason.JETBRAINS_CONNECTION
+        )
         val buildResponse = retroRestClient.createWorkspaceBuild(workspace.id, buildRequest)
         if (buildResponse.code() != HttpURLConnection.HTTP_CREATED) {
             throw APIResponseException(
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/convertors/LoggingConverterFactory.kt b/src/main/kotlin/com/coder/toolbox/sdk/convertors/LoggingConverterFactory.kt
new file mode 100644
index 0000000..839d753
--- /dev/null
+++ b/src/main/kotlin/com/coder/toolbox/sdk/convertors/LoggingConverterFactory.kt
@@ -0,0 +1,53 @@
+package com.coder.toolbox.sdk.convertors
+
+import com.coder.toolbox.CoderToolboxContext
+import okhttp3.RequestBody
+import okhttp3.ResponseBody
+import retrofit2.Converter
+import retrofit2.Retrofit
+import java.lang.reflect.Type
+
+class LoggingConverterFactory private constructor(
+    private val context: CoderToolboxContext,
+    private val delegate: Converter.Factory,
+) : Converter.Factory() {
+
+    override fun responseBodyConverter(
+        type: Type,
+        annotations: Array<Annotation>,
+        retrofit: Retrofit
+    ): Converter<ResponseBody, *>? {
+        // Get the delegate converter
+        val delegateConverter = delegate.responseBodyConverter(type, annotations, retrofit)
+            ?: return null
+
+        @Suppress("UNCHECKED_CAST")
+        return LoggingMoshiConverter(context, delegateConverter as Converter<ResponseBody, Any?>)
+    }
+
+    override fun requestBodyConverter(
+        type: Type,
+        parameterAnnotations: Array<Annotation>,
+        methodAnnotations: Array<Annotation>,
+        retrofit: Retrofit
+    ): Converter<*, RequestBody>? {
+        return delegate.requestBodyConverter(type, parameterAnnotations, methodAnnotations, retrofit)
+    }
+
+    override fun stringConverter(
+        type: Type,
+        annotations: Array<Annotation>,
+        retrofit: Retrofit
+    ): Converter<*, String>? {
+        return delegate.stringConverter(type, annotations, retrofit)
+    }
+
+    companion object {
+        fun wrap(
+            context: CoderToolboxContext,
+            delegate: Converter.Factory,
+        ): LoggingConverterFactory {
+            return LoggingConverterFactory(context, delegate)
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/convertors/LoggingMoshiConverter.kt b/src/main/kotlin/com/coder/toolbox/sdk/convertors/LoggingMoshiConverter.kt
new file mode 100644
index 0000000..9cc548a
--- /dev/null
+++ b/src/main/kotlin/com/coder/toolbox/sdk/convertors/LoggingMoshiConverter.kt
@@ -0,0 +1,34 @@
+package com.coder.toolbox.sdk.convertors
+
+import com.coder.toolbox.CoderToolboxContext
+import okhttp3.ResponseBody
+import okhttp3.ResponseBody.Companion.toResponseBody
+import retrofit2.Converter
+
+class LoggingMoshiConverter(
+    private val context: CoderToolboxContext,
+    private val delegate: Converter<ResponseBody, Any?>
+) : Converter<ResponseBody, Any> {
+
+    override fun convert(value: ResponseBody): Any? {
+        val bodyString = value.string()
+
+        return try {
+            // Parse with Moshi
+            delegate.convert(bodyString.toResponseBody(value.contentType()))
+        } catch (e: Exception) {
+            // Log the raw content that failed to parse
+            context.logger.error(
+                """
+                |Moshi parsing failed:
+                |Content-Type: ${value.contentType()}
+                |Content: $bodyString
+                |Error: ${e.message}
+            """.trimMargin()
+            )
+
+            // Re-throw so the onFailure callback still gets called
+            throw e
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/interceptors/Interceptors.kt b/src/main/kotlin/com/coder/toolbox/sdk/interceptors/Interceptors.kt
new file mode 100644
index 0000000..9c9f3ee
--- /dev/null
+++ b/src/main/kotlin/com/coder/toolbox/sdk/interceptors/Interceptors.kt
@@ -0,0 +1,64 @@
+package com.coder.toolbox.sdk.interceptors
+
+import com.coder.toolbox.CoderToolboxContext
+import com.coder.toolbox.util.getArch
+import com.coder.toolbox.util.getHeaders
+import com.coder.toolbox.util.getOS
+import okhttp3.Interceptor
+import java.net.URL
+
+/**
+ * Factory of okhttp interceptors
+ */
+object Interceptors {
+
+    /**
+     * Creates a token authentication interceptor
+     */
+    fun tokenAuth(token: String): Interceptor {
+        return Interceptor { chain ->
+            chain.proceed(
+                chain.request().newBuilder()
+                    .addHeader("Coder-Session-Token", token)
+                    .build()
+            )
+        }
+    }
+
+    /**
+     * Creates a User-Agent header interceptor
+     */
+    fun userAgent(pluginVersion: String): Interceptor {
+        return Interceptor { chain ->
+            chain.proceed(
+                chain.request().newBuilder()
+                    .addHeader("User-Agent", "Coder Toolbox/$pluginVersion (${getOS()}; ${getArch()})")
+                    .build()
+            )
+        }
+    }
+
+    /**
+     * Adds headers generated by executing a native command
+     */
+    fun externalHeaders(context: CoderToolboxContext, url: URL): Interceptor {
+        val settings = context.settingsStore.readOnly()
+        return Interceptor { chain ->
+            var request = chain.request()
+            val headers = getHeaders(url, settings.headerCommand)
+            if (headers.isNotEmpty()) {
+                val reqBuilder = request.newBuilder()
+                headers.forEach { h -> reqBuilder.addHeader(h.key, h.value) }
+                request = reqBuilder.build()
+            }
+            chain.proceed(request)
+        }
+    }
+
+    /**
+     * Creates a logging interceptor
+     */
+    fun logging(context: CoderToolboxContext): Interceptor {
+        return LoggingInterceptor(context)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/interceptors/LoggingInterceptor.kt b/src/main/kotlin/com/coder/toolbox/sdk/interceptors/LoggingInterceptor.kt
new file mode 100644
index 0000000..4bbb1b9
--- /dev/null
+++ b/src/main/kotlin/com/coder/toolbox/sdk/interceptors/LoggingInterceptor.kt
@@ -0,0 +1,120 @@
+package com.coder.toolbox.sdk.interceptors
+
+import com.coder.toolbox.CoderToolboxContext
+import com.coder.toolbox.settings.HttpLoggingVerbosity
+import okhttp3.Headers
+import okhttp3.Interceptor
+import okhttp3.MediaType
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.Response
+import okhttp3.ResponseBody
+import okio.Buffer
+import java.nio.charset.StandardCharsets
+
+private val SENSITIVE_HEADERS = setOf("Coder-Session-Token", "Proxy-Authorization")
+
+class LoggingInterceptor(private val context: CoderToolboxContext) : Interceptor {
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val logLevel = context.settingsStore.httpClientLogLevel
+        if (logLevel == HttpLoggingVerbosity.NONE) {
+            return chain.proceed(chain.request())
+        }
+
+        val request = chain.request()
+        logRequest(request, logLevel)
+
+        val response = chain.proceed(request)
+        logResponse(response, request, logLevel)
+
+        return response
+    }
+
+    private fun logRequest(request: Request, logLevel: HttpLoggingVerbosity) {
+        val log = buildString {
+            append("request --> ${request.method} ${request.url}")
+
+            if (logLevel >= HttpLoggingVerbosity.HEADERS) {
+                append("\n${request.headers.sanitized()}")
+            }
+
+            if (logLevel == HttpLoggingVerbosity.BODY) {
+                request.body?.let { body ->
+                    append("\n${body.toPrintableString()}")
+                }
+            }
+        }
+
+        context.logger.info(log)
+    }
+
+    private fun logResponse(response: Response, request: Request, logLevel: HttpLoggingVerbosity) {
+        val log = buildString {
+            append("response <-- ${response.code} ${response.message} ${request.url}")
+
+            if (logLevel >= HttpLoggingVerbosity.HEADERS) {
+                append("\n${response.headers.sanitized()}")
+            }
+
+            if (logLevel == HttpLoggingVerbosity.BODY) {
+                response.body?.let { body ->
+                    append("\n${body.toPrintableString()}")
+                }
+            }
+        }
+
+        context.logger.info(log)
+    }
+}
+
+// Extension functions for cleaner code
+private fun Headers.sanitized(): String = buildString {
+    this@sanitized.forEach { (name, value) ->
+        val displayValue = if (name in SENSITIVE_HEADERS) "<redacted>" else value
+        append("$name: $displayValue\n")
+    }
+}
+
+private fun RequestBody.toPrintableString(): String {
+    if (!contentType().isPrintable()) {
+        return "[Binary body: ${contentLength().formatBytes()}, ${contentType()}]"
+    }
+
+    return try {
+        val buffer = Buffer()
+        writeTo(buffer)
+        buffer.readString(contentType()?.charset() ?: StandardCharsets.UTF_8)
+    } catch (e: Exception) {
+        "[Error reading body: ${e.message}]"
+    }
+}
+
+private fun ResponseBody.toPrintableString(): String {
+    if (!contentType().isPrintable()) {
+        return "[Binary body: ${contentLength().formatBytes()}, ${contentType()}]"
+    }
+
+    return try {
+        val source = source()
+        source.request(Long.MAX_VALUE)
+        source.buffer.clone().readString(contentType()?.charset() ?: StandardCharsets.UTF_8)
+    } catch (e: Exception) {
+        "[Error reading body: ${e.message}]"
+    }
+}
+
+private fun MediaType?.isPrintable(): Boolean = when {
+    this == null -> false
+    type == "text" -> true
+    subtype == "json" || subtype.endsWith("+json") -> true
+    else -> false
+}
+
+private fun Long.formatBytes(): String = when {
+    this < 0 -> "unknown"
+    this < 1024 -> "${this}B"
+    this < 1024 * 1024 -> "${this / 1024}KB"
+    this < 1024 * 1024 * 1024 -> "${this / (1024 * 1024)}MB"
+    else -> "${this / (1024 * 1024 * 1024)}GB"
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/v2/models/CreateWorkspaceBuildRequest.kt b/src/main/kotlin/com/coder/toolbox/sdk/v2/models/CreateWorkspaceBuildRequest.kt
index a2f1ca2..53c70c8 100644
--- a/src/main/kotlin/com/coder/toolbox/sdk/v2/models/CreateWorkspaceBuildRequest.kt
+++ b/src/main/kotlin/com/coder/toolbox/sdk/v2/models/CreateWorkspaceBuildRequest.kt
@@ -10,7 +10,8 @@ data class CreateWorkspaceBuildRequest(
     @Json(name = "template_version_id") val templateVersionID: UUID?,
     // Use to start, stop and delete the workspace.
     @Json(name = "transition") val transition: WorkspaceTransition,
-    @Json(name = "orphan") var orphan: Boolean? = null
+    @Json(name = "orphan") var orphan: Boolean? = null,
+    @Json(name = "reason") var reason: WorkspaceBuildReason? = null
 ) {
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -21,6 +22,7 @@ data class CreateWorkspaceBuildRequest(
         if (templateVersionID != other.templateVersionID) return false
         if (transition != other.transition) return false
         if (orphan != other.orphan) return false
+        if (reason != other.reason) return false
         return true
     }
 
@@ -28,6 +30,7 @@ data class CreateWorkspaceBuildRequest(
         var result = orphan?.hashCode() ?: 0
         result = 31 * result + (templateVersionID?.hashCode() ?: 0)
         result = 31 * result + transition.hashCode()
+        result = 31 * result + (reason?.hashCode() ?: 0)
         return result
     }
 }
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/v2/models/WorkspaceBuildReason.kt b/src/main/kotlin/com/coder/toolbox/sdk/v2/models/WorkspaceBuildReason.kt
new file mode 100644
index 0000000..390c934
--- /dev/null
+++ b/src/main/kotlin/com/coder/toolbox/sdk/v2/models/WorkspaceBuildReason.kt
@@ -0,0 +1,7 @@
+package com.coder.toolbox.sdk.v2.models
+
+import com.squareup.moshi.Json
+
+enum class WorkspaceBuildReason {
+    @Json(name = "jetbrains_connection") JETBRAINS_CONNECTION,
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt b/src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt
index a6d6143..0000ea6 100644
--- a/src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt
+++ b/src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt
@@ -29,10 +29,20 @@ interface ReadOnlyCoderSettings {
     val binaryDirectory: String?
 
     /**
-     * Controls whether we fall back release.coder.com
+     * Controls whether we verify the cli signature
+     */
+    val disableSignatureVerification: Boolean
+
+    /**
+     * Controls whether we fall back on release.coder.com for signatures if signature validation is enabled
      */
     val fallbackOnCoderForSignatures: SignatureFallbackStrategy
 
+    /**
+     * Controls the logging for the rest client.
+     */
+    val httpClientLogLevel: HttpLoggingVerbosity
+
     /**
      * Default CLI binary name based on OS and architecture
      */
@@ -146,6 +156,11 @@ interface ReadOnlyCoderSettings {
      * Return the URL and token from the config, if they exist.
      */
     fun readConfig(dir: Path): Pair<String?, String?>
+
+    /**
+     * Returns whether the SSH connection should be automatically established.
+     */
+    fun shouldAutoConnect(workspaceId: String): Boolean
 }
 
 /**
@@ -206,4 +221,32 @@ enum class SignatureFallbackStrategy {
             else -> NOT_CONFIGURED
         }
     }
+}
+
+enum class HttpLoggingVerbosity {
+    NONE,
+
+    /**
+     * Logs URL, method, and status
+     */
+    BASIC,
+
+    /**
+     * Logs BASIC + sanitized headers
+     */
+    HEADERS,
+
+    /**
+     * Logs HEADERS + body content
+     */
+    BODY;
+
+    companion object {
+        fun fromValue(value: String?): HttpLoggingVerbosity = when (value?.lowercase(getDefault())) {
+            "basic" -> BASIC
+            "headers" -> HEADERS
+            "body" -> BODY
+            else -> NONE
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/store/CoderSecretsStore.kt b/src/main/kotlin/com/coder/toolbox/store/CoderSecretsStore.kt
index 3170a06..a807b69 100644
--- a/src/main/kotlin/com/coder/toolbox/store/CoderSecretsStore.kt
+++ b/src/main/kotlin/com/coder/toolbox/store/CoderSecretsStore.kt
@@ -24,9 +24,8 @@ class CoderSecretsStore(private val store: PluginSecretStore) {
     var lastToken: String
         get() = get("last-token")
         set(value) = set("last-token", value)
-    var rememberMe: Boolean
-        get() = get("remember-me").toBoolean()
-        set(value) = set("remember-me", value.toString())
+    val canAutoLogin: Boolean
+        get() = lastDeploymentURL.isNotBlank() && lastToken.isNotBlank()
 
     fun tokenFor(url: URL): String? = store[url.host]
 
diff --git a/src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt b/src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt
index a57ff45..f770da8 100644
--- a/src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt
+++ b/src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt
@@ -1,6 +1,7 @@
 package com.coder.toolbox.store
 
 import com.coder.toolbox.settings.Environment
+import com.coder.toolbox.settings.HttpLoggingVerbosity
 import com.coder.toolbox.settings.ReadOnlyCoderSettings
 import com.coder.toolbox.settings.ReadOnlyTLSSettings
 import com.coder.toolbox.settings.SignatureFallbackStrategy
@@ -38,8 +39,12 @@ class CoderSettingsStore(
     override val defaultURL: String get() = store[DEFAULT_URL] ?: "https://dev.coder.com"
     override val binarySource: String? get() = store[BINARY_SOURCE]
     override val binaryDirectory: String? get() = store[BINARY_DIRECTORY]
+    override val disableSignatureVerification: Boolean
+        get() = store[DISABLE_SIGNATURE_VALIDATION]?.toBooleanStrictOrNull() ?: false
     override val fallbackOnCoderForSignatures: SignatureFallbackStrategy
         get() = SignatureFallbackStrategy.fromValue(store[FALLBACK_ON_CODER_FOR_SIGNATURES])
+    override val httpClientLogLevel: HttpLoggingVerbosity
+        get() = HttpLoggingVerbosity.fromValue(store[HTTP_CLIENT_LOG_LEVEL])
     override val defaultCliBinaryNameByOsAndArch: String get() = getCoderCLIForOS(getOS(), getArch())
     override val binaryName: String get() = store[BINARY_NAME] ?: getCoderCLIForOS(getOS(), getArch())
     override val defaultSignatureNameByOsAndArch: String get() = getCoderSignatureForOS(getOS(), getArch())
@@ -142,6 +147,10 @@ class CoderSettingsStore(
                 }
     }
 
+    override fun shouldAutoConnect(workspaceId: String): Boolean {
+        return store["$SSH_AUTO_CONNECT_PREFIX$workspaceId"]?.toBooleanStrictOrNull() ?: false
+    }
+
     // a readonly cast
     fun readOnly(): ReadOnlyCoderSettings = this
 
@@ -162,6 +171,10 @@ class CoderSettingsStore(
         store[ENABLE_DOWNLOADS] = shouldEnableDownloads.toString()
     }
 
+    fun updateDisableSignatureVerification(shouldDisableSignatureVerification: Boolean) {
+        store[DISABLE_SIGNATURE_VALIDATION] = shouldDisableSignatureVerification.toString()
+    }
+
     fun updateSignatureFallbackStrategy(fallback: Boolean) {
         store[FALLBACK_ON_CODER_FOR_SIGNATURES] = when (fallback) {
             true -> SignatureFallbackStrategy.ALLOW.toString()
@@ -169,6 +182,11 @@ class CoderSettingsStore(
         }
     }
 
+    fun updateHttpClientLogLevel(level: HttpLoggingVerbosity?) {
+        if (level == null) return
+        store[HTTP_CLIENT_LOG_LEVEL] = level.toString()
+    }
+
     fun updateBinaryDirectoryFallback(shouldEnableBinDirFallback: Boolean) {
         store[ENABLE_BINARY_DIR_FALLBACK] = shouldEnableBinDirFallback.toString()
     }
@@ -213,6 +231,10 @@ class CoderSettingsStore(
         store[SSH_CONFIG_OPTIONS] = options
     }
 
+    fun updateAutoConnect(workspaceId: String, autoConnect: Boolean) {
+        store["$SSH_AUTO_CONNECT_PREFIX$workspaceId"] = autoConnect.toString()
+    }
+
     private fun getDefaultGlobalDataDir(): Path {
         return when (getOS()) {
             OS.WINDOWS -> Paths.get(env.get("LOCALAPPDATA"), "coder-toolbox")
@@ -250,42 +272,17 @@ class CoderSettingsStore(
     /**
      * Return the name of the binary (with extension) for the provided OS and architecture.
      */
-    private fun getCoderCLIForOS(
-        os: OS?,
-        arch: Arch?,
-    ): String {
+    private fun getCoderCLIForOS(os: OS?, arch: Arch?): String {
         logger.debug("Resolving binary for $os $arch")
-        return buildCoderFileName(os, arch)
-    }
-
-    /**
-     * Return the name of the signature file (.asc) for the provided OS and architecture.
-     */
-    private fun getCoderSignatureForOS(
-        os: OS?,
-        arch: Arch?,
-    ): String {
-        logger.debug("Resolving signature for $os $arch")
-        return buildCoderFileName(os, arch, true)
-    }
 
-    /**
-     * Build the coder file name based on OS, architecture, and whether it's a signature file.
-     */
-    private fun buildCoderFileName(
-        os: OS?,
-        arch: Arch?,
-        isSignature: Boolean = false
-    ): String {
-        if (os == null) {
-            logger.error("Could not resolve client OS and architecture, defaulting to WINDOWS AMD64")
-            return if (isSignature) "coder-windows-amd64.asc" else "coder-windows-amd64.exe"
-        }
-
-        val osName = when (os) {
-            OS.WINDOWS -> "windows"
-            OS.LINUX -> "linux"
-            OS.MAC -> "darwin"
+        val (osName, extension) = when (os) {
+            OS.WINDOWS -> "windows" to ".exe"
+            OS.LINUX -> "linux" to ""
+            OS.MAC -> "darwin" to ""
+            null -> {
+                logger.error("Could not resolve client OS and architecture, defaulting to WINDOWS AMD64")
+                return "coder-windows-amd64.exe"
+            }
         }
 
         val archName = when (arch) {
@@ -295,14 +292,17 @@ class CoderSettingsStore(
             else -> "amd64" // default fallback
         }
 
-        val extension = if (isSignature) ".asc" else when (os) {
-            OS.WINDOWS -> ".exe"
-            OS.LINUX, OS.MAC -> ""
-        }
-
         return "coder-$osName-$archName$extension"
     }
 
+    /**
+     * Return the name of the signature file (.asc) for the provided OS and architecture.
+     */
+    private fun getCoderSignatureForOS(os: OS?, arch: Arch?): String {
+        logger.debug("Resolving signature for $os $arch")
+        return "${getCoderCLIForOS(os, arch)}.asc"
+    }
+
     /**
      * Append the host to the path.  For example, foo/bar could become
      * foo/bar/dev.coder.com-8080.
diff --git a/src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt b/src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt
index 91e3b74..5f8f5af 100644
--- a/src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt
+++ b/src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt
@@ -10,8 +10,12 @@ internal const val BINARY_SOURCE = "binarySource"
 
 internal const val BINARY_DIRECTORY = "binaryDirectory"
 
+internal const val DISABLE_SIGNATURE_VALIDATION = "disableSignatureValidation"
+
 internal const val FALLBACK_ON_CODER_FOR_SIGNATURES = "signatureFallbackStrategy"
 
+internal const val HTTP_CLIENT_LOG_LEVEL = "httpClientLogLevel"
+
 internal const val BINARY_NAME = "binaryName"
 
 internal const val DATA_DIRECTORY = "dataDirectory"
@@ -42,3 +46,5 @@ internal const val SSH_CONFIG_OPTIONS = "sshConfigOptions"
 
 internal const val NETWORK_INFO_DIR = "networkInfoDir"
 
+internal const val SSH_AUTO_CONNECT_PREFIX = "ssh_auto_connect_"
+
diff --git a/src/main/kotlin/com/coder/toolbox/util/CoderProtocolHandler.kt b/src/main/kotlin/com/coder/toolbox/util/CoderProtocolHandler.kt
index 23b015d..a4c0b48 100644
--- a/src/main/kotlin/com/coder/toolbox/util/CoderProtocolHandler.kt
+++ b/src/main/kotlin/com/coder/toolbox/util/CoderProtocolHandler.kt
@@ -9,10 +9,19 @@ import com.coder.toolbox.sdk.CoderRestClient
 import com.coder.toolbox.sdk.v2.models.Workspace
 import com.coder.toolbox.sdk.v2.models.WorkspaceAgent
 import com.coder.toolbox.sdk.v2.models.WorkspaceStatus
+import com.coder.toolbox.util.WebUrlValidationResult.Invalid
+import com.coder.toolbox.views.CoderCliSetupWizardPage
+import com.coder.toolbox.views.CoderSettingsPage
+import com.coder.toolbox.views.state.CoderCliSetupContext
+import com.coder.toolbox.views.state.CoderCliSetupWizardState
+import com.coder.toolbox.views.state.WizardStep
+import com.jetbrains.toolbox.api.remoteDev.ProviderVisibilityState
 import com.jetbrains.toolbox.api.remoteDev.connection.RemoteToolsHelper
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.time.withTimeout
@@ -24,12 +33,13 @@ import kotlin.time.Duration.Companion.seconds
 import kotlin.time.toJavaDuration
 
 private const val CAN_T_HANDLE_URI_TITLE = "Can't handle URI"
-private val noOpTextProgress: (String) -> Unit = { _ -> }
 
 @Suppress("UnstableApiUsage")
 open class CoderProtocolHandler(
     private val context: CoderToolboxContext,
     private val dialogUi: DialogUi,
+    private val settingsPage: CoderSettingsPage,
+    private val visibilityState: MutableStateFlow<ProviderVisibilityState>,
     private val isInitialized: StateFlow<Boolean>,
 ) {
     private val settings = context.settingsStore.readOnly()
@@ -44,8 +54,6 @@ open class CoderProtocolHandler(
     suspend fun handle(
         uri: URI,
         shouldWaitForAutoLogin: Boolean,
-        markAsBusy: () -> Unit,
-        unmarkAsBusy: () -> Unit,
         reInitialize: suspend (CoderRestClient, CoderCLIManager) -> Unit
     ) {
         val params = uri.toQueryParameters()
@@ -57,22 +65,24 @@ open class CoderProtocolHandler(
         // this switches to the main plugin screen, even
         // if last opened provider was not Coder
         context.envPageManager.showPluginEnvironmentsPage()
-        markAsBusy()
         if (shouldWaitForAutoLogin) {
             isInitialized.waitForTrue()
         }
 
         context.logger.info("Handling $uri...")
         val deploymentURL = resolveDeploymentUrl(params) ?: return
-        val token = resolveToken(params) ?: return
+        val token = if (!context.settingsStore.requireTokenAuth) null else resolveToken(params) ?: return
         val workspaceName = resolveWorkspaceName(params) ?: return
-        val restClient = buildRestClient(deploymentURL, token) ?: return
-        val workspace = restClient.workspaces().matchName(workspaceName, deploymentURL) ?: return
 
-        val cli = configureCli(deploymentURL, restClient)
-
-        var agent: WorkspaceAgent
-        try {
+        suspend fun onConnect(
+            restClient: CoderRestClient,
+            cli: CoderCLIManager
+        ) {
+            val workspace = restClient.workspaces().matchName(workspaceName, deploymentURL)
+            if (workspace == null) {
+                context.envPageManager.showPluginEnvironmentsPage()
+                return
+            }
             reInitialize(restClient, cli)
             context.envPageManager.showPluginEnvironmentsPage()
             if (!prepareWorkspace(workspace, restClient, workspaceName, deploymentURL)) return
@@ -80,25 +90,36 @@ open class CoderProtocolHandler(
             // errors like: no agent available while workspace is starting or stopping
             // we also need to retrieve the workspace again to have the latest resources (ex: agent)
             // attached to the workspace.
-            agent = resolveAgent(
+            val agent: WorkspaceAgent = resolveAgent(
                 params,
                 restClient.workspace(workspace.id)
             ) ?: return
             if (!ensureAgentIsReady(workspace, agent)) return
-        } finally {
-            unmarkAsBusy()
-        }
-        delay(2.seconds)
-        val environmentId = "${workspace.name}.${agent.name}"
-        context.showEnvironmentPage(environmentId)
+            delay(2.seconds)
+            val environmentId = "${workspace.name}.${agent.name}"
+            context.showEnvironmentPage(environmentId)
 
-        val productCode = params.ideProductCode()
-        val buildNumber = params.ideBuildNumber()
-        val projectFolder = params.projectFolder()
+            val productCode = params.ideProductCode()
+            val buildNumber = params.ideBuildNumber()
+            val projectFolder = params.projectFolder()
 
-        if (!productCode.isNullOrBlank() && !buildNumber.isNullOrBlank()) {
-            launchIde(environmentId, productCode, buildNumber, projectFolder)
+            if (!productCode.isNullOrBlank() && !buildNumber.isNullOrBlank()) {
+                launchIde(environmentId, productCode, buildNumber, projectFolder)
+            }
         }
+
+        CoderCliSetupContext.apply {
+            url = deploymentURL.toURL()
+            CoderCliSetupContext.token = token
+        }
+        CoderCliSetupWizardState.goToStep(WizardStep.CONNECT)
+        context.ui.showUiPage(
+            CoderCliSetupWizardPage(
+                context, settingsPage, visibilityState, true,
+                jumpToMainPageOnError = true,
+                onConnect = ::onConnect
+            )
+        )
     }
 
     private suspend fun resolveDeploymentUrl(params: Map<String, String>): String? {
@@ -107,6 +128,11 @@ open class CoderProtocolHandler(
             context.logAndShowError(CAN_T_HANDLE_URI_TITLE, "Query parameter \"$URL\" is missing from URI")
             return null
         }
+        val validationResult = deploymentURL.validateStrictWebUrl()
+        if (validationResult is Invalid) {
+            context.logAndShowError(CAN_T_HANDLE_URI_TITLE, "\"$URL\" is invalid: ${validationResult.reason}")
+            return null
+        }
         return deploymentURL
     }
 
@@ -128,7 +154,7 @@ open class CoderProtocolHandler(
         return workspace
     }
 
-    private suspend fun buildRestClient(deploymentURL: String, token: String): CoderRestClient? {
+    private suspend fun buildRestClient(deploymentURL: String, token: String?): CoderRestClient? {
         try {
             return authenticate(deploymentURL, token)
         } catch (ex: Exception) {
@@ -140,11 +166,11 @@ open class CoderProtocolHandler(
     /**
      * Returns an authenticated Coder CLI.
      */
-    private suspend fun authenticate(deploymentURL: String, token: String): CoderRestClient {
+    private suspend fun authenticate(deploymentURL: String, token: String?): CoderRestClient {
         val client = CoderRestClient(
             context,
             deploymentURL.toURL(),
-            if (settings.requireTokenAuth) token else null,
+            token,
             PluginManager.pluginInfo.version
         )
         client.initializeSession()
@@ -302,13 +328,14 @@ open class CoderProtocolHandler(
 
     private suspend fun configureCli(
         deploymentURL: String,
-        restClient: CoderRestClient
+        restClient: CoderRestClient,
+        progressReporter: (String) -> Unit
     ): CoderCLIManager {
         val cli = ensureCLI(
             context,
             deploymentURL.toURL(),
             restClient.buildInfo().version,
-            noOpTextProgress
+            progressReporter
         )
 
         // We only need to log in if we are using token-based auth.
@@ -328,7 +355,7 @@ open class CoderProtocolHandler(
         buildNumber: String,
         projectFolder: String?
     ) {
-        context.cs.launch {
+        context.cs.launch(CoroutineName("Launch Remote IDE")) {
             val selectedIde = selectAndInstallRemoteIde(productCode, buildNumber, environmentId) ?: return@launch
             context.logger.info("$productCode-$buildNumber is already on $environmentId. Going to launch JBClient")
             installJBClient(selectedIde, environmentId).join()
@@ -396,10 +423,11 @@ open class CoderProtocolHandler(
         return "$productCode-$buildNumber"
     }
 
-    private fun installJBClient(selectedIde: String, environmentId: String): Job = context.cs.launch {
-        context.logger.info("Downloading and installing JBClient counterpart to $selectedIde locally")
-        context.jbClientOrchestrator.prepareClient(environmentId, selectedIde)
-    }
+    private fun installJBClient(selectedIde: String, environmentId: String): Job =
+        context.cs.launch(CoroutineName("JBClient Installer")) {
+            context.logger.info("Downloading and installing JBClient counterpart to $selectedIde locally")
+            context.jbClientOrchestrator.prepareClient(environmentId, selectedIde)
+        }
 
     private fun launchJBClient(selectedIde: String, environmentId: String, projectFolder: String?) {
         context.logger.info("Launching $selectedIde on $environmentId")
@@ -449,12 +477,6 @@ open class CoderProtocolHandler(
     }
 }
 
-
-private fun CoderToolboxContext.popupPluginMainPage() {
-    this.ui.showWindow()
-    this.envPageManager.showPluginEnvironmentsPage(true)
-}
-
 private suspend fun CoderToolboxContext.showEnvironmentPage(envId: String) {
     this.ui.showWindow()
     this.envPageManager.showEnvironmentPage(envId, false)
diff --git a/src/main/kotlin/com/coder/toolbox/util/URLExtensions.kt b/src/main/kotlin/com/coder/toolbox/util/URLExtensions.kt
index c1aaa81..7e2a8e3 100644
--- a/src/main/kotlin/com/coder/toolbox/util/URLExtensions.kt
+++ b/src/main/kotlin/com/coder/toolbox/util/URLExtensions.kt
@@ -1,11 +1,44 @@
 package com.coder.toolbox.util
 
+import com.coder.toolbox.util.WebUrlValidationResult.Invalid
+import com.coder.toolbox.util.WebUrlValidationResult.Valid
 import java.net.IDN
 import java.net.URI
 import java.net.URL
 
 fun String.toURL(): URL = URI.create(this).toURL()
 
+fun String.validateStrictWebUrl(): WebUrlValidationResult = try {
+    val uri = URI(this)
+
+    when {
+        uri.isOpaque -> Invalid(
+            "The URL \"$this\" is invalid because it is not in the standard format. " +
+                    "Please enter a full web address like \"https://example.com\""
+        )
+
+        !uri.isAbsolute -> Invalid(
+            "The URL \"$this\" is missing a scheme (like https://). " +
+                    "Please enter a full web address like \"https://example.com\""
+        )
+        uri.scheme?.lowercase() !in setOf("http", "https") ->
+            Invalid(
+                "The URL \"$this\" must start with http:// or https://, not \"${uri.scheme}\""
+            )
+        uri.authority.isNullOrBlank() ->
+            Invalid(
+                "The URL \"$this\" does not include a valid website name. " +
+                        "Please enter a full web address like \"https://example.com\""
+            )
+        else -> Valid
+    }
+} catch (_: Exception) {
+    Invalid(
+        "The input \"$this\" is not a valid web address. " +
+                "Please enter a full web address like \"https://example.com\""
+    )
+}
+
 fun URL.withPath(path: String): URL = URL(
     this.protocol,
     this.host,
@@ -30,3 +63,8 @@ fun URI.toQueryParameters(): Map<String, String> = (this.query ?: "")
             parts[0] to ""
         }
     }
+
+sealed class WebUrlValidationResult {
+    object Valid : WebUrlValidationResult()
+    data class Invalid(val reason: String) : WebUrlValidationResult()
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/views/CoderCliSetupWizardPage.kt b/src/main/kotlin/com/coder/toolbox/views/CoderCliSetupWizardPage.kt
index 5115204..7ff36bc 100644
--- a/src/main/kotlin/com/coder/toolbox/views/CoderCliSetupWizardPage.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/CoderCliSetupWizardPage.kt
@@ -4,13 +4,12 @@ import com.coder.toolbox.CoderToolboxContext
 import com.coder.toolbox.cli.CoderCLIManager
 import com.coder.toolbox.sdk.CoderRestClient
 import com.coder.toolbox.sdk.ex.APIResponseException
-import com.coder.toolbox.util.toURL
-import com.coder.toolbox.views.state.CoderCliSetupContext
 import com.coder.toolbox.views.state.CoderCliSetupWizardState
 import com.coder.toolbox.views.state.WizardStep
 import com.jetbrains.toolbox.api.remoteDev.ProviderVisibilityState
 import com.jetbrains.toolbox.api.ui.actions.RunnableActionDescription
 import com.jetbrains.toolbox.api.ui.components.UiField
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
@@ -21,6 +20,7 @@ class CoderCliSetupWizardPage(
     private val settingsPage: CoderSettingsPage,
     private val visibilityState: MutableStateFlow<ProviderVisibilityState>,
     initialAutoSetup: Boolean = false,
+    jumpToMainPageOnError: Boolean = false,
     onConnect: suspend (
         client: CoderRestClient,
         cli: CoderCLIManager,
@@ -35,7 +35,8 @@ class CoderCliSetupWizardPage(
     private val tokenStep = TokenStep(context)
     private val connectStep = ConnectStep(
         context,
-        shouldAutoSetup,
+        shouldAutoLogin = shouldAutoSetup,
+        jumpToMainPageOnError,
         this::notify,
         this::displaySteps,
         onConnect
@@ -49,13 +50,6 @@ class CoderCliSetupWizardPage(
 
     private val errorBuffer = mutableListOf<Throwable>()
 
-    init {
-        if (shouldAutoSetup.value) {
-            CoderCliSetupContext.url = context.secrets.lastDeploymentURL.toURL()
-            CoderCliSetupContext.token = context.secrets.lastToken
-        }
-    }
-
     override fun beforeShow() {
         displaySteps()
         if (errorBuffer.isNotEmpty() && visibilityState.value.applicationVisible) {
@@ -147,7 +141,7 @@ class CoderCliSetupWizardPage(
             } else ex.message
         } else ex.message
 
-        context.cs.launch {
+        context.cs.launch(CoroutineName("Coder Setup Visual Error Reporting")) {
             context.ui.showSnackbar(
                 UUID.randomUUID().toString(),
                 context.i18n.ptrl("Error encountered while setting up Coder"),
diff --git a/src/main/kotlin/com/coder/toolbox/views/CoderPage.kt b/src/main/kotlin/com/coder/toolbox/views/CoderPage.kt
index 363d618..eec0765 100644
--- a/src/main/kotlin/com/coder/toolbox/views/CoderPage.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/CoderPage.kt
@@ -1,6 +1,5 @@
 package com.coder.toolbox.views
 
-import com.coder.toolbox.CoderToolboxContext
 import com.jetbrains.toolbox.api.core.ui.icons.SvgIcon
 import com.jetbrains.toolbox.api.core.ui.icons.SvgIcon.IconType
 import com.jetbrains.toolbox.api.localization.LocalizableString
@@ -43,12 +42,6 @@ abstract class CoderPage(
     } else {
         SvgIcon(byteArrayOf(), type = IconType.Masked)
     }
-
-    override val isBusyCreatingNewEnvironment: MutableStateFlow<Boolean> = MutableStateFlow(false)
-
-    companion object {
-        fun emptyPage(ctx: CoderToolboxContext): UiPage = UiPage(ctx.i18n.pnotr(""))
-    }
 }
 
 /**
diff --git a/src/main/kotlin/com/coder/toolbox/views/CoderSettingsPage.kt b/src/main/kotlin/com/coder/toolbox/views/CoderSettingsPage.kt
index 448a20f..3444683 100644
--- a/src/main/kotlin/com/coder/toolbox/views/CoderSettingsPage.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/CoderSettingsPage.kt
@@ -1,11 +1,19 @@
 package com.coder.toolbox.views
 
 import com.coder.toolbox.CoderToolboxContext
+import com.coder.toolbox.settings.HttpLoggingVerbosity.BASIC
+import com.coder.toolbox.settings.HttpLoggingVerbosity.BODY
+import com.coder.toolbox.settings.HttpLoggingVerbosity.HEADERS
+import com.coder.toolbox.settings.HttpLoggingVerbosity.NONE
 import com.jetbrains.toolbox.api.ui.actions.RunnableActionDescription
 import com.jetbrains.toolbox.api.ui.components.CheckboxField
+import com.jetbrains.toolbox.api.ui.components.ComboBoxField
+import com.jetbrains.toolbox.api.ui.components.ComboBoxField.LabelledValue
 import com.jetbrains.toolbox.api.ui.components.TextField
 import com.jetbrains.toolbox.api.ui.components.TextType
 import com.jetbrains.toolbox.api.ui.components.UiField
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ClosedSendChannelException
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -20,7 +28,7 @@ import kotlinx.coroutines.launch
  * TODO@JB: There is no scroll, and our settings do not fit.  As a consequence,
  *          I have not been able to test this page.
  */
-class CoderSettingsPage(context: CoderToolboxContext, triggerSshConfig: Channel<Boolean>) :
+class CoderSettingsPage(private val context: CoderToolboxContext, triggerSshConfig: Channel<Boolean>) :
     CoderPage(MutableStateFlow(context.i18n.ptrl("Coder Settings")), false) {
     private val settings = context.settingsStore.readOnly()
 
@@ -33,11 +41,28 @@ class CoderSettingsPage(context: CoderToolboxContext, triggerSshConfig: Channel<
         TextField(context.i18n.ptrl("Data directory"), settings.dataDirectory ?: "", TextType.General)
     private val enableDownloadsField =
         CheckboxField(settings.enableDownloads, context.i18n.ptrl("Enable downloads"))
+
+    private val disableSignatureVerificationField = CheckboxField(
+        settings.disableSignatureVerification,
+        context.i18n.ptrl("Disable Coder CLI signature verification")
+    )
     private val signatureFallbackStrategyField =
         CheckboxField(
             settings.fallbackOnCoderForSignatures.isAllowed(),
             context.i18n.ptrl("Verify binary signature using releases.coder.com when CLI signatures are not available from the deployment")
         )
+
+    private val httpLoggingField = ComboBoxField(
+        ComboBoxField.Label(context.i18n.ptrl("HTTP logging level:")),
+        settings.httpClientLogLevel,
+        listOf(
+            LabelledValue(context.i18n.ptrl("None"), NONE, listOf("" to "No logs")),
+            LabelledValue(context.i18n.ptrl("Basic"), BASIC, listOf("" to "Method, URL and status")),
+            LabelledValue(context.i18n.ptrl("Header"), HEADERS, listOf("" to " Basic + sanitized headers")),
+            LabelledValue(context.i18n.ptrl("Body"), BODY, listOf("" to "Headers + body content")),
+        )
+    )
+
     private val enableBinaryDirectoryFallbackField =
         CheckboxField(
             settings.enableBinaryDirectoryFallback,
@@ -65,14 +90,16 @@ class CoderSettingsPage(context: CoderToolboxContext, triggerSshConfig: Channel<
     private val networkInfoDirField =
         TextField(context.i18n.ptrl("SSH network metrics directory"), settings.networkInfoDir, TextType.General)
 
-
+    private lateinit var visibilityUpdateJob: Job
     override val fields: StateFlow<List<UiField>> = MutableStateFlow(
         listOf(
             binarySourceField,
             enableDownloadsField,
             binaryDirectoryField,
             enableBinaryDirectoryFallbackField,
+            disableSignatureVerificationField,
             signatureFallbackStrategyField,
+            httpLoggingField,
             dataDirectoryField,
             headerCommandField,
             tlsCertPathField,
@@ -94,7 +121,9 @@ class CoderSettingsPage(context: CoderToolboxContext, triggerSshConfig: Channel<
                 context.settingsStore.updateBinaryDirectory(binaryDirectoryField.contentState.value)
                 context.settingsStore.updateDataDirectory(dataDirectoryField.contentState.value)
                 context.settingsStore.updateEnableDownloads(enableDownloadsField.checkedState.value)
+                context.settingsStore.updateDisableSignatureVerification(disableSignatureVerificationField.checkedState.value)
                 context.settingsStore.updateSignatureFallbackStrategy(signatureFallbackStrategyField.checkedState.value)
+                context.settingsStore.updateHttpClientLogLevel(httpLoggingField.selectedValueState.value)
                 context.settingsStore.updateBinaryDirectoryFallback(enableBinaryDirectoryFallbackField.checkedState.value)
                 context.settingsStore.updateHeaderCommand(headerCommandField.contentState.value)
                 context.settingsStore.updateCertPath(tlsCertPathField.contentState.value)
@@ -106,7 +135,7 @@ class CoderSettingsPage(context: CoderToolboxContext, triggerSshConfig: Channel<
                 context.settingsStore.updateEnableSshWildcardConfig(enableSshWildCardConfig.checkedState.value)
 
                 if (enableSshWildCardConfig.checkedState.value != oldIsSshWildcardConfigEnabled) {
-                    context.cs.launch {
+                    context.cs.launch(CoroutineName("SSH Wildcard Setting")) {
                         try {
                             triggerSshConfig.send(true)
                             context.logger.info("Wildcard settings have been modified from $oldIsSshWildcardConfigEnabled to ${!oldIsSshWildcardConfigEnabled}, ssh config is going to be regenerated...")
@@ -182,5 +211,19 @@ class CoderSettingsPage(context: CoderToolboxContext, triggerSshConfig: Channel<
         networkInfoDirField.contentState.update {
             settings.networkInfoDir
         }
+
+        visibilityUpdateJob = context.cs.launch(CoroutineName("Signature Verification Fallback Setting")) {
+            disableSignatureVerificationField.checkedState.collect { state ->
+                signatureFallbackStrategyField.visibility.update {
+                    // the fallback checkbox should not be visible
+                    // if signature verification is disabled
+                    !state
+                }
+            }
+        }
+    }
+
+    override fun afterHide() {
+        visibilityUpdateJob.cancel()
     }
 }
diff --git a/src/main/kotlin/com/coder/toolbox/views/ConnectStep.kt b/src/main/kotlin/com/coder/toolbox/views/ConnectStep.kt
index 9964d0c..f005b53 100644
--- a/src/main/kotlin/com/coder/toolbox/views/ConnectStep.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/ConnectStep.kt
@@ -10,12 +10,13 @@ import com.coder.toolbox.views.state.CoderCliSetupWizardState
 import com.jetbrains.toolbox.api.ui.components.LabelField
 import com.jetbrains.toolbox.api.ui.components.RowGroup
 import com.jetbrains.toolbox.api.ui.components.ValidationErrorField
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.yield
-import java.util.concurrent.CancellationException
 
 private const val USER_HIT_THE_BACK_BUTTON = "User hit the back button"
 
@@ -25,6 +26,7 @@ private const val USER_HIT_THE_BACK_BUTTON = "User hit the back button"
 class ConnectStep(
     private val context: CoderToolboxContext,
     private val shouldAutoLogin: StateFlow<Boolean>,
+    private val jumpToMainPageOnError: Boolean,
     private val notify: (String, Throwable) -> Unit,
     private val refreshWizard: () -> Unit,
     private val onConnect: suspend (
@@ -47,7 +49,7 @@ class ConnectStep(
             context.i18n.pnotr("")
         }
 
-        if (CoderCliSetupContext.isNotReadyForAuth()) {
+        if (context.settingsStore.requireTokenAuth && CoderCliSetupContext.isNotReadyForAuth()) {
             errorField.textState.update {
                 context.i18n.pnotr("URL and token were not properly configured. Please go back and provide a proper URL and token!")
             }
@@ -67,23 +69,24 @@ class ConnectStep(
             return
         }
 
-        if (!CoderCliSetupContext.hasToken()) {
+        if (context.settingsStore.requireTokenAuth && !CoderCliSetupContext.hasToken()) {
             errorField.textState.update { context.i18n.ptrl("Token is required") }
             return
         }
         signInJob?.cancel()
-        signInJob = context.cs.launch {
+        signInJob = context.cs.launch(CoroutineName("Http and CLI Setup")) {
             try {
+                context.logger.info("Setting up the HTTP client...")
                 val client = CoderRestClient(
                     context,
                     CoderCliSetupContext.url!!,
-                    CoderCliSetupContext.token!!,
+                    if (context.settingsStore.requireTokenAuth) CoderCliSetupContext.token else null,
                     PluginManager.pluginInfo.version,
                 )
                 // allows interleaving with the back/cancel action
                 yield()
                 client.initializeSession()
-                statusField.textState.update { (context.i18n.ptrl("Checking Coder CLI...")) }
+                logAndReportProgress("Checking Coder CLI...")
                 val cli = ensureCLI(
                     context, client.url,
                     client.buildVersion
@@ -91,47 +94,68 @@ class ConnectStep(
                     statusField.textState.update { (context.i18n.pnotr(progress)) }
                 }
                 // We only need to log in if we are using token-based auth.
-                if (client.token != null) {
-                    statusField.textState.update { (context.i18n.ptrl("Configuring Coder CLI...")) }
+                if (context.settingsStore.requireTokenAuth) {
+                    logAndReportProgress("Configuring Coder CLI...")
                     // allows interleaving with the back/cancel action
                     yield()
-                    cli.login(client.token)
+                    cli.login(client.token!!)
                 }
-                statusField.textState.update { (context.i18n.ptrl("Successfully configured ${CoderCliSetupContext.url!!.host}...")) }
+                logAndReportProgress("Successfully configured ${CoderCliSetupContext.url!!.host}...")
                 // allows interleaving with the back/cancel action
                 yield()
                 CoderCliSetupContext.reset()
-                CoderCliSetupWizardState.resetSteps()
+                CoderCliSetupWizardState.goToFirstStep()
+                context.logger.info("Connection setup done, initializing the workspace poller...")
                 onConnect(client, cli)
             } catch (ex: CancellationException) {
                 if (ex.message != USER_HIT_THE_BACK_BUTTON) {
                     notify("Connection to ${CoderCliSetupContext.url!!.host} was configured", ex)
-                    onBack()
+                    handleNavigation()
                     refreshWizard()
                 }
             } catch (ex: Exception) {
                 notify("Failed to configure ${CoderCliSetupContext.url!!.host}", ex)
-                onBack()
+                handleNavigation()
                 refreshWizard()
             }
         }
     }
 
+    private fun logAndReportProgress(msg: String) {
+        context.logger.info(msg)
+        statusField.textState.update { context.i18n.pnotr(msg) }
+    }
+
+    /**
+     * Handle navigation logic for both errors and back button
+     */
+    private fun handleNavigation() {
+        if (shouldAutoLogin.value) {
+            CoderCliSetupContext.reset()
+            if (jumpToMainPageOnError) {
+                context.popupPluginMainPage()
+            } else {
+                CoderCliSetupWizardState.goToFirstStep()
+            }
+        } else {
+            if (context.settingsStore.requireTokenAuth) {
+                CoderCliSetupWizardState.goToPreviousStep()
+            } else {
+                CoderCliSetupWizardState.goToFirstStep()
+            }
+        }
+    }
+
     override fun onNext(): Boolean {
         return false
     }
 
     override fun onBack() {
         try {
+            context.logger.info("Back button was pressed, cancelling in-progress connection setup...")
             signInJob?.cancel(CancellationException(USER_HIT_THE_BACK_BUTTON))
         } finally {
-            if (shouldAutoLogin.value) {
-                CoderCliSetupContext.reset()
-                CoderCliSetupWizardState.resetSteps()
-                context.secrets.rememberMe = false
-            } else {
-                CoderCliSetupWizardState.goToPreviousStep()
-            }
+            handleNavigation()
         }
     }
 }
diff --git a/src/main/kotlin/com/coder/toolbox/views/DeploymentUrlStep.kt b/src/main/kotlin/com/coder/toolbox/views/DeploymentUrlStep.kt
index 2a76864..34b027c 100644
--- a/src/main/kotlin/com/coder/toolbox/views/DeploymentUrlStep.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/DeploymentUrlStep.kt
@@ -1,8 +1,9 @@
 package com.coder.toolbox.views
 
 import com.coder.toolbox.CoderToolboxContext
-import com.coder.toolbox.settings.SignatureFallbackStrategy
+import com.coder.toolbox.util.WebUrlValidationResult.Invalid
 import com.coder.toolbox.util.toURL
+import com.coder.toolbox.util.validateStrictWebUrl
 import com.coder.toolbox.views.state.CoderCliSetupContext
 import com.coder.toolbox.views.state.CoderCliSetupWizardState
 import com.jetbrains.toolbox.api.ui.components.CheckboxField
@@ -39,7 +40,7 @@ class DeploymentUrlStep(
 
     override val panel: RowGroup
         get() {
-            if (context.settingsStore.fallbackOnCoderForSignatures == SignatureFallbackStrategy.NOT_CONFIGURED) {
+            if (!context.settingsStore.disableSignatureVerification) {
                 return RowGroup(
                     RowGroup.RowField(urlField),
                     RowGroup.RowField(emptyLine),
@@ -69,23 +70,22 @@ class DeploymentUrlStep(
 
     override fun onNext(): Boolean {
         context.settingsStore.updateSignatureFallbackStrategy(signatureFallbackStrategyField.checkedState.value)
-        var url = urlField.textState.value
+        val url = urlField.textState.value
         if (url.isBlank()) {
             errorField.textState.update { context.i18n.ptrl("URL is required") }
             return false
         }
-        url = if (!url.startsWith("http://") && !url.startsWith("https://")) {
-            "https://$url"
-        } else {
-            url
-        }
         try {
             CoderCliSetupContext.url = validateRawUrl(url)
         } catch (e: MalformedURLException) {
             notify("URL is invalid", e)
             return false
         }
-        CoderCliSetupWizardState.goToNextStep()
+        if (context.settingsStore.requireTokenAuth) {
+            CoderCliSetupWizardState.goToNextStep()
+        } else {
+            CoderCliSetupWizardState.goToLastStep()
+        }
         return true
     }
 
@@ -94,6 +94,10 @@ class DeploymentUrlStep(
      */
     private fun validateRawUrl(url: String): URL {
         try {
+            val result = url.validateStrictWebUrl()
+            if (result is Invalid) {
+                throw MalformedURLException(result.reason)
+            }
             return url.toURL()
         } catch (e: Exception) {
             throw MalformedURLException(e.message)
diff --git a/src/main/kotlin/com/coder/toolbox/views/EnvironmentView.kt b/src/main/kotlin/com/coder/toolbox/views/EnvironmentView.kt
index 020ed8a..3353fe4 100644
--- a/src/main/kotlin/com/coder/toolbox/views/EnvironmentView.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/EnvironmentView.kt
@@ -21,20 +21,51 @@ class EnvironmentView(
     private val workspace: Workspace,
     private val agent: WorkspaceAgent,
 ) : SshEnvironmentContentsView {
-    override suspend fun getConnectionInfo(): SshConnectionInfo = object : SshConnectionInfo {
-        /**
-         * The host name generated by the cli manager for this workspace.
-         */
-        override val host: String = cli.getHostname(url, workspace, agent)
-
-        /**
-         * The port is ignored by the Coder proxy command.
-         */
-        override val port: Int = 22
-
-        /**
-         * The username is ignored by the Coder proxy command.
-         */
-        override val userName: String? = null
+    override suspend fun getConnectionInfo(): SshConnectionInfo = WorkspaceSshConnectionInfo(url, cli, workspace, agent)
+}
+
+private class WorkspaceSshConnectionInfo(
+    url: URL,
+    cli: CoderCLIManager,
+    private val workspace: Workspace,
+    private val agent: WorkspaceAgent,
+) : SshConnectionInfo {
+    /**
+     * The host name generated by the cli manager for this workspace.
+     */
+    override val host: String = cli.getHostname(url, workspace, agent)
+
+    /**
+     * The port is ignored by the Coder proxy command.
+     */
+    override val port: Int = 22
+
+    /**
+     * The username is ignored by the Coder proxy command.
+     */
+    override val userName: String? = null
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as WorkspaceSshConnectionInfo
+
+        if (port != other.port) return false
+        if (workspace.name != other.workspace.name) return false
+        if (agent.name != other.agent.name) return false
+        if (host != other.host) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = port
+        result = 31 * result + workspace.name.hashCode()
+        result = 31 * result + agent.name.hashCode()
+        result = 31 * result + host.hashCode()
+        return result
     }
+
+
 }
\ No newline at end of file
diff --git a/src/main/kotlin/com/coder/toolbox/views/state/CoderCliSetupWizardState.kt b/src/main/kotlin/com/coder/toolbox/views/state/CoderCliSetupWizardState.kt
index f1efca4..92a0845 100644
--- a/src/main/kotlin/com/coder/toolbox/views/state/CoderCliSetupWizardState.kt
+++ b/src/main/kotlin/com/coder/toolbox/views/state/CoderCliSetupWizardState.kt
@@ -25,7 +25,11 @@ object CoderCliSetupWizardState {
         currentStep = WizardStep.entries.toTypedArray()[(currentStep.ordinal - 1) % WizardStep.entries.size]
     }
 
-    fun resetSteps() {
+    fun goToLastStep() {
+        currentStep = WizardStep.CONNECT
+    }
+
+    fun goToFirstStep() {
         currentStep = WizardStep.URL_REQUEST
     }
 }
diff --git a/src/main/resources/localization/defaultMessages.po b/src/main/resources/localization/defaultMessages.po
index f176105..8aabe3f 100644
--- a/src/main/resources/localization/defaultMessages.po
+++ b/src/main/resources/localization/defaultMessages.po
@@ -164,4 +164,19 @@ msgid "Abort"
 msgstr ""
 
 msgid "Run anyway"
+msgstr ""
+
+msgid "Disable Coder CLI signature verification"
+msgstr ""
+
+msgid "None"
+msgstr ""
+
+msgid "Basic"
+msgstr ""
+
+msgid "Headers"
+msgstr ""
+
+msgid "Body"
 msgstr ""
\ No newline at end of file
diff --git a/src/test/kotlin/com/coder/toolbox/cli/CoderCLIManagerTest.kt b/src/test/kotlin/com/coder/toolbox/cli/CoderCLIManagerTest.kt
index 4ef1235..7f5c831 100644
--- a/src/test/kotlin/com/coder/toolbox/cli/CoderCLIManagerTest.kt
+++ b/src/test/kotlin/com/coder/toolbox/cli/CoderCLIManagerTest.kt
@@ -35,6 +35,7 @@ import com.jetbrains.toolbox.api.core.diagnostics.Logger
 import com.jetbrains.toolbox.api.core.os.LocalDesktopManager
 import com.jetbrains.toolbox.api.localization.LocalizableStringFactory
 import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper
+import com.jetbrains.toolbox.api.remoteDev.connection.ProxyAuth
 import com.jetbrains.toolbox.api.remoteDev.connection.RemoteToolsHelper
 import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings
 import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateColorPalette
@@ -52,6 +53,8 @@ import org.zeroturnaround.exec.InvalidExitValueException
 import org.zeroturnaround.exec.ProcessInitException
 import java.net.HttpURLConnection
 import java.net.InetSocketAddress
+import java.net.Proxy
+import java.net.ProxySelector
 import java.net.URI
 import java.net.URL
 import java.nio.file.AccessDeniedException
@@ -87,8 +90,17 @@ internal class CoderCLIManagerTest {
             mockk<Logger>(relaxed = true)
         ),
         mockk<CoderSecretsStore>(),
-        mockk<ToolboxProxySettings>()
-    )
+        object : ToolboxProxySettings {
+            override fun getProxy(): Proxy? = null
+            override fun getProxySelector(): ProxySelector? = null
+            override fun getProxyAuth(): ProxyAuth? = null
+
+            override fun addProxyChangeListener(listener: Runnable) {
+            }
+
+            override fun removeProxyChangeListener(listener: Runnable) {
+            }
+        })
 
     @BeforeTest
     fun setup() {
@@ -137,6 +149,7 @@ internal class CoderCLIManagerTest {
             }
 
             val body = response.toByteArray()
+            exchange.responseHeaders["Content-Type"] = "application/octet-stream"
             exchange.sendResponseHeaders(code, if (code == HttpURLConnection.HTTP_OK) body.size.toLong() else -1)
             exchange.responseBody.write(body)
             exchange.close()
@@ -197,11 +210,11 @@ internal class CoderCLIManagerTest {
         val ccm = CoderCLIManager(
             context.copy(
                 settingsStore = CoderSettingsStore(
-                pluginTestSettingsStore(
-                    DATA_DIRECTORY to tmpdir.resolve("cli-dir-fail-to-write").toString(),
-                ),
-                Environment(),
-                context.logger
+                    pluginTestSettingsStore(
+                        DATA_DIRECTORY to tmpdir.resolve("cli-dir-fail-to-write").toString(),
+                    ),
+                    Environment(),
+                    context.logger
                 )
             ),
             url
@@ -307,11 +320,11 @@ internal class CoderCLIManagerTest {
         val ccm = CoderCLIManager(
             context.copy(
                 settingsStore = CoderSettingsStore(
-                pluginTestSettingsStore(
-                    DATA_DIRECTORY to tmpdir.resolve("does-not-exist").toString(),
-                ),
-                Environment(),
-                context.logger
+                    pluginTestSettingsStore(
+                        DATA_DIRECTORY to tmpdir.resolve("does-not-exist").toString(),
+                    ),
+                    Environment(),
+                    context.logger
                 )
             ),
             URL("https://foo")
@@ -329,12 +342,12 @@ internal class CoderCLIManagerTest {
         val ccm = CoderCLIManager(
             context.copy(
                 settingsStore = CoderSettingsStore(
-                pluginTestSettingsStore(
-                    FALLBACK_ON_CODER_FOR_SIGNATURES to "allow",
-                    DATA_DIRECTORY to tmpdir.resolve("overwrite-cli").toString(),
-                ),
-                Environment(),
-                context.logger
+                    pluginTestSettingsStore(
+                        FALLBACK_ON_CODER_FOR_SIGNATURES to "allow",
+                        DATA_DIRECTORY to tmpdir.resolve("overwrite-cli").toString(),
+                    ),
+                    Environment(),
+                    context.logger
                 )
             ),
             url
@@ -546,11 +559,10 @@ internal class CoderCLIManagerTest {
                     context.logger,
                 )
 
-            val ccm =
-                CoderCLIManager(
-                    context.copy(settingsStore = settings),
-                    it.url ?: URI.create("https://test.coder.invalid").toURL()
-                )
+            val ccm = CoderCLIManager(
+                context.copy(settingsStore = settings),
+                it.url ?: URI.create("https://test.coder.invalid").toURL()
+            )
 
             val sshConfigPath = Path.of(settings.sshConfigPath)
             // Input is the configuration that we start with, if any.
diff --git a/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt b/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt
index c42ead2..49314c5 100644
--- a/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt
+++ b/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt
@@ -225,7 +225,7 @@ class CoderRestClientTest {
         val client = CoderRestClient(context, URL(url), "token")
         assertEquals(user.username, runBlocking { client.me() }.username)
 
-        val tests = listOf("invalid", null)
+        val tests = listOf("invalid")
         tests.forEach { token ->
             val ex =
                 assertFailsWith(
@@ -238,6 +238,26 @@ class CoderRestClientTest {
         srv.stop(0)
     }
 
+    @Test
+    fun `exception is raised when token is required for authentication and token value is null or empty`() {
+        listOf("", null).forEach { token ->
+            val ex =
+                assertFailsWith(
+                    exceptionClass = IllegalStateException::class,
+                    block = {
+                        runBlocking {
+                            CoderRestClient(
+                                context,
+                                URI.create("https://coder.com").toURL(),
+                                token
+                            ).me()
+                        }
+                    },
+                )
+            assertEquals(ex.message, "Token is required for https://coder.com deployment")
+        }
+    }
+
     @Test
     fun testGetsWorkspaces() {
         val tests =
diff --git a/src/test/kotlin/com/coder/toolbox/store/CoderSettingsStoreTest.kt b/src/test/kotlin/com/coder/toolbox/store/CoderSettingsStoreTest.kt
index 5798524..636ef61 100644
--- a/src/test/kotlin/com/coder/toolbox/store/CoderSettingsStoreTest.kt
+++ b/src/test/kotlin/com/coder/toolbox/store/CoderSettingsStoreTest.kt
@@ -35,15 +35,11 @@ class CoderSettingsStoreTest {
 
     @Test
     fun `Default CLI and signature for Windows AMD64`() =
-        assertBinaryAndSignature("Windows 10", "amd64", "coder-windows-amd64.exe", "coder-windows-amd64.asc")
+        assertBinaryAndSignature("Windows 10", "amd64", "coder-windows-amd64.exe", "coder-windows-amd64.exe.asc")
 
     @Test
     fun `Default CLI and signature for Windows ARM64`() =
-        assertBinaryAndSignature("Windows 10", "aarch64", "coder-windows-arm64.exe", "coder-windows-arm64.asc")
-
-    @Test
-    fun `Default CLI and signature for Windows ARMV7`() =
-        assertBinaryAndSignature("Windows 10", "armv7l", "coder-windows-armv7.exe", "coder-windows-armv7.asc")
+        assertBinaryAndSignature("Windows 10", "aarch64", "coder-windows-arm64.exe", "coder-windows-arm64.exe.asc")
 
     @Test
     fun `Default CLI and signature for Linux AMD64`() =
@@ -65,13 +61,9 @@ class CoderSettingsStoreTest {
     fun `Default CLI and signature for Mac ARM64`() =
         assertBinaryAndSignature("Mac OS X", "aarch64", "coder-darwin-arm64", "coder-darwin-arm64.asc")
 
-    @Test
-    fun `Default CLI and signature for Mac ARMV7`() =
-        assertBinaryAndSignature("Mac OS X", "armv7l", "coder-darwin-armv7", "coder-darwin-armv7.asc")
-
     @Test
     fun `Default CLI and signature for unknown OS and Arch`() =
-        assertBinaryAndSignature(null, null, "coder-windows-amd64.exe", "coder-windows-amd64.asc")
+        assertBinaryAndSignature(null, null, "coder-windows-amd64.exe", "coder-windows-amd64.exe.asc")
 
     @Test
     fun `Default CLI and signature for unknown Arch fallback on Linux`() =
diff --git a/src/test/kotlin/com/coder/toolbox/util/CoderProtocolHandlerTest.kt b/src/test/kotlin/com/coder/toolbox/util/CoderProtocolHandlerTest.kt
index b26acde..56402e5 100644
--- a/src/test/kotlin/com/coder/toolbox/util/CoderProtocolHandlerTest.kt
+++ b/src/test/kotlin/com/coder/toolbox/util/CoderProtocolHandlerTest.kt
@@ -5,9 +5,11 @@ import com.coder.toolbox.sdk.DataGen
 import com.coder.toolbox.settings.Environment
 import com.coder.toolbox.store.CoderSecretsStore
 import com.coder.toolbox.store.CoderSettingsStore
+import com.coder.toolbox.views.CoderSettingsPage
 import com.jetbrains.toolbox.api.core.diagnostics.Logger
 import com.jetbrains.toolbox.api.core.os.LocalDesktopManager
 import com.jetbrains.toolbox.api.localization.LocalizableStringFactory
+import com.jetbrains.toolbox.api.remoteDev.ProviderVisibilityState
 import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper
 import com.jetbrains.toolbox.api.remoteDev.connection.RemoteToolsHelper
 import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings
@@ -16,6 +18,7 @@ import com.jetbrains.toolbox.api.remoteDev.ui.EnvironmentUiPageManager
 import com.jetbrains.toolbox.api.ui.ToolboxUi
 import io.mockk.mockk
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.DisplayName
@@ -43,6 +46,8 @@ internal class CoderProtocolHandlerTest {
     private val protocolHandler = CoderProtocolHandler(
         context,
         DialogUi(context),
+        CoderSettingsPage(context, Channel(Channel.CONFLATED)),
+        MutableStateFlow(ProviderVisibilityState(applicationVisible = true, providerVisible = true)),
         MutableStateFlow(false)
     )
 
diff --git a/src/test/kotlin/com/coder/toolbox/util/URLExtensionsTest.kt b/src/test/kotlin/com/coder/toolbox/util/URLExtensionsTest.kt
index 1db26c7..af1b4ef 100644
--- a/src/test/kotlin/com/coder/toolbox/util/URLExtensionsTest.kt
+++ b/src/test/kotlin/com/coder/toolbox/util/URLExtensionsTest.kt
@@ -60,4 +60,96 @@ internal class URLExtensionsTest {
             )
         }
     }
+
+    @Test
+    fun `valid http URL should return Valid`() {
+        val result = "http://coder.com".validateStrictWebUrl()
+        assertEquals(WebUrlValidationResult.Valid, result)
+    }
+
+    @Test
+    fun `valid https URL with path and query should return Valid`() {
+        val result = "https://coder.com/bin/coder-linux-amd64?query=1".validateStrictWebUrl()
+        assertEquals(WebUrlValidationResult.Valid, result)
+    }
+
+    @Test
+    fun `relative URL should return Invalid with appropriate message`() {
+        val url = "/bin/coder-linux-amd64"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"/bin/coder-linux-amd64\" is missing a scheme (like https://). Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
+
+    @Test
+    fun `opaque URI like mailto should return Invalid`() {
+        val url = "mailto:user@coder.com"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"mailto:user@coder.com\" is invalid because it is not in the standard format. Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
+
+    @Test
+    fun `unsupported scheme like ftp should return Invalid`() {
+        val url = "ftp://coder.com"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"ftp://coder.com\" must start with http:// or https://, not \"ftp\""),
+            result
+        )
+    }
+
+    @Test
+    fun `http URL with missing authority should return Invalid`() {
+        val url = "http:///bin/coder-linux-amd64"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"http:///bin/coder-linux-amd64\" does not include a valid website name. Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
+
+    @Test
+    fun `malformed URI should return Invalid with parsing error message`() {
+        val url = "http://[invalid-uri]"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The input \"http://[invalid-uri]\" is not a valid web address. Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
+
+    @Test
+    fun `URI without colon should return Invalid as URI is not absolute`() {
+        val url = "http//coder.com"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"http//coder.com\" is missing a scheme (like https://). Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
+
+    @Test
+    fun `URI without double forward slashes should return Invalid because the URI is not hierarchical`() {
+        val url = "http:coder.com"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"http:coder.com\" is invalid because it is not in the standard format. Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
+
+    @Test
+    fun `URI without a single forward slash should return Invalid because the URI does not have a hostname`() {
+        val url = "https:/coder.com"
+        val result = url.validateStrictWebUrl()
+        assertEquals(
+            WebUrlValidationResult.Invalid("The URL \"https:/coder.com\" does not include a valid website name. Please enter a full web address like \"https://example.com\""),
+            result
+        )
+    }
 }
diff --git a/src/test/resources/extension.json b/src/test/resources/extension.json
new file mode 100644
index 0000000..3f897e2
--- /dev/null
+++ b/src/test/resources/extension.json
@@ -0,0 +1,4 @@
+{
+  "id": "com.coder.toolbox",
+  "version": "development"
+}
\ No newline at end of file