swm-gpu 0.2.2__tar.gz → 0.2.4__tar.gz

swm_gpu-0.2.4/.agents/skills/swm-gpu-workflow/SKILL.md

@@ -0,0 +1,317 @@
+---
+name: swm-gpu-workflow
+description: >
+  Use when the user wants to search cloud GPUs across providers, provision a
+  GPU pod, install AI frameworks (ComfyUI, SwarmUI, vLLM, Ollama, Open WebUI,
+  Axolotl, H2O LLM Studio), pull models from HuggingFace / Civitai / URLs to a
+  unified store, sync workspaces to S3, manage idle-pod lifecycle, or track
+  GPU spend — all via the swm CLI. Do NOT use for general Docker, Kubernetes,
+  or non-GPU cloud tasks.
+license: Apache-2.0
+compatibility: "macOS or Linux, Python 3.11+, SSH client"
+metadata:
+  author: swm-gpu
+  version: "0.2.3"
+  docs-url: https://swmgpu.com
+  repository: https://github.com/swm-gpu/swm
+---
+
+# swm — Cloud GPU Workflow Manager
+
+One CLI to search, provision, install, sync, and tear down GPU pods across 10 cloud providers. Why swm over ad-hoc SSH scripts:
+
+- **Cross-provider search** — `swm gpus` hits 10 providers with live pricing and stock in one call.
+- **Declarative frameworks** — `swm setup install <name>` brings up ComfyUI / SwarmUI / vLLM / Ollama / Open WebUI / Axolotl / llm-studio idempotently; venv, custom nodes, and multi-GPU tensor parallelism handled.
+- **Unified model store** — `swm models pull` auto-detects HF / Civitai / Ollama / URL refs, lands files under `/workspace/models/<bucket>/`, symlinks them into each framework's expected path.
+- **Workspace persistence** — three-tier S3 sync (inotify → s5cmd → tar) survives auto-down. `pod create -w <name>` restores the last session.
+- **Lifecycle guard** — `auto-down` / `auto-stop` / `remind` policies stop idle bills.
+
+> **Stop condition.** Don't hand off until **Phase 5** passes. A pod that's "almost up" still bills.
+
+## Prerequisites
+
+- `swm --version` works (`pipx install swm-gpu` or `brew tap swm-gpu/swm && brew install swm`).
+- `ssh` and `scp` on PATH.
+- At least one provider key: `swm config set runpod.api_key <key>` (or `vastai`, `lambda`, …).
+- Optional `/workspace` persistence: `swm config set b2.key_id …` + `swm config set storage.default b2:<bucket>`.
+
+## Phase 0 — State check
+
+```bash
+swm pod list && swm use --show
+```
+
+If a matching pod is `RUNNING`, set it active (`swm use <name>`) and skip to Phase 5. Otherwise continue.
+
+## Phase 1 — Clarify
+
+Use `AskQuestion`:
+
+| Question | Options |
+|---|---|
+| **VRAM floor**? | `≤16 GB` / `16–24 GB` / `24–48 GB` / `48–80 GB` / `>80 GB` |
+| **Provider**? | `runpod` / `vastai` / `lambda` / `tensordock` / `vultr` / `auto (cheapest)` |
+| **Lifecycle**? | `auto-down` (default) / `auto-stop` / `remind` / `manual` |
+| **Idle timeout**? | `10` / `20` / `30` / `60` / `120` min |
+| Persist `/workspace`? | `yes` (default) / `no — one-shot, --no-storage` |
+
+| VRAM floor | GPU class to search |
+|---|---|
+| ≤16 GB | `RTX 4090`, `A4000`, `RTX 6000 Ada` |
+| 16–24 GB | `RTX 4090`, `RTX 6000 Ada`, `L40S` |
+| 24–48 GB | `A100 40GB`, `A100 80GB`, `L40S` |
+| 48–80 GB | `H100`, `H100 SXM`, `A100 80GB` |
+| >80 GB | `H200`, `B200`, multi-GPU `H100 SXM` |
+
+For unsupported frameworks, read the README for: install method (`pip` vs `uv sync` vs custom), ComfyUI custom node vs standalone server, default ports, model cache location, UI mode toggles.
+
+## Phase 2 — Pick GPU
+
+```bash
+swm gpus -g <class> --sort price --secure | head -20
+```
+
+Pick the cheapest in-stock SKU meeting the VRAM floor. **Capture the exact display name** (e.g. `"NVIDIA H100 80GB HBM3"`) — that's what `-g` on `pod create` wants. Quote it; spaces break shells.
+
+## Phase 3 — Provision
+
+```bash
+swm pod create -p <provider> -g "<gpu-display-name>" \
+  -n <name> --lifecycle <policy> --idle-timeout <min> -y
+```
+
+- `-y` is **mandatory** in agent shells — the `Proceed?` prompt has no fallback.
+- Container disk wipes on stop; only `/workspace` persists. `--volume N` sizes it (RunPod requires `>= 1`).
+- `-w <name>` restores the last workspace pushed under that name.
+- After this the new pod is the active pod; subsequent `swm run` / `swm setup` can omit the id.
+
+## Phase 4 — Install
+
+### 4a. Prefer built-in frameworks
+
+| Framework | Use when |
+|---|---|
+| `comfyui` | Image/video gen, custom-node ecosystems |
+| `swarmui` | Higher-level wrapper around ComfyUI |
+| `vllm` | Multi-GPU LLM serving (OpenAI-compatible) |
+| `ollama` | Single-GPU LLM chat |
+| `open-webui` | ChatGPT-style frontend for Ollama / vLLM |
+| `axolotl` | LLM fine-tuning |
+| `llm-studio` | H2O no-code fine-tuning |
+
+```bash
+swm setup list
+swm setup install <name>                                         # idempotent
+swm setup start   <name>                                         # background, prints proxy URL, probes health
+swm setup start   vllm    --model Qwen/Qwen3-8B                  # vLLM model selection
+swm setup start   comfyui --port 8288 --extra-args "--use-sage-attention"
+swm setup stop    <name>
+```
+
+vLLM auto-detects GPU count for tensor parallelism. swm opens SSH tunnels for unexposed ports and probes `/health` before reporting ready.
+
+### 4b. Custom tools — chain `swm run`
+
+Each `swm run` is its own SSH session. Use absolute paths, `&&`-chain idempotent commands, install into `/workspace`:
+
+```bash
+swm run "pip install -q uv && mkdir -p /workspace/.cache/uv \
+  && cd /workspace && [ -d <repo> ] || git clone --depth 1 <git-url> \
+  && cd <repo> && UV_CACHE_DIR=/workspace/.cache/uv uv sync"
+```
+
+Use `uv sync` over `pip install -e .` when `pyproject.toml` has `[tool.uv.sources]` — pip silently ignores those overrides.
+
+### 4c. ComfyUI custom nodes
+
+Install **before** `swm setup start comfyui`. Custom-node deps go into ComfyUI's venv (not system pip):
+
+```bash
+swm run "cd /workspace/ComfyUI/custom_nodes \
+  && [ -d <node-dir> ] || git clone --depth 1 <git-url> \
+  && /workspace/ComfyUI/venv/bin/pip install -r <node-dir>/requirements.txt"
+```
+
+### 4d. Models — use the unified store
+
+`swm models pull` lands files under `/workspace/models/<bucket>/` and symlinks them into each framework's expected path. Source auto-detected from the ref shape:
+
+```bash
+swm models pull <pod> Qwen/Qwen3-8B                              # HuggingFace
+swm models pull <pod> civitai:1925758 --as lora                  # Civitai
+swm models pull <pod> https://example.com/m.safetensors --as checkpoint   # URL
+swm models pull <pod> ollama:llama3                              # Ollama
+swm models pull <pod> Comfy-Org/Wan_2.2_ComfyUI_Repackaged \
+  --as lora --filename split_files/loras/wan2.2_i2v_lightx2v_4steps_lora_v1_low_noise.safetensors
+
+swm models info <ref>             # metadata before pulling
+swm models list <pod> [--all]     # tracked (+ untracked) files
+swm models link <pod> /abs/path/to/file --as vae
+swm models remove <pod> <name>
+```
+
+API keys (set once; legacy `hf_token` also read):
+
+```bash
+swm config set hf.api_key <token>        # gated HF models
+swm config set civitai.api_key <token>   # Civitai gated / NSFW
+```
+
+`--filename` supports nested HF paths (`split_files/loras/foo.safetensors`). If a bare basename 404s, swm prints matching paths from the repo. Multi-file pulls from one HF repo get distinct manifest entries (`hf:{repo}:{filename}`); no overwrites.
+
+### 4e. Background daemon pattern
+
+Mirror swm's `exec_background`: `nohup … > log 2>&1 < /dev/null &` with `&` **outside** `bash -c`, then sleep + `pgrep` so the call returns non-zero on crash:
+
+```bash
+swm run "nohup env <VAR>=<val> /workspace/<repo>/.venv/bin/<entrypoint> \
+  --host 127.0.0.1 --port <port> > /workspace/<name>.log 2>&1 < /dev/null & \
+  sleep 3 && pgrep -fa <entrypoint> \
+  || (tail -50 /workspace/<name>.log; exit 1)"
+```
+
+Bind `127.0.0.1` for internal services, `0.0.0.0` only if the proxy URL needs to reach it. Omit `< /dev/null` and SSH may hang on stdin.
+
+## Phase 5 — Verify
+
+Every claim must hold before hand-off:
+
+- Framework main port returns `200` (ComfyUI `:8188`, vLLM `:8000/v1/models`, Ollama `:11434/api/tags`, Open WebUI `:8080/api/version`).
+- Side-server `/health` returns `200` (if any).
+- Custom-node directory appears in the host's startup log.
+- Expected node/model types appear in `/object_info` (ComfyUI) or `/v1/models` (vLLM).
+- Checkpoint dirs non-empty and roughly the size from the model card.
+- VRAM in the expected ballpark (low if lazy-loaded, near full after first request).
+- `df -h /workspace` not over 80 %.
+
+If any check fails, iterate on the relevant phase. Don't hand off a half-working pod.
+
+## Phase 6 — Hand off
+
+1. **Public URL** verbatim (RunPod: `https://<pod>-<port>.proxy.runpod.net`).
+2. **Sync status**: `swm sync status <pod>` — confirm watcher running, last push stamp recent.
+3. **Local download** for workflow / config files: `swm download <relative-path> -d ~/Downloads`.
+4. **Framework foot-guns** — spell out UI toggles (e.g. ACE-Step's `cloud → local` mode, model-selector defaults). #1 reason a working pod looks broken.
+5. **Resume command** with `-w <name>` so the next session restores the workspace.
+6. **Log tails**: `swm run "tail -f /tmp/<host>.log"` for live debugging.
+
+See [examples.md](examples.md) for a fully worked run (ACE-Step on H100).
+
+---
+
+# Command reference
+
+## GPU search
+
+```bash
+swm gpus -g h200 --secure --sort price        # filter, secure cloud only, cheapest first
+swm gpus -g h200 -c 4 --max-price 4           # 4×H200 under $4/hr
+swm gpus -p vastai -n 50 --all                # single provider, more rows
+```
+
+Unknown provider slugs raise `UsageError` listing valid ones.
+
+## Pod management
+
+```bash
+swm pod create -p runpod -g h200 -n s1 -y
+swm pod create -p vastai -g h200 -n train --gpu-count 4 --volume 200 --cloud-type SECURE -y
+swm pod list                                  # auto-prunes stale entries vs live provider state
+swm pod status / stop / start / down / prune <pod>
+```
+
+## Sync
+
+```bash
+swm sync pull  [pod]              # storage → pod
+swm sync pull  [pod] --tar        # tarball mode (600k+ small files; fails loudly on error)
+swm sync push  [pod]              # pod → storage
+swm sync watch [pod]              # inotify auto-push
+swm sync status [pod]             # s5cmd, watcher, autosync, pending changes
+```
+
+Three-tier sync: inotify watcher → incremental s5cmd → tar. Push reconciles inotify events with a `find -newer` scan so `pip install` bursts aren't missed. Pull re-runs framework link-repair steps so `/workspace/models/` symlinks stay wired after restore.
+
+## Guard
+
+```bash
+swm guard set <pod> --mode auto-down --idle-timeout 30   # set/update policy
+swm guard set <pod> --mode remind                        # notify-only
+swm guard disable <pod> [--force-manual]                 # remove override / pin manual
+swm guard defaults --mode auto-down --idle-timeout 30    # for new pods
+swm guard list                                           # live status
+swm guard stop-daemon
+```
+
+Monitors 4 signals: SSH sessions (`who`), GPU utilization, filesystem writes, active processes. Setting `auto-stop`/`auto-down` auto-starts the local daemon. `--idle-timeout 0` and `--poll-interval 0` are honored as explicit values (not unset).
+
+## Costs
+
+```bash
+swm costs live                                # right-now burn
+swm costs summary [--period today|...]        # breakdown by provider/pod (today = UTC day)
+swm costs reconcile                           # verify vs provider billing (RunPod, Vast.ai)
+swm costs budget set 100                      # $/month alert
+```
+
+## Remote
+
+```bash
+swm ssh    <pod>
+swm run    [pod] '<cmd>'
+swm upload   [pod] ./local remote/path
+swm download [pod] remote/file -d ~/Downloads
+```
+
+## Pricing reference
+
+```bash
+swm pricing compare  --gpu h100|h200|b200|a100|rtx-4090|l40s
+swm pricing estimate -g h200 --hours 24
+```
+
+## Instance ID format
+
+`provider:id` (`runpod:abc123`, `vastai:34182944`). A bare id auto-resolves by querying configured providers. `swm use <pod>` validates and sets the active pod.
+
+## Providers
+
+| Slug | API | Live pricing |
+|---|---|---|
+| `runpod` | GraphQL | yes |
+| `vastai` | REST | yes |
+| `lambda` | REST | yes |
+| `vultr` | REST | yes |
+| `tensordock` | REST | yes |
+| `fluidstack` | REST | yes |
+| `aws` | boto3 | yes |
+| `gcp` | gcloud CLI | yes |
+| `azure` | az CLI (`pip install swm-gpu[azure]`) | yes |
+| `coreweave` | Kubernetes | yes |
+
+## Storage
+
+S3-compatible via s5cmd. Config keys:
+
+| Backend | Keys |
+|---|---|
+| Backblaze B2 | `b2.key_id`, `b2.app_key`, `b2.bucket` |
+| Amazon S3 | `s3.access_key`, `s3.secret_key`, `s3.bucket` |
+| Google GCS | `gcs.hmac_access`, `gcs.hmac_secret`, `gcp.bucket` |
+
+Default: `swm config set storage.default b2:<bucket>`. Credentials are masked by suffix in `config get/list` and never written to the pod (passed as transient env vars per s5cmd call).
+
+---
+
+## Anti-patterns
+
+- **Never omit `-y` on `swm pod create`** — agent shells hang on the `Proceed?` prompt.
+- **Never install outside `/workspace`** — container disk wipes on stop; only `/workspace` survives auto-down.
+- **Never drop `&` outside `bash -c`** when starting daemons — SSH waits for foreground and `swm run` hangs.
+- **Never reuse one venv across frameworks** with conflicting `torch` pins — separate venvs (~7 GB each) beat dependency hell.
+- **Never trust `pip install -e .`** for projects with `[tool.uv.sources]` — use `uv sync`.
+- **Never `swm run -q`** during initial setup — quiet mode swallows install errors. Reserve `-q` for scripted health checks.
+- **Never tear down before `du -sh /workspace`** — 10–30 GB bloat extends the next pull.
+- **Never guess nested HF file paths** — run `swm models info <repo>` and copy the exact `rfilename`.
+- **Never skip Phase 0** — a forgotten running pod bills silently.
+- **Never hand off** before Phase 5 passes.

swm_gpu-0.2.4/.agents/skills/swm-gpu-workflow/examples.md

@@ -0,0 +1,68 @@
+# swm worked examples
+
+Full end-to-end runs that pass Phase 5. Use these as templates when bringing up a new framework.
+
+## ACE-Step on H100 (ComfyUI custom node + side server)
+
+Music generation with the ACE-Step diffusion model. Two processes: ComfyUI on `:8188` (public via RunPod proxy) and `acestep-openrouter` on `127.0.0.1:8002` (internal, called by the custom node).
+
+```bash
+swm pod create -p runpod -g "NVIDIA H100 80GB HBM3" \
+  -n ace-step-test --lifecycle auto-down --idle-timeout 20 -y
+
+swm setup install comfyui
+
+swm run "pip install -q uv"
+swm run "mkdir -p /workspace/.cache/uv /workspace/.cache/huggingface \
+  && cd /workspace && [ -d ACE-Step-1.5 ] \
+    || git clone --depth 1 https://github.com/ace-step/ACE-Step-1.5.git \
+  && cd ACE-Step-1.5 && UV_CACHE_DIR=/workspace/.cache/uv uv sync"
+
+swm run "cd /workspace/ComfyUI/custom_nodes \
+  && [ -d ACE-Step-ComfyUI ] \
+    || git clone --depth 1 https://github.com/ace-step/ACE-Step-ComfyUI.git \
+  && /workspace/ComfyUI/venv/bin/pip install \
+       -r ACE-Step-ComfyUI/requirements.txt"
+
+swm run "nohup env \
+  ACESTEP_CHECKPOINTS_DIR=/workspace/.cache/acestep-checkpoints \
+  HF_HOME=/workspace/.cache/huggingface \
+  /workspace/ACE-Step-1.5/.venv/bin/acestep-openrouter \
+  --host 127.0.0.1 --port 8002 \
+  > /workspace/acestep.log 2>&1 < /dev/null & \
+  sleep 3 && pgrep -fa acestep-openrouter \
+  || (tail -60 /workspace/acestep.log; exit 1)"
+
+swm setup start comfyui
+```
+
+**Verified end state:**
+
+- ComfyUI 0.19.3 on `:8188`, ACE-Step custom node imported in 0.0 s
+- `acestep-openrouter` on `127.0.0.1:8002`, `/health` → `{"status":"ok"}`, `/v1/models` → `acemusic/acestep-v15-turbo`
+- Checkpoints (9.4 GB) under `/workspace/.cache/acestep-checkpoints/`: `acestep-v15-turbo` (4.5 GB), `acestep-5Hz-lm-1.7B` (3.5 GB), `Qwen3-Embedding-0.6B` (1.2 GB), `vae` (322 MB)
+- Workflow at `/workspace/ComfyUI/custom_nodes/ACE-Step-ComfyUI/workflows/text2music.json`
+- GPU memory 8.6 / 80 GiB before first inference
+
+**Hand-off foot-gun:** `AceStepText2MusicServer` defaults to `cloud` mode and must be flipped to `local` in the ComfyUI node UI — otherwise the H100 sits idle and burns money.
+
+**Switch to XL 4B variant** (without recreating the pod):
+
+```bash
+swm run "pkill -f acestep-openrouter; nohup env \
+  ACESTEP_CONFIG_PATH=acestep-v15-xl-turbo \
+  ACESTEP_CHECKPOINTS_DIR=/workspace/.cache/acestep-checkpoints \
+  HF_HOME=/workspace/.cache/huggingface \
+  /workspace/ACE-Step-1.5/.venv/bin/acestep-openrouter \
+  --host 127.0.0.1 --port 8002 \
+  > /workspace/acestep.log 2>&1 < /dev/null & \
+  sleep 3 && pgrep -fa acestep-openrouter"
+```
+
+**Resume next session** (restores `/workspace` from S3, custom nodes and checkpoints intact):
+
+```bash
+swm pod create -p runpod -g "NVIDIA H100 80GB HBM3" -n ace-step-test \
+  -w ace-step-test --lifecycle auto-down --idle-timeout 20 -y
+swm setup start comfyui
+```

{swm_gpu-0.2.2 → swm_gpu-0.2.4}/CHANGELOG.md

@@ -6,6 +6,62 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-05-27
+
+### Fixed
+- `swm sync push --force` now propagates the s5cmd exit code through the CLI;
+  previously partial failures (e.g. B2 503 SlowDown on a single object) were
+  silently reported as success.
+- `swm sync push --force` advances the push stamp even on partial s5cmd
+  failure during the initial baseline upload, so the next autosync cycle can
+  retry missed files via `find -newer` instead of permanently refusing to start.
+- `swm sync auto --force` touches the push stamp on the pod when missing,
+  matching the client-side `--force` semantics so the daemon's internal stamp
+  check no longer blocks startup after a forced push.
+- `swm pod create -n <name>` (without `-w`) no longer fails when `/workspace`
+  contains files from the docker image — `swm` now uploads the existing
+  contents as the new workspace baseline and starts autosync normally. This
+  was the root cause of silent data loss when a pod was created without `-w`.
+
+### Added
+- `swm pod status <pod>` now reports autosync running state, watcher state,
+  last push age, and pending change count over SSH. Loudly warns when
+  autosync is not running on a pod that has been up > 5 minutes.
+- `swm pod down --force-down` flag to override the new sync-safety guard
+  (terminate even if the workspace push did not write a recent stamp).
+
+### Changed
+- `swm pod down` refuses to wipe `/workspace` or terminate the pod when the
+  workspace push exits non-zero or fails to write a push stamp within the
+  last 10 minutes. The lifecycle guard's `auto-down` path applies the same
+  guard and leaves the pod alive on partial-push failure.
+
+## [0.2.3] - 2026-05-24
+
+### Fixed
+- `swm sync pull --tar` no longer reports success when download/extract fails.
+- `swm models pull` tracks each HF file under a unique manifest key; multi-file
+  repos (e.g. high/low LoRA pairs) no longer overwrite each other.
+- HF pull 404s suggest nested repo paths; `--filename` resolves basenames when unique.
+- `swm guard set` honors `--idle-timeout 0` / `--poll-interval 0` and starts the
+  local guard daemon for auto-stop/auto-down policies.
+- `swm sync status` reports push stamp, watcher, pending changes, and auto-sync.
+- `swm use` validates the pod exists before setting the active pod.
+- SwarmUI install creates `dlbackend` before cloning ComfyUI (fixes #9).
+- `swm gpus -p badslug` errors instead of returning empty results.
+- `swm costs summary --period today` uses UTC calendar day, not rolling 24h.
+- Cost tracking failures on pod lifecycle commands emit dim warnings.
+
+### Changed
+- Removed deprecated shims: `swm models set`, `swm pod gpus`, hidden `setup comfyui` /
+  `setup swarmui`.
+- `swm guard disable --force-manual` pins a pod to manual mode.
+- `swm pricing` supports H100, A100, RTX 4090, and L40S reference data.
+- Shell completion suggests `provider:id` pod references.
+- Config masking uses suffix-based sensitive key detection.
+- Azure optional dependencies in `pyproject.toml` (`pip install swm-gpu[azure]`).
+- Regenerated repo docs (`docs/cli-reference.md`, `docs/configuration.md`).
+
 ## [0.2.2] - 2026-05-24
 
 ### Added

{swm_gpu-0.2.2 → swm_gpu-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swm-gpu
-Version: 0.2.2
+Version: 0.2.4
 Summary: One CLI to search, provision, and manage cloud GPUs across 10 providers
 Project-URL: Homepage, https://swmgpu.com
 Project-URL: Repository, https://github.com/swm-gpu/swm
@@ -29,7 +29,16 @@ Requires-Dist: httpx>=0.27
 Requires-Dist: rich>=13.0
 Requires-Dist: tomli-w>=1.0
 Provides-Extra: all
+Requires-Dist: azure-identity>=1.15; extra == 'all'
+Requires-Dist: azure-mgmt-compute>=30.0; extra == 'all'
+Requires-Dist: azure-mgmt-network>=25.0; extra == 'all'
+Requires-Dist: azure-mgmt-resource>=23.0; extra == 'all'
 Requires-Dist: kubernetes>=29.0; extra == 'all'
+Provides-Extra: azure
+Requires-Dist: azure-identity>=1.15; extra == 'azure'
+Requires-Dist: azure-mgmt-compute>=30.0; extra == 'azure'
+Requires-Dist: azure-mgmt-network>=25.0; extra == 'azure'
+Requires-Dist: azure-mgmt-resource>=23.0; extra == 'azure'
 Provides-Extra: coreweave
 Requires-Dist: kubernetes>=29.0; extra == 'coreweave'
 Provides-Extra: dev

{swm_gpu-0.2.2 → swm_gpu-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "swm-gpu"
-version = "0.2.2"
+version = "0.2.4"
 description = "One CLI to search, provision, and manage cloud GPUs across 10 providers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -30,8 +30,14 @@ dependencies = [
 
 [project.optional-dependencies]
 coreweave = ["kubernetes>=29.0"]
+azure = [
+    "azure-identity>=1.15",
+    "azure-mgmt-compute>=30.0",
+    "azure-mgmt-network>=25.0",
+    "azure-mgmt-resource>=23.0",
+]
 dev = ["nuitka", "ordered-set", "zstandard"]
-all = ["kubernetes>=29.0"]
+all = ["kubernetes>=29.0", "azure-identity>=1.15", "azure-mgmt-compute>=30.0", "azure-mgmt-network>=25.0", "azure-mgmt-resource>=23.0"]
 
 [project.urls]
 Homepage = "https://swmgpu.com"

swm_gpu-0.2.4/src/swm/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.4"

{swm_gpu-0.2.2 → swm_gpu-0.2.4}/src/swm/bootstrap.py

@@ -309,20 +309,29 @@ _WS_MARKER_NAMES = (
 )
 
 
-def _ensure_workspace_empty_on_pod(session: RemoteSession) -> None:
-    """Raise if /workspace/ on the pod contains any non-marker files.
+def _workspace_leftover_files(session: RemoteSession) -> list[str]:
+    """Return paths in /workspace/ that aren't swm markers.
 
-    A blind ``touch PUSH_STAMP`` on a non-empty workspace would silently
-    declare those files synced even though they were never uploaded.
-    Refuse, and tell the user to push or clear before attaching.
+    Non-marker files commonly appear because docker images use
+    /workspace as a default WORKDIR and seed it with content (e.g. the
+    pytorch base image). Callers decide how to handle these — usually
+    by uploading them as the initial baseline rather than failing.
     """
     excludes = " ".join(f"-not -name '{n}'" for n in _WS_MARKER_NAMES)
     cmd = (
-        f"find /workspace -mindepth 1 -maxdepth 1 {excludes} 2>/dev/null "
-        "| head -5"
+        f"find /workspace -mindepth 1 -maxdepth 1 {excludes} 2>/dev/null"
     )
     _, out, _ = session.exec(cmd, stream=False)
-    leftover = [line for line in out.splitlines() if line.strip()]
+    return [line for line in out.splitlines() if line.strip()]
+
+
+def _ensure_workspace_empty_on_pod(session: RemoteSession) -> None:
+    """Raise if /workspace/ on the pod contains any non-marker files.
+
+    Retained for callers that want the strict behavior. Most call sites
+    should prefer ``_workspace_leftover_files`` and seed-by-pushing.
+    """
+    leftover = _workspace_leftover_files(session)
     if leftover:
         sample = ", ".join(p.rsplit("/", 1)[-1] for p in leftover[:3])
         more = "" if len(leftover) <= 3 else f" (+ more)"
@@ -381,14 +390,49 @@ def bootstrap_workspace_on_pod(
     if storage_ok:
         try:
             if is_new:
-                _ensure_workspace_empty_on_pod(session)
-                _con.print("  [dim]New workspace — skipping pull[/dim]")
-                session.exec(
-                    f": > {WATCH_LOG} 2>/dev/null; touch {PUSH_STAMP}",
-                    stream=False,
-                )
-                if start_watcher(session, "/workspace"):
-                    _con.print("  [dim]Watcher started for change tracking[/dim]")
+                # Docker images commonly seed /workspace with content
+                # (e.g. pytorch base image). Rather than fail bootstrap
+                # and leave the pod without autosync — the historical
+                # failure mode that caused silent data loss — seed the
+                # new workspace by uploading whatever is already on the
+                # pod as the initial baseline.
+                leftover = _workspace_leftover_files(session)
+                if leftover:
+                    sample = ", ".join(
+                        p.rsplit("/", 1)[-1] for p in leftover[:3]
+                    )
+                    more = (
+                        "" if len(leftover) <= 3
+                        else f" (+ {len(leftover) - 3} more)"
+                    )
+                    _con.print(
+                        f"  [yellow]/workspace contains existing files "
+                        f"(e.g. {sample}{more}) — uploading them as the "
+                        f"new workspace baseline before starting "
+                        f"auto-sync.[/yellow]"
+                    )
+                    from swm.sync.push import workspace_push
+                    rc = workspace_push(
+                        session, storage_slug, bucket, workspace,
+                        extra_excludes=extra_excludes, force=True,
+                    )
+                    if rc != 0:
+                        raise RuntimeError(
+                            f"Initial baseline push failed (s5cmd exit "
+                            f"{rc}). Re-run `swm sync push "
+                            f"{qualified_id} --force` then "
+                            f"`swm sync auto {qualified_id}`."
+                        )
+                else:
+                    _con.print("  [dim]New workspace — skipping pull[/dim]")
+                    session.exec(
+                        f": > {WATCH_LOG} 2>/dev/null; touch {PUSH_STAMP}",
+                        stream=False,
+                    )
+                    if start_watcher(session, "/workspace"):
+                        _con.print(
+                            "  [dim]Watcher started for change tracking[/dim]"
+                        )
             else:
                 workspace_pull(
                     session, storage_slug, bucket, workspace,

{swm_gpu-0.2.2 → swm_gpu-0.2.4}/src/swm/cli.py

@@ -32,7 +32,11 @@ Workflow:
 @click.group(epilog=_WORKFLOW_EPILOG)
 @click.version_option(__version__, prog_name="swm")
 def main():
-    """swm — Cloud GPU workflow manager for ComfyUI / SwarmUI."""
+    """swm — Cloud GPU workflow manager across 10 providers.
+
+    Search GPUs, provision pods, install frameworks (ComfyUI, vLLM, Ollama, …),
+    sync workspaces, manage models, and automate lifecycle with guard policies.
+    """
 
 
 # ── GPU search (top-level, kept here for brevity) ──────────────────
@@ -103,7 +107,10 @@ def gpus(gpu: str | None, gpu_count: int | None, max_price: float | None,
         try:
             sources = [get_provider(provider)]
         except ValueError:
-            sources = []
+            known = ", ".join(sorted(_SLUG_TO_NAME))
+            raise click.UsageError(
+                f"Unknown provider {provider!r}. Known slugs: {known}"
+            ) from None
     else:
         configured = get_configured_providers()
         unconfigured_slugs = (

{swm_gpu-0.2.2 → swm_gpu-0.2.4}/src/swm/commands/_helpers.py

@@ -63,16 +63,29 @@ def resolve_active_pod(instance_id: str | None) -> str:
 
 
 def _iter_configured_pod_ids() -> list[str]:
-    """Return pod ids known to swm's config (`pods.<provider:id>`)."""
+    """Return qualified pod ids known to swm's config (`provider:id`)."""
     pods = cfg.get("pods") or {}
     if not isinstance(pods, dict):
         return []
-    return sorted(pods.keys())
+    out: list[str] = []
+    for pid, meta in pods.items():
+        prov = (meta or {}).get("provider", "")
+        out.append(f"{prov}:{pid}" if prov else pid)
+    return sorted(out)
 
 
 def complete_pod_id(ctx, param, incomplete: str):
     """Click shell completion callback for pod id arguments."""
-    return [pid for pid in _iter_configured_pod_ids() if pid.startswith(incomplete)]
+    pods = cfg.get("pods") or {}
+    if not isinstance(pods, dict):
+        return []
+    candidates: set[str] = set()
+    for pid, meta in pods.items():
+        prov = (meta or {}).get("provider", "")
+        qid = f"{prov}:{pid}" if prov else pid
+        candidates.add(qid)
+        candidates.add(pid)
+    return sorted(c for c in candidates if c.startswith(incomplete))
 
 
 def pod_arg_callback(ctx, param, value):
@@ -94,7 +107,8 @@ def looks_like_pod_id(value: str) -> bool:
         return False
     if any(value.startswith(p) for p in _PROVIDER_PREFIXES):
         return True
-    return value in _iter_configured_pod_ids()
+    pods = cfg.get("pods") or {}
+    return isinstance(pods, dict) and value in pods
 
 
 def split_pod_and_command(