Update main.py

main.py

@@ -6,7 +6,6 @@ import json
 import sys
 import time
 import zipfile
-import re
 import requests
 import gradio as gr
 
@@ -18,25 +17,24 @@ FRP_VERSION = "0.69.0"
 CURRENT_DIR = REPO_PATH
 LAST_OUTPUT = ""
 
-# ===== 新增：ModelScope 整库克隆/下载并启动 ComfyUI 的配置 =====
+# ===== ModelScope 下载 comfy_portable.zip 并启动 ComfyUI 的配置 =====
 MODELSCOPE_MODEL_ID = "HOPStudio/forgeui"
-# forgeui 整库和 offline_build 下载包都很大，不放在 REPO_PATH 里，避免 clone_repository() 删除 /root/modelscope 时把断点文件删掉。
-OFFLINE_BUILD_CACHE_DIR = "/root/offline_build_cache"
-MODELSCOPE_DOWNLOAD_DIR = os.path.join(OFFLINE_BUILD_CACHE_DIR, "modelscope_download")
-MODELSCOPE_CACHE_DIR = os.path.join(OFFLINE_BUILD_CACHE_DIR, "modelscope_cache")
-OFFLINE_BUILD_DIR = os.path.join(REPO_PATH, "offline_build")
+COMFY_PORTABLE_ZIP_NAME = "comfy_portable.zip"
+
+# 便携整合包固定路径：下载到 /root/comfy_portable.zip，解压后得到 /root/comfy_portable。
+# 运行时不使用 venv，只调用整合包内置 Python。
+COMFY_PORTABLE_ZIP_PATH = "/root/comfy_portable.zip"
+COMFY_PORTABLE_DIR = "/root/comfy_portable"
+COMFY_PORTABLE_PYTHON = os.path.join(COMFY_PORTABLE_DIR, "python", "bin", "python")
+COMFYUI_DIR = os.path.join(COMFY_PORTABLE_DIR, "ComfyUI")
+COMFYUI_MAIN = os.path.join(COMFYUI_DIR, "main.py")
+
+MODELSCOPE_CACHE_DIR = "/root/modelscope_cache"
 COMFYUI_PORT = 8188
 COMFYUI_LOG_PATH = os.path.join(REPO_PATH, "comfyui.log")
 PROXY_URL = "http://103.71.69.203:17890"
 MODELSCOPE_DOWNLOAD_TIMEOUT = 21600
 
-# 兼容可能的文件名拼写：用户当前指定 offlinbuild.zip，
-# 同时兼容 offlinebuild.zip / offline_build.zip，避免文件名略有差异时直接失败。
-OFFLINE_BUILD_ZIP_CANDIDATES = [
-    "offlinbuild.zip",
-    "offlinebuild.zip",
-    "offline_build.zip"
-]
 
 
 def clone_repository():
@@ -392,7 +390,7 @@ def start_jupyterlab_process():
 
 
 
-# ===== 新增：ModelScope 整库克隆/下载 offline_build 并启动 ComfyUI =====
+# ===== ModelScope 下载 comfy_portable.zip，解压并用内置 Python 启动 ComfyUI =====
 def get_proxy_env():
     env = os.environ.copy()
 
@@ -407,25 +405,14 @@ def get_proxy_env():
     return env
 
 
-def get_modelscope_download_env(use_proxy=False):
+def get_modelscope_download_env(use_proxy=True):
     env = os.environ.copy()
 
-    # 固定 ModelScope 缓存目录，避免默认缓存散落到 ~/.cache，且方便断点续传。
     os.makedirs(MODELSCOPE_CACHE_DIR, exist_ok=True)
     env["MODELSCOPE_CACHE"] = MODELSCOPE_CACHE_DIR
     env["MODELSCOPE_ENDPOINT"] = "https://www.modelscope.cn"
     env["MODELSCOPE_SDK_ENDPOINT"] = "https://www.modelscope.cn"
 
-    # ModelScope 下载大文件时会跳到阿里云 OSS。这里默认直连，避免代理把 OSS 内网地址转坏。
-    proxy_keys = [
-        "http_proxy",
-        "https_proxy",
-        "HTTP_PROXY",
-        "HTTPS_PROXY",
-        "ALL_PROXY",
-        "all_proxy"
-    ]
-
     if use_proxy:
         env["http_proxy"] = PROXY_URL
         env["https_proxy"] = PROXY_URL
@@ -434,12 +421,18 @@ def get_modelscope_download_env(use_proxy=False):
         env["ALL_PROXY"] = PROXY_URL
         env["all_proxy"] = PROXY_URL
     else:
-        for key in proxy_keys:
+        for key in [
+            "http_proxy",
+            "https_proxy",
+            "HTTP_PROXY",
+            "HTTPS_PROXY",
+            "ALL_PROXY",
+            "all_proxy"
+        ]:
             env.pop(key, None)
 
-    no_proxy_value = "localhost,127.0.0.1,modelscope.cn,www.modelscope.cn,.modelscope.cn,aliyuncs.com,.aliyuncs.com"
-    env["no_proxy"] = no_proxy_value
-    env["NO_PROXY"] = no_proxy_value
+    env["no_proxy"] = "localhost,127.0.0.1"
+    env["NO_PROXY"] = "localhost,127.0.0.1"
 
     return env
 
@@ -474,35 +467,11 @@ def is_valid_zip(path):
             return False
 
         with zipfile.ZipFile(path, "r") as zf:
-            # 只读取目录，不做全量 testzip，避免大压缩包校验耗时过长。
             return len(zf.namelist()) > 0
     except Exception:
         return False
 
 
-def find_existing_offline_zip():
-    search_dirs = [MODELSCOPE_DOWNLOAD_DIR, OFFLINE_BUILD_CACHE_DIR, REPO_PATH]
-
-    for directory in search_dirs:
-        if not os.path.isdir(directory):
-            continue
-
-        for zip_name in OFFLINE_BUILD_ZIP_CANDIDATES:
-            zip_path = os.path.join(directory, zip_name)
-            if is_valid_zip(zip_path):
-                return zip_path
-
-        for root, _, files in os.walk(directory):
-            for filename in files:
-                lower_name = filename.lower()
-                if lower_name.endswith(".zip") and "offlin" in lower_name:
-                    zip_path = os.path.join(root, filename)
-                    if is_valid_zip(zip_path):
-                        return zip_path
-
-    return None
-
-
 def install_modelscope_cli():
     if shutil.which("modelscope"):
         print("检测到 modelscope 命令。")
@@ -535,6 +504,7 @@ def install_modelscope_cli():
         try:
             result = subprocess.run(
                 command,
+                env=get_proxy_env(),
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
@@ -556,297 +526,43 @@ def install_modelscope_cli():
         except Exception as e:
             print(f"modelscope 安装异常: {e}")
 
-    print("modelscope 不可用，无法继续下载 offline_build。")
+    print("modelscope 不可用，无法继续下载 comfy_portable.zip。")
     return False
 
 
-def extract_urls_from_text(text):
-    if not text:
-        return []
-
-    urls = re.findall(r"https?://[^\s'\")<>]+", text)
-    cleaned_urls = []
-
-    for url in urls:
-        cleaned_urls.append(url.rstrip(".,;"))
-
-    return cleaned_urls
-
-
-def convert_internal_oss_url_to_public(url):
-    if not url:
-        return None
-
-    public_url = url.replace("-internal.aliyuncs.com", ".aliyuncs.com")
-    public_url = public_url.replace("http://", "https://", 1)
-
-    if public_url == url:
-        return None
-
-    return public_url
-
-
-def download_url_to_file(url, output_path, use_proxy=False):
-    os.makedirs(os.path.dirname(output_path), exist_ok=True)
-
-    env = get_modelscope_download_env(use_proxy=use_proxy)
-
-    if shutil.which("aria2c"):
-        command = [
-            "aria2c",
-            "--continue=true",
-            "--max-connection-per-server=8",
-            "--split=8",
-            "--min-split-size=16M",
-            "--check-certificate=false",
-            "--summary-interval=30",
-            "--timeout=30",
-            "--retry-wait=10",
-            "--max-tries=20",
-            "--dir",
-            os.path.dirname(output_path),
-            "--out",
-            os.path.basename(output_path),
-            url
-        ]
-    else:
-        command = [
-            "wget",
-            "--continue",
-            "--timeout=30",
-            "--tries=20",
-            "--no-check-certificate",
-            "--output-document",
-            output_path,
-            url
-        ]
+def locate_comfy_portable_dir():
+    if os.path.exists(COMFY_PORTABLE_PYTHON) and os.path.exists(COMFYUI_MAIN):
+        return COMFY_PORTABLE_DIR
 
+    # 兼容 zip 解压后多套了一层目录的情况。
+    root_dir = "/root"
     try:
-        print("执行直链下载命令: " + " ".join(command[:1]) + " ...")
+        for root, dirs, files in os.walk(root_dir):
+            if root.count(os.sep) - root_dir.count(os.sep) > 4:
+                dirs[:] = []
+                continue
 
-        result = subprocess.run(
-            command,
-            env=env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=MODELSCOPE_DOWNLOAD_TIMEOUT
-        )
-
-        if result.stdout.strip():
-            print(result.stdout[-2000:])
-        if result.stderr.strip():
-            print(result.stderr[-2000:])
+            candidate_python = os.path.join(root, "python", "bin", "python")
+            candidate_main = os.path.join(root, "ComfyUI", "main.py")
 
-        if result.returncode == 0 and is_valid_zip(output_path):
-            print(f"直链下载成功: {output_path}")
-            return True
-
-        print(f"直链下载失败或压缩包无效: {output_path}")
-        return False
-
-    except subprocess.TimeoutExpired:
-        print("直链下载超时。")
-        return False
+            if os.path.exists(candidate_python) and os.path.exists(candidate_main):
+                return root
     except Exception as e:
-        print(f"直链下载异常: {e}")
-        return False
-
-
-def try_public_oss_fallback(download_output, zip_name):
-    urls = extract_urls_from_text(download_output)
-
-    for url in urls:
-        public_url = convert_internal_oss_url_to_public(url)
-        if not public_url:
-            continue
-
-        print("检测到 ModelScope 返回 OSS 内网地址，尝试改用公网 OSS 地址继续下载。")
-        target_path = os.path.join(MODELSCOPE_DOWNLOAD_DIR, zip_name)
-
-        # 先直连公网 OSS；失败后才走代理。直连更适合国内服务器访问阿里云 OSS。
-        if download_url_to_file(public_url, target_path, use_proxy=False):
-            return target_path
-
-        if download_url_to_file(public_url, target_path, use_proxy=True):
-            return target_path
+        print(f"定位 comfy_portable 目录异常: {e}")
 
     return None
 
 
-def ensure_git_lfs_available():
-    try:
-        result = subprocess.run(
-            ["git", "lfs", "version"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=20
-        )
-        if result.returncode == 0:
-            print("检测到 git-lfs。")
-            return True
-    except Exception:
-        pass
-
-    print("未检测到 git-lfs，尝试安装 git-lfs。")
-
-    install_commands = []
-    if shutil.which("apt-get"):
-        install_commands.append(["bash", "-lc", "apt-get update && apt-get install -y git-lfs"])
-    if shutil.which("yum"):
-        install_commands.append(["bash", "-lc", "yum install -y git-lfs"])
-
-    for command in install_commands:
-        try:
-            result = subprocess.run(
-                command,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                timeout=600
-            )
-            if result.stdout.strip():
-                print(result.stdout[-2000:])
-            if result.stderr.strip():
-                print(result.stderr[-2000:])
-
-            check = subprocess.run(
-                ["git", "lfs", "version"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                timeout=20
-            )
-            if check.returncode == 0:
-                print("git-lfs 安装成功。")
-                return True
-
-        except subprocess.TimeoutExpired:
-            print("git-lfs 安装超时。")
-        except Exception as e:
-            print(f"git-lfs 安装异常: {e}")
-
-    print("git-lfs 不可用，后续 git clone 可能只能拿到 LFS 指针文件。")
-    return False
-
-
-def clone_whole_forgeui_repo_with_git():
-    os.makedirs(OFFLINE_BUILD_CACHE_DIR, exist_ok=True)
-
-    existing_zip = find_existing_offline_zip()
-    if existing_zip:
-        print(f"检测到已有 offline_build 压缩包: {existing_zip}")
-        return existing_zip
-
-    if not shutil.which("git"):
-        print("未检测到 git，跳过 git 整库克隆。")
-        return None
-
-    ensure_git_lfs_available()
-
-    repo_urls = [
-        "https://www.modelscope.cn/HOPStudio/forgeui.git",
-        "https://modelscope.cn/HOPStudio/forgeui.git"
-    ]
-
-    if os.path.isdir(os.path.join(MODELSCOPE_DOWNLOAD_DIR, ".git")):
-        print(f"检测到已存在 ModelScope 整库仓库: {MODELSCOPE_DOWNLOAD_DIR}")
-        try:
-            subprocess.run(
-                ["git", "-C", MODELSCOPE_DOWNLOAD_DIR, "lfs", "pull"],
-                env=get_modelscope_download_env(use_proxy=False),
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                timeout=MODELSCOPE_DOWNLOAD_TIMEOUT
-            )
-        except Exception as e:
-            print(f"git lfs pull 执行异常: {e}")
-
-        existing_zip = find_existing_offline_zip()
-        if existing_zip:
-            print(f"在已克隆仓库中找到 offline_build 压缩包: {existing_zip}")
-            return existing_zip
-
-    elif os.path.exists(MODELSCOPE_DOWNLOAD_DIR):
-        # 这里是旧版 modelscope download 留下的目录。整库 git clone 需要空目录，
-        # 因此先改名备份，不直接删除，避免误删已有断点文件。
-        backup_dir = MODELSCOPE_DOWNLOAD_DIR + f".bak_{int(time.time())}"
-        try:
-            shutil.move(MODELSCOPE_DOWNLOAD_DIR, backup_dir)
-            print(f"检测到非 git 下载目录，已备份为: {backup_dir}")
-        except Exception as e:
-            print(f"备份旧下载目录失败: {e}")
-            return None
-
-    for repo_url in repo_urls:
-        for use_proxy, mode_name in [(False, "直连"), (True, "代理")]:
-            if os.path.exists(MODELSCOPE_DOWNLOAD_DIR):
-                shutil.rmtree(MODELSCOPE_DOWNLOAD_DIR, ignore_errors=True)
-
-            env = get_modelscope_download_env(use_proxy=use_proxy)
-            command = [
-                "git",
-                "clone",
-                "--depth",
-                "1",
-                repo_url,
-                MODELSCOPE_DOWNLOAD_DIR
-            ]
-
-            try:
-                print(f"执行 ModelScope 整库 git clone [{mode_name}]: " + " ".join(command))
-
-                result = subprocess.run(
-                    command,
-                    env=env,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    timeout=MODELSCOPE_DOWNLOAD_TIMEOUT
-                )
-
-                if result.stdout.strip():
-                    print(result.stdout[-2000:])
-                if result.stderr.strip():
-                    print(result.stderr[-4000:])
-
-                if result.returncode != 0:
-                    print("本次 git clone 失败，继续尝试下一个方式。")
-                    continue
-
-                try:
-                    subprocess.run(
-                        ["git", "-C", MODELSCOPE_DOWNLOAD_DIR, "lfs", "pull"],
-                        env=env,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        text=True,
-                        timeout=MODELSCOPE_DOWNLOAD_TIMEOUT
-                    )
-                except Exception as e:
-                    print(f"git lfs pull 执行异常: {e}")
-
-                zip_path = find_existing_offline_zip()
-                if zip_path:
-                    print(f"ModelScope 整库克隆完成，找到 offline_build 压缩包: {zip_path}")
-                    return zip_path
-
-                print("整库 git clone 完成，但未找到有效 offline_build 压缩包。")
-
-            except subprocess.TimeoutExpired:
-                print("ModelScope 整库 git clone 超时，继续尝试下一个方式。")
-            except Exception as e:
-                print(f"ModelScope 整库 git clone 异常: {e}")
-
-    return None
-
+def download_comfy_portable_from_modelscope():
+    if is_valid_zip(COMFY_PORTABLE_ZIP_PATH):
+        print(f"检测到已有 comfy_portable.zip: {COMFY_PORTABLE_ZIP_PATH}")
+        return COMFY_PORTABLE_ZIP_PATH
 
-def download_whole_forgeui_repo_with_modelscope_cli():
     if not install_modelscope_cli():
         return None
 
+    os.makedirs(MODELSCOPE_CACHE_DIR, exist_ok=True)
+
     commands = [
         (
             [
@@ -854,11 +570,12 @@ def download_whole_forgeui_repo_with_modelscope_cli():
                 "download",
                 "--model",
                 MODELSCOPE_MODEL_ID,
+                COMFY_PORTABLE_ZIP_NAME,
                 "--local_dir",
-                MODELSCOPE_DOWNLOAD_DIR
+                "/root"
             ],
-            False,
-            "整库直连"
+            True,
+            "代理下载"
         ),
         (
             [
@@ -866,13 +583,12 @@ def download_whole_forgeui_repo_with_modelscope_cli():
                 "download",
                 "--model",
                 MODELSCOPE_MODEL_ID,
+                COMFY_PORTABLE_ZIP_NAME,
                 "--local_dir",
-                MODELSCOPE_DOWNLOAD_DIR,
-                "--endpoint",
-                "https://www.modelscope.cn"
+                "/root"
             ],
             False,
-            "整库直连+显式 endpoint"
+            "直连下载"
         ),
         (
             [
@@ -881,16 +597,28 @@ def download_whole_forgeui_repo_with_modelscope_cli():
                 "--model",
                 MODELSCOPE_MODEL_ID,
                 "--local_dir",
-                MODELSCOPE_DOWNLOAD_DIR
+                "/root/modelscope_download"
             ],
             True,
-            "整库代理"
+            "整库代理下载"
+        ),
+        (
+            [
+                "modelscope",
+                "download",
+                "--model",
+                MODELSCOPE_MODEL_ID,
+                "--local_dir",
+                "/root/modelscope_download"
+            ],
+            False,
+            "整库直连下载"
         )
     ]
 
     for command, use_proxy, mode_name in commands:
         try:
-            print(f"执行 ModelScope CLI 整库下载 [{mode_name}]: " + " ".join(command))
+            print(f"执行 ModelScope 下载 [{mode_name}]: " + " ".join(command))
 
             result = subprocess.run(
                 command,
@@ -901,129 +629,122 @@ def download_whole_forgeui_repo_with_modelscope_cli():
                 timeout=MODELSCOPE_DOWNLOAD_TIMEOUT
             )
 
-            output_text = ""
             if result.stdout.strip():
-                output_text += result.stdout + "\n"
                 print(result.stdout[-2000:])
             if result.stderr.strip():
-                output_text += result.stderr + "\n"
                 print(result.stderr[-4000:])
 
-            zip_path = find_existing_offline_zip()
-            if result.returncode == 0 and zip_path:
-                print(f"ModelScope CLI 整库下载完成，找到 offline_build 压缩包: {zip_path}")
-                return zip_path
+            if is_valid_zip(COMFY_PORTABLE_ZIP_PATH):
+                print(f"comfy_portable.zip 下载完成: {COMFY_PORTABLE_ZIP_PATH}")
+                return COMFY_PORTABLE_ZIP_PATH
 
-            # 这里不再按文件名调用 modelscope download，只在 CLI 日志暴露 OSS 直链时做公网地址回退。
-            fallback_zip = try_public_oss_fallback(output_text, "offlinbuild.zip")
-            if fallback_zip and is_valid_zip(fallback_zip):
-                print(f"offline_build 压缩包通过公网 OSS 回退下载成功: {fallback_zip}")
+            fallback_zip = os.path.join("/root/modelscope_download", COMFY_PORTABLE_ZIP_NAME)
+            if is_valid_zip(fallback_zip):
+                print(f"在整库下载目录中找到 comfy_portable.zip: {fallback_zip}")
                 return fallback_zip
 
-            print("本次整库下载未找到有效 offline_build 压缩包，继续尝试下一个命令。")
+            if result.returncode != 0:
+                print("本次 ModelScope 下载失败，继续尝试下一个方式。")
+            else:
+                print("本次 ModelScope 下载完成，但未找到有效 comfy_portable.zip。")
 
         except subprocess.TimeoutExpired:
-            print("ModelScope CLI 整库下载超时，继续尝试下一个命令。")
+            print("ModelScope 下载超时，继续尝试下一个方式。")
         except Exception as e:
-            print(f"ModelScope CLI 整库下载异常: {e}")
+            print(f"ModelScope 下载异常: {e}")
 
+    print("ModelScope 下载失败，未找到有效 comfy_portable.zip。")
     return None
 
 
-def download_offline_build_from_modelscope():
-    os.makedirs(MODELSCOPE_DOWNLOAD_DIR, exist_ok=True)
-    os.makedirs(MODELSCOPE_CACHE_DIR, exist_ok=True)
-
-    existing_zip = find_existing_offline_zip()
-    if existing_zip:
-        print(f"检测到已有 offline_build 压缩包: {existing_zip}")
-        return existing_zip
-
-    print(f"开始从 ModelScope 整库克隆/下载 {MODELSCOPE_MODEL_ID}。")
-
-    zip_path = clone_whole_forgeui_repo_with_git()
-    if zip_path:
-        return zip_path
-
-    print("git 整库克隆未成功，改用 ModelScope CLI 整库下载。")
-
-    zip_path = download_whole_forgeui_repo_with_modelscope_cli()
-    if zip_path:
-        return zip_path
+def safe_extract_zip(zip_path, extract_root):
+    if not is_valid_zip(zip_path):
+        print(f"zip 文件无效: {zip_path}")
+        return False
 
-    print("ModelScope 整库克隆/下载失败，未找到有效 offline_build 压缩包。")
-    return None
+    try:
+        extract_root_abs = os.path.abspath(extract_root)
 
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            for member in zf.infolist():
+                target_path = os.path.abspath(os.path.join(extract_root_abs, member.filename))
+                if not target_path.startswith(extract_root_abs + os.sep) and target_path != extract_root_abs:
+                    raise RuntimeError(f"zip 中存在不安全路径: {member.filename}")
 
-def locate_offline_build_dir():
-    expected_main = os.path.join(OFFLINE_BUILD_DIR, "ComfyUI", "main.py")
-    if os.path.exists(expected_main):
-        return OFFLINE_BUILD_DIR
+            zf.extractall(extract_root_abs)
 
-    for root, dirs, files in os.walk(REPO_PATH):
-        if "main.py" in files and os.path.basename(root) == "ComfyUI":
-            parent_dir = os.path.dirname(root)
-            venv_activate = os.path.join(parent_dir, "venv", "bin", "activate")
-            if os.path.exists(venv_activate):
-                return parent_dir
+        return True
 
-    return None
+    except Exception as e:
+        print(f"解压 zip 失败: {e}")
+        return False
 
 
-def extract_offline_build(zip_path):
-    existing_dir = locate_offline_build_dir()
+def extract_comfy_portable(zip_path):
+    existing_dir = locate_comfy_portable_dir()
     if existing_dir:
-        print(f"检测到已解压的 offline_build: {existing_dir}")
+        print(f"检测到已解压的 comfy_portable: {existing_dir}")
         return existing_dir
 
     if not zip_path or not is_valid_zip(zip_path):
-        print(f"offline_build 压缩包无效: {zip_path}")
+        print(f"comfy_portable.zip 无效: {zip_path}")
         return None
 
     try:
-        print(f"正在解压 offline_build: {zip_path}")
+        if os.path.exists(COMFY_PORTABLE_DIR):
+            backup_dir = COMFY_PORTABLE_DIR + f".bak_{int(time.time())}"
+            shutil.move(COMFY_PORTABLE_DIR, backup_dir)
+            print(f"检测到不完整 comfy_portable 目录，已备份为: {backup_dir}")
 
-        with zipfile.ZipFile(zip_path, "r") as zf:
-            zf.extractall(REPO_PATH)
+        print(f"正在解压 comfy_portable.zip: {zip_path}")
+        if not safe_extract_zip(zip_path, "/root"):
+            return None
 
-        extracted_dir = locate_offline_build_dir()
-        if extracted_dir:
-            print(f"offline_build 解压完成: {extracted_dir}")
-            return extracted_dir
+        portable_dir = locate_comfy_portable_dir()
+        if not portable_dir:
+            print("解压完成，但未找到 python/bin/python 和 ComfyUI/main.py。")
+            return None
 
-        print("解压完成，但未找到 offline_build/ComfyUI/main.py。")
-        return None
+        python_path = os.path.join(portable_dir, "python", "bin", "python")
+        try:
+            subprocess.run(["chmod", "+x", python_path], check=False)
+        except Exception:
+            pass
+
+        print(f"comfy_portable 解压完成: {portable_dir}")
+        return portable_dir
 
     except Exception as e:
-        print(f"解压 offline_build 失败: {e}")
+        print(f"准备 comfy_portable 失败: {e}")
         return None
 
 
-def prepare_offline_build():
-    existing_dir = locate_offline_build_dir()
+def prepare_comfy_portable():
+    existing_dir = locate_comfy_portable_dir()
     if existing_dir:
-        print(f"offline_build 已存在，跳过下载解压: {existing_dir}")
+        print(f"comfy_portable 已存在，跳过下载解压: {existing_dir}")
         return existing_dir
 
-    zip_path = download_offline_build_from_modelscope()
+    zip_path = download_comfy_portable_from_modelscope()
     if not zip_path:
         return None
 
-    return extract_offline_build(zip_path)
+    return extract_comfy_portable(zip_path)
 
 
 def start_comfyui_process():
-    offline_build_dir = prepare_offline_build()
+    portable_dir = prepare_comfy_portable()
 
-    if not offline_build_dir:
-        print("offline_build 准备失败，跳过 ComfyUI 启动。")
+    if not portable_dir:
+        print("comfy_portable 准备失败，跳过 ComfyUI 启动。")
         return
 
-    venv_activate = os.path.join(offline_build_dir, "venv", "bin", "activate")
-    comfyui_main = os.path.join(offline_build_dir, "ComfyUI", "main.py")
+    python_path = os.path.join(portable_dir, "python", "bin", "python")
+    comfyui_dir = os.path.join(portable_dir, "ComfyUI")
+    comfyui_main = os.path.join(comfyui_dir, "main.py")
 
-    if not os.path.exists(venv_activate):
-        print(f"未找到虚拟环境激活脚本: {venv_activate}")
+    if not os.path.exists(python_path):
+        print(f"未找到便携 Python: {python_path}")
         return
 
     if not os.path.exists(comfyui_main):
@@ -1032,9 +753,11 @@ def start_comfyui_process():
 
     configure_git_proxy()
 
+    python_lib_dir = os.path.join(portable_dir, "python", "lib")
+
     command = f'''
 set -e
-source "{venv_activate}"
+export LD_LIBRARY_PATH="{python_lib_dir}:${{LD_LIBRARY_PATH:-}}"
 export http_proxy={PROXY_URL}
 export https_proxy={PROXY_URL}
 export HTTP_PROXY={PROXY_URL}
@@ -1044,8 +767,8 @@ export no_proxy=localhost,127.0.0.1
 export NO_PROXY=localhost,127.0.0.1
 git config --global http.proxy {PROXY_URL}
 git config --global https.proxy {PROXY_URL}
-cd "{os.path.join(offline_build_dir, "ComfyUI")}"
-python main.py --listen 0.0.0.0 --port {COMFYUI_PORT}
+cd "{comfyui_dir}"
+"{python_path}" main.py --listen 0.0.0.0 --port {COMFYUI_PORT}
 '''
 
     try:
@@ -1054,7 +777,7 @@ python main.py --listen 0.0.0.0 --port {COMFYUI_PORT}
 
         process = subprocess.Popen(
             ["bash", "-lc", command],
-            cwd=offline_build_dir,
+            cwd=portable_dir,
             env=get_proxy_env(),
             stdout=log_file,
             stderr=subprocess.STDOUT