Update main.py

main.py

@@ -3,25 +3,22 @@ import sys
 import time
 import asyncio
 import importlib.util
-import uvicorn
+import uvicorn  # Programmatic bootstrapper
 
 # =====================================================================
-# 1. CORE ARCHITECTURE & PERMANENT RUNTIME PATHS
+# 1. CRITICAL PATH INJECTION FIX (Matched to Root Repository Layout)
 # =====================================================================
 CURRENT_BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-OUTPUT_DIR = os.path.join(CURRENT_BASE_DIR, "output")
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-# 🚨 PR FIX 1: Paths must be permanently appended for runtime lazy-imports
-if CURRENT_BASE_DIR not in sys.path:
-    sys.path.insert(0, CURRENT_BASE_DIR)
+VERSION_1_PATH = os.path.join(CURRENT_BASE_DIR, "Version_1")
+# 🔥 FIXED: Added spaces around the hyphen to match your exact directory name
+VERSION_2_PATH = os.path.join(CURRENT_BASE_DIR, "Version_2 - Copy")
+VERSION_3_PATH = os.path.join(CURRENT_BASE_DIR, "Version_3")
+VERSION_4_PATH = os.path.join(CURRENT_BASE_DIR, "Version_4")
+VERSION_5_PATH = os.path.join(CURRENT_BASE_DIR, "Version_5")
 
-# Append sub-engines to the END of sys.path. 
-# This keeps them available for runtime execution without overriding root namespaces.
-for engine_dir in ["Version_1", "Version_2", "Version_3", "Version_4", "Version_5"]:
-    engine_path = os.path.join(CURRENT_BASE_DIR, engine_dir)
-    if os.path.exists(engine_path) and engine_path not in sys.path:
-        sys.path.append(engine_path)
+for path in [CURRENT_BASE_DIR, VERSION_1_PATH, VERSION_2_PATH, VERSION_3_PATH, VERSION_4_PATH, VERSION_5_PATH]:
+    if os.path.exists(path) and path not in sys.path:
+        sys.path.insert(0, path)
 
 # =====================================================================
 # 2. FRAMEWORK & CORE ENGINE IMPORTS
@@ -31,40 +28,66 @@ import xgboost as xgb
 from fastapi import FastAPI, HTTPException, APIRouter
 from pydantic import BaseModel, Field
 from typing import Dict, Any
-from dataclasses import asdict
 from playwright.async_api import async_playwright
-from fastapi.middleware.cors import CORSMiddleware
 
-# Initialize core application gateway
+# Version 4 Imports
+try:
+    from Version_4.features import extract_url_features
+except ModuleNotFoundError:
+    from features import extract_url_features
+
+# Version 5 Imports
+try:
+    from Version_5.src.dom_scraper import extract_dom_features
+    from Version_5.src.sub_agents import (
+        agent_url_analyst, 
+        agent_html_structure, 
+        agent_content_semantics, 
+        agent_brand_impersonation
+    )
+    from Version_5.src.orchestrator import evaluate_consensus, run_judge
+except Exception as e:
+    print(f"[-] Warning: Could not import Version 5 modules: {e}")
+
+# =====================================================================
+# 3. INITIALIZE MASTER APP GATEWAY
+# =====================================================================
+from fastapi.middleware.cors import CORSMiddleware
 app = FastAPI(
     title="Master Threat Intelligence Hub Gateway",
-    description="Unified routing architecture managing deployed sub-engines: V1 through V6."
+    description="The ultimate, fully unified routing architecture managing deployments: V1, V2, V3, V4, V5, and V6."
 )
 
+# 🔥 UPDATED: Expanded CORS configurations to allow frontend origins (local, HF Space, and Netlify)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], 
-    allow_credentials=False, 
+    allow_origins=[
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "https://atharvawarade9807-duplicate.hf.space",
+        "https://*.netlify.app",  # or your exact Netlify URL after deploy
+    ],
+    allow_credentials=False,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+OUTPUT_DIR = os.path.join(CURRENT_BASE_DIR, "output")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
 # =====================================================================
-# [ ENGINE 1 ] VERSION 1: HEURISTICS
+# [ ENGINE 1 ] VERSION 1: LEGACY MODEL 
 # =====================================================================
-# 🚨 PR FIX 3: Consolidated imports. Loading app and process_payload together to utilize sys.modules cache.
 try:
-    from Version_1.main import app as v1_app, process_payload as v1_process
+    from Version_1.main import app as v1_app
     app.include_router(v1_app.router, tags=["Version 1: Legacy Model"])
     print("[+] Successfully merged Version 1 into root UI")
 except Exception as e:
-    v1_process = None
     print(f"[-] Could not merge Version 1. Error: {e}")
 
 # =====================================================================
-# [ ENGINE 2 ] VERSION 2: VISUAL RESNET18
+# [ ENGINE 2 ] VERSION 2: VISUAL RESNET18 PHISHING DETECTOR
 # =====================================================================
-VERSION_2_PATH = os.path.join(CURRENT_BASE_DIR, "Version_2")
 v2_router = APIRouter(prefix="/api/v2", tags=["Version 2: Visual ResNet18 Engine"])
 
 class V2VisionRequest(BaseModel):
@@ -76,16 +99,16 @@ v2_capture_screenshot = None
 try:
     print("[*] Attempting to load Version 2 visual engine...")
     v2_main_path = os.path.join(VERSION_2_PATH, "main.py")
-    if os.path.exists(v2_main_path):
-        spec = importlib.util.spec_from_file_location("v2_main", v2_main_path)
-        v2_main = importlib.util.module_from_spec(spec)
-        sys.modules["v2_main"] = v2_main
-        spec.loader.exec_module(v2_main)
-        
-        V2_MODEL_PATH = os.path.join(VERSION_2_PATH, "models", "production_resnet_ema.pth")
-        v2_analyzer = v2_main.ProductionAnalyzer(model_path=V2_MODEL_PATH)
-        v2_capture_screenshot = v2_main.capture_screenshot
-        print("[+] Successfully initialized Version 2 ResNet18 visual engine.")
+    
+    spec = importlib.util.spec_from_file_location("v2_main", v2_main_path)
+    v2_main = importlib.util.module_from_spec(spec)
+    sys.modules["v2_main"] = v2_main
+    spec.loader.exec_module(v2_main)
+    
+    V2_MODEL_PATH = os.path.join(VERSION_2_PATH, "models", "production_resnet_ema.pth")
+    v2_analyzer = v2_main.ProductionAnalyzer(model_path=V2_MODEL_PATH)
+    v2_capture_screenshot = v2_main.capture_screenshot
+    print("[+] Successfully initialized Version 2 ResNet18 visual engine.")
 except Exception as e:
     print(f"[-] Could not load Version 2 visual engine. Error: {e}")
 
@@ -103,8 +126,9 @@ async def analyze_url_vision(payload: V2VisionRequest):
 
     try:
         screenshot_file = await v2_capture_screenshot(url, temp_img_path)
+
         if not screenshot_file or not os.path.exists(screenshot_file):
-            raise HTTPException(status_code=502, detail="Failed to capture page frame.")
+            raise HTTPException(status_code=502, detail="Failed to capture screenshot. The target may be offline.")
 
         result = v2_analyzer.analyze_image(screenshot_file)
         latency_ms = (time.perf_counter() - start_time) * 1000
@@ -112,9 +136,11 @@ async def analyze_url_vision(payload: V2VisionRequest):
         if "error" in result:
             raise HTTPException(status_code=500, detail=result["error"])
 
+        verdict = "QUARANTINE" if result["prediction"] == "Phishing" else "PASS"
+
         return {
             "target_url": url,
-            "verdict": "QUARANTINE" if result["prediction"] == "Phishing" else "PASS",
+            "verdict": verdict,
             "raw_prediction": result["prediction"],
             "confidence": result["confidence"],
             "latency_ms": round(latency_ms, 2)
@@ -126,13 +152,14 @@ async def analyze_url_vision(payload: V2VisionRequest):
 app.include_router(v2_router)
 
 # =====================================================================
-# [ ENGINE 3 ] VERSION 3: CONTENT TEXT SVM
+# [ ENGINE 3 ] VERSION 3: LEGACY ONNX MODEL 
 # =====================================================================
 try:
     print("[*] Attempting to load Version 3...")
     from Version_3.main import app as v3_app
     app.mount("/scan", v3_app, name="v3_email")
     print("[+] Successfully merged Version 3 email scanner")
+    print("[+] Successfully merged Version 3 into root UI")
 except Exception as e:
     print(f"[-] Could not merge Version 3. Error: {e}")
 
@@ -144,7 +171,6 @@ v4_router = APIRouter(prefix="/api/v4", tags=["Version 4: XGBoost Engine"])
 class XGBoostRequest(BaseModel):
     url: str = Field(..., description="Target URL to evaluate via structural feature mapping", example="google.com")
 
-VERSION_4_PATH = os.path.join(CURRENT_BASE_DIR, "Version_4")
 MODEL_PATH = os.path.join(VERSION_4_PATH, "models", "final_model.json")
 if os.path.exists(MODEL_PATH):
     bst = xgb.Booster()
@@ -153,14 +179,6 @@ else:
     bst = None
     print(f"[-] Warning: {MODEL_PATH} not found. V4 engine will return a configuration error.")
 
-try:
-    from Version_4.features import extract_url_features
-except ModuleNotFoundError:
-    try:
-        from features import extract_url_features
-    except ModuleNotFoundError:
-        pass # Fails loudly at runtime endpoint as intended
-
 @v4_router.post("/evaluate")
 async def evaluate_xgboost_url(payload: XGBoostRequest):
     if bst is None:
@@ -178,9 +196,11 @@ async def evaluate_xgboost_url(payload: XGBoostRequest):
         features = extract_url_features(processed_url)
         dmatrix_payload = xgb.DMatrix(np.array([features]))
         
+        # This is the "Safeness" probability (1.0 = Safe, 0.0 = Phishing)
         safeness_prob = float(bst.predict(dmatrix_payload)[0])
         latency_ms = (time.perf_counter() - start_time) * 1000
 
+        # INVERTED LOGIC: Low safeness means high phishing risk
         if safeness_prob < 0.50:
             verdict = "🚨 PHISHING DETECTED"
             confidence = (1.0 - safeness_prob) * 100
@@ -197,23 +217,70 @@ async def evaluate_xgboost_url(payload: XGBoostRequest):
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Structural evaluation failure: {str(e)}")
-
 app.include_router(v4_router)
 
 # =====================================================================
 # [ ENGINE 5 ] VERSION 5: AGENTIC MULTI-SPECIALIST FORENSIC PANEL 
 # =====================================================================
-# 🚨 PR FIX 2: Restored visibility of internal V5 dependencies for architectural tracking
-try:
-    from Version_5.src.dom_scraper import extract_dom_features
-    from Version_5.src.orchestrator import evaluate_consensus
+v5_router = APIRouter(prefix="/api/v5", tags=["Version 5: Agentic Panel"])
+
+class ThreatAnalysisRequest(BaseModel):
+    url: str = Field(..., description="Target landing page URL to analyze", example="http://example-verify-login.com")
+    sender: str = Field(..., description="Alleged sender address header", example="security@paypal.com")
+    email_body: str = Field(..., description="Full text/body payload of the incoming message")
+
+@v5_router.post("/predict")
+async def analyze_payload_endpoint(payload: ThreatAnalysisRequest):
+    url = payload.url.strip()
+    sender = payload.sender.strip()
+    email_body = payload.email_body.strip()
     
-    # Internal dependencies verified, mounting encapsulated router
-    from Version_5.app import router as v5_router
-    app.include_router(v5_router, prefix="/api/v5", tags=["Version 5: Agentic Panel"])
-    print("[+] Successfully merged Version 5 Agentic panel into gateway.")
-except Exception as e:
-    print(f"[-] Could not load Version 5 Agentic engine. Missing dependencies: {e}")
+    if not url and not email_body:
+        raise HTTPException(status_code=400, detail="Provide at least a validation URL or a message body.")
+        
+    try:
+        start_time = time.perf_counter()
+        dom_data = extract_dom_features(url)
+        
+        reports = {
+            "URL_Agent": agent_url_analyst(url),
+            "HTML_Agent": agent_html_structure(dom_data),
+            "Content_Agent": agent_content_semantics(email_body),
+            "Brand_Agent": agent_brand_impersonation(email_body, sender)
+        }
+        
+        consensus_victory = evaluate_consensus(reports)
+        
+        if consensus_victory:
+            final_verdict = {
+                "verdict": reports["URL_Agent"].claim if hasattr(reports["URL_Agent"], 'claim') else str(reports["URL_Agent"]),
+                "confidence_score": reports["URL_Agent"].confidence if hasattr(reports["URL_Agent"], 'confidence') else 1.0,
+                "justification": "Bypassed judicial review due to absolute sub-agent unanimity across forensics."
+            }
+        else:
+            reports_str = "\n".join([f"[{name}]\n{r.model_dump_json(indent=2) if hasattr(r, 'model_dump_json') else str(r)}" for name, r in reports.items()])
+            raw_data = f"Target URL: {url}\nTarget Sender: {sender}\nBody: {email_body}"
+            judge_verdict = run_judge(reports_summary=reports_str, raw_data=raw_data)
+            final_verdict = judge_verdict.model_dump() if hasattr(judge_verdict, 'model_dump') else judge_verdict
+            
+        latency_ms = (time.perf_counter() - start_time) * 1000
+        
+        serializable_reports = {}
+        for name, report in reports.items():
+            serializable_reports[name] = report.model_dump() if hasattr(report, "model_dump") else str(report)
+
+        return {
+            "target_url": url,
+            "target_sender": sender,
+            "consensus_reached": consensus_victory,
+            "latency_ms": round(latency_ms, 2),
+            "sub_agent_claims": serializable_reports,
+            "final_evaluation": final_verdict
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal agent execution crash: {str(e)}")
+
+app.include_router(v5_router)
 
 # =====================================================================
 # [ ENGINE 6 ] VERSION 6: INTERACTIVE THREAT COGNITIVE SANDBOX
@@ -288,9 +355,13 @@ async def gateway_status():
         "loaded_engines": ["V1", "V2", "V3", "V4", "V5", "V6"]
     }
 
+
 # =====================================================================
 # [ MASTER FUSION ENGINE ] COMBINES V1, V2 (CNN), and V4 (XGBoost)
 # =====================================================================
+from Version_1.main import process_payload as v1_process
+from dataclasses import asdict
+
 class UnifiedRequest(BaseModel):
     url: str
 
@@ -302,7 +373,7 @@ async def unified_scan_endpoint(payload: UnifiedRequest):
 
     start_time = time.perf_counter()
     
-    # 1. Run V1 (Heuristics) - Will crash loudly via 500 error if offline as intended for security
+    # 1. Run V1 (Heuristics)
     v1_matrix = await v1_process(url)
     v1_score = v1_matrix.composite_score
     
@@ -315,17 +386,20 @@ async def unified_scan_endpoint(payload: UnifiedRequest):
             dmatrix_payload = xgb.DMatrix(np.array([features]))
             
             raw_safeness = float(bst.predict(dmatrix_payload)[0])
+            
+            # INVERT TO RISK: If safeness is 0.99 (Google), risk becomes 0.01 (1%)
             v4_score = 1.0 - raw_safeness 
+            
             v4_msg = f"XGBoost Match: {round(v4_score * 100, 1)}% Phishing Risk"
     except Exception as e:
         v4_msg = f"V4 Error: {str(e)}"
-
     # 3. Run V2 (CNN ResNet18) - Wrapped securely to prevent timeout crashes
     v2_score = 0.0
     v2_msg = "Skipped (Timeout Prevention)"
     try:
         if v2_analyzer is not None and v2_capture_screenshot is not None:
             temp_img = os.path.join(OUTPUT_DIR, f"fusion_{int(time.time()*1000)}.png")
+            # Set a strict timeout so Playwright doesn't hang the server
             screenshot = await asyncio.wait_for(v2_capture_screenshot(url, temp_img), timeout=10.0)
             if screenshot and os.path.exists(screenshot):
                 result = v2_analyzer.analyze_image(screenshot)
@@ -337,10 +411,12 @@ async def unified_scan_endpoint(payload: UnifiedRequest):
     except Exception as e:
         v2_msg = f"V2 Vision Unavailable"
 
-    # 4. Calculate the Master Risk Score
+    # 4. Calculate the Master Risk Score (Dynamic Weights)
     if "Skipped" in v2_msg or "Unavailable" in v2_msg:
+        # If CNN times out, re-balance weights so a dummy 0.0 doesn't dilute the risk
         master_score = (v1_score * 0.5) + (v4_score * 0.5)
     else:
+        # Standard 40/40/20 split
         master_score = (v1_score * 0.4) + (v4_score * 0.4) + (v2_score * 0.2)
         
     latency = (time.perf_counter() - start_time) * 1000
@@ -349,7 +425,7 @@ async def unified_scan_endpoint(payload: UnifiedRequest):
     return {
         "composite_score": master_score,
         "latency_ms": round(latency, 2),
-        "layer_scores": asdict(v1_matrix.layer_scores), 
+        "layer_scores": asdict(v1_matrix.layer_scores), # Safely unpacks the dataclass
         "details": {
             "xgboost_analysis": {"score": v4_score, "message": v4_msg},
             "cnn_visual_analysis": {"score": v2_score, "message": v2_msg}
@@ -363,6 +439,7 @@ if __name__ == "__main__":
     print("[*] Resolving path mapping vectors securely...")
     print(f"[+] Directing Uvicorn to look inside application anchor: {CURRENT_BASE_DIR}")
     
+    # 🔥 FIXED: Points directly to port 7860 for Hugging Face standard routing context
     uvicorn.run(
         "main:app",
         host="0.0.0.0",