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

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

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

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

@@ -908,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.
@@ -915,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'],
@@ -942,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():
@@ -1078,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.
 
@@ -1108,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.3.0 → devs_common-3.3.1}/devs_common.egg-info/PKG-INFO

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

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

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