Upload 21 files

Dockerfile

@@ -34,24 +34,21 @@ RUN mkdir -p ./clash_core ./subconverter ./data && \
     chmod -R 777 ./clash_core && \
     chmod -R 777 ./subconverter
 
-# Download Clash Meta Core
-# Check https://github.com/MetaCubeX/Clash.Meta/releases for latest versions and architectures
-ARG CLASH_META_VERSION="v1.18.0" # Or specific version like v1.18.0
-ARG TARGETARCH
-
-# Determine Clash binary URL based on architecture
-RUN if [ "${TARGETARCH}" = "amd64" ]; then \
-        CLASH_URL="https://github.com/MetaCubeX/Clash.Meta/releases/download/${CLASH_META_VERSION}/clash.meta-linux-amd64-${CLASH_META_VERSION}.gz"; \
-    elif [ "${TARGETARCH}" = "arm64" ]; then \
-        CLASH_URL="https://github.com/MetaCubeX/Clash.Meta/releases/download/${CLASH_META_VERSION}/clash.meta-linux-arm64-${CLASH_META_VERSION}.gz"; \
-    else \
-        echo "Unsupported architecture: ${TARGETARCH}" && exit 1; \
-    fi && \
-    echo "Downloading Clash Meta Core from ${CLASH_URL}" && \
-    curl -sSL ${CLASH_URL} -o clash.meta.gz && \
-    gzip -d clash.meta.gz && \
-    mv clash.meta /app/clash_core/clash.meta-linux-${TARGETARCH} && \
-    chmod +x /app/clash_core/clash.meta-linux-${TARGETARCH} # Add execute permission here
+# 下载并安装Clash Meta，保留原始文件名
+RUN echo "Downloading Clash Meta..." && \
+    curl -L -f -o /tmp/clash-meta.gz "https://github.com/MetaCubeX/Clash.Meta/releases/download/v1.16.0/clash.meta-linux-amd64-v1.16.0.gz" && \
+    echo "Extracting Clash Meta..." && \
+    gunzip -c /tmp/clash-meta.gz > ./clash_core/clash.meta-linux-amd64 && \
+    echo "Setting Clash Meta permissions..." && \
+    chmod +x ./clash_core/clash.meta-linux-amd64 && \
+    # 确保Linux可执行属性已设置
+    ls -la ./clash_core/clash.meta-linux-amd64 && \
+    # 显示文件类型
+    file ./clash_core/clash.meta-linux-amd64 && \
+    echo "Verifying Clash Meta exists..." && \
+    test -f ./clash_core/clash.meta-linux-amd64 && \
+    echo "Cleaning up Clash Meta download..." && \
+    rm /tmp/clash-meta.gz
 
 # 下载并完整解压subconverter
 RUN echo "Downloading subconverter..." && \
@@ -86,12 +83,21 @@ RUN echo "Installing Python dependencies..." && \
 # 可选：删除构建依赖以减小镜像体积
 RUN apk del python3-dev musl-dev libffi-dev yaml-dev
 
-# Download Yacd UI (gh-pages branch)
-RUN echo "Downloading Yacd UI from gh-pages branch..." && \
-    curl -sSL https://github.com/MetaCubeX/Yacd-meta/archive/gh-pages.tar.gz -o yacd.tar.gz && \
-    mkdir -p /app/static/yacd && \
-    tar -xzf yacd.tar.gz --strip-components=1 -C /app/static/yacd && \
-    rm yacd.tar.gz
+# 下载并准备 Yacd UI 文件 (从 Yacd-meta 的 gh-pages 分支)
+RUN echo "Downloading Yacd-meta UI (gh-pages branch)..." && \
+    YACD_DIR=/app/app/static/yacd && \
+    mkdir -p ${YACD_DIR} && \
+    # 下载 gh-pages 分支的 zip 压缩包
+    curl -L -f -o /tmp/yacd-gh-pages.zip "https://github.com/MetaCubeX/Yacd-meta/archive/refs/heads/gh-pages.zip" && \
+    echo "Extracting Yacd-meta UI (gh-pages)..." && \
+    # 解压到临时目录
+    unzip -q /tmp/yacd-gh-pages.zip -d /tmp && \
+    # 将解压后的 gh-pages 目录下的 *所有内容* 移动到目标位置
+    # 注意：解压后的文件夹名通常是 {repo_name}-{branch_name}，即 Yacd-meta-gh-pages
+    mv /tmp/Yacd-meta-gh-pages/* ${YACD_DIR}/ && \
+    echo "Cleaning up Yacd-meta download..." && \
+    rm /tmp/yacd-gh-pages.zip && \
+    rm -rf /tmp/Yacd-meta-gh-pages
 
 # 设置环境变量
 ENV PYTHONDONTWRITEBYTECODE=1 \
@@ -111,7 +117,7 @@ COPY entrypoint.sh ./
 RUN chmod +x ./entrypoint.sh
 
 # 给脚本和二进制文件执行权限 (重复的chmod可能不需要，但在构建阶段设置更安全)
-RUN chmod +x ./clash_core/clash.meta-linux-${TARGETARCH} || true
+RUN chmod +x ./clash_core/clash.meta-linux-amd64 || true
 RUN chmod +x ./subconverter/subconverter || true
 
 # 暴露端口

app/main.py

@@ -7,13 +7,14 @@ Simple Clash Relay - Flask 应用入口
 
 import os
 import logging
-from flask import Flask, request, jsonify, Response, redirect, send_from_directory
+from flask import Flask, request, jsonify, Response, redirect, send_from_directory, flash
 from .clash_manager import ClashManager
 from .sub_manager import SubscriptionManager
 from .auth import authenticate
 import requests
 from functools import wraps
-from threading import Lock
+from werkzeug.utils import secure_filename
+import time
 
 # 配置日志
 logging.basicConfig(
@@ -22,108 +23,24 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# --- 全局变量 ---
-clash_manager = None
-sub_manager = None
-initialization_error = "尚未初始化" # 初始状态
-API_KEY = os.environ.get("API_KEY", "changeme") # 从环境变量获取API密钥，默认changeme
-SUB_URL = os.environ.get("SUB_URL") # 从环境变量获取订阅链接
+# 从环境变量加载配置
+SUB_URL = os.environ.get("SUB_URL")
+API_KEY = os.environ.get("API_KEY", "changeme")
 FLASK_PORT = int(os.environ.get("FLASK_PORT", 7860))  # 默认端口改为7860
 CLASH_PROXY_PORT = int(os.environ.get("CLASH_PROXY_PORT", 7890))
 CLASH_API_PORT = int(os.environ.get("CLASH_API_PORT", 9090))
 
-# 基础路径
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-DATA_DIR = os.path.join(BASE_DIR, "data")
-CLASH_CORE_DIR = os.path.join(BASE_DIR, "clash_core")
-CONFIG_PATH = os.path.join(DATA_DIR, "config.yaml")
-RAW_CONFIG_PATH = f"{CONFIG_PATH}.raw"
-CLASH_BINARY_PATH = os.path.join(CLASH_CORE_DIR, "clash.meta-linux-amd64") # 根据实际文件名调整
-
-# 确保目录存在
-os.makedirs(DATA_DIR, exist_ok=True)
-os.makedirs(CLASH_CORE_DIR, exist_ok=True)
-
-class InitializationManager:
-    def __init__(self):
-        self._initialized = False
-        self._lock = Lock()
-
-    def __call__(self):
-        global clash_manager, sub_manager, initialization_error
-        
-        # 使用锁确保只初始化一次
-        with self._lock:
-            if self._initialized:
-                return # 如果已经初始化，直接返回
-            
-            logger.info("正在初始化应用 (首次请求或重新初始化)...")
-            initialization_error = "正在初始化..." # 设置状态
-
-            try:
-                # 优先检查本地配置文件是否存在
-                if os.path.exists(CONFIG_PATH):
-                    logger.info(f"找到本地配置文件: {CONFIG_PATH}，优先使用此配置")
-                    try:
-                        # 验证并可能需要修补现有配置
-                        temp_sub_manager = SubscriptionManager(config_path=CONFIG_PATH)
-                        temp_sub_manager._patch_config() # 确保端口等设置正确
-                        logger.info("已检查并修补本地配置文件")
-                        
-                        # 使用本地配置启动Clash
-                        clash_manager = ClashManager(
-                            config_path=CONFIG_PATH,
-                            clash_path=CLASH_BINARY_PATH,
-                            api_port=CLASH_API_PORT,
-                            proxy_port=CLASH_PROXY_PORT
-                        )
-                        clash_manager.start_clash()
-                        initialization_error = None # 初始化成功
-                        self._initialized = True
-                        logger.info("使用本地配置成功初始化并启动Clash")
-                        return # 初始化成功，退出
-                    except Exception as e:
-                        error_msg = f"使用本地配置文件启动Clash失败: {str(e)}"
-                        logger.error(error_msg)
-                        initialization_error = error_msg
-                        # 不要在这里返回，继续尝试下载订阅（如果提供了URL）
-
-                # 如果本地配置不存在或启动失败，并且提供了订阅URL，则尝试下载
-                if SUB_URL:
-                    logger.info("未找到本地配置或启动失败，尝试从订阅URL加载...")
-                    sub_manager = SubscriptionManager(sub_url=SUB_URL, config_path=CONFIG_PATH)
-                    sub_manager.load_and_convert_sub() # 下载并转换
-                    
-                    clash_manager = ClashManager(
-                        config_path=CONFIG_PATH,
-                        clash_path=CLASH_BINARY_PATH,
-                        api_port=CLASH_API_PORT,
-                        proxy_port=CLASH_PROXY_PORT
-                    )
-                    clash_manager.start_clash()
-                    initialization_error = None # 初始化成功
-                    logger.info("成功从订阅URL初始化并启动Clash")
-                
-                # 如果没有本地配置，也没有提供订阅URL
-                elif not os.path.exists(CONFIG_PATH):
-                    error_msg = "初始化失败：未找到本地 config.yaml 且未设置 SUB_URL 环境变量"
-                    logger.error(error_msg)
-                    initialization_error = error_msg
-                
-                # 如果走到这里，表示初始化完成（可能成功也可能失败）
-                self._initialized = True
-
-            except Exception as e:
-                error_msg = f"应用初始化过程中发生严重错误: {str(e)}"
-                logger.exception(error_msg) # 使用exception记录堆栈信息
-                initialization_error = error_msg
-                # 即使失败，也标记为已尝试初始化，避免无限重试
-                self._initialized = True
-
-initialize_once = InitializationManager()
+# 添加标记文件路径
+MANUAL_CONFIG_MARKER = os.path.join(os.path.dirname(__file__), "data", ".use_manual_config")
 
 # 初始化Flask应用
 app = Flask(__name__, static_folder='static')
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "supersecretkey") # 用于flash消息
+
+# 初始化管理器
+clash_manager = None
+sub_manager = None
+initialization_error = None
 
 @app.before_request
 def initialize_once():
@@ -235,9 +152,14 @@ def get_current_node():
 @app.route("/api/refresh", methods=["POST"])
 @authenticate
 def refresh_subscription():
-    """刷新订阅并重新加载Clash配置"""
+    """刷新订阅并重新加载Clash配置（如果未使用手动配置）"""
     global clash_manager, sub_manager, initialization_error
     
+    # 检查是否正在使用手动配置
+    if os.path.exists(MANUAL_CONFIG_MARKER):
+        logger.info("正在使用手动配置文件，跳过订阅刷新。")
+        return jsonify({"success": True, "message": "当前使用手动配置文件，无需刷新订阅。"})
+    
     try:
         # 尝试重新加载订阅
         if sub_manager is None:
@@ -268,84 +190,6 @@ def refresh_subscription():
         initialization_error = error_msg
         return jsonify({"success": False, "error": error_msg}), 500
 
-@app.route("/api/upload_config", methods=["POST"])
-@authenticate
-def upload_config():
-    """上传并使用自定义配置文件"""
-    global clash_manager, initialization_error
-    
-    if 'config_file' not in request.files:
-        return jsonify({"success": False, "error": "未找到配置文件"}), 400
-        
-    file = request.files['config_file']
-    if file.filename == '':
-        return jsonify({"success": False, "error": "未选择文件"}), 400
-    
-    if not file.filename.endswith(('.yaml', '.yml')):
-        return jsonify({"success": False, "error": "文件必须是YAML格式"}), 400
-        
-    # 配置文件路径
-    config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "config.yaml")
-    raw_config_path = f"{config_path}.raw"
-    
-    try:
-        # 保存上传的文件作为原始配置
-        file.save(raw_config_path)
-        logger.info(f"配置文件已上传到: {raw_config_path}")
-        
-        # 创建一个临时的SubscriptionManager来处理配置
-        temp_sub_manager = SubscriptionManager(
-            sub_url=None, # 不需要URL
-            config_path=config_path
-        )
-        
-        # 转换并修补配置
-        try:
-            # 将原始配置处理为Clash配置
-            temp_sub_manager._convert_raw_to_config()
-            logger.info("成功处理上传的配置文件")
-        except Exception as e:
-            logger.error(f"处理配置文件时出错: {str(e)}")
-            return jsonify({"success": False, "error": f"配置文件处理失败: {str(e)}"}), 500
-        
-        # 重启Clash
-        if clash_manager is not None:
-            try:
-                clash_manager.restart_clash()
-                logger.info("已重启Clash以应用新配置")
-                return jsonify({
-                    "success": True, 
-                    "message": "配置文件已上传并应用，Clash已重启"
-                })
-            except Exception as e:
-                error_msg = f"重启Clash失败: {str(e)}"
-                logger.error(error_msg)
-                initialization_error = error_msg
-                return jsonify({"success": False, "error": error_msg}), 500
-        else:
-            # 如果Clash未运行，尝试启动它
-            try:
-                clash_manager = ClashManager(
-                    config_path=config_path,
-                    clash_path=os.path.join(os.path.dirname(os.path.dirname(__file__)), "clash_core", "clash.meta-linux-amd64"),
-                    api_port=CLASH_API_PORT,
-                    proxy_port=CLASH_PROXY_PORT
-                )
-                clash_manager.start_clash()
-                initialization_error = None
-                return jsonify({
-                    "success": True, 
-                    "message": "配置文件已上传并应用，Clash已启动"
-                })
-            except Exception as e:
-                error_msg = f"启动Clash失败: {str(e)}"
-                logger.error(error_msg)
-                initialization_error = error_msg
-                return jsonify({"success": False, "error": error_msg}), 500
-    except Exception as e:
-        logger.error(f"上传配置文件时发生错误: {str(e)}")
-        return jsonify({"success": False, "error": f"上传失败: {str(e)}"}), 500
-
 @app.route("/health", methods=["GET"])
 def health_check():
     """健康检查接口"""
@@ -361,18 +205,22 @@ def health_check():
 @app.route("/debug/clean", methods=["POST"])
 @authenticate
 def debug_clean():
-    """清理并重新初始化配置"""
+    """清理配置、标记文件并重新初始化(恢复使用订阅)"""
     global clash_manager, sub_manager, initialization_error
     
     try:
+        # 停止Clash
         if clash_manager is not None:
             clash_manager.stop_clash()
             clash_manager = None
         
-        config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "config.yaml")
+        # 删除配置文件和标记文件
+        config_dir = os.path.join(os.path.dirname(__file__), "data")
+        config_path = os.path.join(config_dir, "config.yaml")
         raw_config_path = f"{config_path}.raw"
+        marker_path = MANUAL_CONFIG_MARKER
         
-        files_to_delete = [config_path, raw_config_path]
+        files_to_delete = [config_path, raw_config_path, marker_path]
         deleted_files = []
         
         for file_path in files_to_delete:
@@ -380,18 +228,19 @@ def debug_clean():
                 try:
                     os.remove(file_path)
                     deleted_files.append(os.path.basename(file_path))
+                    logger.info(f"已删除文件: {file_path}")
                 except OSError as e:
                     logger.warning(f"删除文件失败: {file_path}, 错误: {e}")
         
-        # 重新初始化并启动
-        initialize_once._initialized = False # 强制下次请求时重新初始化
+        # 强制重新初始化 (将恢复使用订阅，因为标记文件已删除)
+        initialize_once._initialized = False
         initialize_once()
         
-        status_msg = "已清理并重新初始化" if initialization_error is None else f"已清理但初始化失败: {initialization_error}"
+        status_msg = "配置已清理，恢复使用订阅链接。" if initialization_error is None else f"配置已清理，但重新初始化失败: {initialization_error}"
         return jsonify({"success": True, "message": status_msg, "deleted_files": deleted_files})
     
     except Exception as e:
-        logger.error(f"清理配置时出错: {str(e)}")
+        logger.exception(f"清理配置时出错: {str(e)}")
         return jsonify({"success": False, "error": str(e)}), 500
 
 @app.route("/debug/config", methods=["GET"])
@@ -517,17 +366,88 @@ def clash_api_proxy(subpath):
         logger.error(f"代理Clash API请求时发生意外错误: {str(e)}")
         return jsonify({"error": f"代理请求时发生意外错误: {str(e)}"}), 500
 
+# --- 新增：上传配置 API --- 
+@app.route("/api/upload_config", methods=["POST"])
+@authenticate
+def upload_config():
+    """上传并使用自定义配置文件"""
+    global clash_manager, initialization_error
+    
+    if 'config_file' not in request.files:
+        logger.error("上传配置请求中未找到名为 'config_file' 的文件")
+        return jsonify({"success": False, "error": "未找到配置文件部分"}), 400
+        
+    file = request.files['config_file']
+    if file.filename == '' or not file:
+        logger.error("上传的文件无效或未选择")
+        return jsonify({"success": False, "error": "未选择文件或文件无效"}), 400
+    
+    # 限制文件名，防止路径遍历
+    filename = secure_filename(file.filename)
+    if not filename.lower().endswith(('.yaml', '.yml')):
+        logger.error(f"上传的文件类型不支持: {filename}")
+        return jsonify({"success": False, "error": "只允许上传 .yaml 或 .yml 文件"}), 400
+        
+    config_dir = os.path.join(os.path.dirname(__file__), "data")
+    config_path = os.path.join(config_dir, "config.yaml")
+    marker_path = MANUAL_CONFIG_MARKER
+    
+    try:
+        # 确保数据目录存在
+        os.makedirs(config_dir, exist_ok=True)
+        
+        # 保存上传的文件，覆盖旧的 config.yaml
+        file.save(config_path)
+        logger.info(f"成功保存上传的配置文件到: {config_path}")
+        
+        # 创建标记文件，表示正在使用手动配置
+        with open(marker_path, 'w') as f:
+            f.write(f"Uploaded at {time.time()}")
+        logger.info(f"已创建手动配置标记文件: {marker_path}")
+        
+        # 重启Clash以加载新配置
+        if clash_manager is not None:
+            logger.info("正在重启Clash以加载手动配置...")
+            clash_manager.restart_clash(config_path=config_path) # 明确指定新配置路径
+            initialization_error = None # 清除之前的初始化错误
+            logger.info("Clash已使用手动配置重启")
+        else:
+            # 如果Clash未运行，��试初始化并启动
+            logger.info("Clash未运行，尝试使用手动配置进行初始化和启动...")
+            initialize_once._initialized = False
+            initialize_once()
+            if initialization_error:
+                 logger.error(f"使用手动配置启动Clash失败: {initialization_error}")
+                 # 即使启动失败，也保留手动配置和标记
+            else:
+                 logger.info("Clash已使用手动配置成功启动")
+            
+        return jsonify({"success": True, "message": "配置文件已上传并应用，Clash已重启。"})
+    
+    except Exception as e:
+        logger.exception(f"处理上传的配置文件时出错: {str(e)}")
+        # 清理可能不完整的状态
+        if os.path.exists(marker_path):
+            os.remove(marker_path)
+        return jsonify({"success": False, "error": f"处理上传文件时出错: {str(e)}"}), 500
+
 # --- 基础路由 --- 
 
 @app.route('/', methods=['GET'])
 def index():
-    """首页 - 提供简单说明和调试链接"""
+    """首页 - 提供说明、状态和操作"""
     global initialization_error
     
+    using_manual_config = os.path.exists(MANUAL_CONFIG_MARKER)
+    
     status = "运行中" if initialization_error is None else "初始化失败"
     error_msg = "" if initialization_error is None else f"<p style='color:red'>错误: {initialization_error}</p>"
+    config_mode_msg = "<p class='note'>当前模式：<b>手动配置文件</b></p>" if using_manual_config else "<p class='note'>当前模式：<b>订阅链接</b></p>"
+    
+    # 刷新按钮状态
+    refresh_button_disabled = "disabled" if using_manual_config else ""
+    refresh_button_title = "title='当前使用手动配置，无需刷新订阅'" if using_manual_config else ""
     
-    # 检查Yacd UI是否可用
     yacd_link = "<a href='/ui/' class='button'>访问高级控制面板 (Yacd)</a>"
     
     return f"""
@@ -567,22 +487,17 @@ def index():
                     color: #8a6d3b;
                     font-size: 14px;
                 }}
-                .upload-section {{
-                    margin-top: 20px;
-                    padding: 15px;
-                    border: 1px solid #ddd;
-                    border-radius: 4px;
-                    background-color: #f8f9fa;
-                }}
-                .upload-form {{
-                    margin-top: 10px;
-                }}
                 pre {{ max-height: 300px; overflow: auto; background-color: #eee; padding: 10px; border-radius: 4px; }}
+                .note b {{ font-weight: bold; color: #555; }}
+                .upload-section {{ margin-top: 20px; padding: 15px; border: 1px dashed #46b8da; background-color: #d9edf7; }}
+                .upload-section label {{ display: block; margin-bottom: 5px; font-weight: bold; }}
+                .upload-section input[type='file'] {{ margin-bottom: 10px; }}
             </style>
             <script>
+                // 请求API (带密钥)
                 function requestWithApiKey(url, method = 'POST') {{
                     const apiKey = prompt('请输入API密钥 (默认为 changeme)', 'changeme');
-                    if (apiKey === null) return; // 用户取消
+                    if (apiKey === null) return;
 
                     fetch(url, {{
                         method: method,
@@ -590,12 +505,13 @@ def index():
                     }})
                     .then(response => response.json())
                     .then(data => {{
-                        alert(data.success ? data.message : '失败: ' + data.error);
+                        alert(data.success ? data.message : ('失败: ' + (data.error || '未知错误')));
                         if(data.success) location.reload();
                     }})
                     .catch(error => alert('请求失败: ' + error));
                 }}
                 
+                // 查看配置
                 function viewConfig() {{
                     const apiKey = prompt('请输入API密钥 (默认为 changeme)', 'changeme');
                     if (apiKey === null) return;
@@ -624,30 +540,31 @@ def index():
                     }});
                 }}
                 
+                // 上传配置
                 function uploadConfig() {{
-                    const fileInput = document.getElementById('config-file');
-                    if (!fileInput.files || fileInput.files.length === 0) {{
-                        alert('请先选择配置文件');
-                        return;
-                    }}
-                    
                     const apiKey = prompt('请输入API密钥 (默认为 changeme)', 'changeme');
                     if (apiKey === null) return;
                     
+                    const fileInput = document.getElementById('configFileInput');
                     const file = fileInput.files[0];
-                    if (!file.name.endsWith('.yaml') && !file.name.endsWith('.yml')) {{
-                        alert('请选择YAML格式的配置文件 (.yaml 或 .yml)');
+                    
+                    if (!file) {{
+                        alert('请先选择一个 .yaml 或 .yml 文件。');
+                        return;
+                    }}
+                    
+                    if (!file.name.toLowerCase().endsWith('.yaml') && !file.name.toLowerCase().endsWith('.yml')) {{
+                        alert('只允许上传 .yaml 或 .yml 文件。');
                         return;
                     }}
                     
                     const formData = new FormData();
                     formData.append('config_file', file);
                     
-                    // 显示上传中状态
-                    const uploadStatus = document.getElementById('upload-status');
-                    uploadStatus.textContent = '上传中...';
-                    uploadStatus.style.color = 'blue';
-                    
+                    const uploadButton = document.getElementById('uploadButton');
+                    uploadButton.disabled = true;
+                    uploadButton.textContent = '上传中...';
+
                     fetch('/api/upload_config', {{
                         method: 'POST',
                         headers: {{ 'X-API-Key': apiKey }},
@@ -655,21 +572,15 @@ def index():
                     }})
                     .then(response => response.json())
                     .then(data => {{
-                        if (data.success) {{
-                            uploadStatus.textContent = '✅ ' + data.message;
-                            uploadStatus.style.color = 'green';
-                            // 清除文件选择
-                            fileInput.value = '';
-                            // 3秒后刷新页面
-                            setTimeout(() => location.reload(), 3000);
-                        }} else {{
-                            uploadStatus.textContent = '❌ 失败: ' + data.error;
-                            uploadStatus.style.color = 'red';
-                        }}
+                        alert(data.success ? data.message : ('上传失败: ' + (data.error || '未知错误')));
+                        if(data.success) location.reload();
                     }})
                     .catch(error => {{
-                        uploadStatus.textContent = '❌ 请求失败: ' + error;
-                        uploadStatus.style.color = 'red';
+                        alert('上传请求失败: ' + error);
+                    }})
+                    .finally(() => {{
+                        uploadButton.disabled = false;
+                        uploadButton.textContent = '上传并应用配置';
                     }});
                 }}
             </script>
@@ -679,6 +590,7 @@ def index():
                 <h1>Simple Clash Relay</h1>
                 <p>状态: <span class='status {"running" if initialization_error is None else "error"}'>{status}</span></p>
                 {error_msg}
+                {config_mode_msg}
                 
                 <h2>控制面板</h2>
                 {yacd_link}
@@ -702,25 +614,21 @@ def index():
                 </div>
                 
                 <h2>基本操作</h2>
-                <button class="button warning" onclick="requestWithApiKey('/api/refresh')">刷新订阅并重启Clash</button>
+                <button class="button warning" onclick="requestWithApiKey('/api/refresh')" {refresh_button_disabled} {refresh_button_title}>刷新订阅并重启Clash</button>
                 
                 <div class="upload-section">
-                    <h3>上传自定义配置</h3>
-                    <div class="upload-form">
-                        <input type="file" id="config-file" accept=".yaml,.yml" style="margin-bottom: 10px; display: block;" />
-                        <button class="button" onclick="uploadConfig()">上传并应用配置</button>
-                        <div id="upload-status" style="margin-top: 10px;"></div>
-                    </div>
-                    <div class="note">
-                        <p>上传的配置文件将替代订阅生成的配置。适合有自定义需求的用户。</p>
-                        <p>推荐使用完整的Clash配置，包含必要的端口和API设置。</p>
-                    </div>
+                    <h3>上传手动配置</h3>
+                    <p>您可以上传自己的 <code>config.yaml</code> 文件来覆盖订阅链接。上传后，系统将只使用此文件，不再进行订阅更新。</p>
+                    <label for="configFileInput">选择配置文件 (.yaml 或 .yml):</label>
+                    <input type="file" id="configFileInput" name="config_file" accept=".yaml,.yml">
+                    <button class="button" id="uploadButton" onclick="uploadConfig()">上传并应用配置</button>
+                    <p><small>要恢复使用订阅链接，请使用下面的"清理配置并重启"按钮。</small></p>
                 </div>
                 
                 <div class="debug-section">
-                    <h3>调试选项</h3>
+                    <h3>调试与恢复</h3>
                     <button class="button" onclick="viewConfig()">查看当前配置文件</button>
-                    <button class="button danger" onclick="if(confirm('确定要清理配置并重启服务吗？此操作不可逆！')) requestWithApiKey('/debug/clean')">清理配置并重启</button>
+                    <button class="button danger" onclick="if(confirm('确定要清理配置并重启服务吗？此操作将删除手动配置（如果存在）并恢复使用订阅链接！')) requestWithApiKey('/debug/clean')">清理配置并重启 (恢复订阅)</button>
                     <div id="config-content" style="margin-top: 15px;"></div>
                 </div>
                 

app/sub_manager.py

@@ -15,172 +15,274 @@ from urllib.parse import urlparse
 logger = logging.getLogger(__name__)
 
 class SubscriptionManager:
-    """管理订阅下载、转换和配置生成"""
+    """管理订阅链接的下载和配置转换"""
     
-    def __init__(self, sub_url: str = None, config_path: str = None):
+    MANUAL_CONFIG_MARKER = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", ".use_manual_config")
+
+    def __init__(self, sub_url, config_path):
         """
         初始化订阅管理器
         
         Args:
             sub_url: 订阅链接URL
-            config_path: 配置文件输出路径
+            config_path: 生成的Clash配置文件保存路径
         """
         self.sub_url = sub_url
-        self.config_path = config_path
-        
-        # 如果未指定配置路径，使用默认路径
-        if not self.config_path:
-            self.config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "config.yaml")
-        
+        self.config_path = os.path.abspath(config_path)
+        self.raw_config_path = f"{self.config_path}.raw"
         self.subconverter_path = os.path.join(
             os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
             "subconverter", "subconverter"
         )
         
+        # 检查是否设置了订阅链接
+        if not sub_url:
+            raise ValueError("未设置订阅链接 (SUB_URL)")
+        
         # 确保配置目录存在
         os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
         
-        # 只在需要订阅链接但未提供时发出警告
-        if not sub_url:
-            logger.warning("未设置订阅链接，将尝试处理已有的配置文件")
-        
         # 检查subconverter可执行文件是否存在
         if not os.path.exists(self.subconverter_path):
-            logger.warning(f"subconverter可执行文件未找到: {self.subconverter_path}，将使用基本转换方法")
+            raise FileNotFoundError(f"subconverter可执行文件未找到: {self.subconverter_path}")
     
     def load_and_convert_sub(self):
+        """下载订阅并转换为Clash配置，或使用现有配置"""
+        # 检查是否使用了手动上传的配置
+        if os.path.exists(self.MANUAL_CONFIG_MARKER):
+            logger.info("检测到手动配置文件标记，跳过订阅下载和转换。")
+            if not os.path.exists(self.config_path):
+                logger.warning("手动配置模式，但配置文件 config.yaml 不存在！")
+                raise FileNotFoundError("手动配置模式，但配置文件 config.yaml 不存在！")
+            # 确保手动配置也被修补 (如果需要)
+            self._patch_config()
+            return
+
+        # 如果没有设置订阅URL，且配置文件已存在，则直接使用
+        if not self.sub_url:
+            if os.path.exists(self.config_path):
+                logger.info("未设置订阅URL，使用现有的配置文件")
+                self._patch_config()
+                return
+            else:
+                logger.error("未设置订阅URL，且配置文件不存在！")
+                raise ValueError("必须提供订阅URL或已存在的配置文件")
+
+        # 下载订阅
+        try:
+            logger.info(f"正在下载订阅: {self._mask_url(self.sub_url)}")
+            content = self._download_subscription()
+            # 将原始订阅内容保存到 .raw 文件
+            with open(self.raw_config_path, "wb") as f:
+                f.write(content)
+            logger.info(f"成功下载订阅，大小: {len(content)} 字节")
+        except Exception as e:
+            logger.error(f"下载订阅失败: {str(e)}")
+            # 如果下载失败，但旧配置文件存在，则继续使用旧的
+            if os.path.exists(self.config_path):
+                logger.warning("下载失败，继续使用旧的配置文件")
+                self._patch_config()
+                return
+            else:
+                raise RuntimeError(f"下载订阅失败: {str(e)}")
+        
+        # 转换配置
+        try:
+            logger.info("正在将订阅转换为Clash配置")
+            self._convert_to_clash(self.raw_config_path)
+        except Exception as e:
+            logger.error(f"转换配置失败: {str(e)}")
+            # 如果转换失败，但旧配置文件存在，尝试使用旧的
+            if os.path.exists(self.config_path):
+                logger.warning("转换失败，尝试使用旧的配置文件")
+            # 如果转换失败，且没有旧配置，尝试直接使用原始下载内容
+            elif os.path.exists(self.raw_config_path):
+                logger.warning("转换失败，尝试直接使用原始订阅内容作为配置文件")
+                try:
+                    with open(self.raw_config_path, "r", encoding="utf-8") as infile, \
+                         open(self.config_path, "w", encoding="utf-8") as outfile:
+                        outfile.write(infile.read())
+                    logger.info("已将原始订阅内容复制为配置文件")
+                except Exception as copy_err:
+                    logger.error(f"复制原始订阅内容失败: {copy_err}")
+                    raise RuntimeError(f"转换配置失败，且无法使用原始订阅: {str(e)}")
+            else:
+                 raise RuntimeError(f"转换配置失败: {str(e)}")
+
+        # 修补配置文件（添加端口、API等）
+        self._patch_config()
+        
+        return self.config_path
+    
+    def _download_subscription(self):
         """
-        下载订阅内容并转换为Clash配置
+        下载订阅内容
         
+        Returns:
+            str: 订阅内容文本
+            
         Raises:
-            RuntimeError: 下载或转换失败时抛出
+            RuntimeError: 如果下载失败
         """
-        if not self.sub_url:
-            logger.warning("未提供订阅URL，跳过下载步骤")
-            # 尝试处理已有的raw文件
-            self._convert_raw_to_config()
-            return
-            
-        # 下载订阅内容
-        raw_config_path = f"{self.config_path}.raw"
         try:
-            # 安全打印URL（隐藏敏感信息）
-            masked_url = self._mask_url(self.sub_url)
-            logger.info(f"正在下载订阅: {masked_url}")
-            
-            response = requests.get(self.sub_url, timeout=30)
-            response.raise_for_status()  # 抛出HTTP错误
+            headers = {
+                "User-Agent": "ClashforWindows/0.19.0",
+                "Accept": "*/*",
+            }
+            response = requests.get(self.sub_url, headers=headers, timeout=30)
+            response.raise_for_status()
+            content = response.text
             
-            content = response.content
-            
-            # 将原始内容保存为raw文件以备转换
-            with open(raw_config_path, "wb") as f:
-                f.write(content)
+            if not content or len(content) < 10:
+                raise RuntimeError("下载的订阅内容为空或过短")
             
             logger.info(f"成功下载订阅，大小: {len(content)} 字节")
-            
-        except requests.RequestException as e:
-            error_msg = f"下载订阅失败: {str(e)}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
-        
-        # 转换为Clash配置
-        self._convert_raw_to_config()
+            return content
         
-    def _convert_raw_to_config(self):
+        except requests.RequestException as e:
+            logger.error(f"下载订阅失败: {str(e)}")
+            raise RuntimeError(f"下载订阅失败: {str(e)}")
+    
+    def _convert_to_clash(self, input_file):
         """
-        将原始订阅内容转换为Clash配置
+        使用subconverter将订阅内容转换为Clash配置
         
+        Args:
+            input_file: 包含订阅内容的文件路径
+            
         Raises:
-            RuntimeError: 转换失败时抛出
+            RuntimeError: 如果转换失败
         """
-        raw_config_path = f"{self.config_path}.raw"
+        logger.info(f"正在将订阅转换为Clash配置")
+        logger.info(f"输入文件: {input_file}, 配置路径: {self.config_path}")
         
-        # 确保原始配置文件存在
-        if not os.path.exists(raw_config_path):
-            error_msg = f"原始配置文件不存在: {raw_config_path}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
+        # 确保数据目录存在
+        data_dir = os.path.dirname(self.config_path)
+        if not os.path.exists(data_dir):
+            logger.info(f"创建数据目录: {data_dir}")
+            try:
+                os.makedirs(data_dir, exist_ok=True)
+            except Exception as e:
+                logger.error(f"创建数据目录失败: {str(e)}")
         
+        # 尝试直接读取订阅内容，确认它是否已经是Clash配置
         try:
-            logger.info("正在将订阅转换为Clash配置")
-            logger.info(f"输入文件: {raw_config_path}, 配置路径: {self.config_path}")
-            
-            # 先检查原始文件是否已经是Clash格式
-            with open(raw_config_path, "r", encoding="utf-8", errors="ignore") as f:
+            with open(input_file, "r", encoding="utf-8") as f:
                 content = f.read()
-                
-                # 简单检查是否已经是Clash配置文件
-                if "proxies:" in content and ("rules:" in content or "proxy-groups:" in content):
-                    logger.info("检测到输入文件已是Clash配置格式，直接使用")
-                    
-                    # 写入到目标配置文件
-                    with open(self.config_path, "w", encoding="utf-8") as f:
-                        f.write(content)
-                    
-                    # 修补配置文件
-                    self._patch_config()
-                    return
             
-            # 如果不是Clash格式，尝试转换
-            # 使用标准Base64解码尝试
-            try:
-                # 先尝试读取为文本内容(解决某些订阅直接返回明文)
-                with open(raw_config_path, "r", encoding="utf-8", errors="ignore") as f:
-                    content = f.read().strip()
-                
-                # 如果看起来是Base64编码
-                if content.startswith("dm1l") or content.startswith("c3M6"):
-                    # 尝试解码
-                    try:
-                        import base64
-                        decoded_content = base64.b64decode(content).decode("utf-8")
-                        logger.info("成功解码Base64订阅内容")
-                        
-                        # 写入解码后的内容
-                        with open(self.config_path, "w", encoding="utf-8") as f:
-                            # 添加基本的Clash配置头
-                            f.write(self._add_clash_headers())
-                            f.write("\nproxies:\n")
-                            
-                            # 处理每一行（每行应该是一个代理配置）
-                            for line in decoded_content.splitlines():
-                                if line.strip():
-                                    f.write(f"  - {line}\n")
-                        
-                        logger.info("已生成Clash配置")
-                        
-                        # 修补配置文件
-                        self._patch_config()
-                        return
-                    except Exception as e:
-                        logger.error(f"Base64解码或处理失败: {str(e)}")
-                        # 继续尝试其他方法
-            except Exception as e:
-                logger.error(f"读取订阅内容失败: {str(e)}")
-                
-            # 如果上述方法都失败，可能是其他格式，直接尝试作为配置使用
+            # 简单检查是否已经是Clash配置
+            if "proxies:" in content and ("port:" in content or "mixed-port:" in content):
+                logger.info("检测到输入文件已是Clash配置格式，直接使用")
+                with open(self.config_path, "w", encoding="utf-8") as f:
+                    f.write(content)
+                return
+        except Exception as e:
+            logger.warning(f"读取输入文件时出错: {str(e)}，将尝试转换")
+        
+        # 准备subconverter命令
+        cmd = [
+            self.subconverter_path,
+            "-g",  # 生成配置文件
+            "--target", "clash",  # 输出格式为Clash (修正为 --target)
+            "--url", input_file,  # 修正为 --url 参数
+            "--output", self.config_path,  # 输出文件
+            "--include-remarks", ".*"  # 包含所有节点
+        ]
+        
+        logger.info(f"执行命令: {' '.join(cmd)}")
+        
+        # 如果subconverter不存在或执行出错，我们就尝试直接使用订阅内容
+        if not os.path.exists(self.subconverter_path):
+            logger.warning("subconverter不存在，尝试直接使用订阅内容")
             try:
-                with open(raw_config_path, "r", encoding="utf-8", errors="ignore") as f:
+                with open(input_file, "r", encoding="utf-8") as f:
                     content = f.read()
-                
                 with open(self.config_path, "w", encoding="utf-8") as f:
                     f.write(content)
-                logger.warning("尝试直接使用订阅内容作为配置文件")
+                logger.info(f"已将订阅内容直接写入到: {self.config_path}")
                 # 验证文件是否成功写入
                 if os.path.exists(self.config_path):
                     logger.info(f"文件已成功写入，大小: {os.path.getsize(self.config_path)} 字节")
                 else:
                     logger.error(f"文件写入失败，{self.config_path} 不存在")
             except Exception as e:
-                logger.error(f"使用订阅内容作为配置文件时出错: {str(e)}")
+                logger.error(f"直接使用订阅内容时出错: {str(e)}")
                 raise RuntimeError(f"写入配置文件失败: {str(e)}")
-                
-            # 修补配置文件
-            self._patch_config()
+            return
         
-        except Exception as e:
-            logger.error(f"转换配置时出错: {str(e)}")
+        try:
+            # 执行subconverter
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True
+            )
+            stdout, stderr = process.communicate(timeout=30)
+            
+            logger.info(f"subconverter输出: {stdout[:200]}...") # 限制日志长度
+            
+            if process.returncode != 0:
+                logger.error(f"subconverter执��失败: {stderr}")
+                # 错误处理：尝试直接使用订阅内容
+                try:
+                    with open(input_file, "r", encoding="utf-8") as f:
+                        content = f.read()
+                    
+                    # 确保它是有效的配置，如果是普通订阅格式，添加基本的Clash头
+                    if "proxies:" not in content:
+                        content = self._add_clash_headers() + content
+                    
+                    with open(self.config_path, "w", encoding="utf-8") as f:
+                        f.write(content)
+                    logger.warning("尝试直接使用订阅内容作为配置文件")
+                    # 验证文件是否成功写入
+                    if os.path.exists(self.config_path):
+                        logger.info(f"文件已成功写入，大小: {os.path.getsize(self.config_path)} 字节")
+                    else:
+                        logger.error(f"文件写入失败，{self.config_path} 不存在")
+                except Exception as e:
+                    logger.error(f"使用订阅内容作为配置文件时出错: {str(e)}")
+                    raise RuntimeError(f"写入配置文件失败: {str(e)}")
+            else:
+                logger.info("成功转换配置")
+                # 验证输出文件是否存在
+                if os.path.exists(self.config_path):
+                    logger.info(f"配置文件已生成，路径: {self.config_path}，大小: {os.path.getsize(self.config_path)} 字节")
+                else:
+                    # 如果文件不存在但subconverter返回成功，尝试查找配置文件
+                    logger.warning(f"subconverter声称成功但配置文件不存在: {self.config_path}")
+                    # 查找当前目录下可能生成的配置文件
+                    possible_files = [f for f in os.listdir('.') if f.endswith('.yaml') or f.endswith('.yml')]
+                    if possible_files:
+                        logger.info(f"找到可能的配置文件: {possible_files}")
+                        # 尝试复制找到的第一个文件
+                        try:
+                            import shutil
+                            shutil.copy(possible_files[0], self.config_path)
+                            logger.info(f"已复制 {possible_files[0]} 到 {self.config_path}")
+                        except Exception as e:
+                            logger.error(f"复制文件失败: {str(e)}")
+                    else:
+                        logger.error("未找到任何可能的配置文件")
+                        # 尝试使用原始订阅内容作为配置
+                        try:
+                            with open(input_file, "r", encoding="utf-8") as f:
+                                content = f.read()
+                            
+                            # 确保它是有效的配置，如果是普通订阅格式，添加基本的Clash头
+                            if "proxies:" not in content:
+                                content = self._add_clash_headers() + content
+                                
+                            with open(self.config_path, "w", encoding="utf-8") as f:
+                                f.write(content)
+                            logger.warning("使用订阅内容作为配置文件")
+                        except Exception as e:
+                            logger.error(f"使用订阅内容时出错: {str(e)}")
+                            raise RuntimeError(f"写入配置文件失败: {str(e)}")
+        
+        except (subprocess.SubprocessError, OSError) as e:
+            logger.error(f"执行subconverter时出错: {str(e)}")
             raise RuntimeError(f"配置转换失败: {str(e)}")
     
     def _add_clash_headers(self):