devs-common 2.0.5__tar.gz → 2.0.7__tar.gz

{devs_common-2.0.5 → devs_common-2.0.7}/PKG-INFO

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

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common/core/container.py

@@ -293,9 +293,11 @@ class ContainerManager:
                     self.docker.stop_container(existing_container['name'])
                     self.docker.remove_container(existing_container['name'], force=True)
                 else:
-                    # Container exists but not running, remove it
-                    console.print(f"   🗑️  Container exists but not running, removing...")
-                    self.docker.remove_container(existing_container['name'], force=True)
+                    # Container exists but not running with matching config, just restart it
+                    console.print(f"   🔄 Restarting stopped container...")
+                    self.docker.start_container(existing_container['name'])
+                    console.print(f"   ✅ Container restarted successfully")
+                    return True
             else:
                 if rebuild_needed or force_rebuild:
                     console.print(f"   🔨 Rebuild needed (devcontainer files changed or force_rebuild)")
@@ -467,7 +469,41 @@ class ContainerManager:
             
         except DockerError as e:
             raise ContainerError(f"Failed to list containers: {e}")
-    
+
+    @staticmethod
+    def list_all_containers() -> List[ContainerInfo]:
+        """List all devs-managed containers across all projects.
+
+        Returns:
+            List of ContainerInfo objects sorted by project name then dev name
+        """
+        try:
+            docker_client = DockerClient()
+            containers = docker_client.find_containers_by_labels({"devs.managed": "true"})
+
+            result = []
+            for container_data in containers:
+                dev_name = container_data['labels'].get('devs.dev', 'unknown')
+                project_name = container_data['labels'].get('devs.project', 'unknown')
+
+                container_info = ContainerInfo(
+                    name=container_data['name'],
+                    dev_name=dev_name,
+                    project_name=project_name,
+                    status=container_data['status'],
+                    container_id=container_data['id'],
+                    created=_parse_docker_timestamp(container_data['created']),
+                    labels=container_data['labels']
+                )
+
+                result.append(container_info)
+
+            result.sort(key=lambda c: (c.project_name, c.dev_name))
+            return result
+
+        except DockerError as e:
+            raise ContainerError(f"Failed to list containers: {e}")
+
     def find_aborted_containers(self, all_projects: bool = False) -> List[ContainerInfo]:
         """Find aborted devs containers that failed during setup.
         
@@ -841,6 +877,65 @@ class ContainerManager:
 
         return tunnel_name
 
+    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, one-time setup).
+
+        Runs the device code flow interactively inside the container. Auth is
+        stored in a bind-mounted directory (~/.devs/vscode-cli/) so it persists
+        across container recreations and is shared across all containers.
+
+        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
+
+        Raises:
+            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
+            )
+
+            tunnel_name = self._get_tunnel_name(dev_name)
+
+            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 is shared across all containers on this machine.")
+                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}")
+
     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.
 
@@ -877,7 +972,7 @@ class ContainerManager:
                 'docker', 'exec', '-d',
                 container_name,
                 '/bin/sh', '-c',
-                f'{tunnel_cmd} > {log_file} 2>&1'
+                f'VSCODE_CLI_DATA_DIR=/home/node/.vscode/cli {tunnel_cmd} > {log_file} 2>&1'
             ]
 
             if debug:

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common/templates/Dockerfile

@@ -119,8 +119,11 @@ RUN sh -c "$(wget -O- https://github.com/deluan/zsh-in-docker/releases/download/
   -a "export PROMPT_COMMAND='history -a' && export HISTFILE=/commandhistory/.bash_history" \
   -x
 
-# Install Claude CLI and OpenAI Codex CLI
-RUN npm install -g @anthropic-ai/claude-code @openai/codex
+# Install Claude CLI via native installer
+RUN curl -fsSL https://claude.ai/install.sh | bash
+
+# Install OpenAI Codex CLI
+RUN npm install -g @openai/codex
 
 # Install VS Code CLI for tunnel support (needs root for /usr/local/bin)
 # Using the standalone CLI which supports the 'tunnel' command
@@ -139,7 +142,9 @@ RUN ARCH=$(dpkg --print-architecture) && \
 RUN for shell_rc in /home/node/.zshrc /home/node/.bashrc; do \
   echo "export CLAUDE_CONFIG_DIR=\"/home/node/claudeconfig\"" >> "$shell_rc" && \
   echo "export CODEX_CONFIG_HOME=\"/home/node/codexconfig\"" >> "$shell_rc" && \
-  echo "alias claude=\"/usr/local/share/npm-global/bin/claude --dangerously-skip-permissions\"" >> "$shell_rc" && \
+  echo "export VSCODE_CLI_DATA_DIR=\"/home/node/.vscode/cli\"" >> "$shell_rc" && \
+  echo "export PATH=\"/home/node/.local/bin:\$PATH\"" >> "$shell_rc" && \
+  echo "alias claude=\"claude --dangerously-skip-permissions\"" >> "$shell_rc" && \
   echo "alias codex=\"/usr/local/share/npm-global/bin/codex --full-auto\"" >> "$shell_rc" && \
   echo "" >> "$shell_rc" && \
   echo "# Auto-activate Python venv if it exists" >> "$shell_rc" && \

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common/templates/devcontainer.json

@@ -96,7 +96,8 @@
     "DEVS_DEBUG": "${localEnv:DEVS_DEBUG}",
     "DEVS_LIVE_MODE": "${localEnv:DEVS_LIVE_MODE}",
     "DEVS_ENV_MOUNT_PATH": "${localEnv:DEVS_ENV_MOUNT_PATH}",
-    "DEVS_BRIDGE_MOUNT_PATH": "${localEnv:DEVS_BRIDGE_MOUNT_PATH}"
+    "DEVS_BRIDGE_MOUNT_PATH": "${localEnv:DEVS_BRIDGE_MOUNT_PATH}",
+    "VSCODE_CLI_DATA_DIR": "/home/node/.vscode/cli"
   },
   "workspaceFolder": "/workspaces/${localEnv:WORKSPACE_FOLDER_NAME}",
   "postCreateCommand": "/usr/local/bin/post-create-wrapper.sh",

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common/utils/__init__.py

@@ -16,10 +16,11 @@ from .git_utils import (
 
 from .docker_client import DockerClient
 from .devcontainer import DevContainerCLI
+from .repo_cache import RepoCache
 
 __all__ = [
     "copy_file_list",
-    "copy_directory_tree", 
+    "copy_directory_tree",
     "safe_remove_directory",
     "ensure_directory_exists",
     "get_directory_size",
@@ -27,5 +28,6 @@ __all__ = [
     "get_tracked_files",
     "is_git_repository",
     "DockerClient",
-    "DevContainerCLI"
+    "DevContainerCLI",
+    "RepoCache",
 ]

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common/utils/docker_client.py

@@ -81,6 +81,21 @@ class DockerClient:
         except DockerException as e:
             raise DockerError(f"Error checking container status {name}: {e}")
     
+    def start_container(self, name: str) -> None:
+        """Start a stopped container.
+
+        Args:
+            name: Container name
+
+        Raises:
+            DockerError: If starting fails
+        """
+        try:
+            container = self.client.containers.get(name)
+            container.start()
+        except DockerException as e:
+            raise DockerError(f"Error starting container {name}: {e}")
+
     def stop_container(self, name: str) -> None:
         """Stop a container.
         

devs_common-2.0.7/devs_common/utils/repo_cache.py

@@ -0,0 +1,227 @@
+"""Repository cache for cloning GitHub repos locally."""
+
+import os
+import subprocess
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+from ..exceptions import DevsError
+from .console import get_console
+
+console = get_console()
+
+
+class RepoCache:
+    """Manages a local cache of cloned GitHub repositories.
+
+    Repos are cloned into a cache directory (default: ~/.devs/repocache/)
+    using the naming convention org-repo (e.g. ideonate-devs).
+
+    Args:
+        cache_dir: Directory for cached repos. Defaults to ~/.devs/repocache/.
+        token: GitHub token for private repo access. If not provided, falls
+            back to GH_TOKEN / GITHUB_TOKEN environment variables.
+        default_branches: Ordered list of branch names to try when no explicit
+            branch is requested. Defaults to detecting via symbolic-ref, then
+            trying "main" and "master".
+        clean: If True, run ``git clean -fd`` after checkout to remove
+            untracked files from previous runs.
+    """
+
+    def __init__(
+        self,
+        cache_dir: Optional[Path] = None,
+        token: Optional[str] = None,
+        default_branches: Optional[List[str]] = None,
+        clean: bool = False,
+    ) -> None:
+        self.cache_dir = cache_dir or Path.home() / ".devs" / "repocache"
+        self._token = token
+        self._default_branches = default_branches
+        self._clean = clean
+
+    def _repo_name_to_dir_name(self, repo_name: str) -> str:
+        """Convert org/repo to org-repo directory name."""
+        return repo_name.replace("/", "-").lower()
+
+    def _get_token(self) -> Optional[str]:
+        """Return the configured token, falling back to environment variables."""
+        if self._token:
+            return self._token
+        return os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
+
+    def _build_clone_url(self, repo_name: str) -> str:
+        """Build clone URL, using token if available for private repos."""
+        token = self._get_token()
+        if token:
+            return f"https://x-access-token:{token}@github.com/{repo_name}.git"
+        return f"https://github.com/{repo_name}.git"
+
+    def get_repo_path(self, repo_name: str) -> Path:
+        """Return the local cache path for a repo without cloning.
+
+        Args:
+            repo_name: GitHub repo in org/repo format.
+
+        Returns:
+            Path where the repo would be cached.
+        """
+        return self.cache_dir / self._repo_name_to_dir_name(repo_name)
+
+    def ensure_repo(self, repo_name: str, branch: Optional[str] = None) -> Path:
+        """Ensure a repository is cloned and up-to-date in the cache.
+
+        Args:
+            repo_name: GitHub repo in org/repo format (e.g. "ideonate/devs")
+            branch: Optional branch to checkout. Defaults to repo's default branch.
+
+        Returns:
+            Path to the cached repository directory.
+
+        Raises:
+            DevsError: If cloning or updating fails.
+        """
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        dir_name = self._repo_name_to_dir_name(repo_name)
+        repo_path = self.cache_dir / dir_name
+
+        if repo_path.exists() and (repo_path / ".git").exists():
+            self._update_repo(repo_path, repo_name, branch)
+        else:
+            self._clone_repo(repo_path, repo_name, branch)
+
+        return repo_path
+
+    def _clone_repo(self, repo_path: Path, repo_name: str, branch: Optional[str] = None) -> None:
+        """Clone a repository into the cache."""
+        # Remove directory if it exists but isn't a valid git repo
+        if repo_path.exists():
+            shutil.rmtree(repo_path)
+
+        clone_url = self._build_clone_url(repo_name)
+        console.print(f"   Cloning {repo_name} into cache...")
+
+        repo_path.parent.mkdir(parents=True, exist_ok=True)
+
+        cmd = ["git", "clone", clone_url, str(repo_path)]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise DevsError(
+                f"Failed to clone {repo_name}: {result.stderr.strip()}"
+            )
+
+        target = branch or self._detect_branch(repo_path)
+        if target:
+            self._checkout_branch(repo_path, target)
+
+    def _update_repo(self, repo_path: Path, repo_name: str, branch: Optional[str] = None) -> None:
+        """Fetch latest changes for an existing cached repo."""
+        console.print(f"   Updating cached repo {repo_name}...")
+
+        # Update remote URL in case token changed
+        clone_url = self._build_clone_url(repo_name)
+        subprocess.run(
+            ["git", "remote", "set-url", "origin", clone_url],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+
+        result = subprocess.run(
+            ["git", "fetch", "--all"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            # Fetch failed – re-clone from scratch
+            console.print(f"   Fetch failed, re-cloning {repo_name}...")
+            self._clone_repo(repo_path, repo_name, branch)
+            return
+
+        # Checkout the requested branch (or default)
+        target = branch or self._detect_branch(repo_path)
+        if target:
+            self._checkout_branch(repo_path, target)
+
+    def _checkout_branch(self, repo_path: Path, branch: str) -> None:
+        """Checkout a specific branch, pulling latest changes."""
+        result = subprocess.run(
+            ["git", "checkout", "-f", branch],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise DevsError(
+                f"Failed to checkout branch '{branch}': {result.stderr.strip()}"
+            )
+
+        # Reset to match remote so we pick up fetched changes
+        subprocess.run(
+            ["git", "reset", "--hard", f"origin/{branch}"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+
+        if self._clean:
+            self._clean_untracked(repo_path)
+
+    def _clean_untracked(self, repo_path: Path) -> None:
+        """Remove untracked files and directories from the repo."""
+        subprocess.run(
+            ["git", "clean", "-fd"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+
+    def _detect_branch(self, repo_path: Path) -> Optional[str]:
+        """Detect the default branch to checkout.
+
+        If ``default_branches`` was provided at construction, tries each in
+        order. Otherwise falls back to symbolic-ref detection then main/master.
+        """
+        if self._default_branches:
+            for branch in self._default_branches:
+                result = subprocess.run(
+                    ["git", "rev-parse", "--verify", f"origin/{branch}"],
+                    cwd=repo_path,
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode == 0:
+                    return branch
+            return None
+
+        return self._get_default_branch(repo_path)
+
+    def _get_default_branch(self, repo_path: Path) -> Optional[str]:
+        """Detect the default branch of a repo (main or master)."""
+        result = subprocess.run(
+            ["git", "symbolic-ref", "refs/remotes/origin/HEAD"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            # Output like "refs/remotes/origin/main"
+            ref = result.stdout.strip()
+            return ref.split("/")[-1]
+
+        # Fallback: try common branch names
+        for branch in ("main", "master"):
+            result = subprocess.run(
+                ["git", "rev-parse", "--verify", f"origin/{branch}"],
+                cwd=repo_path,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                return branch
+
+        return None

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common.egg-info/PKG-INFO

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

{devs_common-2.0.5 → devs_common-2.0.7}/devs_common.egg-info/SOURCES.txt

@@ -36,4 +36,5 @@ devs_common/utils/devcontainer.py
 devs_common/utils/devcontainer_template.py
 devs_common/utils/docker_client.py
 devs_common/utils/file_utils.py
-devs_common/utils/git_utils.py
+devs_common/utils/git_utils.py
+devs_common/utils/repo_cache.py

{devs_common-2.0.5 → devs_common-2.0.7}/pyproject.toml

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