Upload 20 files

Dockerfile

@@ -99,9 +99,6 @@ RUN echo "Downloading Yacd-meta UI (gh-pages branch)..." && \
     rm /tmp/yacd-gh-pages.zip && \
     rm -rf /tmp/Yacd-meta-gh-pages
 
-# 在容器内创建空的 minimal_pref.yml 文件
-RUN touch /app/subconverter/minimal_pref.yml
-
 # 设置环境变量
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \

app/sub_manager.py

@@ -121,66 +121,131 @@ class SubscriptionManager:
         
         # 确保数据目录存在
         data_dir = os.path.dirname(self.config_path)
-        os.makedirs(data_dir, exist_ok=True)
+        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)}")
         
-        # 准备subconverter命令 - 使用 -i/-o 并强制指定空白配置
-        minimal_pref_path = os.path.join(os.path.dirname(self.subconverter_path), "minimal_pref.yml")
+        # 尝试直接读取订阅内容，确认它是否已经是Clash配置
+        try:
+            with open(input_file, "r", encoding="utf-8") as f:
+                content = f.read()
+            
+            # 简单检查是否已经是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,
-            "-i", input_file,        # 输入文件
-            "-o", self.config_path,  # 输出文件
-            "-t", "clash",            # 目标格式
-            "--config", minimal_pref_path # 强制使用空白配置，避免默认行为
+            "-g",  # 生成配置文件
+            "--target", "clash",  # 输出格式为Clash (修正为 --target)
+            "--url", input_file,  # 修正为 --url 参数
+            "--output", self.config_path,  # 输出文件
+            "--include-remarks", ".*"  # 包含所有节点
         ]
         
         logger.info(f"执行命令: {' '.join(cmd)}")
         
-        # 检查 subconverter 是否存在 (之前的代码已修复)
+        # 如果subconverter不存在或执行出错，我们就尝试直接使用订阅内容
         if not os.path.exists(self.subconverter_path):
-            # ... (省略 subconverter 未找到的回退逻辑) ...
-            logger.error(f"subconverter未找到: {self.subconverter_path}. 无法转换配置。")
-            raise RuntimeError(f"无法转换配置 (subconverter未找到)")
+            logger.warning("subconverter不存在，尝试直接使用订阅内容")
+            try:
+                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.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)}")
+                raise RuntimeError(f"写入配置文件失败: {str(e)}")
+            return
         
-        # --- 正式执行 subconverter ---
         try:
             # 执行subconverter
             process = subprocess.Popen(
                 cmd,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
-                universal_newlines=True,
-                cwd=os.path.dirname(self.subconverter_path) # 尝试在subconverter目录下运行
+                universal_newlines=True
             )
-            stdout, stderr = process.communicate(timeout=60) 
+            stdout, stderr = process.communicate(timeout=30)
             
-            # 记录完整的 subconverter 输出用于调试
-            logger.info(f"subconverter STDOUT:\n---\n{stdout}\n---") 
-            if stderr:
-                logger.warning(f"subconverter STDERR:\n---\n{stderr}\n---")
+            logger.info(f"subconverter输出: {stdout[:200]}...") # 限制日志长度
             
-            # 检查 subconverter 返回码
             if process.returncode != 0:
-                logger.error(f"subconverter执行失败，返回码: {process.returncode}.")
-                # ... (省略 subconverter 失败的回退逻辑) ...
-                raise RuntimeError(f"subconverter转换失败(code {process.returncode})。 Subconverter STDERR: {stderr[:200]}...")
+                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:
-                # subconverter 返回码为 0，表示理论上成功
-                logger.info("subconverter成功执行 (返回码 0)")
-                # 验证输出文件是否存在且非空
-                if os.path.exists(self.config_path) and os.path.getsize(self.config_path) > 0:
+                logger.info("成功转换配置")
+                # 验证输出文件是否存在
+                if os.path.exists(self.config_path):
                     logger.info(f"配置文件已生成，路径: {self.config_path}，大小: {os.path.getsize(self.config_path)} 字节")
                 else:
-                    logger.error(f"subconverter执行成功，但配置文件不存在或为空: {self.config_path}. 请检查subconverter日志了解详情。")
-                    # 检查STDERR中是否有线索
-                    error_detail = stderr if stderr else "(无错误输出)"
-                    raise RuntimeError(f"subconverter执行成功但未生成有效配置文件。 Subconverter STDERR: {error_detail[:500]}...")
+                    # 如果文件不存在但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.TimeoutExpired:
-             logger.error(f"执行subconverter超时 (超过60秒)")
-             raise RuntimeError("subconverter执行超时")
         except (subprocess.SubprocessError, OSError) as e:
-            logger.error(f"执行subconverter时发生错误: {str(e)}")
+            logger.error(f"执行subconverter时出错: {str(e)}")
             raise RuntimeError(f"配置转换失败: {str(e)}")
     
     def _add_clash_headers(self):
@@ -246,186 +311,155 @@ secret: ""
                 # 解析配置
                 config_yaml = yaml.safe_load(config_content)
                 
-                # 检查解析结果是否为有效字典
-                if not isinstance(config_yaml, dict):
-                    logger.error("配置文件解析结果不是有效的YAML字典，无法进行修复")
-                    # 使用简单的文本分析，避免添加重复的配置
-                    has_proxy_groups = "proxy-groups:" in config_content
-                    has_global_group = "GLOBAL" in config_content or "- name: GLOBAL" in config_content
-                    if not has_proxy_groups and not has_global_group:
-                        logger.info("未检测到proxy-groups或GLOBAL策略组，添加基本的GLOBAL策略组")
-                        config_content += "\nproxy-groups:\n  - name: GLOBAL\n    type: select\n    proxies:\n      - DIRECT\n"
-                        has_patch = True
-                    else:
-                        logger.info("检测到已有proxy-groups或GLOBAL配置，跳过添加")
-                else:
-                    # --- 开始修复逻辑 ---
-                    groups_fixed = False
-                    proxies_list = config_yaml.get("proxies")
-                    
-                    # 1. 检查代理列表是否有效
-                    if not proxies_list or not isinstance(proxies_list, list):
-                        logger.error("配置文件缺少有效的 'proxies' 列表或列表为空！将仅使用 DIRECT 代理。请检查原始订阅内容。")
-                        # 设置一个最小化的 proxies 和 proxy-groups
-                        # 不要在 proxies 中显式定义 DIRECT，Clash 内置了它
-                        config_yaml["proxies"] = []
-                        config_yaml["proxy-groups"] = [{
-                            "name": "GLOBAL",
-                            "type": "select",
-                            "proxies": ["DIRECT"] # 直接引用内置的 DIRECT
-                        }]
-                        proxy_names = {"DIRECT", "REJECT"} # 仍然需要知道内置名称
-                        groups_fixed = True # 标记需要重新生成配置内容
-                        has_patch = True
-                    else:
-                        # 2. 代理列表有效，获取所有代理节点名称
+                # 检查是否有代理和代理组
+                if config_yaml and isinstance(config_yaml, dict):
+                    if "proxies" in config_yaml and "proxy-groups" in config_yaml:
+                        # 获取所有代理节点名称
                         proxy_names = set()
-                        valid_proxies_list = []
-                        for proxy in proxies_list:
+                        for proxy in config_yaml.get("proxies", []):
                             if isinstance(proxy, dict) and "name" in proxy:
                                 proxy_names.add(proxy["name"])
-                                valid_proxies_list.append(proxy) # 只保留有效的代理定义
-                            else:
-                                logger.warning(f"配置文件中的 'proxies' 列表包含无效条目: {proxy}")
                         
-                        # 如果所有条目都无效，则回退
-                        if not valid_proxies_list:
-                            logger.error("配置文件中的 'proxies' 列表所有条目均无效！将仅使用 DIRECT 代理。")
-                            config_yaml["proxies"] = [{"name": "DIRECT", "type": "direct"}]
-                            config_yaml["proxy-groups"] = [{
-                                "name": "GLOBAL",
-                                "type": "select",
-                                "proxies": ["DIRECT"]
-                            }]
-                            proxy_names = {"DIRECT", "REJECT"}
-                            groups_fixed = True
-                            has_patch = True
-                        else:
-                            config_yaml["proxies"] = valid_proxies_list # 更新为仅包含有效代理的列表
-                            # 添加内置代理
-                            proxy_names.add("DIRECT")
-                            proxy_names.add("REJECT")
-                    
-                    # 3. 修复或添加代理组
-                    proxy_groups = config_yaml.get("proxy-groups", [])
-                    if not isinstance(proxy_groups, list):
-                        logger.warning("'proxy-groups' 不是一个列表，将重新创建")
-                        proxy_groups = []
-                        config_yaml["proxy-groups"] = proxy_groups
-                        groups_fixed = True
+                        # 添加内置代理
+                        proxy_names.add("DIRECT")
+                        proxy_names.add("REJECT")
                         
-                    has_global = False
-                    valid_groups = []
-                    for group in proxy_groups:
-                        if not isinstance(group, dict) or "name" not in group or "type" not in group:
-                            logger.warning(f"'proxy-groups' 中包含无效组定义: {group}")
-                            groups_fixed = True
-                            continue # 跳过无效组
-                            
-                        if "proxies" in group:
-                            if not isinstance(group["proxies"], list):
-                                logger.warning(f"代理组 '{group['name']}' 的 'proxies' 不是列表，设置为 ['DIRECT']")
-                                group["proxies"] = ["DIRECT"]
-                                groups_fixed = True
-                            else:
+                        # 修复代理组引用
+                        groups_fixed = False
+                        for group in config_yaml.get("proxy-groups", []):
+                            if isinstance(group, dict) and "proxies" in group:
                                 # 删除组中引用的不存在的代理
-                                original_group_proxies = group["proxies"].copy()
-                                group["proxies"] = [p for p in group["proxies"] if p in proxy_names or p == group["name"]]
-                                if len(group["proxies"]) != len(original_group_proxies):
-                                    removed = set(original_group_proxies) - set(group["proxies"])
-                                    if removed:
-                                        logger.warning(f"删除代理组 '{group['name']}' 中的无效引用: {', '.join(removed)}")
+                                valid_proxies = []
+                                for proxy in group["proxies"]:
+                                    if proxy in proxy_names or proxy == group.get("name", ""):
+                                        valid_proxies.append(proxy)
+                                    else:
+                                        logger.warning(f"删除代理组 {group.get('name', '未知')} 中的无效引用: {proxy}")
                                         groups_fixed = True
                                 
                                 # 确保代理组至少有一个有效代理
-                                if not group["proxies"]:
-                                    logger.warning(f"为空代理组 '{group['name']}' 添加默认代理: DIRECT")
-                                    group["proxies"].append("DIRECT")
+                                if not valid_proxies:
+                                    valid_proxies.append("DIRECT")
+                                    logger.warning(f"为空代理组 {group.get('name', '未知')} 添加默认代理: DIRECT")
                                     groups_fixed = True
-                        else:
-                             # 如果组定义没有proxies列表（例如 url-test），通常是正常的
-                             pass
-                             
-                        valid_groups.append(group)
-                        if group["name"] == "GLOBAL":
-                            has_global = True
+                                
+                                group["proxies"] = valid_proxies
                         
-                    # 更新为只包含有效组定义的列表
-                    config_yaml["proxy-groups"] = valid_groups
-                    
-                    # 4. 如果没有 GLOBAL 组，添加一个
-                    if not has_global:
-                        logger.info("添加 GLOBAL 策略组")
-                        # 确定要放入 GLOBAL 组的代理 (所有已知真实代理 + DIRECT)
-                        global_proxies = [p for p in proxy_names if p not in ("DIRECT", "REJECT")]
-                        global_proxies.sort() # 可选：排序
-                        global_proxies.insert(0, "DIRECT") # 将 DIRECT 放前面
+                        # 检查是否有GLOBAL组，如果没有，添加一个
+                        has_global = False
+                        for group in config_yaml.get("proxy-groups", []):
+                            if isinstance(group, dict) and group.get("name") == "GLOBAL":
+                                has_global = True
+                                break
+                        
+                        if not has_global:
+                            # 添加GLOBAL策略组
+                            logger.info("添加GLOBAL策略组")
+                            if "proxy-groups" not in config_yaml:
+                                config_yaml["proxy-groups"] = []
+                            
+                            # 确定要放入GLOBAL组的代理
+                            global_proxies = ["DIRECT"]
+                            # 添加所有代理节点到GLOBAL组
+                            for proxy in config_yaml.get("proxies", []):
+                                if isinstance(proxy, dict) and "name" in proxy:
+                                    proxy_name = proxy["name"]
+                                    if proxy_name != "DIRECT" and proxy_name != "REJECT":
+                                        global_proxies.append(proxy_name)
+                            
+                            config_yaml["proxy-groups"].insert(0, {
+                                "name": "GLOBAL",
+                                "type": "select",
+                                "proxies": global_proxies
+                            })
+                            groups_fixed = True
+                            has_patch = True
+                        
+                        # 如果修复了代理组，重新生成配置
+                        if groups_fixed:
+                            config_content = yaml.dump(config_yaml, sort_keys=False, allow_unicode=True)
+                            has_patch = True
+                    else:
+                        # 配置缺少代理或代理组，添加基本结构
+                        if "proxies" not in config_yaml:
+                            config_yaml["proxies"] = [{"name": "DIRECT", "type": "direct"}]
+                            has_patch = True
+                        
+                        if "proxy-groups" not in config_yaml:
+                            config_yaml["proxy-groups"] = [{
+                                "name": "GLOBAL",
+                                "type": "select",
+                                "proxies": ["DIRECT"]
+                            }]
+                            has_patch = True
                         
-                        config_yaml["proxy-groups"].insert(0, {
-                            "name": "GLOBAL",
-                            "type": "select",
-                            "proxies": global_proxies
-                        })
-                        groups_fixed = True
+                        # 更新配置内容
+                        config_content = yaml.dump(config_yaml, sort_keys=False, allow_unicode=True)
+                else:
+                    # 配置为空或无效，添加基本配置
+                    logger.warning("配置为空或无效，添加基本配置结构")
+                    # 使用简单的文本分析，避免添加重复的配置
+                    has_proxy_groups = "proxy-groups:" in config_content
+                    has_global_group = "GLOBAL" in config_content or "- name: GLOBAL" in config_content
+
+                    if not has_proxy_groups and not has_global_group:
+                        logger.info("未检测到proxy-groups或GLOBAL策略组，添加基本的GLOBAL策略组")
+                        config_content += """
+proxy-groups:
+  - name: GLOBAL
+    type: select
+    proxies:
+      - DIRECT
+"""
                         has_patch = True
+                    else:
+                        logger.info("检测到已有proxy-groups或GLOBAL配置，跳过添加")
                     
-                    # 5. 如果进行了修复，重新序列化 YAML
-                    if groups_fixed:
-                        try:
-                            config_content = yaml.dump(config_yaml, sort_keys=False, allow_unicode=True, default_flow_style=None)
-                            has_patch = True # 确保标记为已修改
-                        except Exception as dump_err:
-                            logger.error(f"重新序列化 YAML 失败: {dump_err}")
-                            # 序列化失败，放弃修复，依赖原始 content + 基础 patch
-                            # 重新读取原始content，只应用基础patch
-                            with open(self.config_path, "r", encoding="utf-8") as f:
-                                config_content = f.read()
-                            if "mixed-port:" not in config_content and "port:" not in config_content: config_content = "mixed-port: 7890\n" + config_content
-                            if "external-controller:" not in config_content: config_content = "external-controller: 127.0.0.1:9090\n" + config_content
-                            if "find-process-mode:" not in config_content: config_content = "find-process-mode: strict\n" + config_content
-                            if "secret:" not in config_content: config_content = "secret: ''\n" + config_content
-                            has_patch = True # 标记基础 patch 已应用
-                            
-            # --- 处理 YAML 导入或解析错误的回退逻辑 ---
             except ImportError as e:
-                logger.error(f"导入PyYAML模块失败: {str(e)}. 无法执行详细配置修复。")
+                logger.error(f"导入PyYAML模块失败: {str(e)}")
                 # 使用简单的文本分析，避免添加重复的配置
                 has_proxy_groups = "proxy-groups:" in config_content
                 has_global_group = "GLOBAL" in config_content or "- name: GLOBAL" in config_content
+
                 if not has_proxy_groups and not has_global_group:
                     logger.info("未检测到proxy-groups或GLOBAL策略组，添加基本的GLOBAL策略组")
-                    config_content += "\nproxy-groups:\n  - name: GLOBAL\n    type: select\n    proxies:\n      - DIRECT\n"
+                    config_content += """
+proxy-groups:
+  - name: GLOBAL
+    type: select
+    proxies:
+      - DIRECT
+"""
                     has_patch = True
                 else:
                     logger.info("检测到已有proxy-groups或GLOBAL配置，跳过添加")
             except Exception as yaml_err:
-                logger.error(f"处理YAML配置时出错: {str(yaml_err)}. 无法执行详细配置修复。")
+                logger.error(f"处理YAML配置时出错: {str(yaml_err)}")
                 # 使用简单的文本分析，避免添加重复的配置
                 has_proxy_groups = "proxy-groups:" in config_content
                 has_global_group = "GLOBAL" in config_content or "- name: GLOBAL" in config_content
+
                 if not has_proxy_groups and not has_global_group:
                     logger.info("未检测到proxy-groups或GLOBAL策略组，添加基本的GLOBAL策略组")
-                    config_content += "\nproxy-groups:\n  - name: GLOBAL\n    type: select\n    proxies:\n      - DIRECT\n"
+                    config_content += """
+proxy-groups:
+  - name: GLOBAL
+    type: select
+    proxies:
+      - DIRECT
+"""
                     has_patch = True
                 else:
                     logger.info("检测到已有proxy-groups或GLOBAL配置，跳过添加")
             
-            # --- 写回文件 ---
+            # 如果我们修改了配置，保存回文件
             if has_patch:
-                logger.info("检测到配置更改，正在写回文件...")
-                try:
-                    with open(self.config_path, "w", encoding="utf-8") as f:
-                        f.write(config_content)
-                    logger.info("已修补配置文件并成功保存")
-                except Exception as write_err:
-                    logger.error(f"写回配置文件失败: {write_err}")
-                    # 记录错误，但允许程序继续
-            else:
-                logger.info("配置文件无需修补")
+                with open(self.config_path, "w", encoding="utf-8") as f:
+                    f.write(config_content)
+                logger.info("已修补配置文件以添加必要的设置")
         
-        # 这个 except 对应最外层的 try
         except Exception as e:
-            logger.error(f"修补配置文件过程中发生意外错误: {str(e)}")
+            logger.error(f"修补配置文件时出错: {str(e)}")
     
     def _mask_url(self, url):
         """