- the plugin will now remember the SSH connection state for each workspace, and it will try to automatically

establish it after an expired token was refreshed.

-`Stop` action is now available for running workspaces that have an out of date template.

- outdated and stopped workspaces are now updated and started when handling URI

- show errors when the Toolbox is visible again after being minimized.

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.

Enabling debug logging is essential for diagnosing issues with the Toolbox plugin, especially when SSH

connections to the remote environment fail — it provides detailed output that includes SSH negotiation

Enabling debug logging is essential for diagnosing issues with the Toolbox plugin, especially when SSH

connections to the remote environment fail — it provides detailed output that includes SSH negotiation

and command execution, which is not visible at the default log level.

If you encounter a problem with Coder's JetBrains Toolbox plugin, follow the steps below to gather more

If you encounter a problem with Coder's JetBrains Toolbox plugin, follow the steps below to gather more

information and help us diagnose and resolve it quickly.

3. In the screen that appears, select_DEBUG_ for the`Log level:` section.

4. Hit the back button at the top.

4. Hit the back button at the top.

There is no need to restart Toolbox, as it will begin logging at the__DEBUG__ level right away.

Once enabled, debug logs will be written to the Toolbox log files. You can access logs directly

Once enabled, debug logs will be written to the Toolbox log files. You can access logs directly

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

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_.

The Coder Settings allows users to control CLI download behavior, SSH configuration, TLS parameters, and data

storage paths. The options can be configured from the plugin's main Workspaces page > deployment action menu > Settings.

```Binary source``` specifies the source URL or relative path from which the Coder CLI should be downloaded.

If a relative path is provided, it is resolved against the deployment domain.

```Enable downloads``` allows automatic downloading of the CLI if the current version is missing or outdated.

```Binary directory``` specifies the directory where CLI binaries are stored. If omitted, it defaults to the data directory.

```Binary directory``` specifies the directory where CLI binaries are stored. If omitted, it defaults to the data

directory.

```Enable binary directory fallback``` if enabled, falls back to the data directory when the specified binary

directory is not writable.

```Data directory``` directory where plugin-specific data such as session tokens and binaries are stored if not

```Data directory``` directory where plugin-specific data such as session tokens and binaries are stored if not

overridden by the binary directory setting.

```Header command``` command that outputs additional HTTP headers. Each line of output must be in the format key=value.

The environment variable CODER_URL will be available to the command process.

The following options control the secure communication behavior of the plugin with Coder deployment and its available API.

The following options control the secure communication behavior of the plugin with Coder deployment and its available

API.

```TLS cert path``` path to a client certificate file for TLS authentication with Coder deployment.

The certificate should be in X.509 PEM format.

certs returned by the Coder deployment. The file should be in X.509 PEM format. This option can also be used to verify

proxy certificates.

```TLS alternate hostname``` overrides the hostname used in TLS verification. This is useful when the hostname

```TLS alternate hostname``` overrides the hostname used in TLS verification. This is useful when the hostname

used to connect to the Coder deployment does not match the hostname in the TLS certificate.

```SSH network metrics directory``` directory where network information used by the SSH proxy is stored.

```Extra SSH options``` additional options appended to the SSH configuration. Can be used to customize the behavior of SSH connections.

```Extra SSH options``` additional options appended to the SSH configuration. Can be used to customize the behavior of

SSH connections.

Changes made in the settings page are saved by clicking the Save button. Some changes, like toggling SSH wildcard support,

Changes made in the settings page are saved by clicking the Save button. Some changes, like toggling SSH wildcard

support,

may trigger regeneration of SSH configurations.

fungetContentsView():EnvironmentContentsView=EnvironmentView(

overridesuspendfungetContentsView():EnvironmentContentsView=EnvironmentView(

client.url,

cli,

workspace,

agent

)

overridefunsetVisible(visibilityState:EnvironmentVisibilityState) {

if (wsRawStatus.ready()&& visibilityState.contentsVisible==true&& isConnected.value==false) {

if (visibilityState.contentsVisible) {

startSshConnection()

}

}

funstartSshConnection():Boolean {

if (wsRawStatus.ready()&&!isConnected.value) {

context.cs.launch {

connectionRequest.update {

}

}

}

}

overridefungetDeleteEnvironmentConfirmationParams():DeleteEnvironmentConfirmationParams? {

}

}

funisConnected():Boolean= isConnected.value

privateval isInitialized:MutableStateFlow<Boolean>=MutableStateFlow(false)

privatevar coderHeaderPage=NewEnvironmentPage(context, context.i18n.pnotr(context.deploymentUrl.toString()))

privateval linkHandler=CoderProtocolHandler(context, dialogUi, isInitialized)

overrideval environments:MutableStateFlow<LoadableState<List<RemoteProviderEnvironment>>>=MutableStateFlow(

overrideval environments:MutableStateFlow<LoadableState<List<CoderRemoteEnvironment>>>=MutableStateFlow(

LoadableState.Loading

)

privateval visibilityState=MutableStateFlow(

ProviderVisibilityState(

applicationVisible=false,

providerVisible=false

)

)

environments.update {

LoadableState.Value(resolvedEnvironments.toList())

}

if (isInitialized.value==false) {

if (!isInitialized.value) {

context.logger.info("Environments for${client.url} are now initialized")

isInitialized.update {

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")

}

}

}

WorkspaceConnectionManager.reset()

}

WorkspaceConnectionManager.collectStatuses(lastEnvironments)

}catch (_:CancellationException) {

context.logger.debug("${client.url} polling loop canceled")

client.setupSession()

}else {

context.logger.error(ex,"workspace polling error encountered, trying to auto-login")

if (exisAPIResponseException&& ex.isTokenExpired) {

WorkspaceConnectionManager.shouldEstablishWorkspaceConnections=true

}

close()

firstRun=true

goToEnvironmentsPage()

}

context.secrets.rememberMe=false

WorkspaceConnectionManager.reset()

close()

}

overridefunsetVisible(visibilityState:ProviderVisibilityState) {}

overridefunsetVisible(visibility:ProviderVisibilityState) {

visibilityState.update {

visibility

}

}

if (autologin&& lastDeploymentURL.isNotBlank()&& (lastToken.isNotBlank()||!settings.requireTokenAuth)) {

try {

AuthWizardState.goToStep(WizardStep.LOGIN)

returnAuthWizardPage(context, settingsPage,true, ::onConnect)

returnAuthWizardPage(context, settingsPage,visibilityState,true, ::onConnect)

}catch (ex:Exception) {

errorBuffer.add(ex)

}

firstRun=false

val authWizard=AuthWizardPage(context, settingsPage,false, ::onConnect)

val authWizard=AuthWizardPage(context, settingsPage,visibilityState, onConnect= ::onConnect)

errorBuffer.forEach {

authWizard.notify("Error encountered", it)

context.refreshMainPage()

}

privatefun MutableStateFlow<LoadableState<List<RemoteProviderEnvironment>>>.showLoadingMessage() {

privatefun MutableStateFlow<LoadableState<List<CoderRemoteEnvironment>>>.showLoadingMessage() {

this.update {

LoadableState.Loading

}

object WorkspaceConnectionManager {

privateval workspaceConnectionState= mutableMapOf<String,Boolean>()

var shouldEstablishWorkspaceConnections=false

funallConnected():Set<String>= workspaceConnectionState.filter { it.value }.map { it.key }.toSet()

funcollectStatuses(workspaces:Set<CoderRemoteEnvironment>) {

workspaces.forEach { register(it.id, it.isConnected()) }

}

privatefunregister(wsId:String,isConnected:Boolean) {

workspaceConnectionState[wsId]= isConnected

}

funreset() {

workspaceConnectionState.clear()

shouldEstablishWorkspaceConnections=false

}

}

classAPIResponseException(action:String,url:URL,code:Int,errorResponse:ApiErrorResponse?) :

IOException(formatToPretty(action, url, code, errorResponse)) {

val isUnauthorized=HttpURLConnection.HTTP_UNAUTHORIZED== code

val isTokenExpired= isUnauthorized&& reason?.contains("API key expired")==true

companionobject {

privatefunformatToPretty(