Update app.py

app.py

@@ -1,252 +1,124 @@
-#!/bin/bash
-
-# =============================================
-#  ADNADE IP SWAPPER - MONITOR MODE
-# =============================================
-
-# Configuration
-CONFIG_DIR="$HOME/.adnade_swapper"
-SHARED_DIR="$HOME/.adnade_shared"
-TEMPLATE_FILE="$SHARED_DIR/template.txt"
-IP_LIST_FILE="$CONFIG_DIR/ip_list.txt"
-GENERATED_URLS_FILE="$CONFIG_DIR/generated_urls.txt"
-PID_FILE="$CONFIG_DIR/surfbar.pid"
-LAST_START_FILE="$CONFIG_DIR/last_start.time"
-CONFIG_FILE="$CONFIG_DIR/settings.conf"
-LOG_FILE="$CONFIG_DIR/surfbar.log"
-
-# Hardcoded list of IP addresses (same as Flask API)
-HARDCODED_IPS=(
-    "108.181.33.119"
-    "108.181.34.151"
-    "108.181.34.157"
-    "108.181.90.163"
-    "108.181.34.177"
-    "208.87.241.1"
-    "208.87.241.149"
-    "208.87.242.125"
-    "208.87.242.233"
-    "108.181.11.171"
-    "108.181.6.9"
-    "108.181.33.135"
-    "108.181.9.39"
-    "108.181.11.193"
-    "108.181.21.229"
-    "108.181.5.31"
-    "108.181.3.54"
-    "108.181.5.51"
+from flask import Flask, request, jsonify
+import base64
+import re
+from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
+from concurrent.futures import ThreadPoolExecutor
+
+app = Flask(__name__)
+
+# Hardcoded list of IPs from the Termux script
+HARDCODED_IPS = [
+    "108.181.33.119",
+    "108.181.34.151", 
+    "108.181.34.157",
+    "108.181.90.163",
+    "108.181.34.177",
+    "208.87.241.1",
+    "208.87.241.149",
+    "208.87.242.125",
+    "208.87.242.233",
+    "108.181.11.171",
+    "108.181.6.9",
+    "108.181.33.135",
+    "108.181.9.39",
+    "108.181.11.193",
+    "108.181.21.229",
+    "108.181.5.31",
+    "108.181.3.54",
+    "108.181.5.51",
     "108.181.11.173"
-)
-
-# ⚙️ Configurable Settings with defaults
-REFRESH_RATE=5
-RESTART_INTERVAL=10800   # 3 hours in seconds
-COOLDOWN_PERIOD=600      # 10 minutes in seconds
-MAX_RETRIES=5
-RETRY_DELAY=30
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-PURPLE='\033[0;35m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-# Logging function
-log() {
-    local message="$1"
-    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
-    echo "[$timestamp] $message" >> "$LOG_FILE"
-    echo -e "$message"
-}
-
-# Initialize system
-init_system() {
-    mkdir -p "$CONFIG_DIR"
-    mkdir -p "$SHARED_DIR"
-    
-    # Load or create config
-    if [ -f "$CONFIG_FILE" ]; then
-        source "$CONFIG_FILE"
-    else
-        save_config
-    fi
-    
-    if [ ! -f "$TEMPLATE_FILE" ]; then
-        echo "# Add your working AdNade URL template here" > "$TEMPLATE_FILE"
-        echo "# Example: http://192.168.1.1:8080/path?param=value" >> "$TEMPLATE_FILE"
-    fi
-    
-    # Initialize log file
-    echo "=== AdNade Swapper Started ===" > "$LOG_FILE"
-}
-
-# Save configuration
-save_config() {
-    cat > "$CONFIG_FILE" << EOF
-# AdNade Swapper Configuration
-REFRESH_RATE=$REFRESH_RATE
-RESTART_INTERVAL=$RESTART_INTERVAL
-COOLDOWN_PERIOD=$COOLDOWN_PERIOD
-MAX_RETRIES=$MAX_RETRIES
-RETRY_DELAY=$RETRY_DELAY
-EOF
-    log "${GREEN}✅ Configuration saved${NC}"
-}
-
-# Pre-flight verification
-verify_setup() {
-    log "${CYAN}🔍 Verifying setup...${NC}"
-    
-    # Check template
-    if [ ! -s "$TEMPLATE_FILE" ] || grep -q "^#" "$TEMPLATE_FILE"; then
-        log "${RED}❌ No template URL found!${NC}"
-        return 1
-    fi
-    
-    # Check firefox
-    if ! command -v firefox &> /dev/null; then
-        log "${RED}❌ Firefox not installed! Run: pkg install firefox${NC}"
-        return 1
-    fi
-    
-    log "${GREEN}✅ Setup verified - Template: OK, Firefox: OK${NC}"
-    return 0
-}
-
-# Get browser process count
-get_browser_process_count() {
-    pgrep -c -f "firefox" 2>/dev/null || echo 0
-}
-
-# Memory display
-show_memory_status() {
-    local total_mem=$(free -m | awk 'NR==2{print $2}')
-    local used_mem=$(free -m | awk 'NR==2{print $3}')
-    local mem_percent=$((used_mem * 100 / total_mem))
-    
-    local swap_total=$(free -m | awk 'NR==3{print $2}')
-    local swap_used=$(free -m | awk 'NR==3{print $3}')
-    local swap_percent=0
-    [ $swap_total -gt 0 ] && swap_percent=$((swap_used * 100 / swap_total))
-    
-    local browser_count=$(get_browser_process_count)
-    
-    echo -e "${CYAN}🖥️  MEMORY STATUS${NC}"
-    echo -e "${BLUE}══════════════════════════════════${NC}"
-    echo -e "📊 RAM:     ${used_mem}MB/${total_mem}MB (${mem_percent}%)"
-    echo -e "💾 SWAP:    ${swap_used}MB/${swap_total}MB (${swap_percent}%)"
-    echo -e "🌐 Browser processes: $browser_count"
-    echo -e "${BLUE}══════════════════════════════════${NC}"
-}
-
-# Base64 URL decode
-base64_url_decode() {
-    local s="$1"
-    s=$(echo "$s" | sed 's/_/\//g; s/-/+/g')
-    local pad=$((4 - ${#s} % 4))
-    if [ $pad -lt 4 ]; then
-        s="${s}$(printf '=%.0s' $(seq 1 $pad))"
-    fi
-    echo "$s" | base64 -d
-}
-
-# Base64 URL encode
-base64_url_encode() {
-    echo -n "$1" | base64 | tr -d '\n' | sed 's/=*$//; s/\//_/g; s/\+/-/g'
-}
-
-# IP Swapping Engine (same as Flask API)
-swap_ip_in_url() {
-    local original_url="$1"
-    local new_ip="$2"
-    
-    [[ -z "$original_url" || -z "$new_ip" ]] && return 1
-    
-    # Parse the URL
-    local scheme=$(echo "$original_url" | awk -F: '{print $1}')
-    local host_port_path=$(echo "$original_url" | sed -E "s|^${scheme}://||")
-    local host=$(echo "$host_port_path" | awk -F/ '{print $1}' | awk -F: '{print $1}')
-    local port=$(echo "$host_port_path" | awk -F/ '{print $1}' | awk -F: '{print $2}')
-    local path_query=$(echo "$host_port_path" | sed -E "s|^[^/]*||")
-    
-    # Replace IP in host
-    local new_netloc="$new_ip"
-    [ -n "$port" ] && new_netloc="$new_netloc:$port"
-    
-    # Process query parameters
-    local query=$(echo "$path_query" | grep -oP '\?.*' | sed 's/^//')
-    local new_query=""
-    
-    if [ -n "$query" ]; then
-        IFS='&' read -ra params <<< "$query"
-        for param in "${query[@]}"; do
-            local key=$(echo "$param" | cut -d'=' -f1)
-            local value=$(echo "$param" | cut -d'=' -f2-)
+]
+
+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('=')
+
+def swap_ip_in_url(template_url, new_ip):
+    try:
+        # Split URL into base and query string
+        base_url = template_url.split('?')[0]
+        query_string = '?'.join(template_url.split('?')[1:]) if '?' in template_url else ''
+        
+        # Extract original IP
+        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
+        old_ip = old_ip_match.group(0)
+        
+        # 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
+                    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)
+                        
+                        if decoded_r:
+                            # Replace IP in decoded value
+                            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)
+                        else:
+                            new_values.append(value)
+                    except:
+                        new_values.append(value)
+                else:
+                    new_values.append(value)
             
-            if [ "$key" = "r" ]; then
-                # Decode and process r parameter
-                local decoded_r "$value")
-                if [ -n "$decoded_r" ]; then
-                    # Replace IP in decoded r value
-                    local new_decoded_r | sed "s/$host/$new_ip/g")
-                    # Re-encode value
-                    value=$(base64_url_encode "$modified_r")
-                fi
-                fi
-            fi
-            new_query="${new_query}&${key}=${value}"
-        done
-        new_query="${new_query:1}"
-    fi
+            new_params[key] = new_values
+        
+        # Rebuild query string
+        new_query = urlencode(new_params, doseq=True)
+        
+        return f"{new_base_url}?{new_query}"
     
-    # Reconstruct URL
-    echo "${scheme}://${new_netloc}${path_query%%\?*}${new_query:+?$new_query}"
-}
+    except Exception as e:
+        print(f"Error processing URL: {str(e)}")
+        return None
 
-# Generate URLs
-generate_urls() {
-    log "${CYAN}🔄 Generating fresh URLs...${NC}"
-    
-    if [ ! -s "$TEMPLATE_FILE" ] || grep -q "^#" "$TEMPLATE_FILE"; then
-        log "${RED}❌ No template URL! Use option 2 first.${NC}"
-        return 1
-    fi
-    
-    local template_url=$(grep -v "^#" "$TEMPLATE_FILE" | head -1)
-    
-    # Create temporary file first
-    local temp_file="$GENERATED_URLS_FILE.tmp"
-    rm -f "$temp_file"
-    touch "$temp_file"
+@app.route('/')
+def home():
+    return "IP Swapper API is running. Use POST /generate with JSON payload."
+
+@app.route('/generate', methods=['POST'])
+def generate_urls():
+    data = request.get_json()
     
-    local count=0
-    local success_count=0
+    if not data or 'template_url' not in data:
+        return jsonify({"error": "template_url is required"}), 400
     
-    for ip in "${HARDCODED_IPS[@]}"; do
-        ((count++))
-        local new_url=$(swap_ip_in_url "$template_url" "$ip")
-        
-        if [[ -n "$new_url" ]]; then
-            echo "$new_url" >> "$temp_file"
-            ((success_count++))
-        else
-            log "${RED}❌ Failed to generate URL for IP: $ip${NC}"
-        fi
-    done
+    template_url = data['template_url'].strip()
     
-    # Atomic replace
-    if [ -s "$temp_file" ]; then
-        mv -f "$temp_file" "$GENERATED_URLS_FILE"
-        log "${GREEN}✅ Generated $success_count/$count URLs${NC}"
-    else
-        log "${RED}❌ CRITICAL: No URLs generated!${NC}"
-        return 1
-    fi
+    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)
     
-    return 0
-}
+    return jsonify({"generated_urls": results})
 
-# ... rest of the script remains the same ...
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860, threaded=True)