serverless: RunPod worker (handler, build/deploy scripts, Dockerfile, qwen-edit-turbo endpoint)

serverless/Dockerfile

@@ -0,0 +1,59 @@
+# Reproducible Dockerfile equivalent of build.sh (which assembles the same
+# image daemonlessly with crane, since RunPod pods have no Docker daemon).
+#
+# Build from the HF-repo root (context needs serverless/ and apply_patches.sh),
+# passing your HF token as a BuildKit secret so it is never baked into a layer:
+#
+#   DOCKER_BUILDKIT=1 docker build \
+#     -f serverless/Dockerfile \
+#     --secret id=hf_token,env=HF_TOKEN \
+#     --build-arg ENDPOINT=qwen-edit-turbo \
+#     -t plx1029/comfyui-serverless:qwen-edit-turbo-v1 .
+#
+# Layer order mirrors build.sh: custom nodes + models first (heavy, rarely
+# change), serverless code last (tiny, changes often) — so code iterations
+# never re-push model layers.
+
+FROM plx1029/comfyui-qwen:v6
+
+ARG ENDPOINT=qwen-edit-turbo
+ARG CUSTOM_SCRIPTS_COMMIT=main
+ARG QWENEDITUTILS_COMMIT=main
+
+# ---- custom nodes (rgthree already ships in the base) ----
+RUN git clone https://github.com/pythongosssss/ComfyUI-Custom-Scripts.git \
+        /workspace/ComfyUI/custom_nodes/ComfyUI-Custom-Scripts && \
+    git -C /workspace/ComfyUI/custom_nodes/ComfyUI-Custom-Scripts checkout ${CUSTOM_SCRIPTS_COMMIT} && \
+    git clone https://github.com/lrzjason/Comfyui-QwenEditUtils.git \
+        /workspace/ComfyUI/custom_nodes/Comfyui-QwenEditUtils && \
+    git -C /workspace/ComfyUI/custom_nodes/Comfyui-QwenEditUtils checkout ${QWENEDITUTILS_COMMIT}
+
+# ---- models: one RUN (= one layer) per file, list must match endpoint.json ----
+COPY serverless/endpoints/${ENDPOINT}/endpoint.json /tmp/endpoint.json
+RUN pip install -q -U huggingface_hub
+# hf download reads the token from the mounted secret; one layer per model
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/diffusion_models/qwen_image_edit_2511_bf16.safetensors --local-dir /workspace/ComfyUI
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/text_encoders/qwen_2.5_vl_7b.safetensors --local-dir /workspace/ComfyUI
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/vae/qwen_image_vae.safetensors --local-dir /workspace/ComfyUI
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/loras/Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors --local-dir /workspace/ComfyUI
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/loras/Qwen-Image-Edit-2511-Lightning-8steps-V1.0-bf16.safetensors --local-dir /workspace/ComfyUI
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/loras/Qwen_LoRA_Skin_Fix_v2.safetensors --local-dir /workspace/ComfyUI
+RUN --mount=type=secret,id=hf_token HF_TOKEN=$(cat /run/secrets/hf_token) \
+    hf download aleph65/ComfyUI models/loras/Qwen_LoRA_Amateur_Photo_v1.safetensors --local-dir /workspace/ComfyUI
+
+# ---- serverless code (top layer: cheap to rebuild) ----
+COPY apply_patches.sh /workspace/apply_patches.sh
+RUN bash /workspace/apply_patches.sh
+COPY serverless/ /opt/serverless/src/
+RUN rm -rf /opt/serverless/src/Dockerfile /opt/serverless/src/build.sh && \
+    find /opt/serverless/src/endpoints -mindepth 1 -maxdepth 1 ! -name "${ENDPOINT}" -exec rm -rf {} + && \
+    pip install -q --target /opt/serverless/lib runpod && \
+    chmod +x /opt/serverless/src/start.sh
+
+CMD ["/opt/serverless/src/start.sh"]

serverless/README.md

@@ -0,0 +1,115 @@
+# ComfyUI serverless workers (RunPod)
+
+Run ComfyUI workflows as RunPod serverless endpoints, optimized for cold start:
+**everything is baked into the image** (models included) so a worker whose host
+has the image cached starts in seconds and never touches the network.
+
+Images: `plx1029/comfyui-serverless` on Docker Hub. Current endpoint:
+
+| endpoint | image tag | RunPod endpoint id | contents |
+|---|---|---|---|
+| qwen-edit-turbo | `qwen-edit-turbo-v1` | `dom5lwr0o5wq6u` | Qwen-Image-Edit-2511 **bf16** + Lightning 4/8-step loras + Skin-Fix/Amateur loras, workflow `qwen-edit-turbo-v4` |
+
+RunPod template: `serverless-qwen-edit-turbo-v1` (`c7i24kc1wh`), endpoint
+`serverless-qwen-edit-turbo`: H100 80GB (SXM/PCIe/NVL), FlashBoot, min 0 /
+max 2 workers, idle timeout 60 s, QUEUE_DELAY scaler.
+
+## Layout
+
+```
+serverless/
+├── handler.py            # generic RunPod handler (same file for every endpoint)
+├── start.sh              # container CMD: boot ComfyUI headless, run handler
+├── build.sh              # daemonless image builder (crane; runs on a pod)
+├── Dockerfile            # reproducible equivalent for machines with Docker
+├── endpoints/
+│   └── qwen-edit-turbo/
+│       ├── endpoint.json           # models + custom nodes + default workflow
+│       ├── workflows/<name>.json   # API-format workflow(s) baked into the image
+│       └── params/<name>.json      # friendly-param -> node.input mapping
+└── tests/
+    ├── local_test.py     # drive handler against a locally running ComfyUI
+    └── endpoint_test.py  # drive a deployed RunPod endpoint
+```
+
+## Calling the endpoint
+
+```
+POST https://api.runpod.ai/v2/<ENDPOINT_ID>/runsync     (or /run + /status/<id>)
+```
+
+```json
+{"input": {
+  "images": [
+    {"name": "main.jpg", "image": "<base64 or data-URI>"},
+    {"name": "ref.png",  "image": "<base64>"}
+  ],
+  "params": {
+    "prompt": "replace the outfit ...",
+    "mode": "turbo-8",
+    "seed": 123,
+    "input_max_dim": 2048,
+    "output_max_dim": 2560,
+    "lora_skin_fix": true
+  },
+  "set": {"43.cfg": 1.0}
+}}
+```
+
+- `images[0]` auto-fills the `image` slot, `images[1]` the `image_ref` slot; a
+  missing second image automatically sets `use_ref=false`.
+- `mode`: `turbo-4` | `turbo-8` (default) | `quality`.
+- `seed` omitted → randomized (returned in the response).
+- `set` patches any raw `NODE.INPUT` (or `NODE.INPUT.KEY`) after params.
+- `workflow` selects among baked workflows; `workflow_json` runs a full
+  API-format graph passthrough.
+- Full param list per workflow: `endpoints/<ep>/params/<workflow>.json`.
+
+Response: `{"images": [{"filename", "type": "base64", "data"}], "seed",
+"prompt_id", "workflow", "timings": {...}}`.
+
+Payload limits (RunPod): ~10 MB on `/run`, ~20 MB on `/runsync` — enough for
+two photos. URL inputs / S3 outputs are a planned follow-up for bigger traffic.
+
+## Building images (no Docker needed — run on a pod)
+
+```bash
+cd serverless
+# heavy tag: base + custom nodes + one layer PER model (build rarely)
+./build.sh models qwen-edit-turbo v1
+# tiny tag: + handler/workflows/params + CMD (build often, pushes only MBs)
+./build.sh code qwen-edit-turbo v1 v1
+```
+
+Needs: `crane` + `pigz` installed, models on disk under
+`$COMFY_WORKSPACE/ComfyUI/models/`, `DOCKER_HUB_ACCESS_TOKEN` set. The model
+layers are content-addressed: rebuilding/pushing a new code version never
+re-uploads them. On a machine with Docker, `Dockerfile` builds the same image.
+
+**Adding a new endpoint family** (e.g. krea2): create
+`endpoints/krea2/{endpoint.json,workflows/,params/}`, download its models on
+the build pod (`download_missing_models.sh <workflows...>`), then
+`./build.sh all krea2 v1`. The handler is already generic.
+
+## Cold start design
+
+- Models live in image layers → cached on RunPod host NVMe after first pull;
+  no network volume, no downloads at start.
+- ComfyUI runs headless (`127.0.0.1`, no Manager/frontend extras) with
+  `--highvram` so the ~55 GB of bf16 weights stay resident in VRAM between
+  jobs; only the first job on a fresh worker pays model loading.
+- FlashBoot on the endpoint snapshots warm workers.
+- `SERVERLESS_REFRESH=true` (endpoint env) re-pulls handler/workflows/params
+  from `hf.co/aleph65/ComfyUI/serverless/` at worker boot — iterate on code and
+  workflow JSONs with **zero image rebuild** (off by default to keep cold
+  starts fully offline).
+
+## Endpoint env vars
+
+| var | default | meaning |
+|---|---|---|
+| `SERVERLESS_ENDPOINT` | sole dir in `endpoints/` | which endpoint config to serve |
+| `COMFY_PORT` | 7865 | internal ComfyUI port |
+| `COMFY_ARGS` | `--highvram` | extra ComfyUI flags |
+| `COMFY_EXEC_TIMEOUT` | 600 | per-job execution timeout (s) |
+| `SERVERLESS_REFRESH` | false | boot-time code refresh from the HF repo |

serverless/build.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# Daemonless image builder for RunPod serverless endpoints (crane-based; no
+# Docker needed — runs on any RunPod pod that has the models on disk).
+#
+# Layer model (order matters — cheap-to-change stuff goes LAST):
+#
+#   plx1029/comfyui-qwen:v6                       (base: torch + ComfyUI + rgthree)
+#     + custom-nodes layer + one layer PER model  -> :<endpoint>-models-<V>   (heavy, build rarely)
+#       + serverless code layer + CMD mutate      -> :<endpoint>-<V>          (tiny, build often)
+#
+# Because the code layer sits on top, iterating on handler/workflows/params
+# re-uploads only a few MB; the model layers are content-addressed and are
+# never pushed twice.
+#
+# Usage (from the directory holding this script):
+#   ./build.sh models qwen-edit-turbo v1            # build+push heavy models tag
+#   ./build.sh code   qwen-edit-turbo v1 v1         # build+push final tag on models-v1
+#   ./build.sh all    qwen-edit-turbo v1            # both
+#
+# Env: DOCKER_HUB_ACCESS_TOKEN (required), DOCKER_HUB_USER (default plx1029),
+#      BASE_IMAGE (default plx1029/comfyui-qwen:v6),
+#      DEST_REPO (default docker.io/<user>/comfyui-serverless),
+#      COMFY_WORKSPACE (default /workspace).
+
+set -euo pipefail
+
+CMD_MODE="${1:?models|code|all}"; ENDPOINT="${2:?endpoint name}"; VER="${3:?version}"
+MODELS_VER="${4:-$VER}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WS="${COMFY_WORKSPACE:-/workspace}"
+USER="${DOCKER_HUB_USER:-plx1029}"
+BASE="${BASE_IMAGE:-plx1029/comfyui-qwen:v6}"
+REPO="${DEST_REPO:-docker.io/${USER}/comfyui-serverless}"
+EP_DIR="$SCRIPT_DIR/endpoints/$ENDPOINT"
+BUILD_DIR="${BUILD_DIR:-/root/build}"
+THREADS=$(( $(nproc) > 64 ? 64 : $(nproc) ))
+
+[ -f "$EP_DIR/endpoint.json" ] || { echo "no endpoint.json in $EP_DIR"; exit 1; }
+command -v crane >/dev/null || { echo "crane not installed"; exit 1; }
+command -v pigz  >/dev/null || { echo "pigz not installed";  exit 1; }
+
+echo "$DOCKER_HUB_ACCESS_TOKEN" | crane auth login index.docker.io -u "$USER" --password-stdin
+
+mkdir -p "$BUILD_DIR"
+TAR_OPTS=(--owner=0 --group=0 --exclude='__pycache__' --exclude='*.pyc')
+
+layer_from_paths() {  # $1 = output tgz, rest = paths relative to /
+    local out="$1"; shift
+    [ -s "$out" ] && { echo "  (cached) $out"; return; }
+    tar "${TAR_OPTS[@]}" -C / -cf - "$@" | pigz -p "$THREADS" -1 > "$out.tmp"
+    mv "$out.tmp" "$out"
+    echo "  $(du -h "$out" | cut -f1) $out"
+}
+
+build_models() {
+    local tag="$REPO:$ENDPOINT-models-$VER"
+    echo "== building $tag on $BASE"
+    local layers=()
+
+    # custom nodes the endpoint needs that aren't already in the base image
+    # (BASE_HAS_NODES lists packs baked into $BASE; rgthree ships in v6)
+    local base_has=" ${BASE_HAS_NODES:-rgthree-comfy} "
+    local nodes n paths=()
+    nodes=$(python3 -c "import json;print(' '.join(json.load(open('$EP_DIR/endpoint.json'))['custom_nodes']))")
+    for n in $nodes; do
+        case "$base_has" in *" $n "*) continue ;; esac
+        [ -d "$WS/ComfyUI/custom_nodes/$n" ] || { echo "missing custom node $n"; exit 1; }
+        paths+=("workspace/ComfyUI/custom_nodes/$n")
+    done
+    if [ "${#paths[@]}" -gt 0 ]; then
+        echo "-- custom nodes layer: ${paths[*]}"
+        layer_from_paths "$BUILD_DIR/$ENDPOINT-nodes.tgz" "${paths[@]}"
+        layers+=(-f "$BUILD_DIR/$ENDPOINT-nodes.tgz")
+    fi
+
+    # one layer per model file (content-addressed => pushed exactly once, ever)
+    while read -r m; do
+        [ -f "$WS/ComfyUI/$m" ] || { echo "missing model $WS/ComfyUI/$m — download it first"; exit 1; }
+        local tgz="$BUILD_DIR/model-$(basename "$m").tgz"
+        echo "-- model layer: $m"
+        layer_from_paths "$tgz" "workspace/ComfyUI/$m"
+        layers+=(-f "$tgz")
+    done < <(python3 -c "import json;print('\n'.join(json.load(open('$EP_DIR/endpoint.json'))['models']))")
+
+    crane append -b "$BASE" "${layers[@]}" -t "$tag"
+    echo "== pushed $tag"
+}
+
+build_code() {
+    local models_tag="$REPO:$ENDPOINT-models-$MODELS_VER"
+    local tag="$REPO:$ENDPOINT-$VER"
+    echo "== building $tag on $models_tag"
+
+    local stage="$BUILD_DIR/stage-code"
+    rm -rf "$stage"
+    mkdir -p "$stage/opt/serverless/src" "$stage/opt/serverless/lib" \
+             "$stage/workspace/ComfyUI/comfy"
+    cp -r "$SCRIPT_DIR"/handler.py "$SCRIPT_DIR"/start.sh "$SCRIPT_DIR"/endpoints \
+          "$SCRIPT_DIR"/tests "$stage/opt/serverless/src/"
+    # only THIS endpoint's config goes into the image
+    find "$stage/opt/serverless/src/endpoints" -mindepth 1 -maxdepth 1 \
+         ! -name "$ENDPOINT" -exec rm -rf {} +
+    # vendored python deps for the handler (runpod sdk); build them if absent
+    if [ ! -d /opt/serverless/lib/runpod ]; then
+        pip install -q --target /opt/serverless/lib runpod
+    fi
+    cp -r /opt/serverless/lib/. "$stage/opt/serverless/lib/"
+    # local core patches (ComfyUI #14573 aimdo fix) ride along with the code
+    cp "$WS/ComfyUI/comfy/model_management.py" "$stage/workspace/ComfyUI/comfy/"
+    chmod +x "$stage/opt/serverless/src/start.sh"
+
+    tar "${TAR_OPTS[@]}" --exclude='local-out-*' -C "$stage" -cf - . \
+        | pigz -p "$THREADS" -1 > "$BUILD_DIR/code.tgz"
+    crane append -b "$models_tag" -f "$BUILD_DIR/code.tgz" -t "$tag"
+    crane mutate "$tag" --cmd "/opt/serverless/src/start.sh" -t "$tag"
+    echo "== pushed $tag"
+}
+
+case "$CMD_MODE" in
+    models) build_models ;;
+    code)   build_code ;;
+    all)    build_models; MODELS_VER="$VER" build_code ;;
+    *) echo "unknown mode $CMD_MODE"; exit 1 ;;
+esac

serverless/deploy.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Create (or update) the RunPod template + serverless endpoint for an endpoint
+# image built by build.sh. Idempotent-ish: reuses template/endpoint by name.
+#
+#   ./deploy.sh qwen-edit-turbo v1
+#
+# Env: RUNPOD_API_KEY (required), DOCKER_HUB_USER (default plx1029),
+#      GPU_IDS (comma list, default all H100 80GB variants),
+#      WORKERS_MAX (default 2), IDLE_TIMEOUT (default 60s),
+#      CONTAINER_DISK_GB (default 20).
+
+set -euo pipefail
+ENDPOINT="${1:?endpoint name}"; VER="${2:?version}"
+USER="${DOCKER_HUB_USER:-plx1029}"
+IMAGE="docker.io/${USER}/comfyui-serverless:${ENDPOINT}-${VER}"
+TPL_NAME="serverless-${ENDPOINT}-${VER}"
+EP_NAME="serverless-${ENDPOINT}"
+GPUS="${GPU_IDS:-NVIDIA H100 80GB HBM3,NVIDIA H100 PCIe,NVIDIA H100 NVL}"
+API="https://rest.runpod.io/v1"
+AUTH=(-H "Authorization: Bearer $RUNPOD_API_KEY" -H "Content-Type: application/json")
+
+gpu_json=$(python3 -c "import json,sys;print(json.dumps(sys.argv[1].split(',')))" "$GPUS")
+
+# ---- template ----
+tpl_id=$(curl -s "${AUTH[@]}" "$API/templates" | python3 -c "
+import json,sys
+for t in json.load(sys.stdin):
+    if t.get('name')=='$TPL_NAME': print(t['id']); break")
+if [ -z "$tpl_id" ]; then
+    tpl_id=$(curl -s "${AUTH[@]}" -X POST "$API/templates" -d "{
+        \"name\": \"$TPL_NAME\",
+        \"imageName\": \"$IMAGE\",
+        \"isServerless\": true,
+        \"containerDiskInGb\": ${CONTAINER_DISK_GB:-20},
+        \"env\": {}
+    }" | python3 -c "import json,sys;d=json.load(sys.stdin);print(d.get('id') or sys.exit(json.dumps(d)))")
+    echo "created template $tpl_id ($TPL_NAME -> $IMAGE)"
+else
+    echo "template $tpl_id ($TPL_NAME) already exists"
+fi
+
+# ---- endpoint ----
+ep_id=$(curl -s "${AUTH[@]}" "$API/endpoints" | python3 -c "
+import json,sys
+for e in json.load(sys.stdin):
+    if e.get('name')=='$EP_NAME': print(e['id']); break")
+if [ -z "$ep_id" ]; then
+    ep_id=$(curl -s "${AUTH[@]}" -X POST "$API/endpoints" -d "{
+        \"name\": \"$EP_NAME\",
+        \"templateId\": \"$tpl_id\",
+        \"computeType\": \"GPU\",
+        \"gpuTypeIds\": $gpu_json,
+        \"gpuCount\": 1,
+        \"workersMin\": 0,
+        \"workersMax\": ${WORKERS_MAX:-2},
+        \"idleTimeout\": ${IDLE_TIMEOUT:-60},
+        \"flashboot\": true,
+        \"scalerType\": \"QUEUE_DELAY\",
+        \"scalerValue\": 4,
+        \"executionTimeoutMs\": 600000
+    }" | python3 -c "import json,sys;d=json.load(sys.stdin);print(d.get('id') or sys.exit(json.dumps(d)))")
+    echo "created endpoint $ep_id ($EP_NAME)"
+else
+    echo "endpoint $ep_id ($EP_NAME) exists — pointing it at template $tpl_id"
+    curl -s "${AUTH[@]}" -X PATCH "$API/endpoints/$ep_id" -d "{\"templateId\": \"$tpl_id\"}" >/dev/null
+fi
+echo
+echo "endpoint id: $ep_id"
+echo "  POST https://api.runpod.ai/v2/$ep_id/runsync"

serverless/endpoints/qwen-edit-turbo/endpoint.json

@@ -0,0 +1,21 @@
+{
+  "name": "qwen-edit-turbo",
+  "description": "Qwen-Image-Edit-2511 bf16 + Lightning 4/8-step turbo (qwen-edit-turbo-v4)",
+  "default_workflow": "qwen-edit-turbo-v4",
+  "hf_repo": "aleph65/ComfyUI",
+  "models": [
+    "models/diffusion_models/qwen_image_edit_2511_bf16.safetensors",
+    "models/text_encoders/qwen_2.5_vl_7b.safetensors",
+    "models/vae/qwen_image_vae.safetensors",
+    "models/loras/Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors",
+    "models/loras/Qwen-Image-Edit-2511-Lightning-8steps-V1.0-bf16.safetensors",
+    "models/loras/Qwen_LoRA_Skin_Fix_v2.safetensors",
+    "models/loras/Qwen_LoRA_Amateur_Photo_v1.safetensors"
+  ],
+  "custom_nodes": [
+    "rgthree-comfy",
+    "ComfyUI-Custom-Scripts",
+    "Comfyui-QwenEditUtils"
+  ],
+  "comfy_args": "--highvram"
+}

serverless/endpoints/qwen-edit-turbo/params/qwen-edit-turbo-v4.json

@@ -0,0 +1,24 @@
+{
+  "params": {
+    "prompt":            {"node": "40", "input": "prompt"},
+    "image":             {"node": "20", "input": "image", "type": "image"},
+    "image_ref":         {"node": "30", "input": "image", "type": "image"},
+    "use_ref":           {"node": "56", "input": "value"},
+    "mode":              {"node": "5",  "input": "value",
+                          "choices": {"turbo-4": 1, "turbo-8": 2, "quality": 3}},
+    "seed":              {"node": "43", "input": "seed"},
+    "input_max_dim":     {"node": "21", "input": "value"},
+    "ref_max_dim":       {"node": "31", "input": "value"},
+    "upscale_input":     {"node": "15", "input": "value"},
+    "downscale_input":   {"node": "16", "input": "value"},
+    "upscale_output":    {"node": "46", "input": "value"},
+    "output_max_dim":    {"node": "47", "input": "value"},
+    "lora_skin_fix":          {"node": "52", "input": "lora_1", "subkey": "on"},
+    "lora_skin_fix_strength": {"node": "52", "input": "lora_1", "subkey": "strength"},
+    "lora_amateur":           {"node": "52", "input": "lora_2", "subkey": "on"},
+    "lora_amateur_strength":  {"node": "52", "input": "lora_2", "subkey": "strength"}
+  },
+  "defaults": {"mode": "turbo-8"},
+  "image_slots": ["image", "image_ref"],
+  "when_image_absent": {"image_ref": {"use_ref": false}}
+}

serverless/endpoints/qwen-edit-turbo/workflows/qwen-edit-turbo-v4.json

@@ -0,0 +1,758 @@
+{
+  "1": {
+    "class_type": "UNETLoader",
+    "inputs": {
+      "unet_name": "qwen_image_edit_2511_bf16.safetensors",
+      "weight_dtype": "default"
+    }
+  },
+  "13": {
+    "class_type": "ModelSamplingAuraFlow",
+    "inputs": {
+      "model": [
+        "53:6",
+        0
+      ],
+      "shift": 3.1
+    }
+  },
+  "14": {
+    "class_type": "CFGNorm",
+    "inputs": {
+      "model": [
+        "13",
+        0
+      ],
+      "pre_cfg": false,
+      "strength": 1
+    }
+  },
+  "15": {
+    "_meta": {
+      "title": "upscale_input_to_max_size"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": true
+    }
+  },
+  "16": {
+    "_meta": {
+      "title": "downscale_input_to_max_size"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": false
+    }
+  },
+  "20": {
+    "_meta": {
+      "title": "Main Image"
+    },
+    "class_type": "LoadImage",
+    "inputs": {
+      "image": "733427737_18059858666742129_6215894921112236726_n.jpg"
+    }
+  },
+  "21": {
+    "_meta": {
+      "title": "Input max size (main)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 2048
+    }
+  },
+  "27": {
+    "_meta": {
+      "title": "Main image config"
+    },
+    "class_type": "QwenEditConfigPreparer",
+    "inputs": {
+      "image": [
+        "20",
+        0
+      ],
+      "ref_crop": "pad",
+      "ref_longest_edge": [
+        "54:5",
+        0
+      ],
+      "ref_main_image": true,
+      "ref_upscale": "lanczos",
+      "to_ref": true,
+      "to_vl": true,
+      "vl_crop": "center",
+      "vl_resize": true,
+      "vl_target_size": 384,
+      "vl_upscale": "bicubic"
+    }
+  },
+  "3": {
+    "class_type": "CLIPLoader",
+    "inputs": {
+      "clip_name": "qwen_2.5_vl_7b.safetensors",
+      "device": "default",
+      "type": "qwen_image"
+    }
+  },
+  "30": {
+    "_meta": {
+      "title": "Reference Image 2 (optional)"
+    },
+    "class_type": "LoadImage",
+    "inputs": {
+      "image": "b.png"
+    }
+  },
+  "31": {
+    "_meta": {
+      "title": "Input max size (ref 2)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 1024
+    }
+  },
+  "37": {
+    "_meta": {
+      "title": "Reference image 2 config"
+    },
+    "class_type": "QwenEditConfigPreparer",
+    "inputs": {
+      "configs": [
+        "27",
+        0
+      ],
+      "image": [
+        "30",
+        0
+      ],
+      "ref_crop": "center",
+      "ref_longest_edge": [
+        "55:5",
+        0
+      ],
+      "ref_main_image": false,
+      "ref_upscale": "lanczos",
+      "to_ref": true,
+      "to_vl": true,
+      "vl_crop": "center",
+      "vl_resize": true,
+      "vl_target_size": 384,
+      "vl_upscale": "bicubic"
+    }
+  },
+  "4": {
+    "class_type": "VAELoader",
+    "inputs": {
+      "vae_name": "qwen_image_vae.safetensors"
+    }
+  },
+  "40": {
+    "_meta": {
+      "title": "Qwen Edit Encode (prompt here)"
+    },
+    "class_type": "TextEncodeQwenImageEditPlusCustom_lrzjason",
+    "inputs": {
+      "clip": [
+        "3",
+        0
+      ],
+      "configs": [
+        "57",
+        0
+      ],
+      "instruction": "",
+      "prompt": "replace the outfit of the subject in the first image with the outfit in the second image, don't change anything else. do not change the body's anatomy or shape or skin tone. only put the outfit onto the person in the first image. ",
+      "return_full_refs_cond": true,
+      "vae": [
+        "4",
+        0
+      ]
+    }
+  },
+  "41": {
+    "class_type": "QwenEditOutputExtractor",
+    "inputs": {
+      "custom_output": [
+        "40",
+        2
+      ]
+    }
+  },
+  "42": {
+    "_meta": {
+      "title": "Negative (zeroed)"
+    },
+    "class_type": "ConditioningZeroOut",
+    "inputs": {
+      "conditioning": [
+        "40",
+        0
+      ]
+    }
+  },
+  "43": {
+    "class_type": "KSampler",
+    "inputs": {
+      "cfg": [
+        "53:14",
+        0
+      ],
+      "denoise": 1,
+      "latent_image": [
+        "40",
+        1
+      ],
+      "model": [
+        "14",
+        0
+      ],
+      "negative": [
+        "42",
+        0
+      ],
+      "positive": [
+        "40",
+        0
+      ],
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "seed": 440984114065874,
+      "steps": [
+        "53:11",
+        0
+      ]
+    }
+  },
+  "44": {
+    "class_type": "VAEDecode",
+    "inputs": {
+      "samples": [
+        "43",
+        0
+      ],
+      "vae": [
+        "4",
+        0
+      ]
+    }
+  },
+  "45": {
+    "_meta": {
+      "title": "Remove padding"
+    },
+    "class_type": "CropWithPadInfo",
+    "inputs": {
+      "image": [
+        "44",
+        0
+      ],
+      "pad_info": [
+        "41",
+        0
+      ]
+    }
+  },
+  "46": {
+    "_meta": {
+      "title": "upscale_output_to_selected_size"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": true
+    }
+  },
+  "47": {
+    "_meta": {
+      "title": "Selected output size"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 2560
+    }
+  },
+  "48": {
+    "_meta": {
+      "title": "Scale output"
+    },
+    "class_type": "ImageScaleToMaxDimension",
+    "inputs": {
+      "image": [
+        "45",
+        0
+      ],
+      "largest_size": [
+        "47",
+        0
+      ],
+      "upscale_method": "lanczos"
+    }
+  },
+  "49": {
+    "_meta": {
+      "title": "Output size switch"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "45",
+        0
+      ],
+      "on_true": [
+        "48",
+        0
+      ],
+      "switch": [
+        "46",
+        0
+      ]
+    }
+  },
+  "5": {
+    "_meta": {
+      "title": "Sampling mode: 1=4-step / 2=8-step / 3=quality"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 1
+    }
+  },
+  "50": {
+    "class_type": "SaveImage",
+    "inputs": {
+      "filename_prefix": "qwen-edit-turbo-v4",
+      "images": [
+        "49",
+        0
+      ]
+    }
+  },
+  "52": {
+    "_meta": {
+      "title": "User LoRAs"
+    },
+    "class_type": "Power Lora Loader (rgthree)",
+    "inputs": {
+      "lora_1": {
+        "lora": "Qwen_LoRA_Skin_Fix_v2.safetensors",
+        "on": false,
+        "strength": 1,
+        "strengthTwo": null
+      },
+      "lora_2": {
+        "lora": "Qwen_LoRA_Amateur_Photo_v1.safetensors",
+        "on": false,
+        "strength": 1,
+        "strengthTwo": null
+      },
+      "model": [
+        "1",
+        0
+      ]
+    }
+  },
+  "53:1": {
+    "_meta": {
+      "title": "LoRA: Lightning 4 steps"
+    },
+    "class_type": "LoraLoaderModelOnly",
+    "inputs": {
+      "lora_name": "Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors",
+      "model": [
+        "52",
+        0
+      ],
+      "strength_model": 1
+    }
+  },
+  "53:10": {
+    "_meta": {
+      "title": "Steps switch 4/8"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:7",
+        0
+      ],
+      "on_true": [
+        "53:8",
+        0
+      ],
+      "switch": [
+        "53:3",
+        2
+      ]
+    }
+  },
+  "53:11": {
+    "_meta": {
+      "title": "Steps switch quality"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:10",
+        0
+      ],
+      "on_true": [
+        "53:9",
+        0
+      ],
+      "switch": [
+        "53:4",
+        2
+      ]
+    }
+  },
+  "53:12": {
+    "_meta": {
+      "title": "CFG (lightning)"
+    },
+    "class_type": "PrimitiveFloat",
+    "inputs": {
+      "value": 1.0
+    }
+  },
+  "53:13": {
+    "_meta": {
+      "title": "CFG (quality)"
+    },
+    "class_type": "PrimitiveFloat",
+    "inputs": {
+      "value": 3.0
+    }
+  },
+  "53:14": {
+    "_meta": {
+      "title": "CFG switch"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:12",
+        0
+      ],
+      "on_true": [
+        "53:13",
+        0
+      ],
+      "switch": [
+        "53:4",
+        2
+      ]
+    }
+  },
+  "53:2": {
+    "_meta": {
+      "title": "LoRA: Lightning 8 steps"
+    },
+    "class_type": "LoraLoaderModelOnly",
+    "inputs": {
+      "lora_name": "Qwen-Image-Edit-2511-Lightning-8steps-V1.0-bf16.safetensors",
+      "model": [
+        "52",
+        0
+      ],
+      "strength_model": 1
+    }
+  },
+  "53:3": {
+    "_meta": {
+      "title": "is 8-step (mode == 2)"
+    },
+    "class_type": "ComfyMathExpression",
+    "inputs": {
+      "expression": "a == 2",
+      "values.a": [
+        "5",
+        0
+      ]
+    }
+  },
+  "53:4": {
+    "_meta": {
+      "title": "is quality (mode == 3)"
+    },
+    "class_type": "ComfyMathExpression",
+    "inputs": {
+      "expression": "a == 3",
+      "values.a": [
+        "5",
+        0
+      ]
+    }
+  },
+  "53:5": {
+    "_meta": {
+      "title": "Model switch 4/8"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:1",
+        0
+      ],
+      "on_true": [
+        "53:2",
+        0
+      ],
+      "switch": [
+        "53:3",
+        2
+      ]
+    }
+  },
+  "53:6": {
+    "_meta": {
+      "title": "Model switch quality"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:5",
+        0
+      ],
+      "on_true": [
+        "52",
+        0
+      ],
+      "switch": [
+        "53:4",
+        2
+      ]
+    }
+  },
+  "53:7": {
+    "_meta": {
+      "title": "Steps (4-step)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 4
+    }
+  },
+  "53:8": {
+    "_meta": {
+      "title": "Steps (8-step)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 8
+    }
+  },
+  "53:9": {
+    "_meta": {
+      "title": "Steps (quality)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 12
+    }
+  },
+  "54:1": {
+    "_meta": {
+      "title": "native edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "20",
+        0
+      ],
+      "expression": "max(a.width, a.height)"
+    }
+  },
+  "54:2": {
+    "_meta": {
+      "title": "upscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "20",
+        0
+      ],
+      "c": [
+        "21",
+        0
+      ],
+      "expression": "max(a.width, a.height, c)"
+    }
+  },
+  "54:3": {
+    "_meta": {
+      "title": "apply upscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "54:1",
+        0
+      ],
+      "on_true": [
+        "54:2",
+        0
+      ],
+      "switch": [
+        "15",
+        0
+      ]
+    }
+  },
+  "54:4": {
+    "_meta": {
+      "title": "downscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "54:3",
+        0
+      ],
+      "c": [
+        "21",
+        0
+      ],
+      "expression": "min(a, c)"
+    }
+  },
+  "54:5": {
+    "_meta": {
+      "title": "apply downscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "54:3",
+        0
+      ],
+      "on_true": [
+        "54:4",
+        0
+      ],
+      "switch": [
+        "16",
+        0
+      ]
+    }
+  },
+  "55:1": {
+    "_meta": {
+      "title": "native edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "30",
+        0
+      ],
+      "expression": "max(a.width, a.height)"
+    }
+  },
+  "55:2": {
+    "_meta": {
+      "title": "upscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "30",
+        0
+      ],
+      "c": [
+        "31",
+        0
+      ],
+      "expression": "max(a.width, a.height, c)"
+    }
+  },
+  "55:3": {
+    "_meta": {
+      "title": "apply upscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "55:1",
+        0
+      ],
+      "on_true": [
+        "55:2",
+        0
+      ],
+      "switch": [
+        "15",
+        0
+      ]
+    }
+  },
+  "55:4": {
+    "_meta": {
+      "title": "downscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "55:3",
+        0
+      ],
+      "c": [
+        "31",
+        0
+      ],
+      "expression": "min(a, c)"
+    }
+  },
+  "55:5": {
+    "_meta": {
+      "title": "apply downscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "55:3",
+        0
+      ],
+      "on_true": [
+        "55:4",
+        0
+      ],
+      "switch": [
+        "16",
+        0
+      ]
+    }
+  },
+  "56": {
+    "_meta": {
+      "title": "Use Reference Image 2"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": true
+    }
+  },
+  "57": {
+    "_meta": {
+      "title": "Ref 2 on/off switch"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "27",
+        0
+      ],
+      "on_true": [
+        "37",
+        0
+      ],
+      "switch": [
+        "56",
+        0
+      ]
+    }
+  }
+}

serverless/handler.py

@@ -0,0 +1,307 @@
+"""RunPod serverless handler for ComfyUI workflows.
+
+Generic across endpoint images: everything workflow-specific lives in
+endpoints/<family>/ (API-format workflow JSONs + param maps + endpoint.json).
+The family baked into an image is selected by $SERVERLESS_ENDPOINT
+(default: the only directory in endpoints/).
+
+Request schema (everything except images/prompt optional):
+
+    {"input": {
+        "workflow": "qwen-edit-turbo-v4",       # default: endpoint.json default_workflow
+        "images": [                              # written into ComfyUI's input dir
+            {"name": "main.jpg", "image": "<base64 or data-URI>"},
+            {"name": "ref.png",  "image": "<base64>"}
+        ],
+        "params": {                              # friendly names from the param map
+            "prompt": "...",
+            "image": "main.jpg",                 # default: images[0]
+            "image_ref": "ref.png",              # default: images[1] if present
+            "mode": "turbo-8",                   # turbo-4 | turbo-8 | quality
+            "seed": 123,                         # default: random
+            "input_max_dim": 2048, "output_max_dim": 2560, ...
+        },
+        "set": {"43.cfg": 1.0},                  # raw NODE.INPUT overrides, applied last
+        "workflow_json": { ... }                 # full API-graph passthrough (advanced;
+                                                 # params other than images/set are ignored)
+    }}
+
+Response:
+
+    {"images": [{"filename": "...", "type": "base64", "data": "..."}],
+     "seed": 123, "prompt_id": "...",
+     "timings": {"queue_s": ..., "execute_s": ..., "total_s": ...}}
+"""
+
+import base64
+import binascii
+import copy
+import glob
+import json
+import os
+import random
+import shutil
+import sys
+import time
+import urllib.error
+import urllib.request
+
+SERVERLESS_DIR = os.path.dirname(os.path.abspath(__file__))
+COMFY_HOST = f"127.0.0.1:{os.environ.get('COMFY_PORT', '7865')}"
+COMFY_DIR = os.environ.get("COMFY_DIR", "/workspace/ComfyUI")
+INPUT_DIR = os.path.join(COMFY_DIR, "input")
+OUTPUT_DIR = os.path.join(COMFY_DIR, "output")
+BOOT_TIMEOUT = float(os.environ.get("COMFY_BOOT_TIMEOUT", "300"))
+EXEC_TIMEOUT = float(os.environ.get("COMFY_EXEC_TIMEOUT", "600"))
+POLL_INTERVAL = 0.25
+SEED_INPUTS = ("seed", "noise_seed")
+
+
+# ---------------- endpoint config ----------------
+
+def _load_endpoint():
+    root = os.path.join(SERVERLESS_DIR, "endpoints")
+    name = os.environ.get("SERVERLESS_ENDPOINT")
+    if not name:
+        dirs = sorted(d for d in os.listdir(root) if os.path.isdir(os.path.join(root, d)))
+        if len(dirs) != 1:
+            raise RuntimeError(f"set SERVERLESS_ENDPOINT; found {dirs} in {root}")
+        name = dirs[0]
+    base = os.path.join(root, name)
+    with open(os.path.join(base, "endpoint.json")) as fh:
+        cfg = json.load(fh)
+    workflows, params = {}, {}
+    for p in glob.glob(os.path.join(base, "workflows", "*.json")):
+        workflows[os.path.splitext(os.path.basename(p))[0]] = p
+    for p in glob.glob(os.path.join(base, "params", "*.json")):
+        params[os.path.splitext(os.path.basename(p))[0]] = p
+    return name, cfg, workflows, params
+
+
+ENDPOINT_NAME, ENDPOINT_CFG, WORKFLOWS, PARAM_MAPS = _load_endpoint()
+
+
+# ---------------- comfy http ----------------
+
+def _http(method, path, payload=None, timeout=30):
+    url = f"http://{COMFY_HOST}{path}"
+    data = json.dumps(payload).encode() if payload is not None else None
+    req = urllib.request.Request(url, data=data, method=method,
+                                 headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        body = r.read()
+    return json.loads(body) if body else {}
+
+
+def wait_for_comfy(timeout=BOOT_TIMEOUT):
+    start = time.monotonic()
+    last_err = None
+    while time.monotonic() - start < timeout:
+        try:
+            _http("GET", "/system_stats", timeout=5)
+            return time.monotonic() - start
+        except Exception as e:  # noqa: BLE001 - retry until deadline
+            last_err = e
+            time.sleep(0.5)
+    log = ""
+    for lf in ("/comfyui.log", os.path.join(COMFY_DIR, "comfyui.log")):
+        if os.path.exists(lf):
+            with open(lf) as fh:
+                log = "".join(fh.readlines()[-40:])
+            break
+    raise RuntimeError(f"ComfyUI not up after {timeout:.0f}s ({last_err}); log tail:\n{log}")
+
+
+# ---------------- request handling ----------------
+
+def _decode_image(entry, dest_dir):
+    name = os.path.basename(entry.get("name", ""))
+    if not name:
+        raise ValueError("each images[] entry needs a 'name'")
+    data = entry.get("image", "")
+    if data.startswith("data:"):
+        data = data.split(",", 1)[-1]
+    try:
+        raw = base64.b64decode(data, validate=True)
+    except (binascii.Error, ValueError) as e:
+        raise ValueError(f"images[{name!r}] is not valid base64: {e}") from None
+    os.makedirs(dest_dir, exist_ok=True)
+    with open(os.path.join(dest_dir, name), "wb") as fh:
+        fh.write(raw)
+    return name
+
+
+def _apply_param(graph, spec, value):
+    node = graph.get(str(spec["node"]))
+    if node is None:
+        raise ValueError(f"param targets missing node {spec['node']}")
+    inputs = node.setdefault("inputs", {})
+    if "choices" in spec:
+        if str(value) not in spec["choices"]:
+            raise ValueError(f"value {value!r} not in {sorted(spec['choices'])}")
+        value = spec["choices"][str(value)]
+    if "subkey" in spec:
+        tgt = inputs.get(spec["input"])
+        if not isinstance(tgt, dict):
+            raise ValueError(f"node {spec['node']}.{spec['input']} is not a dict input")
+        tgt[spec["subkey"]] = value
+    else:
+        inputs[spec["input"]] = value
+
+
+def build_graph(job_input, job_id, image_names):
+    """Return (graph, seed, workflow_name)."""
+    if isinstance(job_input.get("workflow_json"), dict):
+        graph = copy.deepcopy(job_input["workflow_json"])
+        wf_name = "(passthrough)"
+        pmap = {"params": {}, "defaults": {}, "image_slots": []}
+    else:
+        wf_name = job_input.get("workflow") or ENDPOINT_CFG.get("default_workflow")
+        if wf_name not in WORKFLOWS:
+            raise ValueError(f"unknown workflow {wf_name!r}; baked: {sorted(WORKFLOWS)}")
+        with open(WORKFLOWS[wf_name]) as fh:
+            graph = json.load(fh)
+        with open(PARAM_MAPS[wf_name]) as fh:
+            pmap = json.load(fh)
+
+    params = dict(pmap.get("defaults", {}))
+    params.update(job_input.get("params") or {})
+
+    # image slots default to uploaded images in order; slots with no upload of
+    # their own trigger their "absent" side effects (e.g. use_ref=false) and
+    # then get a placeholder image anyway — ComfyUI validates every LoadImage
+    # node, even ones behind a disabled switch.
+    slots = pmap.get("image_slots", [])
+    for i, slot in enumerate(slots):
+        if slot not in params and i < len(image_names):
+            params[slot] = image_names[i]
+    for slot, effects in (pmap.get("when_image_absent") or {}).items():
+        if slot not in params:
+            for k, v in effects.items():
+                params.setdefault(k, v)
+    for slot in slots:
+        if slot not in params and image_names:
+            params[slot] = image_names[0]
+
+    spec_map = pmap.get("params", {})
+    for key, value in params.items():
+        spec = spec_map.get(key)
+        if spec is None:
+            raise ValueError(f"unknown param {key!r}; available: {sorted(spec_map)}")
+        if spec.get("type") == "image":
+            if value not in image_names:
+                raise ValueError(f"param {key!r}={value!r} does not match an uploaded image name")
+            value = f"{job_id}/{value}"
+        _apply_param(graph, spec, value)
+
+    # raw overrides, applied last: {"43.cfg": 1.0} or {"52.lora_1.on": true}
+    for target, value in (job_input.get("set") or {}).items():
+        parts = target.split(".")
+        if len(parts) == 2:
+            spec = {"node": parts[0], "input": parts[1]}
+        elif len(parts) == 3:
+            spec = {"node": parts[0], "input": parts[1], "subkey": parts[2]}
+        else:
+            raise ValueError(f"bad set target {target!r} (want NODE.INPUT or NODE.INPUT.KEY)")
+        _apply_param(graph, spec, value)
+
+    # seed: explicit param wins; otherwise randomize every seed-ish input
+    seed = params.get("seed")
+    if seed is None:
+        seed = random.randrange(2**48)
+        for node in graph.values():
+            for name in SEED_INPUTS:
+                if isinstance(node.get("inputs", {}).get(name), int):
+                    node["inputs"][name] = seed
+
+    # route outputs into a per-job folder for clean collection
+    for node in graph.values():
+        if "filename_prefix" in node.get("inputs", {}):
+            node["inputs"]["filename_prefix"] = f"{job_id}/out"
+
+    return graph, seed, wf_name
+
+
+def run_graph(graph):
+    """Queue and wait. Returns (history_entry, queue_s, execute_s)."""
+    t0 = time.monotonic()
+    try:
+        resp = _http("POST", "/prompt", {"prompt": graph, "client_id": "runpod"})
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode(errors="replace")
+        try:
+            detail = json.dumps(json.loads(detail), indent=2)
+        except ValueError:
+            pass
+        raise RuntimeError(f"workflow validation failed (HTTP {e.code}):\n{detail}") from None
+    prompt_id = resp["prompt_id"]
+    queued = time.monotonic() - t0
+
+    while True:
+        if time.monotonic() - t0 > EXEC_TIMEOUT:
+            _http("POST", "/interrupt", {})
+            raise RuntimeError(f"execution timed out after {EXEC_TIMEOUT:.0f}s")
+        h = _http("GET", f"/history/{prompt_id}")
+        if prompt_id in h:
+            entry = h[prompt_id]
+            status = entry.get("status", {})
+            if status.get("status_str") == "error":
+                msgs = [m for m in status.get("messages", []) if m and m[0] == "execution_error"]
+                raise RuntimeError("workflow execution failed:\n"
+                                   + json.dumps(msgs or status.get("messages", []), indent=2))
+            return entry, prompt_id, queued, time.monotonic() - t0
+        time.sleep(POLL_INTERVAL)
+
+
+def collect_outputs(entry):
+    out = []
+    for node_output in entry.get("outputs", {}).values():
+        for value in node_output.values():
+            if not isinstance(value, list):
+                continue
+            for item in value:
+                if isinstance(item, dict) and "filename" in item and item.get("type") == "output":
+                    sub = item.get("subfolder", "")
+                    path = os.path.join(OUTPUT_DIR, sub, item["filename"])
+                    with open(path, "rb") as fh:
+                        out.append({"filename": item["filename"], "type": "base64",
+                                    "data": base64.b64encode(fh.read()).decode()})
+    return out
+
+
+def handler(job):
+    t_start = time.monotonic()
+    job_id = job.get("id") or f"job-{random.randrange(16**8):08x}"
+    job_id = job_id.replace("/", "_")
+    job_input = job.get("input") or {}
+    job_input_dir = os.path.join(INPUT_DIR, job_id)
+    try:
+        image_names = [_decode_image(e, job_input_dir)
+                       for e in (job_input.get("images") or [])]
+        graph, seed, wf_name = build_graph(job_input, job_id, image_names)
+        entry, prompt_id, queue_s, execute_s = run_graph(graph)
+        images = collect_outputs(entry)
+        if not images:
+            return {"error": "workflow finished but produced no output images"}
+        return {
+            "images": images,
+            "seed": seed,
+            "workflow": wf_name,
+            "prompt_id": prompt_id,
+            "timings": {"queue_s": round(queue_s, 3),
+                        "execute_s": round(execute_s, 3),
+                        "total_s": round(time.monotonic() - t_start, 3)},
+        }
+    except (ValueError, RuntimeError) as e:
+        return {"error": str(e)}
+    finally:
+        shutil.rmtree(job_input_dir, ignore_errors=True)
+        shutil.rmtree(os.path.join(OUTPUT_DIR, job_id), ignore_errors=True)
+
+
+if __name__ == "__main__":
+    boot_wait = wait_for_comfy()
+    print(f"[serverless] endpoint={ENDPOINT_NAME} workflows={sorted(WORKFLOWS)} "
+          f"comfy ready after {boot_wait:.1f}s", flush=True)
+    import runpod
+    runpod.serverless.start({"handler": handler})

serverless/start.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Container CMD for the serverless image: boot ComfyUI headless, then run the
+# RunPod handler. Models + code are baked; nothing is fetched at cold start
+# unless SERVERLESS_REFRESH=true (then handler/workflows/params are re-pulled
+# from the HF repo best-effort, for zero-rebuild iteration).
+set -u
+
+COMFY_DIR="${COMFY_DIR:-/workspace/ComfyUI}"
+COMFY_PORT="${COMFY_PORT:-7865}"
+SRC="${SERVERLESS_SRC:-/opt/serverless/src}"
+export PYTHONPATH="/opt/serverless/lib${PYTHONPATH:+:$PYTHONPATH}"
+
+if [ "${SERVERLESS_REFRESH:-false}" = "true" ]; then
+    echo "[start] refreshing serverless code from HF repo (SERVERLESS_REFRESH=true)"
+    tok="${HUGGING_FACE_ACCESS_TOKEN:-${HF_TOKEN:-}}"
+    auth=(); [ -n "$tok" ] && auth=(-H "Authorization: Bearer $tok")
+    base="https://huggingface.co/aleph65/ComfyUI/resolve/main/serverless"
+    while read -r rel; do
+        tmp=$(mktemp)
+        if curl -fsSL --connect-timeout 5 --max-time 20 "${auth[@]}" \
+                "$base/$rel" -o "$tmp" 2>/dev/null; then
+            mkdir -p "$SRC/$(dirname "$rel")" && mv "$tmp" "$SRC/$rel"
+            echo "[start]   refreshed $rel"
+        else
+            rm -f "$tmp"
+        fi
+    done < <(cd "$SRC" && find . -name '*.py' -o -name '*.json' | sed 's|^\./||')
+fi
+
+cd "$COMFY_DIR"
+# shellcheck disable=SC2086 — COMFY_ARGS is intentionally word-split
+python -u main.py --listen 127.0.0.1 --port "$COMFY_PORT" \
+    --disable-auto-launch ${COMFY_ARGS:---highvram} \
+    > /comfyui.log 2>&1 &
+
+exec python -u "$SRC/handler.py"

serverless/tests/endpoint_test.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Exercise a deployed RunPod serverless endpoint.
+
+    python tests/endpoint_test.py --endpoint-id XXXX main.jpg [ref.png] \
+        [--prompt "..."] [--mode turbo-8] [--seed 1] [--sync]
+
+Reads RUNPOD_API_KEY from the environment. Saves returned images next to this
+script and prints per-phase timings (delay/queue vs execution).
+"""
+import argparse
+import base64
+import json
+import os
+import pathlib
+import sys
+import time
+import urllib.request
+
+
+def api(method, url, payload=None, timeout=120):
+    req = urllib.request.Request(
+        url, method=method,
+        data=json.dumps(payload).encode() if payload is not None else None,
+        headers={"Content-Type": "application/json",
+                 "Authorization": f"Bearer {os.environ['RUNPOD_API_KEY']}"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.load(r)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("images", nargs="+")
+    ap.add_argument("--endpoint-id", required=True)
+    ap.add_argument("--prompt", default="replace the outfit of the subject in the first "
+                    "image with the outfit in the second image, don't change anything else.")
+    ap.add_argument("--mode", default="turbo-8")
+    ap.add_argument("--seed", type=int)
+    ap.add_argument("--sync", action="store_true", help="use /runsync instead of /run+poll")
+    ap.add_argument("--timeout", type=float, default=900)
+    args = ap.parse_args()
+
+    imgs = [{"name": os.path.basename(p),
+             "image": base64.b64encode(open(p, "rb").read()).decode()}
+            for p in args.images]
+    params = {"prompt": args.prompt, "mode": args.mode}
+    if args.seed is not None:
+        params["seed"] = args.seed
+    payload = {"input": {"images": imgs, "params": params}}
+    base = f"https://api.runpod.ai/v2/{args.endpoint_id}"
+
+    t0 = time.monotonic()
+    if args.sync:
+        result = api("POST", f"{base}/runsync", payload, timeout=args.timeout)
+    else:
+        job = api("POST", f"{base}/run", payload)
+        print(f"job {job['id']} -> {job['status']}", file=sys.stderr)
+        while True:
+            result = api("GET", f"{base}/status/{job['id']}")
+            if result["status"] in ("COMPLETED", "FAILED", "CANCELLED", "TIMED_OUT"):
+                break
+            if time.monotonic() - t0 > args.timeout:
+                sys.exit(f"timed out after {args.timeout}s (status {result['status']})")
+            print(f"  {result['status']} ... {time.monotonic()-t0:.0f}s", file=sys.stderr)
+            time.sleep(2)
+    wall = time.monotonic() - t0
+
+    if result.get("status") != "COMPLETED":
+        sys.exit(f"FAILED: {json.dumps(result, indent=2)[:3000]}")
+    out = result["output"]
+    if "error" in out:
+        sys.exit(f"handler error: {out['error']}")
+    for i, img in enumerate(out["images"]):
+        dest = pathlib.Path(__file__).parent / f"endpoint-out-{i}-{img['filename']}"
+        dest.write_bytes(base64.b64decode(img["data"]))
+        print(f"saved {dest}")
+    print(f"status=COMPLETED wall={wall:.1f}s delayTime={result.get('delayTime')}ms "
+          f"executionTime={result.get('executionTime')}ms\n"
+          f"handler timings={out.get('timings')} seed={out.get('seed')}")
+
+
+if __name__ == "__main__":
+    main()

serverless/tests/local_test.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Drive handler.py directly against a locally running ComfyUI (no RunPod).
+
+    python tests/local_test.py main.jpg [ref.png] [--prompt "..."] [--mode turbo-8]
+
+Saves returned images next to this script and prints timings.
+"""
+import argparse
+import base64
+import json
+import os
+import pathlib
+import sys
+import time
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+import handler as H  # noqa: E402
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("images", nargs="+", help="input image file(s): main [ref]")
+    ap.add_argument("--prompt", default="replace the outfit of the subject in the first "
+                    "image with the outfit in the second image, don't change anything else.")
+    ap.add_argument("--mode", default="turbo-8")
+    ap.add_argument("--seed", type=int)
+    ap.add_argument("--set", dest="sets", action="append", default=[],
+                    metavar="NODE.INPUT=JSONVALUE")
+    args = ap.parse_args()
+
+    imgs = []
+    for p in args.images:
+        imgs.append({"name": os.path.basename(p),
+                     "image": base64.b64encode(open(p, "rb").read()).decode()})
+    params = {"prompt": args.prompt, "mode": args.mode}
+    if args.seed is not None:
+        params["seed"] = args.seed
+    overrides = {}
+    for s in args.sets:
+        k, v = s.split("=", 1)
+        try:
+            overrides[k] = json.loads(v)
+        except json.JSONDecodeError:
+            overrides[k] = v
+
+    boot = H.wait_for_comfy()
+    print(f"comfy ready ({boot:.1f}s)")
+    t0 = time.monotonic()
+    out = H.handler({"id": f"local-{int(t0)}",
+                     "input": {"images": imgs, "params": params, "set": overrides}})
+    if "error" in out:
+        sys.exit(f"ERROR: {out['error']}")
+    for i, img in enumerate(out["images"]):
+        dest = pathlib.Path(__file__).parent / f"local-out-{i}-{img['filename']}"
+        dest.write_bytes(base64.b64decode(img["data"]))
+        print(f"saved {dest}")
+    print(f"seed={out['seed']} timings={out['timings']} wall={time.monotonic()-t0:.1f}s")
+
+
+if __name__ == "__main__":
+    main()