ptn 0.1.4__py3-none-any.whl

porterminal/asgi.py

@@ -0,0 +1,38 @@
+"""ASGI application factory for uvicorn.
+
+This module provides a factory function that uvicorn can use to create
+the FastAPI application with proper dependency injection.
+
+Usage:
+    uvicorn porterminal.asgi:create_app_from_env --factory
+"""
+
+import os
+
+from porterminal.composition import create_container
+
+
+def create_app_from_env():
+    """Create FastAPI app from environment variables.
+
+    This is called by uvicorn when using the --factory flag.
+    Environment variables:
+        PORTERMINAL_CONFIG_PATH: Path to config file (default: config.yaml)
+        PORTERMINAL_CWD: Working directory for PTY sessions
+    """
+    from porterminal.app import create_app
+
+    config_path = os.environ.get("PORTERMINAL_CONFIG_PATH", "config.yaml")
+    cwd = os.environ.get("PORTERMINAL_CWD")
+
+    container = create_container(config_path=config_path, cwd=cwd)
+
+    # Create app with container
+    # Note: The current app.py doesn't accept container yet,
+    # so we just create the default app and store container in state
+    app = create_app()
+
+    # Store container in app state for handlers to access
+    app.state.container = container
+
+    return app

porterminal/cli/__init__.py

@@ -0,0 +1,19 @@
+"""CLI utilities for Porterminal."""
+
+from .args import parse_args
+from .display import (
+    LOGO,
+    TAGLINE,
+    display_startup_screen,
+    get_caution,
+    get_qr_code,
+)
+
+__all__ = [
+    "parse_args",
+    "display_startup_screen",
+    "get_qr_code",
+    "get_caution",
+    "LOGO",
+    "TAGLINE",
+]

porterminal/cli/args.py

@@ -0,0 +1,91 @@
+"""Command line argument parsing."""
+
+import argparse
+import sys
+
+from porterminal import __version__
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments.
+
+    Returns:
+        Parsed arguments namespace with:
+        - path: Starting directory for the shell (optional)
+        - no_tunnel: Whether to skip Cloudflare tunnel
+        - verbose: Whether to show detailed logs
+        - update: Whether to update to latest version
+        - check_update: Whether to check for updates
+    """
+    parser = argparse.ArgumentParser(
+        description="Porterminal - Web terminal via Cloudflare Tunnel",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=None,
+        help="Starting directory for the shell (default: current directory)",
+    )
+    parser.add_argument(
+        "--no-tunnel",
+        action="store_true",
+        help="Start server only, without Cloudflare tunnel",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Show detailed startup logs",
+    )
+    parser.add_argument(
+        "-U",
+        "--update",
+        action="store_true",
+        help="Update to the latest version",
+    )
+    parser.add_argument(
+        "--check-update",
+        action="store_true",
+        help="Check if a newer version is available",
+    )
+    parser.add_argument(
+        "-b",
+        "--background",
+        action="store_true",
+        help="Run in background and return immediately",
+    )
+    # Internal argument for background mode communication
+    parser.add_argument(
+        "--_url-file",
+        dest="url_file",
+        help=argparse.SUPPRESS,
+    )
+
+    args = parser.parse_args()
+
+    # Handle update commands early (before main app starts)
+    if args.check_update:
+        from porterminal.updater import check_for_updates, get_upgrade_command
+
+        has_update, latest = check_for_updates(use_cache=False)
+        if has_update:
+            print(f"Update available: {__version__} → {latest}")
+            print(f"Run: {get_upgrade_command()}")
+        else:
+            print(f"Already at latest version ({__version__})")
+        sys.exit(0)
+
+    if args.update:
+        from porterminal.updater import update_package
+
+        success = update_package()
+        sys.exit(0 if success else 1)
+
+    return args

porterminal/cli/display.py

@@ -0,0 +1,157 @@
+"""Display utilities for the startup screen."""
+
+import io
+import random
+import sys
+
+import qrcode
+from rich.align import Align
+from rich.console import Console
+from rich.table import Table
+
+from porterminal import __version__
+
+# Force UTF-8 for Windows console
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+console = Console(force_terminal=True)
+
+LOGO = r"""
+██████  ██████  ██████  ██████  ██████  ██████  ██   ██  ██  ██   ██   ████   ██
+██  ██  ██  ██  ██  ██    ██    ██      ██  ██  ███ ███  ██  ███  ██  ██  ██  ██
+██████  ██  ██  ██████    ██    ████    ██████  ██ █ ██  ██  ██ █ ██  ██████  ██
+██      ██  ██  ██  ██    ██    ██      ██  ██  ██   ██  ██  ██  ███  ██  ██  ██
+██      ██████  ██  ██    ██    ██████  ██  ██  ██   ██  ██  ██   ██  ██  ██  ██████
+"""
+
+TAGLINE = r"""
+█ █ █ █▄▄ █▀▀   █▀▀ █▀█ █▀▄ █▀▀   █▀▀ █▀█ █▀█ █▀▄▀█   ▄▀█ █▄ █ █▄█ █ █ █ █▀▀ █▀█ █▀▀
+▀▄▀ █ █▄█ ██▄   █▄▄ █▄█ █▄▀ ██▄   █▀  █▀▄ █▄█ █ ▀ █   █▀█ █ ▀█  █  ▀▄▀▄▀ ██▄ █▀▄ ██▄
+""".strip()
+
+CAUTION_DEFAULT = "CAUTION: DO NOT VIBE CODE WHILE DRIVING"
+
+CAUTION_EASTER_EGGS = [
+    "VIBE CODING ON THE TOILET IS FINE THO",
+    "DEPLOYING TO PROD FROM BED IS A LIFESTYLE",
+    "TOUCHING GRASS WHILE TOUCHING CODE",
+    "MOM SAID IT'S MY TURN ON THE SERVER",
+    "IT WORKS ON MY PHONE",
+    "404: WORK-LIFE BALANCE NOT FOUND",
+    "git commit -m 'fixed from toilet'",
+    "*HACKER VOICE* I'M IN (the bathroom)",
+    "THEY SAID REMOTE WORK. I DELIVERED.",
+    "TECHNICALLY THIS IS A STANDING DESK",
+    "SUDO MAKE ME A SANDWICH (I'M IN LINE)",
+    "MY OTHER TERMINAL IS A YACHT",
+    "REAL PROGRAMMERS CODE IN TRAFFIC JAMS",
+    "MERGE CONFLICTS RESOLVED AT 30,000 FT",
+    "PUSHED TO MAIN FROM THE CHECKOUT LINE",
+]
+
+
+def get_caution() -> str:
+    """Get caution message with 1% chance of easter egg."""
+    if random.random() < 0.01:
+        return random.choice(CAUTION_EASTER_EGGS)
+    return CAUTION_DEFAULT
+
+
+def get_qr_code(url: str) -> str:
+    """Generate QR code as ASCII string.
+
+    Args:
+        url: URL to encode in the QR code.
+
+    Returns:
+        ASCII art representation of the QR code.
+    """
+    qr = qrcode.QRCode(
+        version=1,
+        error_correction=qrcode.constants.ERROR_CORRECT_L,
+        box_size=1,
+        border=1,
+    )
+    qr.add_data(url)
+    qr.make(fit=True)
+
+    buffer = io.StringIO()
+    qr.print_ascii(out=buffer, invert=True)
+    # Remove only truly empty lines (not whitespace-only lines which are part of QR)
+    lines = [line for line in buffer.getvalue().split("\n") if line]
+    # Strip trailing empty lines
+    while lines and not lines[-1]:
+        lines.pop()
+    return "\n".join(lines)
+
+
+def display_startup_screen(
+    url: str,
+    is_tunnel: bool = True,
+    cwd: str | None = None,
+) -> None:
+    """Display the final startup screen with QR code.
+
+    Args:
+        url: Primary URL to display and encode in QR.
+        is_tunnel: Whether tunnel mode is active.
+        cwd: Current working directory to display.
+    """
+    console.clear()
+
+    # Build QR code
+    try:
+        qr_text = get_qr_code(url)
+    except Exception:
+        qr_text = "[QR code unavailable]"
+
+    # Status indicator
+    if is_tunnel:
+        status = "[green]●[/green] TUNNEL ACTIVE - SCAN THE QR CODE TO ACCESS YOUR TERMINAL"
+    else:
+        status = "[yellow]●[/yellow] LOCAL MODE"
+
+    # Build logo with gradient
+    logo_lines = LOGO.strip().split("\n")
+    colors = ["bold bright_cyan", "bright_cyan", "cyan", "bright_blue", "blue"]
+    logo_colored = []
+    for i, line in enumerate(logo_lines):
+        color = colors[i] if i < len(colors) else colors[-1]
+        logo_colored.append(f"[{color}]{line}[/{color}]")
+
+    # Build tagline with gradient
+    tagline_lines = TAGLINE.split("\n")
+    tagline_colors = ["bright_magenta", "magenta"]
+    tagline_colored = []
+    for i, line in enumerate(tagline_lines):
+        color = tagline_colors[i] if i < len(tagline_colors) else tagline_colors[-1]
+        tagline_colored.append(f"[{color}]{line}[/{color}]")
+
+    # Left side content
+    left_lines = [
+        *logo_colored,
+        f"[dim]v{__version__}[/dim]",
+        "",
+        *tagline_colored,
+        "",
+        f"[bold yellow]{get_caution()}[/bold yellow]",
+        "[bright_red]The URL is the only security. Use at your own risk.[/bright_red]",
+        status,
+        f"[bold cyan]{url}[/bold cyan]",
+    ]
+    if cwd:
+        left_lines.append(f"[dim]{cwd}[/dim]")
+    left_lines.append("[dim]Ctrl+C to stop[/dim]")
+
+    left_content = "\n".join(left_lines)
+
+    # Create side-by-side layout (logo left, QR right)
+    table = Table.grid(padding=(0, 4))
+    table.add_column(justify="left", vertical="middle")
+    table.add_column(justify="left", vertical="middle")
+    table.add_row(left_content, qr_text)
+
+    console.print()
+    console.print(Align.center(table))
+    console.print()

porterminal/composition.py

@@ -0,0 +1,208 @@
+"""Composition root - the ONLY place where dependencies are wired."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+from porterminal.application.services import (
+    ManagementService,
+    SessionService,
+    TabService,
+    TerminalService,
+)
+from porterminal.container import Container
+from porterminal.domain import (
+    EnvironmentRules,
+    EnvironmentSanitizer,
+    PTYPort,
+    SessionLimitChecker,
+    ShellCommand,
+    TabLimitChecker,
+    TerminalDimensions,
+)
+from porterminal.infrastructure.config import ShellDetector, YAMLConfigLoader
+from porterminal.infrastructure.registry import UserConnectionRegistry
+from porterminal.infrastructure.repositories import InMemorySessionRepository, InMemoryTabRepository
+
+
+def create_pty_factory(
+    cwd: str | None = None,
+) -> Callable[[ShellCommand, TerminalDimensions, dict[str, str], str | None], PTYPort]:
+    """Create a PTY factory function.
+
+    This bridges the domain PTYPort interface with the existing
+    infrastructure PTY implementation.
+    """
+    from porterminal.pty import SecurePTYManager, create_backend
+
+    def factory(
+        shell: ShellCommand,
+        dimensions: TerminalDimensions,
+        environment: dict[str, str],
+        working_directory: str | None = None,
+    ) -> PTYPort:
+        # Use provided cwd or factory default
+        effective_cwd = working_directory or cwd
+
+        # Create backend
+        backend = create_backend()
+
+        # Create shell config compatible with existing infrastructure
+        from porterminal.config import ShellConfig as LegacyShellConfig
+
+        legacy_shell = LegacyShellConfig(
+            name=shell.name,
+            id=shell.id,
+            command=shell.command,
+            args=list(shell.args),
+        )
+
+        # Create manager (which implements PTY operations)
+        manager = SecurePTYManager(
+            backend=backend,
+            shell_config=legacy_shell,
+            cols=dimensions.cols,
+            rows=dimensions.rows,
+            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)
+
+    return factory
+
+
+class PTYManagerAdapter:
+    """Adapts SecurePTYManager to PTYPort interface."""
+
+    def __init__(self, manager, dimensions: TerminalDimensions) -> None:
+        self._manager = manager
+        self._dimensions = dimensions
+
+    def spawn(self) -> None:
+        """Already spawned in factory."""
+        pass
+
+    def read(self, size: int = 4096) -> bytes:
+        return self._manager.read(size)
+
+    def write(self, data: bytes) -> None:
+        self._manager.write(data)
+
+    def resize(self, dimensions: TerminalDimensions) -> None:
+        self._manager.resize(dimensions.cols, dimensions.rows)
+        self._dimensions = dimensions
+
+    def is_alive(self) -> bool:
+        return self._manager.is_alive()
+
+    def close(self) -> None:
+        self._manager.close()
+
+    @property
+    def dimensions(self) -> TerminalDimensions:
+        return self._dimensions
+
+
+def create_container(
+    config_path: Path | str = "config.yaml",
+    cwd: str | None = None,
+) -> Container:
+    """Create the dependency container with all wired dependencies.
+
+    This is the composition root - the single place where all
+    dependencies are created and wired together.
+
+    Args:
+        config_path: Path to config file.
+        cwd: Working directory for PTY sessions.
+
+    Returns:
+        Fully wired dependency container.
+    """
+    # Load configuration
+    loader = YAMLConfigLoader(config_path)
+    config_data = loader.load()
+
+    # Detect shells
+    detector = ShellDetector()
+    shells = detector.detect_shells()
+
+    # Get config values with defaults
+    server_data = config_data.get("server", {})
+    terminal_data = config_data.get("terminal", {})
+
+    server_host = server_data.get("host", "127.0.0.1")
+    server_port = server_data.get("port", 8000)
+    default_cols = terminal_data.get("cols", 120)
+    default_rows = terminal_data.get("rows", 30)
+    default_shell_id = terminal_data.get("default_shell") or detector.get_default_shell_id()
+    buttons = config_data.get("buttons", [])
+
+    # Use configured shells if provided, otherwise use detected
+    configured_shells = terminal_data.get("shells", [])
+    if configured_shells:
+        shells = [ShellCommand.from_dict(s) for s in configured_shells]
+
+    # Create repositories
+    session_repository = InMemorySessionRepository()
+    tab_repository = InMemoryTabRepository()
+
+    # Create connection registry for broadcasting
+    connection_registry = UserConnectionRegistry()
+
+    # Create PTY factory
+    pty_factory = create_pty_factory(cwd)
+
+    # Create services
+    session_service = SessionService(
+        repository=session_repository,
+        pty_factory=pty_factory,
+        limit_checker=SessionLimitChecker(),
+        environment_sanitizer=EnvironmentSanitizer(EnvironmentRules()),
+        working_directory=cwd,
+    )
+
+    tab_service = TabService(
+        repository=tab_repository,
+        limit_checker=TabLimitChecker(),
+    )
+
+    terminal_service = TerminalService()
+
+    # Create a shell provider closure for ManagementService
+    def get_shell(shell_id: str | None) -> ShellCommand | None:
+        target_id = shell_id or default_shell_id
+        for shell in shells:
+            if shell.id == target_id:
+                return shell
+        return shells[0] if shells else None
+
+    management_service = ManagementService(
+        session_service=session_service,
+        tab_service=tab_service,
+        connection_registry=connection_registry,
+        shell_provider=get_shell,
+        default_dimensions=TerminalDimensions(default_cols, default_rows),
+    )
+
+    return Container(
+        session_service=session_service,
+        tab_service=tab_service,
+        terminal_service=terminal_service,
+        management_service=management_service,
+        session_repository=session_repository,
+        tab_repository=tab_repository,
+        connection_registry=connection_registry,
+        pty_factory=pty_factory,
+        available_shells=shells,
+        default_shell_id=default_shell_id,
+        server_host=server_host,
+        server_port=server_port,
+        default_cols=default_cols,
+        default_rows=default_rows,
+        buttons=buttons,
+        cwd=cwd,
+    )