266 lines
8.5 KiB
Python
266 lines
8.5 KiB
Python
#////////// PROJECT FILE SEPARATION LINE ////////// CODE AFTER THIS LINE ARE FROM: <ProjectRoot>/Data/server.py
|
|
|
|
import eventlet
|
|
# Monkey-patch stdlib for cooperative sockets
|
|
eventlet.monkey_patch()
|
|
|
|
import requests
|
|
from flask import Flask, request, jsonify, Response, send_from_directory, make_response
|
|
from flask_socketio import SocketIO, emit
|
|
from flask_cors import CORS
|
|
|
|
import time
|
|
import os # To Read Production ReactJS Server Folder
|
|
|
|
# Borealis Python API Endpoints
|
|
from Python_API_Endpoints.ocr_engines import run_ocr_on_base64
|
|
|
|
# ---------------------------------------------
|
|
# Flask + WebSocket Server Configuration
|
|
# ---------------------------------------------
|
|
app = Flask(
|
|
__name__,
|
|
static_folder=os.path.join(os.path.dirname(__file__), '../web-interface/build'),
|
|
static_url_path=''
|
|
)
|
|
|
|
# Enable CORS on All Routes
|
|
CORS(app)
|
|
|
|
socketio = SocketIO(
|
|
app,
|
|
cors_allowed_origins="*",
|
|
async_mode="eventlet",
|
|
engineio_options={
|
|
'max_http_buffer_size': 100_000_000,
|
|
'max_websocket_message_size': 100_000_000
|
|
}
|
|
)
|
|
|
|
# ---------------------------------------------
|
|
# Serve ReactJS Production Vite Build from dist/
|
|
# ---------------------------------------------
|
|
@app.route('/', defaults={'path': ''})
|
|
@app.route('/<path:path>')
|
|
def serve_dist(path):
|
|
full_path = os.path.join(app.static_folder, path)
|
|
if path and os.path.isfile(full_path):
|
|
return send_from_directory(app.static_folder, path)
|
|
else:
|
|
# SPA entry point
|
|
return send_from_directory(app.static_folder, 'index.html')
|
|
|
|
|
|
# ---------------------------------------------
|
|
# Health Check Endpoint
|
|
# ---------------------------------------------
|
|
@app.route("/health")
|
|
def health():
|
|
return jsonify({"status": "ok"})
|
|
|
|
# ---------------------------------------------
|
|
# Borealis Python API Endpoints
|
|
# ---------------------------------------------
|
|
# /api/ocr: Accepts a base64 image and OCR engine selection,
|
|
# and returns extracted text lines.
|
|
@app.route("/api/ocr", methods=["POST"])
|
|
def ocr_endpoint():
|
|
payload = request.get_json()
|
|
image_b64 = payload.get("image_base64")
|
|
engine = payload.get("engine", "tesseract").lower().strip()
|
|
backend = payload.get("backend", "cpu").lower().strip()
|
|
|
|
if engine in ["tesseractocr", "tesseract"]:
|
|
engine = "tesseract"
|
|
elif engine == "easyocr":
|
|
engine = "easyocr"
|
|
else:
|
|
return jsonify({"error": f"OCR engine '{engine}' not recognized."}), 400
|
|
|
|
try:
|
|
lines = run_ocr_on_base64(image_b64, engine=engine, backend=backend)
|
|
return jsonify({"lines": lines})
|
|
except Exception as e:
|
|
return jsonify({"error": str(e)}), 500
|
|
|
|
# ---------------------------------------------
|
|
# Borealis Agent API Endpoints
|
|
# ---------------------------------------------
|
|
# These endpoints handle agent registration, provisioning, and image streaming.
|
|
registered_agents = {}
|
|
agent_configurations = {}
|
|
latest_images = {}
|
|
|
|
@app.route("/api/agents")
|
|
def get_agents():
|
|
return jsonify(registered_agents)
|
|
|
|
@app.route("/api/agent/provision", methods=["POST"])
|
|
def provision_agent():
|
|
data = request.json
|
|
agent_id = data.get("agent_id")
|
|
roles = data.get("roles", [])
|
|
|
|
if not agent_id or not isinstance(roles, list):
|
|
return jsonify({"error": "Missing agent_id or roles[] in provision payload."}), 400
|
|
|
|
config = {"roles": roles}
|
|
agent_configurations[agent_id] = config
|
|
|
|
if agent_id in registered_agents:
|
|
registered_agents[agent_id]["status"] = "provisioned"
|
|
|
|
socketio.emit("agent_config", config)
|
|
return jsonify({"status": "provisioned", "roles": roles})
|
|
|
|
# ---------------------------------------------
|
|
# Borealis External API Proxy Endpoint
|
|
# ---------------------------------------------
|
|
@app.route("/api/proxy", methods=["GET", "POST", "OPTIONS"])
|
|
def proxy():
|
|
target = request.args.get("url")
|
|
if not target:
|
|
return {"error": "Missing ?url="}, 400
|
|
|
|
# Forward method, headers, body
|
|
upstream = requests.request(
|
|
method = request.method,
|
|
url = target,
|
|
headers = {k:v for k,v in request.headers if k.lower() != "host"},
|
|
data = request.get_data(),
|
|
timeout = 10
|
|
)
|
|
|
|
excluded = ["content-encoding","content-length","transfer-encoding","connection"]
|
|
headers = [(k,v) for k,v in upstream.raw.headers.items() if k.lower() not in excluded]
|
|
|
|
resp = make_response(upstream.content, upstream.status_code)
|
|
for k,v in headers:
|
|
resp.headers[k] = v
|
|
return resp
|
|
|
|
# ---------------------------------------------
|
|
# Live Screenshot Viewer for Debugging
|
|
# ---------------------------------------------
|
|
# Serves an HTML canvas that shows real-time screenshots from a given agent+node.
|
|
@app.route("/api/agent/<agent_id>/node/<node_id>/screenshot/live")
|
|
def screenshot_node_viewer(agent_id, node_id):
|
|
return f"""
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Borealis Live View - {agent_id}:{node_id}</title>
|
|
<style>
|
|
body {{
|
|
margin: 0;
|
|
background-color: #000;
|
|
display: flex;
|
|
align-items: center;
|
|
justify-content: center;
|
|
height: 100vh;
|
|
}}
|
|
canvas {{
|
|
border: 1px solid #444;
|
|
max-width: 90vw;
|
|
max-height: 90vh;
|
|
background-color: #111;
|
|
}}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<canvas id="viewerCanvas"></canvas>
|
|
<script src="https://cdn.socket.io/4.8.1/socket.io.min.js"></script>
|
|
<script>
|
|
const agentId = "{agent_id}";
|
|
const nodeId = "{node_id}";
|
|
const canvas = document.getElementById("viewerCanvas");
|
|
const ctx = canvas.getContext("2d");
|
|
const socket = io(window.location.origin, {{ transports: ["websocket"] }});
|
|
|
|
socket.on("agent_screenshot_task", (data) => {{
|
|
if (data.agent_id !== agentId || data.node_id !== nodeId) return;
|
|
const base64 = data.image_base64;
|
|
if (!base64 || base64.length < 100) return;
|
|
|
|
const img = new Image();
|
|
img.onload = () => {{
|
|
if (canvas.width !== img.width || canvas.height !== img.height) {{
|
|
canvas.width = img.width;
|
|
canvas.height = img.height;
|
|
}}
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
|
ctx.drawImage(img, 0, 0);
|
|
}};
|
|
img.src = "data:image/png;base64," + base64;
|
|
}});
|
|
</script>
|
|
</body>
|
|
</html>
|
|
"""
|
|
|
|
# ---------------------------------------------
|
|
# WebSocket Events for Real-Time Communication
|
|
# ---------------------------------------------
|
|
@socketio.on("agent_screenshot_task")
|
|
def receive_screenshot_task(data):
|
|
agent_id = data.get("agent_id")
|
|
node_id = data.get("node_id")
|
|
image = data.get("image_base64", "")
|
|
|
|
if not agent_id or not node_id:
|
|
print("[WS] Screenshot task missing agent_id or node_id.")
|
|
return
|
|
|
|
if image:
|
|
latest_images[f"{agent_id}:{node_id}"] = {
|
|
"image_base64": image,
|
|
"timestamp": time.time()
|
|
}
|
|
|
|
# Emit the full payload, including geometry (even if image is empty)
|
|
emit("agent_screenshot_task", data, broadcast=True)
|
|
|
|
@socketio.on("connect_agent")
|
|
def connect_agent(data):
|
|
agent_id = data.get("agent_id")
|
|
hostname = data.get("hostname", "unknown")
|
|
print(f"Agent connected: {agent_id}")
|
|
|
|
registered_agents[agent_id] = {
|
|
"agent_id": agent_id,
|
|
"hostname": hostname,
|
|
"last_seen": time.time(),
|
|
"status": "orphaned" if agent_id not in agent_configurations else "provisioned"
|
|
}
|
|
|
|
@socketio.on("request_config")
|
|
def send_agent_config(data):
|
|
agent_id = data.get("agent_id")
|
|
config = agent_configurations.get(agent_id)
|
|
if config:
|
|
emit("agent_config", config)
|
|
|
|
@socketio.on("screenshot")
|
|
def receive_screenshot(data):
|
|
agent_id = data.get("agent_id")
|
|
image = data.get("image_base64")
|
|
|
|
if agent_id and image:
|
|
latest_images[agent_id] = {
|
|
"image_base64": image,
|
|
"timestamp": time.time()
|
|
}
|
|
emit("new_screenshot", {"agent_id": agent_id, "image_base64": image}, broadcast=True)
|
|
|
|
@socketio.on("disconnect")
|
|
def on_disconnect():
|
|
print("[WebSocket] Connection Disconnected")
|
|
|
|
# ---------------------------------------------
|
|
# Server Launch
|
|
# ---------------------------------------------
|
|
if __name__ == "__main__":
|
|
import eventlet.wsgi
|
|
listener = eventlet.listen(('0.0.0.0', 5000))
|
|
eventlet.wsgi.server(listener, app)
|