portacode 1.4.37.dev0__tar.gz → 1.4.37.dev2__tar.gz

{portacode-1.4.37.dev0 → portacode-1.4.37.dev2}/PKG-INFO

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

{portacode-1.4.37.dev0 → portacode-1.4.37.dev2}/portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.4.37.dev0'
-__version_tuple__ = version_tuple = (1, 4, 37, 'dev0')
+__version__ = version = '1.4.37.dev2'
+__version_tuple__ = version_tuple = (1, 4, 37, 'dev2')
 
 __commit_id__ = commit_id = None

{portacode-1.4.37.dev0 → portacode-1.4.37.dev2}/portacode/connection/handlers/project_state/file_system_watcher.py

@@ -6,8 +6,11 @@ files or directories are modified.
 """
 
 import asyncio
+import faulthandler
 import logging
 import os
+import sys
+import time
 from pathlib import Path
 from typing import Optional, Set
 
@@ -125,6 +128,12 @@ class FileSystemWatcher:
         if normalized_name == '.git':
             logger.debug("Skipping watch for .git path: %s", path)
             return
+        if not os.path.isdir(path):
+            logger.debug("Skipping watch for non-directory path: %s", path)
+            return
+        if not os.access(path, os.R_OK | os.X_OK):
+            logger.debug("Skipping watch due to insufficient access: %s", path)
+            return
 
         if path not in self.watched_paths:
             try:
@@ -151,16 +160,54 @@ class FileSystemWatcher:
             # Actually unschedule the watch using stored handle
             watch_handle = self.watch_handles.get(path)
             if watch_handle:
+                start = time.monotonic()
+                logger.info(
+                    "About to unschedule watch: path=%s handle=%s observer_alive=%s watched_paths=%d watch_handles=%d",
+                    path,
+                    id(watch_handle),
+                    bool(self.observer and self.observer.is_alive()),
+                    len(self.watched_paths),
+                    len(self.watch_handles),
+                )
                 try:
+                    # If unschedule blocks silently, force a thread traceback dump for diagnosis.
+                    faulthandler.dump_traceback_later(8.0, file=sys.stderr, repeat=False)
                     self.observer.unschedule(watch_handle)
-                    logger.info("Successfully unscheduled watch for: %s", path)
+                    logger.info(
+                        "Successfully unscheduled watch for: %s (elapsed=%.3fs)",
+                        path,
+                        max(time.monotonic() - start, 0.0),
+                    )
                 except Exception as e:
-                    logger.error("Error unscheduling watch for %s: %s", path, e)
+                    logger.exception(
+                        "Error unscheduling watch for %s after %.3fs: %s",
+                        path,
+                        max(time.monotonic() - start, 0.0),
+                        e,
+                    )
                 finally:
+                    try:
+                        faulthandler.cancel_dump_traceback_later()
+                    except Exception:
+                        pass
                     self.watch_handles.pop(path, None)
+            else:
+                logger.warning(
+                    "Path %s marked as watched but has no watch handle; watched_paths=%d watch_handles=%d",
+                    path,
+                    len(self.watched_paths),
+                    len(self.watch_handles),
+                )
 
             self.watched_paths.discard(path)
             logger.debug("Stopped watching path: %s", path)
+        else:
+            logger.debug(
+                "stop_watching called for non-watched path: %s (watched_paths=%d watch_handles=%d)",
+                path,
+                len(self.watched_paths),
+                len(self.watch_handles),
+            )
     
     def stop_all(self):
         """Stop all file watching."""

{portacode-1.4.37.dev0 → portacode-1.4.37.dev2}/portacode/connection/handlers/project_state/manager.py

@@ -281,6 +281,12 @@ class ProjectStateManager:
             with os.scandir(project_state.project_folder_path) as entries:
                 for entry in entries:
                     if entry.is_dir() and entry.name != '.git':  # Only exclude .git, allow other dot folders
+                        if not os.access(entry.path, os.R_OK | os.X_OK):
+                            logger.debug(
+                                "Skipping monitored folder due to insufficient access: %s",
+                                entry.path,
+                            )
+                            continue
                         project_state.monitored_folders.append(
                             MonitoredFolder(folder_path=entry.path, is_expanded=False)
                         )
@@ -350,6 +356,12 @@ class ProjectStateManager:
             with os.scandir(parent_folder_path) as entries:
                 for entry in entries:
                     if entry.is_dir() and entry.name != '.git':  # Only exclude .git, allow other dot folders
+                        if not os.access(entry.path, os.R_OK | os.X_OK):
+                            logger.debug(
+                                "Skipping monitored folder due to insufficient access: %s",
+                                entry.path,
+                            )
+                            continue
                         # logger.info("Found subdirectory: %s", entry.path)
                         if entry.path not in existing_paths:
                             logger.info("Adding new monitored folder: %s", entry.path)
@@ -1210,13 +1222,52 @@ class ProjectStateManager:
                     logger.debug("Removed %d pending change paths for session %s during cleanup", len(removed), client_session_id)
             
             # Stop watching all monitored folders for this project
-            for monitored_folder in project_state.monitored_folders:
+            total_monitored = len(project_state.monitored_folders)
+            logger.info(
+                "Cleanup starting watcher unschedule loop: session=%s project_path=%s monitored_folders=%d watched_paths=%d watch_handles=%d",
+                client_session_id,
+                project_state.project_folder_path,
+                total_monitored,
+                len(self.file_watcher.watched_paths) if self.file_watcher else -1,
+                len(self.file_watcher.watch_handles) if self.file_watcher else -1,
+            )
+            cleanup_loop_start = time.monotonic()
+            for idx, monitored_folder in enumerate(project_state.monitored_folders, start=1):
+                per_folder_start = time.monotonic()
+                logger.info(
+                    "Cleanup unschedule start: session=%s idx=%d/%d path=%s",
+                    client_session_id,
+                    idx,
+                    total_monitored,
+                    monitored_folder.folder_path,
+                )
                 self.file_watcher.stop_watching(monitored_folder.folder_path)
+                logger.info(
+                    "Cleanup unschedule done: session=%s idx=%d/%d path=%s elapsed=%.3fs",
+                    client_session_id,
+                    idx,
+                    total_monitored,
+                    monitored_folder.folder_path,
+                    max(time.monotonic() - per_folder_start, 0.0),
+                )
+            logger.info(
+                "Cleanup watcher unschedule loop completed: session=%s total_elapsed=%.3fs",
+                client_session_id,
+                max(time.monotonic() - cleanup_loop_start, 0.0),
+            )
             
             # Stop watching .git directory if it was being monitored
             if project_state.is_git_repo:
                 git_dir_path = os.path.join(project_state.project_folder_path, '.git')
+                git_unschedule_start = time.monotonic()
+                logger.info("Cleanup unschedule start (git dir): session=%s path=%s", client_session_id, git_dir_path)
                 self.file_watcher.stop_watching(git_dir_path)
+                logger.info(
+                    "Cleanup unschedule done (git dir): session=%s path=%s elapsed=%.3fs",
+                    client_session_id,
+                    git_dir_path,
+                    max(time.monotonic() - git_unschedule_start, 0.0),
+                )
             
             self.projects.pop(client_session_id, None)
             logger.info("Cleaned up project state: %s", client_session_id)

{portacode-1.4.37.dev0 → portacode-1.4.37.dev2}/portacode/connection/terminal.py

@@ -14,12 +14,9 @@ in the handlers directory.
 """
 
 import asyncio
-import faulthandler
 import json
 import logging
 import os
-import sys
-import threading
 import time
 from datetime import datetime, timezone
 from dataclasses import asdict
@@ -392,185 +389,11 @@ class TerminalManager:
         self.mux = mux
         self.debug = debug
         self._last_exposed_services_signature = "__unset__"
-        self._diag_lock = threading.Lock()
-        now_mono = time.monotonic()
-        self._diag_state: Dict[str, Any] = {
-            "heartbeat_monotonic": now_mono,
-            "heartbeat_epoch_s": time.time(),
-            "loop_phase": "init",
-            "active_cmd": None,
-            "active_cmd_started_monotonic": None,
-            "active_cmd_reply_channel": None,
-            "last_completed_cmd": None,
-            "last_completed_cmd_duration_s": None,
-            "queue_stats": {},
-        }
-        self._diag_monitor_enabled = os.getenv("PORTACODE_EVENT_LOOP_BLOCK_MONITOR", "1").lower() not in ("0", "false", "no")
-        self._diag_threshold_s = float(os.getenv("PORTACODE_EVENT_LOOP_BLOCK_THRESHOLD_S", "5"))
-        self._diag_monitor_interval_s = float(os.getenv("PORTACODE_EVENT_LOOP_BLOCK_MONITOR_INTERVAL_S", "0.5"))
-        self._diag_report_interval_s = float(os.getenv("PORTACODE_EVENT_LOOP_BLOCK_REPORT_INTERVAL_S", "30"))
-        self._diag_heartbeat_interval_s = float(os.getenv("PORTACODE_EVENT_LOOP_BLOCK_HEARTBEAT_INTERVAL_S", "0.5"))
-        self._diag_dump_threads = os.getenv("PORTACODE_EVENT_LOOP_BLOCK_DUMP_THREADS", "1").lower() not in ("0", "false", "no")
-        self._diag_monitor_stop = threading.Event()
-        self._diag_monitor_thread: Optional[threading.Thread] = None
-        self._diag_last_report_monotonic = 0.0
-        self._diag_last_report_key: Optional[str] = None
         self._session_manager = None  # Initialize as None first
         self._client_session_manager = ClientSessionManager()  # Initialize client session manager
         self._client_session_manager.set_terminal_manager(self)  # Set reference for cleanup
-        self._start_block_monitor_thread_if_enabled()
         self._set_mux(mux, is_initial=True)
 
-    def _start_block_monitor_thread_if_enabled(self) -> None:
-        if not self._diag_monitor_enabled or self._diag_monitor_thread:
-            return
-        self._diag_monitor_thread = threading.Thread(
-            target=self._event_loop_block_monitor_thread,
-            name="portacode-event-loop-block-monitor",
-            daemon=True,
-        )
-        self._diag_monitor_thread.start()
-
-    def _set_diag_phase(self, phase: str) -> None:
-        now_mono = time.monotonic()
-        now_epoch = time.time()
-        with self._diag_lock:
-            self._diag_state["loop_phase"] = phase
-            self._diag_state["heartbeat_monotonic"] = now_mono
-            self._diag_state["heartbeat_epoch_s"] = now_epoch
-
-    def _set_diag_active_cmd(self, cmd: str, reply_channel: Optional[str]) -> None:
-        now_mono = time.monotonic()
-        now_epoch = time.time()
-        with self._diag_lock:
-            self._diag_state["active_cmd"] = cmd
-            self._diag_state["active_cmd_reply_channel"] = reply_channel
-            self._diag_state["active_cmd_started_monotonic"] = now_mono
-            self._diag_state["heartbeat_monotonic"] = now_mono
-            self._diag_state["heartbeat_epoch_s"] = now_epoch
-
-    def _clear_diag_active_cmd(self, completed_cmd: str, duration_s: float) -> None:
-        now_mono = time.monotonic()
-        now_epoch = time.time()
-        with self._diag_lock:
-            self._diag_state["active_cmd"] = None
-            self._diag_state["active_cmd_reply_channel"] = None
-            self._diag_state["active_cmd_started_monotonic"] = None
-            self._diag_state["last_completed_cmd"] = completed_cmd
-            self._diag_state["last_completed_cmd_duration_s"] = round(duration_s, 4)
-            self._diag_state["heartbeat_monotonic"] = now_mono
-            self._diag_state["heartbeat_epoch_s"] = now_epoch
-
-    def _snapshot_diag_state_for_monitor(self) -> Dict[str, Any]:
-        with self._diag_lock:
-            return dict(self._diag_state)
-
-    def _event_loop_block_monitor_thread(self) -> None:
-        while not self._diag_monitor_stop.wait(self._diag_monitor_interval_s):
-            snapshot = self._snapshot_diag_state_for_monitor()
-            now = time.monotonic()
-            last_hb = float(snapshot.get("heartbeat_monotonic") or now)
-            blocked_for_s = max(now - last_hb, 0.0)
-
-            if blocked_for_s < self._diag_threshold_s:
-                continue
-
-            active_cmd = snapshot.get("active_cmd")
-            queue_stats = snapshot.get("queue_stats") if isinstance(snapshot.get("queue_stats"), dict) else {}
-            control_q = queue_stats.get("control_channel_queue_size")
-            total_mux_q = queue_stats.get("mux_total_queued_frames")
-            has_backlog = (
-                (isinstance(control_q, int) and control_q > 0)
-                or (isinstance(total_mux_q, int) and total_mux_q > 0)
-            )
-            if not active_cmd and not has_backlog:
-                continue
-
-            active_cmd_started = snapshot.get("active_cmd_started_monotonic")
-            active_cmd_age_s = None
-            if active_cmd and isinstance(active_cmd_started, (int, float)):
-                active_cmd_age_s = max(now - float(active_cmd_started), 0.0)
-
-            report_key = f"{snapshot.get('loop_phase')}:{active_cmd}:{snapshot.get('heartbeat_epoch_s')}"
-            if report_key == self._diag_last_report_key and (now - self._diag_last_report_monotonic) < self._diag_report_interval_s:
-                continue
-
-            self._diag_last_report_key = report_key
-            self._diag_last_report_monotonic = now
-
-            payload = {
-                "event": "event_loop_blocking_detected",
-                "blocked_for_s": round(blocked_for_s, 3),
-                "threshold_s": self._diag_threshold_s,
-                "cause_hint": {
-                    "loop_phase": snapshot.get("loop_phase"),
-                    "active_cmd": active_cmd,
-                    "active_cmd_reply_channel": snapshot.get("active_cmd_reply_channel"),
-                    "active_cmd_age_s": round(active_cmd_age_s, 3) if active_cmd_age_s is not None else None,
-                    "last_completed_cmd": snapshot.get("last_completed_cmd"),
-                    "last_completed_cmd_duration_s": snapshot.get("last_completed_cmd_duration_s"),
-                },
-                "queue_stats": queue_stats,
-                "last_heartbeat_epoch_s": snapshot.get("heartbeat_epoch_s"),
-                "monitor_thread_epoch_s": time.time(),
-                "pid": os.getpid(),
-            }
-            logger.error("Event loop stall monitor: %s", json.dumps(payload, sort_keys=True))
-
-            if self._diag_dump_threads:
-                try:
-                    faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
-                except Exception as exc:
-                    logger.error("Event loop stall monitor failed to dump thread traceback: %s", exc)
-
-    def _collect_loop_queue_stats(self) -> Dict[str, Any]:
-        control_q_size = None
-        try:
-            control_q = getattr(self._control_channel, "_incoming", None)
-            if control_q is not None:
-                control_q_size = control_q.qsize()
-        except Exception:
-            control_q_size = None
-
-        mux_channels = getattr(self.mux, "_channels", {}) if self.mux else {}
-        total_queued = 0
-        top_channels = []
-        for channel_id, channel in mux_channels.items():
-            try:
-                incoming_q = getattr(channel, "_incoming", None)
-                size = incoming_q.qsize() if incoming_q is not None else None
-            except Exception:
-                size = None
-            if isinstance(size, int):
-                total_queued += size
-                top_channels.append((str(channel_id), size))
-
-        top_channels.sort(key=lambda item: item[1], reverse=True)
-        return {
-            "control_channel_queue_size": control_q_size,
-            "mux_channel_count": len(mux_channels),
-            "mux_total_queued_frames": total_queued,
-            "mux_top_queues": [{"channel_id": cid, "size": size} for cid, size in top_channels[:5]],
-            "client_sessions_count": len(self._client_session_manager.get_sessions()),
-        }
-
-    async def _diag_heartbeat_loop(self) -> None:
-        while True:
-            try:
-                await asyncio.sleep(self._diag_heartbeat_interval_s)
-                queue_stats = self._collect_loop_queue_stats()
-                now_mono = time.monotonic()
-                now_epoch = time.time()
-                with self._diag_lock:
-                    self._diag_state["heartbeat_monotonic"] = now_mono
-                    self._diag_state["heartbeat_epoch_s"] = now_epoch
-                    self._diag_state["queue_stats"] = queue_stats
-            except asyncio.CancelledError:
-                return
-            except Exception as exc:
-                logger.debug("Event loop heartbeat diagnostics error: %s", exc)
-                await asyncio.sleep(self._diag_heartbeat_interval_s)
-
     # ------------------------------------------------------------------
     # Mux attach/detach helpers (for reconnection resilience)
     # ------------------------------------------------------------------
@@ -646,14 +469,6 @@ class TerminalManager:
             except Exception:
                 pass
         self._exposed_services_task = asyncio.create_task(self._watch_exposed_services())
-
-        # Start passive event-loop diagnostics heartbeat (asyncio thread only).
-        if getattr(self, "_diag_heartbeat_task", None):
-            try:
-                self._diag_heartbeat_task.cancel()
-            except Exception:
-                pass
-        self._diag_heartbeat_task = asyncio.create_task(self._diag_heartbeat_loop())
         
         # For initial connections, request client sessions after control loop starts
         if is_initial:
@@ -716,9 +531,7 @@ class TerminalManager:
         logger.info("terminal_manager: Starting control loop")
         while True:
             try:
-                self._set_diag_phase("control_loop_waiting_for_message")
                 message = await self._control_channel.recv()
-                self._set_diag_phase("control_loop_received_message")
                 logger.debug("terminal_manager: Received message: %s", message)
                 
                 # Older parts of the system may send *raw* str. Ensure dict.
@@ -741,8 +554,6 @@ class TerminalManager:
                     logger.warning("terminal_manager: Missing 'cmd' in control frame: %s", message)
                     continue
                 reply_chan = message.get("reply_channel")
-                cmd_start = time.monotonic()
-                self._set_diag_active_cmd(cmd, reply_chan)
                 
                 logger.info("terminal_manager: Processing command '%s' with reply_channel=%s", cmd, reply_chan)
                 logger.debug("terminal_manager: Full message: %s", message)
@@ -762,8 +573,6 @@ class TerminalManager:
                         asyncio.create_task(self._send_initial_data_to_clients(newly_added_sessions))
                     else:
                         logger.info("terminal_manager: ℹ️ No new sessions to send data to")
-                    self._clear_diag_active_cmd(cmd, time.monotonic() - cmd_start)
-                    self._set_diag_phase("control_loop_completed_client_sessions_update")
                     continue
                 
                 # Dispatch command through registry
@@ -771,16 +580,9 @@ class TerminalManager:
                 if not handled:
                     logger.warning("terminal_manager: Command '%s' was not handled by any handler", cmd)
                     await self._send_error(f"Unknown cmd: {cmd}", reply_chan)
-                self._clear_diag_active_cmd(cmd, time.monotonic() - cmd_start)
-                self._set_diag_phase(f"control_loop_completed_{cmd}")
                     
             except Exception as exc:
                 logger.exception("terminal_manager: Error in control loop: %s", exc)
-                with self._diag_lock:
-                    self._diag_state["active_cmd"] = None
-                    self._diag_state["active_cmd_started_monotonic"] = None
-                    self._diag_state["active_cmd_reply_channel"] = None
-                self._set_diag_phase("control_loop_exception")
                 # Continue processing other messages
                 continue
 

{portacode-1.4.37.dev0 → portacode-1.4.37.dev2}/portacode.egg-info/PKG-INFO

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