devs-common 3.2.4__tar.gz → 3.3.1__tar.gz

{devs_common-3.2.4 → devs_common-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-common
-Version: 3.2.4
+Version: 3.3.1
 Summary: Shared utilities for devs package ecosystem
 Author: Dan Lester
 License-Expression: MIT

{devs_common-3.2.4 → devs_common-3.3.1}/devs_common/core/container.py

@@ -40,7 +40,7 @@ from ..utils.docker_client import DockerClient
 from ..utils.devcontainer import DevContainerCLI
 from ..utils.devcontainer_template import get_template_dir
 from ..utils.console import get_console
-from ..utils.config_hash import compute_env_config_hash, get_env_mount_path
+from ..utils.config_hash import compute_env_config_hash, compute_devcontainer_hash, get_env_mount_path
 from .project import Project
 
 # Initialize console based on environment
@@ -138,100 +138,84 @@ class ContainerManager:
         
         return labels
     
-    def should_rebuild_image(self, dev_name: str) -> Tuple[bool, str]:
-        """Check if devcontainer image should be rebuilt.
-        
+    def should_rebuild_image(self, dev_name: str, project_labels: dict) -> Tuple[bool, str]:
+        """Check if devcontainer image should be rebuilt based on content hash.
+
+        Compares the content hash of devcontainer files against the hash stored
+        in the existing container's label. This avoids false positives from fresh
+        checkouts, rebases, or other operations that update file timestamps without
+        changing the actual content.
+
         Args:
             dev_name: Development environment name
-            
+            project_labels: Labels used to find the existing container
+
         Returns:
             Tuple of (should_rebuild, reason)
         """
         try:
-            # Find existing images for this devcontainer configuration
-            image_pattern = f"vsc-{self.project.get_workspace_name(dev_name)}-"
-            existing_images = self.docker.find_images_by_pattern(image_pattern)
-            
-            if not existing_images:
-                return False, "No existing image found"
-            
-            # Get the newest image creation time
-            newest_image_time = None
-            for image_name in existing_images:
-                image_time = self.docker.get_image_creation_time(image_name)
-                if image_time and (not newest_image_time or image_time > newest_image_time):
-                    newest_image_time = image_time
-            
-            if not newest_image_time:
-                return False, "Could not determine image age"
-            
-            # Check if devcontainer-related files are newer than the image
-            devcontainer_files = [
-                self.project.project_dir / ".devcontainer",
-                self.project.project_dir / "Dockerfile", 
-                self.project.project_dir / "docker-compose.yml",
-                self.project.project_dir / "docker-compose.yaml",
-            ]
-            
-            for file_path in devcontainer_files:
-                if file_path.exists():
-                    if file_path.is_file():
-                        file_time = datetime.fromtimestamp(file_path.stat().st_mtime, tz=timezone.utc)
-                        if file_time > newest_image_time:
-                            return True, f"File newer than image: {file_path.name}"
-                    elif file_path.is_dir():
-                        # For directories, find the newest file
-                        newest_file_time = None
-                        newest_file = None
-                        
-                        for item in file_path.rglob('*'):
-                            if item.is_file():
-                                item_time = datetime.fromtimestamp(item.stat().st_mtime, tz=timezone.utc)
-                                if not newest_file_time or item_time > newest_file_time:
-                                    newest_file_time = item_time
-                                    newest_file = item
-                        
-                        if newest_file_time and newest_file_time > newest_image_time:
-                            return True, f"File newer than image: {newest_file}"
-            
-            return False, "Image is up to date"
-            
+            current_hash = compute_devcontainer_hash(self.project.project_dir)
+
+            # Look for an existing container to compare against
+            existing_containers = self.docker.find_containers_by_labels(project_labels)
+            if not existing_containers:
+                return False, "No existing container to compare against"
+
+            existing_container = existing_containers[0]
+            existing_labels = existing_container.get('labels', {})
+            stored_hash = existing_labels.get('devs.devcontainer-hash', '')
+
+            if not stored_hash:
+                # No hash stored yet — don't trigger a rebuild speculatively
+                return False, "No devcontainer hash label on existing container"
+
+            if stored_hash != current_hash:
+                return True, f"Devcontainer files changed ({stored_hash} → {current_hash})"
+
+            return False, "Devcontainer files unchanged"
+
         except (DockerError, OSError) as e:
             console.print(f"[yellow]Warning: Could not check image rebuild status: {e}[/yellow]")
             return False, "Could not determine rebuild status"
     
     def ensure_container_running(
-        self, 
+        self,
         dev_name: str,
         workspace_dir: Path,
         force_rebuild: bool = False,
+        check_rebuild: bool = True,
         debug: bool = False,
         live: bool = False,
         extra_env: Optional[Dict[str, str]] = None
     ) -> bool:
         """Ensure a container is running for the specified dev environment.
-        
+
         Args:
             dev_name: Development environment name
             workspace_dir: Workspace directory path
             force_rebuild: Force rebuild even if not needed
+            check_rebuild: Automatically rebuild if devcontainer files have changed.
+                Set to False (e.g. for the CLI) to only rebuild when force_rebuild=True.
             debug: Show debug output for devcontainer operations
             live: Whether to use live mode (mount current directory instead of copying)
             extra_env: Additional environment variables to pass to container
-            
+
         Returns:
             True if container is running successfully
-            
+
         Raises:
             ContainerError: If container operations fail
         """
         workspace_info = self._get_container_info(dev_name, live)
         container_name = workspace_info["container_name"]
         project_labels = self._get_project_labels(dev_name, live)
-        
+
         try:
             # Check if we need to rebuild
-            rebuild_needed, rebuild_reason = self.should_rebuild_image(dev_name)
+            if check_rebuild:
+                rebuild_needed, rebuild_reason = self.should_rebuild_image(dev_name, project_labels)
+            else:
+                rebuild_needed, rebuild_reason = False, "Auto-rebuild disabled"
             if rebuild_needed or force_rebuild:
                 if force_rebuild:
                     console.print(f"   🔄 Forcing image rebuild for {dev_name}...")
@@ -248,9 +232,10 @@ class ContainerManager:
                         console.print(f"[dim]Removing container: {existing_container['name']}[/dim]")
                     self.docker.remove_container(existing_container['name'])
             
-            # Compute current config hash for comparison
+            # Compute current config hashes for comparison
             env_mount_path = get_env_mount_path(self.project.info.name)
             current_config_hash = compute_env_config_hash(self.project.info.name)
+            current_devcontainer_hash = compute_devcontainer_hash(self.project.project_dir)
             console.print(f"   📁 Env mount: {env_mount_path} (hash: {current_config_hash})")
 
             # Check if container is already running
@@ -267,13 +252,19 @@ class ContainerManager:
 
                 console.print(f"   🔍 Found container: {existing_container['name']} (status: {existing_container['status']}, hash: {existing_config_hash or 'none'})")
 
-                # Check if config hash has changed
+                # Check if config hash has changed (only when auto-rebuild checks are enabled)
                 if existing_config_hash and existing_config_hash != current_config_hash:
-                    config_hash_changed = True
-                    console.print(f"   🔄 Config hash changed ({existing_config_hash} → {current_config_hash}), will restart container")
-                elif not existing_config_hash:
-                    console.print(f"   ⚠️  Container has no config hash label, will restart to add it")
-                    config_hash_changed = True
+                    if check_rebuild:
+                        config_hash_changed = True
+                        console.print(f"   🔄 Config hash changed ({existing_config_hash} → {current_config_hash}), will restart container")
+                    else:
+                        console.print(f"   ℹ️  Env config has changed since container was created — use --rebuild-if-changed to restart")
+
+                # Check devcontainer hash when not rebuilding, to inform user of changes
+                if not check_rebuild:
+                    existing_devcontainer_hash = existing_labels.get('devs.devcontainer-hash', '')
+                    if existing_devcontainer_hash and existing_devcontainer_hash != current_devcontainer_hash:
+                        console.print(f"   ℹ️  Devcontainer files have changed since image was built — use --rebuild-if-changed to rebuild")
 
                 # Check if existing container matches the requested mode
                 if existing_is_live != live:
@@ -335,7 +326,8 @@ class ContainerManager:
                 config_path=config_path,
                 live=live,
                 extra_env=extra_env,
-                config_hash=current_config_hash
+                config_hash=current_config_hash,
+                devcontainer_hash=current_devcontainer_hash
             )
             
             if not success:
@@ -628,8 +620,8 @@ class ContainerManager:
                 console.print(f"   ▶️  Starting stopped container: {container_id}")
                 self.docker.start_container(container_id)
         else:
-            # Ensure container is running (may create/restart as needed)
-            if not self.ensure_container_running(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env):
+            # Ensure container is running (may create/restart as needed, but never auto-rebuild)
+            if not self.ensure_container_running(dev_name, workspace_dir, check_rebuild=False, debug=debug, live=live, extra_env=extra_env):
                 raise ContainerError(f"Failed to start container for {dev_name}")
 
         return container_name, container_workspace_dir
@@ -916,6 +908,22 @@ class ContainerManager:
             console.print("[yellow]Authentication was cancelled or failed.[/yellow]")
             return False
 
+    def _kill_tunnel_processes(self, container_name: str) -> None:
+        """Kill all tunnel processes in the container.
+
+        Uses pkill to ensure detached shell wrappers and tunnel processes
+        are fully terminated, not just the service-level shutdown that
+        'code tunnel kill' provides.
+        """
+        subprocess.run(
+            ['docker', 'exec', container_name, '/usr/local/bin/code', 'tunnel', 'kill'],
+            capture_output=True
+        )
+        subprocess.run(
+            ['docker', 'exec', container_name, 'pkill', '-f', 'code tunnel'],
+            capture_output=True
+        )
+
     def _start_and_poll_tunnel(self, container_name: str, dev_name: str, tunnel_cmd: str,
                                log_file: str, vscode_cmd: str, web_url: str, debug: bool = False) -> bool:
         """Start a detached tunnel and poll the log for startup confirmation.
@@ -923,6 +931,14 @@ class ContainerManager:
         Returns:
             True if tunnel started (or timed out), False if auth is needed.
         """
+        # Kill any stale tunnel processes and clear the log before starting
+        self._kill_tunnel_processes(container_name)
+        subprocess.run(
+            ['docker', 'exec', container_name, '/bin/sh', '-c', f'> {log_file}'],
+            capture_output=True
+        )
+        time.sleep(1)
+
         subprocess.run(
             ['docker', 'exec', '-d', container_name,
              '/bin/sh', '-c', f'{tunnel_cmd} > {log_file} 2>&1'],
@@ -950,10 +966,7 @@ class ContainerManager:
                 return True
 
             if 'log in' in output.lower() or 'device' in output.lower() or 'invalid' in output.lower():
-                subprocess.run(
-                    ['docker', 'exec', container_name, '/usr/local/bin/code', 'tunnel', 'kill'],
-                    capture_output=True
-                )
+                self._kill_tunnel_processes(container_name)
                 return False
 
             if debug and output.strip():
@@ -1086,14 +1099,92 @@ class ContainerManager:
 
             result = subprocess.run(cmd, capture_output=True, text=True)
 
+            # Get auth info (logged in user/provider)
+            user_result = subprocess.run(
+                ['docker', 'exec', container_name,
+                 '/usr/local/bin/code', 'tunnel', 'user', 'show'],
+                capture_output=True, text=True
+            )
+            auth_info = user_result.stdout.strip() if user_result.returncode == 0 else None
+
             if result.returncode == 0:
-                return True, result.stdout.strip()
+                raw = result.stdout.strip()
+                return True, self._format_tunnel_status(raw, dev_name, auth_info)
             else:
                 return False, result.stderr.strip() if result.stderr else "No tunnel running"
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to get tunnel status in {dev_name}: {e}")
 
+    def _format_tunnel_status(self, raw_json: str, dev_name: str, auth_info: Optional[str] = None) -> str:
+        """Format tunnel status JSON into human-readable output."""
+        import json
+        try:
+            data = json.loads(raw_json)
+        except json.JSONDecodeError:
+            return raw_json
+
+        tunnel = data.get("tunnel")
+        if not tunnel:
+            lines = ["[dim]● No tunnel running[/dim]"]
+            if auth_info:
+                lines.append(f"   Auth: {auth_info}")
+            return "\n".join(lines)
+        name = tunnel.get("name") or "unknown"
+        state = tunnel.get("tunnel", "Unknown")
+        started_at = tunnel.get("started_at")
+        connected_at = tunnel.get("last_connected_at")
+        disconnected_at = tunnel.get("last_disconnected_at")
+        fail_reason = tunnel.get("last_fail_reason")
+
+        lines = []
+
+        # Status line with color
+        if state == "Connected":
+            lines.append(f"[bold green]● Connected[/bold green]  ({name})")
+        elif state == "Disconnected":
+            lines.append(f"[bold red]● Disconnected[/bold red]  ({name})")
+        else:
+            lines.append(f"[bold yellow]● {state}[/bold yellow]  ({name})")
+
+        # Timestamps
+        if started_at:
+            lines.append(f"   Started:      {self._format_timestamp(started_at)}")
+        if connected_at:
+            lines.append(f"   Connected:    {self._format_timestamp(connected_at)}")
+        if disconnected_at:
+            lines.append(f"   Disconnected: {self._format_timestamp(disconnected_at)}")
+        if fail_reason:
+            lines.append(f"   Fail reason:  {fail_reason}")
+        if auth_info:
+            lines.append(f"   Auth:         {auth_info}")
+
+        # Connection info when connected
+        if state == "Connected":
+            tunnel_name = self._get_tunnel_name(dev_name)
+            lines.append("")
+            lines.append("[bold]Connect:[/bold]")
+            lines.append(f"   Desktop:  code --remote tunnel+{tunnel_name}")
+            lines.append(f"   Browser:  https://vscode.dev/tunnel/{tunnel_name}")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def _format_timestamp(ts: str) -> str:
+        """Format an ISO timestamp into a friendly local time string."""
+        from datetime import datetime
+        try:
+            # Handle nanosecond precision by truncating to microseconds
+            if "." in ts:
+                base, frac = ts.split(".")
+                frac = frac.rstrip("Z")[:6]
+                ts = f"{base}.{frac}Z"
+            dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+            local_dt = dt.astimezone()
+            return local_dt.strftime("%H:%M:%S %Z")
+        except (ValueError, TypeError):
+            return ts
+
     def kill_tunnel(self, dev_name: str, workspace_dir: Path, debug: bool = False, live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> bool:
         """Kill a running VS Code tunnel in the container.
 
@@ -1116,24 +1207,13 @@ class ContainerManager:
                 dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
             )
 
-            # Kill the tunnel
-            cmd = [
-                'docker', 'exec',
-                container_name,
-                '/usr/local/bin/code', 'tunnel', 'kill'
-            ]
-
+            # Kill the tunnel (both service-level and process-level)
             if debug:
-                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
-
-            result = subprocess.run(cmd, capture_output=True, text=True)
+                console.print(f"[dim]Killing tunnel processes in {container_name}[/dim]")
 
-            if result.returncode == 0:
-                console.print(f"   Tunnel killed in: {dev_name}")
-                return True
-            else:
-                console.print(f"   No tunnel to kill in: {dev_name}")
-                return False
+            self._kill_tunnel_processes(container_name)
+            console.print(f"   Tunnel killed in: {dev_name}")
+            return True
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to kill tunnel in {dev_name}: {e}")

{devs_common-3.2.4 → devs_common-3.3.1}/devs_common/utils/config_hash.py

@@ -39,11 +39,60 @@ def compute_env_config_hash(project_name: str) -> str:
         Short hash string (first 12 chars of SHA256)
     """
     env_path = get_env_mount_path(project_name)
-    return _hash_directory_mtimes(env_path)
+    return _hash_directory_contents(env_path)
 
 
-def _hash_directory_mtimes(directory: Path) -> str:
-    """Hash mtimes of all files in a directory.
+def compute_devcontainer_hash(project_dir: Path) -> str:
+    """Compute a content hash of devcontainer-related files.
+
+    Uses file contents (not mtimes) so that fresh checkouts or rebases that
+    don't change the actual devcontainer files produce the same hash.
+
+    Args:
+        project_dir: Root directory of the project
+
+    Returns:
+        Short hash string (first 12 chars of SHA256)
+    """
+    hasher = hashlib.sha256()
+
+    devcontainer_paths = [
+        project_dir / ".devcontainer",
+        project_dir / "Dockerfile",
+        project_dir / "docker-compose.yml",
+        project_dir / "docker-compose.yaml",
+    ]
+
+    found_any = False
+    try:
+        for path in devcontainer_paths:
+            if not path.exists():
+                continue
+            found_any = True
+            if path.is_file():
+                rel = path.relative_to(project_dir)
+                hasher.update(str(rel).encode())
+                hasher.update(path.read_bytes())
+            elif path.is_dir():
+                for item in sorted(path.rglob("*")):
+                    if item.is_file():
+                        rel = item.relative_to(project_dir)
+                        hasher.update(str(rel).encode())
+                        hasher.update(item.read_bytes())
+    except (OSError, PermissionError):
+        hasher.update(b"error")
+
+    if not found_any:
+        hasher.update(b"no-devcontainer")
+
+    return hasher.hexdigest()[:12]
+
+
+def _hash_directory_contents(directory: Path) -> str:
+    """Hash the contents of all files in a directory.
+
+    Uses file contents rather than mtimes so that fresh checkouts or rebases
+    that don't change actual file content produce the same hash.
 
     Args:
         directory: Directory to hash
@@ -65,10 +114,10 @@ def _hash_directory_mtimes(directory: Path) -> str:
         files = sorted(directory.rglob("*"))
         for file_path in files:
             if file_path.is_file():
-                # Include relative path and mtime in hash
+                # Include relative path and file contents in hash
                 rel_path = file_path.relative_to(directory)
-                mtime = file_path.stat().st_mtime
-                hasher.update(f"{rel_path}:{mtime}".encode())
+                hasher.update(str(rel_path).encode())
+                hasher.update(file_path.read_bytes())
     except (OSError, PermissionError):
         hasher.update(b"error")
 

{devs_common-3.2.4 → devs_common-3.3.1}/devs_common/utils/devcontainer.py

@@ -238,10 +238,11 @@ class DevContainerCLI:
         config_path: Optional[Path] = None,
         live: bool = False,
         extra_env: Optional[dict] = None,
-        config_hash: Optional[str] = None
+        config_hash: Optional[str] = None,
+        devcontainer_hash: Optional[str] = None
     ) -> bool:
         """Start a devcontainer.
-        
+
         Args:
             workspace_folder: Path to workspace folder on host
             dev_name: Development environment name
@@ -254,7 +255,8 @@ class DevContainerCLI:
             config_path: Optional path to external devcontainer config directory
             live: Whether to use live mode (mount current directory)
             extra_env: Additional environment variables to pass to container
-            config_hash: Optional hash of config files for detecting changes
+            config_hash: Optional hash of env config files for detecting changes
+            devcontainer_hash: Optional content hash of devcontainer files for rebuild detection
 
         Returns:
             True if successful
@@ -291,6 +293,10 @@ class DevContainerCLI:
             if config_hash:
                 cmd.extend(['--id-label', f'devs.config-hash={config_hash}'])
 
+            # Add devcontainer content hash label for rebuild detection
+            if devcontainer_hash:
+                cmd.extend(['--id-label', f'devs.devcontainer-hash={devcontainer_hash}'])
+
             # Add extra container labels from config if provided
             if self.config and hasattr(self.config, 'container_labels'):
                 for k, v in self.config.container_labels.items():

{devs_common-3.2.4 → devs_common-3.3.1}/devs_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-common
-Version: 3.2.4
+Version: 3.3.1
 Summary: Shared utilities for devs package ecosystem
 Author: Dan Lester
 License-Expression: MIT

{devs_common-3.2.4 → devs_common-3.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devs-common"
-version = "3.2.4"
+version = "3.3.1"
 description = "Shared utilities for devs package ecosystem"
 authors = [
     {name = "Dan Lester"},