fix: tighten remote SSH launch semantics

Author: michidk

README.md

@@ -244,6 +244,8 @@ vscli open /path/to/project         # open vscode in the specified directory
 
 The default behavior tries to detect whether the project is a [dev container](https://containers.dev/) project. If it is, it will launch the dev container instead - if not it will launch vscode normally.
 
+These behaviors apply to local workspaces. Remote SSH workspaces always open as remote folders; `--behavior detect` and `--behavior force-container` are not supported with `--remote-host`.
+
 You can change the launch behavior using the `--behavior` flag:
 
 ```sh
@@ -281,6 +283,7 @@ vscli recent --command cursor                   # open the selected project with
 vscli recent --behavior force-container         # force open the selected project in a dev container
 vscli recent --command cursor --behavior detect # open with cursor and detect if dev container should be used
 vscli recent --config .devcontainer/custom.json # open with a specific dev container config
+vscli recent --remote-host my-ec2               # reopen the selected project on a remembered remote host
 vscli recent -- --disable-gpu                   # pass additional arguments to the editor
 vscli recent --hide-instructions                # hide the keybinding instructions from the UI
 vscli recent --hide-info                        # hide additional information like strategy, command, args and dev container path
@@ -305,11 +308,12 @@ If you already use VS Code Remote SSH, you can point `vscli` at a remote host al
 
 ```sh
 vscli open --remote-host my-ec2 /home/ec2-user/app
-vscli open --remote-host my-ec2 --behavior force-container /home/ec2-user/app
 vscli recent --remote-host my-ec2
 ```
 
-This opens the workspace using a `vscode-remote://ssh-remote+...` folder URI. If the remote folder contains a `.devcontainer` setup, VS Code Dev Containers can reopen it in a container on that remote host.
+This opens the workspace using a `vscode-remote://ssh-remote+...` folder URI and stores the remote host in `recent` history so you can reopen it from the UI later.
+
+`vscli` does not manage dev containers on remote SSH hosts. Remote workspaces are opened as SSH folders; if the remote folder contains a `.devcontainer` setup, VS Code Dev Containers may offer to reopen it in a container afterward.
 
 #### Environment Variables
 

src/history.rs

@@ -229,3 +229,59 @@ impl Tracker {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Entry, History, Tracker};
+    use crate::launch::{Behavior, ContainerStrategy};
+    use chrono::Utc;
+    use std::ffi::OsString;
+    use std::path::PathBuf;
+
+    fn unique_test_path(name: &str) -> PathBuf {
+        let unique = format!(
+            "vscli-history-{name}-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        );
+        std::env::temp_dir().join(unique).join("history.json")
+    }
+
+    #[test]
+    fn tracker_store_and_load_preserve_remote_host_entries() {
+        let path = unique_test_path("remote-host");
+        let mut tracker = Tracker {
+            path: path.clone(),
+            history: History::default(),
+        };
+
+        tracker.history.upsert(Entry {
+            workspace_name: "workspace".to_string(),
+            dev_container_name: None,
+            config_name: None,
+            workspace_path: PathBuf::from("/home/dev/workspace"),
+            remote_host: Some("vscli-remote-test".to_string()),
+            config_path: None,
+            behavior: Behavior {
+                strategy: ContainerStrategy::ForceClassic,
+                args: vec![OsString::from("--reuse-window")],
+                command: "code".to_string(),
+            },
+            last_opened: Utc::now(),
+        });
+
+        tracker.store().unwrap();
+
+        let loaded = Tracker::load(path).unwrap();
+        let entries = loaded.history.into_entries();
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].remote_host.as_deref(), Some("vscli-remote-test"));
+        assert_eq!(
+            entries[0].behavior.strategy,
+            ContainerStrategy::ForceClassic
+        );
+    }
+}

src/main.rs

@@ -27,7 +27,7 @@ use crate::config_store::ConfigStore;
 use crate::history::{Entry, Tracker};
 
 use crate::{
-    launch::{Behavior, Setup},
+    launch::{Behavior, ContainerStrategy, Setup},
     opts::{LaunchArgs, Opts},
     workspace::Workspace,
 };
@@ -69,12 +69,35 @@ fn workspace_root_from_config(
         current = parent;
     };
     let path_abs = std::fs::canonicalize(path_arg).unwrap_or(path_arg.to_path_buf());
-    let sub = if path_abs.starts_with(&root) && path_abs != root {
-        path_abs.strip_prefix(&root).ok().map(Path::to_path_buf)
+    if path_abs.starts_with(&root) {
+        let sub = if path_abs == root {
+            None
+        } else {
+            path_abs.strip_prefix(&root).ok().map(Path::to_path_buf)
+        };
+        Ok((root, sub))
     } else {
-        None
-    };
-    Ok((root, sub))
+        Ok((path_abs, None))
+    }
+}
+
+fn resolve_strategy_for_remote(
+    remote_host: Option<&str>,
+    strategy: Option<ContainerStrategy>,
+) -> Result<ContainerStrategy> {
+    if remote_host.is_some() {
+        match strategy {
+            None | Some(ContainerStrategy::ForceClassic) => Ok(ContainerStrategy::ForceClassic),
+            Some(ContainerStrategy::Detect) => {
+                bail!("--behavior detect is not supported with --remote-host.")
+            }
+            Some(ContainerStrategy::ForceContainer) => {
+                bail!("--behavior force-container is not supported with --remote-host.")
+            }
+        }
+    } else {
+        Ok(strategy.unwrap_or_default())
+    }
 }
 
 fn open_workspace(
@@ -111,7 +134,7 @@ fn open_workspace(
     let remote_host = ws.remote_host.clone();
 
     let behavior = Behavior {
-        strategy: launch.behavior.unwrap_or_default(),
+        strategy: resolve_strategy_for_remote(ws.remote_host.as_deref(), launch.behavior)?,
         args: launch.args,
         command: launch.command.unwrap_or_else(|| "code".to_string()),
     };
@@ -167,6 +190,9 @@ fn reopen_recent(
             entry.behavior.args = launch.args;
         }
 
+        entry.behavior.strategy =
+            resolve_strategy_for_remote(remote_host.as_deref(), Some(entry.behavior.strategy))?;
+
         let resolved_config = if launch.config.is_some() {
             resolve_launch_config(launch.config.as_ref(), config_store)?
         } else {
@@ -279,3 +305,83 @@ fn log_format(
         writeln!(buf, "{}: {}", colored_level, record.args())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{resolve_strategy_for_remote, workspace_root_from_config};
+    use crate::launch::ContainerStrategy;
+    use std::path::{Path, PathBuf};
+
+    fn unique_test_dir(name: &str) -> PathBuf {
+        let unique = format!(
+            "vscli-main-{name}-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        );
+        std::env::temp_dir().join(unique)
+    }
+
+    #[test]
+    fn preserves_project_path_for_external_config() {
+        let root = unique_test_dir("external-config");
+        let config = root
+            .join("configs")
+            .join("rust-dev")
+            .join(".devcontainer")
+            .join("devcontainer.json");
+        let project = root.join("projects").join("my-app");
+
+        std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+        std::fs::create_dir_all(&project).unwrap();
+        std::fs::write(&config, "{}\n").unwrap();
+
+        let (workspace, subfolder) = workspace_root_from_config(&config, &project).unwrap();
+
+        assert_eq!(workspace, project.canonicalize().unwrap());
+        assert_eq!(subfolder, None);
+    }
+
+    #[test]
+    fn derives_subfolder_when_path_is_inside_config_workspace() {
+        let root = unique_test_dir("subfolder");
+        let workspace = root.join("workspace");
+        let config = workspace.join(".devcontainer").join("devcontainer.json");
+        let project = workspace.join("packages").join("api");
+
+        std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+        std::fs::create_dir_all(&project).unwrap();
+        std::fs::write(&config, "{}\n").unwrap();
+
+        let (resolved_workspace, subfolder) =
+            workspace_root_from_config(&config, &project).unwrap();
+
+        assert_eq!(resolved_workspace, workspace.canonicalize().unwrap());
+        assert_eq!(subfolder.as_deref(), Some(Path::new("packages/api")));
+    }
+
+    #[test]
+    fn remote_workspaces_default_to_force_classic() {
+        let strategy = resolve_strategy_for_remote(Some("remote-test"), None).unwrap();
+        assert_eq!(strategy, ContainerStrategy::ForceClassic);
+    }
+
+    #[test]
+    fn remote_workspaces_reject_detect_behavior() {
+        let err = resolve_strategy_for_remote(Some("remote-test"), Some(ContainerStrategy::Detect))
+            .unwrap_err();
+        assert!(err.to_string().contains("not supported with --remote-host"));
+    }
+
+    #[test]
+    fn remote_workspaces_reject_force_container_behavior() {
+        let err = resolve_strategy_for_remote(
+            Some("remote-test"),
+            Some(ContainerStrategy::ForceContainer),
+        )
+        .unwrap_err();
+        assert!(err.to_string().contains("not supported with --remote-host"));
+    }
+}