portacode 0.3.12.dev1__tar.gz → 0.3.12.dev3__tar.gz

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/PKG-INFO

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

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/portacode/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.12.dev1'
-__version_tuple__ = version_tuple = (0, 3, 12, 'dev1')
+__version__ = version = '0.3.12.dev3'
+__version_tuple__ = version_tuple = (0, 3, 12, 'dev3')

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/portacode/connection/handlers/base.py

@@ -40,28 +40,54 @@ class BaseHandler(ABC):
         """
         pass
     
-    async def send_response(self, payload: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
-        """Send a response back to the gateway.
+    async def send_response(self, payload: Dict[str, Any], reply_channel: Optional[str] = None, project_id: str = None) -> None:
+        """Send a response back to the gateway with client session awareness.
         
         Args:
             payload: Response payload
-            reply_channel: Optional reply channel
+            reply_channel: Optional reply channel for backward compatibility
+            project_id: Optional project filter for targeting specific sessions
         """
-        if reply_channel:
-            payload["reply_channel"] = reply_channel
-        await self.control_channel.send(payload)
+        # Get client session manager from context
+        client_session_manager = self.context.get("client_session_manager")
+        
+        if client_session_manager and client_session_manager.has_interested_clients():
+            # Get target sessions
+            target_sessions = client_session_manager.get_target_sessions(project_id)
+            if not target_sessions:
+                logger.debug("handler: No target sessions found, skipping response send")
+                return
+            
+            # Add session targeting information
+            enhanced_payload = dict(payload)
+            enhanced_payload["client_sessions"] = target_sessions
+            
+            # Add backward compatibility reply_channel (first session if not provided)
+            if not reply_channel:
+                reply_channel = client_session_manager.get_reply_channel_for_compatibility()
+            if reply_channel:
+                enhanced_payload["reply_channel"] = reply_channel
+            
+            logger.debug("handler: Sending response to %d client sessions: %s", 
+                        len(target_sessions), target_sessions)
+            
+            await self.control_channel.send(enhanced_payload)
+        else:
+            # Fallback to original behavior if no client session manager or no clients
+            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.
+    async def send_error(self, message: str, reply_channel: Optional[str] = None, project_id: str = None) -> None:
+        """Send an error response with client session awareness.
         
         Args:
             message: Error message
-            reply_channel: Optional reply channel
+            reply_channel: Optional reply channel for backward compatibility
+            project_id: Optional project filter for targeting specific sessions
         """
         payload = {"event": "error", "message": message}
-        if reply_channel:
-            payload["reply_channel"] = reply_channel
-        await self.control_channel.send(payload)
+        await self.send_response(payload, reply_channel, project_id)
 
 
 class AsyncHandler(BaseHandler):
@@ -87,10 +113,15 @@ class AsyncHandler(BaseHandler):
         try:
             response = await self.execute(message)
             logger.info("handler: Command %s executed successfully", self.command_name)
-            await self.send_response(response, reply_channel)
+            
+            # Extract project_id from response for session targeting
+            project_id = response.get("project_id")
+            await self.send_response(response, reply_channel, project_id)
         except Exception as exc:
             logger.exception("handler: Error in async handler %s: %s", self.command_name, exc)
-            await self.send_error(str(exc), reply_channel)
+            # Extract project_id from original message for error targeting
+            project_id = message.get("project_id")
+            await self.send_error(str(exc), reply_channel, project_id)
 
 
 class SyncHandler(BaseHandler):
@@ -113,7 +144,12 @@ class SyncHandler(BaseHandler):
         try:
             loop = asyncio.get_running_loop()
             response = await loop.run_in_executor(None, self.execute, message)
-            await self.send_response(response, reply_channel)
+            
+            # Extract project_id from response for session targeting
+            project_id = response.get("project_id")
+            await self.send_response(response, reply_channel, project_id)
         except Exception as exc:
             logger.exception("Error in sync handler %s: %s", self.command_name, exc)
-            await self.send_error(str(exc), reply_channel) 
+            # Extract project_id from original message for error targeting
+            project_id = message.get("project_id")
+            await self.send_error(str(exc), reply_channel, project_id) 

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/portacode/connection/handlers/registry.py

@@ -94,13 +94,42 @@ class CommandRegistry:
             return True
         except Exception as exc:
             logger.exception("registry: 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)
+            # Send session-aware error response
+            await self._send_session_aware_error(str(exc), reply_channel, message.get("project_id"))
             return False
     
+    async def _send_session_aware_error(self, message: str, reply_channel: Optional[str] = None, project_id: str = None) -> None:
+        """Send an error response with client session awareness."""
+        error_payload = {"event": "error", "message": message}
+        
+        # Get client session manager from context
+        client_session_manager = self.context.get("client_session_manager")
+        
+        if client_session_manager and client_session_manager.has_interested_clients():
+            # Get target sessions
+            target_sessions = client_session_manager.get_target_sessions(project_id)
+            if not target_sessions:
+                logger.debug("registry: No target sessions found, skipping error send")
+                return
+            
+            # Add session targeting information
+            error_payload["client_sessions"] = target_sessions
+            
+            # Add backward compatibility reply_channel (first session if not provided)
+            if not reply_channel:
+                reply_channel = client_session_manager.get_reply_channel_for_compatibility()
+            if reply_channel:
+                error_payload["reply_channel"] = reply_channel
+            
+            logger.debug("registry: Sending error to %d client sessions: %s", 
+                        len(target_sessions), target_sessions)
+        else:
+            # Fallback to original behavior
+            if reply_channel:
+                error_payload["reply_channel"] = reply_channel
+        
+        await self.control_channel.send(error_payload)
+
     def update_context(self, context: Dict[str, Any]) -> None:
         """Update the shared context for all handlers.
         

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/portacode/connection/handlers/terminal_handlers.py

@@ -51,12 +51,12 @@ 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)
         
         # Only cleanup session if it still exists (not already removed by stop handler)
         if session_manager.get_session(terminal_id):
@@ -152,13 +152,13 @@ class TerminalStopHandler(AsyncHandler):
             logger.info("terminal_stop: Successfully stopped terminal %s", terminal_id)
             
             # Send success notification
-            await self.control_channel.send({
+            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)
@@ -175,35 +175,35 @@ class TerminalStopHandler(AsyncHandler):
                 logger.error("terminal_stop: Failed to force kill terminal %s: %s", terminal_id, kill_exc)
             
             # Send timeout notification
-            await self.control_channel.send({
+            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.control_channel.send({
+            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.control_channel.send({
+        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):

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/portacode/connection/terminal.py

@@ -78,6 +78,37 @@ class ClientSessionManager:
         """Check if there are any connected clients interested in this device."""
         return len(self._client_sessions) > 0
     
+    def get_target_sessions(self, project_id: str = None) -> List[str]:
+        """Get list of channel_names for target client sessions.
+        
+        Args:
+            project_id: If specified, only include sessions for this project
+            
+        Returns:
+            List of channel_names to target
+        """
+        if not self._client_sessions:
+            return []
+        
+        target_sessions = []
+        for session in self._client_sessions.values():
+            # If project_id specified, filter by project
+            if project_id and session.get("project_id") != project_id:
+                continue
+            target_sessions.append(session.get("channel_name"))
+        
+        return [s for s in target_sessions if s]  # Filter out None values
+    
+    def get_reply_channel_for_compatibility(self) -> Optional[str]:
+        """Get the first session's channel_name for backward compatibility.
+        
+        Returns:
+            First available channel_name or None
+        """
+        if not self._client_sessions:
+            return None
+        return next(iter(self._client_sessions.keys()), None)
+    
     def _write_debug_file(self) -> None:
         """Write current client sessions to debug JSON file."""
         try:
@@ -205,10 +236,12 @@ class TerminalManager:
                 reply_chan = message.get("reply_channel")
                 
                 logger.info("terminal_manager: Processing command '%s' with reply_channel=%s", cmd, reply_chan)
+                logger.debug("terminal_manager: Full message: %s", message)
                 
                 # Handle client sessions update directly (special case)
                 if cmd == "client_sessions_update":
                     sessions = message.get("sessions", [])
+                    logger.info("terminal_manager: Handling client_sessions_update with %d sessions", len(sessions))
                     self._client_session_manager.update_sessions(sessions)
                     logger.info("terminal_manager: Updated client sessions (%d sessions)", len(sessions))
                     continue
@@ -260,7 +293,39 @@ class TerminalManager:
         payload = {"event": "error", "message": message}
         if reply_channel:
             payload["reply_channel"] = reply_channel
-        await self._control_channel.send(payload)
+        await self._send_session_aware(payload)
+    
+    async def _send_session_aware(self, payload: dict, project_id: str = None) -> None:
+        """Send a message with client session awareness.
+        
+        Args:
+            payload: The message payload to send
+            project_id: Optional project filter for targeting specific sessions
+        """
+        # Check if there are any interested clients
+        if not self._client_session_manager.has_interested_clients():
+            logger.debug("terminal_manager: No interested clients, skipping message send")
+            return
+        
+        # Get target sessions
+        target_sessions = self._client_session_manager.get_target_sessions(project_id)
+        if not target_sessions:
+            logger.debug("terminal_manager: No target sessions found, skipping message send")
+            return
+        
+        # Add session targeting information
+        enhanced_payload = dict(payload)
+        enhanced_payload["client_sessions"] = target_sessions
+        
+        # Add backward compatibility reply_channel (first session)
+        reply_channel = self._client_session_manager.get_reply_channel_for_compatibility()
+        if reply_channel and "reply_channel" not in enhanced_payload:
+            enhanced_payload["reply_channel"] = reply_channel
+        
+        logger.debug("terminal_manager: Sending to %d client sessions: %s", 
+                    len(target_sessions), target_sessions)
+        
+        await self._control_channel.send(enhanced_payload)
 
     async def _send_terminal_list(self) -> None:
         """Send terminal list for reconnection reconciliation."""
@@ -272,7 +337,7 @@ class TerminalManager:
                 "event": "terminal_list",
                 "sessions": sessions,
             }
-            await self._control_channel.send(payload)
+            await self._send_session_aware(payload)
         except Exception as exc:
             logger.warning("Failed to send terminal list: %s", exc)
     
@@ -282,6 +347,8 @@ class TerminalManager:
             payload = {
                 "event": "request_client_sessions"
             }
+            # This is a special case - always send regardless of current client sessions
+            # because we're trying to get the client sessions list
             await self._control_channel.send(payload)
             logger.info("Requested client sessions from server")
         except Exception as exc:

{portacode-0.3.12.dev1 → portacode-0.3.12.dev3}/portacode.egg-info/PKG-INFO

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