Update app/app.py

app/app.py

@@ -1,54 +1,43 @@
 """
-Sentinel Arbitrage Engine - v12.0 FINAL (Correct Mount)
+Sentinel Arbitrage Engine - v13.0 OMEGA (File-Based & Unbreakable)
 
-This version uses the robust singleton broker pattern and correctly mounts
-the Socket.IO application to the path expected by the client, ensuring
-a successful real-time connection.
+This version uses a file-based log for absolute signal persistence and
+a high-frequency polling mechanism for guaranteed data delivery.
 """
 import asyncio
 import os
-from contextlib import asynccontextmanager
 import json
 import time
+from contextlib import asynccontextmanager
 from datetime import datetime, timezone
-
 import httpx
-import socketio
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
+from fastapi.responses import FileResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
 
-# --- IMPORTS ---
-# Correctly use relative imports for our local package structure
+# --- RELATIVE IMPORTS ---
 from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
-from .broker import signal_broker # Using the robust singleton broker
 
 OPPORTUNITY_THRESHOLD = 0.0015
+SIGNALS_FILE = "signals.json"
 
-# --- SOCKET.IO SERVER SETUP ---
-# This creates the server instance that will handle WebSocket connections
-sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
-# This wraps the Socket.IO server in an ASGI application
-socket_app = socketio.ASGIApp(sio)
-
-
-# --- APPLICATION LIFESPAN ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Manages the application's startup and shutdown procedures."""
-    print("🚀 Initializing Sentinel Arbitrage Engine v12.0...")
+    # Clear the log on startup
+    if os.path.exists(SIGNALS_FILE):
+        os.remove(SIGNALS_FILE)
+    
     async with httpx.AsyncClient() as client:
-        # We can store these on the app state, but the broker handles the critical part
         app.state.price_fetcher = PriceFetcher(client)
         app.state.arbitrage_analyzer = ArbitrageAnalyzer(client)
         
-        # Launch the engine as a background task
         arbitrage_task = asyncio.create_task(
             run_arbitrage_detector(app.state.price_fetcher, app.state.arbitrage_analyzer)
         )
         
-        print("✅ Engine is online and hunting for opportunities.")
-        yield # Application runs here
+        print("🚀 Sentinel Arbitrage Engine v13.0 (File-Based) started.")
+        yield
         
         print("⏳ Shutting down engine...")
         arbitrage_task.cancel()
@@ -56,7 +45,7 @@ async def lifespan(app: FastAPI):
         except asyncio.CancelledError: print("Engine shut down gracefully.")
 
 async def run_arbitrage_detector(price_fetcher, analyzer):
-    """The core engine loop; detects opportunities and puts them in the broker queue."""
+    """The core engine loop. Detects opportunities and writes them to a file."""
     while True:
         try:
             await price_fetcher.update_prices_async()
@@ -73,41 +62,69 @@ async def run_arbitrage_detector(price_fetcher, analyzer):
                             "asset": asset, "pyth_price": pyth_price,
                             "chainlink_price": chainlink_price, "spread_pct": spread * 100
                         }
-                        print(f"⚡️ Dislocation for {asset}: {opportunity['spread_pct']:.3f}%")
                         briefing = await analyzer.get_alpha_briefing(asset, opportunity)
                         if briefing:
                             signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
-                            await signal_broker.queue.put(signal)
-                            print(f"✅ Signal Emitted via Broker: {signal['strategy']}")
+                            
+                            # --- THE FIX: Write signal directly to the JSON file ---
+                            try:
+                                with open(SIGNALS_FILE, 'r+') as f:
+                                    data = json.load(f)
+                                    data.insert(0, signal) # Prepend new signal
+                                    f.seek(0)
+                                    json.dump(data, f, indent=4)
+                            except (FileNotFoundError, json.JSONDecodeError):
+                                with open(SIGNALS_FILE, 'w') as f:
+                                    json.dump([signal], f, indent=4)
+                            
+                            print(f"✅ Signal LOGGED for {asset}: {signal['spread_pct']:.3f}%")
         except Exception as e:
             print(f"❌ ERROR in engine loop: {e}")
 
         await asyncio.sleep(15)
 
-# --- FASTAPI APP SETUP ---
+# --- FastAPI App Setup ---
 app = FastAPI(lifespan=lifespan)
 
-# --- SOCKET.IO EVENT HANDLERS ---
-@sio.event
-async def connect(sid, environ):
-    """Handles new client connections."""
-    print(f"✅ Client connected: {sid}")
-    # We can even send a welcome message here if we want
-    await sio.emit('welcome', {'message': 'Connection to Sentinel Engine established!'}, to=sid)
+# --- API Endpoints ---
+@app.get("/api/signals", response_class=HTMLResponse)
+async def get_signals_table(request: Request):
+    """Reads the signals file and renders the table body."""
+    try:
+        with open(SIGNALS_FILE, 'r') as f:
+            signals = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        signals = []
+
+    if not signals:
+        return HTMLResponse('<tr id="placeholder-row"><td colspan="7" style="text-align:center;">Monitoring for arbitrage opportunities...</td></tr>')
+
+    table_rows = []
+    total_profit = 0
+    for s in signals:
+        pyth_class = "buy" if s['pyth_price'] < s['chainlink_price'] else "sell"
+        chainlink_class = "sell" if s['pyth_price'] < s['chainlink_price'] else "buy"
+        profit = (s['chainlink_price'] - s['pyth_price']) if pyth_class == 'buy' else (s['pyth_price'] - s['chainlink_price'])
+        profit_after_fees = profit * (1 - 0.002) # Assume 0.2% total fees
+        total_profit += profit_after_fees
 
-@sio.event
-async def disconnect(sid):
-    """Handles client disconnections."""
-    print(f"🔥 Client disconnected: {sid}")
+        table_rows.append(f"""
+        <tr>
+            <td>{datetime.fromisoformat(s['timestamp']).strftime('%H:%M:%S')}</td>
+            <td><strong>{s['asset']}/USD</strong></td>
+            <td><span class="{pyth_class}">Pyth</span><br>${s['pyth_price']:,.2f}</td>
+            <td><span class="{chainlink_class}">Agg.</span><br>${s['chainlink_price']:,.2f}</td>
+            <td><strong>{s['spread_pct']:.3f}%</strong></td>
+            <td><span class="risk-{s.get('risk', 'low').lower()}">{s.get('risk', 'N/A')}</span></td>
+            <td>{s.get('strategy', 'N/A')}</td>
+        </tr>
+        """)
+    
+    # Use OOB swap to update the P/L ticker
+    profit_html = f'<span id="pnl-ticker" hx-swap-oob="true">Simulated P/L: <span style="color: #34D399;">${total_profit:,.2f}</span></span>'
 
-# --- THE CRITICAL FIX ---
-# Mount the Socket.IO application at the path the client expects ('/socket.io/').
-# This MUST come before the root static file mount.
-app.mount('/socket.io', socket_app)
+    return HTMLResponse(profit_html + "".join(table_rows))
 
-# Mount the static directory to serve index.html at the root path "/".
-app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
-# We no longer need the old SSE endpoint, as Socket.IO handles everything.
-# The `run_arbitrage_detector` now emits directly to clients,
-# and the `static/index.html`'s JavaScript listens for these events.
+# Serve the static files (like index.html) from the 'static' directory
+app.mount("/", StaticFiles(directory="static", html=True), name="static")