portacode 0.3.4.dev0__py3-none-any.whl → 1.4.11.dev0__py3-none-any.whl

portacode/connection/handlers/project_state/models.py

@@ -0,0 +1,108 @@
+"""Data models for project state management.
+
+This module contains all the dataclasses and models used throughout the project
+state management system, including TabInfo, FileItem, GitFileChange, 
+GitDetailedStatus, ProjectState, and MonitoredFolder.
+"""
+
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, List, Optional, Set, Union
+
+
+@dataclass
+class TabInfo:
+    """Represents an editor tab with content and metadata."""
+    tab_id: str  # Unique identifier for the tab
+    tab_type: str  # 'file', 'diff', 'untitled', 'image', 'audio', 'video'
+    title: str  # Display title for the tab
+    file_path: Optional[str] = None  # Path for file-based tabs
+    content: Optional[str] = None  # Text content or base64 for media
+    original_content: Optional[str] = None  # For diff view
+    modified_content: Optional[str] = None  # For diff view
+    
+    # Content hash fields for caching optimization
+    content_hash: Optional[str] = None  # SHA-256 hash of content
+    original_content_hash: Optional[str] = None  # SHA-256 hash of original_content for diffs
+    modified_content_hash: Optional[str] = None  # SHA-256 hash of modified_content for diffs
+    html_diff_hash: Optional[str] = None  # SHA-256 hash of html_diff_versions JSON
+    
+    is_dirty: bool = False  # Has unsaved changes
+    mime_type: Optional[str] = None  # For media files
+    encoding: Optional[str] = None  # Content encoding (base64, utf-8, etc.)
+    metadata: Optional[Dict[str, Any]] = None  # Additional metadata
+
+
+@dataclass
+class MonitoredFolder:
+    """Represents a folder that is being monitored for changes."""
+    folder_path: str
+    is_expanded: bool = False
+
+
+@dataclass
+class FileItem:
+    """Represents a file or directory item with metadata."""
+    name: str
+    path: str
+    is_directory: bool
+    parent_path: str
+    size: Optional[int] = None
+    modified_time: Optional[float] = None
+    is_git_tracked: Optional[bool] = None
+    git_status: Optional[str] = None
+    is_staged: Optional[Union[bool, str]] = None  # True, False, or "mixed"
+    is_hidden: bool = False
+    is_ignored: bool = False
+    children: Optional[List['FileItem']] = None
+    is_expanded: bool = False
+    is_loaded: bool = False
+
+
+@dataclass
+class GitFileChange:
+    """Represents a single file change in git."""
+    file_repo_path: str  # Relative path from repository root
+    file_name: str  # Just the filename (basename)
+    file_abs_path: str  # Absolute path to the file
+    change_type: str  # 'added', 'modified', 'deleted', 'untracked' - follows git's native types
+    content_hash: Optional[str] = None  # SHA256 hash of current file content
+    is_staged: bool = False  # Whether this change is staged
+    diff_details: Optional[Dict[str, Any]] = None  # Per-character diff information using diff-match-patch
+
+
+@dataclass
+class GitDetailedStatus:
+    """Represents detailed git status with file hashes."""
+    head_commit_hash: Optional[str] = None  # Hash of HEAD commit
+    staged_changes: List[GitFileChange] = None  # Changes in the staging area
+    unstaged_changes: List[GitFileChange] = None  # Changes in working directory
+    untracked_files: List[GitFileChange] = None  # Untracked files
+    
+    def __post_init__(self):
+        if self.staged_changes is None:
+            self.staged_changes = []
+        if self.unstaged_changes is None:
+            self.unstaged_changes = []
+        if self.untracked_files is None:
+            self.untracked_files = []
+
+
+@dataclass
+class ProjectState:
+    """Represents the complete state of a project."""
+    client_session_id: str  # The client session ID - one project per client session
+    project_folder_path: str
+    items: List[FileItem]
+    monitored_folders: List[MonitoredFolder] = None
+    is_git_repo: bool = False
+    git_branch: Optional[str] = None
+    git_status_summary: Optional[Dict[str, int]] = None  # Kept for backward compatibility
+    git_detailed_status: Optional[GitDetailedStatus] = None  # New detailed git state
+    open_tabs: Dict[str, 'TabInfo'] = None  # Changed from List to Dict with unique keys
+    active_tab: Optional['TabInfo'] = None
+    
+    def __post_init__(self):
+        if self.open_tabs is None:
+            self.open_tabs = {}
+        if self.monitored_folders is None:
+            self.monitored_folders = []

portacode/connection/handlers/project_state/utils.py

@@ -0,0 +1,50 @@
+"""Utility functions for project state management.
+
+This module contains shared utility functions used across the project state
+management system, including tab key generation and other helper functions.
+"""
+
+import hashlib
+import uuid
+
+
+def generate_tab_key(tab_type: str, file_path: str, **kwargs) -> str:
+    """Generate a unique key for a tab.
+    
+    Args:
+        tab_type: Type of tab ('file', 'diff', 'untitled', etc.)
+        file_path: Path to the file
+        **kwargs: Additional parameters for diff tabs (from_ref, to_ref, from_hash, to_hash)
+    
+    Returns:
+        Unique string key for the tab
+    """
+    if tab_type == 'file':
+        return file_path
+    elif tab_type == 'diff':
+        from_ref = kwargs.get('from_ref', '')
+        to_ref = kwargs.get('to_ref', '')
+        from_hash = kwargs.get('from_hash', '')
+        to_hash = kwargs.get('to_hash', '')
+        return f"diff:{file_path}:{from_ref}:{to_ref}:{from_hash}:{to_hash}"
+    elif tab_type == 'untitled':
+        # For untitled tabs, use the tab_id as the key since they don't have a file path
+        return kwargs.get('tab_id', str(uuid.uuid4()))
+    else:
+        # For other tab types, use file_path if available, otherwise tab_id
+        return file_path if file_path else kwargs.get('tab_id', str(uuid.uuid4()))
+
+
+def generate_content_hash(content: str) -> str:
+    """Generate SHA-256 hash of content for caching.
+    
+    Args:
+        content: The string content to hash
+        
+    Returns:
+        SHA-256 hash prefixed with 'sha256:'
+    """
+    if content is None:
+        return None
+    
+    return "sha256:" + hashlib.sha256(content.encode('utf-8')).hexdigest()

portacode/connection/handlers/project_state_handlers.py

@@ -0,0 +1,45 @@
+"""Project state handlers - modular architecture.
+
+This module serves as a compatibility layer that imports all the project state
+handlers from the new modular structure. This ensures existing code continues
+to work while providing access to the new architecture.
+
+The original monolithic file has been broken down into a modular structure
+located in the project_state/ subdirectory. All functionality, logging, and
+documentation has been preserved while improving maintainability.
+
+For detailed information about the new structure, see:
+project_state/README.md
+"""
+
+# Import everything from the modular structure for backward compatibility
+from .project_state import *
+
+# Ensure all handlers are available at module level for existing imports
+from .project_state.handlers import (
+    ProjectStateFolderExpandHandler,
+    ProjectStateFolderCollapseHandler,
+    ProjectStateFileOpenHandler,
+    ProjectStateTabCloseHandler,
+    ProjectStateSetActiveTabHandler,
+    ProjectStateDiffOpenHandler,
+    ProjectStateDiffContentHandler,
+    ProjectStateGitStageHandler,
+    ProjectStateGitUnstageHandler,
+    ProjectStateGitRevertHandler,
+    ProjectStateGitCommitHandler,
+    handle_client_session_cleanup
+)
+
+from .project_state.manager import (
+    get_or_create_project_state_manager,
+    reset_global_project_state_manager,
+    debug_global_manager_state
+)
+
+from .project_state.utils import generate_tab_key
+
+# Re-export with the old private function names for backward compatibility
+_get_or_create_project_state_manager = get_or_create_project_state_manager
+_reset_global_project_state_manager = reset_global_project_state_manager
+_debug_global_manager_state = debug_global_manager_state

portacode/connection/handlers/proxmox_infra.py

@@ -0,0 +1,307 @@
+"""Proxmox infrastructure configuration handler."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import stat
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Tuple
+
+import platformdirs
+
+from .base import SyncHandler
+
+logger = logging.getLogger(__name__)
+
+CONFIG_DIR = Path(platformdirs.user_config_dir("portacode"))
+CONFIG_PATH = CONFIG_DIR / "proxmox_infra.json"
+
+DEFAULT_HOST = "localhost"
+DEFAULT_NODE_NAME = os.uname().nodename.split(".", 1)[0]
+DEFAULT_BRIDGE = "vmbr1"
+SUBNET_CIDR = "10.10.0.1/24"
+BRIDGE_IP = SUBNET_CIDR.split("/", 1)[0]
+DHCP_START = "10.10.0.100"
+DHCP_END = "10.10.0.200"
+DNS_SERVER = "1.1.1.1"
+IFACES_PATH = Path("/etc/network/interfaces")
+SYSCTL_PATH = Path("/etc/sysctl.d/99-portacode-forward.conf")
+UNIT_DIR = Path("/etc/systemd/system")
+
+
+def _call_subprocess(cmd: List[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    env = os.environ.copy()
+    env.setdefault("DEBIAN_FRONTEND", "noninteractive")
+    return subprocess.run(cmd, env=env, text=True, capture_output=True, **kwargs)
+
+
+def _ensure_proxmoxer() -> Any:
+    try:
+        from proxmoxer import ProxmoxAPI  # noqa: F401
+    except ModuleNotFoundError as exc:
+        python = sys.executable
+        logger.info("Proxmoxer missing; installing via pip")
+        try:
+            _call_subprocess([python, "-m", "pip", "install", "proxmoxer"], check=True)
+        except subprocess.CalledProcessError as pip_exc:
+            msg = pip_exc.stderr or pip_exc.stdout or str(pip_exc)
+            raise RuntimeError(f"Failed to install proxmoxer: {msg}") from pip_exc
+        from proxmoxer import ProxmoxAPI  # noqa: F401
+    from proxmoxer import ProxmoxAPI
+    return ProxmoxAPI
+
+
+def _parse_token(token_identifier: str) -> Tuple[str, str]:
+    identifier = token_identifier.strip()
+    if "!" not in identifier or "@" not in identifier:
+        raise ValueError("Expected API token in the form user@realm!tokenid")
+    user_part, token_name = identifier.split("!", 1)
+    user = user_part.strip()
+    token_name = token_name.strip()
+    if "@" not in user:
+        raise ValueError("API token missing user realm (user@realm)")
+    if not token_name:
+        raise ValueError("Token identifier missing token name")
+    return user, token_name
+
+
+def _save_config(data: Dict[str, Any]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    tmp_path = CONFIG_PATH.with_suffix(".tmp")
+    tmp_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    os.replace(tmp_path, CONFIG_PATH)
+    os.chmod(CONFIG_PATH, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def _load_config() -> Dict[str, Any]:
+    if not CONFIG_PATH.exists():
+        return {}
+    try:
+        return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        logger.warning("Failed to parse Proxmox infra config: %s", exc)
+        return {}
+
+
+def _pick_node(client: Any) -> str:
+    nodes = client.nodes().get()
+    for node in nodes:
+        if node.get("node") == DEFAULT_NODE_NAME:
+            return DEFAULT_NODE_NAME
+    return nodes[0].get("node") if nodes else DEFAULT_NODE_NAME
+
+
+def _list_templates(client: Any, node: str, storages: Iterable[Dict[str, Any]]) -> List[str]:
+    templates: List[str] = []
+    for storage in storages:
+        storage_name = storage.get("storage")
+        if not storage_name:
+            continue
+        try:
+            items = client.nodes(node).storage(storage_name).content.get()
+        except Exception:
+            continue
+        for item in items:
+            if item.get("content") == "vztmpl" and item.get("volid"):
+                templates.append(item["volid"])
+    return templates
+
+
+def _pick_storage(storages: Iterable[Dict[str, Any]]) -> str:
+    candidates = [s for s in storages if "rootdir" in s.get("content", "") and s.get("avail", 0) > 0]
+    if not candidates:
+        candidates = [s for s in storages if "rootdir" in s.get("content", "")]
+    if not candidates:
+        return ""
+    candidates.sort(key=lambda entry: entry.get("avail", 0), reverse=True)
+    return candidates[0].get("storage", "")
+
+
+def _write_bridge_config(bridge: str) -> None:
+    begin = f"# Portacode INFRA BEGIN {bridge}"
+    end = f"# Portacode INFRA END {bridge}"
+    current = IFACES_PATH.read_text(encoding="utf-8") if IFACES_PATH.exists() else ""
+    if begin in current:
+        return
+    block = f"""
+{begin}
+auto {bridge}
+iface {bridge} inet static
+    address {SUBNET_CIDR}
+    bridge-ports none
+    bridge-stp off
+    bridge-fd 0
+{end}
+
+"""
+    mode = "a" if IFACES_PATH.exists() else "w"
+    with open(IFACES_PATH, mode, encoding="utf-8") as fh:
+        if current and not current.endswith("\n"):
+            fh.write("\n")
+        fh.write(block)
+
+
+def _ensure_sysctl() -> None:
+    SYSCTL_PATH.write_text("net.ipv4.ip_forward=1\n", encoding="utf-8")
+    _call_subprocess(["/sbin/sysctl", "-w", "net.ipv4.ip_forward=1"], check=True)
+
+
+def _write_units(bridge: str) -> None:
+    nat_name = f"portacode-{bridge}-nat.service"
+    dns_name = f"portacode-{bridge}-dnsmasq.service"
+    nat = UNIT_DIR / nat_name
+    dns = UNIT_DIR / dns_name
+    nat.write_text(f"""[Unit]
+Description=Portacode NAT for {bridge}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/sbin/iptables -t nat -A POSTROUTING -s {BRIDGE_IP}/24 -o vmbr0 -j MASQUERADE
+ExecStart=/usr/sbin/iptables -A FORWARD -i {bridge} -o vmbr0 -j ACCEPT
+ExecStart=/usr/sbin/iptables -A FORWARD -i vmbr0 -o {bridge} -m state --state RELATED,ESTABLISHED -j ACCEPT
+ExecStop=/usr/sbin/iptables -t nat -D POSTROUTING -s {BRIDGE_IP}/24 -o vmbr0 -j MASQUERADE
+ExecStop=/usr/sbin/iptables -D FORWARD -i {bridge} -o vmbr0 -j ACCEPT
+ExecStop=/usr/sbin/iptables -D FORWARD -i vmbr0 -o {bridge} -m state --state RELATED,ESTABLISHED -j ACCEPT
+
+[Install]
+WantedBy=multi-user.target
+""", encoding="utf-8")
+    dns.write_text(f"""[Unit]
+Description=Portacode dnsmasq for {bridge}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=/usr/sbin/dnsmasq --keep-in-foreground --interface={bridge} --bind-interfaces --listen-address={BRIDGE_IP} \
+  --port=0 --dhcp-range={DHCP_START},{DHCP_END},12h \
+  --dhcp-option=option:router,{BRIDGE_IP} \
+  --dhcp-option=option:dns-server,{DNS_SERVER} \
+  --conf-file=/dev/null --pid-file=/run/portacode_dnsmasq.pid --dhcp-leasefile=/var/lib/misc/portacode_dnsmasq.leases
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+""", encoding="utf-8")
+
+
+def _ensure_bridge(bridge: str = DEFAULT_BRIDGE) -> Dict[str, Any]:
+    if os.geteuid() != 0:
+        raise PermissionError("Bridge setup requires root privileges")
+    if not shutil.which("dnsmasq"):
+        apt = shutil.which("apt-get")
+        if not apt:
+            raise RuntimeError("dnsmasq is missing and apt-get unavailable to install it")
+        _call_subprocess([apt, "update"], check=True)
+        _call_subprocess([apt, "install", "-y", "dnsmasq"], check=True)
+    _write_bridge_config(bridge)
+    _ensure_sysctl()
+    _write_units(bridge)
+    _call_subprocess(["/bin/systemctl", "daemon-reload"], check=True)
+    nat_service = f"portacode-{bridge}-nat.service"
+    dns_service = f"portacode-{bridge}-dnsmasq.service"
+    _call_subprocess(["/bin/systemctl", "enable", "--now", nat_service, dns_service], check=True)
+    _call_subprocess(["/sbin/ifup", bridge], check=False)
+    return {"applied": True, "bridge": bridge, "message": f"Bridge {bridge} configured"}
+
+
+def build_snapshot(config: Dict[str, Any]) -> Dict[str, Any]:
+    if not config:
+        return {"configured": False}
+    network = config.get("network", {})
+    return {
+        "configured": True,
+        "host": config.get("host"),
+        "node": config.get("node"),
+        "user": config.get("user"),
+        "token_name": config.get("token_name"),
+        "default_storage": config.get("default_storage"),
+        "templates": config.get("templates") or [],
+        "last_verified": config.get("last_verified"),
+        "network": {
+            "applied": network.get("applied", False),
+            "message": network.get("message"),
+            "bridge": network.get("bridge", DEFAULT_BRIDGE),
+        },
+    }
+
+
+def configure_infrastructure(token_identifier: str, token_value: str, verify_ssl: bool = False) -> Dict[str, Any]:
+    ProxmoxAPI = _ensure_proxmoxer()
+    user, token_name = _parse_token(token_identifier)
+    client = ProxmoxAPI(
+        DEFAULT_HOST,
+        user=user,
+        token_name=token_name,
+        token_value=token_value,
+        verify_ssl=verify_ssl,
+        timeout=30,
+    )
+    node = _pick_node(client)
+    status = client.nodes(node).status.get()
+    storages = client.nodes(node).storage.get()
+    default_storage = _pick_storage(storages)
+    templates = _list_templates(client, node, storages)
+    network: Dict[str, Any] = {}
+    try:
+        network = _ensure_bridge()
+    except PermissionError as exc:
+        network = {"applied": False, "message": str(exc), "bridge": DEFAULT_BRIDGE}
+        logger.warning("Bridge setup skipped: %s", exc)
+    except Exception as exc:  # pragma: no cover - best effort
+        network = {"applied": False, "message": str(exc), "bridge": DEFAULT_BRIDGE}
+        logger.warning("Bridge setup failed: %s", exc)
+    config = {
+        "host": DEFAULT_HOST,
+        "node": node,
+        "user": user,
+        "token_name": token_name,
+        "token_value": token_value,
+        "verify_ssl": verify_ssl,
+        "default_storage": default_storage,
+        "templates": templates,
+        "last_verified": datetime.utcnow().isoformat() + "Z",
+        "network": network,
+        "node_status": status,
+    }
+    _save_config(config)
+    snapshot = build_snapshot(config)
+    snapshot["node_status"] = status
+    return snapshot
+
+
+def get_infra_snapshot() -> Dict[str, Any]:
+    config = _load_config()
+    snapshot = build_snapshot(config)
+    if config.get("node_status"):
+        snapshot["node_status"] = config["node_status"]
+    return snapshot
+
+
+class ConfigureProxmoxInfraHandler(SyncHandler):
+    @property
+    def command_name(self) -> str:
+        return "setup_proxmox_infra"
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        token_identifier = message.get("token_identifier")
+        token_value = message.get("token_value")
+        verify_ssl = bool(message.get("verify_ssl"))
+        if not token_identifier or not token_value:
+            raise ValueError("token_identifier and token_value are required")
+        snapshot = configure_infrastructure(token_identifier, token_value, verify_ssl=verify_ssl)
+        return {
+            "event": "proxmox_infra_configured",
+            "success": True,
+            "message": "Proxmox infrastructure configured",
+            "infra": snapshot,
+        }

portacode/connection/handlers/registry.py

@@ -2,6 +2,7 @@
 
 import logging
 from typing import Dict, Type, Any, Optional, List, TYPE_CHECKING
+from portacode.utils.ntp_clock import ntp_clock
 
 if TYPE_CHECKING:
     from ..multiplex import Channel
@@ -72,32 +73,74 @@ class CommandRegistry:
     
     async def dispatch(self, command_name: str, message: Dict[str, Any], reply_channel: Optional[str] = None) -> bool:
         """Dispatch a command to its handler.
-        
+
         Args:
             command_name: The command name
             message: The command message
             reply_channel: Optional reply channel
-            
+
         Returns:
             True if handler was found and executed, False otherwise
         """
+        logger.info("registry: Dispatching command '%s' with reply_channel=%s", command_name, reply_channel)
+
+        # Add handler_receive timestamp if trace present
+        if "trace" in message and "request_id" in message:
+            handler_receive_time = ntp_clock.now_ms()
+            if handler_receive_time is not None:
+                message["trace"]["handler_receive"] = handler_receive_time
+                # Update ping to show total time from client_send
+                if "client_send" in message["trace"]:
+                    message["trace"]["ping"] = handler_receive_time - message["trace"]["client_send"]
+                logger.info(f"🎯 Handler received traced message: {message['request_id']}")
+
         handler = self.get_handler(command_name)
         if handler is None:
-            logger.warning("No handler found for command: %s", command_name)
+            logger.warning("registry: No handler found for command: %s", command_name)
             return False
-        
+
         try:
             await handler.handle(message, reply_channel)
+            logger.info("registry: Successfully dispatched command '%s'", command_name)
             return True
         except Exception as exc:
-            logger.exception("Error dispatching command %s: %s", command_name, exc)
-            # Send error response
-            error_payload = {"event": "error", "message": str(exc)}
-            if reply_channel:
-                error_payload["reply_channel"] = reply_channel
-            await self.control_channel.send(error_payload)
+            logger.exception("registry: Error dispatching command %s: %s", command_name, exc)
+            # Send session-aware error response
+            await self._send_session_aware_error(str(exc), reply_channel, message.get("project_id"))
             return False
     
+    async def _send_session_aware_error(self, message: str, reply_channel: Optional[str] = None, project_id: str = None) -> None:
+        """Send an error response with client session awareness."""
+        error_payload = {"event": "error", "message": message}
+        
+        # Get client session manager from context
+        client_session_manager = self.context.get("client_session_manager")
+        
+        if client_session_manager and client_session_manager.has_interested_clients():
+            # Get target sessions
+            target_sessions = client_session_manager.get_target_sessions(project_id)
+            if not target_sessions:
+                logger.debug("registry: No target sessions found, skipping error send")
+                return
+            
+            # Add session targeting information
+            error_payload["client_sessions"] = target_sessions
+            
+            # Add backward compatibility reply_channel (first session if not provided)
+            if not reply_channel:
+                reply_channel = client_session_manager.get_reply_channel_for_compatibility()
+            if reply_channel:
+                error_payload["reply_channel"] = reply_channel
+            
+            logger.debug("registry: Sending error to %d client sessions: %s", 
+                        len(target_sessions), target_sessions)
+        else:
+            # Fallback to original behavior
+            if reply_channel:
+                error_payload["reply_channel"] = reply_channel
+        
+        await self.control_channel.send(error_payload)
+
     def update_context(self, context: Dict[str, Any]) -> None:
         """Update the shared context for all handlers.