Upload 20 files

app/main.py

@@ -179,6 +179,84 @@ 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():
     """健康检查接口"""
@@ -400,6 +478,16 @@ 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; }}
             </style>
             <script>
@@ -446,6 +534,55 @@ def index():
                         configDiv.innerHTML = '<p style="color:red">请求失败: ' + error + '</p>';
                     }});
                 }}
+                
+                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 file = fileInput.files[0];
+                    if (!file.name.endsWith('.yaml') && !file.name.endsWith('.yml')) {{
+                        alert('请选择YAML格式的配置文件 (.yaml 或 .yml)');
+                        return;
+                    }}
+                    
+                    const formData = new FormData();
+                    formData.append('config_file', file);
+                    
+                    // 显示上传中状态
+                    const uploadStatus = document.getElementById('upload-status');
+                    uploadStatus.textContent = '上传中...';
+                    uploadStatus.style.color = 'blue';
+                    
+                    fetch('/api/upload_config', {{
+                        method: 'POST',
+                        headers: {{ 'X-API-Key': apiKey }},
+                        body: formData
+                    }})
+                    .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';
+                        }}
+                    }})
+                    .catch(error => {{
+                        uploadStatus.textContent = '❌ 请求失败: ' + error;
+                        uploadStatus.style.color = 'red';
+                    }});
+                }}
             </script>
         </head>
         <body>
@@ -478,6 +615,19 @@ def index():
                 <h2>基本操作</h2>
                 <button class="button warning" onclick="requestWithApiKey('/api/refresh')">刷新订阅并重启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>
+                </div>
+                
                 <div class="debug-section">
                     <h3>调试选项</h3>
                     <button class="button" onclick="viewConfig()">查看当前配置文件</button>

app/sub_manager.py

@@ -15,18 +15,23 @@ from urllib.parse import urlparse
 logger = logging.getLogger(__name__)
 
 class SubscriptionManager:
-    """管理订阅链接的下载和配置转换"""
+    """管理订阅下载、转换和配置生成"""
     
-    def __init__(self, sub_url, config_path):
+    def __init__(self, sub_url: str = None, config_path: str = None):
         """
         初始化订阅管理器
         
         Args:
             sub_url: 订阅链接URL
-            config_path: 生成的Clash配置文件保存路径
+            config_path: 配置文件输出路径
         """
         self.sub_url = sub_url
-        self.config_path = os.path.abspath(config_path)
+        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.subconverter_path = os.path.join(
             os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
             "subconverter", "subconverter"
@@ -47,205 +52,135 @@ class SubscriptionManager:
         """
         下载订阅内容并转换为Clash配置
         
-        Returns:
-            str: 生成的Clash配置文件路径
-            
         Raises:
-            RuntimeError: 如果下载或转换失败
+            RuntimeError: 下载或转换失败时抛出
         """
+        if not self.sub_url:
+            logger.warning("未提供订阅URL，跳过下载步骤")
+            # 尝试处理已有的raw文件
+            self._convert_raw_to_config()
+            return
+            
         # 下载订阅内容
-        sub_content = self._download_subscription()
-        
-        # 保存订阅内容到临时文件
-        temp_file = f"{self.config_path}.raw"
-        with open(temp_file, "w", encoding="utf-8") as f:
-            f.write(sub_content)
-        
-        # 使用subconverter转换为Clash配置
-        self._convert_to_clash(temp_file)
-        
-        # 修改配置文件以确保端口设置正确
-        self._patch_config()
-        
-        # 清理临时文件
+        raw_config_path = f"{self.config_path}.raw"
         try:
-            os.remove(temp_file)
-        except OSError:
-            pass
-        
-        return self.config_path
-    
-    def _download_subscription(self):
-        """
-        下载订阅内容
-        
-        Returns:
-            str: 订阅内容文本
+            # 安全打印URL（隐藏敏感信息）
+            masked_url = self._mask_url(self.sub_url)
+            logger.info(f"正在下载订阅: {masked_url}")
             
-        Raises:
-            RuntimeError: 如果下载失败
-        """
-        logger.info(f"正在下载订阅: {self._mask_url(self.sub_url)}")
-        
-        try:
-            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
+            response = requests.get(self.sub_url, timeout=30)
+            response.raise_for_status()  # 抛出HTTP错误
+            
+            content = response.content
             
-            if not content or len(content) < 10:
-                raise RuntimeError("下载的订阅内容为空或过短")
+            # 将原始内容保存为raw文件以备转换
+            with open(raw_config_path, "wb") as f:
+                f.write(content)
             
             logger.info(f"成功下载订阅，大小: {len(content)} 字节")
-            return content
-        
+            
         except requests.RequestException as e:
-            logger.error(f"下载订阅失败: {str(e)}")
-            raise RuntimeError(f"下载订阅失败: {str(e)}")
-    
-    def _convert_to_clash(self, input_file):
+            error_msg = f"下载订阅失败: {str(e)}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+        
+        # 转换为Clash配置
+        self._convert_raw_to_config()
+        
+    def _convert_raw_to_config(self):
         """
-        使用subconverter将订阅内容转换为Clash配置
+        将原始订阅内容转换为Clash配置
         
-        Args:
-            input_file: 包含订阅内容的文件路径
-            
         Raises:
-            RuntimeError: 如果转换失败
+            RuntimeError: 转换失败时抛出
         """
-        logger.info(f"正在将订阅转换为Clash配置")
-        logger.info(f"输入文件: {input_file}, 配置路径: {self.config_path}")
+        raw_config_path = f"{self.config_path}.raw"
         
-        # 确保数据目录存在
-        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)}")
+        # 确保原始配置文件存在
+        if not os.path.exists(raw_config_path):
+            error_msg = f"原始配置文件不存在: {raw_config_path}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
         
-        # 尝试直接读取订阅内容，确认它是否已经是Clash配置
         try:
-            with open(input_file, "r", encoding="utf-8") as f:
+            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:
                 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配置
-            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不存在，尝试直接使用订阅内容")
+            # 如果不是Clash格式，尝试转换
+            # 使用标准Base64解码尝试
             try:
-                with open(input_file, "r", encoding="utf-8") as f:
+                # 先尝试读取为文本内容(解决某些订阅直接返回明文)
+                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)}")
+                
+            # 如果上述方法都失败，可能是其他格式，直接尝试作为配置使用
+            try:
+                with open(raw_config_path, "r", encoding="utf-8", errors="ignore") as f:
                     content = f.read()
+                
                 with open(self.config_path, "w", encoding="utf-8") as f:
                     f.write(content)
-                logger.info(f"已将订���内容直接写入到: {self.config_path}")
+                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)}")
+                logger.error(f"使用订阅内容作为配置文件时出错: {str(e)}")
                 raise RuntimeError(f"写入配置文件失败: {str(e)}")
-            return
-        
-        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)}")
+                
+            # 修补配置文件
+            self._patch_config()
         
-        except (subprocess.SubprocessError, OSError) as e:
-            logger.error(f"执行subconverter时出错: {str(e)}")
+        except Exception as e:
+            logger.error(f"转换配置时出错: {str(e)}")
             raise RuntimeError(f"配置转换失败: {str(e)}")
     
     def _add_clash_headers(self):