Handle Cursor editor on Windows WSL and add tests for this

Signed-off-by: Oliver Holworthy <[email protected]>

Author: oliverholworthy

nemo_run/devspace/editor.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 import os
+import platform
 import shutil
 from pathlib import Path
 
@@ -22,11 +23,92 @@
 from nemo_run.core.frontend.console.api import CONSOLE
 
 
+def find_editor_executable(base_executable_name):
+    """Find the proper executable path for an editor, especially in WSL environments.
+
+    Args:
+        base_executable_name (str): The base name of the executable (e.g., 'code', 'cursor')
+
+    Returns:
+        str: The path to the executable
+
+    Raises:
+        ValueError: If the editor is not supported
+        EnvironmentError: If the editor is not installed or Windows executable not found in WSL
+    """
+    # Define supported editors
+    SUPPORTED_EDITORS = {
+        "code": {
+            "display_name": "VS Code",
+            "download_url": "https://code.visualstudio.com/",
+            "exe_name": "Code.exe",
+        },
+        "cursor": {
+            "display_name": "Cursor",
+            "download_url": "https://www.cursor.com/",
+            "exe_name": "Cursor.exe",
+        },
+        # Add new editors here
+    }
+
+    # Check if the editor is supported
+    if base_executable_name not in SUPPORTED_EDITORS:
+        supported_list = ", ".join(SUPPORTED_EDITORS.keys())
+        raise ValueError(
+            f"Editor '{base_executable_name}' is not supported. "
+            f"Supported editors are: {supported_list}"
+        )
+
+    editor_config = SUPPORTED_EDITORS[base_executable_name]
+
+    # Check if the editor is installed
+    executable_path = shutil.which(base_executable_name)
+    if not executable_path:
+        raise EnvironmentError(
+            f"{editor_config['display_name']} is not installed. "
+            f"Please install it from {editor_config['download_url']}"
+        )
+
+    # Default editor command is the base executable
+    editor_cmd = base_executable_name
+
+    # If we're running in WSL, find the Windows executable
+    if os.name == "posix" and "WSL" in os.uname().release:
+        # Start from the executable directory
+        current_path = Path(executable_path).parent
+        exe_found = False
+
+        # Walk up to 5 levels to find the Windows .exe
+        for _ in range(5):
+            potential_exe = current_path / editor_config["exe_name"]
+            if potential_exe.exists():
+                editor_cmd = potential_exe.as_posix().replace(" ", "\\ ")
+                exe_found = True
+                break
+            # Move up one directory
+            parent_path = current_path.parent
+            if parent_path == current_path:  # Reached root
+                break
+            current_path = parent_path
+
+        # Raise an error if we couldn't find the Windows executable in WSL
+        if not exe_found:
+            raise EnvironmentError(
+                f"Running in WSL but couldn't find {editor_config['exe_name']} in the "
+                f"directory structure. For proper WSL integration, ensure {editor_config['display_name']} "
+                f"is installed in Windows and properly configured for WSL. "
+                f"See the documentation for {editor_config['display_name']} WSL integration."
+            )
+
+    return editor_cmd
+
+
 def launch_editor(tunnel: str, path: str):
     """Launch a code editor for the specified SSH tunnel.
 
     Args:
         tunnel (str): The name of the SSH tunnel.
+        path (str): The path to open in the editor.
 
     Raises:
         EnvironmentError: If the specified editor is not installed.
@@ -42,26 +124,15 @@ def launch_editor(tunnel: str, path: str):
 
     if editor != "none":
         CONSOLE.rule(f"[bold green]Launching {editor}", characters="*")
-        if editor == "code":
-            if not shutil.which("code"):
-                raise EnvironmentError(
-                    "VS Code is not installed. Please install it from https://code.visualstudio.com/"
-                )
-
-            code_cli = "code"
-
-            # If we're running in WSL. Launch code from the executable directly.
-            # This avoids the code launch script activating the WSL remote extension
-            # which enables us to specify the ssh tunnel as the remote
-            if os.name == "posix" and "WSL" in os.uname().release:
-                code_cli = (
-                    (Path(shutil.which("code")).parent.parent / "Code.exe")
-                    .as_posix()
-                    .replace(" ", "\\ ")
-                )
-
-            cmd = f"{code_cli} --new-window --remote ssh-remote+tunnel.{tunnel} {path}"
-            CONSOLE.print(cmd)
-            local.run(f"NEMO_EDITOR=vscode {cmd}")
-        elif editor == "cursor":
-            local.run(f"NEMO_EDITOR=cursor cursor --remote ssh-remote+tunnel.{tunnel} {path}")
+
+        # Find the proper executable
+        editor_cmd = find_editor_executable(editor)
+
+        # Execute the editor command
+        cmd = f"{editor_cmd} --new-window --remote ssh-remote+tunnel.{tunnel} {path}"
+        CONSOLE.print(cmd)
+
+        if platform.system() == "Windows":
+            local.run(f"set NEMO_EDITOR={editor} && {cmd}")
+        else:
+            local.run(f"NEMO_EDITOR={editor} {cmd}")

test/devspace/test_editor.py

@@ -0,0 +1,163 @@
+import os
+import platform
+import subprocess
+import pytest
+from pathlib import Path
+import shutil
+from unittest.mock import patch, MagicMock
+
+from nemo_run.devspace.editor import find_editor_executable
+
+
+class TestFindEditorExecutable:
+    def test_unsupported_editor(self):
+        """Test that unsupported editors raise ValueError."""
+        with pytest.raises(ValueError, match="not supported"):
+            find_editor_executable("unsupported_editor")
+
+    def test_editor_not_installed(self, monkeypatch):
+        """Test that missing editors raise EnvironmentError."""
+        # Monkeypatch shutil.which to return None (simulate editor not found)
+        monkeypatch.setattr(shutil, "which", lambda x: None)
+
+        with pytest.raises(EnvironmentError, match="is not installed"):
+            find_editor_executable("code")
+
+        with pytest.raises(EnvironmentError, match="is not installed"):
+            find_editor_executable("cursor")
+
+    def test_non_wsl_environment(self, tmp_path, monkeypatch):
+        """Test editor detection in non-WSL environment using real file."""
+        # Create a fake editor executable in a temp directory
+        bin_dir = tmp_path / "bin"
+        bin_dir.mkdir()
+
+        code_exec = bin_dir / "code"
+        code_exec.touch(mode=0o755)  # Make it executable
+
+        cursor_exec = bin_dir / "cursor"
+        cursor_exec.touch(mode=0o755)
+
+        # Add our temp directory to PATH
+        old_path = os.environ.get("PATH", "")
+        os.environ["PATH"] = f"{bin_dir}:{old_path}"
+
+        try:
+            # Monkeypatch os.uname to return a non-WSL environment
+            if hasattr(os, "uname"):  # Skip on Windows
+                monkeypatch.setattr(os, "uname", lambda: MagicMock(release="Linux 5.10.0"))
+
+            # Test with actual executables in path
+            assert find_editor_executable("code") == "code"
+            assert find_editor_executable("cursor") == "cursor"
+        finally:
+            # Restore PATH
+            os.environ["PATH"] = old_path
+
+    @pytest.mark.skipif(
+        platform.system() == "Windows", reason="WSL tests only relevant on Unix systems"
+    )
+    def test_wsl_environment(self, tmp_path, monkeypatch):
+        """Test editor detection in WSL environment."""
+        # Create directory structure with both Linux and "Windows" executables
+        bin_dir = tmp_path / "bin"
+        bin_dir.mkdir()
+
+        # Linux executables
+        code_exec = bin_dir / "code"
+        code_exec.touch(mode=0o755)
+
+        cursor_exec = bin_dir / "cursor"
+        cursor_exec.touch(mode=0o755)
+
+        # Windows .exe files at various levels
+        exe_dir = tmp_path / "winbin"
+        exe_dir.mkdir()
+        code_exe = exe_dir / "Code.exe"
+        code_exe.touch(mode=0o755)
+
+        cursor_exe_dir = tmp_path / "apps" / "cursor"
+        cursor_exe_dir.mkdir(parents=True)
+        cursor_exe = cursor_exe_dir / "Cursor.exe"
+        cursor_exe.touch(mode=0o755)
+
+        # Add our temp directory to PATH
+        old_path = os.environ.get("PATH", "")
+        os.environ["PATH"] = f"{bin_dir}:{old_path}"
+
+        try:
+            # Mock WSL environment
+            monkeypatch.setattr(os, "name", "posix")
+            monkeypatch.setattr(os, "uname", lambda: MagicMock(release="Microsoft-WSL"))
+
+            # Test cases with different configurations
+
+            # 1. Case where we find the .exe file at a specific location
+            with monkeypatch.context() as m:
+
+                def mock_which(cmd):
+                    if cmd == "code":
+                        return str(code_exec)
+                    elif cmd == "cursor":
+                        return str(cursor_exec)
+                    return None
+
+                # Only need to mock exists for the specific paths we want to test
+                original_exists = Path.exists
+
+                def mock_exists(self):
+                    if (
+                        self == code_exe
+                        or self.name == "Code.exe"
+                        and str(self).startswith(str(tmp_path))
+                    ):
+                        return True
+                    if (
+                        self == cursor_exe
+                        or self.name == "Cursor.exe"
+                        and str(self).startswith(str(tmp_path))
+                    ):
+                        return True
+                    return original_exists(self)
+
+                m.setattr(shutil, "which", mock_which)
+                m.setattr(Path, "exists", mock_exists)
+
+                # Test code with .exe available
+                result = find_editor_executable("code")
+                assert "Code.exe" in result
+
+                # Test cursor with .exe available
+                result = find_editor_executable("cursor")
+                assert "Cursor.exe" in result
+
+            # 2. Case where we don't find the .exe file (should now raise error)
+            with monkeypatch.context() as m:
+
+                def mock_which(cmd):
+                    if cmd == "code":
+                        return str(code_exec)
+                    elif cmd == "cursor":
+                        return str(cursor_exec)
+                    return None
+
+                # Make exists always return False for .exe files
+                def mock_exists(self):
+                    if ".exe" in str(self).lower():
+                        return False
+                    return original_exists(self)
+
+                m.setattr(shutil, "which", mock_which)
+                m.setattr(Path, "exists", mock_exists)
+
+                # Test code with no .exe available (should now raise error)
+                with pytest.raises(EnvironmentError, match="Running in WSL but couldn't find"):
+                    find_editor_executable("code")
+
+                # Test cursor with no .exe available (should now raise error)
+                with pytest.raises(EnvironmentError, match="Running in WSL but couldn't find"):
+                    find_editor_executable("cursor")
+
+        finally:
+            # Restore PATH
+            os.environ["PATH"] = old_path