Update app.py

app.py

@@ -6,10 +6,10 @@ from concurrent.futures import ThreadPoolExecutor
 
 app = Flask(__name__)
 
-# Hardcoded list of IPs from the Termux script
+# Exact same IP list from your script
 HARDCODED_IPS = [
     "108.181.33.119",
-    "108.181.34.151", 
+    "108.181.34.151",
     "108.181.34.157",
     "108.181.90.163",
     "108.181.34.177",
@@ -29,23 +29,17 @@ HARDCODED_IPS = [
     "108.181.11.173"
 ]
 
-def base64_url_decode(s):
-    s = s.replace('_', '/').replace('-', '+')
-    pad = len(s) % 4
-    if pad:
-        s += '=' * (4 - pad)
-    return base64.b64decode(s).decode('utf-8')
-
-def base64_url_encode(s):
-    return base64.b64encode(s.encode('utf-8')).decode('utf-8').replace('/', '_').replace('+', '-').rstrip('=')
-
+# EXACT REPLICA of the swap_ip_in_url function from your script
 def swap_ip_in_url(template_url, new_ip):
+    if not template_url or not new_ip:
+        return None
+    
     try:
-        # Split URL into base and query string
+        # Split URL into base and query string (exact logic)
         base_url = template_url.split('?')[0]
-        query_string = '?'.join(template_url.split('?')[1:]) if '?' in template_url else ''
+        query_string = template_url.split('?')[1] if '?' in template_url else ""
         
-        # Extract original IP
+        # Extract old IP using regex (same as script)
         old_ip_match = re.search(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', base_url)
         if not old_ip_match:
             return None
@@ -54,45 +48,59 @@ def swap_ip_in_url(template_url, new_ip):
         # Replace IP in base URL
         new_base_url = base_url.replace(old_ip, new_ip)
         
-        # Process query parameters
         if not query_string:
             return new_base_url
-            
-        params = parse_qs(query_string, keep_blank_values=True)
-        new_params = {}
         
-        for key, values in params.items():
-            new_values = []
-            for value in values:
-                if key == 'r':
-                    # Special handling for 'r' parameter
+        # Process query parameters (EXACT same logic)
+        new_query_string = ""
+        params = query_string.split('&')
+        
+        for param in params:
+            if '=' in param:
+                key, value = param.split('=', 1)
+                
+                if key == "r":
+                    # URL decode the value (exact same replacements)
+                    url_decoded_value = value
+                    replacements = [
+                        ('%2F', '/'), ('%3D', '='), ('%3F', '?'), ('%5F', '_'),
+                        ('%20', ' '), ('%26', '&'), ('%25', '%'), ('%2B', '+')
+                    ]
+                    
+                    for old_char, new_char in replacements:
+                        url_decoded_value = url_decoded_value.replace(old_char, new_char)
+                    
+                    # Make it base64 safe (exact same logic)
+                    safe_value = url_decoded_value.replace('_', '/').replace('-', '+')
+                    
                     try:
-                        # URL decode value first
-                        url_decoded = value.replace('%2F', '/').replace('%3D', '=').replace('%3F', '?').replace('%5F', '_')
-                        
-                        # Base64 URL decode
-                        safe_value = url_decoded.replace('_', '/').replace('-', '+')
-                        decoded_r = base64_url_decode(safe_value)
+                        # Base64 decode
+                        decoded_r = base64.b64decode(safe_value).decode('utf-8')
                         
                         if decoded_r:
-                            # Replace IP in decoded value
+                            # Replace IP in decoded URL
                             new_decoded_r = decoded_r.replace(old_ip, new_ip)
-                            # Re-encode
-                            new_value = base64_url_encode(new_decoded_r)
-                            new_values.append(new_value)
+                            
+                            # Base64 encode (exact same logic)
+                            new_encoded = base64.b64encode(new_decoded_r.encode('utf-8')).decode('utf-8')
+                            
+                            # Make URL safe
+                            new_value = new_encoded.replace('/', '_').replace('+', '-').replace('=', '')
+                            
+                            new_query_string += f"&{key}={new_value}"
                         else:
-                            new_values.append(value)
+                            new_query_string += f"&{key}={value}"
                     except:
-                        new_values.append(value)
+                        new_query_string += f"&{key}={value}"
                 else:
-                    new_values.append(value)
-            
-            new_params[key] = new_values
+                    new_query_string += f"&{key}={value}"
+            else:
+                new_query_string += f"&{param}"
         
-        # Rebuild query string
-        new_query = urlencode(new_params, doseq=True)
+        # Remove leading '&'
+        new_query_string = new_query_string[1:] if new_query_string.startswith('&') else new_query_string
         
-        return f"{new_base_url}?{new_query}"
+        return f"{new_base_url}?{new_query_string}"
     
     except Exception as e:
         print(f"Error processing URL: {str(e)}")
@@ -100,7 +108,7 @@ def swap_ip_in_url(template_url, new_ip):
 
 @app.route('/')
 def home():
-    return "IP Swapper API is running. Use POST /generate with JSON payload."
+    return "IP Swapper API is running. Use POST /generate with JSON payload containing 'template_url'."
 
 @app.route('/generate', methods=['POST'])
 def generate_urls():
@@ -111,14 +119,21 @@ def generate_urls():
     
     template_url = data['template_url'].strip()
     
-    with ThreadPoolExecutor() as executor:
-        results = []
-        for ip in HARDCODED_IPS:
-            new_url = swap_ip_in_url(template_url, ip)
-            if new_url:
-                results.append(new_url)
+    # Generate URLs using the exact same method as your script
+    results = []
+    for ip in HARDCODED_IPS:
+        new_url = swap_ip_in_url(template_url, ip)
+        if new_url:
+            results.append(new_url)
     
-    return jsonify({"generated_urls": results})
+    return jsonify({
+        "generated_urls": results,
+        "count": len(results)
+    })
+
+@app.route('/health', methods=['GET'])
+def health():
+    return jsonify({"status": "healthy", "ip_count": len(HARDCODED_IPS)})
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, threaded=True)
+    app.run(host='0.0.0.0', port=7860, debug=True, threaded=True)