#!/usr/bin/env python3 # Auto-generated remote bootstrap script (HF + aria2c Ultra-Flash Mode, sanitized) # @title 1. Arranque Flash: Modelos Tier 0/1 (aria2c) + Entorno Limpio (zstd) + Cachés Triton/LoRA import os, sys, re, time, json, math, struct, shutil, hashlib, subprocess, urllib.parse, urllib.request, concurrent.futures from pathlib import Path import torch WITH_NODES = True # @param {type:"boolean"} INFERENCE_MODE = "reference" # @param ["reference", "first_frame"] CUSTOM_MODEL = "10Eros_Max_h3_TURBO-hybrid_beta5_int8" # @param ["10Eros_Max_h3_TURBO-hybrid_beta5_int8", "10Eros_Max_h3_TURBO-hybrid_beta5_w4a8_14gb_optimized", "10Eros_Max_h3_8stepTURBO_beta7_fix1-native_int8_protected_edges_HQ", "minimax_h3_ref2va_pruned_w4a8_mixed", "None"] TURBO_LORA_MODE = "resized_rank21_4step" # @param ["resized_rank21_4step", "pdmd_2step_ultrafast", "full_bf16_4step"] VIDEO_VAE_MODE = "video_vae_int8" # @param ["video_vae_int8", "lynnreal_light_int8"] DOWNLOAD_QWEN_NSFW = True # @param {type:"boolean"} QWEN_IN_BACKGROUND = True # @param {type:"boolean"} COPY_MY_LORAS = True # @param {type:"boolean"} HF_ASSETS_REPO = "ramusgill/comfyui-colab-flash" # @param {type:"string"} PREBUILT_ENV_ARCHIVE = "h3_env_py313_cu130_flash.tar.zst" # @param {type:"string"} REBUILD_ENV = False # @param {type:"boolean"} _env_mode = os.environ.get("H3_INFERENCE_MODE", "").strip().lower() if _env_mode: INFERENCE_MODE = _env_mode os.environ["HF_XET_HIGH_PERFORMANCE"] = "1" os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1" T0 = time.time() def lap(msg): print(f"[{time.time()-T0:6.1f}s] {msg}", flush=True) def sh(cmd, check=True, **kw): return subprocess.run(cmd, shell=isinstance(cmd, str), check=check, **kw) assert torch.cuda.is_available(), "Selecciona una GPU en 'Entorno de ejecución > Cambiar tipo de entorno de ejecución'." vram_gib = round(torch.cuda.get_device_properties(0).total_memory / 2**30, 1) GPU_CAPABILITY = torch.cuda.get_device_capability(0) CUDA_MAJOR = int((torch.version.cuda or "0").split(".", 1)[0]) print(f"🚀 GPU: {torch.cuda.get_device_name(0)} (CC {GPU_CAPABILITY[0]}.{GPU_CAPABILITY[1]}) | VRAM: {vram_gib} GiB | CUDA: {torch.version.cuda}") if not (shutil.which("aria2c") and shutil.which("zstd")): sh("apt-get install -y -qq aria2 zstd >/dev/null 2>&1", check=False) COMFY = Path("/content/ComfyUI"); VENV = Path("/content/venv"); VPY = VENV / "bin" / "python" CACHE = Path("/content/h3_cache"); CACHE.mkdir(exist_ok=True) DRIVE_DIR = Path("/content/drive/MyDrive/MiniMax_H3_Colab") if Path("/content/drive/MyDrive").exists(): DRIVE_DIR.mkdir(parents=True, exist_ok=True) MODELS_ROOT = COMFY / "models" for folder in ["checkpoints", "diffusion_models", "loras", "text_encoders", "vae", "controlnet", "model_patches"]: (MODELS_ROOT / folder).mkdir(parents=True, exist_ok=True) # ---------- 1) Selección de Modelos SOTA Benchmarkeados ---------- BASE_REPO = "Comfy-Org/MiniMax-H3" HF = "https://huggingface.co/{}/resolve/main/{}" TEXT_ENCODER = "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors" AUDIO_VAE = "minimax_h3_audio_vae_fp32.safetensors" if VIDEO_VAE_MODE == "lynnreal_light_int8" and CUDA_MAJOR >= 13: VIDEO_VAE = "minimax_h3_lynnreal_light_vae_int8_convrot.safetensors" video_vae_url = HF.format("Kijai/MiniMax-H3-experimental", VIDEO_VAE) elif CUDA_MAJOR >= 13 and GPU_CAPABILITY >= (8, 0): VIDEO_VAE = "minimax_h3_video_vae_int8_convrot.safetensors" video_vae_url = HF.format(BASE_REPO, "vae/" + VIDEO_VAE) else: VIDEO_VAE = "minimax_h3_video_vae_fp16.safetensors" video_vae_url = HF.format(BASE_REPO, "vae/" + VIDEO_VAE) if CUSTOM_MODEL == "minimax_h3_ref2va_pruned_w4a8_mixed": DIFFUSION = "minimax_h3_ref2va_pruned_w4a8_mixed.safetensors" diffusion_url = HF.format("Kijai/MiniMax-H3-experimental", DIFFUSION) elif CUSTOM_MODEL != "None": DIFFUSION = f"{CUSTOM_MODEL}.safetensors" diffusion_url = HF.format("TenStrip/10Eros-Max", DIFFUSION) else: if INFERENCE_MODE == "reference": variant = "int8_convrot" if (CUDA_MAJOR >= 13 and GPU_CAPABILITY >= (8, 0)) else ("fp8_scaled" if GPU_CAPABILITY >= (8, 9) else "bf16") DIFFUSION = f"minimax_h3_ref2va_pruned_{variant}.safetensors" else: variant = "int8_convrot" if CUDA_MAJOR >= 13 else "fp8_scaled" DIFFUSION = f"minimax_h3_fl2va_pruned_{variant}.safetensors" diffusion_url = HF.format(BASE_REPO, "diffusion_models/" + DIFFUSION) if TURBO_LORA_MODE == "pdmd_2step_ultrafast": PRIMARY_TURBO_LORA = "minimax_h3_pdmd_2step_lora_avg_rank_38_bf16.safetensors" turbo_lora_url = HF.format(HF_ASSETS_REPO, "loras/" + PRIMARY_TURBO_LORA) elif TURBO_LORA_MODE == "full_bf16_4step": PRIMARY_TURBO_LORA = "minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors" turbo_lora_url = HF.format(BASE_REPO, "loras/" + PRIMARY_TURBO_LORA) else: PRIMARY_TURBO_LORA = "minimax_h3_ref2v_turbo_4step_v0.1_comfyui_resized_avg_rank_21_bf16.safetensors" turbo_lora_url = HF.format(HF_ASSETS_REPO, "loras/" + PRIMARY_TURBO_LORA) TIER0_JOBS = [ (HF.format(BASE_REPO, "text_encoders/" + TEXT_ENCODER), "text_encoders", TEXT_ENCODER), (video_vae_url, "vae", VIDEO_VAE), (HF.format(BASE_REPO, "vae/" + AUDIO_VAE), "vae", AUDIO_VAE), (diffusion_url, "diffusion_models", DIFFUSION), (turbo_lora_url, "loras", PRIMARY_TURBO_LORA), ] QWEN_JOBS = [] if DOWNLOAD_QWEN_NSFW: QWEN_JOBS = [ ("https://huggingface.co/Phr00t/Qwen-Image-Edit-Rapid-AIO/resolve/main/v23/Qwen-Rapid-AIO-NSFW-v23.safetensors", "checkpoints", "Qwen-Rapid-AIO-NSFW-v23.safetensors"), ("https://huggingface.co/RunningHubAI/rh-wuji-qwen2511-aio-nsfw-2603-checkpoint/resolve/main/WuJi_Qwen2511-AIONSFW%E8%81%9A%E5%90%88%E7%89%88_2603.safetensors", "checkpoints", "WuJi_Qwen2511-AIONSFW.safetensors"), ("https://huggingface.co/Comfy-Org/Qwen-Image-Edit_ComfyUI/resolve/main/split_files/diffusion_models/qwen_image_edit_2511_int8_convrot.safetensors", "diffusion_models", "qwen_image_edit_2511_int8_convrot.safetensors"), (HF.format(HF_ASSETS_REPO, "vae/qwen_image_vae.safetensors"), "vae", "qwen_image_vae.safetensors"), (HF.format(HF_ASSETS_REPO, "text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors"), "text_encoders", "qwen_2.5_vl_7b_fp8_scaled.safetensors"), (HF.format(HF_ASSETS_REPO, "loras/Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors"), "loras", "Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors"), ("https://huggingface.co/fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA/resolve/main/qwen-image-edit-2511-multiple-angles-lora.safetensors", "loras", "qwen-image-edit-2511-multiple-angles-lora.safetensors"), ("https://huggingface.co/Rumcajs9000/SexGod_NSFW_Female_Nudes_QWEN_Image_Edit_2511/resolve/main/SEXGOD_FemaleNudity_QwenEdit_2511_v2.safetensors", "loras", "SEXGOD_FemaleNudity_QwenEdit_2511_v2.safetensors"), ("https://huggingface.co/prithivMLmods/Qwen-Image-Edit-2511-Midnight-Noir-Eyes-Spotlight/resolve/main/Qwen-Image-Edit-2511-Midnight-Noir-Eyes-Spotlight.safetensors", "loras", "Qwen-Image-Edit-2511-Midnight-Noir-Eyes-Spotlight.safetensors"), ("https://huggingface.co/MatheeshaNxtDoor/kaia/resolve/main/bfs_head_v5_2511_merged_version_rank_16_fp16.safetensors", "loras", "bfs_head_v5_2511_merged_version_rank_16_fp16.safetensors"), ("https://huggingface.co/metncelik/qwen-edit-2511-consistence-lora/resolve/main/qe2511_consis_alpha_patched.safetensors", "loras", "qe2511_consis_alpha_patched.safetensors"), ("https://huggingface.co/Cofiejunkie81/Au_naturale/resolve/main/SexGod_CouplesNudity_QwenEdit_2511_v1.safetensors", "loras", "SexGod_CouplesNudity_QwenEdit_2511_v1.safetensors"), ("https://huggingface.co/Gotlayeh/loras/resolve/main/Qwen_Image_Edit_2511_All_included_with_extra_gay_v2.0.safetensors", "loras", "Qwen_Image_Edit_2511_All_included_with_extra_gay_v2.0.safetensors"), ("https://huggingface.co/prithivMLmods/Qwen-Image-Edit-2511-Ultra-Realistic-Portrait/resolve/main/URP_20.safetensors", "loras", "URP_20.safetensors"), ("https://huggingface.co/mickmumpitz/QWEN-EDIT_360/resolve/main/251018_MICKMUMPITZ_QWEN-EDIT_360_03.safetensors", "loras", "251018_MICKMUMPITZ_QWEN-EDIT_360_03.safetensors"), ] if not QWEN_IN_BACKGROUND: TIER0_JOBS += QWEN_JOBS def _valid_safetensors(p: Path) -> bool: try: if not p.exists() or Path(str(p) + ".aria2").exists() or p.stat().st_size < 1024: return False with open(p, "rb") as f: hdr_len = struct.unpack("= 13: ta = fetch_archive("triton_cache_cu130_blackwell.tar.zst") return bool(ta and extract(ta)) return False with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool: fut_env = pool.submit(_setup_env) fut_nodes = pool.submit(_setup_nodes) fut_meta = pool.submit(_setup_lora_meta) fut_triton = pool.submit(_setup_triton_cache) env_ready = fut_env.result() nodes_ready = fut_nodes.result() meta_ready = fut_meta.result() triton_ready = fut_triton.result() if not env_ready or not env_ok(): lap("Construyendo entorno Python acelerado de respaldo con uv...") sh([sys.executable, "-m", "pip", "install", "-q", "uv"]) shutil.rmtree(VENV, ignore_errors=True) sh([sys.executable, "-m", "uv", "venv", "--system-site-packages", "--python", sys.executable, str(VENV)]) if not (COMFY / "main.py").exists(): tmp = Path("/content/_comfy_src"); shutil.rmtree(tmp, ignore_errors=True) sh(["git", "clone", "--depth", "1", "https://github.com/Comfy-Org/ComfyUI.git", str(tmp)]) shutil.rmtree(tmp / ".git", ignore_errors=True) COMFY.mkdir(exist_ok=True); sh(["cp", "-a", f"{tmp}/.", f"{COMFY}/"]) def clean_reqs(path): lines = path.read_text(encoding="utf-8", errors="ignore").splitlines() filtered = [l for l in lines if not re.match(r"^\s*(torch|torchvision|torchaudio|triton|transformers|diffusers|protobuf|opencv)([>=<~!\s-]|$)", l, re.I)] dst = CACHE / f"filtered_{path.name}" dst.write_text("\n".join(filtered) + "\n", encoding="utf-8") return str(dst) uv = [sys.executable, "-m", "uv", "pip", "install", "--python", str(VPY), "-q", "--index-strategy", "unsafe-best-match"] sh(uv + ["-r", clean_reqs(COMFY / "requirements.txt"), "onnxruntime-gpu", "nvidia-ml-py", "av>=17.0.0", "onnx"]) MARKER.write_text("py313_cu130_uv_fallback") (COMFY / "input").mkdir(exist_ok=True); (COMFY / "output").mkdir(exist_ok=True) lap(f"✅ Setup completado (LoRA-Meta={'OK' if meta_ready else 'skip'}, Triton-Cache={'OK' if triton_ready else 'skip'}).") # @title 2. Esperar modelos núcleo Tier 0 (aria2c) def _done(): return all(_valid_safetensors(t) for t in MODEL_TARGETS) for attempt in range(3): if ARIA_PROC is not None: while ARIA_PROC.poll() is None: got = sum(t.stat().st_size for t in MODEL_TARGETS if t.exists()) loras_count = len(list((MODELS_ROOT / "loras").glob("*.safetensors"))) print(f"\r⬇️ Tier 0 Core: {got/2**30:6.2f} GiB | LoRAs en NVMe: {loras_count}...", end="", flush=True) time.sleep(1.5) print() if _done(): break print(f"Reanudando descarga Tier 0 intento {attempt+1}/3...") ARIA_PROC = subprocess.Popen(ARIA_CMD, stdout=open(ARIA_LOG, "a"), stderr=subprocess.STDOUT) assert _done(), "Descarga Tier 0 incompleta; revisa " + str(ARIA_LOG) + "\n" + ARIA_LOG.read_text()[-3000:] for t in MODEL_TARGETS: print(f"✅ {t.name}: {t.stat().st_size/2**30:.2f} GiB") loras_ready = len(list((MODELS_ROOT / "loras").glob("*.safetensors"))) lap(f"🎉 Núcleo Tier 0 verificado ({loras_ready} LoRAs ya disponibles en NVMe).") # @title 3. Iniciar ComfyUI + Túnel HTTP/2 Zero Trust + Caché RAM/CDN + Auto-Warmup GPU import json, time, uuid, threading, requests, sys, subprocess, os, re, shutil from pathlib import Path import torch ATTENTION_BACKEND = "ck_int8" # @param ["ck_int8", "sage"] PREVIEW_METHOD = "none" # @param ["none", "latent2rgb", "auto", "taesd"] TUNNEL_PROTOCOL = "http2" # @param ["http2", "quic"] USE_ZERO_TRUST = True # @param {type:"boolean"} WARMUP_ON_BOOT = True # @param {type:"boolean"} KEEP_CELL_ALIVE = True # @param {type:"boolean"} CLOUDFLARE_TOKEN = '' # @param {type:"string"} if not CLOUDFLARE_TOKEN.strip(): CLOUDFLARE_TOKEN = os.environ.get("CLOUDFLARE_TOKEN", "").strip() if not CLOUDFLARE_TOKEN.strip(): try: from google.colab import userdata CLOUDFLARE_TOKEN = (userdata.get("CLOUDFLARE_TOKEN") or "").strip() except Exception: pass PORT = 8188 BASE_URL = f"http://127.0.0.1:{PORT}" LOG_PATH = Path("/content/comfyui_h3.log") SHM_TEMP = Path("/dev/shm/comfy_temp"); SHM_TEMP.mkdir(parents=True, exist_ok=True) os.system("pkill -9 -f 'main.py --listen' 2>/dev/null; pkill -9 -f 'comfy_watchdog.py' 2>/dev/null; pkill -9 cloudflared 2>/dev/null") time.sleep(1) lap("Verificando parches FP8 TensorCore, RoPE y SageAttention...") # 1) Parche FP8 dinámico (scale="recalculate") en comfy/ops.py _ops_file = COMFY / "comfy" / "ops.py" if _ops_file.exists(): _ops_txt = _ops_file.read_text(encoding="utf-8") _old_fp8_block = ( " scale_weight = torch.ones((), device=input.device, dtype=torch.float32)\n\n" " scale_input = torch.ones((), device=input.device, dtype=torch.float32)\n" " input = torch.clamp(input, min=-448, max=448, out=input)\n" " input_fp8 = input.to(dtype).contiguous()\n" " layout_params_input = TensorCoreFP8Layout.Params(scale=scale_input, orig_dtype=input_dtype, orig_shape=tuple(input_fp8.shape))\n" " quantized_input = QuantizedTensor(input_fp8, \"TensorCoreFP8Layout\", layout_params_input)" ) _new_fp8_block = ( " scale_weight = getattr(self, \"scale_weight\", None)\n" " if scale_weight is None:\n" " scale_weight = torch.ones((), device=input.device, dtype=torch.float32)\n\n" " quantized_input = QuantizedTensor.from_float(input, \"TensorCoreFP8E4M3Layout\", scale=\"recalculate\")" ) if _old_fp8_block in _ops_txt: _ops_file.write_text(_ops_txt.replace(_old_fp8_block, _new_fp8_block), encoding="utf-8") # 2) Parche RoPE dtype en minimax/model.py _mm_model = COMFY / "comfy" / "ldm" / "minimax" / "model.py" if _mm_model.exists(): _mm_txt = _mm_model.read_text(encoding="utf-8") _mm_patched = _mm_txt.replace( "qw = comfy.model_management.cast_to(self.q_norm.weight, device=x.device)\n kw = comfy.model_management.cast_to(self.k_norm.weight, device=x.device)", "qw = comfy.model_management.cast_to(self.q_norm.weight, dtype=q.dtype, device=x.device)\n kw = comfy.model_management.cast_to(self.k_norm.weight, dtype=k.dtype, device=x.device)" ) if _mm_patched != _mm_txt: _mm_model.write_text(_mm_patched, encoding="utf-8") # 3) Ruedas precompiladas de sageattn3 y sageattention (fallback si se reconstruyó con uv) if subprocess.run([str(VPY), "-c", "import sageattn3, sageattention; getattr(sageattention, 'sageattn_qk_int8_pv_fp8_cuda_sm90')"], capture_output=True).returncode != 0: _whls = [ f"https://huggingface.co/{HF_ASSETS_REPO}/resolve/main/wheels/sageattn3-1.0.0-cp313-cp313-linux_x86_64.whl", f"https://huggingface.co/{HF_ASSETS_REPO}/resolve/main/wheels/sageattention-2.2.0-py3-none-any.whl", ] subprocess.run([str(VPY), "-m", "pip", "install", "-q", "--no-deps", "--force-reinstall"] + _whls, check=False) # 3b) Parche RAM-Gzip + Cache-Control CDN/Browser en middleware/cache_middleware.py (elimina 'no-store' en /assets y /extensions) _cache_mw = COMFY / "middleware" / "cache_middleware.py" if _cache_mw.parent.exists(): _cache_mw.write_text('''"""Ultra-fast RAM-gzipped + Edge/Browser Cache-Control middleware for remote ComfyUI""" import gzip, mimetypes, time from pathlib import Path from typing import Callable, Awaitable, Dict, Tuple from aiohttp import web ONE_HOUR, ONE_DAY, ONE_YEAR = 3600, 86400, 31536000 IMG_EXTENSIONS = (".jpg", ".jpeg", ".png", ".ppm", ".bmp", ".pgm", ".tif", ".tiff", ".webp", ".ico") COMPRESSIBLE_EXTS = (".js", ".mjs", ".css", ".svg", ".json", ".html", ".txt", ".xml") FONT_EXTS = (".woff2", ".woff", ".ttf", ".otf", ".eot") MIME_MAP = { ".js": "application/javascript; charset=utf-8", ".mjs": "application/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".html": "text/html; charset=utf-8", ".json": "application/json; charset=utf-8", ".svg": "image/svg+xml", ".woff2": "font/woff2", ".woff": "font/woff", ".ttf": "font/ttf", ".otf": "font/otf", ".ico": "image/x-icon", } _STATIC_CACHE: Dict[str, Tuple[int, int, bytes, bytes, str, str]] = {} _OBJ_INFO_CACHE: Dict[str, Tuple[float, bytes, str, str]] = {} def _cache_policy_for_path(req_path: str) -> str: low = req_path.lower() fname = low.rsplit("/", 1)[-1] if req_path == "/" or fname == "index.html" or (fname.startswith("index") and fname.endswith(".json")) or fname.startswith("manifest-"): return "no-cache" if req_path.startswith("/assets/") or low.endswith(FONT_EXTS): return f"public, max-age={ONE_YEAR}, immutable" if req_path.startswith(("/extensions/", "/scripts/", "/lib/")) or low.endswith((".js", ".mjs", ".css", ".svg")): return f"public, max-age={ONE_DAY}, stale-while-revalidate={ONE_DAY * 7}" return "" @web.middleware async def cache_control(request: web.Request, handler: Callable[[web.Request], Awaitable[web.Response]]) -> web.Response: req_path = request.path if request.method == "GET" and req_path in ("/object_info", "/api/object_info") and not request.query_string: want_gz = "gzip" in request.headers.get("Accept-Encoding", "") ckey = "gz" if want_gz else "raw" cached_oi = _OBJ_INFO_CACHE.get(ckey) now = time.monotonic() if cached_oi and (now - cached_oi[0]) < 20.0: _, body_b, ctype, enc = cached_oi hdrs = {"Content-Type": ctype, "Cache-Control": "private, max-age=15", "Vary": "Accept-Encoding"} if enc: hdrs["Content-Encoding"] = enc return web.Response(body=body_b, status=200, headers=hdrs) resp = await handler(request) if isinstance(resp, web.Response) and resp.status == 200 and resp.body is not None: raw_b = bytes(resp.body) enc = resp.headers.get("Content-Encoding", "") ctype = resp.headers.get("Content-Type", "application/json; charset=utf-8") if want_gz and not enc and len(raw_b) > 1024: raw_b = gzip.compress(raw_b, compresslevel=6); enc = "gzip" _OBJ_INFO_CACHE[ckey] = (now, raw_b, ctype, enc) hdrs = dict(resp.headers); hdrs.pop("Transfer-Encoding", None); hdrs.pop("Content-Length", None) hdrs["Cache-Control"] = "private, max-age=15"; hdrs["Vary"] = "Accept-Encoding" if enc: hdrs["Content-Encoding"] = enc return web.Response(body=raw_b, status=200, headers=hdrs) return resp response: web.Response = await handler(request) if req_path.startswith(("/view", "/api/view", "/userdata", "/api/userdata")): return response policy = _cache_policy_for_path(req_path) if request.method == "GET" and isinstance(response, web.FileResponse) and hasattr(response, "_path"): try: fpath = Path(response._path); ext = fpath.suffix.lower() if ext in COMPRESSIBLE_EXTS or ext in FONT_EXTS: st = fpath.stat() if st.st_size <= 25 * 1024 * 1024: key = str(fpath); entry = _STATIC_CACHE.get(key) if entry is None or entry[0] != st.st_mtime_ns or entry[1] != st.st_size: raw_b = fpath.read_bytes() gz_b = gzip.compress(raw_b, compresslevel=6) if (ext in COMPRESSIBLE_EXTS and len(raw_b) > 256) else raw_b ctype = MIME_MAP.get(ext) or mimetypes.guess_type(key)[0] or "application/octet-stream" etag = f'W/"{st.st_mtime_ns:x}-{st.st_size:x}"' if len(_STATIC_CACHE) > 2500: _STATIC_CACHE.clear() entry = (st.st_mtime_ns, st.st_size, raw_b, gz_b, ctype, etag); _STATIC_CACHE[key] = entry _, _, raw_b, gz_b, ctype, etag = entry hdrs = {"ETag": etag, "Cache-Control": policy or f"public, max-age={ONE_DAY}", "Vary": "Accept-Encoding"} for hk in ("Access-Control-Allow-Origin", "Access-Control-Allow-Methods", "Access-Control-Allow-Headers"): if hk in response.headers: hdrs[hk] = response.headers[hk] inm = request.headers.get("If-None-Match") if inm and etag in inm: return web.Response(status=304, headers=hdrs) hdrs["Content-Type"] = ctype if "gzip" in request.headers.get("Accept-Encoding", "") and gz_b is not raw_b and len(gz_b) < len(raw_b): hdrs["Content-Encoding"] = "gzip" return web.Response(body=gz_b, status=200, headers=hdrs) return web.Response(body=raw_b, status=200, headers=hdrs) except OSError: pass if policy: response.headers["Cache-Control"] = policy return response if not req_path.lower().endswith(IMG_EXTENSIONS): return response if response.status == 404: response.headers.setdefault("Cache-Control", f"public, max-age={ONE_HOUR}") elif response.status in (200, 201, 202, 203, 204, 205, 206, 301, 308): response.headers.setdefault("Cache-Control", f"public, max-age={ONE_DAY}") elif response.status in (302, 303, 307): response.headers.setdefault("Cache-Control", "no-cache") return response ''', encoding="utf-8") help_txt = subprocess.run([str(VPY), "main.py", "--help"], cwd=COMFY, capture_output=True, text=True).stdout launch = [ str(VPY), "-u", "main.py", "--listen", "127.0.0.1", "--port", str(PORT), "--disable-auto-launch", ] for flag in ("--fast", "--fast-disk", "--dont-upcast-attention", "--supports-fp8-compute", "--enable-triton-backend", "--enable-cors-header", "--enable-compress-response-body", "--disable-partner-nodes"): if flag in help_txt: launch.append(flag) attn_cli = "--use-sage-attention" if ATTENTION_BACKEND == "sage" else "--use-ck-attention" if attn_cli in help_txt: launch.append(attn_cli) if "--preview-method" in help_txt: launch += ["--preview-method", PREVIEW_METHOD] if "--temp-directory" in help_txt: launch += ["--temp-directory", str(SHM_TEMP)] if "--default-hashing-function" in help_txt: launch += ["--default-hashing-function", "md5"] vram = torch.cuda.get_device_properties(0).total_memory if vram < 16 * 2**30: launch.append("--lowvram") elif vram >= 24 * 2**30 and "--highvram" in help_txt: launch.append("--highvram") if "--reserve-vram" in help_txt: launch += ["--reserve-vram", "2.0"] if "--cache-lru" in help_txt: launch += ["--cache-lru", "32"] env = dict( os.environ, PYTHONUNBUFFERED="1", HF_XET_HIGH_PERFORMANCE="1", HF_HUB_ENABLE_HF_TRANSFER="1", PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True", ) lap(f"Lanzando ComfyUI optimizado ({ATTENTION_BACKEND})...") LOG_PATH.write_text("") COMFY_PROCESS = subprocess.Popen(launch, cwd=COMFY, env=env, stdout=open(LOG_PATH, "a"), stderr=subprocess.STDOUT, start_new_session=True) for _ in range(1200): if COMFY_PROCESS.poll() is not None: log_content = LOG_PATH.read_text(errors="ignore") raise RuntimeError("ComfyUI falló al iniciar:\n" + log_content[-2000:]) try: requests.get(BASE_URL + "/system_stats", timeout=3).raise_for_status() break except requests.RequestException: time.sleep(0.4) else: raise TimeoutError(f"ComfyUI no respondió a tiempo; revisa {LOG_PATH}") lap("🔥 ¡ComfyUI activo en modo HIGH_VRAM + fast_disk=True!") # 4) Túnel Cloudflare QUIC + TCP BBR os.system("sysctl -w net.core.default_qdisc=fq net.ipv4.tcp_congestion_control=bbr net.core.rmem_max=33554432 net.core.wmem_max=33554432 >/dev/null 2>&1") CF_BIN = Path("/usr/local/bin/cloudflared") if not CF_BIN.exists(): sh(["aria2c", "-q", "-x", "8", "-s", "8", "-d", "/usr/local/bin", "-o", "cloudflared", "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64"]) CF_BIN.chmod(0o755) CF_LOG = Path("/content/cloudflared.log"); CF_LOG.write_text("") CF_ZT_LOG = Path("/content/cloudflared_zt.log"); CF_ZT_LOG.write_text("") cf_base = [str(CF_BIN), "tunnel", "--no-autoupdate", "--protocol", TUNNEL_PROTOCOL, "--edge-ip-version", "auto"] if USE_ZERO_TRUST and CLOUDFLARE_TOKEN.strip(): cf_zt = cf_base + ["run", "--token", CLOUDFLARE_TOKEN.strip()] subprocess.Popen(cf_zt, stdout=open(CF_ZT_LOG, "a"), stderr=subprocess.STDOUT, start_new_session=True) print(f"🌐 Túnel Zero Trust ({TUNNEL_PROTOCOL.upper()}) activo: https://colab-comfy.ntic.cl") Path("/content/comfy_url.txt").write_text("https://colab-comfy.ntic.cl") cf_quick = cf_base + ["--url", BASE_URL] subprocess.Popen(cf_quick, stdout=open(CF_LOG, "a"), stderr=subprocess.STDOUT, start_new_session=True) public_url = None for _ in range(40): m = re.search(r"https://[a-z0-9-]+\.trycloudflare\.com", CF_LOG.read_text(errors="ignore")) if m: public_url = m.group(0) print("\n=======================================================") if USE_ZERO_TRUST and CLOUDFLARE_TOKEN.strip(): print("🚀 ENLACE PRINCIPAL ZERO TRUST: https://colab-comfy.ntic.cl") print(f"🚀 ENLACE RESPALDO TRYCLOUDFLARE: {public_url}") print("=======================================================\n") if not (USE_ZERO_TRUST and CLOUDFLARE_TOKEN.strip()): Path("/content/comfy_url.txt").write_text(public_url) break time.sleep(0.4) # 5) Auto-Warmup asíncrono en GPU (pre-carga los 37.6 GiB en VRAM para que la 1ª petición web tarde ~3.6s en vez de 14s) def _bg_gpu_warmup(): try: from PIL import Image w_img = COMFY / "input" / "_warmup_ref.png" if not w_img.exists(): Image.new("RGB", (256, 256), (64, 72, 96)).save(w_img) if INFERENCE_MODE != "reference": return g = { "1": {"class_type": "UNETLoader", "inputs": {"unet_name": DIFFUSION, "weight_dtype": "default"}}, "2": {"class_type": "LoraLoaderModelOnly", "inputs": {"model": ["1", 0], "lora_name": PRIMARY_TURBO_LORA, "strength_model": 1.0}}, "3": {"class_type": "CLIPLoader", "inputs": {"clip_name": TEXT_ENCODER, "type": "minimax", "device": "default"}}, "4": {"class_type": "VAELoader", "inputs": {"vae_name": VIDEO_VAE}}, "5": {"class_type": "VAELoader", "inputs": {"vae_name": AUDIO_VAE}}, "6": {"class_type": "LoadImage", "inputs": {"image": "_warmup_ref.png"}}, "7": {"class_type": "MiniMaxH3ReferenceToVideo", "inputs": {"clip": ["3", 0], "prompt": "Warmup .", "width": 256, "height": 256, "length": 5, "ref_image_size": "match", "vae": ["4", 0], "audio_vae": ["5", 0], "ref_images.ref_image_1": ["6", 0]}}, "8": {"class_type": "BasicGuider", "inputs": {"model": ["2", 0], "conditioning": ["7", 0]}}, "9": {"class_type": "RandomNoise", "inputs": {"noise_seed": 1}}, "10": {"class_type": "KSamplerSelect", "inputs": {"sampler_name": "euler"}}, "11": {"class_type": "BasicScheduler", "inputs": {"scheduler": "beta", "steps": 1, "denoise": 1.0, "model": ["2", 0]}}, "12": {"class_type": "SamplerCustomAdvanced", "inputs": {"noise": ["9", 0], "guider": ["8", 0], "sampler": ["10", 0], "sigmas": ["11", 0], "latent_image": ["7", 1]}}, "13": {"class_type": "VAEDecode", "inputs": {"samples": ["12", 0], "vae": ["4", 0]}}, "14": {"class_type": "PreviewImage", "inputs": {"images": ["13", 0]}}, } requests.post(BASE_URL + "/prompt", json={"prompt": g, "client_id": "boot-warmup"}, timeout=10) except Exception as _we: print("Warmup aviso:", _we) if WARMUP_ON_BOOT and vram >= 40 * 2**30: threading.Thread(target=_bg_gpu_warmup, daemon=True).start() lap("⚡ Auto-Warmup GPU disparado en background (anclando UNET + Qwen3VL-32B + VAEs en VRAM).") def _bg_http_ram_prewarm(): try: requests.get(BASE_URL + "/api/object_info", headers={"Accept-Encoding": "gzip"}, timeout=20) exts = requests.get(BASE_URL + "/extensions", headers={"Accept-Encoding": "gzip"}, timeout=10).json() for ep in exts: requests.get(BASE_URL + ep, headers={"Accept-Encoding": "gzip"}, timeout=5) except Exception: pass threading.Thread(target=_bg_http_ram_prewarm, daemon=True).start() # 6) Demonio Watchdog Anti-Caídas + Keep-Alive GPU (/content/comfy_watchdog.py) watchdog_code = f'''import os, time, subprocess, urllib.request import torch LAUNCH_CMD = {launch!r} CF_ZT_CMD = {[str(CF_BIN), "tunnel", "--no-autoupdate", "--protocol", TUNNEL_PROTOCOL, "--edge-ip-version", "auto", "run", "--token", CLOUDFLARE_TOKEN.strip()]!r} USE_ZT = {bool(USE_ZERO_TRUST and CLOUDFLARE_TOKEN.strip())!r} COMFY_DIR = "/content/ComfyUI" LOG_PATH = "/content/comfyui_h3.log" CF_ZT_LOG = "/content/cloudflared_zt.log" def is_comfy_up(): try: urllib.request.urlopen("http://127.0.0.1:8188/system_stats", timeout=5) return True except Exception: return False def is_proc_running(pattern): return subprocess.run(["pgrep", "-f", pattern], capture_output=True).returncode == 0 last_gpu_pulse = 0 fail_count = 0 while True: try: if not is_comfy_up(): fail_count += 1 if not is_proc_running("[m]ain.py --listen") or fail_count >= 6: os.system("pkill -9 -f '[m]ain.py --listen' 2>/dev/null") time.sleep(1) env = dict(os.environ, PYTHONUNBUFFERED="1", HF_XET_HIGH_PERFORMANCE="1", PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True") subprocess.Popen(LAUNCH_CMD, cwd=COMFY_DIR, env=env, stdout=open(LOG_PATH, "a"), stderr=subprocess.STDOUT, start_new_session=True) fail_count = 0 time.sleep(15) else: fail_count = 0 if USE_ZT and not is_proc_running("cloudflared.*--token"): subprocess.Popen(CF_ZT_CMD, stdout=open(CF_ZT_LOG, "a"), stderr=subprocess.STDOUT, start_new_session=True) now = time.time() if now - last_gpu_pulse > 40 and torch.cuda.is_available(): _x = torch.ones((64, 64), device="cuda", dtype=torch.float16) _y = _x @ _x del _x, _y last_gpu_pulse = now except Exception as e: print("[Watchdog] Error:", e, flush=True) time.sleep(8) ''' Path("/content/comfy_watchdog.py").write_text(watchdog_code, encoding="utf-8") subprocess.Popen([str(VPY), "-u", "/content/comfy_watchdog.py"], stdout=open("/content/watchdog.log", "a"), stderr=subprocess.STDOUT, start_new_session=True) lap("🛡️ Watchdog Anti-Caídas y GPU Keep-Alive activo (/content/comfy_watchdog.py).") lap("🎉 ¡Servidor listo para inferencia remota de ultra-baja latencia!") if KEEP_CELL_ALIVE and ("ipykernel" in sys.modules) and os.environ.get("COLAB_BACKGROUND_BOOTSTRAP") != "1": print("🔒 Modo Anti-Desconexión Activo en celda...") last_pos = LOG_PATH.stat().st_size if LOG_PATH.exists() else 0 try: while True: if LOG_PATH.exists(): with open(LOG_PATH, "r", encoding="utf-8", errors="ignore") as _f: _f.seek(0, 2) curr_pos = _f.tell() if curr_pos < last_pos: last_pos = 0 if curr_pos > last_pos: _f.seek(last_pos) print(_f.read(), end="", flush=True) last_pos = curr_pos time.sleep(2.0) except KeyboardInterrupt: print("\nℹ️ Streaming pausado (ComfyUI + Watchdog siguen activos en background).")