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

portacode/connection/handlers/__init__.py

@@ -20,7 +20,28 @@ from .file_handlers import (
     DirectoryListHandler,
     FileInfoHandler,
     FileDeleteHandler,
+    FileCreateHandler,
+    FolderCreateHandler,
+    FileRenameHandler,
+    FileSearchHandler,
+    ContentRequestHandler,
 )
+from .diff_handlers import FileApplyDiffHandler, FilePreviewDiffHandler
+from .project_state_handlers import (
+    ProjectStateFolderExpandHandler,
+    ProjectStateFolderCollapseHandler,
+    ProjectStateFileOpenHandler,
+    ProjectStateTabCloseHandler,
+    ProjectStateSetActiveTabHandler,
+    ProjectStateDiffOpenHandler,
+    ProjectStateDiffContentHandler,
+    ProjectStateGitStageHandler,
+    ProjectStateGitUnstageHandler,
+    ProjectStateGitRevertHandler,
+    ProjectStateGitCommitHandler,
+)
+from .update_handler import UpdatePortacodeHandler
+from .proxmox_infra import ConfigureProxmoxInfraHandler
 
 __all__ = [
     "BaseHandler",
@@ -32,10 +53,31 @@ __all__ = [
     "TerminalStopHandler",
     "TerminalListHandler",
     "SystemInfoHandler",
+    "ConfigureProxmoxInfraHandler",
     # File operation handlers (optional - register as needed)
     "FileReadHandler",
     "FileWriteHandler", 
     "DirectoryListHandler",
     "FileInfoHandler",
     "FileDeleteHandler",
-] 
+    "FileCreateHandler",
+    "FolderCreateHandler",
+    "FileRenameHandler",
+    "FileSearchHandler",
+    "ContentRequestHandler",
+    "FileApplyDiffHandler",
+    "FilePreviewDiffHandler",
+    # Project state handlers
+    "ProjectStateFolderExpandHandler",
+    "ProjectStateFolderCollapseHandler",
+    "ProjectStateFileOpenHandler",
+    "ProjectStateTabCloseHandler",
+    "ProjectStateSetActiveTabHandler",
+    "ProjectStateDiffOpenHandler",
+    "ProjectStateDiffContentHandler",
+    "ProjectStateGitStageHandler",
+    "ProjectStateGitUnstageHandler",
+    "ProjectStateGitRevertHandler",
+    "ProjectStateGitCommitHandler",
+    "UpdatePortacodeHandler",
+] 

portacode/connection/handlers/base.py

@@ -4,6 +4,7 @@ import asyncio
 import logging
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional, TYPE_CHECKING
+from portacode.utils.ntp_clock import ntp_clock
 
 if TYPE_CHECKING:
     from ..multiplex import Channel
@@ -40,28 +41,64 @@ class BaseHandler(ABC):
         """
         pass
     
-    async def send_response(self, payload: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
-        """Send a response back to the gateway.
-        
+    async def send_response(self, payload: Dict[str, Any], reply_channel: Optional[str] = None, project_id: str = None) -> None:
+        """Send a response back to the gateway with client session awareness.
+
         Args:
             payload: Response payload
-            reply_channel: Optional reply channel
+            reply_channel: Optional reply channel for backward compatibility
+            project_id: Optional project filter for targeting specific sessions
         """
-        if reply_channel:
-            payload["reply_channel"] = reply_channel
-        await self.control_channel.send(payload)
+        # Add device_send timestamp if trace present
+        if "trace" in payload and "request_id" in payload:
+            device_send_time = ntp_clock.now_ms()
+            if device_send_time is not None:
+                payload["trace"]["device_send"] = device_send_time
+                # Update ping to show total time from client_send
+                if "client_send" in payload["trace"]:
+                    payload["trace"]["ping"] = device_send_time - payload["trace"]["client_send"]
+                logger.info(f"📤 Device sending traced response: {payload['request_id']}")
+
+        # 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("handler: No target sessions found, skipping response send")
+                return
+
+            # Add session targeting information
+            enhanced_payload = dict(payload)
+            enhanced_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:
+                enhanced_payload["reply_channel"] = reply_channel
+
+            logger.debug("handler: Sending response to %d client sessions: %s",
+                        len(target_sessions), target_sessions)
+
+            await self.control_channel.send(enhanced_payload)
+        else:
+            # Fallback to original behavior if no client session manager or no clients
+            if reply_channel:
+                payload["reply_channel"] = reply_channel
+            await self.control_channel.send(payload)
     
-    async def send_error(self, message: str, reply_channel: Optional[str] = None) -> None:
-        """Send an error response.
+    async def send_error(self, message: str, reply_channel: Optional[str] = None, project_id: str = None) -> None:
+        """Send an error response with client session awareness.
         
         Args:
             message: Error message
-            reply_channel: Optional reply channel
+            reply_channel: Optional reply channel for backward compatibility
+            project_id: Optional project filter for targeting specific sessions
         """
         payload = {"event": "error", "message": message}
-        if reply_channel:
-            payload["reply_channel"] = reply_channel
-        await self.control_channel.send(payload)
+        await self.send_response(payload, reply_channel, project_id)
 
 
 class AsyncHandler(BaseHandler):
@@ -81,12 +118,52 @@ class AsyncHandler(BaseHandler):
     
     async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
         """Handle the command by executing it and sending the response."""
+        logger.info("handler: Processing command %s with reply_channel=%s",
+                   self.command_name, reply_channel)
+
+        # Add handler_dispatch timestamp if trace present
+        if "trace" in message and "request_id" in message:
+            handler_dispatch_time = ntp_clock.now_ms()
+            if handler_dispatch_time is not None:
+                message["trace"]["handler_dispatch"] = handler_dispatch_time
+                # Update ping to show total time from client_send
+                if "client_send" in message["trace"]:
+                    message["trace"]["ping"] = handler_dispatch_time - message["trace"]["client_send"]
+                logger.info(f"🔧 Handler dispatching: {message['request_id']} ({self.command_name})")
+
         try:
             response = await self.execute(message)
-            await self.send_response(response, reply_channel)
+            logger.info("handler: Command %s executed successfully", self.command_name)
+
+            # Handle cases where execute() sends responses directly and returns None
+            if response is not None:
+                # 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"]
+
+                # Pass through trace from request to response (add to existing trace, don't create new one)
+                if "trace" in message and "request_id" in message:
+                    response["trace"] = dict(message["trace"])
+                    handler_complete_time = ntp_clock.now_ms()
+                    if handler_complete_time is not None:
+                        response["trace"]["handler_complete"] = handler_complete_time
+                        # Update ping to show total time from client_send
+                        if "client_send" in response["trace"]:
+                            response["trace"]["ping"] = handler_complete_time - response["trace"]["client_send"]
+                        logger.info(f"✅ Handler completed: {message['request_id']} ({self.command_name})")
+
+                # Extract project_id from response for session targeting
+                project_id = response.get("project_id")
+                logger.info("handler: %s response project_id=%s, response=%s",
+                           self.command_name, project_id, response)
+                await self.send_response(response, reply_channel, project_id)
+            else:
+                logger.info("handler: %s handled response transmission directly", self.command_name)
         except Exception as exc:
-            logger.exception("Error in async handler %s: %s", self.command_name, exc)
-            await self.send_error(str(exc), reply_channel)
+            logger.exception("handler: Error in async handler %s: %s", self.command_name, exc)
+            # Extract project_id from original message for error targeting
+            project_id = message.get("project_id")
+            await self.send_error(str(exc), reply_channel, project_id)
 
 
 class SyncHandler(BaseHandler):
@@ -106,10 +183,37 @@ class SyncHandler(BaseHandler):
     
     async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
         """Handle the command by executing it in an executor and sending the response."""
+        # Add handler_dispatch timestamp if trace present
+        if "trace" in message and "request_id" in message:
+            handler_dispatch_time = ntp_clock.now_ms()
+            if handler_dispatch_time is not None:
+                message["trace"]["handler_dispatch"] = handler_dispatch_time
+                # Update ping to show total time from client_send
+                if "client_send" in message["trace"]:
+                    message["trace"]["ping"] = handler_dispatch_time - message["trace"]["client_send"]
+                logger.info(f"🔧 Handler dispatching: {message['request_id']} ({self.command_name})")
+
         try:
             loop = asyncio.get_running_loop()
             response = await loop.run_in_executor(None, self.execute, message)
-            await self.send_response(response, reply_channel)
+
+            # 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"]
+
+            # Pass through trace from request to response (add to existing trace, don't create new one)
+            if "trace" in message and "request_id" in message:
+                response["trace"] = dict(message["trace"])
+                handler_complete_time = ntp_clock.now_ms()
+                if handler_complete_time is not None:
+                    response["trace"]["handler_complete"] = handler_complete_time
+                    logger.info(f"✅ Handler completed: {message['request_id']} ({self.command_name})")
+
+            # Extract project_id from response for session targeting
+            project_id = response.get("project_id")
+            await self.send_response(response, reply_channel, project_id)
         except Exception as exc:
             logger.exception("Error in sync handler %s: %s", self.command_name, exc)
-            await self.send_error(str(exc), reply_channel) 
+            # Extract project_id from original message for error targeting
+            project_id = message.get("project_id")
+            await self.send_error(str(exc), reply_channel, project_id) 

portacode/connection/handlers/chunked_content.py

@@ -0,0 +1,244 @@
+"""
+Chunked content transfer utilities for handling large content over WebSocket.
+
+This module provides functionality to split large content into chunks for reliable
+transmission over WebSocket connections, and to reassemble chunks on the client side.
+"""
+
+import hashlib
+import uuid
+from typing import Dict, Any, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Maximum size for content before chunking (200KB)
+MAX_CONTENT_SIZE = 200 * 1024  # 200KB
+
+# Maximum chunk size (64KB per chunk for reliable WebSocket transmission)
+CHUNK_SIZE = 64 * 1024  # 64KB
+
+
+def should_chunk_content(content: str) -> bool:
+    """Determine if content should be chunked based on size."""
+    if content is None:
+        return False
+    
+    content_bytes = content.encode('utf-8')
+    return len(content_bytes) > MAX_CONTENT_SIZE
+
+
+def calculate_content_hash(content: str) -> str:
+    """Calculate SHA-256 hash of content for verification."""
+    if content is None:
+        return ""
+    
+    content_bytes = content.encode('utf-8')
+    return hashlib.sha256(content_bytes).hexdigest()
+
+
+def split_content_into_chunks(content: str, transfer_id: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Split content into chunks for transmission.
+    
+    Args:
+        content: The content to split
+        transfer_id: Optional transfer ID, will generate one if not provided
+        
+    Returns:
+        List of chunk dictionaries ready for transmission
+    """
+    if content is None:
+        return []
+    
+    if transfer_id is None:
+        transfer_id = str(uuid.uuid4())
+    
+    content_bytes = content.encode('utf-8')
+    total_size = len(content_bytes)
+    content_hash = hashlib.sha256(content_bytes).hexdigest()
+    
+    chunks = []
+    chunk_index = 0
+    offset = 0
+    
+    while offset < len(content_bytes):
+        chunk_data = content_bytes[offset:offset + CHUNK_SIZE]
+        chunk_content = chunk_data.decode('utf-8')
+        chunk_hash = hashlib.sha256(chunk_data).hexdigest()
+        
+        chunks.append({
+            "transfer_id": transfer_id,
+            "chunk_index": chunk_index,
+            "chunk_count": (total_size + CHUNK_SIZE - 1) // CHUNK_SIZE,  # Ceiling division
+            "chunk_size": len(chunk_data),
+            "total_size": total_size,
+            "content_hash": content_hash,
+            "chunk_hash": chunk_hash,
+            "chunk_content": chunk_content,
+            "is_final_chunk": offset + CHUNK_SIZE >= len(content_bytes)
+        })
+        
+        chunk_index += 1
+        offset += CHUNK_SIZE
+    
+    logger.info(f"Split content into {len(chunks)} chunks (total size: {total_size} bytes, transfer_id: {transfer_id})")
+    return chunks
+
+
+def create_chunked_response(base_response: Dict[str, Any], content_field: str, content: str) -> List[Dict[str, Any]]:
+    """
+    Create chunked response messages from a base response and content.
+    
+    Args:
+        base_response: The base response dictionary
+        content_field: The field name where content should be placed
+        content: The content to chunk
+        
+    Returns:
+        List of response dictionaries with chunked content
+    """
+    if not should_chunk_content(content):
+        # Content is small enough, return as single response
+        response = base_response.copy()
+        response[content_field] = content
+        response["chunked"] = False
+        return [response]
+    
+    # Content needs chunking
+    transfer_id = str(uuid.uuid4())
+    chunks = split_content_into_chunks(content, transfer_id)
+    responses = []
+    
+    for chunk in chunks:
+        response = base_response.copy()
+        response["chunked"] = True
+        response["transfer_id"] = chunk["transfer_id"]
+        response["chunk_index"] = chunk["chunk_index"]
+        response["chunk_count"] = chunk["chunk_count"]
+        response["chunk_size"] = chunk["chunk_size"]
+        response["total_size"] = chunk["total_size"]
+        response["content_hash"] = chunk["content_hash"]
+        response["chunk_hash"] = chunk["chunk_hash"]
+        response["is_final_chunk"] = chunk["is_final_chunk"]
+        response[content_field] = chunk["chunk_content"]
+        
+        responses.append(response)
+    
+    logger.info(f"Created chunked response with {len(responses)} chunks for transfer_id: {transfer_id}")
+    return responses
+
+
+class ChunkAssembler:
+    """
+    Helper class to assemble chunked content on the receiving side.
+    """
+    
+    def __init__(self):
+        self.transfers: Dict[str, Dict[str, Any]] = {}
+    
+    def add_chunk(self, chunk_data: Dict[str, Any], content_field: str) -> Optional[str]:
+        """
+        Add a chunk to the assembler.
+        
+        Args:
+            chunk_data: The chunk data dictionary
+            content_field: The field name containing the chunk content
+            
+        Returns:
+            Complete content if all chunks received, None if more chunks needed
+            
+        Raises:
+            ValueError: If chunk data is invalid or verification fails
+        """
+        transfer_id = chunk_data.get("transfer_id")
+        chunk_index = chunk_data.get("chunk_index")
+        chunk_count = chunk_data.get("chunk_count")
+        chunk_size = chunk_data.get("chunk_size")
+        total_size = chunk_data.get("total_size")
+        content_hash = chunk_data.get("content_hash")
+        chunk_hash = chunk_data.get("chunk_hash")
+        chunk_content = chunk_data.get(content_field)
+        is_final_chunk = chunk_data.get("is_final_chunk")
+        
+        if not all([transfer_id, chunk_index is not None, chunk_count, chunk_size, 
+                   total_size, content_hash, chunk_hash, chunk_content is not None]):
+            raise ValueError("Missing required chunk fields")
+        
+        # Verify chunk content hash
+        chunk_bytes = chunk_content.encode('utf-8')
+        if len(chunk_bytes) != chunk_size:
+            raise ValueError(f"Chunk size mismatch: expected {chunk_size}, got {len(chunk_bytes)}")
+        
+        calculated_chunk_hash = hashlib.sha256(chunk_bytes).hexdigest()
+        if calculated_chunk_hash != chunk_hash:
+            raise ValueError(f"Chunk hash mismatch: expected {chunk_hash}, got {calculated_chunk_hash}")
+        
+        # Initialize transfer if not exists
+        if transfer_id not in self.transfers:
+            self.transfers[transfer_id] = {
+                "chunk_count": chunk_count,
+                "total_size": total_size,
+                "content_hash": content_hash,
+                "chunks": {},
+                "received_chunks": 0
+            }
+        
+        transfer = self.transfers[transfer_id]
+        
+        # Verify transfer metadata consistency
+        if (transfer["chunk_count"] != chunk_count or 
+            transfer["total_size"] != total_size or 
+            transfer["content_hash"] != content_hash):
+            raise ValueError("Transfer metadata mismatch")
+        
+        # Store chunk if not already received
+        if chunk_index not in transfer["chunks"]:
+            transfer["chunks"][chunk_index] = chunk_content
+            transfer["received_chunks"] += 1
+            
+            logger.debug(f"Received chunk {chunk_index + 1}/{chunk_count} for transfer {transfer_id}")
+        
+        # Check if all chunks received
+        if transfer["received_chunks"] == chunk_count:
+            # Assemble content
+            assembled_content = ""
+            for i in range(chunk_count):
+                if i not in transfer["chunks"]:
+                    raise ValueError(f"Missing chunk {i} for transfer {transfer_id}")
+                assembled_content += transfer["chunks"][i]
+            
+            # Verify final content hash
+            assembled_bytes = assembled_content.encode('utf-8')
+            if len(assembled_bytes) != total_size:
+                raise ValueError(f"Final content size mismatch: expected {total_size}, got {len(assembled_bytes)}")
+            
+            calculated_hash = hashlib.sha256(assembled_bytes).hexdigest()
+            if calculated_hash != content_hash:
+                raise ValueError(f"Final content hash mismatch: expected {content_hash}, got {calculated_hash}")
+            
+            # Clean up transfer
+            del self.transfers[transfer_id]
+            
+            logger.info(f"Successfully assembled content from {chunk_count} chunks (transfer_id: {transfer_id}, size: {total_size} bytes)")
+            return assembled_content
+        
+        return None  # More chunks needed
+    
+    def cleanup_stale_transfers(self, max_age_seconds: int = 300):
+        """Clean up transfers older than max_age_seconds."""
+        import time
+        current_time = time.time()
+        
+        stale_transfers = []
+        for transfer_id, transfer in self.transfers.items():
+            # Add timestamp if not exists
+            if "start_time" not in transfer:
+                transfer["start_time"] = current_time
+            
+            if current_time - transfer["start_time"] > max_age_seconds:
+                stale_transfers.append(transfer_id)
+        
+        for transfer_id in stale_transfers:
+            logger.warning(f"Cleaning up stale transfer: {transfer_id}")
+            del self.transfers[transfer_id]