portacode 1.3.32__py3-none-any.whl → 1.4.11.dev5__py3-none-any.whl

portacode/connection/handlers/system_handlers.py

@@ -1,17 +1,189 @@
 """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
 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 _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 +270,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 +294,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/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,10 @@ from .handlers import (
     ProjectStateGitUnstageHandler,
     ProjectStateGitRevertHandler,
     ProjectStateGitCommitHandler,
+    UpdatePortacodeHandler,
+    ConfigureProxmoxInfraHandler,
+    CreateProxmoxContainerHandler,
+    RevertProxmoxInfraHandler,
 )
 from .handlers.project_aware_file_handlers import (
     ProjectAwareFileWriteHandler,
@@ -108,7 +117,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 +133,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 +182,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 +194,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 +209,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 +227,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:
@@ -419,6 +430,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 +458,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 +474,11 @@ 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(RevertProxmoxInfraHandler)
+        self._command_registry.register(UpdatePortacodeHandler)
 
     # ---------------------------------------------------------------------
     # Control loop – receives commands from gateway
@@ -516,6 +543,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 +808,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 +873,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) 

portacode/keypair.py

@@ -98,4 +98,66 @@ def fingerprint_public_key(pem: bytes) -> str:
     """Return a short fingerprint for display purposes (SHA-256)."""
     digest = hashes.Hash(hashes.SHA256())
     digest.update(pem)
-    return digest.finalize().hex()[:16] 
+    return digest.finalize().hex()[:16]
+
+
+class InMemoryKeyPair:
+    """Keypair kept purely in memory until explicitly persisted."""
+
+    def __init__(self, private_pem: bytes, public_pem: bytes, key_dir: Path):
+        self._private_pem = private_pem
+        self._public_pem = public_pem
+        self._key_dir = key_dir
+        self._is_new = True
+
+    @property
+    def private_key_pem(self) -> bytes:
+        return self._private_pem
+
+    @property
+    def public_key_pem(self) -> bytes:
+        return self._public_pem
+
+    def sign_challenge(self, challenge: str) -> bytes:
+        private_key = serialization.load_pem_private_key(self._private_pem, password=None)
+        return private_key.sign(
+            challenge.encode(),
+            padding.PKCS1v15(),
+            hashes.SHA256(),
+        )
+
+    def public_key_der_b64(self) -> str:
+        pubkey = serialization.load_pem_public_key(self._public_pem)
+        der = pubkey.public_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+        return base64.b64encode(der).decode()
+
+    def persist(self) -> KeyPair:
+        """Write the keypair to disk and return a regular KeyPair."""
+        key_dir = self._key_dir
+        key_dir.mkdir(parents=True, exist_ok=True)
+        priv_path = key_dir / PRIVATE_KEY_FILE
+        pub_path = key_dir / PUBLIC_KEY_FILE
+        priv_path.write_bytes(self._private_pem)
+        pub_path.write_bytes(self._public_pem)
+        keypair = KeyPair(priv_path, pub_path)
+        keypair._is_new = True  # type: ignore[attr-defined]
+        keypair._key_dir = key_dir  # type: ignore[attr-defined]
+        return keypair
+
+
+def generate_in_memory_keypair() -> InMemoryKeyPair:
+    """Generate a new keypair but keep it in memory until pairing succeeds."""
+    private_pem, public_pem = _generate_keypair()
+    key_dir = get_key_dir()
+    return InMemoryKeyPair(private_pem, public_pem, key_dir)
+
+
+def keypair_files_exist() -> bool:
+    """Return True if the persisted keypair already exists on disk."""
+    key_dir = get_key_dir()
+    priv_path = key_dir / PRIVATE_KEY_FILE
+    pub_path = key_dir / PUBLIC_KEY_FILE
+    return priv_path.exists() and pub_path.exists()

portacode/link_capture/__init__.py

@@ -0,0 +1,38 @@
+"""Helpers for the link capture wrapper scripts."""
+
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+try:
+    # Use the stdlib helpers when they are available (Python ≥3.9).
+    from importlib.resources import as_file, files
+except ImportError:  # pragma: no cover
+    # Fall back to the backport for older Python 3.x runtimes (>=3.6).
+    from importlib_resources import as_file, files
+
+_LINK_CAPTURE_TEMP_DIR: Optional[Path] = None
+
+
+def prepare_link_capture_bin() -> Optional[Path]:
+    """Extract the packaged link capture wrappers into a temporary dir and return it."""
+    global _LINK_CAPTURE_TEMP_DIR
+    if _LINK_CAPTURE_TEMP_DIR:
+        return _LINK_CAPTURE_TEMP_DIR
+
+    bin_source = files(__package__) / "bin"
+    if not bin_source.is_dir():
+        return None
+
+    temp_dir = Path(tempfile.mkdtemp(prefix="portacode-link-capture-"))
+    for entry in bin_source.iterdir():
+        if not entry.is_file():
+            continue
+        with as_file(entry) as file_path:
+            dest = temp_dir / entry.name
+            shutil.copyfile(file_path, dest)
+            dest.chmod(dest.stat().st_mode | 0o111)
+
+    _LINK_CAPTURE_TEMP_DIR = temp_dir
+    return _LINK_CAPTURE_TEMP_DIR

portacode/link_capture/bin/elinks

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" elinks "$@"

portacode/link_capture/bin/gio-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" gio-open "$@"

portacode/link_capture/bin/gnome-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" gnome-open "$@"

portacode/link_capture/bin/gvfs-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" gvfs-open "$@"

portacode/link_capture/bin/kde-open

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" kde-open "$@"

portacode/link_capture/bin/kfmclient

@@ -0,0 +1,3 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+exec "$SCRIPT_DIR/link_capture_exec.sh" kfmclient "$@"

portacode/link_capture/bin/link_capture_exec.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+COMMAND_NAME="$1"
+shift
+
+if [ -z "$COMMAND_NAME" ]; then
+  echo "link_capture: missing command name" >&2
+  exit 1
+fi
+
+exec "$SCRIPT_DIR/link_capture_wrapper.py" "$COMMAND_NAME" "$@"