portacode 0.3.19.dev4__py3-none-any.whl → 1.4.11.dev1__py3-none-any.whl

portacode/connection/handlers/system_handlers.py

@@ -1,17 +1,155 @@
 """System command handlers."""
 
+import concurrent.futures
+import getpass
+import importlib.util
 import logging
 import os
 import platform
+import shutil
+import threading
 from pathlib import Path
 from typing import Any, Dict
+
 from portacode import __version__
 import psutil
 
+try:
+    from importlib import metadata as importlib_metadata
+except ImportError:  # pragma: no cover - py<3.8
+    import importlib_metadata
+
 from .base import SyncHandler
+from .proxmox_infra import get_infra_snapshot
 
 logger = logging.getLogger(__name__)
 
+# Global CPU monitoring
+_cpu_percent = 0.0
+_cpu_thread = None
+_cpu_lock = threading.Lock()
+
+def _cpu_monitor():
+    """Background thread to update CPU usage every 5 seconds."""
+    global _cpu_percent
+    while True:
+        _cpu_percent = psutil.cpu_percent(interval=5.0)
+
+def _ensure_cpu_thread():
+    """Ensure CPU monitoring thread is running (singleton)."""
+    global _cpu_thread
+    with _cpu_lock:
+        if _cpu_thread is None or not _cpu_thread.is_alive():
+            _cpu_thread = threading.Thread(target=_cpu_monitor, daemon=True)
+            _cpu_thread.start()
+
+
+def _get_user_context() -> Dict[str, Any]:
+    """Gather current CLI user plus permission hints."""
+    context = {}
+    login_source = "os.getlogin"
+    try:
+        username = os.getlogin()
+    except Exception:
+        login_source = "getpass"
+        username = getpass.getuser()
+
+    context["username"] = username
+    context["username_source"] = login_source
+    context["home"] = str(Path.home())
+
+    uid = getattr(os, "getuid", None)
+    euid = getattr(os, "geteuid", None)
+    context["uid"] = uid() if uid else None
+    context["euid"] = euid() if euid else context["uid"]
+    if os.name == "nt":
+        try:
+            import ctypes
+
+            context["is_root"] = bool(ctypes.windll.shell32.IsUserAnAdmin())
+        except Exception:
+            context["is_root"] = None
+    else:
+        context["is_root"] = context["euid"] == 0 if context["euid"] is not None else False
+
+    context["has_sudo"] = shutil.which("sudo") is not None
+    context["sudo_user"] = os.environ.get("SUDO_USER")
+    context["is_sudo_session"] = bool(os.environ.get("SUDO_UID"))
+    return context
+
+
+def _get_playwright_info() -> Dict[str, Any]:
+    """Return Playwright presence, version, and browser binaries if available."""
+    result: Dict[str, Any] = {
+        "installed": False,
+        "version": None,
+        "browsers": {},
+        "error": None,
+    }
+
+    if importlib.util.find_spec("playwright") is None:
+        return result
+
+    result["installed"] = True
+    try:
+        result["version"] = importlib_metadata.version("playwright")
+    except Exception as exc:
+        logger.debug("Unable to read Playwright version metadata: %s", exc)
+
+    def _inspect_browsers() -> Dict[str, Any]:
+        from playwright.sync_api import sync_playwright
+
+        browsers_data: Dict[str, Any] = {}
+        with sync_playwright() as p:
+            for name in ("chromium", "firefox", "webkit"):
+                browser_type = getattr(p, name, None)
+                if browser_type is None:
+                    continue
+                exec_path = getattr(browser_type, "executable_path", None)
+                browsers_data[name] = {
+                    "available": bool(exec_path),
+                    "executable_path": exec_path,
+                }
+        return browsers_data
+
+    try:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(_inspect_browsers)
+            browsers = future.result(timeout=5)
+            result["browsers"] = browsers
+    except concurrent.futures.TimeoutError:
+        msg = "Playwright inspection timed out"
+        logger.warning(msg)
+        result["error"] = msg
+    except Exception as exc:
+        logger.warning("Playwright browser inspection failed: %s", exc)
+        result["error"] = str(exc)
+
+    return result
+
+
+def _get_proxmox_info() -> Dict[str, Any]:
+    """Detect if the current host is a Proxmox node."""
+    info: Dict[str, Any] = {"is_proxmox_node": False, "version": None}
+    release_file = Path("/etc/proxmox-release")
+    if release_file.exists():
+        info["is_proxmox_node"] = True
+        try:
+            info["version"] = release_file.read_text().strip()
+        except Exception:
+            info["version"] = None
+    elif Path("/etc/pve").exists():
+        info["is_proxmox_node"] = True
+    if not info["version"]:
+        version_hint = Path("/etc/pve/.version")
+        if version_hint.exists():
+            try:
+                info["version"] = version_hint.read_text().strip()
+            except Exception:
+                info["version"] = None
+    info["infra"] = get_infra_snapshot()
+    return info
+
 
 def _get_os_info() -> Dict[str, Any]:
     """Get operating system information with robust error handling."""
@@ -98,15 +236,13 @@ class SystemInfoHandler(SyncHandler):
         """Get system information including OS details."""
         logger.debug("Collecting system information...")
         
+        # Ensure CPU monitoring thread is running
+        _ensure_cpu_thread()
+        
         # Collect basic system metrics
         info = {}
         
-        try:
-            info["cpu_percent"] = psutil.cpu_percent(interval=0.1)
-            logger.debug("CPU usage: %s%%", info["cpu_percent"])
-        except Exception as e:
-            logger.warning("Failed to get CPU info: %s", e)
-            info["cpu_percent"] = 0.0
+        info["cpu_percent"] = _cpu_percent
             
         try:
             info["memory"] = psutil.virtual_memory()._asdict()
@@ -124,11 +260,14 @@ class SystemInfoHandler(SyncHandler):
         
         # Add OS information - this is critical for proper shell detection
         info["os_info"] = _get_os_info()
-        logger.info("System info collected successfully with OS info: %s", info.get("os_info", {}).get("os_type", "Unknown"))
+        info["user_context"] = _get_user_context()
+        info["playwright"] = _get_playwright_info()
+        info["proxmox"] = _get_proxmox_info()
+        # logger.info("System info collected successfully with OS info: %s", info.get("os_info", {}).get("os_type", "Unknown"))
         
         info["portacode_version"] = __version__
 
         return {
             "event": "system_info",
             "info": info,
-        } 
+        } 

portacode/connection/handlers/tab_factory.py

@@ -14,6 +14,8 @@ from pathlib import Path
 from typing import Optional, Dict, Any
 
 from .project_state_handlers import TabInfo
+from .project_state.utils import generate_content_hash
+from .file_handlers import cache_content
 
 logger = logging.getLogger(__name__)
 
@@ -57,7 +59,7 @@ MEDIA_EXTENSIONS = {
     '.ico', '.icns', '.cur', '.psd', '.ai', '.eps', '.raw', '.cr2', '.nef',
     
     # Audio
-    '.mp3', '.wav', '.flac', '.aac', '.ogg', '.wma', '.m4a', '.opus', '.webm',
+    '.mp3', '.wav', '.flac', '.aac', '.ogg', '.oga', '.wma', '.m4a', '.opus', '.webm',
     
     # Video
     '.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm', '.m4v', '.3gp',
@@ -140,7 +142,11 @@ class TabFactory:
         # Determine how to handle the file
         if extension in IGNORED_EXTENSIONS:
             tab_info['metadata']['ignored'] = True
-            tab_info['content'] = f"# Binary file not displayed\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}"
+            content = f"# Binary file not displayed\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}"
+            tab_info['content'] = content
+            content_hash = generate_content_hash(content)
+            tab_info['content_hash'] = content_hash
+            cache_content(content_hash, content)
             return TabInfo(**tab_info)
         
         # Handle different file types
@@ -156,45 +162,7 @@ class TabFactory:
                 await self._load_binary_content(file_path, tab_info, file_size)
         
         return TabInfo(**tab_info)
-    
-    async def create_diff_tab(self, file_path: str, original_content: str, 
-                            modified_content: str, tab_id: Optional[str] = None,
-                            diff_details: Optional[Dict[str, Any]] = None) -> TabInfo:
-        """Create a diff tab for comparing file versions.
-        
-        Args:
-            file_path: Path to the file being compared
-            original_content: Original version of the file
-            modified_content: Modified version of the file
-            tab_id: Optional tab ID, will generate UUID if not provided
-            diff_details: Optional detailed diff information from diff-match-patch
-            
-        Returns:
-            TabInfo object configured for diff viewing
-        """
-        if tab_id is None:
-            tab_id = str(uuid.uuid4())
-        
-        file_path = Path(file_path)
-        
-        metadata = {'diff_mode': True}
-        if diff_details:
-            metadata['diff_details'] = diff_details
-        
-        return TabInfo(
-            tab_id=tab_id,
-            tab_type='diff',
-            title=f"{file_path.name} (diff)",
-            file_path=str(file_path),
-            content=None,  # Diff tabs don't use regular content
-            original_content=original_content,
-            modified_content=modified_content,
-            is_dirty=False,
-            mime_type=None,
-            encoding='utf-8',
-            metadata=metadata
-        )
-    
+
     async def create_diff_tab_with_title(self, file_path: str, original_content: str, 
                                        modified_content: str, title: str, 
                                        tab_id: Optional[str] = None,
@@ -219,6 +187,12 @@ class TabFactory:
         if diff_details:
             metadata['diff_details'] = diff_details
         
+        # Cache diff content
+        original_hash = generate_content_hash(original_content)
+        modified_hash = generate_content_hash(modified_content)
+        cache_content(original_hash, original_content)
+        cache_content(modified_hash, modified_content)
+        
         return TabInfo(
             tab_id=tab_id,
             tab_type='diff',
@@ -227,6 +201,8 @@ class TabFactory:
             content=None,  # Diff tabs don't use regular content
             original_content=original_content,
             modified_content=modified_content,
+            original_content_hash=original_hash,
+            modified_content_hash=modified_hash,
             is_dirty=False,
             mime_type=None,
             encoding='utf-8',
@@ -248,12 +224,17 @@ class TabFactory:
         if tab_id is None:
             tab_id = str(uuid.uuid4())
         
+        # Cache untitled content
+        content_hash = generate_content_hash(content)
+        cache_content(content_hash, content)
+        
         return TabInfo(
             tab_id=tab_id,
             tab_type='untitled',
             title="Untitled",
             file_path=None,
             content=content,
+            content_hash=content_hash,
             original_content=None,
             modified_content=None,
             is_dirty=bool(content),  # Dirty if has initial content
@@ -265,7 +246,11 @@ class TabFactory:
     async def _load_text_content(self, file_path: Path, tab_info: Dict[str, Any], file_size: int):
         """Load text content from file."""
         if file_size > MAX_TEXT_FILE_SIZE:
-            tab_info['content'] = f"# File too large to display\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}\n# Maximum size for text files: {self._format_file_size(MAX_TEXT_FILE_SIZE)}"
+            content = f"# File too large to display\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}\n# Maximum size for text files: {self._format_file_size(MAX_TEXT_FILE_SIZE)}"
+            tab_info['content'] = content
+            content_hash = generate_content_hash(content)
+            tab_info['content_hash'] = content_hash
+            cache_content(content_hash, content)
             tab_info['metadata']['truncated'] = True
             return
         
@@ -275,6 +260,9 @@ class TabFactory:
                 try:
                     content = file_path.read_text(encoding=encoding)
                     tab_info['content'] = content
+                    content_hash = generate_content_hash(content)
+                    tab_info['content_hash'] = content_hash
+                    cache_content(content_hash, content)
                     tab_info['encoding'] = encoding
                     self.logger.debug(f"Successfully loaded {file_path} with {encoding} encoding")
                     return
@@ -287,14 +275,22 @@ class TabFactory:
             
         except OSError as e:
             self.logger.error(f"Error reading file {file_path}: {e}")
-            tab_info['content'] = f"# Error reading file\n# {e}"
+            content = f"# Error reading file\n# {e}"
+            tab_info['content'] = content
+            content_hash = generate_content_hash(content)
+            tab_info['content_hash'] = content_hash
+            cache_content(content_hash, content)
             tab_info['metadata']['error'] = str(e)
     
     async def _load_media_content(self, file_path: Path, tab_info: Dict[str, Any], 
                                 file_size: int, mime_type: Optional[str]):
         """Load media content as base64."""
         if file_size > MAX_BINARY_FILE_SIZE:
-            tab_info['content'] = f"# Media file too large to display\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}"
+            content = f"# Media file too large to display\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}"
+            tab_info['content'] = content
+            content_hash = generate_content_hash(content)
+            tab_info['content_hash'] = content_hash
+            cache_content(content_hash, content)
             tab_info['metadata']['too_large'] = True
             return
         
@@ -313,6 +309,9 @@ class TabFactory:
             base64_content = base64.b64encode(binary_content).decode('ascii')
             
             tab_info['content'] = base64_content
+            content_hash = generate_content_hash(base64_content)
+            tab_info['content_hash'] = content_hash
+            cache_content(content_hash, base64_content)
             tab_info['encoding'] = 'base64'
             tab_info['metadata']['original_size'] = file_size
             
@@ -320,12 +319,20 @@ class TabFactory:
             
         except OSError as e:
             self.logger.error(f"Error reading media file {file_path}: {e}")
-            tab_info['content'] = f"# Error loading media file\n# {e}"
+            content = f"# Error loading media file\n# {e}"
+            tab_info['content'] = content
+            content_hash = generate_content_hash(content)
+            tab_info['content_hash'] = content_hash
+            cache_content(content_hash, content)
             tab_info['metadata']['error'] = str(e)
     
     async def _load_binary_content(self, file_path: Path, tab_info: Dict[str, Any], file_size: int):
         """Handle binary files that can't be displayed."""
-        tab_info['content'] = f"# Binary file\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}\n# Type: {tab_info.get('mime_type', 'Unknown')}\n\n# This file contains binary data and cannot be displayed as text."
+        content = f"# Binary file\n# File: {file_path.name}\n# Size: {self._format_file_size(file_size)}\n# Type: {tab_info.get('mime_type', 'Unknown')}\n\n# This file contains binary data and cannot be displayed as text."
+        tab_info['content'] = content
+        content_hash = generate_content_hash(content)
+        tab_info['content_hash'] = content_hash
+        cache_content(content_hash, content)
         tab_info['metadata']['binary'] = True
         self.logger.debug(f"Marked {file_path} as binary file")
     

portacode/connection/handlers/terminal_handlers.py

@@ -218,24 +218,33 @@ class TerminalListHandler(AsyncHandler):
     
     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", 
+        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", 
+
+            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
@@ -249,15 +258,19 @@ class TerminalListHandler(AsyncHandler):
         session_manager = self.context.get("session_manager")
         if not session_manager:
             raise RuntimeError("Session manager not available")
-        
+
         # 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,

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: