devs-common 2.0.10__tar.gz → 2.0.12__tar.gz

{devs_common-2.0.10 → devs_common-2.0.12}/PKG-INFO

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

{devs_common-2.0.10 → devs_common-2.0.12}/devs_common/core/container.py

@@ -399,27 +399,20 @@ class ContainerManager:
         project_labels = self._get_project_labels(dev_name)
 
         try:
-            console.print(f"   🔍 Looking for containers with labels: {project_labels}")
             existing_containers = self.docker.find_containers_by_labels(project_labels)
-            console.print(f"   📋 Found {len(existing_containers)} containers")
 
             if existing_containers:
                 for container_info in existing_containers:
                     container_name = container_info['name']
-                    container_status = container_info['status']
 
-                    console.print(f"   🛑 Stopping container: {container_name} (status: {container_status})")
                     try:
-                        stop_result = self.docker.stop_container(container_name)
-                        console.print(f"   📋 Stop result: {stop_result}")
+                        self.docker.stop_container(container_name)
                     except DockerError as stop_e:
                         console.print(f"   ⚠️  Stop failed for {container_name}: {stop_e}")
 
                     if remove:
-                        console.print(f"   🗑️  Removing container: {container_name}")
                         try:
-                            remove_result = self.docker.remove_container(container_name)
-                            console.print(f"   📋 Remove result: {remove_result}")
+                            self.docker.remove_container(container_name)
                         except DockerError as remove_e:
                             console.print(f"   ⚠️  Remove failed for {container_name}: {remove_e}")
 
@@ -586,7 +579,7 @@ class ContainerManager:
         
         return removed_count
     
-    def _prepare_container_exec(self, dev_name: str, workspace_dir: Path, debug: bool = False, live: bool = False, extra_env: Optional[Dict[str, str]] = None) -> Tuple[str, str]:
+    def _prepare_container_exec(self, dev_name: str, workspace_dir: Path, debug: bool = False, live: bool = False, extra_env: Optional[Dict[str, str]] = None, reuse_existing: bool = False) -> Tuple[str, str]:
         """Prepare container for exec operations (shared by exec_shell and exec_command).
 
         Args:
@@ -595,6 +588,10 @@ class ContainerManager:
             debug: Show debug output for devcontainer operations
             live: Whether the container is in live mode
             extra_env: Additional environment variables to pass to container
+            reuse_existing: If True, use existing container as-is (starting
+                it if stopped) without rebuilding. Only creates a new
+                container if none exists. Used by tunnel commands to
+                avoid accidentally destroying work in the container.
 
         Returns:
             Tuple of (container_name, container_workspace_dir)
@@ -623,9 +620,17 @@ class ContainerManager:
             workspace_name = workspace_info["workspace_name"]
         container_workspace_dir = f"/workspaces/{workspace_name}"
 
-        # Ensure container is running
-        if not self.ensure_container_running(dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env):
-            raise ContainerError(f"Failed to start container for {dev_name}")
+        if reuse_existing and existing_containers:
+            # Use existing container as-is (start if stopped, but never rebuild)
+            status = existing_containers[0].get('status', '')
+            if status != 'running':
+                container_id = existing_containers[0].get('name', container_name)
+                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):
+                raise ContainerError(f"Failed to start container for {dev_name}")
 
         return container_name, container_workspace_dir
     
@@ -877,13 +882,99 @@ class ContainerManager:
 
         return tunnel_name
 
+    def _run_tunnel_auth(self, container_name: str, debug: bool = False) -> bool:
+        """Run interactive VS Code tunnel authentication in a container.
+
+        Returns:
+            True if authentication succeeded
+        """
+        console.print("[yellow]Follow the prompts to authenticate:[/yellow]")
+        console.print("   1. A URL and code will be displayed")
+        console.print("   2. Open the URL in your browser")
+        console.print("   3. Enter the code to authenticate with GitHub/Microsoft")
+        console.print("")
+
+        cmd = [
+            'docker', 'exec', '-it',
+            container_name,
+            '/usr/local/bin/code', 'tunnel', 'user', 'login',
+            '--provider', 'github'
+        ]
+
+        if debug:
+            console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+
+        result = subprocess.run(cmd, check=False)
+
+        if result.returncode == 0:
+            console.print("")
+            console.print("[bold green]Authentication successful![/bold green]")
+            console.print("   Auth persists across container stop/restart cycles.")
+            return True
+        else:
+            console.print("")
+            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:
+        """Start a detached tunnel and poll the log for startup confirmation.
+
+        Returns:
+            True if tunnel started (or timed out), False if auth is needed.
+        """
+        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(
+                ['docker', 'exec', container_name, 'cat', log_file],
+                capture_output=True, text=True
+            )
+            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
+
+            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
+
+            if debug and output.strip():
+                console.print(f"[dim]Log ({i+1}s): {output.strip()[-100:]}[/dim]")
+
+        # Timeout
+        result = subprocess.run(
+            ['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
+
     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).
 
-        Runs the device code flow interactively inside the container. Auth is
-        stored in the container's filesystem and persists across stop/restart
-        cycles (but not container removal/recreation).
-
         Args:
             dev_name: Development environment name
             workspace_dir: Workspace directory path
@@ -896,7 +987,7 @@ class ContainerManager:
         """
         try:
             container_name, container_workspace_dir = self._prepare_container_exec(
-                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env
+                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
             )
 
             tunnel_name = self._get_tunnel_name(dev_name)
@@ -904,34 +995,11 @@ class ContainerManager:
             console.print("🔐 Setting up VS Code tunnel authentication...")
             console.print(f"   Container: {container_name}")
             console.print("")
-            console.print("[yellow]Follow the prompts to authenticate:[/yellow]")
-            console.print("   1. A URL and code will be displayed")
-            console.print("   2. Open the URL in your browser")
-            console.print("   3. Enter the code to authenticate with GitHub/Microsoft")
-            console.print("")
 
-            cmd = [
-                'docker', 'exec', '-it',
-                container_name,
-                '/usr/local/bin/code', 'tunnel', 'user', 'login',
-                '--provider', 'github'
-            ]
-
-            if debug:
-                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
-
-            result = subprocess.run(cmd, check=False)
-
-            if result.returncode == 0:
-                console.print("")
-                console.print("[bold green]Authentication successful![/bold green]")
-                console.print("   Auth persists across container stop/restart cycles.")
+            if self._run_tunnel_auth(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}")
-            else:
-                console.print("")
-                console.print("[yellow]Authentication was cancelled or failed.[/yellow]")
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to authenticate tunnel in {dev_name}: {e}")
@@ -939,8 +1007,7 @@ class ContainerManager:
     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.
 
-        Requires prior authentication via tunnel_auth(). The tunnel runs
-        detached inside the container.
+        If authentication is needed, prompts interactively then retries.
 
         Args:
             dev_name: Development environment name
@@ -954,78 +1021,33 @@ class ContainerManager:
         """
         try:
             container_name, container_workspace_dir = self._prepare_container_exec(
-                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env
+                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
             )
 
             tunnel_name = self._get_tunnel_name(dev_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("")
 
-            # Start detached
-            cmd = [
-                'docker', 'exec', '-d',
-                container_name,
-                '/bin/sh', '-c',
-                f'{tunnel_cmd} > {log_file} 2>&1'
-            ]
-
-            if debug:
-                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
-
-            subprocess.run(cmd, check=True)
-
-            # Poll the log to confirm startup and show the URL
-            console.print("[dim]Waiting for tunnel to start...[/dim]")
-            for i in range(15):
-                time.sleep(1)
-                result = subprocess.run(
-                    ['docker', 'exec', container_name, 'cat', log_file],
-                    capture_output=True, text=True
-                )
-                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 from your local machine:[/bold]")
-                    console.print(f"   {vscode_cmd}")
-                    console.print("")
-                    for line in output.split('\n'):
-                        if 'vscode.dev/tunnel' in line:
-                            console.print(f"[dim]Or open in browser: {line.strip()}[/dim]")
-                    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
-
-                if 'log in' in output.lower() or 'device' in output.lower() or 'invalid' in output.lower():
-                    console.print("[yellow]Authentication required.[/yellow]")
-                    console.print(f"   Run: devs tunnel {dev_name} --auth")
-                    subprocess.run(
-                        ['docker', 'exec', container_name, '/usr/local/bin/code', 'tunnel', 'kill'],
-                        capture_output=True
-                    )
+            if not self._start_and_poll_tunnel(container_name, dev_name, tunnel_cmd,
+                                               log_file, vscode_cmd, web_url, debug=debug):
+                # Auth needed
+                console.print("[yellow]Authentication required. Starting login...[/yellow]")
+                console.print("")
+                if not self._run_tunnel_auth(container_name, debug=debug):
                     return
 
-                if debug and output.strip():
-                    console.print(f"[dim]Log ({i+1}s): {output.strip()[-100:]}[/dim]")
-
-            # Timeout - show what we have
-            result = subprocess.run(
-                ['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")
+                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)
 
         except (DockerError, subprocess.SubprocessError) as e:
             raise ContainerError(f"Failed to start tunnel in {dev_name}: {e}")
@@ -1049,7 +1071,7 @@ class ContainerManager:
         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
+                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
             )
 
             # Check tunnel status
@@ -1091,7 +1113,7 @@ class ContainerManager:
         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
+                dev_name, workspace_dir, debug=debug, live=live, extra_env=extra_env, reuse_existing=True
             )
 
             # Kill the tunnel

{devs_common-2.0.10 → devs_common-2.0.12}/devs_common/templates/Dockerfile

@@ -125,9 +125,14 @@ RUN curl -fsSL https://claude.ai/install.sh | bash
 # Install OpenAI Codex CLI
 RUN npm install -g @openai/codex
 
+# Install cloudflared for tunnel support (proxies all HTTP methods correctly)
 # Install VS Code CLI for tunnel support (needs root for /usr/local/bin)
 # Using the standalone CLI which supports the 'tunnel' command
 USER root
+RUN ARCH=$(dpkg --print-architecture) && \
+  curl -fSL "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${ARCH}" -o /usr/local/bin/cloudflared && \
+  chmod +x /usr/local/bin/cloudflared
+
 RUN ARCH=$(dpkg --print-architecture) && \
   if [ "$ARCH" = "amd64" ]; then \
     curl -fSL 'https://update.code.visualstudio.com/latest/cli-linux-x64/stable' -o /tmp/vscode-cli.tar.gz; \

{devs_common-2.0.10 → devs_common-2.0.12}/devs_common.egg-info/PKG-INFO

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

{devs_common-2.0.10 → devs_common-2.0.12}/pyproject.toml

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