Fix /open-file WSL path joining (warpdotdev#9322)

## Description
Fixes warpdotdev#9191.

`/open-file` now resolves the shell argument with the active shell path
encoding before converting it to a host `PathBuf`. This preserves Unix
separators for WSL paths like `/home/ubuntu/subdir/test.txt` instead of
joining the final component with a Windows separator.

The change keeps line and column parsing intact and adds a regression
test for WSL-style relative paths.

## Testing
- `cargo fmt -- --check`
- `git diff --check`
- Attempted `cargo test -p warp --features local_fs
open_file_command_uses_shell_separators_for_wsl_paths`, but the local
Cargo build failed before compiling the app because `warpui` could not
execute Apple's `metal` compiler (`xcodebuild -downloadComponent
MetalToolchain` is required on this machine).

## Server API dependencies
None.

## Agent Mode
- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mode

## Changelog Entries for Stable
CHANGELOG-BUG-FIX: Fixed `/open-file` handling for relative WSL paths so
Unix separators are preserved before opening files on Windows hosts.

Co-Authored-By: Warp <agent@warp.dev>

---------

Co-authored-by: Warp <agent@warp.dev>
Co-authored-by: Andy <8334252+acarl005@users.noreply.github.com>

Author: 3 people

app/src/terminal/input/slash_commands/mod.rs

@@ -7,11 +7,16 @@ pub use cloud_mode_v2_view::{CloudModeV2SlashCommandView, Section as CloudModeV2
 pub use data_source::*;
 pub use view::{CloseReason, InlineSlashCommandView, SlashCommandsEvent};
 
+#[cfg(feature = "local_fs")]
+use std::path::PathBuf;
+
 use ai::skills::SkillReference;
 use warp_core::features::FeatureFlag;
 use warp_core::send_telemetry_from_ctx;
 use warp_core::ui::appearance::Appearance;
 use warp_core::ui::theme::AnsiColorIdentifier;
+#[cfg(feature = "local_fs")]
+use warp_util::path::{CleanPathResult, LineAndColumnArg};
 use warpui::clipboard::ClipboardContent;
 use warpui::{SingletonEntity, ViewContext};
 
@@ -43,6 +48,8 @@ use crate::terminal::input::slash_command_model::{
 use crate::terminal::input::{
     CompletionsTrigger, Event, Input, InputAction, InputSuggestionsMode, UserQueryMenuAction,
 };
+#[cfg(feature = "local_fs")]
+use crate::terminal::model::session::Session;
 use crate::terminal::view::TerminalAction;
 use crate::ui_components::color_dot;
 use crate::view_components::DismissibleToast;
@@ -109,6 +116,33 @@ impl SlashCommandTrigger {
     }
 }
 
+#[cfg(feature = "local_fs")]
+fn open_file_command_path(
+    session: &Session,
+    current_dir: &str,
+    raw_arg: &str,
+) -> (PathBuf, Option<LineAndColumnArg>) {
+    let parsed_path = CleanPathResult::with_line_and_column_number(raw_arg.trim());
+    // The argument may contain shell-escaped characters (e.g. `\ ` for spaces) from auto-suggest.
+    // Unescape them so the path matches the actual filesystem entry.
+    let unescaped_path = session.shell_family().unescape(&parsed_path.path);
+    // Expand `~` to the user's home directory.
+    let expanded_path = shellexpand::tilde(&unescaped_path);
+
+    let shell_path = session
+        .convert_directory_to_typed_path_buf(current_dir.to_owned())
+        .join(session.convert_directory_to_typed_path_buf(expanded_path.into_owned()))
+        .normalize();
+    let file_path = session
+        .maybe_convert_to_native_path(&shell_path.to_path())
+        .unwrap_or_else(|err| {
+            log::warn!("unable to convert /open-file path to native path: {err:?}");
+            PathBuf::from(shell_path.to_string_lossy().into_owned())
+        });
+
+    (file_path, parsed_path.line_and_column_num)
+}
+
 impl Input {
     pub(super) fn select_slash_command(
         &mut self,
@@ -525,9 +559,6 @@ impl Input {
                 #[cfg(feature = "local_fs")]
                 match argument {
                     Some(args) if !args.is_empty() => {
-                        use shellexpand::tilde;
-                        use warp_util::path::CleanPathResult;
-
                         let Some(session_id) = self.active_block_session_id() else {
                             return false;
                         };
@@ -555,20 +586,14 @@ impl Input {
                             .active_block_metadata
                             .as_ref()
                             .and_then(|metadata| metadata.current_working_directory())
-                            .map(std::path::PathBuf::from);
+                            .map(str::to_owned);
 
                         let Some(current_dir) = current_dir else {
                             return false;
                         };
 
-                        let parsed_path = CleanPathResult::with_line_and_column_number(args.trim());
-                        // The argument may contain shell-escaped characters (e.g. `\ ` for
-                        // spaces) from auto-suggest. Unescape them so the path matches the
-                        // actual filesystem entry.
-                        let unescaped_path = session.shell_family().unescape(&parsed_path.path);
-                        // Expand `~` to the user's home directory.
-                        let expanded_path = tilde(&unescaped_path);
-                        let file_path = current_dir.join(&*expanded_path);
+                        let (file_path, line_col) =
+                            open_file_command_path(&session, &current_dir, args);
 
                         match std::fs::metadata(&file_path) {
                             Ok(metadata) if metadata.is_file() => {
@@ -577,7 +602,7 @@ impl Input {
                                 ctx.dispatch_typed_action(&TerminalAction::OpenCodeInWarp {
                                     path: file_path,
                                     layout: external_editor::settings::EditorLayout::SplitPane,
-                                    line_col: parsed_path.line_and_column_num,
+                                    line_col,
                                 });
                             }
                             Ok(_) => {
@@ -1219,6 +1244,68 @@ impl Input {
     }
 }
 
+#[cfg(all(test, feature = "local_fs", windows))]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    use crate::terminal::model::session::command_executor::testing::TestCommandExecutor;
+    use crate::terminal::model::session::SessionInfo;
+    use crate::terminal::shell::ShellType;
+    use crate::terminal::ShellLaunchData;
+
+    fn wsl_session() -> Session {
+        Session::new(
+            SessionInfo::new_for_test().with_shell_type(ShellType::Bash),
+            Arc::new(TestCommandExecutor::default()),
+        )
+        .with_shell_launch_data(ShellLaunchData::WSL {
+            distro: "Ubuntu".to_owned(),
+        })
+    }
+
+    #[test]
+    fn open_file_command_converts_wsl_paths_to_host_paths() {
+        let session = wsl_session();
+        let cases = [
+            (
+                "/home/ubuntu",
+                "subdir/test.txt",
+                r"\\WSL$\Ubuntu\home\ubuntu\subdir\test.txt",
+                None,
+            ),
+            (
+                "/home/ubuntu/project",
+                "../test.txt",
+                r"\\WSL$\Ubuntu\home\ubuntu\test.txt",
+                None,
+            ),
+            (
+                "/home/ubuntu",
+                "subdir/file\\ name.txt",
+                r"\\WSL$\Ubuntu\home\ubuntu\subdir\file name.txt",
+                None,
+            ),
+            (
+                "/home/ubuntu",
+                "subdir/test.txt:4:2",
+                r"\\WSL$\Ubuntu\home\ubuntu\subdir\test.txt",
+                Some(LineAndColumnArg {
+                    line_num: 4,
+                    column_num: Some(2),
+                }),
+            ),
+        ];
+
+        for (current_dir, raw_arg, expected_path, expected_line_col) in cases {
+            let (path, line_col) = open_file_command_path(&session, current_dir, raw_arg);
+
+            assert_eq!(path, PathBuf::from(expected_path));
+            assert_eq!(line_col, expected_line_col);
+        }
+    }
+}
+
 /// Returns true when the conversation with `conversation_id` is associated with a cloud Oz
 /// `AmbientAgentTask`. Used as the defensive runtime gate for `/continue-locally` so a
 /// keybinding-triggered execution can't fall through onto a non-cloud-Oz conversation after