portacode 1.3.27.dev0__tar.gz → 1.3.28__tar.gz

{portacode-1.3.27.dev0 → portacode-1.3.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.3.27.dev0
+Version: 1.3.28
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.3.27.dev0'
-__version_tuple__ = version_tuple = (1, 3, 27, 'dev0')
+__version__ = version = '1.3.28'
+__version_tuple__ = version_tuple = (1, 3, 28)
 
 __commit_id__ = commit_id = None

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode/connection/client.py

@@ -148,6 +148,25 @@ class ConnectionManager:
         while not self._stop_event.is_set():
             try:
                 message = await asyncio.wait_for(self.websocket.recv(), timeout=1.0)
+
+                # Add device_receive timestamp if trace present
+                try:
+                    import json
+                    data = json.loads(message)
+                    payload = data.get("payload", {})
+                    if isinstance(payload, dict) and "trace" in payload and "request_id" in payload:
+                        from portacode.utils.ntp_clock import ntp_clock
+                        device_receive_time = ntp_clock.now_ms()
+                        if device_receive_time is not None:
+                            payload["trace"]["device_receive"] = device_receive_time
+                            if "client_send" in payload["trace"]:
+                                payload["trace"]["ping"] = device_receive_time - payload["trace"]["client_send"]
+                            # Re-serialize with updated trace
+                            message = json.dumps(data)
+                            logger.info(f"📥 Device received traced message: {payload['request_id']}")
+                except:
+                    pass  # Not a traced message, continue normally
+
                 if self.mux:
                     await self.mux.on_raw_message(message)
             except asyncio.TimeoutError:

{portacode-1.3.27.dev0 → portacode-1.3.28}/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
@@ -42,35 +43,45 @@ class BaseHandler(ABC):
     
     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 for backward compatibility
             project_id: Optional project filter for targeting specific sessions
         """
+        # 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", 
+
+            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
@@ -110,6 +121,16 @@ class AsyncHandler(BaseHandler):
         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)
             logger.info("handler: Command %s executed successfully", self.command_name)
@@ -120,6 +141,17 @@ class AsyncHandler(BaseHandler):
                 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",
@@ -151,6 +183,16 @@ 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)
@@ -159,6 +201,14 @@ class SyncHandler(BaseHandler):
             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)

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode/connection/handlers/project_state/git_manager.py

@@ -291,7 +291,242 @@ class GitManager:
         except Exception as e:
             logger.debug("Error getting Git status for %s: %s", file_path, e)
             return {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
-    
+
+    def get_file_status_batch(self, file_paths: List[str]) -> Dict[str, Dict[str, Any]]:
+        """Get Git status for multiple files/directories at once (optimized batch operation).
+
+        Args:
+            file_paths: List of absolute file paths
+
+        Returns:
+            Dict mapping file_path to status dict: {"is_tracked": bool, "status": str, "is_ignored": bool, "is_staged": bool|"mixed"}
+        """
+        if not self.is_git_repo or not self.repo:
+            # Return empty status for all paths
+            return {path: {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+                    for path in file_paths}
+
+        result = {}
+
+        try:
+            # Convert all paths to relative paths
+            rel_paths_map = {}  # abs_path -> rel_path
+            for file_path in file_paths:
+                try:
+                    rel_path = os.path.relpath(file_path, self.repo.working_dir)
+                    rel_paths_map[file_path] = rel_path
+                except Exception as e:
+                    logger.debug("Error converting path %s to relative: %s", file_path, e)
+                    result[file_path] = {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
+            rel_paths = list(rel_paths_map.values())
+
+            # BATCH OPERATION 1: Get all ignored paths at once
+            ignored_paths = set()
+            try:
+                ignored_list = self.repo.ignored(*rel_paths)
+                ignored_paths = set(ignored_list) if ignored_list else set()
+            except Exception as e:
+                logger.debug("Error checking ignored status for batch: %s", e)
+
+            # BATCH OPERATION 2: Get global git data once
+            untracked_files = set(self.repo.untracked_files)
+
+            try:
+                staged_files_output = self.repo.git.diff('--cached', '--name-only')
+                staged_files = set(staged_files_output.splitlines()) if staged_files_output.strip() else set()
+            except Exception:
+                staged_files = set()
+
+            try:
+                unstaged_files_output = self.repo.git.diff('--name-only')
+                unstaged_files = set(unstaged_files_output.splitlines()) if unstaged_files_output.strip() else set()
+            except Exception:
+                unstaged_files = set()
+
+            # BATCH OPERATION 3: Get status for all paths at once
+            status_map = {}  # rel_path -> status_line
+            try:
+                status_output = self.repo.git.status(*rel_paths, porcelain=True)
+                if status_output.strip():
+                    for line in status_output.strip().split('\n'):
+                        if len(line) >= 3:
+                            file_path_from_status = line[3:] if len(line) > 3 else ""
+                            status_map[file_path_from_status] = line
+            except Exception as e:
+                logger.debug("Error getting batch status: %s", e)
+
+            # BATCH OPERATION 4: Get all tracked files
+            try:
+                tracked_files_output = self.repo.git.ls_files()
+                tracked_files = set(tracked_files_output.splitlines()) if tracked_files_output.strip() else set()
+            except Exception:
+                tracked_files = set()
+
+            # Process each file with the batch data
+            for file_path, rel_path in rel_paths_map.items():
+                try:
+                    # Check if ignored
+                    if rel_path in ignored_paths:
+                        result[file_path] = {"is_tracked": False, "status": "ignored", "is_ignored": True, "is_staged": False}
+                        continue
+
+                    # Determine staging status
+                    is_staged = self._get_staging_status_from_batch(
+                        file_path, rel_path, staged_files, unstaged_files
+                    )
+
+                    # Handle directories
+                    if os.path.isdir(file_path):
+                        result[file_path] = self._get_directory_status_from_batch(
+                            file_path, rel_path, untracked_files, status_map, tracked_files, is_staged
+                        )
+                    # Handle files
+                    else:
+                        result[file_path] = self._get_file_status_from_batch(
+                            file_path, rel_path, untracked_files, staged_files, tracked_files, is_staged
+                        )
+
+                except Exception as e:
+                    logger.debug("Error processing status for %s: %s", file_path, e)
+                    result[file_path] = {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
+            # Fill in any missing paths with default status
+            for file_path in file_paths:
+                if file_path not in result:
+                    result[file_path] = {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
+        except Exception as e:
+            logger.error("Error in get_file_status_batch: %s", e)
+            # Return default status for all paths on error
+            for file_path in file_paths:
+                if file_path not in result:
+                    result[file_path] = {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
+        return result
+
+    def _get_staging_status_from_batch(self, file_path: str, rel_path: str,
+                                       staged_files: set, unstaged_files: set) -> Union[bool, str]:
+        """Get staging status using pre-fetched batch data."""
+        try:
+            if os.path.isdir(file_path):
+                # For directories, check files within
+                dir_staged_files = [f for f in staged_files if f.startswith(rel_path + '/') or f == rel_path]
+                dir_unstaged_files = [f for f in unstaged_files if f.startswith(rel_path + '/') or f == rel_path]
+
+                has_staged = len(dir_staged_files) > 0
+                has_unstaged = len(dir_unstaged_files) > 0
+
+                # Check for mixed staging
+                has_mixed_files = any(f in dir_unstaged_files for f in dir_staged_files)
+
+                if has_mixed_files or (has_staged and has_unstaged):
+                    return "mixed"
+                elif has_staged:
+                    return True
+                else:
+                    return False
+            else:
+                # For files
+                has_staged = rel_path in staged_files
+                has_unstaged = rel_path in unstaged_files
+
+                if has_staged and has_unstaged:
+                    return "mixed"
+                elif has_staged:
+                    return True
+                else:
+                    return False
+        except Exception:
+            return False
+
+    def _get_directory_status_from_batch(self, file_path: str, rel_path: str,
+                                         untracked_files: set, status_map: dict,
+                                         tracked_files: set, is_staged: Union[bool, str]) -> Dict[str, Any]:
+        """Get directory status using pre-fetched batch data."""
+        try:
+            rel_path_normalized = rel_path.replace('\\', '/')
+
+            # Check for untracked files in this directory
+            has_untracked = any(
+                f.replace('\\', '/').startswith(rel_path_normalized + '/') or f.replace('\\', '/') == rel_path_normalized
+                for f in untracked_files
+            )
+
+            # Check for modified/deleted files using status map
+            has_modified = False
+            has_deleted = False
+
+            for status_file_path, status_line in status_map.items():
+                if len(status_line) >= 2:
+                    file_normalized = status_file_path.replace('\\', '/')
+                    if file_normalized.startswith(rel_path_normalized + '/') or file_normalized == rel_path_normalized:
+                        index_status = status_line[0] if len(status_line) > 0 else ' '
+                        worktree_status = status_line[1] if len(status_line) > 1 else ' '
+
+                        if index_status in ['M', 'A', 'R', 'C'] or worktree_status in ['M', 'A', 'R', 'C']:
+                            has_modified = True
+                        elif index_status == 'D' or worktree_status == 'D':
+                            has_deleted = True
+
+            # Priority order: untracked > modified/deleted > clean
+            if has_untracked:
+                return {"is_tracked": False, "status": "untracked", "is_ignored": False, "is_staged": is_staged}
+            elif has_deleted:
+                return {"is_tracked": True, "status": "deleted", "is_ignored": False, "is_staged": is_staged}
+            elif has_modified:
+                return {"is_tracked": True, "status": "modified", "is_ignored": False, "is_staged": is_staged}
+
+            # Check if directory has tracked files
+            has_tracked = any(
+                f.replace('\\', '/').startswith(rel_path_normalized + '/') or f.replace('\\', '/') == rel_path_normalized
+                for f in tracked_files
+            )
+
+            status = "clean" if has_tracked else None
+            return {"is_tracked": has_tracked, "status": status, "is_ignored": False, "is_staged": is_staged}
+
+        except Exception as e:
+            logger.debug("Error getting directory status for %s: %s", file_path, e)
+            return {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
+    def _get_file_status_from_batch(self, file_path: str, rel_path: str,
+                                    untracked_files: set, staged_files: set,
+                                    tracked_files: set, is_staged: Union[bool, str]) -> Dict[str, Any]:
+        """Get file status using pre-fetched batch data."""
+        try:
+            # Check if untracked
+            if rel_path in untracked_files:
+                return {"is_tracked": False, "status": "untracked", "is_ignored": False, "is_staged": is_staged}
+
+            # If file is staged, determine original status
+            if is_staged:
+                # Check if file existed in HEAD
+                try:
+                    self.repo.git.show(f"HEAD:{rel_path}")
+                    # File existed in HEAD
+                    return {"is_tracked": True, "status": "modified", "is_ignored": False, "is_staged": is_staged}
+                except Exception:
+                    # File didn't exist in HEAD (new file)
+                    return {"is_tracked": False, "status": "added", "is_ignored": False, "is_staged": is_staged}
+
+            # Check if tracked and dirty
+            try:
+                if self.repo.is_dirty(path=rel_path):
+                    return {"is_tracked": True, "status": "modified", "is_ignored": False, "is_staged": is_staged}
+            except Exception:
+                pass
+
+            # Check if tracked and clean
+            if rel_path in tracked_files:
+                return {"is_tracked": True, "status": "clean", "is_ignored": False, "is_staged": is_staged}
+
+            return {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
+        except Exception as e:
+            logger.debug("Error getting file status for %s: %s", file_path, e)
+            return {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
+
     def get_status_summary(self) -> Dict[str, int]:
         """Get summary of Git status."""
         if not self.is_git_repo or not self.repo:

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode/connection/handlers/project_state/manager.py

@@ -156,16 +156,23 @@ class ProjectStateManager:
         
         git_manager = GitManager(project_folder_path, change_callback=git_change_callback)
         self.git_managers[client_session_id] = git_manager
-        
+
+        # Run git operations in executor to avoid blocking event loop
+        loop = asyncio.get_event_loop()
+        is_git_repo = git_manager.is_git_repo
+        git_branch = await loop.run_in_executor(None, git_manager.get_branch_name)
+        git_status_summary = await loop.run_in_executor(None, git_manager.get_status_summary)
+        git_detailed_status = await loop.run_in_executor(None, git_manager.get_detailed_status)
+
         # Create project state
         project_state = ProjectState(
             client_session_id=client_session_id,
             project_folder_path=project_folder_path,
             items=[],
-            is_git_repo=git_manager.is_git_repo,
-            git_branch=git_manager.get_branch_name(),
-            git_status_summary=git_manager.get_status_summary(),
-            git_detailed_status=git_manager.get_detailed_status()
+            is_git_repo=is_git_repo,
+            git_branch=git_branch,
+            git_status_summary=git_status_summary,
+            git_detailed_status=git_detailed_status
         )
         
         # Initialize monitored folders with project root and its immediate subdirectories
@@ -352,16 +359,60 @@ class ProjectStateManager:
     
     async def _build_flattened_items_structure(self, project_state: ProjectState):
         """Build a flattened items structure including ALL items from ALL monitored folders."""
+        import time
+        func_start = time.time()
+
         all_items = []
-        
+
         # Create sets for quick lookup
         expanded_paths = {mf.folder_path for mf in project_state.monitored_folders if mf.is_expanded}
         monitored_paths = {mf.folder_path for mf in project_state.monitored_folders}
-        
-        # Load items from ALL monitored folders
+
+        # OPTIMIZATION: Collect all file paths first, then batch git operations
+        batch_git_start = time.time()
+        all_file_paths = []
+        folder_to_paths = {}  # monitored_folder_path -> list of child paths
+
+        # First pass: scan all directories to collect file paths
+        for monitored_folder in project_state.monitored_folders:
+            try:
+                child_paths = []
+                with os.scandir(monitored_folder.folder_path) as entries:
+                    for entry in entries:
+                        if entry.name != '.git' or not entry.is_dir():
+                            child_paths.append(entry.path)
+                            all_file_paths.append(entry.path)
+                folder_to_paths[monitored_folder.folder_path] = child_paths
+            except (OSError, PermissionError) as e:
+                logger.error("Error scanning folder %s: %s", monitored_folder.folder_path, e)
+                folder_to_paths[monitored_folder.folder_path] = []
+
+        # BATCH GIT OPERATION: Get status for ALL files at once
+        git_manager = self.git_managers.get(project_state.client_session_id)
+        git_status_map = {}
+        if git_manager and all_file_paths:
+            loop = asyncio.get_event_loop()
+            git_status_map = await loop.run_in_executor(
+                None,
+                git_manager.get_file_status_batch,
+                all_file_paths
+            )
+
+        batch_git_duration = time.time() - batch_git_start
+        logger.info("⏱️ Batch git operations for %d files took %.4f seconds", len(all_file_paths), batch_git_duration)
+
+        # Second pass: load items using pre-fetched git status
+        load_items_start = time.time()
+        loop = asyncio.get_event_loop()
         for monitored_folder in project_state.monitored_folders:
-            # Load direct children of this monitored folder
-            children = await self._load_directory_items_list(monitored_folder.folder_path, monitored_folder.folder_path)
+            # Load direct children of this monitored folder (run in executor to avoid blocking)
+            children = await loop.run_in_executor(
+                None,
+                self._load_directory_items_list_sync,
+                monitored_folder.folder_path,
+                monitored_folder.folder_path,
+                git_status_map  # Pass pre-fetched git status
+            )
             
             # Set correct expansion and loading states for each child
             for child in children:
@@ -374,27 +425,41 @@ class ProjectStateManager:
                     # Files are always loaded
                     child.is_loaded = True
                 all_items.append(child)
-        
+
+        load_items_duration = time.time() - load_items_start
+        logger.info("⏱️ Loading items took %.4f seconds", load_items_duration)
+
         # Remove duplicates (items might be loaded multiple times due to nested monitoring)
-        # Use a dict to deduplicate by path while preserving the last loaded state
+        dedup_start = time.time()
         items_dict = {}
         for item in all_items:
             items_dict[item.path] = item
-        
+
+        dedup_duration = time.time() - dedup_start
+        logger.info("⏱️ Deduplication took %.4f seconds", dedup_duration)
+
         # Convert back to list and sort for consistent ordering
+        sort_start = time.time()
         project_state.items = list(items_dict.values())
         project_state.items.sort(key=lambda x: (x.parent_path, not x.is_directory, x.name.lower()))
+        sort_duration = time.time() - sort_start
+        logger.info("⏱️ Sorting took %.4f seconds", sort_duration)
+
+        func_duration = time.time() - func_start
+        logger.info("⏱️ _build_flattened_items_structure TOTAL: %.4f seconds (batch_git=%.4f, load=%.4f)",
+                   func_duration, batch_git_duration, load_items_duration)
     
-    async def _load_directory_items_list(self, directory_path: str, parent_path: str) -> List[FileItem]:
-        """Load directory items and return as a list with parent_path."""
-        git_manager = None
-        for manager in self.git_managers.values():
-            if directory_path.startswith(manager.project_path):
-                git_manager = manager
-                break
-        
+    def _load_directory_items_list_sync(self, directory_path: str, parent_path: str,
+                                       git_status_map: Dict[str, Dict[str, Any]] = None) -> List[FileItem]:
+        """Load directory items and return as a list with parent_path (synchronous version for executor).
+
+        Args:
+            directory_path: Directory to scan
+            parent_path: Parent path for items
+            git_status_map: Optional pre-fetched git status map (path -> status_dict)
+        """
         items = []
-        
+
         try:
             with os.scandir(directory_path) as entries:
                 for entry in entries:
@@ -402,15 +467,15 @@ class ProjectStateManager:
                         # Skip .git folders and their contents
                         if entry.name == '.git' and entry.is_dir():
                             continue
-                            
+
                         stat_info = entry.stat()
                         is_hidden = entry.name.startswith('.')
-                        
-                        # Get Git status if available
+
+                        # Get Git status from pre-fetched map or use default
                         git_info = {"is_tracked": False, "status": None, "is_ignored": False, "is_staged": False}
-                        if git_manager:
-                            git_info = git_manager.get_file_status(entry.path)
-                        
+                        if git_status_map and entry.path in git_status_map:
+                            git_info = git_status_map[entry.path]
+
                         file_item = FileItem(
                             name=entry.name,
                             path=entry.path,
@@ -426,19 +491,19 @@ class ProjectStateManager:
                             is_expanded=False,
                             is_loaded=True  # Will be set correctly in _build_flattened_items_structure
                         )
-                        
+
                         items.append(file_item)
-                        
+
                     except (OSError, PermissionError) as e:
                         logger.debug("Error reading entry %s: %s", entry.path, e)
                         continue
-            
+
             # Sort items: directories first, then files, both alphabetically
             items.sort(key=lambda x: (not x.is_directory, x.name.lower()))
-            
+
         except (OSError, PermissionError) as e:
             logger.error("Error loading directory %s: %s", directory_path, e)
-        
+
         return items
     
     async def expand_folder(self, client_session_id: str, folder_path: str) -> bool:

{portacode-1.3.27.dev0 → portacode-1.3.28}/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,22 +73,32 @@ 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("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)

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode/connection/terminal.py

@@ -497,9 +497,10 @@ class TerminalManager:
                     logger.info("terminal_manager: ✅ Updated client sessions (%d sessions)", len(sessions))
                     
                     # Auto-send initial data only to newly added clients
+                    # Create a background task so it doesn't block the control loop
                     if newly_added_sessions:
-                        logger.info("terminal_manager: 🚀 Triggering auto-send of initial data to newly added clients")
-                        await self._send_initial_data_to_clients(newly_added_sessions)
+                        logger.info("terminal_manager: 🚀 Triggering auto-send of initial data to newly added clients (non-blocking)")
+                        asyncio.create_task(self._send_initial_data_to_clients(newly_added_sessions))
                     else:
                         logger.info("terminal_manager: ℹ️ No new sessions to send data to")
                     continue

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode/static/js/utils/ntp-clock.js

@@ -42,6 +42,8 @@ class NTPClock {
         this._syncAttempts++;
 
         try {
+            // Capture local time BEFORE the fetch to avoid timing drift
+            const localTimeBeforeFetch = Date.now();
             const t0 = performance.now();
             const response = await fetch('https://cloudflare.com/cdn-cgi/trace');
             const t1 = performance.now();
@@ -49,11 +51,11 @@ class NTPClock {
             const text = await response.text();
             const serverTime = this._parseCloudflareTime(text);
 
-            const localTime = Date.now();
             const latency = (t1 - t0) / 2;  // Estimate one-way latency
 
-            // Calculate offset accounting for latency
-            this.offset = serverTime - localTime + latency;
+            // Calculate offset: server generated timestamp at local time (localTimeBeforeFetch + latency)
+            // So offset = serverTime - (localTimeBeforeFetch + latency)
+            this.offset = serverTime - (localTimeBeforeFetch + latency);
             this.lastSync = Date.now();
 
             console.log(

portacode-1.3.28/portacode/utils/NTP_ARCHITECTURE.md

@@ -0,0 +1,136 @@
+# NTP Clock Architecture
+
+## Overview
+
+All entities (client, server, device) synchronize to **time.cloudflare.com** for distributed tracing.
+
+## Architecture: Single Package for Everything
+
+All NTP clock implementations (Python and JavaScript) are in the **portacode package** to ensure DRY principles.
+
+## Python Implementation
+
+**Location:** `portacode/utils/ntp_clock.py` (in portacode package)
+
+### Import Path
+```python
+from portacode.utils.ntp_clock import ntp_clock
+```
+
+### Usage Locations
+1. **Django Server Consumers** (`server/portacode_django/dashboard/consumers.py`)
+2. **Device Base Handlers** (`portacode/connection/handlers/base.py`)
+3. **Device Client** (`server/portacode_django/data/services/device_client.py`)
+4. **Any Python code with portacode installed**
+
+### Dependencies
+- `setup.py`: Added `ntplib>=0.4.0` to `install_requires`
+- `server/portacode_django/requirements.txt`: Added `portacode>=1.3.26`
+
+### API
+```python
+# Get NTP-synchronized timestamp (None if not synced)
+ntp_clock.now_ms()      # milliseconds
+ntp_clock.now()         # seconds
+ntp_clock.now_iso()     # ISO format
+
+# Check sync status
+status = ntp_clock.get_status()
+# {
+#   'server': 'time.cloudflare.com',
+#   'offset_ms': 6.04,
+#   'last_sync': '2025-10-05T04:37:12.768445+00:00',
+#   'is_synced': True
+# }
+```
+
+## JavaScript Implementation
+
+**Location:** `portacode/static/js/utils/ntp-clock.js` (in portacode package)
+
+### Django Setup
+
+Django will serve static files from the portacode package automatically after `collectstatic`:
+
+```python
+# Django settings.py - no changes needed, just ensure:
+INSTALLED_APPS = [
+    # ... other apps
+    'portacode',  # Add portacode as an installed app (optional, for admin integration)
+]
+
+# Static files will be collected from portacode package
+STATIC_URL = '/static/'
+```
+
+After installing portacode (`pip install portacode` or `pip install -e .`), run:
+```bash
+python manage.py collectstatic
+```
+
+This will copy `portacode/static/js/utils/ntp-clock.js` to Django's static files directory.
+
+### Import Path (in Django templates/JS)
+```javascript
+import ntpClock from '/static/js/utils/ntp-clock.js';
+// or relative to your JS file:
+import ntpClock from './utils/ntp-clock.js';
+```
+
+### Usage Locations
+1. **Dashboard WebSocket** (`websocket-service.js`)
+2. **Project WebSocket** (`websocket-service-project.js`)
+
+### API
+```javascript
+// Get NTP-synchronized timestamp (null if not synced)
+ntpClock.now()          // milliseconds
+ntpClock.nowISO()       // ISO format
+
+// Check sync status
+const status = ntpClock.getStatus();
+// {
+//   server: 'time.cloudflare.com',
+//   offset: 6.04,
+//   lastSync: '2025-10-05T04:37:12.768445+00:00',
+//   isSynced: true
+// }
+```
+
+## Design Principles
+
+1. **DRY (Don't Repeat Yourself)**
+   - **Python:** Single implementation in portacode package (`portacode/utils/ntp_clock.py`)
+   - **JavaScript:** Single implementation in portacode package (`portacode/static/js/utils/ntp-clock.js`)
+   - Both served from the same package, no duplication across repos
+
+2. **No Fallback Servers**
+   - All entities MUST sync to time.cloudflare.com
+   - If sync fails, timestamps are None/null
+   - Ensures all timestamps are comparable
+
+3. **Auto-Sync**
+   - Re-syncs every 5 minutes automatically
+   - Initial sync on import/load
+   - Max 3 retry attempts before marking as failed
+
+4. **Thread-Safe (Python)**
+   - Uses threading.Lock for concurrent access
+   - Background daemon thread for periodic sync
+
+## Testing
+
+### Python
+```bash
+python tools/test_python_ntp_clock.py
+```
+
+### JavaScript
+The test file is included in the package at `portacode/static/js/test-ntp-clock.html`.
+
+After Django collectstatic, open: `/static/js/test-ntp-clock.html` in browser
+
+Or run directly from package:
+```bash
+python -c "import portacode, os; print(os.path.join(os.path.dirname(portacode.__file__), 'static/js/test-ntp-clock.html'))"
+```

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.3.27.dev0
+Version: 1.3.28
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.3.27.dev0 → portacode-1.3.28}/portacode.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ portacode/connection/handlers/project_state/models.py
 portacode/connection/handlers/project_state/utils.py
 portacode/static/js/test-ntp-clock.html
 portacode/static/js/utils/ntp-clock.js
+portacode/utils/NTP_ARCHITECTURE.md
 portacode/utils/__init__.py
 portacode/utils/ntp_clock.py
 test_modules/README.md
@@ -86,4 +87,5 @@ testing_framework/core/runner.py
 testing_framework/core/shared_cli_manager.py
 testing_framework/core/test_discovery.py
 todo/issues/indefinite_resource_loading.md
-todo/issues/premature_terminal_exit.md
+todo/issues/premature_terminal_exit.md
+tools/test_python_ntp_clock.py

{portacode-1.3.27.dev0 → portacode-1.3.28}/testing_framework/core/playwright_manager.py

@@ -177,8 +177,14 @@ class PlaywrightManager:
     async def _perform_login(self):
         """Perform login using provided credentials."""
         try:
+            # Navigate to login page first
+            login_url = f"{self.base_url}/accounts/login/"
+            await self.page.goto(login_url)
+            await self.log_action("navigate_to_login", {"url": login_url})
+            await self.take_screenshot("login_page")
+
             await self.log_action("login_start", {"username": self.username})
-            
+
             # Look for common login form elements
             username_selectors = [
                 'input[name="username"]',

portacode-1.3.28/tools/test_python_ntp_clock.py

@@ -0,0 +1,39 @@
+"""Test Python NTP Clock"""
+import time
+from portacode.utils.ntp_clock import ntp_clock
+
+print("=" * 50)
+print("Testing Python NTP Clock")
+print("=" * 50)
+
+# Wait for initial sync
+print("\nWaiting for initial sync...")
+time.sleep(2)
+
+# Print status
+status = ntp_clock.get_status()
+print(f"\nSync Status: {'✅ SYNCED' if status['is_synced'] else '❌ NOT SYNCED'}")
+print(f"Server: {status['server']}")
+print(f"Offset: {status['offset_ms']}ms" if status['offset_ms'] is not None else "Offset: None")
+print(f"Last Sync: {status['last_sync']}")
+
+# Compare timestamps
+print("\nTimestamp Comparison:")
+print(f"  Local time (ms):  {int(time.time() * 1000)}")
+ntp_time = ntp_clock.now_ms()
+print(f"  NTP time (ms):    {ntp_time if ntp_time is not None else 'None (not synced)'}")
+ntp_iso = ntp_clock.now_iso()
+print(f"  NTP time (ISO):   {ntp_iso if ntp_iso is not None else 'None (not synced)'}")
+
+# Test multiple calls
+print("\nTesting consistency (10 calls):")
+for i in range(10):
+    ts = ntp_clock.now_ms()
+    if ts is not None:
+        print(f"  {i+1}: {ts}")
+    else:
+        print(f"  {i+1}: None (not synced)")
+    time.sleep(0.1)
+
+print("\n✅ Test complete")
+print("=" * 50)