portacode 0.3.16.dev10__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

@@ -0,0 +1,389 @@
+"""Tab factory for creating TabInfo objects with appropriate content loading.
+
+This module provides a centralized way to create tabs for different file types,
+handling content loading, MIME type detection, and encoding appropriately.
+"""
+
+import asyncio
+import base64
+import logging
+import mimetypes
+import os
+import uuid
+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__)
+
+# Maximum file size for text content loading (10MB)
+MAX_TEXT_FILE_SIZE = 10 * 1024 * 1024
+
+# Maximum file size for binary content loading (50MB)
+MAX_BINARY_FILE_SIZE = 50 * 1024 * 1024
+
+# Text file extensions that should be treated as code/text
+TEXT_EXTENSIONS = {
+    # Programming languages
+    '.py', '.js', '.ts', '.jsx', '.tsx', '.html', '.htm', '.css', '.scss', '.sass',
+    '.json', '.xml', '.yaml', '.yml', '.toml', '.ini', '.cfg', '.conf',
+    '.java', '.c', '.cpp', '.cc', '.cxx', '.h', '.hpp', '.cs', '.php', '.rb',
+    '.go', '.rs', '.kt', '.swift', '.dart', '.scala', '.clj', '.hs', '.ml',
+    '.r', '.m', '.pl', '.lua', '.sh', '.bash', '.zsh', '.fish', '.ps1', '.bat',
+    '.sql', '.graphql', '.proto', '.thrift',
+    
+    # Markup and documentation
+    '.md', '.markdown', '.rst', '.txt', '.rtf', '.tex', '.latex',
+    '.adoc', '.asciidoc', '.org',
+    
+    # Configuration and data
+    '.env', '.gitignore', '.gitattributes', '.dockerignore', '.editorconfig',
+    '.eslintrc', '.prettierrc', '.babelrc', '.tsconfig', '.package-lock',
+    '.requirements', '.pipfile', '.gemfile', '.makefile', '.cmake',
+    
+    # Web technologies
+    '.vue', '.svelte', '.astro', '.ejs', '.hbs', '.handlebars', '.mustache',
+    '.pug', '.jade', '.haml', '.slim',
+    
+    # Other text formats
+    '.log', '.diff', '.patch', '.csv', '.tsv', '.properties'
+}
+
+# Binary file extensions that should be treated as media
+MEDIA_EXTENSIONS = {
+    # Images
+    '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.tif', '.webp', '.svg',
+    '.ico', '.icns', '.cur', '.psd', '.ai', '.eps', '.raw', '.cr2', '.nef',
+    
+    # Audio
+    '.mp3', '.wav', '.flac', '.aac', '.ogg', '.oga', '.wma', '.m4a', '.opus', '.webm',
+    
+    # Video
+    '.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm', '.m4v', '.3gp',
+    '.ogv', '.ts', '.mts', '.m2ts'
+}
+
+# Extensions that should be ignored/not loaded
+IGNORED_EXTENSIONS = {
+    '.exe', '.dll', '.so', '.dylib', '.bin', '.dat', '.cache', '.tmp', '.temp',
+    '.lock', '.pid', '.swp', '.swo', '.bak', '.orig', '.pyc', '.pyo', '.class',
+    '.o', '.obj', '.lib', '.a', '.jar', '.war', '.ear', '.zip', '.tar', '.gz',
+    '.7z', '.rar', '.deb', '.rpm', '.dmg', '.iso', '.img'
+}
+
+
+class TabFactory:
+    """Factory class for creating TabInfo objects with appropriate content."""
+    
+    def __init__(self):
+        self.logger = logger.getChild(self.__class__.__name__)
+    
+    async def create_file_tab(self, file_path: str, tab_id: Optional[str] = None) -> TabInfo:
+        """Create a file tab with content loaded based on file type.
+        
+        Args:
+            file_path: Absolute path to the file
+            tab_id: Optional tab ID, will generate UUID if not provided
+            
+        Returns:
+            TabInfo object with appropriate content loaded
+        """
+        if tab_id is None:
+            tab_id = str(uuid.uuid4())
+        
+        file_path = Path(file_path)
+        
+        # Basic tab info
+        tab_info = {
+            'tab_id': tab_id,
+            'tab_type': 'file',
+            'title': file_path.name,
+            'file_path': str(file_path),
+            'content': None,
+            'original_content': None,
+            'modified_content': None,
+            'is_dirty': False,
+            'mime_type': None,
+            'encoding': None,
+            'metadata': {}
+        }
+        
+        # Check if file exists
+        if not file_path.exists():
+            self.logger.warning(f"File does not exist: {file_path}")
+            tab_info['metadata']['error'] = 'File not found'
+            return TabInfo(**tab_info)
+        
+        # Check if it's a file (not directory)
+        if not file_path.is_file():
+            self.logger.warning(f"Path is not a file: {file_path}")
+            tab_info['metadata']['error'] = 'Not a file'
+            return TabInfo(**tab_info)
+        
+        # Get file info
+        try:
+            file_stat = file_path.stat()
+            file_size = file_stat.st_size
+            tab_info['metadata']['size'] = file_size
+            tab_info['metadata']['modified_time'] = file_stat.st_mtime
+        except OSError as e:
+            self.logger.error(f"Error getting file info for {file_path}: {e}")
+            tab_info['metadata']['error'] = f'Cannot access file: {e}'
+            return TabInfo(**tab_info)
+        
+        # Determine file type and MIME type
+        extension = file_path.suffix.lower()
+        mime_type, _ = mimetypes.guess_type(str(file_path))
+        tab_info['mime_type'] = mime_type
+        
+        # Determine how to handle the file
+        if extension in IGNORED_EXTENSIONS:
+            tab_info['metadata']['ignored'] = True
+            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
+        if extension in TEXT_EXTENSIONS or self._is_text_file(file_path, mime_type):
+            await self._load_text_content(file_path, tab_info, file_size)
+        elif extension in MEDIA_EXTENSIONS or (mime_type and mime_type.startswith(('image/', 'audio/', 'video/'))):
+            await self._load_media_content(file_path, tab_info, file_size, mime_type)
+        else:
+            # Try to detect if it's a text file by sampling
+            if await self._detect_text_file(file_path):
+                await self._load_text_content(file_path, tab_info, file_size)
+            else:
+                await self._load_binary_content(file_path, tab_info, file_size)
+        
+        return TabInfo(**tab_info)
+
+    async def create_diff_tab_with_title(self, file_path: str, original_content: str, 
+                                       modified_content: str, title: str, 
+                                       tab_id: Optional[str] = None,
+                                       diff_details: Optional[Dict[str, Any]] = None) -> TabInfo:
+        """Create a diff tab with a custom title for git timeline comparisons.
+        
+        Args:
+            file_path: Path to the file being compared
+            original_content: Original version of the file
+            modified_content: Modified version of the file
+            title: Custom title for the diff tab
+            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 with custom title
+        """
+        if tab_id is None:
+            tab_id = str(uuid.uuid4())
+        
+        metadata = {'diff_mode': True, 'timeline_diff': True}
+        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',
+            title=title,
+            file_path=str(file_path),
+            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',
+            metadata=metadata
+        )
+    
+    async def create_untitled_tab(self, content: str = "", language: str = "plaintext", 
+                                tab_id: Optional[str] = None) -> TabInfo:
+        """Create an untitled tab for new content.
+        
+        Args:
+            content: Initial content for the tab
+            language: Programming language for syntax highlighting
+            tab_id: Optional tab ID, will generate UUID if not provided
+            
+        Returns:
+            TabInfo object for untitled content
+        """
+        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
+            mime_type=None,
+            encoding='utf-8',
+            metadata={'language': language}
+        )
+    
+    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:
+            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
+        
+        try:
+            # Try different encodings
+            for encoding in ['utf-8', 'utf-16', 'latin-1', 'cp1252']:
+                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
+                except UnicodeDecodeError:
+                    continue
+            
+            # If all encodings fail, treat as binary
+            self.logger.warning(f"Could not decode {file_path} as text, treating as binary")
+            await self._load_binary_content(file_path, tab_info, file_size)
+            
+        except OSError as e:
+            self.logger.error(f"Error reading file {file_path}: {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:
+            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
+        
+        try:
+            # Determine tab type based on MIME type
+            if mime_type:
+                if mime_type.startswith('image/'):
+                    tab_info['tab_type'] = 'image'
+                elif mime_type.startswith('audio/'):
+                    tab_info['tab_type'] = 'audio'
+                elif mime_type.startswith('video/'):
+                    tab_info['tab_type'] = 'video'
+            
+            # Read file as binary and encode as base64
+            binary_content = file_path.read_bytes()
+            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
+            
+            self.logger.debug(f"Loaded media file {file_path} as base64 ({file_size} bytes)")
+            
+        except OSError as e:
+            self.logger.error(f"Error reading media file {file_path}: {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."""
+        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")
+    
+    def _is_text_file(self, file_path: Path, mime_type: Optional[str]) -> bool:
+        """Check if a file should be treated as text based on MIME type."""
+        if not mime_type:
+            return False
+        
+        return (mime_type.startswith('text/') or 
+                mime_type in ['application/json', 'application/xml', 'application/javascript',
+                             'application/typescript', 'application/x-python', 'application/x-sh'])
+    
+    async def _detect_text_file(self, file_path: Path) -> bool:
+        """Try to detect if a file is text by sampling the beginning."""
+        try:
+            # Read first 1024 bytes
+            with open(file_path, 'rb') as f:
+                sample = f.read(1024)
+            
+            # Check for null bytes (strong indicator of binary)
+            if b'\x00' in sample:
+                return False
+            
+            # Try to decode as UTF-8
+            try:
+                sample.decode('utf-8')
+                return True
+            except UnicodeDecodeError:
+                return False
+                
+        except OSError:
+            return False
+    
+    def _format_file_size(self, size_bytes: int) -> str:
+        """Format file size in human-readable format."""
+        if size_bytes < 1024:
+            return f"{size_bytes} B"
+        elif size_bytes < 1024 ** 2:
+            return f"{size_bytes / 1024:.1f} KB"
+        elif size_bytes < 1024 ** 3:
+            return f"{size_bytes / (1024 ** 2):.1f} MB"
+        else:
+            return f"{size_bytes / (1024 ** 3):.1f} GB"
+
+
+# Global factory instance
+_tab_factory = None
+
+def get_tab_factory() -> TabFactory:
+    """Get the global tab factory instance."""
+    global _tab_factory
+    if _tab_factory is None:
+        _tab_factory = TabFactory()
+    return _tab_factory

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,