Update main.py

main.py

@@ -3,10 +3,6 @@ import subprocess
 import threading
 import shutil
 import json
-import sys
-import time
-import zipfile
-import re
 import requests
 import gradio as gr
 
@@ -18,26 +14,6 @@ FRP_VERSION = "0.69.0"
 CURRENT_DIR = REPO_PATH
 LAST_OUTPUT = ""
 
-# ===== 新增：ModelScope 整库克隆/下载并启动 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")
-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():
     if os.path.exists(REPO_PATH):
@@ -391,8 +367,19 @@ def start_jupyterlab_process():
         print(f"启动 JupyterLab 失败: {e}")
 
 
+# ===== 新增：ModelScope 下载 comfy_portable.zip，解压后使用自带 Python 启动 ComfyUI =====
+MODELSCOPE_MODEL_ID = "HOPStudio/forgeui"
+COMFY_PORTABLE_ZIP_NAME = "comfy_portable.zip"
+COMFY_PORTABLE_ZIP_PATH = os.path.join("/root", COMFY_PORTABLE_ZIP_NAME)
+COMFY_PORTABLE_DIR = "/root/comfy_portable"
+COMFY_PORTABLE_PYTHON = os.path.join(COMFY_PORTABLE_DIR, "python", "bin", "python")
+COMFYUI_MAIN = os.path.join(COMFY_PORTABLE_DIR, "ComfyUI", "main.py")
+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
+
 
-# ===== 新增：ModelScope 整库克隆/下载 offline_build 并启动 ComfyUI =====
 def get_proxy_env():
     env = os.environ.copy()
 
@@ -407,16 +394,11 @@ def get_proxy_env():
     return env
 
 
-def get_modelscope_download_env(use_proxy=False):
+def get_modelscope_env(use_proxy=False):
     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",
@@ -437,9 +419,8 @@ def get_modelscope_download_env(use_proxy=False):
         for key in proxy_keys:
             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
 
@@ -470,571 +451,158 @@ def is_valid_zip(path):
         return False
 
     try:
+        import zipfile
         if not zipfile.is_zipfile(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
+def is_comfy_portable_ready():
+    return os.path.exists(COMFY_PORTABLE_PYTHON) and os.path.exists(COMFYUI_MAIN)
 
-        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 命令。")
+def download_comfy_portable_from_modelscope():
+    if is_comfy_portable_ready():
+        print(f"检测到已解压的 comfy_portable: {COMFY_PORTABLE_DIR}")
         return True
 
-    print("未检测到 modelscope 命令，尝试安装 modelscope。")
-
-    install_commands = [
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "-U",
-            "modelscope",
-            "-i",
-            "https://pypi.tuna.tsinghua.edu.cn/simple"
-        ],
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "-U",
-            "modelscope"
-        ]
-    ]
+    if is_valid_zip(COMFY_PORTABLE_ZIP_PATH):
+        print(f"检测到已有 comfy_portable 压缩包: {COMFY_PORTABLE_ZIP_PATH}")
+        return True
 
-    for command in install_commands:
+    if os.path.exists(COMFY_PORTABLE_ZIP_PATH):
+        print(f"检测到无效 comfy_portable 压缩包，正在删除: {COMFY_PORTABLE_ZIP_PATH}")
         try:
-            result = subprocess.run(
-                command,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                timeout=300
-            )
-
-            if result.returncode == 0 and shutil.which("modelscope"):
-                print("modelscope 安装成功。")
-                return True
-
-            print("modelscope 安装尝试失败。")
-            if result.stdout.strip():
-                print(result.stdout[-1000:])
-            if result.stderr.strip():
-                print(result.stderr[-1000:])
-
-        except subprocess.TimeoutExpired:
-            print("modelscope 安装超时。")
+            os.remove(COMFY_PORTABLE_ZIP_PATH)
         except Exception as e:
-            print(f"modelscope 安装异常: {e}")
-
-    print("modelscope 不可用，无法继续下载 offline_build。")
-    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
-        ]
-
-    try:
-        print("执行直链下载命令: " + " ".join(command[:1]) + " ...")
-
-        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:])
-
-        if result.returncode == 0 and is_valid_zip(output_path):
-            print(f"直链下载成功: {output_path}")
-            return True
-
-        print(f"直链下载失败或压缩包无效: {output_path}")
-        return False
+            print(f"删除无效压缩包失败: {e}")
+            return False
 
-    except subprocess.TimeoutExpired:
-        print("直链下载超时。")
-        return False
-    except Exception as e:
-        print(f"直链下载异常: {e}")
+    if not shutil.which("modelscope"):
+        print("未检测到 modelscope 命令。为避免改动系统 Python 依赖，本脚本不会自动安装 modelscope。")
+        print("请先在外部环境安装好 modelscope CLI，或手动把 comfy_portable.zip 放到 /root/comfy_portable.zip。")
         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
-
-    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_whole_forgeui_repo_with_modelscope_cli():
-    if not install_modelscope_cli():
-        return None
-
     commands = [
-        (
-            [
-                "modelscope",
-                "download",
-                "--model",
-                MODELSCOPE_MODEL_ID,
-                "--local_dir",
-                MODELSCOPE_DOWNLOAD_DIR
-            ],
-            False,
-            "整库直连"
-        ),
-        (
-            [
-                "modelscope",
-                "download",
-                "--model",
-                MODELSCOPE_MODEL_ID,
-                "--local_dir",
-                MODELSCOPE_DOWNLOAD_DIR,
-                "--endpoint",
-                "https://www.modelscope.cn"
-            ],
-            False,
-            "整库直连+显式 endpoint"
-        ),
-        (
-            [
-                "modelscope",
-                "download",
-                "--model",
-                MODELSCOPE_MODEL_ID,
-                "--local_dir",
-                MODELSCOPE_DOWNLOAD_DIR
-            ],
-            True,
-            "整库代理"
-        )
+        (False, "直连"),
+        (True, "代理")
     ]
 
-    for command, use_proxy, mode_name in commands:
+    for use_proxy, mode_name in commands:
+        command = [
+            "modelscope",
+            "download",
+            "--model",
+            MODELSCOPE_MODEL_ID,
+            COMFY_PORTABLE_ZIP_NAME,
+            "--local_dir",
+            "/root"
+        ]
+
         try:
-            print(f"执行 ModelScope CLI 整库下载 [{mode_name}]: " + " ".join(command))
+            print(f"执行 ModelScope 下载 comfy_portable.zip [{mode_name}]: " + " ".join(command))
 
             result = subprocess.run(
                 command,
-                env=get_modelscope_download_env(use_proxy=use_proxy),
+                env=get_modelscope_env(use_proxy=use_proxy),
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
                 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
-
-            # 这里不再按文件名调用 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}")
-                return fallback_zip
+            if result.returncode == 0 and is_valid_zip(COMFY_PORTABLE_ZIP_PATH):
+                print(f"comfy_portable.zip 下载完成: {COMFY_PORTABLE_ZIP_PATH}")
+                return True
 
-            print("本次整库下载未找到有效 offline_build 压缩包，继续尝试下一个命令。")
+            print("本次 ModelScope 下载失败或压缩包无效，继续尝试下一个方式。")
 
         except subprocess.TimeoutExpired:
-            print("ModelScope CLI 整库下载超时，继续尝试下一个命令。")
+            print("ModelScope 下载 comfy_portable.zip 超时，继续尝试下一个方式。")
         except Exception as e:
-            print(f"ModelScope CLI 整库下载异常: {e}")
-
-    return None
-
-
-def download_offline_build_from_modelscope():
-    os.makedirs(MODELSCOPE_DOWNLOAD_DIR, exist_ok=True)
-    os.makedirs(MODELSCOPE_CACHE_DIR, exist_ok=True)
+            print(f"ModelScope 下载 comfy_portable.zip 异常: {e}")
 
-    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
-
-    print("ModelScope 整库克隆/下载失败，未找到有效 offline_build 压缩包。")
-    return None
-
-
-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
-
-    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
+    print("ModelScope 下载 comfy_portable.zip 失败。")
+    return False
 
-    return None
 
+def extract_comfy_portable():
+    if is_comfy_portable_ready():
+        print(f"comfy_portable 已存在，跳过解压: {COMFY_PORTABLE_DIR}")
+        return True
 
-def extract_offline_build(zip_path):
-    existing_dir = locate_offline_build_dir()
-    if existing_dir:
-        print(f"检测到已解压的 offline_build: {existing_dir}")
-        return existing_dir
+    if not is_valid_zip(COMFY_PORTABLE_ZIP_PATH):
+        print(f"comfy_portable.zip 不存在或无效: {COMFY_PORTABLE_ZIP_PATH}")
+        return False
 
-    if not zip_path or not is_valid_zip(zip_path):
-        print(f"offline_build 压缩包无效: {zip_path}")
-        return None
+    if os.path.exists(COMFY_PORTABLE_DIR):
+        print(f"检测到不完整的 comfy_portable 目录，正在删除后重新解压: {COMFY_PORTABLE_DIR}")
+        try:
+            shutil.rmtree(COMFY_PORTABLE_DIR)
+        except Exception as e:
+            print(f"删除不完整 comfy_portable 目录失败: {e}")
+            return False
 
     try:
-        print(f"正在解压 offline_build: {zip_path}")
+        print(f"正在解压 comfy_portable.zip 到 /root: {COMFY_PORTABLE_ZIP_PATH}")
 
-        with zipfile.ZipFile(zip_path, "r") as zf:
-            zf.extractall(REPO_PATH)
+        import zipfile
+        with zipfile.ZipFile(COMFY_PORTABLE_ZIP_PATH, "r") as zf:
+            zf.extractall("/root")
 
-        extracted_dir = locate_offline_build_dir()
-        if extracted_dir:
-            print(f"offline_build 解压完成: {extracted_dir}")
-            return extracted_dir
+        if is_comfy_portable_ready():
+            print(f"comfy_portable 解压完成: {COMFY_PORTABLE_DIR}")
+            return True
 
-        print("解压完成，但未找到 offline_build/ComfyUI/main.py。")
-        return None
+        print("解压完成，但未找到 /root/comfy_portable/python/bin/python 或 /root/comfy_portable/ComfyUI/main.py。")
+        return False
 
     except Exception as e:
-        print(f"解压 offline_build 失败: {e}")
-        return None
+        print(f"解压 comfy_portable.zip 失败: {e}")
+        return False
 
 
-def prepare_offline_build():
-    existing_dir = locate_offline_build_dir()
-    if existing_dir:
-        print(f"offline_build 已存在，跳过下载解压: {existing_dir}")
-        return existing_dir
+def prepare_comfy_portable():
+    if is_comfy_portable_ready():
+        print(f"comfy_portable 已准备完成: {COMFY_PORTABLE_DIR}")
+        return True
 
-    zip_path = download_offline_build_from_modelscope()
-    if not zip_path:
-        return None
+    if not download_comfy_portable_from_modelscope():
+        return False
 
-    return extract_offline_build(zip_path)
+    return extract_comfy_portable()
 
 
 def start_comfyui_process():
-    offline_build_dir = prepare_offline_build()
-
-    if not offline_build_dir:
-        print("offline_build 准备失败，跳过 ComfyUI 启动。")
+    if not prepare_comfy_portable():
+        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")
-
-    if not os.path.exists(venv_activate):
-        print(f"未找到虚拟环境激活脚本: {venv_activate}")
+    if not os.path.exists(COMFY_PORTABLE_PYTHON):
+        print(f"未找到便携 Python: {COMFY_PORTABLE_PYTHON}")
         return
 
-    if not os.path.exists(comfyui_main):
-        print(f"未找到 ComfyUI main.py: {comfyui_main}")
+    if not os.path.exists(COMFYUI_MAIN):
+        print(f"未找到 ComfyUI main.py: {COMFYUI_MAIN}")
         return
 
     configure_git_proxy()
 
-    command = f'''
+    python_lib_dir = os.path.join(COMFY_PORTABLE_DIR, "python", "lib")
+    comfyui_dir = os.path.join(COMFY_PORTABLE_DIR, "ComfyUI")
+
+    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,9 +612,9 @@ 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}\"
+\"{COMFY_PORTABLE_PYTHON}\" main.py --listen 0.0.0.0 --port {COMFYUI_PORT}
+"""
 
     try:
         os.makedirs(REPO_PATH, exist_ok=True)
@@ -1054,12 +622,13 @@ python main.py --listen 0.0.0.0 --port {COMFYUI_PORT}
 
         process = subprocess.Popen(
             ["bash", "-lc", command],
-            cwd=offline_build_dir,
+            cwd=COMFY_PORTABLE_DIR,
             env=get_proxy_env(),
             stdout=log_file,
             stderr=subprocess.STDOUT
         )
 
+        import time
         time.sleep(3)
 
         if process.poll() is None:
@@ -1070,6 +639,7 @@ python main.py --listen 0.0.0.0 --port {COMFYUI_PORT}
     except Exception as e:
         print(f"启动 ComfyUI 失败: {e}")
 
+
 def start_gradio():
     with gr.Blocks() as demo:
         gr.Markdown("# InternLM 控制台")