portacode 0.3.4.dev0__py3-none-any.whl → 1.4.11.dev0__py3-none-any.whl

portacode/connection/handlers/terminal_handlers.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from .base import AsyncHandler
 from .session import SessionManager
@@ -21,12 +21,13 @@ class TerminalStartHandler(AsyncHandler):
         """Start a new terminal session."""
         shell = message.get("shell")
         cwd = message.get("cwd")
+        project_id = message.get("project_id")
         
         session_manager = self.context.get("session_manager")
         if not session_manager:
             raise RuntimeError("Session manager not available")
         
-        session_info = await session_manager.create_session(shell=shell, cwd=cwd)
+        session_info = await session_manager.create_session(shell=shell, cwd=cwd, project_id=project_id)
         
         # Start background watcher for process exit
         asyncio.create_task(self._watch_process_exit(session_info["terminal_id"]))
@@ -35,6 +36,10 @@ class TerminalStartHandler(AsyncHandler):
             "event": "terminal_started",
             "terminal_id": session_info["terminal_id"],
             "channel": session_info["channel"],
+            "pid": session_info["pid"],
+            "shell": session_info.get("shell"),
+            "cwd": session_info.get("cwd"),
+            "project_id": session_info.get("project_id"),
         }
     
     async def _watch_process_exit(self, terminal_id: str) -> None:
@@ -49,14 +54,16 @@ class TerminalStartHandler(AsyncHandler):
         
         await session.proc.wait()
         
-        await self.control_channel.send({
+        await self.send_response({
             "event": "terminal_exit",
             "terminal_id": terminal_id,
             "returncode": session.proc.returncode,
-        })
+            "project_id": session.project_id,
+        }, project_id=session.project_id)
         
-        # Cleanup session
-        session_manager.remove_session(terminal_id)
+        # Only cleanup session if it still exists (not already removed by stop handler)
+        if session_manager.get_session(terminal_id):
+            session_manager.remove_session(terminal_id)
 
 
 class TerminalSendHandler(AsyncHandler):
@@ -100,22 +107,106 @@ class TerminalStopHandler(AsyncHandler):
         terminal_id = message.get("terminal_id")
         
         if not terminal_id:
+            logger.error("terminal_stop: Missing terminal_id in message")
             raise ValueError("terminal_id is required")
         
+        logger.info("terminal_stop: Processing stop request for terminal_id=%s", terminal_id)
+        
         session_manager = self.context.get("session_manager")
         if not session_manager:
+            logger.error("terminal_stop: Session manager not available in context")
             raise RuntimeError("Session manager not available")
         
+        # Remove session from manager first
         session = session_manager.remove_session(terminal_id)
         if not session:
-            raise ValueError(f"terminal_id {terminal_id} not found")
+            logger.warning("terminal_stop: Terminal %s not found, may have already been stopped", terminal_id)
+            # Send completion event immediately for not found terminals
+            asyncio.create_task(self._send_not_found_completion(terminal_id, None))
+            return {
+                "event": "terminal_stopped",
+                "terminal_id": terminal_id,
+                "status": "not_found",
+                "message": "Terminal was not found or already stopped",
+                "project_id": None,
+            }
+        
+        logger.info("terminal_stop: Found session for terminal %s (PID: %s), starting background stop process", 
+                   terminal_id, getattr(session.proc, 'pid', 'unknown'))
         
-        await session.stop()
+        # Start stop process in background without blocking the control channel
+        asyncio.create_task(self._stop_session_safely(session, terminal_id, session.project_id))
         
         return {
             "event": "terminal_stopped",
             "terminal_id": terminal_id,
+            "status": "stopping",
+            "message": "Terminal stop process initiated",
+            "project_id": session.project_id,
         }
+    
+    async def _stop_session_safely(self, session, terminal_id: str, project_id: Optional[str] = None) -> None:
+        """Safely stop a session in the background with timeout and error handling."""
+        logger.info("terminal_stop: Starting background stop process for terminal %s", terminal_id)
+        
+        try:
+            # Attempt graceful stop with timeout
+            await asyncio.wait_for(session.stop(), timeout=10.0)
+            logger.info("terminal_stop: Successfully stopped terminal %s", terminal_id)
+            
+            # Send success notification
+            await self.send_response({
+                "event": "terminal_stop_completed",
+                "terminal_id": terminal_id,
+                "status": "success",
+                "message": "Terminal stopped successfully",
+                "project_id": project_id,
+            }, project_id=project_id)
+            
+        except asyncio.TimeoutError:
+            logger.warning("terminal_stop: Stop timeout for terminal %s, forcing kill", terminal_id)
+            
+            # Force kill the process
+            try:
+                if hasattr(session.proc, 'kill'):
+                    session.proc.kill()
+                    logger.info("terminal_stop: Force killed terminal %s", terminal_id)
+                elif hasattr(session.proc, 'terminate'):
+                    session.proc.terminate()
+                    logger.info("terminal_stop: Force terminated terminal %s", terminal_id)
+            except Exception as kill_exc:
+                logger.error("terminal_stop: Failed to force kill terminal %s: %s", terminal_id, kill_exc)
+            
+            # Send timeout notification
+            await self.send_response({
+                "event": "terminal_stop_completed",
+                "terminal_id": terminal_id,
+                "status": "timeout",
+                "message": "Terminal stop timed out, process was force killed",
+                "project_id": project_id,
+            }, project_id=project_id)
+            
+        except Exception as exc:
+            logger.exception("terminal_stop: Error stopping terminal %s: %s", terminal_id, exc)
+            
+            # Send error notification
+            await self.send_response({
+                "event": "terminal_stop_completed",
+                "terminal_id": terminal_id,
+                "status": "error",
+                "message": f"Error stopping terminal: {str(exc)}",
+                "project_id": project_id,
+            }, project_id=project_id)
+
+    async def _send_not_found_completion(self, terminal_id: str, project_id: Optional[str] = None) -> None:
+        """Send completion event for not found terminals."""
+        await self.send_response({
+            "event": "terminal_stop_completed",
+            "terminal_id": terminal_id,
+            "status": "not_found",
+            "message": "Terminal was not found or already stopped",
+            "project_id": project_id,
+        }, project_id=project_id)
 
 
 class TerminalListHandler(AsyncHandler):
@@ -125,15 +216,63 @@ class TerminalListHandler(AsyncHandler):
     def command_name(self) -> str:
         return "terminal_list"
     
+    async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
+        """Handle the command by executing it and sending the response to the requesting client session."""
+        logger.info("handler: Processing command %s with reply_channel=%s",
+                   self.command_name, reply_channel)
+
+        try:
+            response = await self.execute(message)
+            logger.info("handler: Command %s executed successfully", self.command_name)
+
+            # Automatically copy request_id if present in the incoming message
+            if "request_id" in message and "request_id" not in response:
+                response["request_id"] = message["request_id"]
+
+            # Get the source client session from the message
+            source_client_session = message.get("source_client_session")
+            project_id = response.get("project_id")
+
+            logger.info("handler: %s response project_id=%s, source_client_session=%s",
+                       self.command_name, project_id, source_client_session)
+
+            # Send response only to the requesting client session
+            if source_client_session:
+                # Add client_sessions field to target only the requesting session
+                response["client_sessions"] = [source_client_session]
+
+                import json
+                logger.info("handler: 📤 SENDING EVENT '%s' (via direct control_channel.send)", response.get("event", "unknown"))
+                logger.info("handler: 📤 FULL EVENT PAYLOAD: %s", json.dumps(response, indent=2, default=str))
+
+                await self.control_channel.send(response)
+            else:
+                # Fallback to original behavior if no source_client_session
+                await self.send_response(response, reply_channel, project_id)
+        except Exception as exc:
+            logger.exception("handler: Error in command %s: %s", self.command_name, exc)
+            await self.send_error(str(exc), reply_channel, message.get("project_id"))
+    
     async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
         """List all terminal sessions."""
         session_manager = self.context.get("session_manager")
         if not session_manager:
             raise RuntimeError("Session manager not available")
-        
-        sessions = session_manager.list_sessions()
-        
+
+        # Accept project_id argument: None (default) = only no project, 'all' = all, else = filter by project_id
+        requested_project_id = message.get("project_id")
+        logger.info("terminal_list: requested_project_id=%r (type: %s)", requested_project_id, type(requested_project_id))
+
+        if requested_project_id == "all":
+            logger.info("terminal_list: Using 'all' mode to list all terminals")
+            sessions = session_manager.list_sessions(project_id="all")
+        else:
+            logger.info("terminal_list: Filtering by project_id=%r", requested_project_id)
+            sessions = session_manager.list_sessions(project_id=requested_project_id)
+
+        logger.info("terminal_list: Found %d sessions, returning with project_id=%r", len(sessions), requested_project_id)
         return {
             "event": "terminal_list",
             "sessions": sessions,
+            "project_id": requested_project_id,
         } 

portacode/connection/handlers/update_handler.py

@@ -0,0 +1,61 @@
+"""Update handler for Portacode CLI."""
+
+import subprocess
+import sys
+import logging
+from typing import Any, Dict
+from .base import AsyncHandler
+
+logger = logging.getLogger(__name__)
+
+
+class UpdatePortacodeHandler(AsyncHandler):
+    """Handler for updating Portacode CLI."""
+    
+    @property
+    def command_name(self) -> str:
+        return "update_portacode_cli"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Update Portacode package and restart process."""
+        try:
+            logger.info("Starting Portacode CLI update...")
+            
+            # Update the package
+            result = subprocess.run([
+                sys.executable, "-m", "pip", "install", "--upgrade", "portacode"
+            ], capture_output=True, text=True, timeout=120)
+            
+            if result.returncode != 0:
+                logger.error("Update failed: %s", result.stderr)
+                return {
+                    "event": "update_portacode_response",
+                    "success": False,
+                    "error": f"Update failed: {result.stderr}"
+                }
+            
+            logger.info("Update successful, restarting process...")
+            
+            # Send success response before exit
+            await self.send_response({
+                "event": "update_portacode_response",
+                "success": True,
+                "message": "Update completed. Process restarting..."
+            })
+            
+            # Exit with special code to trigger restart
+            sys.exit(42)
+            
+        except subprocess.TimeoutExpired:
+            return {
+                "event": "update_portacode_response",
+                "success": False,
+                "error": "Update timed out after 120 seconds"
+            }
+        except Exception as e:
+            logger.exception("Update failed with exception")
+            return {
+                "event": "update_portacode_response",
+                "success": False,
+                "error": str(e)
+            }

portacode/connection/multiplex.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import time
 from asyncio import Queue
 from typing import Any, Dict, Union
 
@@ -49,8 +50,65 @@ class Multiplexer:
         return self._channels[channel_id]
 
     async def _send_on_channel(self, channel_id: Union[int, str], payload: Any) -> None:
-        frame = json.dumps({"channel": channel_id, "payload": payload})
-        await self._send_func(frame)
+        # Start timing the serialization and sending
+        start_time = time.time()
+        
+        try:
+            # Serialize the frame
+            serialization_start = time.time()
+            frame = json.dumps({"channel": channel_id, "payload": payload})
+            serialization_time = time.time() - serialization_start
+            
+            # Calculate message size
+            frame_size_bytes = len(frame.encode('utf-8'))
+            frame_size_kb = frame_size_bytes / 1024
+            
+            # Log warnings for large messages
+            if frame_size_kb > 500:  # Warn for messages > 500KB
+                logger.warning("🚨 LARGE WEBSOCKET MESSAGE: %.1f KB on channel %s (event: %s)", 
+                              frame_size_kb, channel_id, payload.get('event', 'unknown'))
+                
+                # Log additional details for very large messages
+                if frame_size_kb > 1000:  # > 1MB
+                    logger.warning("🚨 VERY LARGE MESSAGE: %.1f KB - This may cause connection drops!", frame_size_kb)
+                    
+                    # Try to identify what's making the message large
+                    if isinstance(payload, dict):
+                        large_fields = []
+                        for key, value in payload.items():
+                            if isinstance(value, (str, list, dict)):
+                                field_size = len(json.dumps(value).encode('utf-8')) / 1024
+                                if field_size > 100:  # Fields > 100KB
+                                    large_fields.append(f"{key}: {field_size:.1f}KB")
+                        if large_fields:
+                            logger.warning("🚨 Large fields detected: %s", ", ".join(large_fields))
+            
+            elif frame_size_kb > 100:  # Info for messages > 100KB
+                logger.info("📦 Large websocket message: %.1f KB on channel %s (event: %s)", 
+                           frame_size_kb, channel_id, payload.get('event', 'unknown'))
+            
+            # Send the frame
+            send_start = time.time()
+            await self._send_func(frame)
+            send_time = time.time() - send_start
+            
+            total_time = time.time() - start_time
+            
+            # Log performance metrics for large messages or slow operations
+            if frame_size_kb > 50 or total_time > 0.1:  # Log for messages > 50KB or operations > 100ms
+                logger.info("📊 WebSocket send performance: %.1f KB in %.3fs (serialize: %.3fs, send: %.3fs) - channel %s", 
+                           frame_size_kb, total_time, serialization_time, send_time, channel_id)
+            
+            # Log detailed timing for very large messages
+            if frame_size_kb > 200:
+                logger.info("🔍 Detailed timing - Channel: %s, Event: %s, Size: %.1f KB, Total: %.3fs", 
+                           channel_id, payload.get('event', 'unknown'), frame_size_kb, total_time)
+                
+        except Exception as e:
+            total_time = time.time() - start_time
+            logger.error("❌ Failed to send websocket message on channel %s after %.3fs: %s", 
+                        channel_id, total_time, e)
+            raise
 
     async def on_raw_message(self, raw: str) -> None:
         try: