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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vmux-cli
-Version: 0.5.4
+Version: 0.5.5
 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.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vmux-cli"
-version = "0.5.4"
+version = "0.5.5"
 description = "Run anything in the cloud. Replace uv run with vmux run."
 readme = "README.md"
 license = "MIT"

{vmux_cli-0.5.4 → vmux_cli-0.5.5}/uv.lock

@@ -827,7 +827,7 @@ wheels = [
 
 [[package]]
 name = "vmux-cli"
-version = "0.5.3"
+version = "0.5.4"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

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

@@ -61,7 +61,7 @@ def run(detach: bool, port: tuple[int, ...], preview: bool, env: tuple[str, ...]
         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 +69,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 +123,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 +274,74 @@ 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.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."""

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

@@ -182,6 +182,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 +199,9 @@ 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()

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

@@ -135,12 +135,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 +159,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 +176,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):

{vmux_cli-0.5.4 → vmux_cli-0.5.5}/vmux/terminal.py

@@ -48,8 +48,7 @@ def print_attach_header(job_id: str) -> None:
     print(f"{c.CYAN}{c.BOLD}  VMUX ATTACH: {c.GREEN}{job_id}{c.RESET}")
     print(f"{c.CYAN}{c.BOLD}{'=' * width}{c.RESET}")
     print()
-    print(f"{c.DIM}  Connecting to cloud container...{c.RESET}")
-    print()
+    print(f"{c.DIM}  Connecting to cloud container...{c.RESET}", end="", flush=True)
 
 
 def print_attach_connected(job_id: str) -> None:
@@ -133,8 +132,28 @@ async def run_attach(job_id: str, config: "VmuxConfig") -> None:
             ws_url,
             additional_headers={"Authorization": f"Bearer {config.auth_token}"},
         ) as ws:
-            # Wait for connected message
-            msg = await asyncio.wait_for(ws.recv(), timeout=10.0)
+            # Wait for connected message with spinner
+            spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+            frame_idx = 0
+
+            async def show_spinner() -> None:
+                nonlocal frame_idx
+                while True:
+                    print(f"\r{Colors.DIM}  Connecting to cloud container... {spinner_frames[frame_idx]}{Colors.RESET}", end="", flush=True)
+                    frame_idx = (frame_idx + 1) % len(spinner_frames)
+                    await asyncio.sleep(0.1)
+
+            spinner_task = asyncio.create_task(show_spinner())
+            try:
+                msg = await asyncio.wait_for(ws.recv(), timeout=30.0)  # Increased timeout for cold containers
+            finally:
+                spinner_task.cancel()
+                try:
+                    await spinner_task
+                except asyncio.CancelledError:
+                    pass
+                print("\r" + " " * 50 + "\r", end="")  # Clear spinner line
+
             data = json.loads(msg)
 
             if data.get("type") == "error":