vmux-cli 0.5.4__tar.gz → 0.6.0__tar.gz

{vmux_cli-0.5.4 → vmux_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vmux-cli
-Version: 0.5.4
+Version: 0.6.0
 Summary: Run anything in the cloud. Replace uv run with vmux run.
 Project-URL: Homepage, https://vmux.sdan.io
 Project-URL: Documentation, https://vmux.sdan.io

{vmux_cli-0.5.4 → vmux_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vmux-cli"
-version = "0.5.4"
+version = "0.6.0"
 description = "Run anything in the cloud. Replace uv run with vmux run."
 readme = "README.md"
 license = "MIT"
@@ -66,6 +66,12 @@ Issues = "https://github.com/sdan/vmux/issues"
 [tool.hatch.build.targets.wheel]
 packages = ["vmux"]
 
+[tool.hatch.build.targets.sdist]
+include = [
+    "vmux/**/*.py",
+    "vmux/**/*.md",
+]
+
 [tool.ruff]
 line-length = 100
 target-version = "py310"

vmux_cli-0.6.0/vmux/claude/skills/vmux/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: vmux
+description: Deploy to vmux cloud compute. Use when user says "deploy", "vmux", "run in cloud", "preview URL", or wants to run commands on remote compute.
+---
+
+# vmux - Cloud Compute in 5 Seconds
+
+Run any command in the cloud. Close your laptop, keep running.
+
+## Setup
+
+```bash
+vmux whoami  # Check login status
+vmux login   # If needed
+```
+
+## vmux run
+
+```bash
+vmux run [flags] <command>
+```
+
+### Flags
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--detach` | `-d` | Run in background, return job ID immediately |
+| `--port <port>` | `-p` | Expose port for preview URL (can use multiple times) |
+| `--preview` | | Auto-detect port from framework and expose it |
+| `--env KEY=VAL` | `-e` | Set environment variable |
+| `--runtime` | `-r` | Force runtime: `python`, `bun`, or `node` |
+
+### Flag Combinations
+
+Flags can be combined: `-dp 8000` = detached + port 8000
+
+```bash
+vmux run python script.py           # Streams logs, blocks
+vmux run -d python script.py        # Detached, returns job ID
+vmux run -p 8000 python server.py   # Expose port 8000, get preview URL
+vmux run -dp 8000 python server.py  # Detached + port (most common for web)
+vmux run -d --preview bun run dev   # Auto-detect port from framework
+vmux run -p 3000 -p 8000 npm run dev  # Multiple ports
+vmux run -e API_KEY=xxx python app.py # With env var
+vmux run -r bun npm run dev         # Force bun runtime
+```
+
+## After Deploy
+
+Always give the user:
+1. The **preview URL** (if port exposed) - format: `https://<job-id>.purr.ge`
+2. The **job ID**
+3. How to monitor: `vmux logs -f <job-id>`
+4. How to stop: `vmux stop <job-id>`
+
+## Other Commands
+
+```bash
+vmux ps                 # List running jobs
+vmux logs <job-id>      # Get logs
+vmux logs -f <job-id>   # Follow logs in real-time
+vmux attach <job-id>    # Interactive tmux session (Ctrl+B,D to detach)
+vmux stop <job-id>      # Kill job
+vmux stop -a            # Stop all running jobs
+vmux debug <job-id>     # Show tmux status and processes
+vmux secret set KEY     # Store secret in keychain
+```

{vmux_cli-0.5.4 → vmux_cli-0.6.0}/vmux/cli.py

@@ -1,6 +1,7 @@
 """CLI for vmux - run any command in the cloud."""
 
 import sys
+from pathlib import Path
 import click
 
 from .client import TupClient
@@ -9,6 +10,56 @@ from .config import load_config, save_config
 from .core import run_command
 
 
+def detect_framework_port() -> int:
+    """Auto-detect the default port based on framework files in current directory.
+
+    Returns:
+        Port number based on detected framework, or 8000 as fallback.
+    """
+    cwd = Path.cwd()
+
+    # Check for Vite (port 5173)
+    if any(cwd.glob("vite.config.*")):
+        return 5173
+
+    # Check for Next.js (port 3000)
+    if any(cwd.glob("next.config.*")):
+        return 3000
+
+    # Check package.json for hints
+    package_json = cwd / "package.json"
+    if package_json.exists():
+        try:
+            import json
+            pkg = json.loads(package_json.read_text())
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+
+            # Vite-based frameworks
+            if "vite" in deps:
+                return 5173
+            # Next.js
+            if "next" in deps:
+                return 3000
+            # Create React App / generic React
+            if "react-scripts" in deps:
+                return 3000
+            # Express / generic Node
+            if "express" in deps:
+                return 3000
+            # Bun default
+            if any(cwd.glob("bun.lockb")) or any(cwd.glob("bunfig.toml")):
+                return 3000
+        except Exception:
+            pass
+
+    # Python frameworks default to 8000
+    if any(cwd.glob("*.py")) or any(cwd.glob("requirements*.txt")) or any(cwd.glob("pyproject.toml")):
+        return 8000
+
+    # Default fallback
+    return 8000
+
+
 @click.group()
 def cli() -> None:
     """Run any command in the cloud."""
@@ -18,10 +69,11 @@ def cli() -> None:
 @cli.command()
 @click.option("--detach", "-d", is_flag=True, help="Return job ID without streaming logs")
 @click.option("--port", "-p", multiple=True, type=int, help="Port to expose for preview URL (can be used multiple times)")
-@click.option("--preview", is_flag=True, help="Expose port 8000 for preview URL (shorthand for -p 8000)")
+@click.option("--preview", is_flag=True, help="Expose port for preview URL (auto-detects port from framework)")
 @click.option("--env", "-e", multiple=True, help="Environment variable (KEY=VALUE)")
+@click.option("--runtime", "-r", type=click.Choice(["python", "bun", "node"]), help="Force runtime (auto-detected if not specified)")
 @click.argument("command", nargs=-1, required=True)
-def run(detach: bool, port: tuple[int, ...], preview: bool, env: tuple[str, ...], command: tuple[str, ...]) -> None:
+def run(detach: bool, port: tuple[int, ...], preview: bool, env: tuple[str, ...], runtime: str | None, command: tuple[str, ...]) -> None:
     """Run a command in the cloud.
 
     \b
@@ -31,6 +83,8 @@ def run(detach: bool, port: tuple[int, ...], preview: bool, env: tuple[str, ...]
         vmux run --preview python server.py   # Web server on :8000
         vmux run -p 8000 python server.py     # Same as above
         vmux run -p 3000 -p 8000 npm run dev  # Multiple ports
+        vmux run --preview bun run server.ts  # Bun web server
+        vmux run -r bun npm run dev           # Force Bun runtime
     """
     env_vars = {}
     for e in env:
@@ -49,19 +103,21 @@ def run(detach: bool, port: tuple[int, ...], preview: bool, env: tuple[str, ...]
             command.insert(0, f"{key}={value}")
             break
 
-    # Combine --preview (default 8000) with explicit -p ports
+    # Combine --preview with explicit -p ports
+    # If --preview is used without -p, auto-detect port from framework
     ports = list(port)
-    if preview and 8000 not in ports:
-        ports.append(8000)
+    if preview and not ports:
+        detected_port = detect_framework_port()
+        ports.append(detected_port)
 
     try:
-        run_command(" ".join(command), env_vars=env_vars or None, detach=detach, ports=ports)
+        run_command(" ".join(command), env_vars=env_vars or None, detach=detach, ports=ports, runtime=runtime)
     except Exception as e:
         error(str(e))
         sys.exit(1)
 
 
-def _list_jobs(limit: int) -> None:
+def _list_jobs(limit: int, all_jobs: bool = False) -> None:
     """Shared implementation for ps/ls."""
     from datetime import datetime
 
@@ -69,8 +125,12 @@ def _list_jobs(limit: int) -> None:
     with TupClient(config) as client:
         jobs = client.list_jobs(limit=limit)
 
+        # Filter out completed/failed unless --all
+        if not all_jobs:
+            jobs = [j for j in jobs if j.get("status") in ("running", "pending")]
+
         if not jobs:
-            warning("No jobs found.")
+            warning("No running jobs." if not all_jobs else "No jobs found.")
             return
 
         # Sort by created_at ascending (oldest first, newest at bottom)
@@ -119,28 +179,62 @@ def _list_jobs(limit: int) -> None:
 
 @cli.command(name="ps")
 @click.option("--limit", "-l", default=20, help="Number of jobs to show")
-def ps_cmd(limit: int) -> None:
+@click.option("--all", "-a", "all_jobs", is_flag=True, help="Show all jobs including completed/failed")
+def ps_cmd(limit: int, all_jobs: bool) -> None:
     """List running jobs."""
-    _list_jobs(limit)
+    _list_jobs(limit, all_jobs)
 
 
-@cli.command(name="ls")
+# Hidden alias for ps
+@cli.command(name="ls", hidden=True)
 @click.option("--limit", "-l", default=20, help="Number of jobs to show")
-def ls_cmd(limit: int) -> None:
-    """List running jobs (alias for ps)."""
-    _list_jobs(limit)
+@click.option("--all", "-a", "all_jobs", is_flag=True, help="Show all jobs including completed/failed")
+def ls_cmd(limit: int, all_jobs: bool) -> None:
+    """List running jobs."""
+    _list_jobs(limit, all_jobs)
 
 
 @cli.command()
-@click.argument("job_id")
-def stop(job_id: str) -> None:
-    """Stop a running job."""
+@click.argument("job_ids", nargs=-1)
+@click.option("--all", "-a", "stop_all", is_flag=True, help="Stop all running jobs")
+def stop(job_ids: tuple[str, ...], stop_all: bool) -> None:
+    """Stop one or more jobs.
+
+    \b
+    Examples:
+        vmux stop abc123              # Stop one job
+        vmux stop abc123 def456       # Stop multiple jobs
+        vmux stop -a                  # Stop all running jobs
+    """
     config = load_config()
     with TupClient(config) as client:
-        if client.stop_job(job_id):
-            success(f"Stopped {job_id}")
+        if stop_all:
+            jobs = client.list_jobs(limit=100)
+            running = [j for j in jobs if j.get("status") == "running"]
+            if not running:
+                warning("No running jobs to stop.")
+                return
+            job_ids = tuple(j["job_id"] for j in running)
+            console.print(f"Stopping {len(job_ids)} running jobs...")
+        elif not job_ids:
+            error("Specify job ID(s) or use --all")
+            sys.exit(1)
+
+        stopped = 0
+        for job_id in job_ids:
+            try:
+                if client.stop_job(job_id):
+                    console.print(f"  [green]✓[/green] {job_id}")
+                    stopped += 1
+                else:
+                    console.print(f"  [red]✗[/red] {job_id} (failed)")
+            except Exception as e:
+                console.print(f"  [red]✗[/red] {job_id} ({e})")
+
+        if stopped > 0:
+            success(f"Stopped {stopped} job(s)")
         else:
-            error("Failed to stop job")
+            error("No jobs stopped")
             sys.exit(1)
 
 
@@ -236,6 +330,96 @@ def logout() -> None:
     success("Logged out.")
 
 
+@cli.command()
+def status() -> None:
+    """Show global capacity status."""
+    config = load_config()
+    if not config.auth_token:
+        error("Not logged in. Run: vmux login")
+        sys.exit(1)
+
+    with TupClient(config) as client:
+        try:
+            data = client.get_status()
+            current = data.get("current_jobs", 0)
+            max_jobs = data.get("max_jobs", 90)
+            percent = data.get("capacity_percent", 0)
+
+            # Color based on capacity
+            if percent < 50:
+                color = "green"
+            elif percent < 80:
+                color = "yellow"
+            else:
+                color = "red"
+
+            console.print()
+            console.print(f"  [dim]Capacity:[/dim]  [{color}]{current}[/{color}] / {max_jobs} jobs ({percent}%)")
+            console.print()
+        except Exception as e:
+            error(f"Failed to get status: {e}")
+            sys.exit(1)
+
+
+@cli.command()
+@click.argument("job_id")
+def debug(job_id: str) -> None:
+    """Debug a job - show tmux status, processes, and recent logs."""
+    config = load_config()
+    if not config.auth_token:
+        error("Not logged in. Run: vmux login")
+        sys.exit(1)
+
+    with TupClient(config) as client:
+        try:
+            data = client.debug_job(job_id)
+            console.print()
+            for cmd, output in data.items():
+                console.print(f"[cyan]$ {cmd}[/cyan]")
+                console.print(output)
+                console.print()
+        except Exception as e:
+            error(f"Debug failed: {e}")
+            sys.exit(1)
+
+
+@cli.command()
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+def prune(force: bool) -> None:
+    """Remove completed/failed jobs from history.
+
+    \b
+    Examples:
+        vmux prune           # Remove old jobs (asks for confirmation)
+        vmux prune -f        # Remove without confirmation
+    """
+    config = load_config()
+    with TupClient(config) as client:
+        jobs = client.list_jobs(limit=200)
+        stale = [j for j in jobs if j.get("status") in ("completed", "failed")]
+
+        if not stale:
+            warning("No completed/failed jobs to prune.")
+            return
+
+        console.print(f"Found {len(stale)} completed/failed jobs.")
+        if not force:
+            if not click.confirm("Remove from history?"):
+                console.print("Cancelled.")
+                return
+
+        removed = 0
+        for job in stale:
+            try:
+                # Stop will mark as failed and clean up
+                client.stop_job(job["job_id"])
+                removed += 1
+            except Exception:
+                pass  # Already gone or can't remove
+
+        success(f"Pruned {removed} jobs")
+
+
 @cli.command()
 def whoami() -> None:
     """Show current user."""
@@ -389,6 +573,65 @@ def secret_rm(key: str) -> None:
         error(f"Secret '{key}' not found")
 
 
+@cli.group()
+def claude() -> None:
+    """Claude Code integration."""
+    pass
+
+
+@claude.command(name="install")
+def claude_install() -> None:
+    """Install vmux skill for Claude Code.
+
+    Copies the vmux skill to ~/.claude/skills/vmux/ so Claude Code
+    can use vmux commands via /vmux or natural language.
+    """
+    import shutil
+
+    # Find the skill file bundled with vmux
+    skill_source = Path(__file__).parent.parent / "claude" / "skills" / "vmux" / "SKILL.md"
+
+    # Fallback: check if installed as package
+    if not skill_source.exists():
+        import importlib.resources
+        try:
+            # Python 3.9+
+            files = importlib.resources.files("vmux")
+            skill_source = Path(str(files / "claude" / "skills" / "vmux" / "SKILL.md"))
+        except Exception:
+            pass
+
+    if not skill_source.exists():
+        error("Skill file not found. Try reinstalling vmux.")
+        sys.exit(1)
+
+    # Install to ~/.claude/skills/vmux/
+    skill_dest = Path.home() / ".claude" / "skills" / "vmux"
+    skill_dest.mkdir(parents=True, exist_ok=True)
+
+    dest_file = skill_dest / "SKILL.md"
+    shutil.copy(skill_source, dest_file)
+
+    success(f"Installed vmux skill to {dest_file}")
+    console.print()
+    console.print("[dim]Claude Code will now understand vmux commands.[/dim]")
+    console.print("[dim]Try: 'deploy this with vmux' or '/vmux'[/dim]")
+
+
+@claude.command(name="uninstall")
+def claude_uninstall() -> None:
+    """Remove vmux skill from Claude Code."""
+    import shutil
+
+    skill_dir = Path.home() / ".claude" / "skills" / "vmux"
+
+    if skill_dir.exists():
+        shutil.rmtree(skill_dir)
+        success("Removed vmux skill from Claude Code")
+    else:
+        warning("vmux skill not installed")
+
+
 def main() -> None:
     cli()
 

{vmux_cli-0.5.4 → vmux_cli-0.6.0}/vmux/client.py

@@ -71,6 +71,7 @@ class TupClient:
         env_vars: dict[str, str] | None = None,
         editables: list[str] | None = None,
         ports: list[int] | None = None,
+        runtime: str | None = None,
         on_upload_start: Callable[[int, bool], None] | None = None,  # (size, is_r2) -> None
     ) -> Iterator[dict]:
         """Run a command and stream logs.
@@ -81,6 +82,7 @@ class TupClient:
             env_vars: Environment variables
             editables: List of editable package names (for PYTHONPATH)
             ports: Ports to expose for preview URLs (default: [8000])
+            runtime: Force runtime ("python", "bun", "node") - auto-detected if None
 
         Yields events:
             {"job_id": "..."} - First event with job ID
@@ -109,13 +111,15 @@ class TupClient:
         if not use_r2:
             # Small bundle: base64 encode and send inline
             bundle_b64 = base64.b64encode(bundle_data).decode("ascii")
-            payload = {
+            payload: dict = {
                 "command": command,
                 "bundle": bundle_b64,
                 "env_vars": merged_env,
                 "editables": editables or [],
                 "ports": ports or [],
             }
+            if runtime:
+                payload["runtime"] = runtime
             if DEBUG:
                 print(f"[DEBUG] Using inline upload ({bundle_size} bytes raw, {len(bundle_b64)} chars base64)")
         else:
@@ -130,6 +134,8 @@ class TupClient:
                 "editables": editables or [],
                 "ports": ports or [],
             }
+            if runtime:
+                payload["runtime"] = runtime
 
         if DEBUG:
             print(f"[DEBUG] Payload size: {len(json.dumps(payload))} bytes")
@@ -182,6 +188,12 @@ class TupClient:
         response.raise_for_status()
         return response.json().get("stopped", False)
 
+    def purge_job(self, job_id: str) -> bool:
+        """Permanently delete a job from history."""
+        response = self._client.delete(f"/jobs/{job_id}?purge=true", headers=self._headers())
+        response.raise_for_status()
+        return response.json().get("purged", False)
+
     def get_logs(self, job_id: str) -> str:
         """Get job logs."""
         response = self._client.get(f"/jobs/{job_id}/logs", headers=self._headers())
@@ -193,3 +205,15 @@ class TupClient:
         response = self._client.get("/usage", headers=self._headers())
         response.raise_for_status()
         return response.json()
+
+    def get_status(self) -> dict:
+        """Get global capacity status."""
+        response = self._client.get("/status", headers=self._headers())
+        response.raise_for_status()
+        return response.json()
+
+    def debug_job(self, job_id: str) -> dict:
+        """Get debug info for a job (tmux status, processes, logs)."""
+        response = self._client.get(f"/jobs/{job_id}/debug", headers=self._headers())
+        response.raise_for_status()
+        return response.json()

{vmux_cli-0.5.4 → vmux_cli-0.6.0}/vmux/core.py

@@ -1,6 +1,7 @@
 """Core functionality for vmux."""
 
 import os
+import re
 import signal
 import sys
 import time
@@ -63,6 +64,7 @@ def run_command(
     detach: bool = False,
     ports: list[int] | None = None,
     directory: Path | str | None = None,
+    runtime: str | None = None,
 ) -> str:
     """Run a command in the cloud.
 
@@ -72,6 +74,7 @@ def run_command(
         detach: Return immediately after job starts (don't stream logs)
         ports: Ports to expose for preview URLs (empty = no preview)
         directory: Working directory (default: current directory)
+        runtime: Force runtime ("python", "bun", "node") - auto-detected if None
 
     Returns:
         job_id
@@ -79,6 +82,23 @@ def run_command(
     ports = ports or []
     t_start = time.time()
     directory = Path(directory) if directory else Path.cwd()
+    env_vars = env_vars or {}
+
+    # Auto-inject PORT env var for JS runtimes (Bun, Node)
+    # This matches Vercel/Render behavior where PORT is set automatically
+    if ports and "PORT" not in env_vars:
+        from .deps import is_bun_project
+        parts = command.split() if command and command.strip() else []
+        first_word = parts[0] if parts else ""
+        js_commands = ("node", "bun", "npm", "npx", "yarn", "pnpm", "deno")
+        is_js_runtime = (
+            runtime in ("bun", "node")
+            or first_word in js_commands
+            or is_bun_project(directory)
+        )
+        if is_js_runtime:
+            env_vars["PORT"] = str(ports[0])
+            _debug(f"Injected PORT={ports[0]} for JS runtime")
 
     # Package project (detects editables automatically)
     _debug("Starting package()")
@@ -96,13 +116,11 @@ def run_command(
 
     config = load_config()
 
-    # Merge secrets from keychain with passed env vars (passed takes precedence)
+    # Merge secrets from keychain with env vars (env_vars takes precedence)
     _debug("Loading secrets")
-    merged_env = get_secrets()
-    if env_vars:
-        merged_env.update(env_vars)
-    env_vars = merged_env or None
-    _debug(f"Secrets loaded: {len(merged_env)} keys")
+    secrets = get_secrets()
+    merged_env = {**secrets, **env_vars}  # env_vars overrides secrets
+    _debug(f"Secrets loaded: {len(secrets)} keys")
 
     _debug(f"Total prep time: {time.time() - t_start:.2f}s")
     _debug("Connecting to API...")
@@ -135,20 +153,15 @@ def run_command(
             for event in client.run(
                 command=command,
                 bundle_data=bundle.data,
-                env_vars=env_vars,
+                env_vars=merged_env or None,
                 editables=bundle.editables,
                 ports=ports,
+                runtime=runtime,
                 on_upload_start=on_upload_start,
             ):
                 if "job_id" in event:
                     job_id = event["job_id"]
-                    # In detach mode without ports, return immediately
-                    if detach and not ports:
-                        deploy_time = time.time() - t_bundled
-                        stats = f"[dim]({_format_bytes(bundle_size)} • {_format_duration(deploy_time)})[/dim]"
-                        success(f"Job started: {job_id} {stats}")
-                        console.print(f"[blue]Follow: vmux logs -f {job_id}[/blue]")
-                        return job_id
+                    # Don't return early - wait for "running" status so setup completes
 
                 # Preview URLs arrive early (before "running") - show them immediately
                 if "preview_urls" in event:
@@ -199,7 +212,10 @@ def run_command(
                         sys.exit(1)
 
                 elif "log" in event:
-                    console.print(event["log"], end="")
+                    # Filter out terminal focus escape sequences (^[[I, ^[[O)
+                    log_text = re.sub(r'\x1b\[[IO]', '', event["log"])
+                    if log_text:
+                        console.print(log_text, end="")
 
                 elif "error" in event:
                     error(event["error"])

{vmux_cli-0.5.4 → vmux_cli-0.6.0}/vmux/deps.py

@@ -57,6 +57,17 @@ def is_uv_project(directory: Path) -> bool:
     return (directory / "pyproject.toml").exists() and (directory / "uv.lock").exists()
 
 
+def is_bun_project(directory: Path) -> bool:
+    """Check if directory is a Bun project (has bun.lockb or bunfig.toml)."""
+    if not directory.is_dir():
+        return False
+    return (
+        (directory / "bun.lockb").exists()
+        or (directory / "bun.lock").exists()
+        or (directory / "bunfig.toml").exists()
+    )
+
+
 def parse_imports(script_path: Path) -> list[str]:
     """Extract third-party imports from a Python script."""
     try:
@@ -135,12 +146,17 @@ def find_editable(pkg_name: str) -> EditablePackage | None:
     )
 
 
-def detect_script_deps(script_path: Path) -> ScriptDeps:
+def detect_script_deps(script_path: Path, verbose: bool = True) -> ScriptDeps:
     """Detect dependencies for a standalone script.
 
     Parses imports, finds editable installs.
     The container will install dependencies from the editable's uv.lock/pyproject.toml.
     """
+    from . import ui
+
+    if verbose:
+        ui.dim(f"→ Scanning {script_path.name} imports...")
+
     imports = set(parse_imports(script_path))
 
     editables: list[EditablePackage] = []
@@ -154,6 +170,9 @@ def detect_script_deps(script_path: Path) -> ScriptDeps:
         return find_cache[name]
 
     # Direct editables imported by the script
+    if verbose and imports:
+        ui.dim(f"→ Checking {len(imports)} imports for editables...")
+
     for pkg_name in sorted(imports):
         editable = cached_find(pkg_name)
         if editable and all(e.name != editable.name for e in editables):
@@ -168,6 +187,9 @@ def detect_script_deps(script_path: Path) -> ScriptDeps:
             continue
         scanned_paths.add(editable_path)
 
+        if verbose:
+            ui.dim(f"→ Scanning {editable.name} for transitive deps...")
+
         for dep_name in sorted(scan_imports_in_tree(editable_path)):
             dep_editable = cached_find(dep_name)
             if dep_editable and all(e.name != dep_editable.name for e in editables):