portacode 1.3.32__py3-none-any.whl → 1.3.33__py3-none-any.whl

portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.3.32'
-__version_tuple__ = version_tuple = (1, 3, 32)
+__version__ = version = '1.3.33'
+__version_tuple__ = version_tuple = (1, 3, 33)
 
 __commit_id__ = commit_id = None

portacode/connection/handlers/project_state/git_manager.py

@@ -1844,16 +1844,17 @@ class GitManager:
         """Monitor git changes periodically and trigger callback when changes are detected."""
         try:
             while self._monitoring_enabled:
-                await asyncio.sleep(1.0)  # Check every 1000ms
-                
+                await asyncio.sleep(5.0)  # Check every 5000ms
+
                 if not self._monitoring_enabled or not self.is_git_repo:
                     break
-                
+
                 try:
-                    # Get current status
-                    current_status_summary = self.get_status_summary()
-                    current_detailed_status = self.get_detailed_status()
-                    current_branch = self.get_branch_name()
+                    # Get current status - run in executor to avoid blocking event loop
+                    loop = asyncio.get_event_loop()
+                    current_status_summary = await loop.run_in_executor(None, self.get_status_summary)
+                    current_detailed_status = await loop.run_in_executor(None, self.get_detailed_status)
+                    current_branch = await loop.run_in_executor(None, self.get_branch_name)
                     
                     # Compare with cached status
                     status_changed = (

portacode/connection/handlers/session.py

@@ -3,13 +3,15 @@
 import asyncio
 import logging
 import os
+import struct
 import sys
 import time
 import uuid
 from asyncio.subprocess import Process
 from pathlib import Path
 from typing import Any, Dict, Optional, List, TYPE_CHECKING
-from collections import deque
+
+import pyte
 
 if TYPE_CHECKING:
     from ..multiplex import Channel
@@ -19,13 +21,32 @@ TERMINAL_DATA_RATE_LIMIT_MS = 60  # Minimum time between terminal_data events (m
 TERMINAL_DATA_MAX_WAIT_MS = 1000   # Maximum time to wait before sending accumulated data (milliseconds)
 TERMINAL_DATA_INITIAL_WAIT_MS = 10  # Time to wait for additional data even on first event (milliseconds)
 
-# Terminal buffer size limit configuration
-TERMINAL_BUFFER_SIZE_LIMIT_BYTES = 30 * 1024  # Maximum buffer size in bytes (30KB)
+# Terminal buffer configuration - using pyte for proper screen state management
+TERMINAL_COLUMNS = 80  # Default terminal width
+TERMINAL_ROWS = 24     # Default terminal height (visible area)
+TERMINAL_SCROLLBACK_LIMIT = 1000  # Maximum number of scrollback lines to preserve
 
 logger = logging.getLogger(__name__)
 
 _IS_WINDOWS = sys.platform.startswith("win")
 
+
+def _configure_pty_window_size(fd: int, rows: int, cols: int) -> None:
+    """Set the PTY window size so subprocesses see a real terminal."""
+    if _IS_WINDOWS:
+        return
+    try:
+        import fcntl
+        import termios
+        winsize = struct.pack("HHHH", rows, cols, 0, 0)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+    except ImportError:
+        logger.debug("termios/fcntl unavailable; skipping PTY window sizing")
+    except OSError as exc:
+        logger.warning("Failed to set PTY window size (%sx%s): %s", cols, rows, exc)
+
+
+
 # Minimal, safe defaults for interactive shells
 _DEFAULT_ENV = {
     "TERM": "xterm-256color",
@@ -39,6 +60,8 @@ def _build_child_env() -> Dict[str, str]:
     env = os.environ.copy()
     for k, v in _DEFAULT_ENV.items():
         env.setdefault(k, v)
+    env.setdefault("COLUMNS", str(TERMINAL_COLUMNS))
+    env.setdefault("LINES", str(TERMINAL_ROWS))
     return env
 
 
@@ -52,9 +75,11 @@ class TerminalSession:
         self.project_id = project_id
         self.terminal_manager = terminal_manager
         self._reader_task: Optional[asyncio.Task[None]] = None
-        self._buffer: deque[str] = deque()
-        self._buffer_size_bytes = 0  # Track total buffer size in bytes
-        
+
+        # Use pyte for proper terminal screen state management
+        self._screen = pyte.HistoryScreen(TERMINAL_COLUMNS, TERMINAL_ROWS, history=TERMINAL_SCROLLBACK_LIMIT)
+        self._stream = pyte.Stream(self._screen)  # Use Stream (not ByteStream) since data is already decoded to strings
+
         # Rate limiting for terminal_data events
         self._last_send_time: float = 0
         self._pending_data: str = ""
@@ -162,13 +187,13 @@ class TerminalSession:
         """Send terminal data immediately and update last send time."""
         self._last_send_time = time.time()
         data_size = len(data.encode('utf-8'))
-        
-        logger.info("session: Attempting to send terminal_data for terminal %s (data_size=%d bytes)", 
+
+        logger.info("session: Attempting to send terminal_data for terminal %s (data_size=%d bytes)",
                    self.id, data_size)
-        
-        # Add to buffer for snapshots with size limiting
+
+        # Feed data to pyte screen for proper terminal state management
         self._add_to_buffer(data)
-        
+
         try:
             # Send terminal data via control channel with client session targeting
             if self.terminal_manager:
@@ -206,39 +231,25 @@ class TerminalSession:
         current_time = time.time()
         time_since_last_send = (current_time - self._last_send_time) * 1000  # Convert to milliseconds
         data_size = len(data.encode('utf-8'))
-        
-        logger.info("session: Received terminal_data for terminal %s (data_size=%d bytes, time_since_last_send=%.1fms)", 
+
+        logger.info("session: Received terminal_data for terminal %s (data_size=%d bytes, time_since_last_send=%.1fms)",
                    self.id, data_size, time_since_last_send)
-        
-        # Add new data to pending buffer with simple size limiting
-        # Always add the new data first
+
+        # Add new data to pending buffer (no trimming needed - pyte handles screen state)
         self._pending_data += data
-        
-        # Simple size limiting - only trim if we exceed the 30KB limit significantly
-        pending_size = len(self._pending_data.encode('utf-8'))
-        if pending_size > TERMINAL_BUFFER_SIZE_LIMIT_BYTES:
-            logger.info("session: Buffer size limit exceeded for terminal %s (pending_size=%d bytes, limit=%d bytes), trimming", 
-                       self.id, pending_size, TERMINAL_BUFFER_SIZE_LIMIT_BYTES)
-            # Only do minimal ANSI-safe trimming from the beginning
-            excess_bytes = pending_size - TERMINAL_BUFFER_SIZE_LIMIT_BYTES
-            trim_pos = self._find_minimal_safe_trim_position(excess_bytes)
-            
-            if trim_pos > 0:
-                self._pending_data = self._pending_data[trim_pos:]
-                logger.info("session: Trimmed %d bytes from pending buffer for terminal %s", trim_pos, self.id)
-        
+
         # Cancel existing debounce task if any
         if self._debounce_task and not self._debounce_task.done():
             logger.debug("session: Cancelling existing debounce task for terminal %s", self.id)
             self._debounce_task.cancel()
-        
+
         # Always set up a debounce timer to catch rapid consecutive outputs
         async def _debounce_timer():
             try:
                 if time_since_last_send >= TERMINAL_DATA_RATE_LIMIT_MS:
                     # Enough time has passed since last send, wait initial delay for more data
                     wait_time = TERMINAL_DATA_INITIAL_WAIT_MS / 1000
-                    logger.info("session: Rate limit satisfied for terminal %s, waiting %.1fms for more data", 
+                    logger.info("session: Rate limit satisfied for terminal %s, waiting %.1fms for more data",
                                self.id, wait_time * 1000)
                 else:
                     # Too soon since last send, wait for either the rate limit period or max wait time
@@ -246,9 +257,9 @@ class TerminalSession:
                         (TERMINAL_DATA_RATE_LIMIT_MS - time_since_last_send) / 1000,
                         TERMINAL_DATA_MAX_WAIT_MS / 1000
                     )
-                    logger.info("session: Rate limit active for terminal %s, waiting %.1fms before send (time_since_last=%.1fms, rate_limit=%dms)", 
+                    logger.info("session: Rate limit active for terminal %s, waiting %.1fms before send (time_since_last=%.1fms, rate_limit=%dms)",
                                self.id, wait_time * 1000, time_since_last_send, TERMINAL_DATA_RATE_LIMIT_MS)
-                
+
                 await asyncio.sleep(wait_time)
                 logger.info("session: Debounce timer expired for terminal %s, flushing pending data", self.id)
                 await self._flush_pending_data()
@@ -256,56 +267,264 @@ class TerminalSession:
                 logger.debug("session: Debounce timer cancelled for terminal %s (new data arrived)", self.id)
                 # Timer was cancelled, another data event came in
                 pass
-        
+
         self._debounce_task = asyncio.create_task(_debounce_timer())
         logger.info("session: Started debounce timer for terminal %s", self.id)
 
-    def _find_minimal_safe_trim_position(self, excess_bytes: int) -> int:
-        """Find a minimal safe position to trim that only avoids breaking ANSI sequences."""
-        import re
-        
-        # Find the basic character-safe position
-        trim_pos = 0
-        current_bytes = 0
-        for i, char in enumerate(self._pending_data):
-            char_bytes = len(char.encode('utf-8'))
-            if current_bytes + char_bytes > excess_bytes:
-                trim_pos = i
-                break
-            current_bytes += char_bytes
-        
-        # Only adjust if we're breaking an ANSI sequence
-        search_start = max(0, trim_pos - 20)  # Much smaller search area
-        text_before_trim = self._pending_data[search_start:trim_pos]
-        
-        # Check if we're in the middle of an incomplete ANSI sequence
-        incomplete_pattern = r'\x1b\[[0-9;]*$'
-        if re.search(incomplete_pattern, text_before_trim):
-            # Find the start of this sequence and trim before it
-            last_esc = text_before_trim.rfind('\x1b[')
-            if last_esc >= 0:
-                return search_start + last_esc
-        
-        # Check if we're cutting right after an ESC character
-        if trim_pos > 0 and self._pending_data[trim_pos - 1] == '\x1b':
-            return trim_pos - 1
-        
-        return trim_pos
-
     def _add_to_buffer(self, data: str) -> None:
-        """Add data to buffer while maintaining size limit."""
-        data_bytes = len(data.encode('utf-8'))
-        self._buffer.append(data)
-        self._buffer_size_bytes += data_bytes
-        
-        # Remove oldest entries until we're under the size limit
-        while self._buffer_size_bytes > TERMINAL_BUFFER_SIZE_LIMIT_BYTES and self._buffer:
-            oldest_data = self._buffer.popleft()
-            self._buffer_size_bytes -= len(oldest_data.encode('utf-8'))
+        """Feed data to pyte virtual terminal screen."""
+        # Feed the data to pyte - it handles all ANSI parsing and screen state management
+        self._stream.feed(data)
 
     def snapshot_buffer(self) -> str:
-        """Return concatenated last buffer contents suitable for UI."""
-        return "".join(self._buffer)
+        """Return the visible terminal content as ANSI sequences suitable for XTerm.js."""
+        # Render screen content to ANSI
+        result = self._render_screen_to_ansi()
+
+        # Add cursor positioning at the end so XTerm.js knows where the cursor should be
+        # This is critical - without it, new data gets written at the wrong position causing duplication
+        cursor_y = self._screen.cursor.y + 1  # Convert 0-indexed to 1-indexed
+        cursor_x = self._screen.cursor.x + 1  # Convert 0-indexed to 1-indexed
+
+        # Move cursor to the correct position
+        result += f'\x1b[{cursor_y};{cursor_x}H'
+
+        return result
+
+    def _render_screen_to_ansi(self) -> str:
+        """Convert pyte screen state to ANSI escape sequences.
+
+        This renders both scrollback history and visible screen with full formatting
+        (colors, bold, italics, underline) preserved as ANSI sequences.
+        """
+        lines = []
+
+        # Get scrollback history if available (HistoryScreen provides this)
+        if hasattr(self._screen, 'history'):
+            # Process scrollback lines (lines that have scrolled off the top)
+            history_top = self._screen.history.top
+            for line_data in history_top:
+                # line_data is a dict mapping column positions to Char objects
+                line = self._render_line_to_ansi(line_data, self._screen.columns)
+                lines.append(line)
+
+        # Process visible screen lines
+        for y in range(self._screen.lines):
+            line_data = self._screen.buffer[y]
+            line = self._render_line_to_ansi(line_data, self._screen.columns)
+            lines.append(line)
+
+        # Join all lines with CRLF for proper terminal display
+        return '\r\n'.join(lines)
+
+    def _render_line_to_ansi(self, line_data: Dict[int, 'pyte.screens.Char'], columns: int) -> str:
+        """Convert a single line from pyte format to ANSI escape sequences.
+
+        Args:
+            line_data: Dict mapping column index to Char objects
+            columns: Number of columns in the terminal
+
+        Returns:
+            String with ANSI escape codes for formatting
+        """
+        result = []
+        last_char = None
+        did_reset = False  # Track if we just emitted a reset code
+
+        for x in range(columns):
+            char = line_data.get(x)
+            if char is None:
+                # Empty cell - reset formatting if we had any
+                if last_char is not None and self._char_has_formatting(last_char):
+                    result.append('\x1b[0m')
+                    did_reset = True
+                result.append(' ')
+                last_char = None
+                continue
+
+            # Check if formatting changed from previous character
+            format_changed = last_char is None or self._char_format_changed(last_char, char) or did_reset
+
+            if format_changed:
+                # If previous char had formatting and current is different, reset first
+                if last_char is not None and self._char_has_formatting(last_char) and not did_reset:
+                    result.append('\x1b[0m')
+
+                # Apply new formatting (always apply after reset)
+                ansi_codes = self._get_ansi_codes_for_char(char)
+                if ansi_codes:
+                    result.append(f'\x1b[{ansi_codes}m')
+                    did_reset = False
+                else:
+                    did_reset = True  # No formatting to apply after reset
+
+            # Add the character data
+            result.append(char.data)
+            last_char = char
+
+        # Reset formatting at end of line if we had any
+        if last_char is not None and self._char_has_formatting(last_char):
+            result.append('\x1b[0m')
+
+        # Strip trailing whitespace from the line
+        line_text = ''.join(result).rstrip()
+        return line_text
+
+    def _char_has_formatting(self, char: 'pyte.screens.Char') -> bool:
+        """Check if a character has any formatting applied."""
+        return (char.bold or
+                (hasattr(char, 'dim') and char.dim) or
+                char.italics or
+                char.underscore or
+                (hasattr(char, 'blink') and char.blink) or
+                char.reverse or
+                (hasattr(char, 'hidden') and char.hidden) or
+                char.strikethrough or
+                char.fg != 'default' or
+                char.bg != 'default')
+
+    def _char_format_changed(self, char1: 'pyte.screens.Char', char2: 'pyte.screens.Char') -> bool:
+        """Check if formatting changed between two characters."""
+        return (char1.bold != char2.bold or
+                (hasattr(char1, 'dim') and hasattr(char2, 'dim') and char1.dim != char2.dim) or
+                char1.italics != char2.italics or
+                char1.underscore != char2.underscore or
+                (hasattr(char1, 'blink') and hasattr(char2, 'blink') and char1.blink != char2.blink) or
+                char1.reverse != char2.reverse or
+                (hasattr(char1, 'hidden') and hasattr(char2, 'hidden') and char1.hidden != char2.hidden) or
+                char1.strikethrough != char2.strikethrough or
+                char1.fg != char2.fg or
+                char1.bg != char2.bg)
+
+    def _get_ansi_codes_for_char(self, char: 'pyte.screens.Char') -> str:
+        """Convert pyte Char formatting to ANSI escape codes.
+
+        Returns:
+            String of semicolon-separated ANSI codes (e.g., "1;32;44")
+        """
+        codes = []
+
+        # Text attributes - comprehensive list matching ANSI SGR codes
+        if char.bold:
+            codes.append('1')
+        if hasattr(char, 'dim') and char.dim:
+            codes.append('2')
+        if char.italics:
+            codes.append('3')
+        if char.underscore:
+            codes.append('4')
+        if hasattr(char, 'blink') and char.blink:
+            codes.append('5')
+        if char.reverse:
+            codes.append('7')
+        if hasattr(char, 'hidden') and char.hidden:
+            codes.append('8')
+        if char.strikethrough:
+            codes.append('9')
+
+        # Foreground color
+        if char.fg != 'default':
+            fg_code = self._color_to_ansi(char.fg, is_background=False)
+            if fg_code:
+                codes.append(fg_code)
+
+        # Background color
+        if char.bg != 'default':
+            bg_code = self._color_to_ansi(char.bg, is_background=True)
+            if bg_code:
+                codes.append(bg_code)
+
+        return ';'.join(codes)
+
+    def _color_to_ansi(self, color, is_background: bool = False) -> Optional[str]:
+        """Convert pyte color to ANSI color code.
+
+        Args:
+            color: Color value (can be string name, int for 256-color, hex string, or tuple for RGB)
+            is_background: True for background color, False for foreground
+
+        Returns:
+            ANSI color code string or None
+        """
+        # Handle default/None
+        if color == 'default' or color is None:
+            return None
+
+        # Standard base for 8 basic colors
+        base = 40 if is_background else 30
+
+        if isinstance(color, str):
+            # pyte stores colors as lowercase strings
+            color_lower = color.lower()
+
+            # Check for hex color format (pyte stores RGB as hex strings like '4782c8')
+            # Hex strings are 6 characters (RRGGBB)
+            if len(color_lower) == 6 and all(c in '0123456789abcdef' for c in color_lower):
+                try:
+                    # Parse hex string to RGB
+                    r = int(color_lower[0:2], 16)
+                    g = int(color_lower[2:4], 16)
+                    b = int(color_lower[4:6], 16)
+                    return f'{"48" if is_background else "38"};2;{r};{g};{b}'
+                except ValueError:
+                    pass  # Not a valid hex color, continue to other checks
+
+            # Named colors (black, red, green, yellow, blue, magenta, cyan, white)
+            color_map = {
+                'black': 0, 'red': 1, 'green': 2, 'yellow': 3,
+                'blue': 4, 'magenta': 5, 'cyan': 6, 'white': 7
+            }
+
+            # Check for bright/intense colors first (pyte may use different formats)
+            # Format 1: "brightred", "brightblue", etc.
+            if color_lower.startswith('bright') and len(color_lower) > 6:
+                color_base = color_lower[6:]  # Remove 'bright' prefix
+                if color_base in color_map:
+                    # Bright colors: 90-97 (fg), 100-107 (bg)
+                    return str(base + 60 + color_map[color_base])
+
+            # Format 2: "bright_red", "bright_blue", etc.
+            if color_lower.startswith('bright_'):
+                color_base = color_lower[7:]  # Remove 'bright_' prefix
+                if color_base in color_map:
+                    return str(base + 60 + color_map[color_base])
+
+            # Standard color names
+            if color_lower in color_map:
+                return str(base + color_map[color_lower])
+
+            # Some terminals use color names like "brown" instead of "yellow"
+            color_aliases = {
+                'brown': 3,  # yellow
+                'lightgray': 7, 'lightgrey': 7,  # white
+                'darkgray': 0, 'darkgrey': 0,  # black
+            }
+            if color_lower in color_aliases:
+                return str(base + color_aliases[color_lower])
+
+        elif isinstance(color, int):
+            # 256-color palette (0-255)
+            # Note: 0-15 are the basic and bright colors, 16-231 are 216 color cube, 232-255 are grayscale
+            if 0 <= color <= 255:
+                return f'{"48" if is_background else "38"};5;{color}'
+
+        elif isinstance(color, tuple) and len(color) == 3:
+            # RGB color (true color / 24-bit)
+            try:
+                r, g, b = color
+                # Ensure values are in valid range
+                r = max(0, min(255, int(r)))
+                g = max(0, min(255, int(g)))
+                b = max(0, min(255, int(b)))
+                return f'{"48" if is_background else "38"};2;{r};{g};{b}'
+            except (ValueError, TypeError):
+                logger.warning("Invalid RGB color tuple: %s", color)
+                return None
+
+        # If we got here, we don't recognize the color format
+        logger.info("PYTE_COLOR_DEBUG: Unrecognized color format - type: %s, value: %r, is_bg: %s",
+                   type(color).__name__, color, is_background)
+        return None
 
     async def reattach_channel(self, new_channel: "Channel") -> None:
         """Reattach this session to a new channel after reconnection."""
@@ -475,6 +694,7 @@ class SessionManager:
             try:
                 import pty
                 master_fd, slave_fd = pty.openpty()
+                _configure_pty_window_size(slave_fd, TERMINAL_ROWS, TERMINAL_COLUMNS)
                 proc = await asyncio.create_subprocess_exec(
                     shell,
                     stdin=slave_fd,

{portacode-1.3.32.dist-info → portacode-1.3.33.dist-info}/METADATA

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

{portacode-1.3.32.dist-info → portacode-1.3.33.dist-info}/RECORD

@@ -1,7 +1,7 @@
 portacode/README.md,sha256=4dKtpvR8LNgZPVz37GmkQCMWIr_u25Ao63iW56s7Ke4,775
 portacode/__init__.py,sha256=oB3sV1wXr-um-RXio73UG8E5Xx6cF2ZVJveqjNmC-vQ,1086
 portacode/__main__.py,sha256=jmHTGC1hzmo9iKJLv-SSYe9BSIbPPZ2IOpecI03PlTs,296
-portacode/_version.py,sha256=d_JbLCEf2f0Y5ScYYYOP97vUKSwyr-VyTj2aQkfr7KU,706
+portacode/_version.py,sha256=nJBSGzQLAZMH96LyzR0NHlWYQsAa05C0c2ZTZZIV0ss,706
 portacode/cli.py,sha256=eDqcZMVFHKzqqWxedhhx8ylu5WMVCLqeJQkbPR7RcJE,16333
 portacode/data.py,sha256=5-s291bv8J354myaHm1Y7CQZTZyRzMU3TGe5U4hb-FA,1591
 portacode/keypair.py,sha256=PAcOYqlVLOoZTPYi6LvLjfsY6BkrWbLOhSZLb8r5sHs,3635
@@ -21,14 +21,14 @@ portacode/connection/handlers/file_handlers.py,sha256=kBj-o3HkqZTKsju2ZxRgBB3Ke4
 portacode/connection/handlers/project_aware_file_handlers.py,sha256=n0M2WmBNWPwzigdIkyZiAsePUQGXVqYSsDyOxm-Nsok,9253
 portacode/connection/handlers/project_state_handlers.py,sha256=v6ZefGW9i7n1aZLq2jOGumJIjYb6aHlPI4m1jkYewm8,1686
 portacode/connection/handlers/registry.py,sha256=qXGE60sYEWg6ZtVQzFcZ5YI2XWR6lMgw4hAL9x5qR1I,6181
-portacode/connection/handlers/session.py,sha256=O7TMI5cRziOiXEBWCfBshkMpEthhjvKqGL0hhNOG1wU,26716
+portacode/connection/handlers/session.py,sha256=XWiD4dofzZB9AH7EDqbWeJ-1CrSNPCUTR2nE2UEZh7Y,35568
 portacode/connection/handlers/system_handlers.py,sha256=65V5ctT0dIBc-oWG91e62MbdvU0z6x6JCTQuIqCWmZ0,5242
 portacode/connection/handlers/tab_factory.py,sha256=VBZnwtxgeNJCsfBzUjkFWAAGBdijvai4MS2dXnhFY8U,18000
 portacode/connection/handlers/terminal_handlers.py,sha256=HRwHW1GiqG1NtHVEqXHKaYkFfQEzCDDH6YIlHcb4XD8,11866
 portacode/connection/handlers/project_state/README.md,sha256=trdd4ig6ungmwH5SpbSLfyxbL-QgPlGNU-_XrMEiXtw,10114
 portacode/connection/handlers/project_state/__init__.py,sha256=5ucIqk6Iclqg6bKkL8r_wVs5Tlt6B9J7yQH6yQUt7gc,2541
 portacode/connection/handlers/project_state/file_system_watcher.py,sha256=2zingW9BoNKRijghHC2eHHdRoyDRdLmIl1yH1y-iuF8,10831
-portacode/connection/handlers/project_state/git_manager.py,sha256=tVcuiGYKk1GJ0f7dgjoSGNL13IXCHUOtoi_VBc8ZTqQ,88682
+portacode/connection/handlers/project_state/git_manager.py,sha256=GO0AEXzHEaKOBGZP043_V2KgGz8zqmSahWJ5KHgC_Cs,88845
 portacode/connection/handlers/project_state/handlers.py,sha256=nhs-3yiENdewAzVZnSdn2Ir-e6TQ9Nz_Bxk3iiFPd9c,37985
 portacode/connection/handlers/project_state/manager.py,sha256=XX3wMgGdPbRgBBs_R1dXtQ4D9j-itETrJR_6IfBeDU0,61296
 portacode/connection/handlers/project_state/models.py,sha256=EZTKvxHKs8QlQUbzI0u2IqfzfRRXZixUIDBwTGCJATI,4313
@@ -38,7 +38,7 @@ portacode/static/js/utils/ntp-clock.js,sha256=KMeHGT-IlUSlxVRZZ899z25dQCJh6EJbgX
 portacode/utils/NTP_ARCHITECTURE.md,sha256=WkESTbz5SNAgdmDKk3DrHMhtYOPji_Kt3_a9arWdRig,3894
 portacode/utils/__init__.py,sha256=NgBlWTuNJESfIYJzP_3adI1yJQJR0XJLRpSdVNaBAN0,33
 portacode/utils/ntp_clock.py,sha256=6QJOVZr9VQuxIyJt9KNG4dR-nZ3bKNyipMxjqDWP89Y,5152
-portacode-1.3.32.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
+portacode-1.3.33.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
 test_modules/README.md,sha256=Do_agkm9WhSzueXjRAkV_xEj6Emy5zB3N3VKY5Roce8,9274
 test_modules/__init__.py,sha256=1LcbHodIHsB0g-g4NGjSn6AMuCoGbymvXPYLOb6Z7F0,53
 test_modules/test_device_online.py,sha256=yiSyVaMwKAugqIX_ZIxmLXiOlmA_8IRXiUp12YmpB98,1653
@@ -63,8 +63,8 @@ testing_framework/core/playwright_manager.py,sha256=8xl-19b8NQjKNdiRyDjyeXlYyKPZ
 testing_framework/core/runner.py,sha256=j2QwNJmAxVBmJvcbVS7DgPJUKPNzqfLmt_4NNdaKmZU,19297
 testing_framework/core/shared_cli_manager.py,sha256=BESSNtyQb7BOlaOvZmm04T8Uezjms4KCBs2MzTxvzYQ,8790
 testing_framework/core/test_discovery.py,sha256=2FZ9fJ8Dp5dloA-fkgXoJ_gCMC_nYPBnA3Hs2xlagzM,4928
-portacode-1.3.32.dist-info/METADATA,sha256=rTf7KoQ6JhbUqq_aOd-8ASc7UfR53vtrxdaLQ-ANsZ8,6989
-portacode-1.3.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-portacode-1.3.32.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
-portacode-1.3.32.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
-portacode-1.3.32.dist-info/RECORD,,
+portacode-1.3.33.dist-info/METADATA,sha256=pSZ7HgbTSK_h7QT8gblUhywYF5EWMed_z_17PL_i2Ss,6989
+portacode-1.3.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+portacode-1.3.33.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
+portacode-1.3.33.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
+portacode-1.3.33.dist-info/RECORD,,