portacode 1.3.32__py3-none-any.whl → 1.4.15.dev3__py3-none-any.whl

portacode/connection/handlers/system_handlers.py

@@ -1,17 +1,318 @@
 """System command handlers."""
+from __future__ import annotations
 
+import concurrent.futures
+import getpass
+import importlib.util
 import logging
 import os
 import platform
+import shutil
+import subprocess
+import threading
+import time
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Optional
+
 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()
+
+# Cgroup v2 tracking
+_CGROUP_ROOT = Path("/sys/fs/cgroup")
+_cgroup_path: Optional[Path] = None
+_cgroup_v2_supported: Optional[bool] = None
+_CGROUP_CPU_STAT = "cpu.stat"
+_CGROUP_CPU_MAX = "cpu.max"
+_last_cgroup_usage: Optional[int] = None
+_last_cgroup_time: Optional[float] = None
+
+def _cpu_monitor():
+    """Background thread to update CPU usage every 5 seconds."""
+    global _cpu_percent
+    while True:
+        percent = _get_cgroup_cpu_percent()
+        if percent is None:
+            # Fall back to psutil when cgroup stats are not available yet.
+            percent = psutil.cpu_percent(interval=5.0)
+        else:
+            time.sleep(5.0)
+        _cpu_percent = percent
+
+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 _resolve_cgroup_path() -> Path:
+    global _cgroup_path
+    if _cgroup_path is not None and _cgroup_path.exists():
+        return _cgroup_path
+    path = _CGROUP_ROOT
+    cgroup_file = Path("/proc/self/cgroup")
+    if cgroup_file.exists():
+        try:
+            contents = cgroup_file.read_text()
+        except OSError:
+            pass
+        else:
+            for line in contents.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split(":", 2)
+                if len(parts) < 3:
+                    continue
+                rel_path = parts[-1].lstrip("/")
+                candidate = _CGROUP_ROOT / rel_path
+                # Fallback to root path if the relative path is empty
+                candidate = candidate if rel_path else _CGROUP_ROOT
+                if candidate.exists():
+                    path = candidate
+                    break
+    _cgroup_path = path
+    return _cgroup_path
+
+
+def _cgroup_file(name: str) -> Path:
+    return _resolve_cgroup_path() / name
+
+
+def _detect_cgroup_v2() -> bool:
+    global _cgroup_v2_supported
+    if _cgroup_v2_supported is not None:
+        return _cgroup_v2_supported
+    controllers = _cgroup_file("cgroup.controllers")
+    cpu_stat = _cgroup_file(_CGROUP_CPU_STAT)
+    _cgroup_v2_supported = controllers.exists() and cpu_stat.exists()
+    return _cgroup_v2_supported
+
+
+def _read_cgroup_cpu_usage() -> Optional[int]:
+    path = _cgroup_file(_CGROUP_CPU_STAT)
+    try:
+        data = path.read_text()
+    except (OSError, UnicodeDecodeError):
+        return None
+    for line in data.splitlines():
+        parts = line.strip().split()
+        if len(parts) >= 2 and parts[0] == "usage_usec":
+            try:
+                return int(parts[1])
+            except ValueError:
+                return None
+    return None
+
+
+def _read_cgroup_cpu_limit() -> Optional[float]:
+    """Return the allowed CPU (cores) for this cgroup, if limited."""
+    path = _cgroup_file(_CGROUP_CPU_MAX)
+    if not path.exists():
+        return None
+    try:
+        data = path.read_text().strip()
+    except (OSError, UnicodeDecodeError):
+        return None
+    parts = data.split()
+    if len(parts) < 2:
+        return None
+    quota, period = parts[0], parts[1]
+    if quota == "max":
+        return None
+    try:
+        quota_value = int(quota)
+        period_value = int(period)
+    except ValueError:
+        return None
+    if period_value <= 0:
+        return None
+    return quota_value / period_value
+
+
+def _get_cgroup_cpu_percent() -> Optional[float]:
+    if not _detect_cgroup_v2():
+        return None
+    usage = _read_cgroup_cpu_usage()
+    if usage is None:
+        return None
+    now = time.monotonic()
+    global _last_cgroup_usage, _last_cgroup_time
+    prev_usage = _last_cgroup_usage
+    prev_time = _last_cgroup_time
+    _last_cgroup_usage = usage
+    _last_cgroup_time = now
+    if prev_usage is None or prev_time is None:
+        return None
+    delta_usage = usage - prev_usage
+    delta_time = now - prev_time
+    if delta_time <= 0 or delta_usage < 0:
+        return None
+    cpu_ratio = (delta_usage / 1_000_000) / delta_time
+    limit_cpus = _read_cgroup_cpu_limit()
+    if limit_cpus and limit_cpus > 0:
+        percent = (cpu_ratio / limit_cpus) * 100.0
+    else:
+        cpu_count = psutil.cpu_count(logical=True) or 1
+        percent = (cpu_ratio / cpu_count) * 100.0
+    return max(0.0, min(percent, 100.0))
+
+
+def _run_probe_command(cmd: list[str]) -> str | None:
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=3)
+    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+    return result.stdout.strip()
+
+
+def _parse_pveversion(output: str) -> str | None:
+    first_token = output.split(None, 1)[0] if output else ""
+    if not first_token:
+        return None
+    if "/" in first_token:
+        return first_token.split("/", 1)[1]
+    return first_token
+
+
+def _parse_dpkg_version(output: str) -> str | None:
+    for line in output.splitlines():
+        if line.lower().startswith("version:"):
+            return line.split(":", 1)[1].strip()
+    return None
+
+
+def _get_proxmox_version() -> str | None:
+    release_file = Path("/etc/proxmox-release")
+    if release_file.exists():
+        try:
+            return release_file.read_text().strip()
+        except Exception:
+            pass
+    value = _run_probe_command(["pveversion"])
+    parsed = _parse_pveversion(value or "")
+    if parsed:
+        return parsed
+    for pkg in ("pve-manager", "proxmox-ve"):
+        pkg_output = _run_probe_command(["dpkg", "-s", pkg])
+        parsed = _parse_dpkg_version(pkg_output or "")
+        if parsed:
+            return parsed
+    return None
+
+
+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}
+    if Path("/etc/proxmox-release").exists() or Path("/etc/pve").exists():
+        info["is_proxmox_node"] = True
+    version = _get_proxmox_version()
+    if version:
+        info["version"] = version
+    info["infra"] = get_infra_snapshot()
+    return info
+
 
 def _get_os_info() -> Dict[str, Any]:
     """Get operating system information with robust error handling."""
@@ -98,15 +399,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 +423,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

@@ -162,53 +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
-        
-        # 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=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,
-            original_content_hash=original_hash,
-            modified_content_hash=modified_hash,
-            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,

portacode/connection/handlers/test_proxmox_infra.py

@@ -0,0 +1,13 @@
+from unittest import TestCase
+
+from portacode.connection.handlers.proxmox_infra import _build_bootstrap_steps
+
+
+class ProxmoxInfraHandlerTests(TestCase):
+    def test_build_bootstrap_steps_includes_portacode_connect_by_default(self):
+        steps = _build_bootstrap_steps("svcuser", "pass", "", include_portacode_connect=True)
+        self.assertTrue(any(step.get("name") == "portacode_connect" for step in steps))
+
+    def test_build_bootstrap_steps_skips_portacode_connect_when_requested(self):
+        steps = _build_bootstrap_steps("svcuser", "pass", "", include_portacode_connect=False)
+        self.assertFalse(any(step.get("name") == "portacode_connect" for step in steps))

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/terminal.py

@@ -21,6 +21,8 @@ import time
 from dataclasses import asdict
 from typing import Any, Dict, Optional, List
 
+from websockets.exceptions import ConnectionClosedError
+
 from .multiplex import Multiplexer, Channel
 from .handlers import (
     CommandRegistry,
@@ -33,8 +35,11 @@ from .handlers import (
     DirectoryListHandler,
     FileInfoHandler,
     FileDeleteHandler,
+    FileSearchHandler,
     FileRenameHandler,
     ContentRequestHandler,
+    FileApplyDiffHandler,
+    FilePreviewDiffHandler,
     ProjectStateFolderExpandHandler,
     ProjectStateFolderCollapseHandler,
     ProjectStateFileOpenHandler,
@@ -46,6 +51,14 @@ from .handlers import (
     ProjectStateGitUnstageHandler,
     ProjectStateGitRevertHandler,
     ProjectStateGitCommitHandler,
+    UpdatePortacodeHandler,
+    ConfigureProxmoxInfraHandler,
+    CreateProxmoxContainerHandler,
+    RevertProxmoxInfraHandler,
+    StartPortacodeServiceHandler,
+    StartProxmoxContainerHandler,
+    StopProxmoxContainerHandler,
+    RemoveProxmoxContainerHandler,
 )
 from .handlers.project_aware_file_handlers import (
     ProjectAwareFileWriteHandler,
@@ -108,7 +121,7 @@ class ClientSessionManager:
         self._write_debug_file()
         return newly_added_sessions
     
-    def cleanup_client_session_explicitly(self, client_session_id: str):
+    async def cleanup_client_session_explicitly(self, client_session_id: str):
         """Explicitly clean up resources for a client session when notified by server."""
         logger.info("Explicitly cleaning up resources for client session: %s", client_session_id)
         
@@ -124,7 +137,7 @@ class ClientSessionManager:
                 if control_channel:
                     project_manager = _get_or_create_project_state_manager(context, control_channel)
                     logger.info("Cleaning up project state for client session: %s", client_session_id)
-                    project_manager.cleanup_projects_by_client_session(client_session_id)
+                    await project_manager.cleanup_projects_by_client_session(client_session_id)
                 else:
                     logger.warning("No control channel available for project state cleanup")
             else:
@@ -173,7 +186,7 @@ class ClientSessionManager:
             for session_id in existing_project_states:
                 if session_id not in current_project_sessions:
                     logger.info(f"Cleaning up project state for session {session_id} (no longer a project session)")
-                    project_manager.cleanup_project(session_id)
+                    await project_manager.cleanup_project(session_id)
             
             # Initialize project states for new project sessions
             for session_name in newly_added_sessions:
@@ -185,6 +198,9 @@ class ClientSessionManager:
                 project_folder_path = session.get('project_folder_path')
                 
                 if project_id is not None and project_folder_path:
+                    if session_name in project_manager.projects:
+                        logger.info("Project state already exists for session %s, skipping re-init", session_name)
+                        continue
                     logger.info(f"Initializing project state for new project session {session_name}: {project_folder_path}")
                     
                     try:
@@ -197,7 +213,6 @@ class ClientSessionManager:
                         
                     except Exception as e:
                         logger.error(f"Failed to initialize project state for {session_name}: {e}")
-                
         except Exception as e:
             logger.error("Error managing project states for session changes: %s", e)
     
@@ -216,7 +231,7 @@ class ClientSessionManager:
                     control_channel = getattr(self._terminal_manager, '_control_channel', None)
                     if control_channel:
                         project_manager = _get_or_create_project_state_manager(context, control_channel)
-                        project_manager.cleanup_orphaned_project_states(current_sessions)
+                        await project_manager.cleanup_orphaned_project_states(current_sessions)
                     else:
                         logger.warning("No control channel available for orphaned project state cleanup")
                 else:
@@ -403,6 +418,7 @@ class TerminalManager:
             "mux": mux,
             "use_content_caching": True,  # Enable content caching optimization
             "debug": self.debug,
+            "event_loop": asyncio.get_running_loop(),
         }
         
         # Initialize command registry
@@ -419,6 +435,14 @@ class TerminalManager:
                 pass
         self._ctl_task = asyncio.create_task(self._control_loop())
         
+        # Start periodic system info sender
+        if getattr(self, "_system_info_task", None):
+            try:
+                self._system_info_task.cancel()
+            except Exception:
+                pass
+        self._system_info_task = asyncio.create_task(self._periodic_system_info())
+        
         # For initial connections, request client sessions after control loop starts
         if is_initial:
             asyncio.create_task(self._initial_connection_setup())
@@ -439,7 +463,10 @@ class TerminalManager:
         self._command_registry.register(ProjectAwareFileCreateHandler)  # Use project-aware version
         self._command_registry.register(ProjectAwareFolderCreateHandler)  # Use project-aware version
         self._command_registry.register(FileRenameHandler)
+        self._command_registry.register(FileSearchHandler)
         self._command_registry.register(ContentRequestHandler)
+        self._command_registry.register(FileApplyDiffHandler)
+        self._command_registry.register(FilePreviewDiffHandler)
         # Project state handlers
         self._command_registry.register(ProjectStateFolderExpandHandler)
         self._command_registry.register(ProjectStateFolderCollapseHandler)
@@ -452,6 +479,15 @@ class TerminalManager:
         self._command_registry.register(ProjectStateGitUnstageHandler)
         self._command_registry.register(ProjectStateGitRevertHandler)
         self._command_registry.register(ProjectStateGitCommitHandler)
+        # System management handlers
+        self._command_registry.register(ConfigureProxmoxInfraHandler)
+        self._command_registry.register(CreateProxmoxContainerHandler)
+        self._command_registry.register(StartPortacodeServiceHandler)
+        self._command_registry.register(StartProxmoxContainerHandler)
+        self._command_registry.register(StopProxmoxContainerHandler)
+        self._command_registry.register(RemoveProxmoxContainerHandler)
+        self._command_registry.register(RevertProxmoxInfraHandler)
+        self._command_registry.register(UpdatePortacodeHandler)
 
     # ---------------------------------------------------------------------
     # Control loop – receives commands from gateway
@@ -516,6 +552,20 @@ class TerminalManager:
                 # Continue processing other messages
                 continue
 
+    async def _periodic_system_info(self) -> None:
+        """Send system_info event every 10 seconds when clients are connected."""
+        while True:
+            try:
+                await asyncio.sleep(10)
+                if self._client_session_manager.has_interested_clients():
+                    from .handlers.system_handlers import SystemInfoHandler
+                    handler = SystemInfoHandler(self._control_channel, self._context)
+                    system_info = handler.execute({})
+                    await self._send_session_aware(system_info)
+            except Exception as exc:
+                logger.exception("Error in periodic system info: %s", exc)
+                continue
+
     async def _send_initial_data_to_clients(self, newly_added_sessions: List[str] = None):
         """Send initial system info and terminal list to connected clients.
         
@@ -767,11 +817,15 @@ class TerminalManager:
             terminal_id = payload.get("channel", "unknown")
             logger.info("terminal_manager: Dispatching %s event (terminal_id=%s, data_size=%d bytes) to %d client sessions", 
                        event_type, terminal_id, data_size, len(target_sessions))
-        else:
-            logger.info("terminal_manager: Dispatching %s event to %d client sessions", 
-                       event_type, len(target_sessions))
+        # else:
+        #     logger.info("terminal_manager: Dispatching %s event to %d client sessions", 
+        #                event_type, len(target_sessions))
         
-        await self._control_channel.send(enhanced_payload)
+        try:
+            await self._control_channel.send(enhanced_payload)
+        except ConnectionClosedError as exc:
+            logger.warning("terminal_manager: Connection closed (%s); skipping %s event", exc, event_type)
+            return
 
     async def _send_terminal_list(self) -> None:
         """Send terminal list for reconnection reconciliation."""
@@ -828,4 +882,4 @@ class TerminalManager:
             await self._request_client_sessions()
             logger.info("Client session request sent after reconnection")
         except Exception as exc:
-            logger.error("Failed to handle reconnection: %s", exc) 
+            logger.error("Failed to handle reconnection: %s", exc)