Upload 11 files

.env.example

@@ -0,0 +1,24 @@
+# Simple Clash Relay 环境变量配置
+
+# 必需：订阅链接
+# 这是您的机场提供的订阅链接，用于获取节点列表
+SUB_URL=https://your-subscription-url.com/path?token=xxx
+
+# 必需：API密钥
+# 用于保护API接口，请设置一个强密码
+API_KEY=your-strong-api-key
+
+# 可选：Flask应用监听端口（默认8000）
+FLASK_PORT=8000
+
+# 可选：Clash代理监听端口（默认7890）
+CLASH_PROXY_PORT=7890
+
+# 可选：Clash API监听端口（默认9090）
+CLASH_API_PORT=9090
+
+# 可选：Worker进程数量（默认为CPU核心数+1）
+# WORKER_COUNT=4
+
+# 可选：日志级别（默认INFO）
+# LOG_LEVEL=INFO 

Dockerfile

@@ -0,0 +1,57 @@
+# 使用官方Python 3.9 Alpine作为基础镜像（轻量级）
+FROM python:3.9-alpine
+
+# 设置工作目录
+WORKDIR /app
+
+# 安装系统依赖
+RUN apk add --no-cache \
+    curl \
+    ca-certificates \
+    tzdata \
+    tar \
+    gzip
+
+# 设置时区为亚洲/上海
+ENV TZ=Asia/Shanghai
+
+# 创建必要的目录
+RUN mkdir -p ./clash_core ./subconverter ./data
+
+# 下载并安装Clash Meta (替代Clash Core，功能更强大)
+RUN curl -L -o /tmp/clash-meta.gz "https://github.com/MetaCubeX/Clash.Meta/releases/download/v1.16.0/clash.meta-linux-amd64-v1.16.0.gz" && \
+    gunzip -c /tmp/clash-meta.gz > ./clash_core/clash-linux-amd64 && \
+    chmod +x ./clash_core/clash-linux-amd64 && \
+    rm /tmp/clash-meta.gz
+
+# 下载并安装subconverter
+RUN curl -L -o /tmp/subconverter.tar.gz "https://github.com/tindy2013/subconverter/releases/download/v0.7.2/subconverter_linux64.tar.gz" && \
+    tar -xzf /tmp/subconverter.tar.gz -C /tmp && \
+    cp -R /tmp/subconverter/* ./subconverter/ && \
+    chmod +x ./subconverter/subconverter && \
+    rm -rf /tmp/subconverter*
+
+# 复制Python依赖列表
+COPY requirements.txt ./
+
+# 安装Python依赖
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 设置环境变量
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    FLASK_APP=app.main \
+    FLASK_ENV=production
+
+# 复制应用代码
+COPY app/ ./app/
+
+# 复制启动脚本并赋予执行权限
+COPY entrypoint.sh ./
+RUN chmod +x ./entrypoint.sh
+
+# 暴露单一端口 (Hugging Face Spaces要求)
+EXPOSE 7860
+
+# 使用entrypoint脚本启动应用
+ENTRYPOINT ["/app/entrypoint.sh"] 

README.md

@@ -1,11 +1,214 @@
----
-title: Clash
-emoji: ⚡
-colorFrom: pink
-colorTo: yellow
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Simple Clash Relay
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Simple Clash Relay
+
+一个轻量级的自建Clash代理服务，可通过API控制节点切换。
+
+## 功能特点
+
+- 🚀 **轻量级**：基于Python Flask和Clash Core，最小化依赖
+- 🔄 **机场订阅支持**：自动下载并转换您的机场订阅链接
+- 🔌 **单端口模式**：通过路径区分API和代理流量，适合Hugging Face部署
+- 🔒 **API认证**：通过API Key保护控制API
+- 🔄 **动态切换节点**：通过API随时切换使用的节点
+- 🐳 **容器化**：完整的Docker支持，便于部署
+- 🔥 **Hugging Face友好**：针对Hugging Face Spaces平台优化
+
+## 系统要求
+
+- Docker (本地开发/部署)
+- 或 Python 3.8+ (本地开发)
+- 机场订阅链接
+- Hugging Face账户 (云部署)
+
+## 项目结构
+
+```
+simple-clash-relay/
+├── app/                      # Flask应用代码
+│   ├── __init__.py
+│   ├── main.py               # API路由和应用入口
+│   ├── clash_manager.py      # Clash Core管理
+│   ├── sub_manager.py        # 订阅管理
+│   └── auth.py               # API认证
+├── clash_core/               # Clash Core可执行文件
+├── subconverter/             # subconverter可执行文件
+├── data/                     # 运行时数据
+├── Dockerfile                # Docker构建文件
+├── entrypoint.sh             # 容器启动脚本
+├── requirements.txt          # Python依赖
+└── .env.example              # 环境变量模板
+```
+
+## 快速开始
+
+### 准备工作
+
+1. 获取可执行文件:
+   - 下载Clash Core: [github.com/Dreamacro/clash/releases](https://github.com/Dreamacro/clash/releases)
+   - 下载subconverter: [github.com/tindy2013/subconverter/releases](https://github.com/tindy2013/subconverter/releases)
+
+2. 将上述文件放入对应目录:
+   - `clash-linux-amd64` → `clash_core/`目录
+   - `subconverter` → `subconverter/`目录
+
+### 本地开发
+
+1. 安装依赖:
+   ```
+   pip install -r requirements.txt
+   ```
+
+2. 设置环境变量:
+   ```
+   cp .env.example .env
+   # 编辑.env文件，设置SUB_URL和API_KEY
+   ```
+
+3. 启动应用:
+   ```
+   python -m app.main
+   ```
+
+### Docker部署
+
+1. 构建Docker镜像:
+   ```
+   docker build -t simple-clash-relay .
+   ```
+
+2. 运行容器:
+   ```
+   docker run -d \
+     -p 7860:7860 \
+     -e SUB_URL=你的订阅链接 \
+     -e API_KEY=你的API密钥 \
+     --name clash-relay \
+     simple-clash-relay
+   ```
+
+### Hugging Face Spaces部署
+
+1. 在Hugging Face上创建Space:
+   - 访问 [huggingface.co/spaces](https://huggingface.co/spaces)
+   - 点击"Create new Space"
+   - 选择"Docker"作为Space SDK
+   - 填写名称和其他设置
+
+2. 克隆Space仓库:
+   ```
+   git clone https://huggingface.co/spaces/你的用户名/你的Space名称
+   cd 你的Space名称
+   ```
+
+3. 复制项目文件:
+   ```
+   # 将所有项目文件复制到此目录
+   ```
+
+4. 提交和推送:
+   ```
+   git add .
+   git commit -m "Initial commit"
+   git push
+   ```
+
+5. 设置Secrets:
+   - 在Hugging Face Space设置页面添加以下secrets:
+     - `SUB_URL`: 你的订阅链接
+     - `API_KEY`: 你的API密钥
+
+## API使用
+
+所有API请求需要在请求头中包含`X-API-Key: 你的API密钥`。
+
+### 获取节点列表
+
+```
+GET /api/nodes
+```
+
+响应:
+```json
+{
+  "success": true,
+  "nodes": ["节点A", "节点B", "节点C"]
+}
+```
+
+### 切换节点
+
+```
+PUT /api/switch
+Content-Type: application/json
+
+{
+  "node": "节点B"
+}
+```
+
+响应:
+```json
+{
+  "success": true,
+  "message": "已切换到节点: 节点B"
+}
+```
+
+### 获取当前节点
+
+```
+GET /api/current
+```
+
+响应:
+```json
+{
+  "success": true,
+  "current_node": "节点B"
+}
+```
+
+### 刷新订阅
+
+```
+POST /api/refresh
+```
+
+响应:
+```json
+{
+  "success": true,
+  "message": "订阅已刷新，Clash已重启"
+}
+```
+
+## 在应用中使用代理
+
+由于使用单端口模式，您的应用需要使用以下代理配置：
+
+- HTTP代理: `http://your-space-name.hf.space/proxy`
+- SOCKS5代理: `socks5://your-space-name.hf.space/proxy`
+
+### 在cursor-to-openai项目中配置
+
+修改您的cursor-to-openai项目配置，设置代理地址为`http://your-space-name.hf.space/proxy`。
+
+## 注意事项
+
+- 本项目仅用于个人学习和研究目的
+- 请遵守当地法律法规，不要用于非法用途
+- 确保设置强密码API Key以保护接口
+- Hugging Face Spaces有资源和流量限制，请合理使用
+
+## 许可
+
+MIT 

app/__init__.py

@@ -0,0 +1,2 @@
+# Simple Clash Relay - Python Package
+# 这个文件用于标识当前目录为一个Python包 

app/auth.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+认证模块 - 提供API访问认证功能
+"""
+
+import os
+import logging
+import functools
+from flask import request, jsonify
+
+logger = logging.getLogger(__name__)
+
+# 从环境变量获取API密钥
+API_KEY = os.environ.get("API_KEY", "changeme")
+
+def authenticate(func):
+    """
+    用于API路由的认证装饰器
+    
+    Args:
+        func: 被装饰的视图函数
+        
+    Returns:
+        函数: 包含认证逻辑的包装函数
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # 获取请求头中的API Key
+        api_key = request.headers.get("X-API-Key")
+        
+        # 验证API Key
+        if not api_key or api_key != API_KEY:
+            logger.warning(f"API认证失败：{'未提供API Key' if not api_key else 'API Key无效'}")
+            return jsonify({
+                "success": False,
+                "error": "未提供API Key或API Key无效"
+            }), 401
+        
+        # 认证通过，调用原始视图函数
+        return func(*args, **kwargs)
+    
+    return wrapper 

app/clash_manager.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Clash管理器 - 负责Clash Core进程的启动、停止和API调用
+"""
+
+import os
+import time
+import signal
+import logging
+import subprocess
+import requests
+import json
+
+logger = logging.getLogger(__name__)
+
+class ClashManager:
+    """管理Clash Core进程和与其API的交互"""
+    
+    def __init__(self, config_path, clash_path, api_port=9090, proxy_port=7890):
+        """
+        初始化Clash管理器
+        
+        Args:
+            config_path: Clash配置文件路径
+            clash_path: Clash可执行文件路径
+            api_port: Clash API监听端口
+            proxy_port: Clash代理监听端口
+        """
+        self.config_path = os.path.abspath(config_path)
+        self.clash_path = os.path.abspath(clash_path)
+        self.api_port = api_port
+        self.proxy_port = proxy_port
+        self.api_base_url = f"http://127.0.0.1:{api_port}"
+        self.clash_process = None
+        
+        # 确保Clash可执行文件存在
+        if not os.path.exists(clash_path):
+            raise FileNotFoundError(f"Clash可执行文件未找到: {clash_path}")
+    
+    def start_clash(self):
+        """启动Clash Core进程"""
+        if self.clash_process and self.clash_process.poll() is None:
+            logger.info("Clash Core已经在运行中")
+            return
+        
+        # 确保配置文件存在
+        if not os.path.exists(self.config_path):
+            raise FileNotFoundError(f"Clash配置文件未找到: {self.config_path}")
+        
+        # 设置Clash命令行参数 (兼容Clash Meta)
+        cmd = [
+            self.clash_path,
+            "-f", self.config_path,
+            "-d", os.path.dirname(self.config_path)
+        ]
+        
+        # 为Clash Meta添加额外参数
+        if "meta" in self.clash_path.lower():
+            # Clash Meta特有参数
+            cmd.extend([
+                "--controller-addr", f"127.0.0.1:{self.api_port}",
+                # 如果需要可以添加更多Clash Meta特有参数
+            ])
+        else:
+            # 原始Clash参数
+            cmd.extend([
+                "-ext-ctl", f"127.0.0.1:{self.api_port}",
+                "-ext-ui", "" # 禁用外部UI
+            ])
+        
+        # 启动Clash进程
+        logger.info(f"正在启动Clash Core: {' '.join(cmd)}")
+        self.clash_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True
+        )
+        
+        # 等待Clash启动
+        time.sleep(2)
+        
+        # 检查进程是否成功启动
+        if self.clash_process.poll() is not None:
+            stderr = self.clash_process.stderr.read()
+            raise RuntimeError(f"Clash启动失败: {stderr}")
+        
+        # 验证API是否可访问
+        try:
+            self._call_api("GET", "/version")
+            logger.info("Clash API已就绪")
+        except Exception as e:
+            self.stop_clash()
+            raise RuntimeError(f"无法连接到Clash API: {str(e)}")
+    
+    def stop_clash(self):
+        """停止Clash Core进程"""
+        if self.clash_process and self.clash_process.poll() is None:
+            logger.info("正在停止Clash Core...")
+            
+            # 尝试优雅地终止进程
+            self.clash_process.terminate()
+            
+            # 等待进程终止
+            try:
+                self.clash_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                # 如果进程没有及时终止，强制结束
+                logger.warning("Clash进程未响应终止信号，强制结束...")
+                self.clash_process.kill()
+            
+            self.clash_process = None
+            logger.info("Clash Core已停止")
+    
+    def restart_clash(self):
+        """重启Clash Core进程"""
+        logger.info("正在重启Clash Core...")
+        self.stop_clash()
+        time.sleep(1)  # 给进程一些时间完全终止
+        self.start_clash()
+        logger.info("Clash Core已重启")
+    
+    def get_nodes(self):
+        """
+        获取所有可用的代理节点名称列表
+        
+        Returns:
+            list: 节点名称列表
+        """
+        response = self._call_api("GET", "/proxies")
+        proxies = response.get("proxies", {})
+        
+        # 过滤出实际的代理节点（排除DIRECT, REJECT等内置代理和策略组）
+        node_names = []
+        for name, proxy in proxies.items():
+            if proxy.get("type") not in ["Direct", "Reject", "Selector", "URLTest", "Fallback", "LoadBalance"]:
+                node_names.append(name)
+        
+        return node_names
+    
+    def switch_node(self, node_name):
+        """
+        切换到指定的代理节点
+        
+        Args:
+            node_name: 节点名称
+            
+        Raises:
+            ValueError: 如果节点名称无效
+        """
+        # 获取所有节点以验证目标节点存在
+        all_nodes = self.get_nodes()
+        if node_name not in all_nodes:
+            raise ValueError(f"无效的节点名称: {node_name}")
+        
+        # 切换GLOBAL策略组到指定节点
+        # 注意：这里假设使用GLOBAL作为顶级策略组，你可能需要根据实际配置调整
+        try:
+            self._call_api("PUT", "/proxies/GLOBAL", json={"name": node_name})
+            logger.info(f"已切换到节点: {node_name}")
+        except Exception as e:
+            raise RuntimeError(f"切换节点失败: {str(e)}")
+    
+    def get_current_node(self):
+        """
+        获取当前使用的节点名称
+        
+        Returns:
+            str: 当前节点名称
+        """
+        # 获取GLOBAL策略组的当前选择
+        # 注意：这里假设使用GLOBAL作为顶级策略组，你可能需要根据实际配置调整
+        response = self._call_api("GET", "/proxies/GLOBAL")
+        return response.get("now", "unknown")
+    
+    def _call_api(self, method, endpoint, **kwargs):
+        """
+        调用Clash的API
+        
+        Args:
+            method: HTTP方法 (GET, POST, PUT等)
+            endpoint: API端点路径
+            **kwargs: 传递给requests的其他参数
+            
+        Returns:
+            dict: API响应的JSON数据
+            
+        Raises:
+            RuntimeError: 如果API调用失败
+        """
+        url = f"{self.api_base_url}{endpoint}"
+        logger.debug(f"调用Clash API: {method} {url}")
+        
+        try:
+            response = requests.request(method, url, timeout=10, **kwargs)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            logger.error(f"Clash API调用失败: {str(e)}")
+            raise RuntimeError(f"Clash API调用失败: {str(e)}")
+    
+    def __del__(self):
+        """析构函数，确保进程在对象销毁时被终止"""
+        self.stop_clash() 

app/main.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Simple Clash Relay - Flask 应用入口
+"""
+
+import os
+import logging
+from flask import Flask, request, jsonify, Response
+from .clash_manager import ClashManager
+from .sub_manager import SubscriptionManager
+from .auth import authenticate
+import requests
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# 从环境变量加载配置
+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))
+
+# 初始化Flask应用
+app = Flask(__name__)
+
+# 初始化管理器
+clash_manager = None
+sub_manager = None
+
+@app.before_first_request
+def initialize():
+    """应用首次请求前的初始化"""
+    global clash_manager, sub_manager
+    
+    logger.info("正在初始化应用...")
+    
+    # 初始化订阅管理器
+    sub_manager = SubscriptionManager(
+        sub_url=SUB_URL,
+        config_path=os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "config.yaml")
+    )
+    
+    # 加载订阅并转换为Clash配置
+    try:
+        sub_manager.load_and_convert_sub()
+        logger.info("成功加载并转换订阅")
+    except Exception as e:
+        logger.error(f"加载订阅失败: {str(e)}")
+        raise
+    
+    # 初始化Clash管理器
+    clash_manager = ClashManager(
+        config_path=os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "config.yaml"),
+        clash_path=os.path.join(os.path.dirname(os.path.dirname(__file__)), "clash_core", "clash-linux-amd64"),
+        api_port=CLASH_API_PORT,
+        proxy_port=CLASH_PROXY_PORT
+    )
+    
+    # 启动Clash Core
+    try:
+        clash_manager.start_clash()
+        logger.info("成功启动Clash Core")
+    except Exception as e:
+        logger.error(f"启动Clash Core失败: {str(e)}")
+        raise
+
+@app.route("/api/nodes", methods=["GET"])
+@authenticate
+def get_nodes():
+    """获取可用节点列表"""
+    try:
+        nodes = clash_manager.get_nodes()
+        return jsonify({"success": True, "nodes": nodes})
+    except Exception as e:
+        logger.error(f"获取节点列表失败: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route("/api/switch", methods=["PUT"])
+@authenticate
+def switch_node():
+    """切换到指定节点"""
+    data = request.get_json()
+    if not data or "node" not in data:
+        return jsonify({"success": False, "error": "缺少'node'参数"}), 400
+    
+    node_name = data["node"]
+    try:
+        clash_manager.switch_node(node_name)
+        return jsonify({"success": True, "message": f"已切换到节点: {node_name}"})
+    except Exception as e:
+        logger.error(f"切换到节点 {node_name} 失败: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route("/api/current", methods=["GET"])
+@authenticate
+def get_current_node():
+    """获取当前使用的节点"""
+    try:
+        current_node = clash_manager.get_current_node()
+        return jsonify({"success": True, "current_node": current_node})
+    except Exception as e:
+        logger.error(f"获取当前节点失败: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route("/api/refresh", methods=["POST"])
+@authenticate
+def refresh_subscription():
+    """刷新订阅并重新加载Clash配置"""
+    try:
+        sub_manager.load_and_convert_sub()
+        clash_manager.restart_clash()
+        return jsonify({"success": True, "message": "订阅已刷新，Clash已重启"})
+    except Exception as e:
+        logger.error(f"刷新订阅失败: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route("/health", methods=["GET"])
+def health_check():
+    """健康检查接口"""
+    return jsonify({"status": "ok"})
+
+# 新增：代理请求转发功能
+@app.route('/proxy/<path:path>', methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH'])
+def proxy_request(path):
+    """代理请求转发到Clash Core"""
+    target_url = f"http://127.0.0.1:{CLASH_PROXY_PORT}/{path}"
+    logger.debug(f"转发请求到: {target_url}")
+    
+    try:
+        # 转发请求
+        resp = requests.request(
+            method=request.method,
+            url=target_url,
+            headers={key: value for key, value in request.headers if key != 'Host'},
+            data=request.get_data(),
+            cookies=request.cookies,
+            allow_redirects=False,
+            stream=True
+        )
+        
+        # 构建响应
+        excluded_headers = ['content-encoding', 'content-length', 'transfer-encoding', 'connection']
+        headers = [(name, value) for name, value in resp.raw.headers.items()
+                if name.lower() not in excluded_headers]
+        
+        response = Response(resp.content, resp.status_code, headers)
+        return response
+    except Exception as e:
+        logger.error(f"代理请求失败: {str(e)}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+# 新增：处理没有path的根代理请求
+@app.route('/proxy', methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH'])
+def proxy_root():
+    """处理根代理请求"""
+    return proxy_request("")
+
+@app.route('/', methods=['GET'])
+def index():
+    """首页 - 提供简单说明"""
+    return """
+    <html>
+        <head><title>Simple Clash Relay</title></head>
+        <body>
+            <h1>Simple Clash Relay</h1>
+            <p>状态: 运行中</p>
+            <p>API端点: /api/*</p>
+            <p>代理端点: /proxy</p>
+            <p>更多信息请查看文档。</p>
+        </body>
+    </html>
+    """
+
+if __name__ == "__main__":
+    # 如果直接运行此文件，将初始化应用并启动Flask服务器
+    initialize()
+    logger.info(f"启动Flask服务器，监听端口: {FLASK_PORT}")
+    app.run(host="0.0.0.0", port=FLASK_PORT) 

app/sub_manager.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+订阅管理器 - 负责下载订阅内容并转换为Clash配置
+"""
+
+import os
+import logging
+import subprocess
+import requests
+import time
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+class SubscriptionManager:
+    """管理订阅链接的下载和配置转换"""
+    
+    def __init__(self, sub_url, config_path):
+        """
+        初始化订阅管理器
+        
+        Args:
+            sub_url: 订阅链接URL
+            config_path: 生成的Clash配置文件保存路径
+        """
+        self.sub_url = sub_url
+        self.config_path = os.path.abspath(config_path)
+        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)
+        
+        # 检查subconverter可执行文件是否存在
+        if not os.path.exists(self.subconverter_path):
+            raise FileNotFoundError(f"subconverter可执行文件未找到: {self.subconverter_path}")
+    
+    def load_and_convert_sub(self):
+        """
+        下载订阅内容并转换为Clash配置
+        
+        Returns:
+            str: 生成的Clash配置文件路径
+            
+        Raises:
+            RuntimeError: 如果下载或转换失败
+        """
+        # 下载订阅内容
+        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()
+        
+        # 清理临时文件
+        try:
+            os.remove(temp_file)
+        except OSError:
+            pass
+        
+        return self.config_path
+    
+    def _download_subscription(self):
+        """
+        下载订阅内容
+        
+        Returns:
+            str: 订阅内容文本
+            
+        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
+            
+            if not content or len(content) < 10:
+                raise RuntimeError("下载的订阅内容为空或过短")
+            
+            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):
+        """
+        使用subconverter将订阅内容转换为Clash配置
+        
+        Args:
+            input_file: 包含订阅内容的文件路径
+            
+        Raises:
+            RuntimeError: 如果转换失败
+        """
+        logger.info(f"正在将订阅转换为Clash配置")
+        
+        # 准备subconverter命令
+        cmd = [
+            self.subconverter_path,
+            "-g",  # 生成配置文件
+            "--artifact", "clash",  # 输出格式为Clash
+            "--input", input_file,  # 输入文件
+            "--output", self.config_path,  # 输出文件
+            "--include-remarks", ".*"  # 包含所有节点
+        ]
+        
+        # 如果subconverter不存在或执行出错，我们就尝试直接使用订阅内容
+        if not os.path.exists(self.subconverter_path):
+            logger.warning("subconverter不存在，尝试直接使用订阅内容")
+            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)
+            return
+        
+        try:
+            # 执行subconverter
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True
+            )
+            stdout, stderr = process.communicate(timeout=30)
+            
+            if process.returncode != 0:
+                logger.error(f"subconverter执行失败: {stderr}")
+                # 错误处理：尝试直接使用订阅内容
+                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("尝试直接使用订阅内容作为配置文件")
+            else:
+                logger.info("成功转换配置")
+        
+        except (subprocess.SubprocessError, OSError) as e:
+            logger.error(f"执行subconverter时出错: {str(e)}")
+            raise RuntimeError(f"配置转换失败: {str(e)}")
+    
+    def _patch_config(self):
+        """
+        修改配置文件以确保端口设置正确，并兼容Clash Meta
+        """
+        # 检查配置文件是否存在
+        if not os.path.exists(self.config_path):
+            logger.warning(f"配置文件不存在，无法修补: {self.config_path}")
+            return
+        
+        try:
+            # 读取配置内容
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                config_content = f.read()
+            
+            # 确保配置包含必要的端口设置
+            has_patch = False
+            
+            # 这里需要检查配置是否为有效的YAML并进行适当修补
+            # 为简单起见，我们只检查和添加一些基本端口配置
+            
+            if "port: 7890" not in config_content and "mixed-port: 7890" not in config_content:
+                # 添加混合端口配置
+                config_content = "mixed-port: 7890\n" + config_content
+                has_patch = True
+            
+            if "external-controller: 127.0.0.1:9090" not in config_content and "external-controller: :9090" not in config_content:
+                # 添加API控制器配置 (兼容Clash Meta)
+                config_content = "external-controller: 127.0.0.1:9090\n" + config_content
+                has_patch = True
+            
+            # Clash Meta特定配置
+            if "find-process-mode: strict" not in config_content:
+                config_content = "find-process-mode: strict\n" + config_content
+                has_patch = True
+            
+            # 确保启用了API
+            if "secret: " not in config_content:
+                config_content = "secret: ''\n" + config_content
+                has_patch = True
+            
+            # 确保配置了全局策略组
+            if "GLOBAL" not in config_content and "- name: GLOBAL" not in config_content:
+                # 我们可能需要添加全局策略组，但这取决于具体的配置结构
+                # 此处简化处理，仅检测，不修改
+                logger.warning("未检测到GLOBAL策略组，切换节点功能可能无法正常工作")
+            
+            # 如果我们修改了配置，保存回文件
+            if has_patch:
+                with open(self.config_path, "w", encoding="utf-8") as f:
+                    f.write(config_content)
+                logger.info("已修补配置文件以添加必要的设置")
+        
+        except Exception as e:
+            logger.error(f"修补配置文件时出错: {str(e)}")
+    
+    def _mask_url(self, url):
+        """
+        遮蔽URL中的敏感信息用于日志记录
+        
+        Args:
+            url: 原始URL
+            
+        Returns:
+            str: 遮蔽后的URL
+        """
+        try:
+            parsed = urlparse(url)
+            netloc = parsed.netloc
+            
+            # 如果URL包含用户名和密码，则遮蔽密码
+            if "@" in netloc:
+                userpass, host = netloc.split("@", 1)
+                if ":" in userpass:
+                    user, _ = userpass.split(":", 1)
+                    netloc = f"{user}:***@{host}"
+            
+            masked_url = url.replace(parsed.netloc, netloc)
+            
+            # 确保不显示完整的token或密钥
+            if "?" in masked_url:
+                base, query = masked_url.split("?", 1)
+                masked_url = f"{base}?****"
+            
+            return masked_url
+        
+        except Exception:
+            # 如果解析失败，返回更简单的遮蔽
+            return f"{url[:10]}...{url[-5:]}" if len(url) > 15 else "***" 

entrypoint.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+# Exit immediately if a command exits with a non-zero status.
+set -e
+
+# 输出基本信息
+echo "=========================="
+echo "  Simple Clash Relay"
+echo "=========================="
+echo "Starting services..."
+
+# 打印环境变量（隐藏敏感信息）
+echo "Environment:"
+echo "FLASK_PORT:        ${FLASK_PORT:-8000}"
+echo "CLASH_PROXY_PORT:  ${CLASH_PROXY_PORT:-7890}"
+echo "CLASH_API_PORT:    ${CLASH_API_PORT:-9090}"
+echo "SUB_URL:           [hidden]"
+echo "API_KEY:           [hidden]"
+
+# 检查必要的环境变量
+if [ -z "$SUB_URL" ]; then
+    echo "ERROR: Required environment variable SUB_URL is not set!"
+    exit 1
+fi
+
+if [ -z "$API_KEY" ]; then
+    echo "WARNING: API_KEY is not set. Using default value (insecure)!"
+    export API_KEY="changeme"
+fi
+
+# 启动Flask应用
+echo "Starting Flask application on port ${FLASK_PORT:-8000}..."
+
+# 使用gunicorn启动Flask应用（生产环境推荐）
+# 如果WORKER_COUNT未设置，使用CPU核心数+1的worker数量
+WORKER_COUNT=${WORKER_COUNT:-$(( $(nproc) + 1 ))}
+echo "Using $WORKER_COUNT workers"
+
+exec gunicorn \
+    --workers=$WORKER_COUNT \
+    --bind=0.0.0.0:${FLASK_PORT:-8000} \
+    --log-level=info \
+    --access-logfile=- \
+    --error-logfile=- \
+    app.main:app 

fly.toml.example

@@ -0,0 +1,53 @@
+# fly.toml 配置示例
+# 部署前，复制此文件为fly.toml并根据需要修改
+
+app = "simple-clash-relay" # 修改为您的应用名称
+primary_region = "hkg" # 选择最近的地区（香港示例）
+
+[build]
+  # 使用Dockerfile
+  dockerfile = "Dockerfile"
+
+[env]
+  # 公共环境变量 (不包含敏密信息)
+  FLASK_PORT = "8000"
+  CLASH_PROXY_PORT = "7890"
+  CLASH_API_PORT = "9090"
+  # 不要在这里设置SUB_URL和API_KEY，应该使用secrets设置
+
+# API服务 - 暴露为HTTPS
+[[services]]
+  internal_port = 8000
+  protocol = "tcp"
+  
+  [[services.ports]]
+    port = 80
+    handlers = ["http"]
+    force_https = true
+  
+  [[services.ports]]
+    port = 443
+    handlers = ["tls", "http"]
+  
+  # 健康检查配置
+  [[services.http_checks]]
+    interval = "10s"
+    timeout = "2s"
+    grace_period = "30s"
+    method = "get"
+    path = "/health"
+    protocol = "http"
+
+# Clash代理服务 - 暴露为TCP
+[[services]]
+  internal_port = 7890
+  protocol = "tcp"
+  
+  [[services.ports]]
+    port = 7890
+    # 不设置handlers，表示原生TCP
+
+# 可选：持久化卷挂载
+# [mounts]
+#   source = "clash_data"
+#   destination = "/app/data" 

requirements.txt

@@ -0,0 +1,4 @@
+flask==2.0.1
+gunicorn==20.1.0
+requests==2.26.0
+pyyaml==6.0