Update app.py

app.py

@@ -1,96 +1,252 @@
-from flask import Flask, request, jsonify
-import base64
-from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
-from concurrent.futures import ThreadPoolExecutor
-
-app = Flask(__name__)
-
-# Hardcoded list of 19 IP addresses
-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",
+#!/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"
     "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('=')
-
-def replace_ip_in_url(original_url, new_ip):
-    try:
-        parsed = urlparse(original_url)
-        netloc = new_ip + (':' + str(parsed.port) if parsed.port else '')
-        
-        query_params = parse_qs(parsed.query, keep_blank_values=True)
-        
-        if 'r' in query_params:
-            r_value = query_params['r'][0]
-            try:
-                decoded_r = base64_url_decode(r_value)
-                parsed_r = urlparse(decoded_r)
-                netloc_r = new_ip + (':' + str(parsed_r.port) if parsed_r.port else '')
-                modified_r_url = urlunparse((
-                    parsed_r.scheme,
-                    netloc_r,
-                    parsed_r.path,
-                    parsed_r.params,
-                    parsed_r.query,
-                    parsed_r.fragment
-                ))
-                new_r_value = base64_url_encode(mod_r_r)
-                query_params['r'] = [new_r_value]
-            except Exception:
-                pass
-        
-        new_query = urlencode(query_params, doseq=True)
-        
-        return urlunparse((
-            parsed.scheme,
-            netloc,
-            parsed.path,
-            parsed.params,
-            new_query,
-            parsed.fragment
-        ))
+)
+
+# ⚙️ 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
     
-    except Exception as e:
-        return f"Error: {str(e)}"
+    log "${GREEN}✅ Setup verified - Template: OK, Firefox: OK${NC}"
+    return 0
+}
 
-@app.route('/generate', methods=['POST'])
-def generate_urls():
-    data = request.get_json()
+# 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|^[^/]*||")
     
-    if not data or 'template_url' not in data:
-        return jsonify({"error": "template_url is required"}), 400
+    # Replace IP in host
+    local new_netloc="$new_ip"
+    [ -n "$port" ] && new_netloc="$new_netloc:$port"
     
-    template_url = data['template_url']
+    # 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-)
+            
+            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
+    
+    # Reconstruct URL
+    echo "${scheme}://${new_netloc}${path_query%%\?*}${new_query:+?$new_query}"
+}
+
+# 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"
+    
+    local count=0
+    local success_count=0
+    
+    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
     
-    with ThreadPoolExecutor() as executor:
-        results = list(executor.map(lambda ip: replace_ip_in_url(template_url, ip), HARDCODED_IPS))
+    # 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
     
-    return jsonify({"generated_urls": results})
+    return 0
+}
 
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, threaded=True)
+# ... rest of the script remains the same ...