Update app.py

app.py

@@ -1,153 +1,65 @@
-from flask import Flask, request
-import requests
-import base64
-import json
 import re
+import yaml
+import requests
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
 
-app = Flask(__name__)
-
-def parse_node_input(node_input):
-    proxies_match = re.search(r'proxies:\s*\n([\s\S]*?)(?:\n\w+:|$)', node_input)
+def extract_and_transform_proxies(input_text):
+    proxies_match = re.search(r'proxies:\s*\n((?:{.*\n)*)', input_text)
     if not proxies_match:
-        return []
+        return "未找到proxies部分"
 
     proxies_text = proxies_match.group(1)
-    nodes = re.findall(r'^\s*-\s*({[^}]+})', proxies_text, re.MULTILINE)
     
-    parsed_nodes = []
-    for node in nodes:
-        node_dict = {}
-        items = re.findall(r'(\w+):\s*([^,}\n]+)', node)
-        for key, value in items:
-            if key in ['port', 'alterId']:
-                node_dict[key] = int(value)
-            elif key in ['udp', 'tls']:
-                node_dict[key] = value.lower() == 'true'
-            else:
-                node_dict[key] = value.strip("'\"")
-        
-        ws_opts_match = re.search(r'ws-opts:\s*({[^}]+})', node)
-        if ws_opts_match:
-            ws_opts = ws_opts_match.group(1)
-            path_match = re.search(r'path:\s*([^,}]+)', ws_opts)
-            if path_match:
-                node_dict['ws-opts.path'] = path_match.group(1).strip("'\"")
-            headers_match = re.search(r'headers:\s*({[^}]+})', ws_opts)
-            if headers_match:
-                headers = headers_match.group(1)
-                host_match = re.search(r'Host:\s*([^,}]+)', headers)
-                if host_match:
-                    node_dict['ws-opts.headers.Host'] = host_match.group(1).strip("'\"")
-
-        parsed_nodes.append(node_dict)
-
-    return parsed_nodes
-
-def convert_to_vmess(node):
-    try:
-        path = node.get('ws-opts.path', '')
-        vmess_node = {
-            "v": "2",
-            "ps": node['name'],
-            "add": node['server'],
-            "port": str(node['port']),
-            "id": node['uuid'],
-            "aid": str(node.get('alterId', 0)),
-            "scy": node.get('cipher', 'auto'),
-            "net": node.get('network', 'tcp'),
-            "type": "none",
-            "host": node.get('ws-opts.headers.Host', node.get('servername', "")),
-            "path": path,
-            "tls": "tls" if node.get('tls', False) else ""
-        }
-        json_str = json.dumps(vmess_node, separators=(',', ':'))
-        vmess_base64 = base64.b64encode(json_str.encode()).decode()
-        return f"vmess://{vmess_base64}"
-    except KeyError as e:
-        return f"Error in VMess conversion: Missing {e} key"
-
-def convert_to_vless(node):
     try:
-        params = []
-        if node.get('tls', False):
-            params.append("security=tls")
-        if node.get('flow', ''):
-            params.append(f"flow={node['flow']}")
-        if node.get('servername', ''):
-            params.append(f"sni={node['servername']}")
-        if node.get('ws-opts.path', ''):
-            params.append(f"path={node['ws-opts.path']}")
-        if node.get('ws-opts.headers.Host', ''):
-            params.append(f"host={node['ws-opts.headers.Host']}")
-        if node.get('client-fingerprint', ''):
-            params.append(f"fp={node['client-fingerprint']}")
-        
-        param_str = "&".join(params)
-        vless_link = f"vless://{node['uuid']}@{node['server']}:{node['port']}?{param_str}#{node['name']}"
-        return vless_link
-    except KeyError as e:
-        return f"Error in VLess conversion: Missing {e} key"
+        proxies_list = yaml.safe_load(proxies_text)
+    except yaml.YAMLError as e:
+        return f"YAML解析错误: {str(e)}"
 
-def convert_to_trojan(node):
-    try:
-        trojan_link = f"trojan://{node['password']}@{node['server']}:{node['port']}?sni={node.get('sni', '')}#{node['name']}"
-        return trojan_link
-    except KeyError as e:
-        return f"Error in Trojan conversion: Missing {e} key"
+    transformed_proxies = []
 
-def convert_to_ss(node):
-    try:
-        ss_config = f"{node['cipher']}:{node['password']}"
-        encoded_config = base64.b64encode(ss_config.encode()).decode()
-        ss_link = f"ss://{encoded_config}@{node['server']}:{node['port']}#{node['name']}"
-        return ss_link
-    except KeyError as e:
-        return f"Error in Shadowsocks conversion: Missing {e} key"
+    for proxy in proxies_list:
+        if proxy['type'] == 'ss':
+            name = proxy['name']
+            server = proxy['server']
+            port = proxy['port']
+            cipher = proxy['cipher']
+            password = proxy['password']
+            udp = 'true' if proxy.get('udp', False) else 'false'
 
-def convert_to_hysteria2(node):
-    try:
-        hysteria2_link = (
-            f"hysteria2://{node['password']}@{node['server']}:{node['port']}"
-            f"?auth={node.get('auth', '')}&skip-cert-verify={str(node.get('skip-cert-verify', False)).lower()}"
-            f"&udp={str(node.get('udp', False)).lower()}#{node['name']}"
-        )
-        return hysteria2_link
-    except KeyError as e:
-        return f"Error in Hysteria2 conversion: Missing {e} key"
+            transformed = f"{name} = ss, {server}, {port}, encrypt-method={cipher}, password={password}, udp-relay={udp}"
+            transformed_proxies.append(transformed)
 
-@app.route('/', methods=['GET'])
-def convert_nodes():
-    url = request.args.get('url')
-    if not url:
-        return "Please provide a URL", 400
+    return "\n".join(transformed_proxies)
 
-    try:
-        response = requests.get(url)
-        response.raise_for_status()
-        node_input = response.text
-    except requests.RequestException as e:
-        return f"Error fetching URL: {str(e)}", 500
+class RequestHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        parsed_path = urlparse(self.path)
+        query_params = parse_qs(parsed_path.query)
 
-    nodes = parse_node_input(node_input)
-    
-    converted_nodes = []
-    
-    for node in nodes:
-        if node['type'] == 'ss':
-            converted_nodes.append(convert_to_ss(node))
-        elif node['type'] == 'vmess':
-            converted_nodes.append(convert_to_vmess(node))
-        elif node['type'] == 'vless':
-            converted_nodes.append(convert_to_vless(node))
-        elif node['type'] == 'trojan':
-            converted_nodes.append(convert_to_trojan(node))
-        elif node['type'] == 'hysteria2':
-            converted_nodes.append(convert_to_hysteria2(node))
+        if 'url' in query_params:
+            url = query_params['url'][0]
+            try:
+                response = requests.get(url)
+                if response.status_code == 200:
+                    input_text = response.text
+                    result = extract_and_transform_proxies(input_text)
+                    self.send_response(200)
+                    self.send_header('Content-type', 'text/plain; charset=utf-8')
+                    self.end_headers()
+                    self.wfile.write(result.encode('utf-8'))
+                else:
+                    self.send_error(response.status_code, f"Failed to fetch data from {url}")
+            except requests.RequestException as e:
+                self.send_error(500, f"Error fetching data: {str(e)}")
         else:
-            converted_nodes.append(f"Unknown node type: {node['type']}")
+            self.send_error(400, "Missing 'url' parameter")
 
-    result = "\n".join(converted_nodes)
-    return result, 200, {'Content-Type': 'text/plain; charset=utf-8'}
+def run_server(port=8080):
+    server_address = ('', port)
+    httpd = HTTPServer(server_address, RequestHandler)
+    print(f"Server running on port {port}")
+    httpd.serve_forever()
 
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=8080)
+if __name__ == "__main__":
+    run_server()