ptn 0.1.4__py3-none-any.whl

porterminal/infrastructure/registry/user_connection_registry.py

@@ -0,0 +1,104 @@
+"""User connection registry for broadcasting tab sync messages."""
+
+import asyncio
+import logging
+from typing import Any
+
+from porterminal.application.ports import ConnectionPort
+from porterminal.domain import UserId
+
+logger = logging.getLogger(__name__)
+
+
+class UserConnectionRegistry:
+    """Track all WebSocket connections per user for broadcasting.
+
+    Enables real-time tab sync across multiple browser windows/devices.
+    Thread-safe for async usage.
+    """
+
+    def __init__(self) -> None:
+        self._connections: dict[str, set[ConnectionPort]] = {}
+        self._lock = asyncio.Lock()
+
+    async def register(self, user_id: UserId, connection: ConnectionPort) -> None:
+        """Register a new connection for a user."""
+        user_str = str(user_id)
+        async with self._lock:
+            if user_str not in self._connections:
+                self._connections[user_str] = set()
+            self._connections[user_str].add(connection)
+            logger.debug(
+                "Connection registered user_id=%s total=%d",
+                user_str,
+                len(self._connections[user_str]),
+            )
+
+    async def unregister(self, user_id: UserId, connection: ConnectionPort) -> None:
+        """Unregister a connection."""
+        user_str = str(user_id)
+        async with self._lock:
+            if user_str in self._connections:
+                self._connections[user_str].discard(connection)
+                if not self._connections[user_str]:
+                    del self._connections[user_str]
+                logger.debug("Connection unregistered user_id=%s", user_str)
+
+    async def broadcast(
+        self,
+        user_id: UserId,
+        message: dict[str, Any],
+        exclude: ConnectionPort | None = None,
+    ) -> int:
+        """Send message to all connections for a user.
+
+        Args:
+            user_id: User to broadcast to.
+            message: Message dict to send.
+            exclude: Optional connection to exclude (e.g., the sender).
+
+        Returns:
+            Number of connections sent to.
+        """
+        user_str = str(user_id)
+
+        async with self._lock:
+            connections = self._connections.get(user_str, set()).copy()
+
+        if exclude:
+            connections.discard(exclude)
+
+        if not connections:
+            return 0
+
+        # Send in parallel
+        async def send_one(conn: ConnectionPort) -> bool:
+            try:
+                await conn.send_message(message)
+                return True
+            except Exception as e:
+                logger.warning("Failed to broadcast to connection: %s", e)
+                return False
+
+        results = await asyncio.gather(
+            *[send_one(conn) for conn in connections],
+            return_exceptions=True,
+        )
+        count = sum(1 for r in results if r is True)
+
+        logger.debug(
+            "Broadcast to user_id=%s sent=%d/%d type=%s",
+            user_str,
+            count,
+            len(connections),
+            message.get("type"),
+        )
+        return count
+
+    def connection_count(self, user_id: UserId) -> int:
+        """Get number of connections for a user."""
+        return len(self._connections.get(str(user_id), set()))
+
+    def total_connections(self) -> int:
+        """Get total number of connections across all users."""
+        return sum(len(conns) for conns in self._connections.values())

porterminal/infrastructure/repositories/__init__.py

@@ -0,0 +1,9 @@
+"""Infrastructure repositories - data storage implementations."""
+
+from .in_memory_session import InMemorySessionRepository
+from .in_memory_tab import InMemoryTabRepository
+
+__all__ = [
+    "InMemorySessionRepository",
+    "InMemoryTabRepository",
+]

porterminal/infrastructure/repositories/in_memory_session.py

@@ -0,0 +1,70 @@
+"""In-memory session repository implementation."""
+
+from typing import TypeVar
+
+from porterminal.domain import Session, SessionId, UserId
+from porterminal.domain.ports import SessionRepository
+
+PTYHandle = TypeVar("PTYHandle")
+
+
+class InMemorySessionRepository(SessionRepository[PTYHandle]):
+    """In-memory session storage implementing SessionRepository.
+
+    Thread-safe for async usage (dict operations are atomic in CPython).
+    """
+
+    def __init__(self) -> None:
+        self._sessions: dict[str, Session[PTYHandle]] = {}
+        self._user_sessions: dict[str, set[str]] = {}
+
+    def get(self, session_id: SessionId) -> Session[PTYHandle] | None:
+        """Get session by ID."""
+        return self._sessions.get(str(session_id))
+
+    def get_by_id_str(self, session_id: str) -> Session[PTYHandle] | None:
+        """Get session by ID string."""
+        return self._sessions.get(session_id)
+
+    def get_by_user(self, user_id: UserId) -> list[Session[PTYHandle]]:
+        """Get all sessions for a user."""
+        user_str = str(user_id)
+        session_ids = self._user_sessions.get(user_str, set())
+        return [self._sessions[sid] for sid in session_ids if sid in self._sessions]
+
+    def add(self, session: Session[PTYHandle]) -> None:
+        """Add a new session."""
+        session_id = str(session.id)
+        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)
+
+    def remove(self, session_id: SessionId) -> Session[PTYHandle] | None:
+        """Remove and return a session."""
+        session_id_str = str(session_id)
+        session = self._sessions.pop(session_id_str, None)
+
+        if session:
+            user_id = str(session.user_id)
+            if user_id in self._user_sessions:
+                self._user_sessions[user_id].discard(session_id_str)
+                if not self._user_sessions[user_id]:
+                    del self._user_sessions[user_id]
+
+        return session
+
+    def count(self) -> int:
+        """Get total session count."""
+        return len(self._sessions)
+
+    def count_for_user(self, user_id: UserId) -> int:
+        """Get session count for a user."""
+        return len(self._user_sessions.get(str(user_id), set()))
+
+    def all_sessions(self) -> list[Session[PTYHandle]]:
+        """Get all sessions."""
+        return list(self._sessions.values())

porterminal/infrastructure/repositories/in_memory_tab.py

@@ -0,0 +1,124 @@
+"""In-memory tab repository implementation."""
+
+from porterminal.domain import SessionId, Tab, TabId, UserId
+from porterminal.domain.ports import TabRepository
+
+
+class InMemoryTabRepository(TabRepository):
+    """In-memory tab storage implementing TabRepository.
+
+    Thread-safe for async usage (dict operations are atomic in CPython).
+    Uses dual-indexing for efficient lookups by user and session.
+    """
+
+    def __init__(self) -> None:
+        self._tabs: dict[str, Tab] = {}
+        self._user_tabs: dict[str, set[str]] = {}  # user_id -> {tab_ids}
+        self._session_tabs: dict[str, set[str]] = {}  # session_id -> {tab_ids}
+
+    def get(self, tab_id: TabId) -> Tab | None:
+        """Get tab by ID."""
+        return self._tabs.get(str(tab_id))
+
+    def get_by_id_str(self, tab_id: str) -> Tab | None:
+        """Get tab by ID string."""
+        return self._tabs.get(tab_id)
+
+    def get_by_user(self, user_id: UserId) -> list[Tab]:
+        """Get all tabs for a user (ordered by created_at ASC)."""
+        user_str = str(user_id)
+        tab_ids = self._user_tabs.get(user_str, set())
+        tabs = [self._tabs[tid] for tid in tab_ids if tid in self._tabs]
+        return sorted(tabs, key=lambda t: t.created_at)
+
+    def get_by_session(self, session_id: SessionId) -> list[Tab]:
+        """Get all tabs referencing a specific session."""
+        session_str = str(session_id)
+        tab_ids = self._session_tabs.get(session_str, set())
+        return [self._tabs[tid] for tid in tab_ids if tid in self._tabs]
+
+    def add(self, tab: Tab) -> None:
+        """Add a new tab."""
+        tab_id = str(tab.id)
+        user_id = str(tab.user_id)
+        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)
+
+    def update(self, tab: Tab) -> None:
+        """Update an existing tab (name, last_accessed)."""
+        tab_id = str(tab.id)
+        if tab_id in self._tabs:
+            self._tabs[tab_id] = tab
+
+    def remove(self, tab_id: TabId) -> Tab | None:
+        """Remove and return a tab."""
+        tab_id_str = str(tab_id)
+        tab = self._tabs.pop(tab_id_str, None)
+
+        if tab:
+            user_id = str(tab.user_id)
+            session_id = str(tab.session_id)
+
+            # Clean up user index
+            if user_id in self._user_tabs:
+                self._user_tabs[user_id].discard(tab_id_str)
+                if not self._user_tabs[user_id]:
+                    del self._user_tabs[user_id]
+
+            # Clean up session index
+            if session_id in self._session_tabs:
+                self._session_tabs[session_id].discard(tab_id_str)
+                if not self._session_tabs[session_id]:
+                    del self._session_tabs[session_id]
+
+        return tab
+
+    def remove_by_session(self, session_id: SessionId) -> list[Tab]:
+        """Remove all tabs referencing a session (cascade).
+
+        Returns:
+            List of removed tabs.
+        """
+        session_str = str(session_id)
+        tab_ids = list(self._session_tabs.get(session_str, set()))
+
+        removed = []
+        for tab_id_str in tab_ids:
+            tab = self._tabs.pop(tab_id_str, None)
+            if tab:
+                removed.append(tab)
+                # Clean up user index
+                user_id = str(tab.user_id)
+                if user_id in self._user_tabs:
+                    self._user_tabs[user_id].discard(tab_id_str)
+                    if not self._user_tabs[user_id]:
+                        del self._user_tabs[user_id]
+
+        # Clean up session index
+        if session_str in self._session_tabs:
+            del self._session_tabs[session_str]
+
+        return removed
+
+    def count(self) -> int:
+        """Get total tab count."""
+        return len(self._tabs)
+
+    def count_for_user(self, user_id: UserId) -> int:
+        """Get tab count for a user."""
+        return len(self._user_tabs.get(str(user_id), set()))
+
+    def all_tabs(self) -> list[Tab]:
+        """Get all tabs."""
+        return list(self._tabs.values())

porterminal/infrastructure/server.py

@@ -0,0 +1,161 @@
+"""Server and tunnel management utilities."""
+
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+import urllib.request
+
+from rich.console import Console
+
+console = Console()
+
+
+def wait_for_server(host: str, port: int, timeout: int = 30) -> bool:
+    """Wait for the server to be ready and verify it's Porterminal.
+
+    Args:
+        host: Server host address.
+        port: Server port number.
+        timeout: Maximum seconds to wait.
+
+    Returns:
+        True if server is ready, False otherwise.
+    """
+    start_time = time.time()
+    url = f"http://{host}:{port}/health"
+
+    while time.time() - start_time < timeout:
+        try:
+            with urllib.request.urlopen(url, timeout=2) as response:
+                if response.status == 200:
+                    # Verify it's actually Porterminal by checking response structure
+                    try:
+                        data = json.loads(response.read().decode("utf-8"))
+                        if data.get("status") == "healthy" and "sessions" in data:
+                            return True
+                    except (json.JSONDecodeError, UnicodeDecodeError):
+                        pass
+        except (urllib.error.URLError, OSError, TimeoutError):
+            pass
+        time.sleep(0.5)
+
+    return False
+
+
+def start_server(host: str, port: int, *, verbose: bool = False) -> subprocess.Popen:
+    """Start the uvicorn server.
+
+    Args:
+        host: Host address to bind.
+        port: Port number to bind.
+        verbose: If True, show server logs directly.
+
+    Returns:
+        Popen process object for the server.
+    """
+    cmd = [
+        sys.executable,
+        "-m",
+        "uvicorn",
+        "porterminal.app:app",
+        "--host",
+        host,
+        "--port",
+        str(port),
+        "--log-level",
+        "debug" if verbose else "warning",
+        "--no-access-log",  # Disable access logging
+    ]
+
+    if verbose:
+        # Let output go directly to console
+        process = subprocess.Popen(cmd)
+    else:
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+
+    return process
+
+
+def start_cloudflared(port: int) -> tuple[subprocess.Popen, str | None]:
+    """Start cloudflared tunnel and return the URL.
+
+    Args:
+        port: Local port to tunnel.
+
+    Returns:
+        Tuple of (process, url) where url may be None if tunnel failed.
+    """
+    cmd = [
+        "cloudflared",
+        "tunnel",
+        "--no-autoupdate",
+        "--protocol",
+        "http2",  # Use HTTP/2 instead of QUIC (more reliable on Windows)
+        "--config",
+        os.devnull,  # Ignore any config files (cross-platform)
+        "--origincert",
+        os.devnull,  # Skip origin certificate (cross-platform)
+        "--url",
+        f"http://127.0.0.1:{port}",  # Use 127.0.0.1 explicitly
+    ]
+
+    # Clear cloudflared config to ensure clean quick tunnel
+    env = os.environ.copy()
+    env["TUNNEL_ORIGIN_CERT"] = ""
+    env["NO_AUTOUPDATE"] = "true"
+    # Point to a non-existent config to force quick tunnel mode
+    env["TUNNEL_CONFIG"] = os.devnull
+
+    process = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        env=env,
+    )
+
+    # Parse URL from cloudflared output (flexible pattern for different Cloudflare domains)
+    url_pattern = re.compile(r"https://[a-z0-9-]+\.(trycloudflare\.com|cloudflare-tunnel\.com)")
+    url = None
+
+    # Read output until we find the URL
+    for line in iter(process.stdout.readline, ""):
+        if process.poll() is not None:
+            break
+
+        match = url_pattern.search(line)
+        if match:
+            url = match.group(0)
+            break
+
+        # Also check for errors
+        if "error" in line.lower():
+            console.print(f"[red]Cloudflared error:[/red] {line.strip()}")
+
+    return process, url
+
+
+def drain_process_output(process: subprocess.Popen) -> None:
+    """Drain process output silently (only print errors).
+
+    Args:
+        process: Subprocess to drain output from.
+    """
+    try:
+        for line in iter(process.stdout.readline, ""):
+            if not line:
+                break
+            line = line.strip()
+            if line and "error" in line.lower():
+                console.print(f"[red]{line}[/red]")
+    except (OSError, ValueError):
+        pass

porterminal/infrastructure/web/__init__.py

@@ -0,0 +1,7 @@
+"""Web infrastructure - FastAPI adapters."""
+
+from .websocket_adapter import FastAPIWebSocketAdapter
+
+__all__ = [
+    "FastAPIWebSocketAdapter",
+]

porterminal/infrastructure/web/websocket_adapter.py

@@ -0,0 +1,78 @@
+"""FastAPI WebSocket adapter implementing ConnectionPort."""
+
+import json
+from typing import Any
+
+from fastapi import WebSocket
+from starlette.websockets import WebSocketDisconnect
+
+from porterminal.application.ports import ConnectionPort
+
+
+class FastAPIWebSocketAdapter(ConnectionPort):
+    """Adapts FastAPI WebSocket to ConnectionPort protocol."""
+
+    def __init__(self, websocket: WebSocket) -> None:
+        self._websocket = websocket
+        self._closed = False
+
+    async def send_output(self, data: bytes) -> None:
+        """Send terminal output to client."""
+        if not self._closed:
+            try:
+                await self._websocket.send_bytes(data)
+            except Exception:
+                self._closed = True
+
+    async def send_message(self, message: dict[str, Any]) -> None:
+        """Send JSON control message to client."""
+        if not self._closed:
+            try:
+                await self._websocket.send_json(message)
+            except Exception:
+                self._closed = True
+
+    async def receive(self) -> dict[str, Any] | bytes:
+        """Receive message from client (binary or JSON).
+
+        Returns:
+            bytes for terminal input, dict for control messages.
+
+        Raises:
+            WebSocketDisconnect: If connection is closed.
+        """
+        try:
+            message = await self._websocket.receive()
+        except WebSocketDisconnect:
+            self._closed = True
+            raise
+
+        if message.get("bytes"):
+            return message["bytes"]
+        elif message.get("text"):
+            return json.loads(message["text"])
+
+        # Handle disconnect message
+        if message.get("type") == "websocket.disconnect":
+            self._closed = True
+            raise WebSocketDisconnect()
+
+        raise ValueError(f"Unknown message type: {message.get('type')}")
+
+    async def close(self, code: int = 1000, reason: str = "") -> None:
+        """Close the connection."""
+        if not self._closed:
+            self._closed = True
+            try:
+                await self._websocket.close(code=code, reason=reason)
+            except Exception:
+                pass
+
+    def is_connected(self) -> bool:
+        """Check if connection is still open."""
+        return not self._closed
+
+    @property
+    def websocket(self) -> WebSocket:
+        """Get underlying WebSocket (for compatibility)."""
+        return self._websocket

porterminal/logging_setup.py

@@ -0,0 +1,48 @@
+"""Logging setup for the Porterminal server."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+
+class CleanFormatter(logging.Formatter):
+    """Clean log formatter with minimal output."""
+
+    FORMATS = {
+        logging.DEBUG: "\033[90m[DEBUG]\033[0m %(message)s",
+        logging.INFO: "\033[36m[INFO]\033[0m %(message)s",
+        logging.WARNING: "\033[33m[WARN]\033[0m %(message)s",
+        logging.ERROR: "\033[31m[ERROR]\033[0m %(message)s",
+        logging.CRITICAL: "\033[31;1m[CRIT]\033[0m %(message)s",
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        fmt = self.FORMATS.get(record.levelno, "[%(levelname)s] %(message)s")
+        formatter = logging.Formatter(fmt)
+        return formatter.format(record)
+
+
+def setup_logging_from_env() -> None:
+    """Configure root logging with clean format."""
+    level_name = (os.environ.get("PORTERMINAL_LOG_LEVEL") or "info").upper()
+    level = getattr(logging, level_name, logging.INFO)
+
+    root = logging.getLogger()
+
+    # Remove existing handlers
+    for handler in root.handlers[:]:
+        root.removeHandler(handler)
+
+    # Add clean handler
+    handler = logging.StreamHandler()
+    handler.setFormatter(CleanFormatter())
+    root.addHandler(handler)
+    root.setLevel(level)
+
+    # Set level for app loggers
+    logging.getLogger("src").setLevel(level)
+
+    # Suppress noisy loggers
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.error").setLevel(logging.WARNING)

porterminal/pty/__init__.py

@@ -0,0 +1,46 @@
+"""
+PTY management with cross-platform support.
+
+This package provides:
+- PTYBackend Protocol for platform-specific implementations
+- SecurePTYManager for secure PTY management with env sanitization
+- Platform-specific backends (Windows, Unix)
+"""
+
+import sys
+
+from .env import BLOCKED_ENV_VARS, SAFE_ENV_VARS, build_safe_environment
+from .manager import SecurePTYManager
+from .protocol import PTYBackend
+
+__all__ = [
+    # Protocol
+    "PTYBackend",
+    # Manager
+    "SecurePTYManager",
+    # Backends
+    "create_backend",
+    # Environment
+    "SAFE_ENV_VARS",
+    "BLOCKED_ENV_VARS",
+    "build_safe_environment",
+]
+
+
+def create_backend() -> PTYBackend:
+    """Create platform-appropriate PTY backend.
+
+    Returns:
+        PTYBackend instance for the current platform.
+
+    Raises:
+        RuntimeError: If no suitable backend is available.
+    """
+    if sys.platform == "win32":
+        from .windows import WindowsPTYBackend
+
+        return WindowsPTYBackend()
+    else:
+        from .unix import UnixPTYBackend
+
+        return UnixPTYBackend()