Added /api/status endpoint with dynamic region and latency monitoring

api.py

@@ -5,6 +5,7 @@ import os
 import random
 from src.crawler import Crawler
 from src.analyzer import ImageAnalyzer
+from src.monitor import SystemMonitor
 
 app = Flask(__name__)
 CORS(app)
@@ -13,12 +14,20 @@ REPORT_FILE = 'seo_report.json'
 
 @app.route('/')
 def home():
-    return "Antigravity API is Running. Use /health to check status."
+    return "Antigravity API is Running. Use /api/status for system info."
 
 @app.route('/health')
 def health_check():
     return jsonify({"status": "alive"}), 200
 
+@app.route('/api/status', methods=['GET'])
+def get_system_status():
+    """
+    Returns real-time system metadata including dynamic region and latency.
+    """
+    stats = SystemMonitor.get_system_stats()
+    return jsonify(stats)
+
 @app.route('/api/seo-report', methods=['GET', 'POST'])
 def get_seo_report():
     # Cache variable attached to function to persist state

src/monitor.py

@@ -0,0 +1,83 @@
+import requests
+import time
+import socket
+
+class SystemMonitor:
+    _region_cache = None
+    _engine_version = "AutoAlt Neural v2"
+
+    @staticmethod
+    def get_region():
+        """
+        Fetches the server's current region/city using a GeoIP service.
+        Cached for the lifetime of the application to avoid rate limits.
+        """
+        if SystemMonitor._region_cache:
+            return SystemMonitor._region_cache
+
+        try:
+            # high-performance, free GeoIP API
+            response = requests.get("http://ip-api.com/json", timeout=3)
+            if response.status_code == 200:
+                data = response.json()
+                # User example showed "Frankfurt", which is a city.
+                # We can combine City, Country for clarity or just City.
+                city = data.get("city", "Unknown")
+                country = data.get("countryCode", "")
+                
+                # Check for cloud provider hints in ISP if needed, but City is usually what people mean by 'Region' in this context
+                region = f"{city}, {country}" if country else city
+                SystemMonitor._region_cache = region
+                return region
+        except Exception as e:
+            print(f"Region detection failed: {e}")
+            return "Unknown (Network Restricted)"
+        
+        return "Unknown"
+
+    @staticmethod
+    def get_latency():
+        """
+        Calculates the system's network latency by timing a request to a reliable backbone (Google).
+        Returns latency in milliseconds (int).
+        """
+        try:
+            # Measure reliable external connection time
+            start = time.time()
+            # Fast HEAD request to Google
+            requests.head("https://www.google.com", timeout=2)
+            end = time.time()
+            
+            # Convert to ms and round
+            latency_ms = int((end - start) * 1000)
+            return latency_ms
+        except Exception:
+            # Retry with a socket method if HTTP fails (sometimes faster/allowed)
+            try:
+                start = time.time()
+                socket.create_connection(("8.8.8.8", 53), timeout=2)
+                end = time.time()
+                return int((end - start) * 1000)
+            except:
+                return 999 # High latency/timeout indicator
+
+    @staticmethod
+    def get_status():
+        """
+        Simple self-diagnostic status.
+        """
+        # If we can reach external network, we are operational.
+        # We could add more checks (disk space, memory) if needed.
+        latency = SystemMonitor.get_latency()
+        if latency < 999:
+            return "operational"
+        return "degraded_connectivity"
+
+    @staticmethod
+    def get_system_stats():
+        return {
+            "region": SystemMonitor.get_region(),
+            "latency": SystemMonitor.get_latency(),
+            "status": SystemMonitor.get_status(),
+            "engine": SystemMonitor._engine_version
+        }