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

porterminal/__init__.py

@@ -8,9 +8,13 @@ This package provides:
 - Configuration system with shell auto-detection
 """
 
-__version__ = "0.1.4"
+try:
+    from ._version import __version__
+except ImportError:
+    __version__ = "0.0.0-dev"  # Fallback before first build
 
 import os
+import signal
 import subprocess
 import sys
 import time
@@ -139,8 +143,37 @@ def _run_in_background(args) -> int:
 def main() -> int:
     """Main entry point."""
     args = parse_args()
+
+    # Check for updates (notification only, never exec's)
+    from porterminal.updater import check_and_notify
+
+    check_and_notify()
     verbose = args.verbose
 
+    # Load config to check require_password setting
+    from porterminal.config import get_config
+
+    config = get_config()
+
+    # Handle password mode (CLI flag or config setting)
+    if args.password or config.security.require_password:
+        import getpass
+
+        try:
+            password = getpass.getpass("Enter password: ")
+            if not password:
+                console.print("[red]Error:[/red] Password cannot be empty")
+                return 1
+
+            import bcrypt
+
+            password_hash = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
+            os.environ["PORTERMINAL_PASSWORD_HASH"] = password_hash.decode()
+            console.print("[green]Password protection enabled[/green]")
+        except KeyboardInterrupt:
+            console.print("\n[dim]Cancelled[/dim]")
+            return 0
+
     # Handle background mode
     if args.background:
         return _run_in_background(args)
@@ -162,9 +195,6 @@ def main() -> int:
         cwd_str = str(cwd)
         os.environ["PORTERMINAL_CWD"] = cwd_str
 
-    from porterminal.config import get_config
-
-    config = get_config()
     bind_host = config.server.host
     preferred_port = config.server.port
     port = preferred_port
@@ -218,6 +248,10 @@ def main() -> int:
             status.update("[cyan]Establishing tunnel...[/cyan]")
             tunnel_process, tunnel_url = start_cloudflared(port)
 
+            if tunnel_url:
+                # Wait for tunnel to stabilize before showing URL
+                time.sleep(1)
+
             if not tunnel_url:
                 console.print("[red]Error:[/red] Failed to establish tunnel")
                 for proc in [server_process, tunnel_process]:
@@ -257,10 +291,18 @@ def main() -> int:
     try:
         while True:
             if server_process is not None and server_process.poll() is not None:
-                console.print("\n[red]Server stopped unexpectedly[/red]")
+                code = server_process.returncode
+                if code == 0 or code < 0:
+                    console.print("\n[dim]Server stopped[/dim]")
+                else:
+                    console.print(f"\n[yellow]Server stopped (exit code {code})[/yellow]")
                 break
             if tunnel_process is not None and tunnel_process.poll() is not None:
-                console.print("\n[red]Tunnel stopped unexpectedly[/red]")
+                code = tunnel_process.returncode
+                if code == 0 or code < 0:
+                    console.print("\n[dim]Tunnel closed[/dim]")
+                else:
+                    console.print(f"\n[yellow]Tunnel stopped (exit code {code})[/yellow]")
                 break
             time.sleep(1)
 
@@ -271,15 +313,41 @@ def main() -> int:
     def cleanup_process(proc: subprocess.Popen | None, name: str) -> None:
         if proc is None or proc.poll() is not None:
             return
-        try:
-            proc.terminate()
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.wait()  # Reap the killed process
 
-    cleanup_process(server_process, "server")
-    cleanup_process(tunnel_process, "tunnel")
+        if sys.platform == "win32":
+            # Windows: use taskkill /T to kill entire process tree
+            try:
+                subprocess.run(
+                    ["taskkill", "/T", "/F", "/PID", str(proc.pid)],
+                    capture_output=True,
+                    timeout=10,
+                )
+                # Wait for process to actually terminate
+                proc.wait(timeout=5)
+            except (subprocess.TimeoutExpired, OSError):
+                # Last resort: try to kill just the main process
+                try:
+                    proc.kill()
+                    proc.wait(timeout=2)
+                except (OSError, subprocess.TimeoutExpired):
+                    pass
+        else:
+            # Unix: terminate gracefully, then kill
+            try:
+                proc.terminate()
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait()
+
+    # Ignore Ctrl+C during cleanup to prevent orphaned processes
+    # Cleanup has timeouts so it won't hang forever
+    old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    try:
+        cleanup_process(server_process, "server")
+        cleanup_process(tunnel_process, "tunnel")
+    finally:
+        signal.signal(signal.SIGINT, old_handler)
 
     return 0
 

porterminal/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)
+
+__commit_id__ = commit_id = None

porterminal/app.py

@@ -13,9 +13,11 @@ from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from starlette.middleware.base import RequestResponseEndpoint
 
+from . import __version__
 from .composition import create_container
 from .container import Container
 from .domain import UserId
+from .infrastructure.auth import authenticate_connection, validate_auth_message
 from .infrastructure.web import FastAPIWebSocketAdapter
 from .logging_setup import setup_logging_from_env
 
@@ -51,10 +53,15 @@ async def lifespan(app: FastAPI):
     security_preflight_checks()
 
     # Create DI container with all wired dependencies
-    config_path = os.environ.get("PORTERMINAL_CONFIG_PATH", "config.yaml")
+    # config_path=None uses find_config_file() to search standard locations
     cwd = os.environ.get("PORTERMINAL_CWD")
 
-    container = create_container(config_path=config_path, cwd=cwd)
+    # Get password hash from environment if set
+    password_hash = None
+    if hash_str := os.environ.get("PORTERMINAL_PASSWORD_HASH"):
+        password_hash = hash_str.encode()
+
+    container = create_container(config_path=None, cwd=cwd, password_hash=password_hash)
     app.state.container = container
 
     # Wire up cascade: when session is destroyed, close associated tabs and broadcast
@@ -82,7 +89,7 @@ def create_app() -> FastAPI:
     app = FastAPI(
         title="Porterminal",
         description="Web-based terminal accessible from phone via Cloudflare Tunnel",
-        version="0.1.2",
+        version=__version__,
         lifespan=lifespan,
     )
 
@@ -224,6 +231,17 @@ def create_app() -> FastAPI:
         )
 
         try:
+            # Authentication phase if password is set
+            if container.password_hash is not None:
+                authenticated = await authenticate_connection(
+                    connection,
+                    container.password_hash,
+                    max_attempts=container.max_auth_attempts,
+                )
+                if not authenticated:
+                    await websocket.close(code=4001, reason="Auth failed")
+                    return
+
             # Register for broadcasts
             await connection_registry.register(user_id, connection)
 
@@ -332,6 +350,13 @@ def create_app() -> FastAPI:
             session.session_id,
         )
 
+        # Authentication check if password is set
+        if container.password_hash is not None:
+            if not await validate_auth_message(connection, container.password_hash):
+                logger.warning("Terminal WebSocket auth failed user_id=%s", user_id)
+                await websocket.close(code=4001, reason="Auth failed")
+                return
+
         # Update tab access time
         tab_service.touch_tab(tab_id, user_id)
 
@@ -339,13 +364,16 @@ def create_app() -> FastAPI:
             # Register connection for broadcasts
             await connection_registry.register(user_id, connection)
 
-            # Send session info
+            # Send session info including current dimensions
+            # New clients should adapt to existing dimensions to prevent rendering issues
             await connection.send_message(
                 {
                     "type": "session_info",
                     "session_id": session.session_id,
                     "shell": session.shell_id,
                     "tab_id": tab.tab_id,
+                    "cols": session.dimensions.cols,
+                    "rows": session.dimensions.rows,
                 }
             )
 

porterminal/application/ports/__init__.py

@@ -1,7 +1,9 @@
 """Application layer ports - interfaces for presentation layer."""
 
 from .connection_port import ConnectionPort
+from .connection_registry_port import ConnectionRegistryPort
 
 __all__ = [
     "ConnectionPort",
+    "ConnectionRegistryPort",
 ]

porterminal/application/ports/connection_registry_port.py

@@ -0,0 +1,46 @@
+"""Connection registry port - interface for broadcasting to user connections."""
+
+from typing import TYPE_CHECKING, Any, Protocol
+
+if TYPE_CHECKING:
+    from porterminal.domain import UserId
+
+    from .connection_port import ConnectionPort
+
+
+class ConnectionRegistryPort(Protocol):
+    """Protocol for managing and broadcasting to user connections.
+
+    Infrastructure layer (e.g., UserConnectionRegistry) implements this.
+    Application layer uses this interface for broadcasting messages.
+    """
+
+    async def register(self, user_id: "UserId", connection: "ConnectionPort") -> None:
+        """Register a new connection for a user."""
+        ...
+
+    async def unregister(self, user_id: "UserId", connection: "ConnectionPort") -> None:
+        """Unregister a connection."""
+        ...
+
+    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.
+        """
+        ...
+
+    def total_connections(self) -> int:
+        """Get total number of connections across all users."""
+        ...

porterminal/application/services/management_service.py

@@ -3,7 +3,7 @@
 import logging
 from collections.abc import Callable
 
-from porterminal.application.ports import ConnectionPort
+from porterminal.application.ports import ConnectionPort, ConnectionRegistryPort
 from porterminal.application.services.session_service import SessionService
 from porterminal.application.services.tab_service import TabService
 from porterminal.domain import (
@@ -11,7 +11,6 @@ from porterminal.domain import (
     TerminalDimensions,
     UserId,
 )
-from porterminal.infrastructure.registry import UserConnectionRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +26,7 @@ class ManagementService:
         self,
         session_service: SessionService,
         tab_service: TabService,
-        connection_registry: UserConnectionRegistry,
+        connection_registry: ConnectionRegistryPort,
         shell_provider: Callable[[str | None], ShellCommand | None],
         default_dimensions: TerminalDimensions,
     ) -> None:

porterminal/application/services/terminal_service.py

@@ -63,11 +63,23 @@ class TerminalService:
         # Multi-client support: track connections and read loops per session
         self._session_connections: dict[str, set[ConnectionPort]] = {}
         self._session_read_tasks: dict[str, asyncio.Task[None]] = {}
+        # Per-session locks to prevent race between buffer replay and broadcast
+        self._session_locks: dict[str, asyncio.Lock] = {}
 
     # -------------------------------------------------------------------------
     # Multi-client connection tracking
     # -------------------------------------------------------------------------
 
+    def _get_session_lock(self, session_id: str) -> asyncio.Lock:
+        """Get or create a lock for a session."""
+        if session_id not in self._session_locks:
+            self._session_locks[session_id] = asyncio.Lock()
+        return self._session_locks[session_id]
+
+    def _cleanup_session_lock(self, session_id: str) -> None:
+        """Remove session lock when no longer needed."""
+        self._session_locks.pop(session_id, None)
+
     def _register_connection(self, session_id: str, connection: ConnectionPort) -> int:
         """Register a connection for a session. Returns connection count."""
         if session_id not in self._session_connections:
@@ -85,8 +97,21 @@ class TerminalService:
             del self._session_connections[session_id]
         return count
 
+    async def _send_to_connections(self, connections: list[ConnectionPort], data: bytes) -> None:
+        """Send data to a list of connections (used with pre-snapshotted list)."""
+        for conn in connections:
+            try:
+                await conn.send_output(data)
+            except Exception:
+                pass  # Connection cleanup handled elsewhere
+
     async def _broadcast_output(self, session_id: str, data: bytes) -> None:
-        """Broadcast PTY output to all connections for a session."""
+        """Broadcast PTY output to all connections for a session.
+
+        Note: This is only used for error/status messages where the race
+        condition doesn't matter. For PTY data, use _send_to_connections
+        with a lock-protected snapshot.
+        """
         connections = self._session_connections.get(session_id, set())
         dead: list[ConnectionPort] = []
         for conn in list(connections):  # Copy to avoid mutation during iteration
@@ -128,31 +153,41 @@ class TerminalService:
         session_id = str(session.id)
         clock = AsyncioClock()
         rate_limiter = TokenBucketRateLimiter(self._rate_limit_config, clock)
+        lock = self._get_session_lock(session_id)
+
+        # Register atomically to prevent race with broadcast.
+        # Without this lock, a new client could register between add_output and
+        # broadcast, receiving the same data twice (once from buffer, once broadcast).
+        #
+        # Buffer snapshot and read loop start are also under lock to ensure:
+        # - Buffer is captured before any new data arrives
+        # - Only one read loop starts per session (prevents duplicate PTY reads)
+        # - I/O (send_output) happens OUTSIDE lock to avoid blocking other clients
+        buffered = None
+        async with lock:
+            connection_count = self._register_connection(session_id, connection)
+            is_first_client = connection_count == 1
 
-        # Register this connection
-        connection_count = self._register_connection(session_id, connection)
-        is_first_client = connection_count == 1
-
-        logger.info(
-            "Client connected session_id=%s connection_count=%d",
-            session_id,
-            connection_count,
-        )
+            logger.info(
+                "Client connected session_id=%s connection_count=%d",
+                session_id,
+                connection_count,
+            )
 
-        try:
-            # First client starts the shared PTY read loop
+            # First client starts the shared PTY read loop (under lock to prevent duplicates)
             if is_first_client:
                 self._start_broadcast_read_loop(session, session_id)
 
+            # Snapshot buffer while under lock (ensures consistency with broadcast)
             # Note: session_info is sent by the caller (app.py) to include tab_id
-
-            # Replay buffered output to THIS connection only (not broadcast)
             if not skip_buffer and not session.output_buffer.is_empty:
                 buffered = session.get_buffered_output()
-                # Don't clear buffer - other clients may need it too
-                if buffered:
-                    await connection.send_output(buffered)
 
+        # Replay buffer OUTSIDE lock to avoid blocking other clients during I/O
+        if buffered:
+            await connection.send_output(buffered)
+
+        try:
             # Start heartbeat for this connection
             heartbeat_task = asyncio.create_task(self._heartbeat_loop(connection))
 
@@ -173,9 +208,10 @@ class TerminalService:
                 remaining,
             )
 
-            # Last client: stop the read loop
+            # Last client: stop the read loop and cleanup lock
             if remaining == 0:
                 await self._stop_broadcast_read_loop(session_id)
+                self._cleanup_session_lock(session_id)
 
     def _start_broadcast_read_loop(
         self,
@@ -212,6 +248,11 @@ class TerminalService:
         - Small data (<64 bytes): flush immediately for interactive responsiveness
         - Large data: batch for ~16ms to reduce WebSocket message frequency
         - Flush if batch exceeds 16KB to prevent memory buildup
+
+        Thread safety:
+        - Uses session lock to prevent race between add_output/broadcast and
+          new client registration/buffer replay. Lock is held briefly during
+          buffer update and connection snapshot, not during actual I/O.
         """
         # Check if PTY is alive at start
         if not session.pty_handle.is_alive():
@@ -219,18 +260,29 @@ class TerminalService:
             await self._broadcast_output(session_id, b"\r\n[PTY failed to start]\r\n")
             return
 
+        lock = self._get_session_lock(session_id)
         batch_buffer: list[bytes] = []
         batch_size = 0
         last_flush_time = asyncio.get_running_loop().time()
 
         async def flush_batch() -> None:
+            """Flush batched data with lock protection."""
             nonlocal batch_buffer, batch_size, last_flush_time
-            if batch_buffer:
-                combined = b"".join(batch_buffer)
-                batch_buffer = []
-                batch_size = 0
-                last_flush_time = asyncio.get_running_loop().time()
-                await self._broadcast_output(session_id, combined)
+            if not batch_buffer:
+                return
+
+            combined = b"".join(batch_buffer)
+            batch_buffer = []
+            batch_size = 0
+            last_flush_time = asyncio.get_running_loop().time()
+
+            # Acquire lock, add to buffer, snapshot connections, release lock
+            async with lock:
+                session.add_output(combined)
+                connections = list(self._session_connections.get(session_id, set()))
+
+            # Broadcast outside lock (I/O can be slow)
+            await self._send_to_connections(connections, combined)
 
         def has_connections() -> bool:
             return (
@@ -242,12 +294,16 @@ class TerminalService:
             try:
                 data = session.pty_handle.read(4096)
                 if data:
-                    session.add_output(data)
                     session.touch(datetime.now(UTC))
 
                     # Small data (interactive): flush immediately for responsiveness
                     if len(data) < INTERACTIVE_THRESHOLD and not batch_buffer:
-                        await self._broadcast_output(session_id, data)
+                        # Acquire lock, add to buffer, snapshot connections
+                        async with lock:
+                            session.add_output(data)
+                            connections = list(self._session_connections.get(session_id, set()))
+                        # Broadcast outside lock
+                        await self._send_to_connections(connections, data)
                     else:
                         # Batch larger data
                         batch_buffer.append(data)
@@ -351,7 +407,7 @@ class TerminalService:
         msg_type = message.get("type")
 
         if msg_type == "resize":
-            await self._handle_resize(session, message)
+            await self._handle_resize(session, message, connection)
         elif msg_type == "input":
             await self._handle_json_input(session, message, rate_limiter, connection)
         elif msg_type == "ping":
@@ -366,8 +422,17 @@ class TerminalService:
         self,
         session: Session[PTYPort],
         message: dict[str, Any],
+        connection: ConnectionPort,
     ) -> None:
-        """Handle terminal resize message."""
+        """Handle terminal resize message.
+
+        Multi-client strategy:
+        - When multiple clients share a session, PTY dimensions are locked
+        - Only the first client (or when all clients agree) can resize
+        - New clients receive current dimensions and must adapt locally
+        - This prevents rendering artifacts from dimension mismatches
+        """
+        session_id = str(session.id)
         cols = int(message.get("cols", 120))
         rows = int(message.get("rows", 30))
 
@@ -377,6 +442,29 @@ class TerminalService:
         if session.dimensions == new_dims:
             return
 
+        # Check if multiple clients are connected
+        connections = self._session_connections.get(session_id, set())
+        if len(connections) > 1:
+            # Multiple clients: reject resize, tell client to use current dimensions
+            logger.info(
+                "Resize rejected (multi-client) session_id=%s requested=%dx%d current=%dx%d",
+                session.id,
+                new_dims.cols,
+                new_dims.rows,
+                session.dimensions.cols,
+                session.dimensions.rows,
+            )
+            # Send current dimensions back so client can adapt
+            await connection.send_message(
+                {
+                    "type": "resize_sync",
+                    "cols": session.dimensions.cols,
+                    "rows": session.dimensions.rows,
+                }
+            )
+            return
+
+        # Single client: allow resize
         session.update_dimensions(new_dims)
         session.pty_handle.resize(new_dims)
         session.touch(datetime.now(UTC))

porterminal/asgi.py

@@ -17,15 +17,20 @@ def create_app_from_env():
 
     This is called by uvicorn when using the --factory flag.
     Environment variables:
-        PORTERMINAL_CONFIG_PATH: Path to config file (default: config.yaml)
+        PORTERMINAL_CONFIG_PATH: Path to config file (overrides search)
         PORTERMINAL_CWD: Working directory for PTY sessions
+
+    Config search order (when env var not set):
+        1. ptn.yaml in cwd
+        2. .ptn/ptn.yaml in cwd
+        3. ~/.ptn/ptn.yaml
     """
     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)
+    # config_path=None uses find_config_file() to search standard locations
+    container = create_container(config_path=None, cwd=cwd)
 
     # Create app with container
     # Note: The current app.py doesn't accept container yet,