portacode 0.2.1.dev0__tar.gz → 0.2.3.dev0__tar.gz

{portacode-0.2.1.dev0 → portacode-0.2.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.2.1.dev0
+Version: 0.2.3.dev0
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-0.2.1.dev0 → portacode-0.2.3.dev0}/portacode/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.1.dev'
-__version_tuple__ = version_tuple = (0, 2, 1, 'dev0')
+__version__ = version = '0.2.3.dev'
+__version_tuple__ = version_tuple = (0, 2, 3, 'dev0')

portacode-0.2.3.dev0/portacode/connection/handlers/__init__.py

@@ -0,0 +1,28 @@
+"""Modular command handler system for Portacode client.
+
+This package provides a flexible system for handling commands from the gateway.
+Handlers can be easily added, removed, or modified without touching the main
+terminal manager code.
+"""
+
+from .base import BaseHandler, AsyncHandler, SyncHandler
+from .registry import CommandRegistry
+from .terminal_handlers import (
+    TerminalStartHandler,
+    TerminalSendHandler,
+    TerminalStopHandler,
+    TerminalListHandler,
+)
+from .system_handlers import SystemInfoHandler
+
+__all__ = [
+    "BaseHandler",
+    "AsyncHandler", 
+    "SyncHandler",
+    "CommandRegistry",
+    "TerminalStartHandler",
+    "TerminalSendHandler",
+    "TerminalStopHandler",
+    "TerminalListHandler",
+    "SystemInfoHandler",
+] 

portacode-0.2.3.dev0/portacode/connection/handlers/base.py

@@ -0,0 +1,115 @@
+"""Base handler classes for command processing."""
+
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..multiplex import Channel
+
+logger = logging.getLogger(__name__)
+
+
+class BaseHandler(ABC):
+    """Base class for all command handlers."""
+    
+    def __init__(self, control_channel: "Channel", context: Dict[str, Any]):
+        """Initialize the handler.
+        
+        Args:
+            control_channel: The control channel for sending responses
+            context: Shared context containing terminal manager state
+        """
+        self.control_channel = control_channel
+        self.context = context
+        
+    @property
+    @abstractmethod
+    def command_name(self) -> str:
+        """Return the command name this handler processes."""
+        pass
+    
+    @abstractmethod
+    async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
+        """Handle the command message.
+        
+        Args:
+            message: The command message dict
+            reply_channel: Optional reply channel for responses
+        """
+        pass
+    
+    async def send_response(self, payload: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
+        """Send a response back to the gateway.
+        
+        Args:
+            payload: Response payload
+            reply_channel: Optional reply channel
+        """
+        if reply_channel:
+            payload["reply_channel"] = reply_channel
+        await self.control_channel.send(payload)
+    
+    async def send_error(self, message: str, reply_channel: Optional[str] = None) -> None:
+        """Send an error response.
+        
+        Args:
+            message: Error message
+            reply_channel: Optional reply channel
+        """
+        payload = {"event": "error", "message": message}
+        if reply_channel:
+            payload["reply_channel"] = reply_channel
+        await self.control_channel.send(payload)
+
+
+class AsyncHandler(BaseHandler):
+    """Base class for asynchronous command handlers."""
+    
+    @abstractmethod
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the command logic asynchronously.
+        
+        Args:
+            message: The command message dict
+            
+        Returns:
+            Response payload dict
+        """
+        pass
+    
+    async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
+        """Handle the command by executing it and sending the response."""
+        try:
+            response = await self.execute(message)
+            await self.send_response(response, reply_channel)
+        except Exception as exc:
+            logger.exception("Error in async handler %s: %s", self.command_name, exc)
+            await self.send_error(str(exc), reply_channel)
+
+
+class SyncHandler(BaseHandler):
+    """Base class for synchronous command handlers."""
+    
+    @abstractmethod
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the command logic synchronously.
+        
+        Args:
+            message: The command message dict
+            
+        Returns:
+            Response payload dict
+        """
+        pass
+    
+    async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
+        """Handle the command by executing it in an executor and sending the response."""
+        try:
+            loop = asyncio.get_running_loop()
+            response = await loop.run_in_executor(None, self.execute, message)
+            await self.send_response(response, reply_channel)
+        except Exception as exc:
+            logger.exception("Error in sync handler %s: %s", self.command_name, exc)
+            await self.send_error(str(exc), reply_channel) 

portacode-0.2.3.dev0/portacode/connection/handlers/registry.py

@@ -0,0 +1,111 @@
+"""Command registry for managing handler dispatch."""
+
+import logging
+from typing import Dict, Type, Any, Optional, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..multiplex import Channel
+    from .base import BaseHandler
+
+logger = logging.getLogger(__name__)
+
+
+class CommandRegistry:
+    """Registry for managing command handlers."""
+    
+    def __init__(self, control_channel: "Channel", context: Dict[str, Any]):
+        """Initialize the command registry.
+        
+        Args:
+            control_channel: The control channel for handlers
+            context: Shared context for handlers
+        """
+        self.control_channel = control_channel
+        self.context = context
+        self._handlers: Dict[str, "BaseHandler"] = {}
+        
+    def register(self, handler_class: Type["BaseHandler"]) -> None:
+        """Register a command handler.
+        
+        Args:
+            handler_class: The handler class to register
+        """
+        handler_instance = handler_class(self.control_channel, self.context)
+        command_name = handler_instance.command_name
+        
+        if command_name in self._handlers:
+            logger.warning("Overriding existing handler for command: %s", command_name)
+        
+        self._handlers[command_name] = handler_instance
+        logger.debug("Registered handler for command: %s", command_name)
+        
+    def unregister(self, command_name: str) -> None:
+        """Unregister a command handler.
+        
+        Args:
+            command_name: The command name to unregister
+        """
+        if command_name in self._handlers:
+            del self._handlers[command_name]
+            logger.debug("Unregistered handler for command: %s", command_name)
+        else:
+            logger.warning("Attempted to unregister non-existent handler: %s", command_name)
+    
+    def get_handler(self, command_name: str) -> Optional["BaseHandler"]:
+        """Get a handler by command name.
+        
+        Args:
+            command_name: The command name
+            
+        Returns:
+            The handler instance or None if not found
+        """
+        return self._handlers.get(command_name)
+    
+    def list_commands(self) -> List[str]:
+        """List all registered command names.
+        
+        Returns:
+            List of command names
+        """
+        return list(self._handlers.keys())
+    
+    async def dispatch(self, command_name: str, message: Dict[str, Any], reply_channel: Optional[str] = None) -> bool:
+        """Dispatch a command to its handler.
+        
+        Args:
+            command_name: The command name
+            message: The command message
+            reply_channel: Optional reply channel
+            
+        Returns:
+            True if handler was found and executed, False otherwise
+        """
+        handler = self.get_handler(command_name)
+        if handler is None:
+            logger.warning("No handler found for command: %s", command_name)
+            return False
+        
+        try:
+            await handler.handle(message, reply_channel)
+            return True
+        except Exception as exc:
+            logger.exception("Error dispatching command %s: %s", command_name, exc)
+            # Send error response
+            error_payload = {"event": "error", "message": str(exc)}
+            if reply_channel:
+                error_payload["reply_channel"] = reply_channel
+            await self.control_channel.send(error_payload)
+            return False
+    
+    def update_context(self, context: Dict[str, Any]) -> None:
+        """Update the shared context for all handlers.
+        
+        Args:
+            context: New context dict
+        """
+        self.context.update(context)
+        
+        # Update context for all existing handlers
+        for handler in self._handlers.values():
+            handler.context = self.context 

portacode-0.2.3.dev0/portacode/connection/handlers/session.py

@@ -0,0 +1,275 @@
+"""Terminal session management."""
+
+import asyncio
+import logging
+import os
+import sys
+import uuid
+from asyncio.subprocess import Process
+from pathlib import Path
+from typing import Any, Dict, Optional, List, TYPE_CHECKING
+from collections import deque
+
+if TYPE_CHECKING:
+    from ..multiplex import Channel
+
+logger = logging.getLogger(__name__)
+
+_IS_WINDOWS = sys.platform.startswith("win")
+
+# Minimal, safe defaults for interactive shells
+_DEFAULT_ENV = {
+    "TERM": "xterm-256color",
+    "LANG": "C.UTF-8",
+}
+
+
+def _build_child_env() -> Dict[str, str]:
+    """Return a copy of os.environ with sensible fallbacks added."""
+    env = os.environ.copy()
+    for k, v in _DEFAULT_ENV.items():
+        env.setdefault(k, v)
+    return env
+
+
+class TerminalSession:
+    """Represents a local shell subprocess bound to a mux channel."""
+
+    def __init__(self, session_id: str, proc: Process, channel: "Channel"):
+        self.id = session_id
+        self.proc = proc
+        self.channel = channel
+        self._reader_task: Optional[asyncio.Task[None]] = None
+        self._buffer: deque[str] = deque(maxlen=400)
+
+    async def start_io_forwarding(self) -> None:
+        """Spawn background task that copies stdout/stderr to the channel."""
+        assert self.proc.stdout is not None, "stdout pipe not set"
+
+        async def _pump() -> None:
+            try:
+                while True:
+                    data = await self.proc.stdout.read(1024)
+                    if not data:
+                        break
+                    text = data.decode(errors="ignore")
+                    logging.getLogger("portacode.terminal").debug(f"[MUX] Terminal {self.id} output: {text!r}")
+                    self._buffer.append(text)
+                    try:
+                        await self.channel.send(text)
+                    except Exception as exc:
+                        logger.warning("Failed to forward terminal output: %s", exc)
+                        await asyncio.sleep(0.5)
+                        continue
+            finally:
+                if self.proc and self.proc.returncode is None:
+                    pass  # Keep alive across reconnects
+
+        self._reader_task = asyncio.create_task(_pump())
+
+    async def write(self, data: str) -> None:
+        if self.proc.stdin is None:
+            logger.warning("stdin pipe closed for terminal %s", self.id)
+            return
+        try:
+            self.proc.stdin.write(data.encode())
+            await self.proc.stdin.drain()
+        except Exception as exc:
+            logger.warning("Failed to write to terminal %s: %s", self.id, exc)
+
+    async def stop(self) -> None:
+        if self.proc.returncode is None:
+            self.proc.terminate()
+        if self._reader_task:
+            await self._reader_task
+        await self.proc.wait()
+
+    def snapshot_buffer(self) -> str:
+        """Return concatenated last buffer contents suitable for UI."""
+        return "".join(self._buffer)
+
+
+class WindowsTerminalSession(TerminalSession):
+    """Terminal session backed by a Windows ConPTY."""
+
+    def __init__(self, session_id: str, pty, channel: "Channel"):
+        # Create a proxy for the PTY process
+        class _WinPTYProxy:
+            def __init__(self, pty):
+                self._pty = pty
+
+            @property
+            def pid(self):
+                return self._pty.pid
+
+            @property
+            def returncode(self):
+                return None if self._pty.isalive() else self._pty.exitstatus
+
+            async def wait(self):
+                loop = asyncio.get_running_loop()
+                await loop.run_in_executor(None, self._pty.wait)
+
+        super().__init__(session_id, _WinPTYProxy(pty), channel)
+        self._pty = pty
+
+    async def start_io_forwarding(self) -> None:
+        """Spawn background task that copies stdout/stderr to the channel."""
+        loop = asyncio.get_running_loop()
+
+        async def _pump() -> None:
+            try:
+                while True:
+                    data = await loop.run_in_executor(None, self._pty.read, 1024)
+                    if not data:
+                        if not self._pty.isalive():
+                            break
+                        await asyncio.sleep(0.05)
+                        continue
+                    if isinstance(data, bytes):
+                        text = data.decode(errors="ignore")
+                    else:
+                        text = data
+                    logging.getLogger("portacode.terminal").debug(f"[MUX] Terminal {self.id} output: {text!r}")
+                    self._buffer.append(text)
+                    try:
+                        await self.channel.send(text)
+                    except Exception as exc:
+                        logger.warning("Failed to forward terminal output: %s", exc)
+                        await asyncio.sleep(0.5)
+                        continue
+            finally:
+                if self._pty and self._pty.isalive():
+                    self._pty.kill()
+
+        self._reader_task = asyncio.create_task(_pump())
+
+    async def write(self, data: str) -> None:
+        loop = asyncio.get_running_loop()
+        try:
+            await loop.run_in_executor(None, self._pty.write, data)
+        except Exception as exc:
+            logger.warning("Failed to write to terminal %s: %s", self.id, exc)
+
+    async def stop(self) -> None:
+        if self._pty.isalive():
+            self._pty.kill()
+        if self._reader_task:
+            await self._reader_task
+
+
+class SessionManager:
+    """Manages terminal sessions."""
+
+    def __init__(self, mux):
+        self.mux = mux
+        self._sessions: Dict[str, TerminalSession] = {}
+        self._next_channel = 100
+
+    def _allocate_channel_id(self) -> int:
+        """Allocate a new channel ID for a terminal session."""
+        cid = self._next_channel
+        self._next_channel += 1
+        return cid
+
+    async def create_session(self, shell: Optional[str] = None, cwd: Optional[str] = None) -> Dict[str, Any]:
+        """Create a new terminal session."""
+        term_id = uuid.uuid4().hex
+        channel_id = self._allocate_channel_id()
+        channel = self.mux.get_channel(channel_id)
+
+        # Choose shell
+        if shell is None:
+            shell = os.getenv("SHELL") if not _IS_WINDOWS else os.getenv("COMSPEC", "cmd.exe")
+
+        logger.info("Launching terminal %s using shell=%s on channel=%d", term_id, shell, channel_id)
+
+        if _IS_WINDOWS:
+            try:
+                from winpty import PtyProcess
+            except ImportError as exc:
+                logger.error("winpty (pywinpty) not found: %s", exc)
+                raise RuntimeError("pywinpty not installed on client")
+
+            pty_proc = PtyProcess.spawn(shell, cwd=cwd or None, env=_build_child_env())
+            session = WindowsTerminalSession(term_id, pty_proc, channel)
+        else:
+            # Unix: try real PTY for proper TTY semantics
+            try:
+                import pty
+                master_fd, slave_fd = pty.openpty()
+                proc = await asyncio.create_subprocess_exec(
+                    shell,
+                    stdin=slave_fd,
+                    stdout=slave_fd,
+                    stderr=slave_fd,
+                    preexec_fn=os.setsid,
+                    cwd=cwd,
+                    env=_build_child_env(),
+                )
+                # Wrap master_fd into a StreamReader
+                loop = asyncio.get_running_loop()
+                reader = asyncio.StreamReader()
+                protocol = asyncio.StreamReaderProtocol(reader)
+                await loop.connect_read_pipe(lambda: protocol, os.fdopen(master_fd, "rb", buffering=0))
+                proc.stdout = reader
+                # Use writer for stdin
+                writer_transport, writer_protocol = await loop.connect_write_pipe(
+                    lambda: asyncio.Protocol(), os.fdopen(master_fd, "wb", buffering=0)
+                )
+                proc.stdin = asyncio.StreamWriter(writer_transport, writer_protocol, reader, loop)
+            except Exception:
+                logger.warning("Failed to allocate PTY, falling back to pipes")
+                proc = await asyncio.create_subprocess_exec(
+                    shell,
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.STDOUT,
+                    cwd=cwd,
+                    env=_build_child_env(),
+                )
+            session = TerminalSession(term_id, proc, channel)
+
+        self._sessions[term_id] = session
+        await session.start_io_forwarding()
+
+        return {
+            "terminal_id": term_id,
+            "channel": channel_id,
+            "pid": session.proc.pid,
+            "shell": shell,
+            "cwd": cwd,
+        }
+
+    def get_session(self, terminal_id: str) -> Optional[TerminalSession]:
+        """Get a terminal session by ID."""
+        return self._sessions.get(terminal_id)
+
+    def remove_session(self, terminal_id: str) -> Optional[TerminalSession]:
+        """Remove and return a terminal session."""
+        return self._sessions.pop(terminal_id, None)
+
+    def list_sessions(self) -> List[Dict[str, Any]]:
+        """List all terminal sessions."""
+        return [
+            {
+                "terminal_id": s.id,
+                "channel": s.channel.id,
+                "pid": s.proc.pid,
+                "returncode": s.proc.returncode,
+                "buffer": s.snapshot_buffer(),
+            }
+            for s in self._sessions.values()
+        ]
+
+    def reattach_sessions(self, mux):
+        """Reattach sessions to a new multiplexer after reconnection."""
+        self.mux = mux
+        highest_cid = self._next_channel
+        
+        for sess in self._sessions.values():
+            cid = sess.channel.id
+            sess.channel = self.mux.get_channel(cid)
+            highest_cid = max(highest_cid, cid + 1)
+        
+        self._next_channel = max(self._next_channel, highest_cid) 

portacode-0.2.3.dev0/portacode/connection/handlers/system_handlers.py

@@ -0,0 +1,32 @@
+"""System command handlers."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+import psutil
+
+from .base import SyncHandler
+
+logger = logging.getLogger(__name__)
+
+
+class SystemInfoHandler(SyncHandler):
+    """Handler for getting system information."""
+    
+    @property
+    def command_name(self) -> str:
+        return "system_info"
+    
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Get system information."""
+        info = {
+            "cpu_percent": psutil.cpu_percent(interval=0.1),
+            "memory": psutil.virtual_memory()._asdict(),
+            "disk": psutil.disk_usage(str(Path.home()))._asdict(),
+        }
+        
+        return {
+            "event": "system_info",
+            "info": info,
+        }