refactor: simplify workspace start status management

Current approach with a secondary poll loop that handles the start action
of a workspace is overengineered. Basically the problem is the CLI takes too
long before moving the workspace into the queued/starting state, during which
the user doesn't have any feedback. To address the issue we:
- stopped the main poll loop from updating the environment
- moved the environment in the queued state immediately after the start button was pushed.
- started a poll loop that moved the workspace from queued state to starting space only
after that state became available in the backend. The intermediary stopped state is skipped by
the secondary poll loop.

@asher pointed out that a better approach can be implemented. We already store the status, and workspace
and the agent in the environment. When the start comes in:
1. We directly update the env. status to "queued"
2. We only change the environment status if there is difference in the existing workspace&agent
status vs the status from the main poll loop
3. no secondary poll loop is needed.

Author: fioan89

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

@@ -37,7 +37,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withTimeout
 import java.io.File
 import java.nio.file.Path
-import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
@@ -55,14 +54,14 @@ class CoderRemoteEnvironment(
     private var workspace: Workspace,
     private var agent: WorkspaceAgent,
 ) : RemoteProviderEnvironment("${workspace.name}.${agent.name}"), BeforeConnectionHook, AfterDisconnectHook {
-    private var wsRawStatus = WorkspaceAndAgentStatus.from(workspace, agent)
+    private var environmentStatus = WorkspaceAndAgentStatus.from(workspace, agent)
 
     override var name: String = "${workspace.name}.${agent.name}"
     private var isConnected: MutableStateFlow<Boolean> = MutableStateFlow(false)
     override val connectionRequest: MutableStateFlow<Boolean> = MutableStateFlow(false)
 
     override val state: MutableStateFlow<RemoteEnvironmentState> =
-        MutableStateFlow(wsRawStatus.toRemoteEnvironmentState(context))
+        MutableStateFlow(environmentStatus.toRemoteEnvironmentState(context))
     override val description: MutableStateFlow<EnvironmentDescription> =
         MutableStateFlow(EnvironmentDescription.General(context.i18n.pnotr(workspace.templateDisplayName)))
     override val additionalEnvironmentInformation: MutableMap<LocalizableString, String> = mutableMapOf()
@@ -71,7 +70,6 @@ class CoderRemoteEnvironment(
     private val networkMetricsMarshaller = Moshi.Builder().build().adapter(NetworkMetrics::class.java)
     private val proxyCommandHandle = SshCommandProcessHandle(context)
     private var pollJob: Job? = null
-    private val startIsInProgress = AtomicBoolean(false)
 
     init {
         if (context.settingsStore.shouldAutoConnect(id)) {
@@ -84,7 +82,7 @@ class CoderRemoteEnvironment(
 
     private fun getAvailableActions(): List<ActionDescription> {
         val actions = mutableListOf<ActionDescription>()
-        if (wsRawStatus.canStop()) {
+        if (environmentStatus.canStop()) {
             actions.add(Action(context, "Open web terminal") {
                 context.desktop.browse(client.url.withPath("/${workspace.ownerName}/$name/terminal").toString()) {
                     context.ui.showErrorInfoPopup(it)
@@ -114,7 +112,7 @@ class CoderRemoteEnvironment(
         }
         )
 
-        if (wsRawStatus.canStart()) {
+        if (environmentStatus.canStart()) {
             if (workspace.outdated) {
                 actions.add(Action(context, "Update and start") {
                     val build = client.updateWorkspace(workspace)
@@ -123,34 +121,18 @@ class CoderRemoteEnvironment(
                 )
             } else {
                 actions.add(Action(context, "Start") {
-                    try {
-                        // needed in order to make sure Queuing is not overridden by the
-                        // general polling loop with the `Stopped` state
-                        startIsInProgress.set(true)
-                        val startJob = context.cs
-                            .launch(CoroutineName("Start Workspace Action CLI Runner") + Dispatchers.IO) {
-                                cli.startWorkspace(workspace.ownerName, workspace.name)
-                            }
-                        // cli takes 15 seconds to move the workspace in queueing/starting state
-                        // while the user won't see anything happening in TBX after start is clicked
-                        // During those 15 seconds we work around by forcing a `Queuing` state
-                        while (startJob.isActive && client.workspace(workspace.id).latestBuild.status.isNotStarted()) {
-                            state.update {
-                                WorkspaceAndAgentStatus.QUEUED.toRemoteEnvironmentState(context)
-                            }
-                            delay(1.seconds)
+                    context.cs
+                        .launch(CoroutineName("Start Workspace Action CLI Runner") + Dispatchers.IO) {
+                            cli.startWorkspace(workspace.ownerName, workspace.name)
                         }
-                        startIsInProgress.set(false)
-                        // retrieve the status again and update the status
-                        update(client.workspace(workspace.id), agent)
-                    } finally {
-                        startIsInProgress.set(false)
-                    }
-                }
-                )
+                    // cli takes 15 seconds to move the workspace in queueing/starting state
+                    // while the user won't see anything happening in TBX after start is clicked
+                    // During those 15 seconds we work around by forcing a `Queuing` state
+                    updateStatus(WorkspaceAndAgentStatus.QUEUED)
+                })
             }
         }
-        if (wsRawStatus.canStop()) {
+        if (environmentStatus.canStop()) {
             if (workspace.outdated) {
                 actions.add(Action(context, "Update and restart") {
                     val build = client.updateWorkspace(workspace)
@@ -170,12 +152,14 @@ class CoderRemoteEnvironment(
         actions.add(Action(context, "Delete workspace", highlightInRed = true) {
             context.cs.launch(CoroutineName("Delete Workspace Action")) {
                 var dialogText =
-                    if (wsRawStatus.canStop()) "This will close the workspace and remove all its information, including files, unsaved changes, history, and usage data."
+                    if (environmentStatus.canStop()) "This will close the workspace and remove all its information, including files, unsaved changes, history, and usage data."
                     else "This will remove all information from the workspace, including files, unsaved changes, history, and usage data."
                 dialogText += "\n\nType \"${workspace.name}\" below to confirm:"
 
                 val confirmation = context.ui.showTextInputPopup(
-                    if (wsRawStatus.canStop()) context.i18n.ptrl("Delete running workspace?") else context.i18n.ptrl("Delete workspace?"),
+                    if (environmentStatus.canStop()) context.i18n.ptrl("Delete running workspace?") else context.i18n.ptrl(
+                        "Delete workspace?"
+                    ),
                     context.i18n.pnotr(dialogText),
                     context.i18n.ptrl("Workspace name"),
                     TextType.General,
@@ -264,23 +248,34 @@ class CoderRemoteEnvironment(
      * Update the workspace/agent status to the listeners, if it has changed.
      */
     fun update(workspace: Workspace, agent: WorkspaceAgent) {
-        if (startIsInProgress.get()) {
-            context.logger.info("Skipping update for $id - workspace start is in progress")
+        if (WorkspaceAndAgentStatus.from(this.workspace, this.agent) == WorkspaceAndAgentStatus.from(
+                workspace,
+                agent
+            )
+        ) {
+            context.logger.debug("Skipping update for $id - previous and current status ")
             return
         }
         this.workspace = workspace
         this.agent = agent
-        wsRawStatus = WorkspaceAndAgentStatus.from(workspace, agent)
+        // workspace&agent status can be different from "environment status"
+        // which is forced to queued state when a workspace is scheduled to start
+        updateStatus(WorkspaceAndAgentStatus.from(workspace, agent))
         // we have to regenerate the action list in order to force a redraw
         // because the actions don't have a state flow on the enabled property
         actionsList.update {
             getAvailableActions()
         }
+    }
+
+    private fun updateStatus(status: WorkspaceAndAgentStatus) {
+        environmentStatus = status
         context.cs.launch(CoroutineName("Workspace Status Updater")) {
             state.update {
-                wsRawStatus.toRemoteEnvironmentState(context)
+                environmentStatus.toRemoteEnvironmentState(context)
             }
         }
+        context.logger.debug("Overall status for workspace $id is $environmentStatus. Workspace status: ${workspace.latestBuild.status}, agent status: ${agent.status}, agent lifecycle state: ${agent.lifecycleState}, login before ready: ${agent.loginBeforeReady}")
     }
 
     /**
@@ -310,7 +305,7 @@ class CoderRemoteEnvironment(
      * Returns true if the SSH connection was scheduled to start, false otherwise.
      */
     fun startSshConnection(): Boolean {
-        if (wsRawStatus.ready() && !isConnected.value) {
+        if (environmentStatus.ready() && !isConnected.value) {
             context.cs.launch(CoroutineName("SSH Connection Trigger")) {
                 connectionRequest.update {
                     true
@@ -336,7 +331,7 @@ class CoderRemoteEnvironment(
                 withTimeout(5.minutes) {
                     var workspaceStillExists = true
                     while (context.cs.isActive && workspaceStillExists) {
-                        if (wsRawStatus == WorkspaceAndAgentStatus.DELETING || wsRawStatus == WorkspaceAndAgentStatus.DELETED) {
+                        if (environmentStatus == WorkspaceAndAgentStatus.DELETING || environmentStatus == WorkspaceAndAgentStatus.DELETED) {
                             workspaceStillExists = false
                             context.envPageManager.showPluginEnvironmentsPage()
                         } else {