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

porterminal/cli/script_discovery.py

@@ -0,0 +1,112 @@
+"""Auto-discover project scripts for config initialization."""
+
+import json
+import re
+import tomllib
+from pathlib import Path
+
+# Pattern for safe script names (alphanumeric, hyphens, underscores only)
+_SAFE_NAME = re.compile(r"^[a-zA-Z0-9_-]+$")
+
+
+def _is_safe_name(name: str) -> bool:
+    """Check if script name contains only safe characters."""
+    return bool(_SAFE_NAME.match(name)) and len(name) <= 50
+
+
+def discover_scripts(cwd: Path | None = None) -> list[dict]:
+    """Discover project scripts in current directory.
+
+    Returns list of button configs: [{"label": "build", "send": "npm run build\\r", "row": 2}]
+    Only includes scripts explicitly defined in project files.
+    """
+    base = cwd or Path.cwd()
+    buttons = []
+
+    # Check each project type (only those with explicit scripts)
+    buttons.extend(_discover_npm_scripts(base))
+    buttons.extend(_discover_python_scripts(base))
+    buttons.extend(_discover_makefile_targets(base))
+
+    # Dedupe by label, keep first occurrence
+    unique: dict[str, dict] = {}
+    for btn in buttons:
+        unique.setdefault(btn["label"], btn)
+    return list(unique.values())
+
+
+def _discover_npm_scripts(base: Path) -> list[dict]:
+    """Extract scripts from package.json."""
+    pkg_file = base / "package.json"
+    if not pkg_file.exists():
+        return []
+
+    try:
+        data = json.loads(pkg_file.read_text(encoding="utf-8"))
+        scripts = data.get("scripts", {})
+
+        # Common useful scripts to include (if defined)
+        priority = ["build", "dev", "start", "test", "lint", "format", "watch"]
+
+        buttons = []
+        for name in priority:
+            if name in scripts:
+                buttons.append({"label": name, "send": f"npm run {name}\r", "row": 2})
+
+        return buttons[:6]  # Limit to 6 buttons
+    except Exception:
+        return []
+
+
+def _discover_python_scripts(base: Path) -> list[dict]:
+    """Extract scripts from pyproject.toml."""
+    toml_file = base / "pyproject.toml"
+    if not toml_file.exists():
+        return []
+
+    try:
+        data = tomllib.loads(toml_file.read_text(encoding="utf-8"))
+        buttons = []
+
+        # Check [project.scripts] (PEP 621)
+        project_scripts = data.get("project", {}).get("scripts", {})
+        for name in list(project_scripts.keys())[:4]:
+            if _is_safe_name(name):
+                buttons.append({"label": name, "send": f"{name}\r", "row": 2})
+
+        # Check [tool.poetry.scripts]
+        poetry_scripts = data.get("tool", {}).get("poetry", {}).get("scripts", {})
+        for name in list(poetry_scripts.keys())[:4]:
+            if _is_safe_name(name) and not any(b["label"] == name for b in buttons):
+                buttons.append({"label": name, "send": f"{name}\r", "row": 2})
+
+        return buttons[:6]
+    except Exception:
+        return []
+
+
+def _discover_makefile_targets(base: Path) -> list[dict]:
+    """Extract targets from Makefile."""
+    makefile = base / "Makefile"
+    if not makefile.exists():
+        return []
+
+    try:
+        content = makefile.read_text(encoding="utf-8")
+        # Match target definitions: "target:" at start of line
+        # Regex excludes targets starting with . (internal targets like .PHONY)
+        pattern = r"^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:"
+        targets = re.findall(pattern, content, re.MULTILINE)
+
+        # Priority order for common targets (use set for O(1) lookup)
+        priority = ["build", "test", "run", "clean", "install", "dev", "lint", "all"]
+        priority_set = set(priority)
+        target_set = set(targets)
+
+        # Priority targets first, then remaining targets
+        ordered = [t for t in priority if t in target_set]
+        ordered.extend(t for t in targets if t not in priority_set)
+
+        return [{"label": name, "send": f"make {name}\r", "row": 2} for name in ordered[:6]]
+    except Exception:
+        return []

porterminal/composition.py

@@ -14,8 +14,6 @@ from porterminal.application.services import (
 from porterminal.config import find_config_file
 from porterminal.container import Container
 from porterminal.domain import (
-    EnvironmentRules,
-    EnvironmentSanitizer,
     PTYPort,
     SessionLimitChecker,
     ShellCommand,
@@ -29,7 +27,7 @@ from porterminal.infrastructure.repositories import InMemorySessionRepository, I
 
 def create_pty_factory(
     cwd: str | None = None,
-) -> Callable[[ShellCommand, TerminalDimensions, dict[str, str], str | None], PTYPort]:
+) -> Callable[[ShellCommand, TerminalDimensions, str | None], PTYPort]:
     """Create a PTY factory function.
 
     This bridges the domain PTYPort interface with the existing
@@ -40,7 +38,6 @@ def create_pty_factory(
     def factory(
         shell: ShellCommand,
         dimensions: TerminalDimensions,
-        environment: dict[str, str],
         working_directory: str | None = None,
     ) -> PTYPort:
         # Use provided cwd or factory default
@@ -60,6 +57,7 @@ def create_pty_factory(
         )
 
         # Create manager (which implements PTY operations)
+        # Environment sanitization is handled internally by SecurePTYManager
         manager = SecurePTYManager(
             backend=backend,
             shell_config=legacy_shell,
@@ -68,8 +66,6 @@ def create_pty_factory(
             cwd=effective_cwd,
         )
 
-        # Spawn with environment (manager handles sanitization internally,
-        # but we pass our sanitized env to be safe)
         manager.spawn()
 
         return PTYManagerAdapter(manager, dimensions)
@@ -173,7 +169,6 @@ def create_container(
         repository=session_repository,
         pty_factory=pty_factory,
         limit_checker=SessionLimitChecker(),
-        environment_sanitizer=EnvironmentSanitizer(EnvironmentRules()),
         working_directory=cwd,
     )
 

porterminal/config.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import yaml
 from pydantic import BaseModel, Field, field_validator
 
+from porterminal.domain.values import MAX_COLS, MAX_ROWS, MIN_COLS, MIN_ROWS
 from porterminal.infrastructure.config import ShellDetector
 
 
@@ -43,8 +44,8 @@ class TerminalConfig(BaseModel):
     """Terminal configuration."""
 
     default_shell: str = ""
-    cols: int = Field(default=120, ge=40, le=500)
-    rows: int = Field(default=30, ge=10, le=200)
+    cols: int = Field(default=120, ge=MIN_COLS, le=MAX_COLS)
+    rows: int = Field(default=30, ge=MIN_ROWS, le=MAX_ROWS)
     shells: list[ShellConfig] = Field(default_factory=list)
 
     def get_shell(self, shell_id: str) -> ShellConfig | None:
@@ -60,6 +61,7 @@ class ButtonConfig(BaseModel):
 
     label: str
     send: str | list[str | int] = ""  # string or list of strings/ints (ints = wait ms)
+    row: int = Field(default=1, ge=1, le=10)  # toolbar row (1-10)
 
 
 class CloudflareConfig(BaseModel):

porterminal/domain/__init__.py

@@ -1,6 +1,5 @@
 """Pure domain layer - no infrastructure dependencies."""
 
-# Value Objects
 # Entities
 from .entities import (
     CLEAR_SCREEN_SEQUENCE,
@@ -23,7 +22,6 @@ from .ports import (
 # Services
 from .services import (
     Clock,
-    EnvironmentSanitizer,
     SessionLimitChecker,
     SessionLimitConfig,
     SessionLimitResult,
@@ -33,13 +31,10 @@ from .services import (
     TokenBucketRateLimiter,
 )
 from .values import (
-    DEFAULT_BLOCKED_VARS,
-    DEFAULT_SAFE_VARS,
     MAX_COLS,
     MAX_ROWS,
     MIN_COLS,
     MIN_ROWS,
-    EnvironmentRules,
     RateLimitConfig,
     SessionId,
     ShellCommand,
@@ -60,9 +55,6 @@ __all__ = [
     "TabId",
     "ShellCommand",
     "RateLimitConfig",
-    "EnvironmentRules",
-    "DEFAULT_SAFE_VARS",
-    "DEFAULT_BLOCKED_VARS",
     # Entities
     "Session",
     "MAX_SESSIONS_PER_USER",
@@ -75,7 +67,6 @@ __all__ = [
     # Services
     "TokenBucketRateLimiter",
     "Clock",
-    "EnvironmentSanitizer",
     "SessionLimitChecker",
     "SessionLimitConfig",
     "SessionLimitResult",

porterminal/domain/entities/output_buffer.py

@@ -9,6 +9,11 @@ OUTPUT_BUFFER_MAX_BYTES = 1_000_000  # 1MB
 # Terminal escape sequence for clear screen (ED2)
 CLEAR_SCREEN_SEQUENCE = b"\x1b[2J"
 
+# Alternate screen buffer sequences (DEC Private Mode)
+# Used by vim, htop, less, tmux, etc.
+ALT_SCREEN_ENTER = (b"\x1b[?47h", b"\x1b[?1047h", b"\x1b[?1049h")
+ALT_SCREEN_EXIT = (b"\x1b[?47l", b"\x1b[?1047l", b"\x1b[?1049l")
+
 
 @dataclass
 class OutputBuffer:
@@ -16,12 +21,21 @@ class OutputBuffer:
 
     Pure domain logic for buffering terminal output.
     No async, no WebSocket - just data management.
+
+    Handles alternate screen buffer (used by vim, htop, less, etc.):
+    - On alt-screen enter: snapshots normal buffer, clears for alt content
+    - On alt-screen exit: restores normal buffer, discards alt content
     """
 
     max_bytes: int = OUTPUT_BUFFER_MAX_BYTES
     _buffer: deque[bytes] = field(default_factory=deque)
     _size: int = 0
 
+    # Alt-screen state
+    _in_alt_screen: bool = False
+    _normal_snapshot: deque[bytes] | None = None
+    _normal_snapshot_size: int = 0
+
     @property
     def size(self) -> int:
         """Current buffer size in bytes."""
@@ -32,12 +46,53 @@ class OutputBuffer:
         """Check if buffer is empty."""
         return self._size == 0
 
+    @property
+    def in_alt_screen(self) -> bool:
+        """Check if currently in alternate screen mode."""
+        return self._in_alt_screen
+
+    def _enter_alt_screen(self) -> None:
+        """Handle alt-screen entry: snapshot normal buffer."""
+        if self._in_alt_screen:
+            return  # Already in alt-screen, ignore nested
+        self._in_alt_screen = True
+        self._normal_snapshot = self._buffer.copy()
+        self._normal_snapshot_size = self._size
+        self._clear_buffer()
+
+    def _exit_alt_screen(self) -> None:
+        """Handle alt-screen exit: restore normal buffer."""
+        if not self._in_alt_screen:
+            return  # Not in alt-screen, ignore
+        self._in_alt_screen = False
+        if self._normal_snapshot is not None:
+            self._buffer = self._normal_snapshot
+            self._size = self._normal_snapshot_size
+            self._normal_snapshot = None
+            self._normal_snapshot_size = 0
+
+    def _clear_buffer(self) -> None:
+        """Clear the buffer contents only."""
+        self._buffer.clear()
+        self._size = 0
+
     def add(self, data: bytes) -> None:
         """Add data to the buffer.
 
-        Handles clear screen detection and size limits.
+        Handles alt-screen transitions, clear screen detection, and size limits.
         When clear screen is detected, only keep content AFTER the last clear sequence.
         """
+        # Check alt-screen transitions FIRST
+        for pattern in ALT_SCREEN_EXIT:
+            if pattern in data:
+                self._exit_alt_screen()
+                break
+        else:
+            for pattern in ALT_SCREEN_ENTER:
+                if pattern in data:
+                    self._enter_alt_screen()
+                    return  # Don't buffer alt-screen enter data
+
         # Check for clear screen sequence
         if CLEAR_SCREEN_SEQUENCE in data:
             # Clear old buffer

porterminal/domain/entities/tab.py

@@ -13,6 +13,15 @@ TAB_NAME_MIN_LENGTH = 1
 TAB_NAME_MAX_LENGTH = 50
 
 
+def _validate_tab_name(name: str) -> None:
+    """Validate tab name length."""
+    if not (TAB_NAME_MIN_LENGTH <= len(name) <= TAB_NAME_MAX_LENGTH):
+        raise ValueError(
+            f"Tab name must be {TAB_NAME_MIN_LENGTH}-{TAB_NAME_MAX_LENGTH} "
+            f"characters, got {len(name)}"
+        )
+
+
 @dataclass
 class Tab:
     """Terminal tab entity.
@@ -35,11 +44,7 @@ class Tab:
     last_accessed: datetime
 
     def __post_init__(self) -> None:
-        if not (TAB_NAME_MIN_LENGTH <= len(self.name) <= TAB_NAME_MAX_LENGTH):
-            raise ValueError(
-                f"Tab name must be {TAB_NAME_MIN_LENGTH}-{TAB_NAME_MAX_LENGTH} "
-                f"characters, got {len(self.name)}"
-            )
+        _validate_tab_name(self.name)
 
     @property
     def tab_id(self) -> str:
@@ -52,11 +57,7 @@ class Tab:
 
     def rename(self, new_name: str) -> None:
         """Rename the tab with validation."""
-        if not (TAB_NAME_MIN_LENGTH <= len(new_name) <= TAB_NAME_MAX_LENGTH):
-            raise ValueError(
-                f"Tab name must be {TAB_NAME_MIN_LENGTH}-{TAB_NAME_MAX_LENGTH} "
-                f"characters, got {len(new_name)}"
-            )
+        _validate_tab_name(new_name)
         self.name = new_name
 
     def to_dict(self) -> dict:

porterminal/domain/services/__init__.py

@@ -1,6 +1,5 @@
 """Domain services - pure business logic operations."""
 
-from .environment_sanitizer import EnvironmentSanitizer
 from .rate_limiter import Clock, TokenBucketRateLimiter
 from .session_limits import SessionLimitChecker, SessionLimitConfig, SessionLimitResult
 from .tab_limits import TabLimitChecker, TabLimitConfig, TabLimitResult
@@ -8,7 +7,6 @@ from .tab_limits import TabLimitChecker, TabLimitConfig, TabLimitResult
 __all__ = [
     "TokenBucketRateLimiter",
     "Clock",
-    "EnvironmentSanitizer",
     "SessionLimitChecker",
     "SessionLimitConfig",
     "SessionLimitResult",

porterminal/domain/values/__init__.py

@@ -1,6 +1,5 @@
 """Domain value objects - immutable data structures."""
 
-from .environment_rules import DEFAULT_BLOCKED_VARS, DEFAULT_SAFE_VARS, EnvironmentRules
 from .rate_limit_config import RateLimitConfig
 from .session_id import SessionId
 from .shell_command import ShellCommand
@@ -19,7 +18,4 @@ __all__ = [
     "TabId",
     "ShellCommand",
     "RateLimitConfig",
-    "EnvironmentRules",
-    "DEFAULT_SAFE_VARS",
-    "DEFAULT_BLOCKED_VARS",
 ]

porterminal/domain/values/environment_rules.py

@@ -22,12 +22,15 @@ DEFAULT_SAFE_VARS: frozenset[str] = frozenset(
         "HOMEPATH",
         "LOCALAPPDATA",
         "APPDATA",
+        "PROGRAMDATA",
         "PROGRAMFILES",
         "PROGRAMFILES(X86)",
         "COMMONPROGRAMFILES",
         # System info
         "COMPUTERNAME",
         "USERNAME",
+        "USER",
+        "LOGNAME",
         "USERDOMAIN",
         "OS",
         "PROCESSOR_ARCHITECTURE",

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:
@@ -149,25 +158,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 +192,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 +423,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 +447,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."""