ptn 0.1.4__py3-none-any.whl

porterminal/domain/values/shell_command.py

@@ -0,0 +1,37 @@
+"""Shell command specification value object."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ShellCommand:
+    """Shell command specification (value object).
+
+    Note: Validation that the command exists on the filesystem
+    is NOT done here - that's an infrastructure concern.
+    """
+
+    id: str
+    name: str
+    command: str
+    args: tuple[str, ...]  # Immutable tuple instead of list
+
+    def __post_init__(self) -> None:
+        if not self.id:
+            raise ValueError("Shell id cannot be empty")
+        if not self.command:
+            raise ValueError("Shell command cannot be empty")
+
+    def to_command_list(self) -> list[str]:
+        """Build command + args list for process spawning."""
+        return [self.command, *self.args]
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ShellCommand":
+        """Create from dictionary (e.g., from config)."""
+        return cls(
+            id=data["id"],
+            name=data.get("name", data["id"]),
+            command=data["command"],
+            args=tuple(data.get("args", [])),
+        )

porterminal/domain/values/tab_id.py

@@ -0,0 +1,24 @@
+"""Tab ID value object."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class TabId:
+    """Strongly-typed tab identifier.
+
+    Generated as UUID string, same pattern as SessionId.
+    Immutable and hashable for use as dict keys.
+    """
+
+    value: str
+
+    def __post_init__(self) -> None:
+        if not self.value or not isinstance(self.value, str):
+            raise ValueError("TabId cannot be empty")
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)

porterminal/domain/values/terminal_dimensions.py

@@ -0,0 +1,45 @@
+"""Terminal dimensions value object with validation."""
+
+from dataclasses import dataclass
+
+# Business rule constants
+MIN_COLS = 40
+MAX_COLS = 500
+MIN_ROWS = 10
+MAX_ROWS = 200
+
+
+@dataclass(frozen=True, slots=True)
+class TerminalDimensions:
+    """Immutable terminal dimensions with validation.
+
+    Invariants:
+    - cols in [40, 500]
+    - rows in [10, 200]
+    """
+
+    cols: int
+    rows: int
+
+    def __post_init__(self) -> None:
+        if not (MIN_COLS <= self.cols <= MAX_COLS):
+            raise ValueError(f"cols must be {MIN_COLS}-{MAX_COLS}, got {self.cols}")
+        if not (MIN_ROWS <= self.rows <= MAX_ROWS):
+            raise ValueError(f"rows must be {MIN_ROWS}-{MAX_ROWS}, got {self.rows}")
+
+    @classmethod
+    def clamped(cls, cols: int, rows: int) -> "TerminalDimensions":
+        """Create dimensions with clamping instead of raising."""
+        return cls(
+            cols=max(MIN_COLS, min(cols, MAX_COLS)),
+            rows=max(MIN_ROWS, min(rows, MAX_ROWS)),
+        )
+
+    @classmethod
+    def default(cls) -> "TerminalDimensions":
+        """Create default dimensions (120x30)."""
+        return cls(cols=120, rows=30)
+
+    def resize(self, cols: int, rows: int) -> "TerminalDimensions":
+        """Return new dimensions with clamping (immutable)."""
+        return TerminalDimensions.clamped(cols, rows)

porterminal/domain/values/user_id.py

@@ -0,0 +1,25 @@
+"""User ID value object."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class UserId:
+    """Strongly-typed user identifier."""
+
+    value: str
+
+    def __post_init__(self) -> None:
+        if not self.value or not isinstance(self.value, str):
+            raise ValueError("UserId cannot be empty")
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    @classmethod
+    def local_user(cls) -> "UserId":
+        """Create default local user ID."""
+        return cls("local-user")

porterminal/infrastructure/__init__.py

@@ -0,0 +1,20 @@
+"""Infrastructure utilities for Porterminal."""
+
+from .cloudflared import CloudflaredInstaller
+from .network import find_available_port, is_port_available
+from .registry import UserConnectionRegistry
+from .repositories import InMemorySessionRepository, InMemoryTabRepository
+from .server import drain_process_output, start_cloudflared, start_server, wait_for_server
+
+__all__ = [
+    "CloudflaredInstaller",
+    "is_port_available",
+    "find_available_port",
+    "start_server",
+    "wait_for_server",
+    "start_cloudflared",
+    "drain_process_output",
+    "InMemorySessionRepository",
+    "InMemoryTabRepository",
+    "UserConnectionRegistry",
+]

porterminal/infrastructure/cloudflared.py

@@ -0,0 +1,295 @@
+"""Cloudflared installation and management."""
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+class CloudflaredInstaller:
+    """Platform-specific cloudflared installer."""
+
+    @staticmethod
+    def is_installed() -> bool:
+        """Check if cloudflared is installed."""
+        return shutil.which("cloudflared") is not None
+
+    @staticmethod
+    def install() -> bool:
+        """Auto-install cloudflared on the current platform.
+
+        Returns:
+            True if installation succeeded, False otherwise.
+        """
+        console.print("[cyan]Installing cloudflared...[/cyan]")
+
+        if sys.platform == "win32":
+            return CloudflaredInstaller._install_windows()
+        elif sys.platform == "linux":
+            return CloudflaredInstaller._install_linux()
+        elif sys.platform == "darwin":
+            return CloudflaredInstaller._install_macos()
+        else:
+            console.print(f"[yellow]Auto-install not supported on {sys.platform}[/yellow]")
+            return False
+
+    @staticmethod
+    def _find_cloudflared_windows() -> str | None:
+        """Find cloudflared.exe in common Windows install locations."""
+        common_paths = [
+            Path(os.environ.get("ProgramFiles", "C:\\Program Files")) / "cloudflared",
+            Path(os.environ.get("ProgramFiles(x86)", "C:\\Program Files (x86)")) / "cloudflared",
+            Path(os.environ.get("LOCALAPPDATA", "")) / "Programs" / "cloudflared",
+            Path(os.environ.get("LOCALAPPDATA", "")) / "cloudflared",
+            Path.home() / "AppData" / "Local" / "Microsoft" / "WinGet" / "Packages",
+        ]
+
+        for path in common_paths:
+            if not path.exists():
+                continue
+            # Direct exe in folder
+            exe = path / "cloudflared.exe"
+            if exe.exists():
+                return str(path)
+            # Search in subdirectories (for WinGet packages folder)
+            for exe in path.rglob("cloudflared.exe"):
+                return str(exe.parent)
+
+        return None
+
+    @staticmethod
+    def _install_windows() -> bool:
+        """Install cloudflared on Windows."""
+        # Try winget first (preferred)
+        if shutil.which("winget"):
+            try:
+                result = subprocess.run(
+                    [
+                        "winget",
+                        "install",
+                        "--id",
+                        "Cloudflare.cloudflared",
+                        "-e",
+                        "--silent",
+                        "--accept-source-agreements",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=120,
+                )
+                if result.returncode == 0 or "already installed" in result.stdout.lower():
+                    console.print("[green]✓ Installed via winget[/green]")
+
+                    # 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]")
+                    # Return True regardless - winget succeeded, may just need shell restart
+                    return True
+            except (subprocess.TimeoutExpired, OSError) as e:
+                console.print(f"[dim]winget failed: {e}[/dim]")
+
+        # Fallback: direct download
+        try:
+            import zipfile
+
+            url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.zip"
+            install_dir = Path.home() / ".cloudflared" / "bin"
+            install_dir.mkdir(parents=True, exist_ok=True)
+
+            console.print("[dim]Downloading from GitHub...[/dim]")
+
+            with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp:
+                tmp_path = tmp.name
+                urllib.request.urlretrieve(url, tmp_path)
+
+            with zipfile.ZipFile(tmp_path, "r") as zf:
+                zf.extractall(install_dir)
+
+            os.unlink(tmp_path)
+
+            exe_path = install_dir / "cloudflared.exe"
+            if exe_path.exists():
+                os.environ["PATH"] = str(install_dir) + os.pathsep + os.environ.get("PATH", "")
+                console.print(f"[green]✓ Installed to {install_dir}[/green]")
+                return True
+
+        except (OSError, urllib.error.URLError) as e:
+            console.print(f"[red]Download failed: {e}[/red]")
+
+        return False
+
+    @staticmethod
+    def _find_cloudflared_unix() -> str | None:
+        """Find cloudflared in common Unix install locations."""
+        common_paths = [
+            Path("/usr/bin"),
+            Path("/usr/local/bin"),
+            Path("/opt/homebrew/bin"),
+            Path.home() / ".local" / "bin",
+            Path.home() / "bin",
+        ]
+
+        for path in common_paths:
+            exe = path / "cloudflared"
+            if exe.exists() and os.access(exe, os.X_OK):
+                return str(path)
+
+        return None
+
+    @staticmethod
+    def _install_linux() -> bool:
+        """Install cloudflared on Linux."""
+        # Determine architecture
+        machine = platform.machine().lower()
+        if machine in ("x86_64", "amd64"):
+            arch = "amd64"
+        elif machine in ("aarch64", "arm64"):
+            arch = "arm64"
+        elif machine.startswith("arm"):
+            arch = "arm"
+        else:
+            arch = "amd64"  # Default fallback
+
+        # Try package managers first
+        pkg_managers = [
+            (["apt-get", "install", "-y", "cloudflared"], "apt"),
+            (["yum", "install", "-y", "cloudflared"], "yum"),
+            (["dnf", "install", "-y", "cloudflared"], "dnf"),
+        ]
+
+        for cmd, name in pkg_managers:
+            if shutil.which(cmd[0]):
+                try:
+                    # Add Cloudflare repo first for apt
+                    if name == "apt":
+                        subprocess.run(
+                            [
+                                "bash",
+                                "-c",
+                                "curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null && "
+                                "echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared $(lsb_release -cs) main' | sudo tee /etc/apt/sources.list.d/cloudflared.list && "
+                                "sudo apt-get update",
+                            ],
+                            capture_output=True,
+                            timeout=60,
+                        )
+                    result = subprocess.run(
+                        ["sudo"] + cmd,
+                        capture_output=True,
+                        text=True,
+                        timeout=120,
+                    )
+                    if result.returncode == 0:
+                        console.print(f"[green]✓ Installed via {name}[/green]")
+
+                        # Check if now in PATH
+                        if shutil.which("cloudflared"):
+                            return True
+
+                        # 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]")
+                        # Return True regardless - package manager succeeded
+                        return True
+                except (subprocess.TimeoutExpired, OSError) as e:
+                    console.print(f"[dim]{name} failed: {e}[/dim]")
+
+        # Fallback: direct binary download
+        try:
+            url = f"https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{arch}"
+            install_dir = Path.home() / ".local" / "bin"
+            install_dir.mkdir(parents=True, exist_ok=True)
+            bin_path = install_dir / "cloudflared"
+
+            console.print("[dim]Downloading from GitHub...[/dim]")
+            urllib.request.urlretrieve(url, bin_path)
+
+            # Make executable
+            os.chmod(bin_path, 0o755)
+
+            # Add to PATH for this session
+            os.environ["PATH"] = str(install_dir) + os.pathsep + os.environ.get("PATH", "")
+            console.print(f"[green]✓ Installed to {bin_path}[/green]")
+            return True
+
+        except (OSError, urllib.error.URLError) as e:
+            console.print(f"[red]Download failed: {e}[/red]")
+
+        return False
+
+    @staticmethod
+    def _install_macos() -> bool:
+        """Install cloudflared on macOS."""
+        # Try Homebrew first
+        if shutil.which("brew"):
+            try:
+                result = subprocess.run(
+                    ["brew", "install", "cloudflared"],
+                    capture_output=True,
+                    text=True,
+                    timeout=120,
+                )
+                if result.returncode == 0:
+                    console.print("[green]✓ Installed via Homebrew[/green]")
+
+                    # Check if now in PATH
+                    if shutil.which("cloudflared"):
+                        return True
+
+                    # 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]")
+                    # Return True regardless - Homebrew succeeded
+                    return True
+            except (subprocess.TimeoutExpired, OSError) as e:
+                console.print(f"[dim]Homebrew failed: {e}[/dim]")
+
+        # Fallback: direct download
+        try:
+            import tarfile
+
+            machine = platform.machine().lower()
+            arch = "arm64" if machine in ("arm64", "aarch64") else "amd64"
+
+            url = f"https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-{arch}.tgz"
+            install_dir = Path.home() / ".local" / "bin"
+            install_dir.mkdir(parents=True, exist_ok=True)
+
+            console.print("[dim]Downloading from GitHub...[/dim]")
+
+            with tempfile.NamedTemporaryFile(suffix=".tgz", delete=False) as tmp:
+                tmp_path = tmp.name
+                urllib.request.urlretrieve(url, tmp_path)
+
+            with tarfile.open(tmp_path, "r:gz") as tf:
+                tf.extractall(install_dir)
+
+            os.unlink(tmp_path)
+
+            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", "")
+                console.print(f"[green]✓ Installed to {bin_path}[/green]")
+                return True
+
+        except (OSError, urllib.error.URLError) as e:
+            console.print(f"[red]Download failed: {e}[/red]")
+
+        return False

porterminal/infrastructure/config/__init__.py

@@ -0,0 +1,9 @@
+"""Configuration infrastructure - loading and detection."""
+
+from .shell_detector import ShellDetector
+from .yaml_loader import YAMLConfigLoader
+
+__all__ = [
+    "YAMLConfigLoader",
+    "ShellDetector",
+]

porterminal/infrastructure/config/shell_detector.py

@@ -0,0 +1,84 @@
+"""Shell detection for available shells on the system."""
+
+import shutil
+import sys
+from pathlib import Path
+
+from porterminal.domain import ShellCommand
+
+
+class ShellDetector:
+    """Detect available shells on the current platform."""
+
+    def detect_shells(self) -> list[ShellCommand]:
+        """Auto-detect available shells.
+
+        Returns:
+            List of detected shell configurations.
+        """
+        candidates = self._get_platform_candidates()
+        shells = []
+
+        for name, shell_id, command, args in candidates:
+            shell_path = shutil.which(command)
+            if shell_path or Path(command).exists():
+                shells.append(
+                    ShellCommand(
+                        id=shell_id,
+                        name=name,
+                        command=shell_path or command,
+                        args=tuple(args),
+                    )
+                )
+
+        return shells
+
+    def get_default_shell_id(self) -> str:
+        """Get the default shell ID for current platform."""
+        if sys.platform == "win32":
+            return self._get_windows_default()
+        elif sys.platform == "darwin":
+            return self._get_macos_default()
+        return self._get_linux_default()
+
+    def _get_platform_candidates(self) -> list[tuple[str, str, str, list[str]]]:
+        """Get shell candidates for current platform.
+
+        Returns:
+            List of (name, id, command, args) tuples.
+        """
+        if sys.platform == "win32":
+            return [
+                ("PS 7", "pwsh", "pwsh.exe", ["-NoLogo"]),
+                ("PS", "powershell", "powershell.exe", ["-NoLogo"]),
+                ("CMD", "cmd", "cmd.exe", []),
+                ("WSL", "wsl", "wsl.exe", []),
+            ]
+        return [
+            ("Bash", "bash", "bash", ["--login"]),
+            ("Zsh", "zsh", "zsh", ["--login"]),
+            ("Fish", "fish", "fish", []),
+            ("Sh", "sh", "sh", []),
+        ]
+
+    def _get_windows_default(self) -> str:
+        """Get default shell ID for Windows."""
+        if shutil.which("pwsh.exe"):
+            return "pwsh"
+        if shutil.which("powershell.exe"):
+            return "powershell"
+        return "cmd"
+
+    def _get_macos_default(self) -> str:
+        """Get default shell ID for macOS."""
+        if shutil.which("zsh"):
+            return "zsh"
+        return "bash"
+
+    def _get_linux_default(self) -> str:
+        """Get default shell ID for Linux."""
+        if shutil.which("bash"):
+            return "bash"
+        if shutil.which("zsh"):
+            return "zsh"
+        return "sh"

porterminal/infrastructure/config/yaml_loader.py

@@ -0,0 +1,34 @@
+"""YAML configuration loader."""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+class YAMLConfigLoader:
+    """Load configuration from YAML files."""
+
+    def __init__(self, config_path: Path | str = "config.yaml") -> None:
+        self._config_path = Path(config_path)
+
+    def load(self) -> dict[str, Any]:
+        """Load raw configuration data from YAML.
+
+        Returns:
+            Configuration dictionary, empty dict if file not found.
+        """
+        if not self._config_path.exists():
+            return {}
+
+        with open(self._config_path, encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+
+    def reload(self) -> dict[str, Any]:
+        """Reload configuration from file."""
+        return self.load()
+
+    @property
+    def path(self) -> Path:
+        """Get configuration file path."""
+        return self._config_path

porterminal/infrastructure/network.py

@@ -0,0 +1,43 @@
+"""Network utilities for Porterminal."""
+
+import socket
+
+
+def is_port_available(host: str, port: int) -> bool:
+    """Check if host:port is available to bind.
+
+    Args:
+        host: Host address to check.
+        port: Port number to check.
+
+    Returns:
+        True if port is available, False otherwise.
+    """
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.bind((host, port))
+            return True
+    except OSError:
+        return False
+
+
+def find_available_port(host: str, preferred_port: int, tries: int = 25) -> int:
+    """Find an available port, starting at preferred_port and incrementing.
+
+    Args:
+        host: Host address to bind.
+        preferred_port: Preferred port to start searching from.
+        tries: Number of consecutive ports to try.
+
+    Returns:
+        Available port number.
+    """
+    for offset in range(tries):
+        candidate = preferred_port + offset
+        if is_port_available(host, candidate):
+            return candidate
+    # Fallback: ask OS for an ephemeral port
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind((host, 0))
+        return sock.getsockname()[1]

porterminal/infrastructure/registry/__init__.py

@@ -0,0 +1,5 @@
+"""Infrastructure registries for connection tracking."""
+
+from .user_connection_registry import UserConnectionRegistry
+
+__all__ = ["UserConnectionRegistry"]