ptn 0.3.2__py3-none-any.whl → 0.4.6__py3-none-any.whl

porterminal/infrastructure/cloudflared.py

@@ -17,6 +17,13 @@ console = Console()
 class CloudflaredInstaller:
     """Platform-specific cloudflared installer."""
 
+    @staticmethod
+    def _add_to_path(path: str | Path) -> None:
+        """Add directory to PATH for current process."""
+        path_str = str(path)
+        os.environ["PATH"] = path_str + os.pathsep + os.environ.get("PATH", "")
+        console.print(f"[dim]Added to PATH: {path_str}[/dim]")
+
     @staticmethod
     def is_installed() -> bool:
         """Check if cloudflared is installed."""
@@ -91,8 +98,7 @@ class CloudflaredInstaller:
                     # Try to find and add to PATH for current session
                     install_path = CloudflaredInstaller._find_cloudflared_windows()
                     if install_path:
-                        os.environ["PATH"] = install_path + os.pathsep + os.environ.get("PATH", "")
-                        console.print(f"[dim]Added to PATH: {install_path}[/dim]")
+                        CloudflaredInstaller._add_to_path(install_path)
                     # Return True regardless - winget succeeded, may just need shell restart
                     return True
             except (subprocess.TimeoutExpired, OSError) as e:
@@ -119,7 +125,7 @@ class CloudflaredInstaller:
 
             exe_path = install_dir / "cloudflared.exe"
             if exe_path.exists():
-                os.environ["PATH"] = str(install_dir) + os.pathsep + os.environ.get("PATH", "")
+                CloudflaredInstaller._add_to_path(install_dir)
                 console.print(f"[green]✓ Installed to {install_dir}[/green]")
                 return True
 
@@ -203,10 +209,7 @@ class CloudflaredInstaller:
                         # Try to find and add to PATH
                         install_path = CloudflaredInstaller._find_cloudflared_unix()
                         if install_path:
-                            os.environ["PATH"] = (
-                                install_path + os.pathsep + os.environ.get("PATH", "")
-                            )
-                            console.print(f"[dim]Added to PATH: {install_path}[/dim]")
+                            CloudflaredInstaller._add_to_path(install_path)
                         # Return True regardless - package manager succeeded
                         return True
                 except (subprocess.TimeoutExpired, OSError) as e:
@@ -226,7 +229,7 @@ class CloudflaredInstaller:
             os.chmod(bin_path, 0o755)
 
             # Add to PATH for this session
-            os.environ["PATH"] = str(install_dir) + os.pathsep + os.environ.get("PATH", "")
+            CloudflaredInstaller._add_to_path(install_dir)
             console.print(f"[green]✓ Installed to {bin_path}[/green]")
             return True
 
@@ -257,8 +260,7 @@ class CloudflaredInstaller:
                     # Try to find and add to PATH
                     install_path = CloudflaredInstaller._find_cloudflared_unix()
                     if install_path:
-                        os.environ["PATH"] = install_path + os.pathsep + os.environ.get("PATH", "")
-                        console.print(f"[dim]Added to PATH: {install_path}[/dim]")
+                        CloudflaredInstaller._add_to_path(install_path)
                     # Return True regardless - Homebrew succeeded
                     return True
             except (subprocess.TimeoutExpired, OSError) as e:
@@ -289,7 +291,7 @@ class CloudflaredInstaller:
             bin_path = install_dir / "cloudflared"
             if bin_path.exists():
                 os.chmod(bin_path, 0o755)
-                os.environ["PATH"] = str(install_dir) + os.pathsep + os.environ.get("PATH", "")
+                CloudflaredInstaller._add_to_path(install_dir)
                 console.print(f"[green]✓ Installed to {bin_path}[/green]")
                 return True
 

porterminal/infrastructure/config/shell_detector.py

@@ -21,6 +21,9 @@ class ShellDetector:
     def detect_shells(self) -> list[ShellCommand]:
         """Auto-detect available shells.
 
+        Detects platform-specific shells and includes the user's $SHELL
+        if it's not already in the list (supports any shell).
+
         Returns:
             List of detected shell configurations.
         """
@@ -39,6 +42,12 @@ class ShellDetector:
                     )
                 )
 
+        # Include user's $SHELL if not already detected (supports unknown shells)
+        user_shell = self._create_shell_from_env()
+        if user_shell and not any(s.id == user_shell.id for s in shells):
+            # Insert at beginning so user's preferred shell is first
+            shells.insert(0, user_shell)
+
         return shells
 
     def get_default_shell_id(self) -> str:
@@ -52,11 +61,19 @@ class ShellDetector:
     def _get_platform_candidates(self) -> list[tuple[str, str, str, list[str]]]:
         """Get shell candidates for current platform.
 
+        On Windows, discovers shells from:
+        - Windows Terminal profiles (includes WSL distros)
+        - Hardcoded common shells (PowerShell, CMD, Git Bash)
+        - Visual Studio Developer shells
+
+        Note: WSL distros are detected from Windows Terminal profiles only.
+        We don't probe inside WSL for individual shells to avoid crossing
+        environment boundaries.
+
         Returns:
             List of (name, id, command, args) tuples.
         """
         if sys.platform == "win32":
-            # Get Windows Terminal profiles first, then hardcoded defaults
             wt_profiles = self._get_windows_terminal_profiles()
             hardcoded = [
                 ("PS 7", "pwsh", "pwsh.exe", ["-NoLogo"]),
@@ -65,15 +82,18 @@ class ShellDetector:
                 ("WSL", "wsl", "wsl.exe", []),
                 ("Git Bash", "gitbash", r"C:\Program Files\Git\bin\bash.exe", ["--login"]),
             ]
-            # Merge WT profiles with hardcoded (dedupe by command)
             merged = self._merge_candidates(wt_profiles, hardcoded)
-            # Add VS dev shells (no deduplication - they're unique due to args)
             vs_shells = self._get_visual_studio_shells()
             return merged + vs_shells
         return [
             ("Bash", "bash", "bash", ["--login"]),
             ("Zsh", "zsh", "zsh", ["--login"]),
             ("Fish", "fish", "fish", []),
+            ("Nu", "nu", "nu", []),
+            ("Ion", "ion", "ion", []),
+            ("Dash", "dash", "dash", []),
+            ("Ksh", "ksh", "ksh", ["--login"]),
+            ("Tcsh", "tcsh", "tcsh", []),
             ("Sh", "sh", "sh", []),
         ]
 
@@ -109,8 +129,20 @@ class ShellDetector:
         for profile in profile_list:
             name = profile.get("name", "")
             commandline = profile.get("commandline", "")
+            source = profile.get("source", "")
 
-            if not name or not commandline:
+            if not name:
+                continue
+
+            # Handle WSL distro profiles (they use source instead of commandline)
+            if source == "Windows.Terminal.Wsl" and not commandline:
+                # Use wsl.exe -d <distro> to launch the specific distro
+                shell_id = self._slugify(name)
+                short_name = self._abbreviate_name(name)
+                profiles.append((short_name, shell_id, "wsl.exe", ["-d", name]))
+                continue
+
+            if not commandline:
                 continue
 
             # Parse commandline into command and args
@@ -149,25 +181,20 @@ class ShellDetector:
 
         try:
             result = subprocess.run(
-                [
-                    str(vswhere),
-                    "-all",
-                    "-prerelease",
-                    "-property",
-                    "installationPath",
-                ],
+                [str(vswhere), "-all", "-prerelease", "-format", "json"],
                 capture_output=True,
                 text=True,
                 timeout=5,
             )
-            vs_paths = [p.strip() for p in result.stdout.strip().split("\n") if p.strip()]
-        except (subprocess.TimeoutExpired, OSError) as e:
+            vs_installs = json.loads(result.stdout) if result.stdout.strip() else []
+        except (subprocess.TimeoutExpired, OSError, json.JSONDecodeError) as e:
             logger.warning("Failed to run vswhere: %s", e)
             return []
 
         shells = []
-        for vs_path in vs_paths:
-            vs_path = Path(vs_path)
+        for vs_info in vs_installs:
+            vs_path = Path(vs_info.get("installationPath", ""))
+            instance_id = vs_info.get("instanceId", "")
             # Extract VS version and edition from path
             # e.g., "C:\Program Files\Microsoft Visual Studio\2022\Community"
             edition = vs_path.name  # Community, Professional, Enterprise
@@ -188,18 +215,32 @@ class ShellDetector:
                     )
                 )
 
-            # Developer PowerShell
-            launch_ps = vs_path / "Common7" / "Tools" / "Launch-VsDevShell.ps1"
-            if launch_ps.exists():
+            # Developer PowerShell - find DevShell.dll (location varies by VS version)
+            devshell_dll = None
+            for dll_path in [
+                vs_path / "Common7" / "Tools" / "Microsoft.VisualStudio.DevShell.dll",
+                vs_path
+                / "Common7"
+                / "Tools"
+                / "vsdevshell"
+                / "Microsoft.VisualStudio.DevShell.dll",
+            ]:
+                if dll_path.exists():
+                    devshell_dll = dll_path
+                    break
+
+            if devshell_dll and instance_id:
                 name = f"Dev PS {year}"
                 shell_id = f"devps-{year}-{edition.lower()}"
-                # powershell.exe -NoExit -Command "& 'path\to\Launch-VsDevShell.ps1'"
+                # Use forward slashes to avoid backslash escape issues (PowerShell accepts both)
+                dll_str = str(devshell_dll).replace("\\", "/")
+                cmd = f"Import-Module '{dll_str}'; Enter-VsDevShell {instance_id} -SkipAutomaticLocation"
                 shells.append(
                     (
                         name,
                         shell_id,
                         "powershell.exe",
-                        ["-NoExit", "-Command", f"& '{launch_ps}'"],
+                        ["-NoExit", "-Command", cmd],
                     )
                 )
 
@@ -405,16 +446,23 @@ class ShellDetector:
         """Get shell ID from user's $SHELL environment variable.
 
         Returns:
-            Shell ID if $SHELL is set and matches a known shell, None otherwise.
+            Shell ID if $SHELL is set and valid, None otherwise.
+            For unknown shells, returns the executable name as the ID.
         """
         shell_path = os.environ.get("SHELL", "")
         if not shell_path:
             return None
 
+        path = Path(shell_path)
+
+        # Validate shell exists
+        if not path.exists() and not shutil.which(shell_path):
+            return None
+
         # Extract shell name from path (e.g., /usr/bin/fish -> fish)
-        shell_name = Path(shell_path).name.lower()
+        shell_name = path.name.lower()
 
-        # Map common shell names to IDs
+        # Map common shell names to canonical IDs (for consistency)
         shell_map = {
             "bash": "bash",
             "zsh": "zsh",
@@ -422,4 +470,45 @@ class ShellDetector:
             "sh": "sh",
         }
 
-        return shell_map.get(shell_name)
+        # Return known ID or use executable name for unknown shells
+        return shell_map.get(shell_name, shell_name)
+
+    def _create_shell_from_env(self) -> ShellCommand | None:
+        """Create a ShellCommand from user's $SHELL environment variable.
+
+        Returns:
+            ShellCommand if $SHELL is set and valid, None otherwise.
+        """
+        shell_path = os.environ.get("SHELL", "")
+        if not shell_path:
+            return None
+
+        path = Path(shell_path)
+
+        # Validate shell exists
+        if not path.exists() and not shutil.which(shell_path):
+            return None
+
+        shell_name = path.name.lower()
+
+        # Known shells with their display names and args
+        known_shells = {
+            "bash": ("Bash", ["--login"]),
+            "zsh": ("Zsh", ["--login"]),
+            "fish": ("Fish", []),
+            "sh": ("Sh", []),
+        }
+
+        if shell_name in known_shells:
+            display_name, args = known_shells[shell_name]
+        else:
+            # Unknown shell - use capitalized name, no special args
+            display_name = shell_name.capitalize()
+            args = []
+
+        return ShellCommand(
+            id=shell_name,
+            name=display_name,
+            command=shell_path,
+            args=tuple(args),
+        )

porterminal/infrastructure/repositories/in_memory_session.py

@@ -38,10 +38,7 @@ class InMemorySessionRepository(SessionRepository[PTYHandle]):
         user_id = str(session.user_id)
 
         self._sessions[session_id] = session
-
-        if user_id not in self._user_sessions:
-            self._user_sessions[user_id] = set()
-        self._user_sessions[user_id].add(session_id)
+        self._user_sessions.setdefault(user_id, set()).add(session_id)
 
     def remove(self, session_id: SessionId) -> Session[PTYHandle] | None:
         """Remove and return a session."""

porterminal/infrastructure/repositories/in_memory_tab.py

@@ -44,16 +44,8 @@ class InMemoryTabRepository(TabRepository):
         session_id = str(tab.session_id)
 
         self._tabs[tab_id] = tab
-
-        # Index by user
-        if user_id not in self._user_tabs:
-            self._user_tabs[user_id] = set()
-        self._user_tabs[user_id].add(tab_id)
-
-        # Index by session
-        if session_id not in self._session_tabs:
-            self._session_tabs[session_id] = set()
-        self._session_tabs[session_id].add(tab_id)
+        self._user_tabs.setdefault(user_id, set()).add(tab_id)
+        self._session_tabs.setdefault(session_id, set()).add(tab_id)
 
     def update(self, tab: Tab) -> None:
         """Update an existing tab (name, last_accessed)."""

porterminal/pty/env.py

@@ -1,94 +1,32 @@
-"""Environment variable sanitization for PTY processes."""
+"""Environment variable sanitization for PTY processes.
+
+This module re-exports the environment rules from the domain layer
+and provides the build_safe_environment() function for PTY spawning.
+"""
 
 import os
 
-# Environment variables to allowlist (safe to pass to shell)
-SAFE_ENV_VARS: frozenset[str] = frozenset(
-    {
-        # System paths
-        "PATH",
-        "PATHEXT",
-        "SYSTEMROOT",
-        "WINDIR",
-        "TEMP",
-        "TMP",
-        "COMSPEC",
-        # User directories
-        "HOME",
-        "USERPROFILE",
-        "HOMEDRIVE",
-        "HOMEPATH",
-        "LOCALAPPDATA",
-        "APPDATA",
-        "PROGRAMFILES",
-        "PROGRAMFILES(X86)",
-        "COMMONPROGRAMFILES",
-        # System info
-        "COMPUTERNAME",
-        "USERNAME",
-        "USERDOMAIN",
-        "OS",
-        "PROCESSOR_ARCHITECTURE",
-        "NUMBER_OF_PROCESSORS",
-        # Terminal
-        "TERM",
-        # Locale settings for proper text rendering
-        "LANG",
-        "LC_ALL",
-        "LC_CTYPE",
-    }
+from porterminal.domain.values.environment_rules import (
+    DEFAULT_BLOCKED_VARS as BLOCKED_ENV_VARS,
 )
-
-# Environment variables to explicitly block (secrets)
-BLOCKED_ENV_VARS: frozenset[str] = frozenset(
-    {
-        # AWS
-        "AWS_ACCESS_KEY_ID",
-        "AWS_SECRET_ACCESS_KEY",
-        "AWS_SESSION_TOKEN",
-        # Azure
-        "AZURE_CLIENT_SECRET",
-        "AZURE_CLIENT_ID",
-        # Git/GitHub/GitLab
-        "GH_TOKEN",
-        "GITHUB_TOKEN",
-        "GITLAB_TOKEN",
-        # Package managers
-        "NPM_TOKEN",
-        # AI APIs
-        "ANTHROPIC_API_KEY",
-        "OPENAI_API_KEY",
-        "GOOGLE_API_KEY",
-        # Payment
-        "STRIPE_SECRET_KEY",
-        # Database
-        "DATABASE_URL",
-        "DB_PASSWORD",
-        # Generic secrets
-        "SECRET_KEY",
-        "API_KEY",
-        "API_SECRET",
-        "PRIVATE_KEY",
-    }
+from porterminal.domain.values.environment_rules import (
+    DEFAULT_SAFE_VARS as SAFE_ENV_VARS,
 )
 
+# Re-export for backward compatibility
+__all__ = ["SAFE_ENV_VARS", "BLOCKED_ENV_VARS", "build_safe_environment"]
+
 
 def build_safe_environment() -> dict[str, str]:
     """Build a sanitized environment for the PTY.
 
+    Uses allowlist approach - only SAFE_ENV_VARS are copied,
+    so BLOCKED_ENV_VARS can never be included.
+
     Returns:
         Dictionary of safe environment variables.
     """
-    safe_env: dict[str, str] = {}
-
-    # Copy only allowed variables
-    for var in SAFE_ENV_VARS:
-        if var in os.environ:
-            safe_env[var] = os.environ[var]
-
-    # Ensure blocked vars are not included (defense in depth)
-    for var in BLOCKED_ENV_VARS:
-        safe_env.pop(var, None)
+    safe_env = {var: os.environ[var] for var in SAFE_ENV_VARS if var in os.environ}
 
     # Set custom variables for audit trail
     safe_env["TERM"] = "xterm-256color"

porterminal/pty/manager.py

@@ -5,6 +5,8 @@ import shutil
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from porterminal.domain.values import MAX_COLS, MAX_ROWS, MIN_COLS, MIN_ROWS
+
 from .env import build_safe_environment
 from .protocol import PTYBackend
 
@@ -43,8 +45,8 @@ class SecurePTYManager:
         """
         self._backend = backend
         self.shell_config = shell_config
-        self.cols = max(40, min(cols, 500))
-        self.rows = max(10, min(rows, 200))
+        self.cols = max(MIN_COLS, min(cols, MAX_COLS))
+        self.rows = max(MIN_ROWS, min(rows, MAX_ROWS))
         self.cwd = cwd
         self._closed = False
 
@@ -133,8 +135,8 @@ class SecurePTYManager:
         if self._closed:
             return
 
-        cols = max(40, min(cols, 500))
-        rows = max(10, min(rows, 200))
+        cols = max(MIN_COLS, min(cols, MAX_COLS))
+        rows = max(MIN_ROWS, min(rows, MAX_ROWS))
 
         try:
             self._backend.resize(rows, cols)