fix(mounts): apply workspace mount changes on restart and upsert mount targets

Author: pRizz

README.md

@@ -245,9 +245,34 @@ occ mount clean --force
 # Purge bind mounts (data loss, removes config entries)
 occ mount clean --purge --force
 
+# Mount a local project into the workspace
+occ mount add /Users/<username>/Desktop/opencode:/home/opencode/workspace
+
+# Apply mount changes (you may be prompted to recreate the container)
+occ restart
+
 # Factory reset host (container, volumes, mounts, config/data)
 occ reset host --force
 
+### Workspace Mounts
+
+Use `/home/opencode/workspace` when you want your host project folder to appear in the
+web UI's project picker and inside the container workspace.
+
+Important behavior:
+- `/home/opencode/workspace` is a single mount target.
+- Adding a new mount to this same target replaces the previous mount entry.
+
+Recommended workflow:
+```bash
+occ mount add /Users/<username>/Desktop/opencode:/home/opencode/workspace
+occ restart
+```
+
+Verify the mount:
+1. Run `occ status` and check `Mounts` -> `Bind mounts` includes your host path mapped to `/home/opencode/workspace`.
+2. In the web UI, open the project picker and confirm your project files appear under `~/workspace`.
+
 ### Container Mode
 
 When `occ` runs inside the opencode container, it will auto-detect this and switch to **container runtime**.

packages/cli-rust/src/commands/mount/add.rs

@@ -20,6 +20,65 @@ pub struct MountAddArgs {
     pub force: bool,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+enum MountUpsertOutcome {
+    Added,
+    AlreadyConfigured,
+    Replaced { replaced_mounts: Vec<ParsedMount> },
+}
+
+fn upsert_mount_by_target(
+    existing_mounts: &[String],
+    mount_spec: &str,
+    parsed: &ParsedMount,
+) -> (Vec<String>, MountUpsertOutcome) {
+    let mut retained = Vec::with_capacity(existing_mounts.len() + 1);
+    let mut same_target = Vec::new();
+
+    for existing in existing_mounts {
+        match ParsedMount::parse(existing) {
+            Ok(existing_parsed) if existing_parsed.container_path == parsed.container_path => {
+                same_target.push(existing_parsed);
+            }
+            _ => retained.push(existing.clone()),
+        }
+    }
+
+    let exact_match_count = same_target
+        .iter()
+        .filter(|mount| mount.host_path == parsed.host_path && mount.read_only == parsed.read_only)
+        .count();
+
+    if exact_match_count == 1 && same_target.len() == 1 {
+        return (
+            existing_mounts.to_vec(),
+            MountUpsertOutcome::AlreadyConfigured,
+        );
+    }
+
+    retained.push(mount_spec.to_string());
+    if same_target.is_empty() {
+        (retained, MountUpsertOutcome::Added)
+    } else {
+        (
+            retained,
+            MountUpsertOutcome::Replaced {
+                replaced_mounts: same_target,
+            },
+        )
+    }
+}
+
+fn mount_to_spec(mount: &ParsedMount) -> String {
+    let mode = if mount.read_only { ":ro" } else { "" };
+    format!(
+        "{}:{}{}",
+        mount.host_path.display(),
+        mount.container_path,
+        mode
+    )
+}
+
 pub async fn cmd_mount_add(args: &MountAddArgs, quiet: bool, _verbose: u8) -> Result<()> {
     // Parse the mount spec
     let parsed = ParsedMount::parse(&args.mount_spec)?;
@@ -44,43 +103,154 @@ pub async fn cmd_mount_add(args: &MountAddArgs, quiet: bool, _verbose: u8) -> Re
 
     // Load config and add mount
     let mut config = load_config_or_default()?;
+    let host_str = parsed.host_path.to_string_lossy().to_string();
+    let (updated_mounts, outcome) =
+        upsert_mount_by_target(&config.mounts, &args.mount_spec, &parsed);
+    config.mounts = updated_mounts;
+    save_config(&config)?;
 
-    // Check for duplicate (by host path)
-    let host_str = parsed.host_path.to_string_lossy();
-    let already_exists = config.mounts.iter().any(|m| {
-        ParsedMount::parse(m)
-            .map(|p| p.host_path.to_string_lossy() == host_str)
-            .unwrap_or(false)
-    });
+    if quiet {
+        return Ok(());
+    }
 
-    if already_exists {
-        if !quiet {
+    match outcome {
+        MountUpsertOutcome::AlreadyConfigured => {
             println!(
-                "Mount for {} already configured. Remove first with: occ mount remove {}",
+                "Mount already configured: {} -> {}",
                 style(&host_str).cyan(),
-                host_str
+                style(&parsed.container_path).cyan()
             );
+            return Ok(());
+        }
+        MountUpsertOutcome::Added => {
+            let mode = if parsed.read_only { "ro" } else { "rw" };
+            println!(
+                "Added mount: {} -> {} ({mode})",
+                style(&host_str).cyan(),
+                style(&parsed.container_path).cyan(),
+            );
+        }
+        MountUpsertOutcome::Replaced { replaced_mounts } => {
+            let mode = if parsed.read_only { "ro" } else { "rw" };
+            println!(
+                "Replaced mount target {} with {} -> {} ({mode})",
+                style(&parsed.container_path).cyan(),
+                style(&host_str).cyan(),
+                style(&parsed.container_path).cyan(),
+            );
+            println!();
+            println!("Previous mount(s) for this target:");
+            for previous in &replaced_mounts {
+                let previous_mode = if previous.read_only { "ro" } else { "rw" };
+                println!(
+                    "  - {} -> {} ({previous_mode})",
+                    previous.host_path.display(),
+                    previous.container_path
+                );
+            }
+            println!();
+            println!("If this replacement was not intended:");
+            println!(
+                "  1) Remove the new mount: {}",
+                style(format!("occ mount remove {host_str}")).cyan()
+            );
+            if let Some(previous) = replaced_mounts.last() {
+                println!(
+                    "  2) Re-add a previous mount: {}",
+                    style(format!("occ mount add {}", mount_to_spec(previous))).cyan()
+                );
+            } else {
+                println!(
+                    "  2) Re-add your previous mount with: {}",
+                    style("occ mount add /host/path:/container/path[:ro]").cyan()
+                );
+            }
         }
-        return Ok(());
     }
 
-    config.mounts.push(args.mount_spec.clone());
-    save_config(&config)?;
+    println!();
+    println!(
+        "{}",
+        style("Note: Run `occ restart` to apply mount changes. If mounts changed, you will be prompted to recreate the container.").dim()
+    );
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn upsert_mount_by_target_exact_same_is_noop() {
+        let existing = vec![
+            "/host/a:/home/opencode/workspace".to_string(),
+            "/host/b:/home/opencode/.cache/opencode".to_string(),
+        ];
+        let parsed = ParsedMount::parse("/host/a:/home/opencode/workspace").unwrap();
 
-    if !quiet {
-        let mode = if parsed.read_only { "ro" } else { "rw" };
-        println!(
-            "Added mount: {} -> {} ({})",
-            style(&host_str).cyan(),
-            style(&parsed.container_path).cyan(),
-            mode
+        let (updated, outcome) =
+            upsert_mount_by_target(&existing, "/host/a:/home/opencode/workspace", &parsed);
+
+        assert_eq!(updated, existing);
+        assert_eq!(outcome, MountUpsertOutcome::AlreadyConfigured);
+    }
+
+    #[test]
+    fn upsert_mount_by_target_replaces_same_target_with_new_host() {
+        let existing = vec![
+            "/host/old:/home/opencode/workspace".to_string(),
+            "/host/cache:/home/opencode/.cache/opencode".to_string(),
+        ];
+        let parsed = ParsedMount::parse("/host/new:/home/opencode/workspace").unwrap();
+
+        let (updated, outcome) =
+            upsert_mount_by_target(&existing, "/host/new:/home/opencode/workspace", &parsed);
+
+        assert_eq!(
+            updated,
+            vec![
+                "/host/cache:/home/opencode/.cache/opencode".to_string(),
+                "/host/new:/home/opencode/workspace".to_string(),
+            ]
         );
-        println!();
-        println!(
-            "{}",
-            style("Note: Restart the container for changes to take effect.").dim()
+        assert_eq!(
+            outcome,
+            MountUpsertOutcome::Replaced {
+                replaced_mounts: vec![
+                    ParsedMount::parse("/host/old:/home/opencode/workspace").unwrap(),
+                ],
+            }
         );
     }
 
-    Ok(())
+    #[test]
+    fn upsert_mount_by_target_replaces_multiple_stale_targets() {
+        let existing = vec![
+            "/host/old1:/home/opencode/workspace".to_string(),
+            "/host/cache:/home/opencode/.cache/opencode".to_string(),
+            "/host/old2:/home/opencode/workspace:ro".to_string(),
+        ];
+        let parsed = ParsedMount::parse("/host/new:/home/opencode/workspace").unwrap();
+
+        let (updated, outcome) =
+            upsert_mount_by_target(&existing, "/host/new:/home/opencode/workspace", &parsed);
+
+        assert_eq!(
+            updated,
+            vec![
+                "/host/cache:/home/opencode/.cache/opencode".to_string(),
+                "/host/new:/home/opencode/workspace".to_string(),
+            ]
+        );
+        assert_eq!(
+            outcome,
+            MountUpsertOutcome::Replaced {
+                replaced_mounts: vec![
+                    ParsedMount::parse("/host/old1:/home/opencode/workspace").unwrap(),
+                    ParsedMount::parse("/host/old2:/home/opencode/workspace:ro").unwrap(),
+                ],
+            }
+        );
+    }
 }