ptn 0.1.4__py3-none-any.whl

porterminal/application/ports/connection_port.py

@@ -0,0 +1,34 @@
+"""Connection port - interface for terminal network connections."""
+
+from typing import Protocol
+
+
+class ConnectionPort(Protocol):
+    """Protocol for terminal I/O over network connection.
+
+    Presentation layer (e.g., WebSocket adapter) implements this.
+    """
+
+    async def send_output(self, data: bytes) -> None:
+        """Send terminal output to client."""
+        ...
+
+    async def send_message(self, message: dict) -> None:
+        """Send JSON control message to client."""
+        ...
+
+    async def receive(self) -> dict | bytes:
+        """Receive message from client (binary or JSON).
+
+        Returns:
+            bytes for terminal input, dict for control messages.
+        """
+        ...
+
+    async def close(self, code: int = 1000, reason: str = "") -> None:
+        """Close the connection."""
+        ...
+
+    def is_connected(self) -> bool:
+        """Check if connection is still open."""
+        ...

porterminal/application/services/__init__.py

@@ -0,0 +1,13 @@
+"""Application services - use case implementations."""
+
+from .management_service import ManagementService
+from .session_service import SessionService
+from .tab_service import TabService
+from .terminal_service import TerminalService
+
+__all__ = [
+    "ManagementService",
+    "SessionService",
+    "TabService",
+    "TerminalService",
+]

porterminal/application/services/management_service.py

@@ -0,0 +1,279 @@
+"""Management service - handles tab management requests via WebSocket."""
+
+import logging
+from collections.abc import Callable
+
+from porterminal.application.ports import ConnectionPort
+from porterminal.application.services.session_service import SessionService
+from porterminal.application.services.tab_service import TabService
+from porterminal.domain import (
+    ShellCommand,
+    TerminalDimensions,
+    UserId,
+)
+from porterminal.infrastructure.registry import UserConnectionRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class ManagementService:
+    """Service for handling management WebSocket messages.
+
+    Handles tab creation, closure, and rename requests.
+    Broadcasts state updates to other connections.
+    """
+
+    def __init__(
+        self,
+        session_service: SessionService,
+        tab_service: TabService,
+        connection_registry: UserConnectionRegistry,
+        shell_provider: Callable[[str | None], ShellCommand | None],
+        default_dimensions: TerminalDimensions,
+    ) -> None:
+        self._session_service = session_service
+        self._tab_service = tab_service
+        self._registry = connection_registry
+        self._get_shell = shell_provider
+        self._default_dims = default_dimensions
+
+    async def handle_message(
+        self,
+        user_id: UserId,
+        connection: ConnectionPort,
+        message: dict,
+    ) -> None:
+        """Handle an incoming management message.
+
+        Args:
+            user_id: User sending the message.
+            connection: Connection that received the message.
+            message: Message dict with 'type' and request data.
+        """
+        msg_type = message.get("type")
+
+        if msg_type == "create_tab":
+            await self._handle_create_tab(user_id, connection, message)
+        elif msg_type == "close_tab":
+            await self._handle_close_tab(user_id, connection, message)
+        elif msg_type == "rename_tab":
+            await self._handle_rename_tab(user_id, connection, message)
+        elif msg_type == "ping":
+            await connection.send_message({"type": "pong"})
+        else:
+            logger.warning("Unknown management message type: %s", msg_type)
+
+    async def _handle_create_tab(
+        self,
+        user_id: UserId,
+        connection: ConnectionPort,
+        message: dict,
+    ) -> None:
+        """Handle tab creation request."""
+        request_id = message.get("request_id", "")
+        shell_id = message.get("shell_id")
+
+        try:
+            # Get shell
+            shell = self._get_shell(shell_id)
+            if not shell:
+                await connection.send_message(
+                    {
+                        "type": "create_tab_response",
+                        "request_id": request_id,
+                        "success": False,
+                        "error": "Invalid shell",
+                    }
+                )
+                return
+
+            # Create session
+            session = await self._session_service.create_session(
+                user_id=user_id,
+                shell=shell,
+                dimensions=self._default_dims,
+            )
+            session.add_client()
+
+            # Create tab
+            tab = self._tab_service.create_tab(
+                user_id=user_id,
+                session_id=session.id,
+                shell_id=shell.id,
+            )
+
+            logger.info(
+                "Management created tab user_id=%s tab_id=%s session_id=%s",
+                user_id,
+                tab.tab_id,
+                session.session_id,
+            )
+
+            # Send response to requester
+            await connection.send_message(
+                {
+                    "type": "create_tab_response",
+                    "request_id": request_id,
+                    "success": True,
+                    "tab": tab.to_dict(),
+                }
+            )
+
+            # Broadcast update to OTHER connections
+            await self._registry.broadcast(
+                user_id,
+                self._tab_service.build_tab_state_update("add", tab),
+                exclude=connection,
+            )
+
+        except ValueError as e:
+            logger.warning("Tab creation failed: %s", e)
+            await connection.send_message(
+                {
+                    "type": "create_tab_response",
+                    "request_id": request_id,
+                    "success": False,
+                    "error": str(e),
+                }
+            )
+
+    async def _handle_close_tab(
+        self,
+        user_id: UserId,
+        connection: ConnectionPort,
+        message: dict,
+    ) -> None:
+        """Handle tab close request."""
+        request_id = message.get("request_id", "")
+        tab_id = message.get("tab_id")
+
+        if not tab_id:
+            await connection.send_message(
+                {
+                    "type": "close_tab_response",
+                    "request_id": request_id,
+                    "success": False,
+                    "error": "Missing tab_id",
+                }
+            )
+            return
+
+        # Get tab and session info before closing
+        tab = self._tab_service.get_tab(tab_id)
+        if not tab:
+            await connection.send_message(
+                {
+                    "type": "close_tab_response",
+                    "request_id": request_id,
+                    "success": False,
+                    "error": "Tab not found",
+                }
+            )
+            return
+
+        session_id = tab.session_id
+
+        # Close the tab
+        closed_tab = self._tab_service.close_tab(tab_id, user_id)
+        if not closed_tab:
+            await connection.send_message(
+                {
+                    "type": "close_tab_response",
+                    "request_id": request_id,
+                    "success": False,
+                    "error": "Failed to close tab",
+                }
+            )
+            return
+
+        # Destroy the session (which will stop the PTY)
+        await self._session_service.destroy_session(session_id)
+
+        logger.info(
+            "Management closed tab user_id=%s tab_id=%s",
+            user_id,
+            tab_id,
+        )
+
+        # Send response to requester
+        await connection.send_message(
+            {
+                "type": "close_tab_response",
+                "request_id": request_id,
+                "success": True,
+            }
+        )
+
+        # Broadcast update to OTHER connections
+        await self._registry.broadcast(
+            user_id,
+            self._tab_service.build_tab_state_update("remove", closed_tab, reason="user"),
+            exclude=connection,
+        )
+
+    async def _handle_rename_tab(
+        self,
+        user_id: UserId,
+        connection: ConnectionPort,
+        message: dict,
+    ) -> None:
+        """Handle tab rename request."""
+        request_id = message.get("request_id", "")
+        tab_id = message.get("tab_id")
+        new_name = message.get("name")
+
+        if not tab_id or not new_name:
+            await connection.send_message(
+                {
+                    "type": "rename_tab_response",
+                    "request_id": request_id,
+                    "success": False,
+                    "error": "Missing tab_id or name",
+                }
+            )
+            return
+
+        # Rename the tab
+        tab = self._tab_service.rename_tab(tab_id, user_id, new_name)
+        if not tab:
+            await connection.send_message(
+                {
+                    "type": "rename_tab_response",
+                    "request_id": request_id,
+                    "success": False,
+                    "error": "Failed to rename tab",
+                }
+            )
+            return
+
+        logger.info(
+            "Management renamed tab user_id=%s tab_id=%s new_name=%s",
+            user_id,
+            tab_id,
+            new_name,
+        )
+
+        # Send response to requester
+        await connection.send_message(
+            {
+                "type": "rename_tab_response",
+                "request_id": request_id,
+                "success": True,
+                "tab": tab.to_dict(),
+            }
+        )
+
+        # Broadcast update to OTHER connections
+        await self._registry.broadcast(
+            user_id,
+            self._tab_service.build_tab_state_update("update", tab),
+            exclude=connection,
+        )
+
+    def build_state_sync(self, user_id: UserId) -> dict:
+        """Build initial state sync message for a user.
+
+        Returns:
+            Message dict with all tabs for the user.
+        """
+        return self._tab_service.build_tab_state_sync(user_id)

porterminal/application/services/session_service.py

@@ -0,0 +1,249 @@
+"""Session service - session lifecycle management."""
+
+import asyncio
+import logging
+import os
+import uuid
+from collections.abc import Awaitable, Callable
+from datetime import UTC, datetime
+
+from porterminal.domain import (
+    EnvironmentRules,
+    EnvironmentSanitizer,
+    PTYPort,
+    Session,
+    SessionId,
+    SessionLimitChecker,
+    ShellCommand,
+    TerminalDimensions,
+    UserId,
+)
+from porterminal.domain.ports import SessionRepository
+
+logger = logging.getLogger(__name__)
+
+
+class SessionService:
+    """Service for managing terminal sessions.
+
+    Handles session creation, reconnection, destruction, and cleanup.
+    """
+
+    def __init__(
+        self,
+        repository: SessionRepository[PTYPort],
+        pty_factory: Callable[
+            [ShellCommand, TerminalDimensions, dict[str, str], str | None], PTYPort
+        ],
+        limit_checker: SessionLimitChecker | None = None,
+        environment_sanitizer: EnvironmentSanitizer | None = None,
+        working_directory: str | None = None,
+    ) -> None:
+        self._repository = repository
+        self._pty_factory = pty_factory
+        self._limit_checker = limit_checker or SessionLimitChecker()
+        self._sanitizer = environment_sanitizer or EnvironmentSanitizer(EnvironmentRules())
+        self._cwd = working_directory
+        self._running = False
+        self._cleanup_task: asyncio.Task | None = None
+        self._on_session_destroyed: Callable[[SessionId, UserId], Awaitable[None]] | None = None
+
+    def set_on_session_destroyed(
+        self, callback: Callable[[SessionId, UserId], Awaitable[None]]
+    ) -> None:
+        """Set async callback to be invoked when a session is destroyed.
+
+        Used for cascading cleanup (e.g., closing associated tabs and broadcasting).
+        """
+        self._on_session_destroyed = callback
+
+    async def start(self) -> None:
+        """Start the session service (cleanup loop)."""
+        self._running = True
+        self._cleanup_task = asyncio.create_task(self._cleanup_loop())
+        logger.info("Session service started")
+
+    async def stop(self) -> None:
+        """Stop the session service and cleanup all sessions."""
+        self._running = False
+
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                pass
+
+        # Close all sessions
+        for session in self._repository.all_sessions():
+            await self.destroy_session(session.id)
+
+        logger.info("Session service stopped")
+
+    async def create_session(
+        self,
+        user_id: UserId,
+        shell: ShellCommand,
+        dimensions: TerminalDimensions,
+    ) -> Session[PTYPort]:
+        """Create a new terminal session.
+
+        Args:
+            user_id: User requesting the session.
+            shell: Shell command to run.
+            dimensions: Initial terminal dimensions.
+
+        Returns:
+            Created session.
+
+        Raises:
+            ValueError: If session limits exceeded.
+        """
+        # Check limits
+        limit_result = self._limit_checker.can_create_session(
+            user_id,
+            self._repository.count_for_user(user_id),
+            self._repository.count(),
+        )
+        if not limit_result.allowed:
+            raise ValueError(limit_result.reason)
+
+        # Create PTY with sanitized environment
+        env = self._sanitizer.sanitize(dict(os.environ))
+        pty = self._pty_factory(shell, dimensions, env, self._cwd)
+
+        # Create session (starts with 0 clients, caller adds via add_client())
+        now = datetime.now(UTC)
+        session = Session(
+            id=SessionId(str(uuid.uuid4())),
+            user_id=user_id,
+            shell_id=shell.id,
+            dimensions=dimensions,
+            created_at=now,
+            last_activity=now,
+            pty_handle=pty,
+        )
+
+        self._repository.add(session)
+        logger.info(
+            "Session created session_id=%s user_id=%s shell=%s",
+            session.id,
+            user_id,
+            shell.id,
+        )
+
+        return session
+
+    async def reconnect_session(
+        self,
+        session_id: SessionId,
+        user_id: UserId,
+    ) -> Session[PTYPort] | None:
+        """Reconnect to an existing session.
+
+        Args:
+            session_id: Session to reconnect to.
+            user_id: User requesting reconnection.
+
+        Returns:
+            Session if reconnection successful, None otherwise.
+        """
+        session = self._repository.get(session_id)
+        if not session:
+            logger.warning("Reconnect failed: session not found session_id=%s", session_id)
+            return None
+
+        # Check ownership
+        limit_result = self._limit_checker.can_reconnect(session, user_id)
+        if not limit_result.allowed:
+            logger.warning(
+                "Reconnect denied: %s session_id=%s user_id=%s",
+                limit_result.reason,
+                session_id,
+                user_id,
+            )
+            return None
+
+        # Check if PTY is still alive
+        if not session.pty_handle.is_alive():
+            logger.warning("Reconnect failed: PTY dead session_id=%s", session_id)
+            await self.destroy_session(session_id)
+            return None
+
+        session.add_client()
+        session.touch(datetime.now(UTC))
+        logger.info("Session reconnected session_id=%s user_id=%s", session_id, user_id)
+
+        return session
+
+    def disconnect_session(self, session_id: SessionId) -> None:
+        """Remove a client from session (but keep alive for reconnection)."""
+        session = self._repository.get(session_id)
+        if session:
+            remaining = session.remove_client()
+            session.touch(datetime.now(UTC))
+            logger.info(
+                "Client disconnected session_id=%s remaining_clients=%d",
+                session_id,
+                remaining,
+            )
+
+    async def destroy_session(self, session_id: SessionId) -> None:
+        """Destroy a session completely."""
+        session = self._repository.remove(session_id)
+        if session:
+            # Invoke cascade callback (e.g., to close associated tabs)
+            if self._on_session_destroyed:
+                try:
+                    await self._on_session_destroyed(session_id, session.user_id)
+                except Exception as e:
+                    logger.warning(
+                        "Error in session destroyed callback session_id=%s: %s",
+                        session_id,
+                        e,
+                    )
+
+            try:
+                session.pty_handle.close()
+            except Exception as e:
+                logger.warning("Error closing PTY session_id=%s: %s", session_id, e)
+
+            session.clear_buffer()
+            logger.info("Session destroyed session_id=%s", session_id)
+
+    def get_session(self, session_id: str) -> Session[PTYPort] | None:
+        """Get session by ID string."""
+        return self._repository.get_by_id_str(session_id)
+
+    def get_user_sessions(self, user_id: UserId) -> list[Session[PTYPort]]:
+        """Get all sessions for a user."""
+        return self._repository.get_by_user(user_id)
+
+    def session_count(self) -> int:
+        """Get total session count."""
+        return self._repository.count()
+
+    async def _cleanup_loop(self) -> None:
+        """Background task to cleanup stale sessions."""
+        while self._running:
+            await asyncio.sleep(60)
+            await self._cleanup_stale_sessions()
+
+    async def _cleanup_stale_sessions(self) -> None:
+        """Check and cleanup stale sessions."""
+        now = datetime.now(UTC)
+
+        for session in self._repository.all_sessions():
+            should_cleanup, reason = self._limit_checker.should_cleanup_session(
+                session,
+                now,
+                session.pty_handle.is_alive(),
+            )
+
+            if should_cleanup:
+                logger.info(
+                    "Cleaning up session session_id=%s reason=%s",
+                    session.id,
+                    reason,
+                )
+                await self.destroy_session(session.id)