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

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

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

devs_common-3.3.2/devs_common/core/__init__.py

@@ -0,0 +1,22 @@
+"""Core classes for devs ecosystem."""
+
+from .project import Project, ProjectInfo
+from .workspace import WorkspaceManager
+from .container import (
+    ContainerManager,
+    ContainerInfo,
+    make_tunnel_name,
+    get_container_workspace_dir,
+    kill_tunnel_processes,
+)
+
+__all__ = [
+    "Project",
+    "ProjectInfo",
+    "WorkspaceManager",
+    "ContainerManager",
+    "ContainerInfo",
+    "make_tunnel_name",
+    "get_container_workspace_dir",
+    "kill_tunnel_processes",
+]

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

@@ -47,6 +47,55 @@ from .project import Project
 console = get_console()
 
 
+def make_tunnel_name(container_name: str) -> str:
+    """Derive a VS Code tunnel name from a container name (max 20 chars).
+
+    VS Code tunnel names have a 20 character limit. We keep the dev name
+    suffix and shorten the project portion if needed.
+
+    Container names are like dev-ideonate-devs-sally.
+    """
+    name = container_name.replace(".", "-").replace("_", "-")
+    if len(name) <= 20:
+        return name
+    # Keep the last segment (dev name) and truncate the rest
+    parts = name.rsplit("-", 1)
+    if len(parts) == 2:
+        suffix = f"-{parts[1]}"
+        budget = 20 - len(suffix)
+        if budget >= 3:
+            return parts[0][:budget].rstrip("-") + suffix
+    return name[:20]
+
+
+def get_container_workspace_dir(container_name: str) -> str:
+    """Derive the workspace path inside a container from its name.
+
+    Container name 'dev-ideonate-devs-bob' -> '/workspaces/ideonate-devs-bob'.
+    """
+    if container_name.startswith("dev-"):
+        workspace_name = container_name[4:]
+    else:
+        workspace_name = container_name
+    return f"/workspaces/{workspace_name}"
+
+
+def kill_tunnel_processes(container_name: str) -> None:
+    """Kill all tunnel processes in a container.
+
+    Uses both 'code tunnel kill' (service-level) and pkill (process-level)
+    to ensure detached shell wrappers and tunnel processes are fully terminated.
+    """
+    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
+    )
+
+
 class ContainerInfo:
     """Information about a devcontainer."""
     
@@ -852,27 +901,11 @@ class ContainerManager:
         )
 
     def _get_tunnel_name(self, dev_name: str) -> str:
-        """Generate a VS Code tunnel name, truncated to 20 chars.
-
-        VS Code tunnel names have a 20 character limit. We keep the dev name
-        suffix and shorten the project portion if needed.
-        """
-        project_prefix = self.config.project_prefix if self.config else "dev"
-        tunnel_name = f"{project_prefix}-{self.project.info.name}-{dev_name}"
-        # Sanitize: tunnel names can only contain alphanumeric, dash, underscore
-        tunnel_name = tunnel_name.replace(".", "-").replace("_", "-")
-
-        if len(tunnel_name) > 20:
-            suffix = f"-{dev_name}"
-            prefix_budget = 20 - len(suffix)
-            if prefix_budget >= 3:
-                project_part = f"{project_prefix}-{self.project.info.name}"
-                project_part = project_part[:prefix_budget].rstrip("-")
-                tunnel_name = f"{project_part}{suffix}"
-            else:
-                tunnel_name = tunnel_name[:20]
-
-        return tunnel_name
+        """Generate a VS Code tunnel name for this project/dev combo."""
+        container_name = self.project.get_container_name(
+            dev_name, self.config.project_prefix if self.config else "dev"
+        )
+        return make_tunnel_name(container_name)
 
     def _run_tunnel_auth(self, container_name: str, debug: bool = False) -> bool:
         """Run interactive VS Code tunnel authentication in a container.
@@ -908,20 +941,31 @@ class ContainerManager:
             console.print("[yellow]Authentication was cancelled or failed.[/yellow]")
             return False
 
-    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:
+    def _kill_tunnel_processes(self, container_name: str) -> None:
+        """Kill all tunnel processes in the container."""
+        kill_tunnel_processes(container_name)
+
+    def _start_and_poll_tunnel(self, container_name: str, tunnel_cmd: str,
+                               log_file: str, debug: bool = False) -> dict:
         """Start a detached tunnel and poll the log for startup confirmation.
 
         Returns:
-            True if tunnel started (or timed out), False if auth is needed.
+            Dict with 'status' key: 'running', 'auth_required', or 'starting'.
         """
+        # 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'],
             check=True
         )
 
-        console.print("[dim]Waiting for tunnel to start...[/dim]")
         for i in range(15):
             time.sleep(1)
             result = subprocess.run(
@@ -931,22 +975,11 @@ class ContainerManager:
             output = result.stdout
 
             if 'Open this link' in output or 'vscode.dev/tunnel' in output:
-                console.print(f"[bold green]Tunnel running![/bold green]")
-                console.print("")
-                console.print("[bold]Connect:[/bold]")
-                console.print(f"   Desktop:  {vscode_cmd}")
-                console.print(f"   Browser:  {web_url}")
-                console.print("")
-                console.print(f"[dim]Use 'devs tunnel {dev_name} --status' to check status[/dim]")
-                console.print(f"[dim]Use 'devs tunnel {dev_name} --kill' to stop[/dim]")
-                return True
+                return {'status': 'running'}
 
             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
-                )
-                return False
+                self._kill_tunnel_processes(container_name)
+                return {'status': 'auth_required'}
 
             if debug and output.strip():
                 console.print(f"[dim]Log ({i+1}s): {output.strip()[-100:]}[/dim]")
@@ -956,16 +989,30 @@ class ContainerManager:
             ['docker', 'exec', container_name, 'cat', log_file],
             capture_output=True, text=True
         )
-        if result.stdout.strip():
-            console.print("[yellow]Tunnel may still be starting. Log output:[/yellow]")
-            console.print(result.stdout.strip())
-        else:
-            console.print("[yellow]Tunnel started but no output yet. Check status with:[/yellow]")
-        console.print(f"   devs tunnel {dev_name} --status")
-        return True
+        return {'status': 'starting', 'log': result.stdout.strip()}
+
+    def get_tunnel_info(self, dev_name: str, workspace_dir: Path, debug: bool = False,
+                        live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> dict:
+        """Get tunnel connection info (names, paths) without starting anything.
+
+        Returns:
+            Dict with container_name, tunnel_name, container_workspace_dir,
+            vscode_cmd, web_url.
+        """
+        container_name, container_workspace_dir = self._prepare_container_exec(
+            dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
+        )
+        tunnel_name = self._get_tunnel_name(dev_name)
+        return {
+            'container_name': container_name,
+            'tunnel_name': tunnel_name,
+            'container_workspace_dir': container_workspace_dir,
+            'vscode_cmd': f"code --remote tunnel+{tunnel_name} {container_workspace_dir}",
+            'web_url': f"https://vscode.dev/tunnel/{tunnel_name}{container_workspace_dir}",
+        }
 
     def tunnel_auth(self, dev_name: str, workspace_dir: Path, debug: bool = False, live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> None:
-        """Authenticate VS Code tunnel (interactive, per-container setup).
+        """Authenticate VS Code tunnel (interactive CLI, per-container setup).
 
         Args:
             dev_name: Development environment name
@@ -978,26 +1025,22 @@ class ContainerManager:
             ContainerError: If authentication fails
         """
         try:
-            container_name, container_workspace_dir = self._prepare_container_exec(
-                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
-            )
-
-            tunnel_name = self._get_tunnel_name(dev_name)
+            info = self.get_tunnel_info(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env)
 
             console.print("🔐 Setting up VS Code tunnel authentication...")
-            console.print(f"   Container: {container_name}")
+            console.print(f"   Container: {info['container_name']}")
             console.print("")
 
-            if self._run_tunnel_auth(container_name, debug=debug):
+            if self._run_tunnel_auth(info['container_name'], debug=debug):
                 console.print("")
                 console.print(f"   Start a tunnel:  devs tunnel {dev_name}")
-                console.print(f"   Then connect:    code --remote tunnel+{tunnel_name} {container_workspace_dir}")
+                console.print(f"   Then connect:    {info['vscode_cmd']}")
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to authenticate tunnel in {dev_name}: {e}")
 
     def start_tunnel(self, dev_name: str, workspace_dir: Path, debug: bool = False, live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> None:
-        """Start a VS Code tunnel in the background.
+        """Start a VS Code tunnel in the background (CLI version with interactive auth).
 
         If authentication is needed, prompts interactively then retries.
 
@@ -1012,90 +1055,191 @@ class ContainerManager:
             ContainerError: If tunnel startup fails
         """
         try:
-            container_name, container_workspace_dir = self._prepare_container_exec(
-                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
-            )
-
-            tunnel_name = self._get_tunnel_name(dev_name)
+            info = self.get_tunnel_info(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env)
+            container_name = info['container_name']
+            tunnel_name = info['tunnel_name']
             log_file = '/tmp/vscode-tunnel.log'
             tunnel_cmd = f'/usr/local/bin/code tunnel --accept-server-license-terms --name {tunnel_name}'
-            vscode_cmd = f"code --remote tunnel+{tunnel_name} {container_workspace_dir}"
-            web_url = f"https://vscode.dev/tunnel/{tunnel_name}{container_workspace_dir}"
 
             console.print(f"[bold cyan]Starting VS Code tunnel for: {dev_name}[/bold cyan]")
             console.print(f"   Container: {container_name}")
             console.print(f"   Tunnel name: {tunnel_name}")
             console.print("")
 
-            if not self._start_and_poll_tunnel(container_name, dev_name, tunnel_cmd,
-                                               log_file, vscode_cmd, web_url, debug=debug):
-                # Auth needed
+            result = self._start_and_poll_tunnel(container_name, tunnel_cmd, log_file, debug=debug)
+
+            if result['status'] == 'running':
+                console.print(f"[bold green]Tunnel running![/bold green]")
+                console.print("")
+                console.print("[bold]Connect:[/bold]")
+                console.print(f"   Desktop:  {info['vscode_cmd']}")
+                console.print(f"   Browser:  {info['web_url']}")
+                console.print("")
+                console.print(f"[dim]Use 'devs tunnel {dev_name} --status' to check status[/dim]")
+                console.print(f"[dim]Use 'devs tunnel {dev_name} --kill' to stop[/dim]")
+            elif result['status'] == 'auth_required':
                 console.print("[yellow]Authentication required. Starting login...[/yellow]")
                 console.print("")
                 if not self._run_tunnel_auth(container_name, debug=debug):
                     return
-
                 console.print("")
                 console.print("[dim]Restarting tunnel...[/dim]")
                 console.print("")
-                self._start_and_poll_tunnel(container_name, dev_name, tunnel_cmd,
-                                            log_file, vscode_cmd, web_url, debug=debug)
+                retry = self._start_and_poll_tunnel(container_name, tunnel_cmd, log_file, debug=debug)
+                if retry['status'] == 'running':
+                    console.print(f"[bold green]Tunnel running![/bold green]")
+                    console.print("")
+                    console.print("[bold]Connect:[/bold]")
+                    console.print(f"   Desktop:  {info['vscode_cmd']}")
+                    console.print(f"   Browser:  {info['web_url']}")
+                    console.print("")
+                    console.print(f"[dim]Use 'devs tunnel {dev_name} --status' to check status[/dim]")
+                    console.print(f"[dim]Use 'devs tunnel {dev_name} --kill' to stop[/dim]")
+                else:
+                    log = retry.get('log', '')
+                    if log:
+                        console.print("[yellow]Tunnel may still be starting. Log output:[/yellow]")
+                        console.print(log)
+                    console.print(f"   devs tunnel {dev_name} --status")
+            else:
+                log = result.get('log', '')
+                if log:
+                    console.print("[yellow]Tunnel may still be starting. Log output:[/yellow]")
+                    console.print(log)
+                else:
+                    console.print("[yellow]Tunnel started but no output yet. Check status with:[/yellow]")
+                console.print(f"   devs tunnel {dev_name} --status")
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to start tunnel in {dev_name}: {e}")
 
     def get_tunnel_status(self, dev_name: str, workspace_dir: Path, debug: bool = False, live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> tuple[bool, str]:
-        """Get VS Code tunnel status in the container.
+        """Get VS Code tunnel status, formatted for CLI display.
 
-        Args:
-            dev_name: Development environment name
-            workspace_dir: Workspace directory path
-            debug: Show debug output for devcontainer operations
-            live: Whether the container is in live mode
-            extra_env: Additional environment variables to pass to container
+        Returns:
+            Tuple of (is_running, formatted_status_message)
+        """
+        data = self.get_tunnel_status_data(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env)
+        return data.get('running', False), self._format_tunnel_status(data)
+
+    def get_tunnel_status_data(self, dev_name: str, workspace_dir: Path, debug: bool = False,
+                               live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> dict:
+        """Get VS Code tunnel status as structured data.
 
         Returns:
-            Tuple of (is_running, status_message)
+            Dict with running, tunnel_name, web_url, vscode_cmd, raw_status, auth_info.
 
         Raises:
             ContainerError: If status check fails
         """
         try:
-            # Prepare container for execution
-            container_name, container_workspace_dir = self._prepare_container_exec(
-                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
-            )
-
-            # Check tunnel status
-            cmd = [
-                'docker', 'exec',
-                container_name,
-                '/usr/local/bin/code', 'tunnel', 'status'
-            ]
+            info = self.get_tunnel_info(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env)
+            container_name = info['container_name']
 
+            cmd = ['docker', 'exec', container_name,
+                   '/usr/local/bin/code', 'tunnel', 'status']
             if debug:
                 console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
 
             result = subprocess.run(cmd, capture_output=True, text=True)
 
+            # Get auth info
+            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
+
+            import json
+            raw_status = {}
             if result.returncode == 0:
-                return True, result.stdout.strip()
-            else:
-                return False, result.stderr.strip() if result.stderr else "No tunnel running"
+                try:
+                    raw_status = json.loads(result.stdout.strip())
+                except json.JSONDecodeError:
+                    pass
+
+            tunnel_data = raw_status.get('tunnel') or {}
+            is_running = result.returncode == 0 and tunnel_data.get('tunnel') == 'Connected'
+
+            return {
+                'running': is_running,
+                'tunnel_name': info['tunnel_name'],
+                'web_url': info['web_url'] if is_running else None,
+                'vscode_cmd': info['vscode_cmd'] if is_running else None,
+                'auth_info': auth_info,
+                'raw_status': raw_status,
+                'container_name': container_name,
+            }
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to get tunnel status in {dev_name}: {e}")
 
+    def _format_tunnel_status(self, data: dict) -> str:
+        """Format tunnel status data into human-readable CLI output."""
+        raw_status = data.get('raw_status', {})
+        tunnel = raw_status.get('tunnel')
+        auth_info = data.get('auth_info')
+
+        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 = []
+
+        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})")
+
+        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}")
+
+        if state == "Connected" and data.get('vscode_cmd'):
+            lines.append("")
+            lines.append("[bold]Connect:[/bold]")
+            lines.append(f"   Desktop:  {data['vscode_cmd']}")
+            lines.append(f"   Browser:  {data['web_url']}")
+
+        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:
+            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.
 
-        Args:
-            dev_name: Development environment name
-            workspace_dir: Workspace directory path
-            debug: Show debug output for devcontainer operations
-            live: Whether the container is in live mode
-            extra_env: Additional environment variables to pass to container
-
         Returns:
             True if tunnel was killed successfully
 
@@ -1103,29 +1247,15 @@ class ContainerManager:
             ContainerError: If tunnel kill fails
         """
         try:
-            # Prepare container for execution
-            container_name, container_workspace_dir = self._prepare_container_exec(
-                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'
-            ]
+            info = self.get_tunnel_info(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env)
+            container_name = info['container_name']
 
             if debug:
-                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+                console.print(f"[dim]Killing tunnel processes in {container_name}[/dim]")
 
-            result = subprocess.run(cmd, capture_output=True, text=True)
-
-            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.2}/devs_common.egg-info/PKG-INFO

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

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

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

devs_common-3.3.0/devs_common/core/__init__.py

@@ -1,13 +0,0 @@
-"""Core classes for devs ecosystem."""
-
-from .project import Project, ProjectInfo
-from .workspace import WorkspaceManager
-from .container import ContainerManager, ContainerInfo
-
-__all__ = [
-    "Project",
-    "ProjectInfo", 
-    "WorkspaceManager",
-    "ContainerManager",
-    "ContainerInfo",
-]