portacode 0.3.5.dev0__tar.gz → 0.3.7.dev0__tar.gz

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.3.5.dev0
+Version: 0.3.7.dev0
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian
+Author-email: hi@menas.pro
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.5.dev'
-__version_tuple__ = version_tuple = (0, 3, 5, 'dev0')
+__version__ = version = '0.3.7.dev'
+__version_tuple__ = version_tuple = (0, 3, 7, 'dev0')

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/cli.py

@@ -29,11 +29,21 @@ def cli() -> None:
 @cli.command()
 @click.option("--gateway", "gateway", "-g", help="Gateway websocket URL (overrides env/ default)")
 @click.option("--detach", "detach", "-d", is_flag=True, help="Run connection in background")
+@click.option("--debug", "debug", is_flag=True, help="Enable debug logging")
 @click.option("--non-interactive", "non_interactive", is_flag=True, envvar="PORTACODE_NON_INTERACTIVE", hidden=True,
               help="Skip interactive prompts (used by background service)")
-def connect(gateway: str | None, detach: bool, non_interactive: bool) -> None:  # noqa: D401 – Click callback
+def connect(gateway: str | None, detach: bool, debug: bool, non_interactive: bool) -> None:  # noqa: D401 – Click callback
     """Connect this machine to Portacode gateway."""
 
+    # Set up debug logging if requested
+    if debug:
+        import logging
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        click.echo(click.style("🔍 Debug logging enabled", fg="yellow"))
+
     # 1. Ensure only a single connection per user
     pid_file = get_pid_file()
     if pid_file.exists():

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/connection/handlers/base.py

@@ -81,11 +81,15 @@ class AsyncHandler(BaseHandler):
     
     async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
         """Handle the command by executing it and sending the response."""
+        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)
             await self.send_response(response, reply_channel)
         except Exception as exc:
-            logger.exception("Error in async handler %s: %s", self.command_name, exc)
+            logger.exception("handler: Error in async handler %s: %s", self.command_name, exc)
             await self.send_error(str(exc), reply_channel)
 
 

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/connection/handlers/registry.py

@@ -81,16 +81,19 @@ class CommandRegistry:
         Returns:
             True if handler was found and executed, False otherwise
         """
+        logger.info("registry: Dispatching command '%s' with reply_channel=%s", command_name, reply_channel)
+        
         handler = self.get_handler(command_name)
         if handler is None:
-            logger.warning("No handler found for command: %s", command_name)
+            logger.warning("registry: No handler found for command: %s", command_name)
             return False
         
         try:
             await handler.handle(message, reply_channel)
+            logger.info("registry: Successfully dispatched command '%s'", command_name)
             return True
         except Exception as exc:
-            logger.exception("Error dispatching command %s: %s", command_name, 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:

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/connection/handlers/session.py

@@ -83,11 +83,46 @@ class TerminalSession:
             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()
+        """Stop the terminal session with comprehensive logging."""
+        logger.info("session.stop: Starting stop process for session %s (PID: %s)", 
+                   self.id, getattr(self.proc, 'pid', 'unknown'))
+        
+        try:
+            # Check if process is still running
+            if self.proc.returncode is None:
+                logger.info("session.stop: Terminating process for session %s", self.id)
+                self.proc.terminate()
+            else:
+                logger.info("session.stop: Process for session %s already exited (returncode: %s)", 
+                           self.id, self.proc.returncode)
+            
+            # Wait for reader task to complete
+            if self._reader_task and not self._reader_task.done():
+                logger.info("session.stop: Waiting for reader task to complete for session %s", self.id)
+                try:
+                    await asyncio.wait_for(self._reader_task, timeout=5.0)
+                    logger.info("session.stop: Reader task completed for session %s", self.id)
+                except asyncio.TimeoutError:
+                    logger.warning("session.stop: Reader task timeout for session %s, cancelling", self.id)
+                    self._reader_task.cancel()
+                    try:
+                        await self._reader_task
+                    except asyncio.CancelledError:
+                        pass
+            
+            # Wait for process to exit
+            if self.proc.returncode is None:
+                logger.info("session.stop: Waiting for process to exit for session %s", self.id)
+                await self.proc.wait()
+                logger.info("session.stop: Process exited for session %s (returncode: %s)", 
+                           self.id, self.proc.returncode)
+            else:
+                logger.info("session.stop: Process already exited for session %s (returncode: %s)", 
+                           self.id, self.proc.returncode)
+                
+        except Exception as exc:
+            logger.exception("session.stop: Error stopping session %s: %s", self.id, exc)
+            raise
 
     def snapshot_buffer(self) -> str:
         """Return concatenated last buffer contents suitable for UI."""
@@ -168,10 +203,37 @@ class WindowsTerminalSession(TerminalSession):
             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
+        """Stop the Windows terminal session with comprehensive logging."""
+        logger.info("session.stop: Starting stop process for Windows session %s (PID: %s)", 
+                   self.id, getattr(self._pty, 'pid', 'unknown'))
+        
+        try:
+            # Check if PTY is still alive
+            if self._pty.isalive():
+                logger.info("session.stop: Killing PTY process for session %s", self.id)
+                self._pty.kill()
+            else:
+                logger.info("session.stop: PTY process for session %s already exited", self.id)
+            
+            # Wait for reader task to complete
+            if self._reader_task and not self._reader_task.done():
+                logger.info("session.stop: Waiting for reader task to complete for Windows session %s", self.id)
+                try:
+                    await asyncio.wait_for(self._reader_task, timeout=5.0)
+                    logger.info("session.stop: Reader task completed for Windows session %s", self.id)
+                except asyncio.TimeoutError:
+                    logger.warning("session.stop: Reader task timeout for Windows session %s, cancelling", self.id)
+                    self._reader_task.cancel()
+                    try:
+                        await self._reader_task
+                    except asyncio.CancelledError:
+                        pass
+            
+            logger.info("session.stop: Successfully stopped Windows session %s", self.id)
+                
+        except Exception as exc:
+            logger.exception("session.stop: Error stopping Windows session %s: %s", self.id, exc)
+            raise
 
 
 class SessionManager:
@@ -270,7 +332,13 @@ class SessionManager:
 
     def remove_session(self, terminal_id: str) -> Optional[TerminalSession]:
         """Remove and return a terminal session."""
-        return self._sessions.pop(terminal_id, None)
+        session = self._sessions.pop(terminal_id, None)
+        if session:
+            logger.info("session_manager: Removed session %s (PID: %s) from session manager", 
+                       terminal_id, getattr(session.proc, 'pid', 'unknown'))
+        else:
+            logger.warning("session_manager: Attempted to remove non-existent session %s", terminal_id)
+        return session
 
     def list_sessions(self) -> List[Dict[str, Any]]:
         """List all terminal sessions."""

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/connection/handlers/terminal_handlers.py

@@ -100,22 +100,89 @@ 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)
+            return {
+                "event": "terminal_stopped",
+                "terminal_id": terminal_id,
+                "status": "not_found",
+                "message": "Terminal was not found or already stopped"
+            }
         
-        await session.stop()
+        logger.info("terminal_stop: Found session for terminal %s (PID: %s), starting background stop process", 
+                   terminal_id, getattr(session.proc, 'pid', 'unknown'))
+        
+        # Start stop process in background without blocking the control channel
+        asyncio.create_task(self._stop_session_safely(session, terminal_id))
         
         return {
             "event": "terminal_stopped",
             "terminal_id": terminal_id,
+            "status": "stopping",
+            "message": "Terminal stop process initiated"
         }
+    
+    async def _stop_session_safely(self, session, terminal_id: str) -> 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.control_channel.send({
+                "event": "terminal_stop_completed",
+                "terminal_id": terminal_id,
+                "status": "success",
+                "message": "Terminal stopped successfully"
+            })
+            
+        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.control_channel.send({
+                "event": "terminal_stop_completed",
+                "terminal_id": terminal_id,
+                "status": "timeout",
+                "message": "Terminal stop timed out, process was force killed"
+            })
+            
+        except Exception as exc:
+            logger.exception("terminal_stop: Error stopping terminal %s: %s", terminal_id, exc)
+            
+            # Send error notification
+            await self.control_channel.send({
+                "event": "terminal_stop_completed",
+                "terminal_id": terminal_id,
+                "status": "error",
+                "message": f"Error stopping terminal: {str(exc)}"
+            })
 
 
 class TerminalListHandler(AsyncHandler):

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode/connection/terminal.py

@@ -113,31 +113,45 @@ class TerminalManager:
     # ---------------------------------------------------------------------
 
     async def _control_loop(self) -> None:
+        logger.info("terminal_manager: Starting control loop")
         while True:
-            message = await self._control_channel.recv()
-            # Older parts of the system may send *raw* str. Ensure dict.
-            if isinstance(message, str):
-                try:
-                    message = json.loads(message)
-                except Exception:
-                    logger.warning("Discarding non-JSON control frame: %s", message)
+            try:
+                message = await self._control_channel.recv()
+                logger.debug("terminal_manager: Received message: %s", message)
+                
+                # Older parts of the system may send *raw* str. Ensure dict.
+                if isinstance(message, str):
+                    try:
+                        message = json.loads(message)
+                        logger.debug("terminal_manager: Parsed string message to dict")
+                    except Exception:
+                        logger.warning("terminal_manager: Discarding non-JSON control frame: %s", message)
+                        continue
+                if not isinstance(message, dict):
+                    logger.warning("terminal_manager: Invalid control frame type: %r", type(message))
                     continue
-            if not isinstance(message, dict):
-                logger.warning("Invalid control frame type: %r", type(message))
-                continue
-            cmd = message.get("cmd")
-            if not cmd:
-                # Ignore frames that are *events* coming from the remote side
-                if message.get("event"):
+                cmd = message.get("cmd")
+                if not cmd:
+                    # Ignore frames that are *events* coming from the remote side
+                    if message.get("event"):
+                        logger.debug("terminal_manager: Ignoring event message: %s", message.get("event"))
+                        continue
+                    logger.warning("terminal_manager: Missing 'cmd' in control frame: %s", message)
                     continue
-                logger.warning("Missing 'cmd' in control frame: %s", message)
+                reply_chan = message.get("reply_channel")
+                
+                logger.info("terminal_manager: Processing command '%s' with reply_channel=%s", cmd, reply_chan)
+                
+                # Dispatch command through registry
+                handled = await self._command_registry.dispatch(cmd, message, reply_chan)
+                if not handled:
+                    logger.warning("terminal_manager: Command '%s' was not handled by any handler", cmd)
+                    await self._send_error(f"Unknown cmd: {cmd}", reply_chan)
+                    
+            except Exception as exc:
+                logger.exception("terminal_manager: Error in control loop: %s", exc)
+                # Continue processing other messages
                 continue
-            reply_chan = message.get("reply_channel")
-            
-            # Dispatch command through registry
-            handled = await self._command_registry.dispatch(cmd, message, reply_chan)
-            if not handled:
-                await self._send_error(f"Unknown cmd: {cmd}", reply_chan)
 
     # ------------------------------------------------------------------
     # Extension API

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/portacode.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.3.5.dev0
+Version: 0.3.7.dev0
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian
+Author-email: hi@menas.pro
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{portacode-0.3.5.dev0 → portacode-0.3.7.dev0}/setup.py

@@ -14,6 +14,7 @@ setup(
     long_description=README,
     long_description_content_type="text/markdown",
     author="Meena Erian",
+    author_email="hi@menas.pro",
     url="https://github.com/portacode/portacode",
     packages=find_packages(exclude=("tests", "server")),
     python_requires=">=3.8",