fix: remote client renders project folders and worktrees as flat list

Add worktree_info and worktree_ids to ApiProject so the server transmits
parent-child worktree relationships. Rewrite client-side materialization
to replicate the server's folder structure (individual FolderData per
server folder) instead of flattening everything into a single wrapper
folder per connection.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: matej21

crates/okena-core/src/api.rs

@@ -48,6 +48,17 @@ pub struct ApiProject {
     pub folder_color: FolderColor,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub services: Vec<ApiServiceInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub worktree_info: Option<ApiWorktreeMetadata>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub worktree_ids: Vec<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ApiWorktreeMetadata {
+    pub parent_project_id: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub color_override: Option<FolderColor>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -380,6 +391,8 @@ mod tests {
                 git_status: None,
                 folder_color: FolderColor::Blue,
                 services: vec![],
+                worktree_info: None,
+                worktree_ids: vec![],
             }],
             focused_project_id: Some("p1".into()),
             fullscreen_terminal: None,

crates/okena-core/src/client/state.rs

@@ -162,6 +162,8 @@ mod tests {
             git_status: None,
             folder_color: Default::default(),
             services: vec![],
+            worktree_info: None,
+            worktree_ids: vec![],
         }
     }
 

crates/okena-views-sidebar/src/folder_list.rs

@@ -16,7 +16,7 @@ use okena_workspace::state::FolderData;
 
 impl Sidebar {
     /// Send a reorder action to the remote server when a project is reordered
-    /// within a "remote-folder:{conn_id}" on the client.
+    /// within a remote folder on the client.
     fn send_remote_reorder(this: &mut Self, conn_id: &str, prefixed_project_id: &str, new_index: usize, cx: &mut App) {
         let server_project_id = okena_core::client::strip_prefix(prefixed_project_id, conn_id);
 
@@ -283,9 +283,12 @@ impl Sidebar {
                                 ws.move_project_to_folder(&drag.project_id, &folder_id, Some(pos), cx);
                             });
                             // Send reorder to server for remote folders
-                            if folder_id.starts_with("remote-folder:") {
-                                if let Some(conn_id) = folder_id.strip_prefix("remote-folder:") {
-                                    Self::send_remote_reorder(this, conn_id, &drag.project_id, pos, cx);
+                            if folder_id.starts_with("remote:") {
+                                // Folder ID is "remote:{conn_id}:{folder_id}" — extract conn_id
+                                if let Some(rest) = folder_id.strip_prefix("remote:") {
+                                    if let Some(conn_id) = rest.split(':').next() {
+                                        Self::send_remote_reorder(this, conn_id, &drag.project_id, pos, cx);
+                                    }
                                 }
                             }
                         }

crates/okena-workspace/src/persistence.rs

@@ -792,9 +792,9 @@ mod tests {
 
         let mut data = make_workspace(
             vec![local, remote1, remote2],
-            vec!["local1", "remote-folder:conn1"],
+            vec!["local1", "remote:conn1:folder1"],
             vec![FolderData {
-                id: "remote-folder:conn1".to_string(),
+                id: "remote:conn1:folder1".to_string(),
                 name: "Server 1".to_string(),
                 project_ids: vec!["remote:conn1:p1".to_string(), "remote:conn1:p2".to_string()],
                 collapsed: false,

crates/okena-workspace/src/state.rs

@@ -63,7 +63,7 @@ impl WorkspaceData {
             version: self.version,
             projects: self.projects.iter().filter(|p| !p.is_remote).cloned().collect(),
             project_order: self.project_order.iter()
-                .filter(|id| !id.starts_with("remote-folder:") && !remote_ids.contains(id.as_str()))
+                .filter(|id| !id.starts_with("remote:") && !remote_ids.contains(id.as_str()))
                 .cloned().collect(),
             project_widths: self.project_widths.iter()
                 .filter(|(id, _)| !remote_ids.contains(id.as_str()))
@@ -72,7 +72,7 @@ impl WorkspaceData {
                 .filter(|(id, _)| !remote_ids.contains(id.as_str()))
                 .map(|(k, v)| (k.clone(), *v)).collect(),
             folders: self.folders.iter()
-                .filter(|f| !f.id.starts_with("remote-folder:"))
+                .filter(|f| !f.id.starts_with("remote:"))
                 .cloned().collect(),
         }
     }
@@ -897,17 +897,16 @@ impl Workspace {
     /// Remove all remote projects (and their folder) for a given connection_id.
     #[allow(dead_code)]
     pub fn remove_remote_projects(&mut self, connection_id: &str, cx: &mut Context<Self>) {
-        let folder_id = format!("remote-folder:{}", connection_id);
         let prefix = format!("remote:{}:", connection_id);
 
         // Remove projects
         self.data.projects.retain(|p| !p.id.starts_with(&prefix));
 
-        // Remove folder
-        self.data.folders.retain(|f| f.id != folder_id);
+        // Remove folders
+        self.data.folders.retain(|f| !f.id.starts_with(&prefix));
 
         // Remove from project_order
-        self.data.project_order.retain(|id| *id != folder_id && !id.starts_with(&prefix));
+        self.data.project_order.retain(|id| !id.starts_with(&prefix));
 
         // Remove from project_widths
         self.data.project_widths.retain(|id, _| !id.starts_with(&prefix));
@@ -3613,17 +3612,17 @@ mod gpui_tests {
 
         let mut data = make_workspace_data(
             vec![local, remote1, remote2, remote3],
-            vec!["local1", "remote-folder:conn1", "remote-folder:conn2"],
+            vec!["local1", "remote:conn1:folder1", "remote:conn2:folder2"],
         );
         data.folders.push(FolderData {
-            id: "remote-folder:conn1".to_string(),
+            id: "remote:conn1:folder1".to_string(),
             name: "Server 1".to_string(),
             project_ids: vec!["remote:conn1:p1".to_string(), "remote:conn1:p2".to_string()],
             collapsed: false,
             folder_color: FolderColor::default(),
         });
         data.folders.push(FolderData {
-            id: "remote-folder:conn2".to_string(),
+            id: "remote:conn2:folder2".to_string(),
             name: "Server 2".to_string(),
             project_ids: vec!["remote:conn2:p1".to_string()],
             collapsed: false,
@@ -3646,11 +3645,11 @@ mod gpui_tests {
 
             // conn1 folder removed, conn2 folder remains
             assert_eq!(ws.data.folders.len(), 1);
-            assert_eq!(ws.data.folders[0].id, "remote-folder:conn2");
+            assert_eq!(ws.data.folders[0].id, "remote:conn2:folder2");
 
             // project_order cleaned
-            assert!(!ws.data.project_order.contains(&"remote-folder:conn1".to_string()));
-            assert!(ws.data.project_order.contains(&"remote-folder:conn2".to_string()));
+            assert!(!ws.data.project_order.contains(&"remote:conn1:folder1".to_string()));
+            assert!(ws.data.project_order.contains(&"remote:conn2:folder2".to_string()));
         });
     }
 
@@ -3666,10 +3665,10 @@ mod gpui_tests {
 
         let mut data = make_workspace_data(
             vec![local, remote1, remote2],
-            vec!["local1", "remote-folder:conn1"],
+            vec!["local1", "remote:conn1:folder1"],
         );
         data.folders.push(FolderData {
-            id: "remote-folder:conn1".to_string(),
+            id: "remote:conn1:folder1".to_string(),
             name: "Server 1".to_string(),
             project_ids: vec!["remote:conn1:p1".to_string(), "remote:conn1:p2".to_string()],
             collapsed: false,

src/app/remote_commands.rs

@@ -163,6 +163,13 @@ pub(crate) async fn remote_command_loop(
                             git_status,
                             folder_color: p.folder_color,
                             services,
+                            worktree_info: p.worktree_info.as_ref().map(|wt| {
+                                okena_core::api::ApiWorktreeMetadata {
+                                    parent_project_id: wt.parent_project_id.clone(),
+                                    color_override: wt.color_override,
+                                }
+                            }),
+                            worktree_ids: p.worktree_ids.clone(),
                         }
                     };
 

src/views/root/mod.rs

@@ -397,44 +397,42 @@ impl RootView {
 
         for snap in &snapshots {
             let conn_id = &snap.config.id;
-            let folder_id = format!("remote-folder:{}", conn_id);
 
             if let Some(ref state) = snap.state {
-                // Build folder_project_ids using server's order when available
-                let folder_project_ids: Vec<String> = if !state.project_order.is_empty() {
-                    // New server: walk project_order, expand folder entries via state.folders
-                    let server_folder_map: std::collections::HashMap<&str, &okena_core::api::ApiFolder> =
-                        state.folders.iter().map(|f| (f.id.as_str(), f)).collect();
-                    let mut ordered = Vec::new();
-                    let mut seen_ids: std::collections::HashSet<String> = std::collections::HashSet::new();
+                // Build the server folder lookup
+                let server_folder_map: std::collections::HashMap<&str, &okena_core::api::ApiFolder> =
+                    state.folders.iter().map(|f| (f.id.as_str(), f)).collect();
+
+                // Build prefixed project_order and folder entries that mirror the server structure
+                let mut remote_order: Vec<String> = Vec::new();
+                let mut remote_folders: Vec<FolderData> = Vec::new();
+
+                if !state.project_order.is_empty() {
                     for order_id in &state.project_order {
                         if let Some(sf) = server_folder_map.get(order_id.as_str()) {
-                            for pid in &sf.project_ids {
-                                let prefixed = format!("remote:{}:{}", conn_id, pid);
-                                if seen_ids.insert(prefixed.clone()) {
-                                    ordered.push(prefixed);
-                                }
-                            }
+                            // This is a folder — create a prefixed FolderData
+                            let prefixed_folder_id = format!("remote:{}:{}", conn_id, sf.id);
+                            let prefixed_project_ids: Vec<String> = sf.project_ids.iter()
+                                .map(|pid| format!("remote:{}:{}", conn_id, pid))
+                                .collect();
+                            remote_folders.push(FolderData {
+                                id: prefixed_folder_id.clone(),
+                                name: sf.name.clone(),
+                                project_ids: prefixed_project_ids,
+                                collapsed: false,
+                                folder_color: sf.folder_color,
+                            });
+                            remote_order.push(prefixed_folder_id);
                         } else {
-                            let prefixed = format!("remote:{}:{}", conn_id, order_id);
-                            if seen_ids.insert(prefixed.clone()) {
-                                ordered.push(prefixed);
-                            }
+                            // This is a top-level project
+                            remote_order.push(format!("remote:{}:{}", conn_id, order_id));
                         }
                     }
-                    // Append orphans not in order
+                } else {
+                    // Old server without project_order: put all projects as top-level
                     for api_project in &state.projects {
-                        let prefixed = format!("remote:{}:{}", conn_id, api_project.id);
-                        if seen_ids.insert(prefixed.clone()) {
-                            ordered.push(prefixed);
-                        }
+                        remote_order.push(format!("remote:{}:{}", conn_id, api_project.id));
                     }
-                    ordered
-                } else {
-                    // Old server: fall back to state.projects Vec order
-                    state.projects.iter()
-                        .map(|p| format!("remote:{}:{}", conn_id, p.id))
-                        .collect()
                 };
 
                 for api_project in &state.projects {
@@ -478,9 +476,33 @@ impl RootView {
                             existing.remote_services = remote_services;
                             existing.remote_host = remote_host;
                             existing.remote_git_status = api_project.git_status.clone();
+                            existing.worktree_info = api_project.worktree_info.as_ref().map(|wt| {
+                                crate::workspace::state::WorktreeMetadata {
+                                    parent_project_id: format!("remote:{}:{}", conn_id, wt.parent_project_id),
+                                    color_override: wt.color_override,
+                                    main_repo_path: String::new(),
+                                    worktree_path: String::new(),
+                                    branch_name: String::new(),
+                                }
+                            });
+                            existing.worktree_ids = api_project.worktree_ids.iter()
+                                .map(|id| format!("remote:{}:{}", conn_id, id))
+                                .collect();
                             // Don't overwrite show_in_overview — it's client-side state
                             // (the user may have toggled visibility locally).
                         } else {
+                            let worktree_info = api_project.worktree_info.as_ref().map(|wt| {
+                                crate::workspace::state::WorktreeMetadata {
+                                    parent_project_id: format!("remote:{}:{}", conn_id, wt.parent_project_id),
+                                    color_override: wt.color_override,
+                                    main_repo_path: String::new(),
+                                    worktree_path: String::new(),
+                                    branch_name: String::new(),
+                                }
+                            });
+                            let worktree_ids: Vec<String> = api_project.worktree_ids.iter()
+                                .map(|id| format!("remote:{}:{}", conn_id, id))
+                                .collect();
                             ws.data.projects.push(ProjectData {
                                 id: prefixed_id.clone(),
                                 name: api_project.name.clone(),
@@ -489,8 +511,8 @@ impl RootView {
                                 layout,
                                 terminal_names,
                                 hidden_terminals: std::collections::HashMap::new(),
-                                worktree_info: None,
-                                worktree_ids: Vec::new(),
+                                worktree_info,
+                                worktree_ids,
                                 folder_color: project_color,
                                 hooks: HooksConfig::default(),
                                 is_remote: true,
@@ -506,32 +528,30 @@ impl RootView {
                     });
                 }
 
-                let folder_name = snap.config.name.clone();
+                // Sync remote folders and project_order into workspace
+                let remote_prefix = format!("remote:{}:", conn_id);
                 workspace.update(cx, |ws, _cx| {
-                    if let Some(folder) = ws.data.folders.iter_mut().find(|f| f.id == folder_id) {
-                        folder.name = folder_name;
-                        folder.project_ids = folder_project_ids;
-                    } else {
-                        ws.data.folders.push(FolderData {
-                            id: folder_id.clone(),
-                            name: folder_name,
-                            project_ids: folder_project_ids,
-                            collapsed: false,
-                            folder_color: FolderColor::default(),
-                        });
-                    }
-                    if !ws.data.project_order.contains(&folder_id) {
-                        ws.data.project_order.push(folder_id.clone());
+                    // Remove old remote folders for this connection
+                    ws.data.folders.retain(|f| !f.id.starts_with(&remote_prefix));
+                    // Remove old remote entries from project_order for this connection
+                    ws.data.project_order.retain(|id| !id.starts_with(&remote_prefix));
+
+                    // Add new remote folders
+                    for rf in remote_folders {
+                        // Preserve collapsed state from previous sync
+                        ws.data.folders.push(rf);
                     }
+
+                    // Add new remote project_order entries
+                    ws.data.project_order.extend(remote_order);
                 });
             } else {
-                // No state (disconnected/connecting) — remove materialized projects
+                // No state (disconnected/connecting) — remove materialized projects and folders
                 let prefix = format!("remote:{}:", conn_id);
                 workspace.update(cx, |ws, _cx| {
                     ws.data.projects.retain(|p| !p.id.starts_with(&prefix));
-                    if let Some(folder) = ws.data.folders.iter_mut().find(|f| f.id == folder_id) {
-                        folder.project_ids.clear();
-                    }
+                    ws.data.folders.retain(|f| !f.id.starts_with(&prefix));
+                    ws.data.project_order.retain(|id| !id.starts_with(&prefix));
                 });
             }
         }
@@ -546,8 +566,11 @@ impl RootView {
                 }
             });
             ws.data.folders.retain(|f| {
-                if f.id.starts_with("remote-folder:") {
-                    let conn_id = f.id.strip_prefix("remote-folder:").unwrap_or("");
+                if f.id.starts_with("remote:") {
+                    // Remote folder IDs are "remote:{conn_id}:{folder_id}"
+                    // Extract conn_id (second segment)
+                    let rest = f.id.strip_prefix("remote:").unwrap_or("");
+                    let conn_id = rest.split(':').next().unwrap_or("");
                     active_conn_ids.contains(conn_id)
                 } else {
                     true