Upload folder using huggingface_hub

Dockerfile.sd-cli-cu12

@@ -0,0 +1,109 @@
+# Dockerfile.sd-cli-cu12 — arch-correct multi-arch sd-cli (CUDA 12.8 toolchain)
+# ---------------------------------------------------------------------------
+# WHY THIS EXISTS
+#   The prebuilt sd-cli currently shipped at /download/sd-cli-cu12 was compiled
+#   on CUDA 12.4 with NO CMAKE_CUDA_ARCHITECTURES, so it emits no sm_120 SASS
+#   and throws "no kernel image is available for execution on the device" on
+#   Blackwell (RTX 50-series, sm_120) cards. sd-cli powers EVERY sdcpp model
+#   (z-image, SD3.5, FLUX.2-klein, HiDream, WAN), so all of them are dead on
+#   Blackwell until this fat binary replaces it.
+#
+# WHAT CHANGED vs the golden recipe
+#   NOTHING except the architecture list. Same upstream repo, same pinned ref,
+#   same feature flags (-DSD_CUDA=ON -DSD_WEBM=ON -DSD_WEBP=ON). The ONLY added
+#   flag is -DCMAKE_CUDA_ARCHITECTURES, which makes this a strict SUPERSET of
+#   the current binary: it still runs on every card the old one did (Turing,
+#   Ampere, Ada, Hopper) AND adds Blackwell (sm_120) + a 120-virtual PTX tail
+#   for forward-compat JIT on future archs.
+#
+# ARCH LIST (CUDA 12.8 — broad coverage of older cards)
+#   70-real   Volta      (V100)
+#   75-real   Turing     (RTX 20xx, T4, GTX 16xx)
+#   80-real   Ampere     (A100)
+#   86-real   Ampere     (RTX 30xx, A10, A40)
+#   89-real   Ada        (RTX 40xx, L4, L40)
+#   90-real   Hopper     (H100, H200)
+#   100-real  Blackwell DC (B100/B200, GB100)
+#   120-real  Blackwell  (RTX 50xx, GB202)  <-- the whole point
+#   120-virtual  PTX tail for compute_120 (JIT forward-compat)
+#   The "-real" suffix bakes SASS cubins; "-virtual" bakes PTX. CUDA 12.8 is the
+#   first toolkit that supports sm_100 + sm_120, so 12.8.x is the FLOOR for this
+#   image — do not downgrade the base.
+#
+# VERIFY THE LIST: the build prints `nvcc --list-gpu-arch` below. If cmake errors
+# with "unsupported gpu architecture", reconcile CUDA_ARCHS against that printout
+# (a listed-but-unsupported arch fails the build — that is the guard, by design).
+#
+# This image is NOT shipped. The operator builds it, extracts /out/sd-cli, and
+# (after Blackwell validation + Ada/Ampere regression) scp's the binary to the
+# VPS. See docs/build/build-and-validate-sd-cli.sh.
+# ---------------------------------------------------------------------------
+
+# CUDA 12.8 devel (toolchain + headers). 22.04 base → glibc 2.35 floor, which
+# keeps the extracted binary portable across the varied provider boxes that pull
+# it. Bump the patch tag (12.8.x) only to another tag that exists on Docker Hub.
+# Tag VERIFIED present on Docker Hub 2026-06-11 (nvidia/cuda registry).
+FROM nvidia/cuda:12.8.1-devel-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      git cmake build-essential binutils ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# --- Identical upstream source to the golden recipe ------------------------
+# Repo + ref are LOCKED to what docs/golden-provider-image.md validated. These
+# pin the feature set (--ref-image, --llm_vision, vid_gen, --diffusion-fa) that
+# image-edit + video depend on. DO NOT change the repo or ref to "add arches" —
+# arches are added purely via CMAKE_CUDA_ARCHITECTURES below.
+ARG SDCPP_REPO=https://github.com/leejet/stable-diffusion.cpp
+# Pinned to the leejet release TAG master-656-0e4ee04 (full SHA
+# 0e4ee04488159b81d95a9ffcd983a077fd5dcb77, dated 2026-05-28). A named release
+# tag is preferred over a bare 7-char short hash: immutable, unambiguous as the
+# repo grows, and self-documenting. This is the SAME commit the golden recipe
+# validated — all four required flags (--ref-image, --llm_vision, vid_gen,
+# --diffusion-fa) are registered in examples/common/common.cpp at this ref, so
+# the build carries them. See docs/golden-provider-image.md (SOURCE OF TRUTH).
+ARG SDCPP_REF=master-656-0e4ee04
+
+# Broadest set CUDA 12.8 supports, ALWAYS including 120-real + 120-virtual.
+ARG CUDA_ARCHS="70-real;75-real;80-real;86-real;89-real;90-real;100-real;120-real;120-virtual"
+
+WORKDIR /opt
+RUN git clone "${SDCPP_REPO}" sdcpp \
+ && cd sdcpp \
+ && git checkout "${SDCPP_REF}" \
+ && git submodule update --init --recursive
+
+WORKDIR /opt/sdcpp
+
+# Print the toolkit's ground-truth arch list for operator verification. The
+# build log will show this right before configure; cross-check CUDA_ARCHS here.
+RUN echo "=== nvcc --list-gpu-arch (CUDA 12.8) ===" && nvcc --list-gpu-arch && \
+    echo "=== CMAKE_CUDA_ARCHITECTURES = ${CUDA_ARCHS} ==="
+
+# IDENTICAL cmake flags to the golden recipe + the one functional add:
+# -DCMAKE_CUDA_ARCHITECTURES. ggml (sd.cpp's CUDA backend) honors the standard
+# CMAKE_CUDA_ARCHITECTURES var; if a future ggml bump ignores it, the fallback
+# is -DGGML_CUDA_ARCHITECTURES with the same value.
+RUN cmake -B build \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DSD_CUDA=ON -DSD_WEBM=ON -DSD_WEBP=ON \
+      -DCMAKE_CUDA_ARCHITECTURES="${CUDA_ARCHS}" \
+ && cmake --build build --config Release --target sd-cli -j"$(nproc)"
+
+# Park the binary at a known path for `docker create` + `docker cp` extraction.
+RUN mkdir -p /out \
+ && cp "$(find build -name sd-cli -type f -perm -u+x | head -n1)" /out/sd-cli \
+ && chmod 755 /out/sd-cli \
+ && echo "sd-cli (cu12 fat binary) staged at /out/sd-cli"
+
+# Flag sanity — GPU-FREE. Do NOT run the binary here. The docker BUILD sandbox has
+# no GPU: libcuda is only present at `docker run --gpus`, so `/out/sd-cli --help`
+# can fail to init the CUDA backend and error out BEFORE printing its flags — which
+# would falsely trip "missing flags" on a perfectly good build. Instead, confirm the
+# flag literals are baked into the binary's string table; `strings` needs no CUDA.
+# The real runtime check (--help + a generation) runs WITH the GPU in
+# build-and-validate-sd-cli.sh, the only place the binary can actually execute.
+RUN strings /out/sd-cli | grep -E -- '--ref-image|--llm_vision|vid_gen|--diffusion-fa' \
+      || (echo "BUILD MISSING REQUIRED FLAG LITERALS — wrong ref?" && exit 1)

Dockerfile.sd-cli-cu13

@@ -0,0 +1,86 @@
+# Dockerfile.sd-cli-cu13 — arch-correct multi-arch sd-cli (CUDA 13 toolchain)
+# ---------------------------------------------------------------------------
+# Companion to Dockerfile.sd-cli-cu12. Same upstream repo + ref + feature flags;
+# the ONLY difference between the two images is the CUDA toolkit and therefore
+# the architecture list. See Dockerfile.sd-cli-cu12 for the full "why".
+#
+# WHY A SEPARATE CUDA 13 IMAGE
+#   setup.py picks the prebuilt by driver: `cu13` when the host CUDA major >= 13,
+#   else `cu12` (downloads/setup.py fetch_or_build_sdcli). A binary built against
+#   the CUDA 13 runtime needs the CUDA 13 toolchain. Blackwell boxes on a CUDA 13
+#   driver pull THIS one.
+#
+# CUDA 13 RAISED ITS ARCH FLOOR — the lists differ BY DESIGN.
+#   CUDA 13 dropped the older virtual/real arches (Maxwell sm_50/52/53, Pascal
+#   sm_60/61/62, and Volta sm_70). Its supported floor is Turing sm_75. So the
+#   cu13 list starts at 75-real (NOT 70-real like cu12) and runs up through 120:
+#   75-real   Turing     (RTX 20xx, T4)
+#   80-real   Ampere     (A100)
+#   86-real   Ampere     (RTX 30xx, A10, A40)
+#   89-real   Ada        (RTX 40xx, L4, L40)
+#   90-real   Hopper     (H100, H200)
+#   100-real  Blackwell DC (B100/B200)
+#   120-real  Blackwell  (RTX 50xx)  <-- the whole point
+#   120-virtual  PTX tail for compute_120 (JIT forward-compat)
+#   Putting 70-real here would FAIL the build (sm_70 unsupported in CUDA 13) —
+#   that is the intended divergence, not an omission. Volta/Pascal/Maxwell users
+#   stay on the cu12 binary, which setup.py already routes them to.
+#
+# VERIFY: the build prints `nvcc --list-gpu-arch` (CUDA 13) below. If cmake errors
+# on an unsupported arch, reconcile CUDA_ARCHS against that printout.
+# ---------------------------------------------------------------------------
+
+# CUDA 13 devel. Keep ubuntu22.04 (glibc 2.35) for binary portability, matching
+# the cu12 image. VERIFIED 2026-06-11: nvidia/cuda:13.0.1-devel-ubuntu22.04 DOES
+# exist on Docker Hub, so cu13 stays on 22.04 / glibc 2.35 — NO elevated glibc
+# floor vs cu12. (13.0.1-devel-ubuntu24.04 also exists; only fall back to it if a
+# future 13.x drops the 22.04 variant — that would raise the binary's floor to
+# glibc 2.39 on provider boxes, so note it on swap if you ever do.)
+FROM nvidia/cuda:13.0.1-devel-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      git cmake build-essential binutils ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Same locked upstream as the golden recipe and the cu12 image. Pinned to the
+# leejet release TAG master-656-0e4ee04 (full SHA
+# 0e4ee04488159b81d95a9ffcd983a077fd5dcb77, dated 2026-05-28) — a named tag,
+# not a bare short hash. All four required flags (--ref-image, --llm_vision,
+# vid_gen, --diffusion-fa) are present in examples/common/common.cpp at this ref.
+ARG SDCPP_REPO=https://github.com/leejet/stable-diffusion.cpp
+ARG SDCPP_REF=master-656-0e4ee04
+
+# Broadest set CUDA 13 supports (floor = sm_75), ALWAYS including 120-real +
+# 120-virtual. NOTE the absence of 70-real vs the cu12 list — intentional.
+ARG CUDA_ARCHS="75-real;80-real;86-real;89-real;90-real;100-real;120-real;120-virtual"
+
+WORKDIR /opt
+RUN git clone "${SDCPP_REPO}" sdcpp \
+ && cd sdcpp \
+ && git checkout "${SDCPP_REF}" \
+ && git submodule update --init --recursive
+
+WORKDIR /opt/sdcpp
+
+RUN echo "=== nvcc --list-gpu-arch (CUDA 13) ===" && nvcc --list-gpu-arch && \
+    echo "=== CMAKE_CUDA_ARCHITECTURES = ${CUDA_ARCHS} ==="
+
+RUN cmake -B build \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DSD_CUDA=ON -DSD_WEBM=ON -DSD_WEBP=ON \
+      -DCMAKE_CUDA_ARCHITECTURES="${CUDA_ARCHS}" \
+ && cmake --build build --config Release --target sd-cli -j"$(nproc)"
+
+RUN mkdir -p /out \
+ && cp "$(find build -name sd-cli -type f -perm -u+x | head -n1)" /out/sd-cli \
+ && chmod 755 /out/sd-cli \
+ && echo "sd-cli (cu13 fat binary) staged at /out/sd-cli"
+
+# Flag sanity — GPU-FREE (see Dockerfile.sd-cli-cu12 for the full why). The build
+# sandbox has no GPU, so running `/out/sd-cli --help` can error before printing and
+# falsely report "missing flags". Check the binary's string table instead — no CUDA
+# needed. The real runtime check runs WITH the GPU in build-and-validate-sd-cli.sh.
+RUN strings /out/sd-cli | grep -E -- '--ref-image|--llm_vision|vid_gen|--diffusion-fa' \
+      || (echo "BUILD MISSING REQUIRED FLAG LITERALS — wrong ref?" && exit 1)

LICENSE

@@ -0,0 +1,15 @@
+MIT License — build recipe © 2026 DEcntAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY ARISING FROM THE USE OF THE SOFTWARE.

NOTICE

@@ -0,0 +1,6 @@
+Prebuilt sd-cli binaries (in Releases) are compiled from:
+  stable-diffusion.cpp - https://github.com/leejet/stable-diffusion.cpp (MIT)
+  ggml                 - https://github.com/ggml-org/ggml (MIT)
+built at ref master-656-0e4ee04. Credit for the inference engine goes to
+leejet and the ggml authors. This repo adds only a multi-arch build recipe
+(CUDA 12/13, sm_70 through sm_120 incl. Blackwell).

README.md

@@ -0,0 +1,19 @@
+# sd-cli - multi-arch stable-diffusion.cpp builds (incl. Blackwell)
+
+Prebuilt `sd-cli` binaries from leejet/stable-diffusion.cpp @ `master-656-0e4ee04`,
+plus the build recipe. Two CUDA variants, both carrying `sm_120` (Blackwell):
+
+| binary        | toolkit | arches (real + PTX)                  | driver floor  |
+|---------------|---------|--------------------------------------|---------------|
+| `sd-cli-cu12` | 12.8    | 70 75 80 86 89 90 100 120 (+120 PTX) | sm_70 (Volta) |
+| `sd-cli-cu13` | 13.0    | 75 80 86 89 90 100 120 (+120 PTX)    | sm_75 (Turing)|
+
+Download from **Releases**. Dynamically linked against the CUDA runtime
+(cudart/cublas/nccl) - same as upstream - so run on a box where those are on
+the loader path (a PyTorch/CUDA image, or `pip install nvidia-cuda-runtime-cu12
+nvidia-cublas-cu12 nvidia-nccl-cu12` + LD_LIBRARY_PATH). Build it yourself via
+the included Dockerfiles + `build-and-validate-sd-cli.sh`.
+
+## License
+Build recipe: MIT (see LICENSE). Binaries derive from stable-diffusion.cpp and
+ggml, both MIT - see NOTICE.

build-and-validate-sd-cli.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+# build-and-validate-sd-cli.sh
+# ===========================================================================
+# OPERATOR script. Run this ON A REAL BLACKWELL (RTX 50-series, sm_120) NODE
+# that has Docker + the NVIDIA container toolkit. It:
+#   1. Builds BOTH arch-correct sd-cli images (cu12 + cu13).
+#   2. Extracts BOTH binaries to ./dist/ locally (no container left running).
+#   3. Runs a REAL generation with the arch-matching binary against a small
+#      sdcpp model and greps the output for "no kernel image" / failure.
+#      (NOT `--help` — that never loads a CUDA kernel and would falsely pass.)
+#   4. PRINTS (does NOT perform) the final scp to the VPS downloads/ dir, plus
+#      the Ada/Ampere regression-test reminder.
+#
+# This script never scp's, never touches the live /download/sd-cli-* binaries,
+# and never runs on the VPS. It builds + validates only. The live swap is a
+# deliberate, separate, manual step you perform AFTER the checks below pass.
+#
+# DISK NOTE: the CUDA *-devel base images are several GB each; both builds plus
+# layers can exceed ~30 GB. Point Docker's data-root at a big volume first, e.g.
+#   sudo mkdir -p /mnt/big/docker
+#   echo '{"data-root":"/mnt/big/docker"}' | sudo tee /etc/docker/daemon.json
+#   sudo systemctl restart docker
+# ===========================================================================
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DIST="${HERE}/dist"
+mkdir -p "${DIST}"
+
+# --- Tunables (override via env) -------------------------------------------
+# A small sdcpp model + a real generation command. sd-cli MUST actually load a
+# CUDA kernel for this to prove sm_120 works, so point MODEL at a small checkpoint
+# already on this box (e.g. an SD1.5 / z-image GGUF). Adjust GEN_ARGS to whatever
+# minimal valid invocation your model needs.
+MODEL="${MODEL:-/workspace/models/sd-v1-5.safetensors}"
+GEN_PROMPT="${GEN_PROMPT:-a red apple on a table}"
+GEN_OUT="${GEN_OUT:-${DIST}/_validate_out.png}"
+# Keep it tiny + fast: small res, few steps. Override if your model needs more.
+GEN_ARGS="${GEN_ARGS:---steps 4 -W 256 -H 256 --cfg-scale 1.0}"
+
+VPS_USER="${VPS_USER:-youruser}"
+VPS_HOST="${VPS_HOST:-your.server.example}"
+VPS_DLDIR="${VPS_DLDIR:-/path/to/your/downloads}"
+
+CU12_IMG="decntai/sd-cli-build:cu12"
+CU13_IMG="decntai/sd-cli-build:cu13"
+
+say() { printf '\n\033[1;36m== %s ==\033[0m\n' "$*"; }
+warn() { printf '\033[1;33m%s\033[0m\n' "$*"; }
+die() { printf '\033[1;31mFATAL: %s\033[0m\n' "$*" >&2; exit 1; }
+
+command -v docker >/dev/null || die "docker not found"
+command -v nvidia-smi >/dev/null || warn "nvidia-smi not found — is this a GPU box?"
+
+# --- 1. Build both images --------------------------------------------------
+say "Building cu12 image (${CU12_IMG})"
+docker build -f "${HERE}/Dockerfile.sd-cli-cu12" -t "${CU12_IMG}" "${HERE}" \
+  || die "cu12 build failed (check the nvcc --list-gpu-arch printout vs CUDA_ARCHS)"
+
+say "Building cu13 image (${CU13_IMG})"
+docker build -f "${HERE}/Dockerfile.sd-cli-cu13" -t "${CU13_IMG}" "${HERE}" \
+  || die "cu13 build failed (check the nvcc --list-gpu-arch printout vs CUDA_ARCHS)"
+
+# --- 2. Extract both binaries to ./dist ------------------------------------
+extract() {  # $1=image  $2=dest
+  local cid
+  cid="$(docker create "$1")" || die "docker create $1 failed"
+  docker cp "${cid}:/out/sd-cli" "$2" || { docker rm -f "${cid}" >/dev/null; die "cp from $1 failed"; }
+  docker rm -f "${cid}" >/dev/null
+  chmod 755 "$2"
+  printf '  extracted %s (%s MB)\n' "$2" "$(( $(stat -c%s "$2") / 1024 / 1024 ))"
+}
+say "Extracting binaries to ${DIST}"
+extract "${CU12_IMG}" "${DIST}/sd-cli-cu12"
+extract "${CU13_IMG}" "${DIST}/sd-cli-cu13"
+
+# --- 3. REAL generation with the arch-matching binary ----------------------
+# Pick the binary by host CUDA major (mirrors setup.py's fetch logic).
+CUDA_MAJOR="$(nvidia-smi --query-gpu=driver_version --format=csv,noheader 2>/dev/null | head -n1 | cut -d. -f1)"
+# driver_version major != CUDA major; the reliable signal is `nvcc` if present,
+# else fall back to the CUDA runtime reported by nvidia-smi.
+if command -v nvcc >/dev/null; then
+  TK_MAJOR="$(nvcc --version | grep -oE 'release [0-9]+' | grep -oE '[0-9]+' | head -n1)"
+else
+  TK_MAJOR="$(nvidia-smi | grep -oE 'CUDA Version: [0-9]+' | grep -oE '[0-9]+' | head -n1)"
+fi
+TK_MAJOR="${TK_MAJOR:-12}"
+if [ "${TK_MAJOR}" -ge 13 ]; then
+  VAL_BIN="${DIST}/sd-cli-cu13"; VAL_ARCH="cu13"
+else
+  VAL_BIN="${DIST}/sd-cli-cu12"; VAL_ARCH="cu12"
+fi
+
+# --- 3a. Runtime flag check (functional — moved OUT of the Dockerfiles) -------
+# THIS is the right place to run the binary: this is a GPU box (libcuda present),
+# unlike the docker BUILD sandbox where `--help` can fail to init CUDA and error
+# before printing. The Dockerfiles only do a GPU-free `strings` smoke; here we
+# assert all four required flags actually surface in --help on real hardware.
+say "Runtime flag check: ${VAL_ARCH} --help must list all four required flags"
+HELP_OUT="$("${VAL_BIN}" --help 2>&1 || true)"
+for f in '--ref-image' '--llm_vision' 'vid_gen' '--diffusion-fa'; do
+  echo "${HELP_OUT}" | grep -qF -- "$f" \
+    || die "Required flag '$f' absent from ${VAL_ARCH} --help — wrong/old ref? Do NOT ship."
+done
+say "All four required flags present in ${VAL_ARCH} --help"
+
+say "Validating ${VAL_ARCH} binary on THIS GPU with a real generation"
+if [ ! -f "${MODEL}" ]; then
+  warn "MODEL not found at ${MODEL}."
+  warn "Set MODEL=/path/to/a/small/sdcpp/checkpoint and re-run. CANNOT validate"
+  warn "sm_120 without loading a real CUDA kernel — skipping gen, build NOT proven."
+  exit 2
+fi
+
+rm -f "${GEN_OUT}"
+GEN_LOG="${DIST}/_validate_${VAL_ARCH}.log"
+# shellcheck disable=SC2086
+"${VAL_BIN}" -m "${MODEL}" -p "${GEN_PROMPT}" -o "${GEN_OUT}" ${GEN_ARGS} \
+  > "${GEN_LOG}" 2>&1
+GEN_RC=$?
+
+echo "  exit=${GEN_RC}  log=${GEN_LOG}"
+if grep -qiE 'no kernel image|invalid device function|CUDA error|out of memory|failed' "${GEN_LOG}"; then
+  warn "---- offending log lines ----"
+  grep -niE 'no kernel image|invalid device function|CUDA error|out of memory|failed' "${GEN_LOG}" | sed 's/^/    /'
+  die "Generation reported a CUDA/kernel failure on sm_120 — the fat binary is NOT good. Do NOT ship."
+fi
+if [ "${GEN_RC}" -ne 0 ] || [ ! -s "${GEN_OUT}" ]; then
+  die "Generation exited ${GEN_RC} or produced no output (${GEN_OUT}). Do NOT ship."
+fi
+say "VALIDATION PASSED on Blackwell (${VAL_ARCH}) — real image written to ${GEN_OUT}"
+
+# --- 4. Next steps: PRINT ONLY (no scp performed here) ---------------------
+cat <<EOF
+
+============================================================================
+ NEXT STEPS — performed MANUALLY by you, NOT by this script
+============================================================================
+ 1) REGRESSION TEST FIRST. Before any live swap, run the SAME real generation
+    with the matching binary on an Ada (sm_89, e.g. RTX 4060) AND an Ampere
+    (sm_86, e.g. RTX 3060) box. The fat binary MUST still work there — it is a
+    strict superset, not a replacement. If either regresses, do NOT ship.
+
+ 2) Only after Blackwell PASS + Ada/Ampere regression PASS, copy the binaries
+    to the VPS (this script does NOT do this for you):
+
+      scp ${DIST}/sd-cli-cu12  ${VPS_USER}@${VPS_HOST}:${VPS_DLDIR}/sd-cli-cu12
+      scp ${DIST}/sd-cli-cu13  ${VPS_USER}@${VPS_HOST}:${VPS_DLDIR}/sd-cli-cu13
+      ssh ${VPS_USER}@${VPS_HOST} 'chmod 755 ${VPS_DLDIR}/sd-cli-cu12 ${VPS_DLDIR}/sd-cli-cu13'
+
+ 3) Confirm they serve:
+      curl -sI https://ai.decntai.com/download/sd-cli-cu12   # expect 200
+      curl -sI https://ai.decntai.com/download/sd-cli-cu13   # expect 200
+
+ New providers fetch these via setup.py fetch_or_build_sdcli (cu13 when host
+ CUDA major >= 13, else cu12). Existing providers re-run setup.py / re-fetch.
+============================================================================
+EOF