Switch to two-query merge with owner-namespaced ids

aslilac · aslilac · commit 60d4eaebe805 · 2026-05-15T20:03:47.000Z
- Always query both `owner:me` and `shared:true`; merge and dedupe.
- Drop the `workspaceFilter` setting.
- Shared workspaces (where `ownerName != client.me.username`) use
  `&lt;owner&gt;.&lt;workspace&gt;.&lt;agent&gt;` as their environment id so they don't
  collide with the user's own workspaces; owned workspaces keep the
  legacy `&lt;workspace&gt;.&lt;agent&gt;` id.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,8 +7,8 @@
 - `Binary destination` can now point directly to an executable, used as-is; otherwise it is treated as a base directory
   as before
 - support for OAuth2
-- workspace listing now accepts a configurable `Workspace filter` (defaults to `owner:me`); leave it blank to include
-  workspaces shared with the current user
+- workspaces shared with the current user via RBAC now appear in the workspace list alongside your own; shared
+  workspaces are namespaced by owner (`<owner>.<workspace>.<agent>`) so they don't collide with yours
 - the URI handler accepts an optional `owner` query parameter to disambiguate shared workspaces
 
 ### Removed
diff --git a/src/main/kotlin/com/coder/toolbox/CoderRemoteEnvironment.kt b/src/main/kotlin/com/coder/toolbox/CoderRemoteEnvironment.kt
@@ -42,6 +42,20 @@ import kotlin.time.Duration.Companion.seconds
 
 private val POLL_INTERVAL = 5.seconds
 
+/**
+ * Build the environment id for a workspace/agent pair. Workspaces shared
+ * with the current user are namespaced by owner (`<owner>.<workspace>.<agent>`)
+ * so they don't collide with the user's own workspaces, while owned
+ * workspaces keep the legacy `<workspace>.<agent>` id to preserve persistent
+ * per-environment state (auto-connect, etc.).
+ */
+fun environmentId(workspace: Workspace, agent: WorkspaceAgent, currentUser: String): String =
+    if (workspace.ownerName == currentUser) {
+        "${workspace.name}.${agent.name}"
+    } else {
+        "${workspace.ownerName}.${workspace.name}.${agent.name}"
+    }
+
 /**
  * Represents an agent and workspace combination.
  *
@@ -53,10 +67,12 @@ class CoderRemoteEnvironment(
     internal var cli: CoderCLIManager,
     private var workspace: Workspace,
     private var agent: WorkspaceAgent,
-) : RemoteProviderEnvironment("${workspace.name}.${agent.name}"), BeforeConnectionHook, AfterDisconnectHook {
+) : RemoteProviderEnvironment(environmentId(workspace, agent, client.me.username)),
+    BeforeConnectionHook,
+    AfterDisconnectHook {
     private var environmentStatus = WorkspaceAndAgentStatus.from(workspace, agent)
 
-    override var name: String = "${workspace.name}.${agent.name}"
+    override var name: String = environmentId(workspace, agent, client.me.username)
     private var isConnected: MutableStateFlow<Boolean> = MutableStateFlow(false)
     override val connectionRequest: MutableStateFlow<Boolean> = MutableStateFlow(false)
 
diff --git a/src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt b/src/main/kotlin/com/coder/toolbox/CoderRemoteProvider.kt
@@ -214,7 +214,8 @@ class CoderRemoteProvider(
                 .flatMap { it.agents ?: emptyList() }
                 .distinctBy { it.name }
                 .map { agent ->
-                    lastEnvironments.firstOrNull { it.id == "${ws.name}.${agent.name}" }
+                    val envId = environmentId(ws, agent, client.me.username)
+                    lastEnvironments.firstOrNull { it.id == envId }
                         ?.also {
                             // If we have an environment already, update that.
                             it.update(ws, agent)
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt b/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt
@@ -163,27 +163,46 @@ open class CoderRestClient(
     /**
      * Retrieves the available workspaces visible to the current user.
      *
-     * The query string is taken from
-     * [com.coder.toolbox.settings.ReadOnlyCoderSettings.workspaceFilter], which
-     * defaults to `owner:me`. Users can broaden it (for example to an empty
-     * string) to also include workspaces shared with them.
+     * Runs two queries against the server, `owner:me` (workspaces owned by the
+     * current user) and `shared:true` (workspaces shared with them via RBAC),
+     * and returns the union deduplicated by workspace id. The `shared:true`
+     * query is best-effort: if the server does not understand it (older
+     * deployments) we log the error and return only the owned set.
      *
-     * @throws [APIResponseException].
+     * @throws [APIResponseException] when the `owner:me` query fails.
      */
     suspend fun workspaces(): List<Workspace> {
-        val workspacesResponse = callWithRetry {
-            retroRestClient.workspaces(context.settingsStore.workspaceFilter)
+        val owned = fetchWorkspaces("owner:me")
+        val shared = try {
+            fetchWorkspaces("shared:true")
+        } catch (ex: APIResponseException) {
+            context.logger.warn(ex, "Failed to list shared workspaces on $url; continuing with owned workspaces only")
+            emptyList()
+        }
+
+        if (shared.isEmpty()) return owned
+
+        // Dedupe by id in case the server returns a workspace in both queries
+        // (for example if a user shares a workspace with themselves).
+        val seen = HashSet<UUID>(owned.size + shared.size)
+        return buildList {
+            for (ws in owned + shared) {
+                if (seen.add(ws.id)) add(ws)
+            }
         }
-        if (!workspacesResponse.isSuccessful) {
+    }
+
+    private suspend fun fetchWorkspaces(query: String): List<Workspace> {
+        val response = callWithRetry { retroRestClient.workspaces(query) }
+        if (!response.isSuccessful) {
             throw APIResponseException(
-                "retrieve workspaces",
+                "retrieve workspaces matching '$query'",
                 url,
-                workspacesResponse.code(),
-                workspacesResponse.parseErrorBody(moshi)
+                response.code(),
+                response.parseErrorBody(moshi)
             )
         }
-
-        return requireNotNull(workspacesResponse.body()?.workspaces) {
+        return requireNotNull(response.body()?.workspaces) {
             "Successful response returned null body or workspaces"
         }
     }
diff --git a/src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt b/src/main/kotlin/com/coder/toolbox/settings/ReadOnlyCoderSettings.kt
@@ -157,13 +157,6 @@ interface ReadOnlyCoderSettings {
      */
     val workspaceCreateUrl: String?
 
-    /**
-     * The filter applied when listing workspaces, passed to the server as the
-     * `q` query parameter. Defaults to `owner:me`. Set to an empty string to
-     * include workspaces shared with the current user.
-     */
-    val workspaceFilter: String
-
     /**
      * The path where network information for SSH hosts are stored
      */
diff --git a/src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt b/src/main/kotlin/com/coder/toolbox/store/CoderSettingsStore.kt
@@ -88,8 +88,6 @@ class CoderSettingsStore(
         get() = store[WORKSPACE_VIEW_URL]
     override val workspaceCreateUrl: String?
         get() = store[WORKSPACE_CREATE_URL]
-    override val workspaceFilter: String
-        get() = store[WORKSPACE_FILTER] ?: "owner:me"
 
     /**
      * Where the specified deployment should put its data.
@@ -264,10 +262,6 @@ class CoderSettingsStore(
         store[PREFER_OAUTH2_IF_AVAILABLE] = preferAuthViaOAuth2.toString()
     }
 
-    fun updateWorkspaceFilter(filter: String) {
-        store[WORKSPACE_FILTER] = filter
-    }
-
     private fun getDefaultGlobalDataDir(): Path {
         return when (getOS()) {
             OS.WINDOWS -> Paths.get(getWinAppData(), "coder-toolbox")
diff --git a/src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt b/src/main/kotlin/com/coder/toolbox/store/StoreKeys.kt
@@ -53,7 +53,6 @@ internal const val NETWORK_INFO_DIR = "networkInfoDir"
 
 internal const val WORKSPACE_VIEW_URL = "workspaceViewUrl"
 internal const val WORKSPACE_CREATE_URL = "workspaceCreateUrl"
-internal const val WORKSPACE_FILTER = "workspaceFilter"
 
 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
@@ -2,6 +2,7 @@ package com.coder.toolbox.util
 
 import com.coder.toolbox.CoderToolboxContext
 import com.coder.toolbox.cli.CoderCLIManager
+import com.coder.toolbox.environmentId
 import com.coder.toolbox.feed.IdeFeedManager
 import com.coder.toolbox.feed.IdeType
 import com.coder.toolbox.models.WorkspaceAndAgentStatus
@@ -59,7 +60,7 @@ open class CoderProtocolHandler(
             ) ?: return
             if (!ensureAgentIsReady(workspace, agent)) return
             delay(2.seconds)
-            val environmentId = "${workspace.name}.${agent.name}"
+            val environmentId = environmentId(workspace, agent, restClient.me.username)
             context.showEnvironmentPage(environmentId)
 
             val productCode = params.ideProductCode()
diff --git a/src/main/kotlin/com/coder/toolbox/views/CoderSettingsPage.kt b/src/main/kotlin/com/coder/toolbox/views/CoderSettingsPage.kt
@@ -125,12 +125,6 @@ class CoderSettingsPage(
         TextType.General
     )
 
-    private val workspaceFilterField = TextField(
-        context.i18n.ptrl("Workspace filter (leave blank to include shared workspaces)"),
-        settings.workspaceFilter,
-        TextType.General,
-    )
-
     private lateinit var visibilityUpdateJob: Job
     override val fields: StateFlow<List<UiField>> = MutableStateFlow(
         listOf(
@@ -140,7 +134,6 @@ class CoderSettingsPage(
                 listOf(
                     useAppNameField,
                     disableAutostartField,
-                    workspaceFilterField,
                     httpLoggingField,
                 )
             ),
@@ -221,7 +214,6 @@ class CoderSettingsPage(
                     updateSshLogDir(sshLogDirField.contentState.value)
                     updateNetworkInfoDir(networkInfoDirField.contentState.value)
                     updateSshConfigOptions(sshExtraArgs.contentState.value)
-                    updateWorkspaceFilter(workspaceFilterField.contentState.value)
                 }
             }
         )
@@ -296,10 +288,6 @@ class CoderSettingsPage(
             settings.networkInfoDir
         }
 
-        workspaceFilterField.contentState.update {
-            settings.workspaceFilter
-        }
-
         visibilityUpdateJob = context.cs.launch(CoroutineName("Signature Verification Fallback Setting")) {
             disableSignatureVerificationField.checkedState.collect { state ->
                 signatureFallbackStrategyField.visibility.update {
diff --git a/src/test/kotlin/com/coder/toolbox/CoderRemoteProviderTest.kt b/src/test/kotlin/com/coder/toolbox/CoderRemoteProviderTest.kt
@@ -44,6 +44,10 @@ class CoderRemoteProviderTest {
         mockCli = mockk(relaxed = true)
         mockContext = mockk(relaxed = true)
         remoteProvider = CoderRemoteProvider(mockContext)
+        // Default mocked client is the owner of every mocked workspace so the
+        // env id stays in the legacy `<workspace>.<agent>` form. Tests that
+        // exercise shared workspaces override `mockClient.me.username`.
+        every { mockClient.me.username } returns "owner"
     }
 
     @AfterTest
@@ -495,6 +499,23 @@ class CoderRemoteProviderTest {
             assertEquals("workspace2.mockAgent", result[1].id)
         }
 
+    @Test
+    fun `given a workspace owned by someone else then env id is namespaced by owner`() = runTest {
+        // given
+        val agent = mockAgent("agent1")
+        val resource = mockResource(agents = listOf(agent))
+        val owned = mockWorkspace("mine", WorkspaceStatus.RUNNING, listOf(resource), ownerName = "me")
+        val shared = mockWorkspace("shared", WorkspaceStatus.RUNNING, listOf(resource), ownerName = "coworker")
+        every { mockClient.me.username } returns "me"
+        coEvery { mockClient.workspaces() } returns listOf(owned, shared)
+
+        // when
+        val result = remoteProvider.resolveWorkspaceEnvironments(mockClient, mockCli)
+
+        // then
+        assertEquals(setOf("mine.agent1", "coworker.shared.agent1"), result.map { it.id }.toSet())
+    }
+
     // Helper functions
     private fun mockAgent(name: String, status: WorkspaceAgentStatus = WorkspaceAgentStatus.CONNECTED): WorkspaceAgent {
         return mockk {
diff --git a/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt b/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt
@@ -289,6 +289,64 @@ class CoderRestClientTest {
         }
     }
 
+    @Test
+    fun testMergesOwnedAndSharedWorkspaces() {
+        val owned = DataGen.workspace("owned", ownerName = "me")
+        val shared = DataGen.workspace("shared", ownerName = "coworker")
+        val (srv, url) = mockServer()
+        val client = CoderRestClient(context, URL(url), "token")
+        srv.createContext(
+            "/api/v2/workspaces",
+            BaseHttpHandler("GET") { exchange ->
+                val query = exchange.requestURI.rawQuery.orEmpty()
+                val workspaces = when {
+                    query.contains("owner%3Ame") -> listOf(owned)
+                    query.contains("shared%3Atrue") -> listOf(shared, owned)
+                    else -> emptyList()
+                }
+                val body = moshi.adapter(WorkspacesResponse::class.java)
+                    .toJson(WorkspacesResponse(workspaces))
+                    .toByteArray()
+                exchange.sendResponseHeaders(HttpURLConnection.HTTP_OK, body.size.toLong())
+                exchange.responseBody.write(body)
+            },
+        )
+
+        val result = runBlocking { client.workspaces() }
+        assertEquals(listOf("owned", "shared"), result.map { it.name })
+        srv.stop(0)
+    }
+
+    @Test
+    fun testIgnoresFailedSharedQuery() {
+        val owned = DataGen.workspace("owned", ownerName = "me")
+        val (srv, url) = mockServer()
+        val client = CoderRestClient(context, URL(url), "token")
+        srv.createContext(
+            "/api/v2/workspaces",
+            BaseHttpHandler("GET") { exchange ->
+                val query = exchange.requestURI.rawQuery.orEmpty()
+                if (query.contains("shared%3Atrue")) {
+                    val response = Response("Bad request", "shared:true is not supported")
+                    val body = moshi.adapter(Response::class.java).toJson(response).toByteArray()
+                    exchange.sendResponseHeaders(HttpURLConnection.HTTP_BAD_REQUEST, body.size.toLong())
+                    exchange.responseBody.write(body)
+                    return@BaseHttpHandler
+                }
+                val body = moshi.adapter(WorkspacesResponse::class.java)
+                    .toJson(WorkspacesResponse(listOf(owned)))
+                    .toByteArray()
+                exchange.sendResponseHeaders(HttpURLConnection.HTTP_OK, body.size.toLong())
+                exchange.responseBody.write(body)
+            },
+        )
+
+        val result = runBlocking { client.workspaces() }
+        assertEquals(listOf("owned"), result.map { it.name })
+        srv.stop(0)
+    }
+
+
     @Test
     fun testGetsResources() {
         val tests =
diff --git a/src/test/kotlin/com/coder/toolbox/settings/CoderSettingsTest.kt b/src/test/kotlin/com/coder/toolbox/settings/CoderSettingsTest.kt
@@ -11,7 +11,6 @@ import com.coder.toolbox.store.TLS_ALTERNATE_HOSTNAME
 import com.coder.toolbox.store.TLS_CA_PATH
 import com.coder.toolbox.store.TLS_CERT_PATH
 import com.coder.toolbox.store.TLS_KEY_PATH
-import com.coder.toolbox.store.WORKSPACE_FILTER
 import com.coder.toolbox.util.OS
 import com.coder.toolbox.util.getOS
 import com.coder.toolbox.util.pluginTestSettingsStore
@@ -281,28 +280,6 @@ internal class CoderSettingsTest {
         assertEquals(null, settings.readOnly().tls.caPath)
         assertEquals(null, settings.readOnly().tls.altHostname)
         assertEquals(getOS() == OS.MAC, settings.readOnly().disableAutostart)
-        assertEquals("owner:me", settings.readOnly().workspaceFilter)
-    }
-
-    @Test
-    fun testWorkspaceFilter() {
-        // An empty value should be preserved so users can broaden the filter
-        // (for example to also list workspaces shared with them).
-        val settings = CoderSettingsStore(
-            pluginTestSettingsStore(WORKSPACE_FILTER to ""),
-            Environment(),
-            logger,
-        )
-        assertEquals("", settings.readOnly().workspaceFilter)
-
-        // Custom filters should round-trip through the store.
-        val customFilter = "owner:me OR shared:true"
-        val custom = CoderSettingsStore(
-            pluginTestSettingsStore(WORKSPACE_FILTER to customFilter),
-            Environment(),
-            logger,
-        )
-        assertEquals(customFilter, custom.readOnly().workspaceFilter)
     }
 
     @Test
