374 lines
15 KiB
Python
374 lines
15 KiB
Python
from __future__ import annotations
|
|
import json
|
|
import threading
|
|
import uuid
|
|
from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
|
|
from typing import Any
|
|
import logging
|
|
from src import session_logger
|
|
|
|
def _get_app_attr(app: Any, name: str, default: Any = None) -> Any:
|
|
if hasattr(app, name):
|
|
return getattr(app, name)
|
|
if hasattr(app, 'controller') and hasattr(app.controller, name):
|
|
return getattr(app.controller, name)
|
|
return default
|
|
|
|
def _has_app_attr(app: Any, name: str) -> bool:
|
|
if hasattr(app, name): return True
|
|
if hasattr(app, 'controller') and hasattr(app.controller, name): return True
|
|
return False
|
|
|
|
def _set_app_attr(app: Any, name: str, value: Any) -> None:
|
|
if hasattr(app, name):
|
|
setattr(app, name, value)
|
|
elif hasattr(app, 'controller'):
|
|
setattr(app.controller, name, value)
|
|
else:
|
|
setattr(app, name, value)
|
|
|
|
class HookServerInstance(ThreadingHTTPServer):
|
|
"""Custom HTTPServer that carries a reference to the main App instance."""
|
|
def __init__(self, server_address: tuple[str, int], RequestHandlerClass: type, app: Any) -> None:
|
|
super().__init__(server_address, RequestHandlerClass)
|
|
self.app = app
|
|
|
|
class HookHandler(BaseHTTPRequestHandler):
|
|
"""Handles incoming HTTP requests for the API hooks."""
|
|
def do_GET(self) -> None:
|
|
app = self.server.app
|
|
session_logger.log_api_hook("GET", self.path, "")
|
|
if self.path == "/status":
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "ok"}).encode("utf-8"))
|
|
elif self.path == "/api/project":
|
|
from src import project_manager
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
flat = project_manager.flat_config(_get_app_attr(app, "project"))
|
|
self.wfile.write(json.dumps({"project": flat}).encode("utf-8"))
|
|
elif self.path == "/api/session":
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
lock = _get_app_attr(app, "_disc_entries_lock")
|
|
entries = _get_app_attr(app, "disc_entries", [])
|
|
if lock:
|
|
with lock: entries_snapshot = list(entries)
|
|
else:
|
|
entries_snapshot = list(entries)
|
|
self.wfile.write(json.dumps({"session": {"entries": entries_snapshot}}).encode("utf-8"))
|
|
elif self.path == "/api/performance":
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
metrics = {}
|
|
perf = _get_app_attr(app, "perf_monitor")
|
|
if perf: metrics = perf.get_metrics()
|
|
self.wfile.write(json.dumps({"performance": metrics}).encode("utf-8"))
|
|
elif self.path == "/api/events":
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
events = []
|
|
if _has_app_attr(app, "_api_event_queue"):
|
|
lock = _get_app_attr(app, "_api_event_queue_lock")
|
|
queue = _get_app_attr(app, "_api_event_queue")
|
|
if lock:
|
|
with lock:
|
|
events = list(queue)
|
|
queue.clear()
|
|
else:
|
|
events = list(queue)
|
|
queue.clear()
|
|
self.wfile.write(json.dumps({"events": events}).encode("utf-8"))
|
|
elif self.path.startswith("/api/gui/value/"):
|
|
field_tag = self.path.split("/")[-1]
|
|
event = threading.Event()
|
|
result = {"value": None}
|
|
def get_val():
|
|
try:
|
|
settable = _get_app_attr(app, "_settable_fields", {})
|
|
if field_tag in settable:
|
|
attr = settable[field_tag]
|
|
result["value"] = _get_app_attr(app, attr, None)
|
|
finally: event.set()
|
|
lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if lock and tasks is not None:
|
|
with lock: tasks.append({"action": "custom_callback", "callback": get_val})
|
|
if event.wait(timeout=10):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps(result).encode("utf-8"))
|
|
else:
|
|
self.send_response(504)
|
|
self.end_headers()
|
|
elif self.path == "/api/gui/mma_status":
|
|
event = threading.Event()
|
|
result = {}
|
|
def get_mma():
|
|
try:
|
|
result["mma_status"] = _get_app_attr(app, "mma_status", "idle")
|
|
result["ai_status"] = _get_app_attr(app, "ai_status", "idle")
|
|
result["active_tier"] = _get_app_attr(app, "active_tier", None)
|
|
at = _get_app_attr(app, "active_track", None)
|
|
result["active_track"] = at.id if hasattr(at, "id") else at
|
|
result["active_tickets"] = _get_app_attr(app, "active_tickets", [])
|
|
result["mma_step_mode"] = _get_app_attr(app, "mma_step_mode", False)
|
|
result["pending_tool_approval"] = _get_app_attr(app, "_pending_ask_dialog", False)
|
|
result["pending_script_approval"] = _get_app_attr(app, "_pending_dialog", None) is not None
|
|
result["pending_mma_step_approval"] = _get_app_attr(app, "_pending_mma_approval", None) is not None
|
|
result["pending_mma_spawn_approval"] = _get_app_attr(app, "_pending_mma_spawn", None) is not None
|
|
result["pending_approval"] = result["pending_mma_step_approval"] or result["pending_tool_approval"]
|
|
result["pending_spawn"] = result["pending_mma_spawn_approval"]
|
|
result["tracks"] = _get_app_attr(app, "tracks", [])
|
|
result["proposed_tracks"] = _get_app_attr(app, "proposed_tracks", [])
|
|
result["mma_streams"] = _get_app_attr(app, "mma_streams", {})
|
|
result["mma_tier_usage"] = _get_app_attr(app, "mma_tier_usage", {})
|
|
finally: event.set()
|
|
lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if lock and tasks is not None:
|
|
with lock: tasks.append({"action": "custom_callback", "callback": get_mma})
|
|
if event.wait(timeout=10):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps(result).encode("utf-8"))
|
|
else:
|
|
self.send_response(504)
|
|
self.end_headers()
|
|
elif self.path == "/api/gui/diagnostics":
|
|
event = threading.Event()
|
|
result = {}
|
|
def check_all():
|
|
try:
|
|
status = _get_app_attr(app, "ai_status", "idle")
|
|
result["thinking"] = status in ["sending...", "running powershell..."]
|
|
result["live"] = status in ["running powershell...", "fetching url...", "searching web...", "powershell done, awaiting AI..."]
|
|
result["prior"] = _get_app_attr(app, "is_viewing_prior_session", False)
|
|
finally: event.set()
|
|
lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if lock and tasks is not None:
|
|
with lock: tasks.append({"action": "custom_callback", "callback": check_all})
|
|
if event.wait(timeout=10):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps(result).encode("utf-8"))
|
|
else:
|
|
self.send_response(504)
|
|
self.end_headers()
|
|
elif self.path == '/api/gui/state':
|
|
event = threading.Event()
|
|
result = {}
|
|
def get_state():
|
|
try:
|
|
gettable = _get_app_attr(app, "_gettable_fields", {})
|
|
for key, attr in gettable.items():
|
|
result[key] = _get_app_attr(app, attr, None)
|
|
finally: event.set()
|
|
lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if lock and tasks is not None:
|
|
with lock: tasks.append({"action": "custom_callback", "callback": get_state})
|
|
if event.wait(timeout=10):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps(result).encode("utf-8"))
|
|
else:
|
|
self.send_response(504)
|
|
self.end_headers()
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
|
|
def do_POST(self) -> None:
|
|
app = self.server.app
|
|
content_length = int(self.headers.get("Content-Length", 0))
|
|
body = self.rfile.read(content_length)
|
|
body_str = body.decode("utf-8") if body else ""
|
|
session_logger.log_api_hook("POST", self.path, body_str)
|
|
try:
|
|
data = json.loads(body_str) if body_str else {}
|
|
if self.path == "/api/project":
|
|
project = _get_app_attr(app, "project")
|
|
_set_app_attr(app, "project", data.get("project", project))
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "updated"}).encode("utf-8"))
|
|
elif self.path.startswith("/api/confirm/"):
|
|
action_id = self.path.split("/")[-1]
|
|
approved = data.get("approved", False)
|
|
resolve_func = _get_app_attr(app, "resolve_pending_action")
|
|
if resolve_func:
|
|
success = resolve_func(action_id, approved)
|
|
if success:
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "ok"}).encode("utf-8"))
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
else:
|
|
self.send_response(500)
|
|
self.end_headers()
|
|
elif self.path == "/api/session":
|
|
lock = _get_app_attr(app, "_disc_entries_lock")
|
|
entries = _get_app_attr(app, "disc_entries")
|
|
new_entries = data.get("session", {}).get("entries", entries)
|
|
if lock:
|
|
with lock: _set_app_attr(app, "disc_entries", new_entries)
|
|
else:
|
|
_set_app_attr(app, "disc_entries", new_entries)
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "updated"}).encode("utf-8"))
|
|
elif self.path == "/api/gui":
|
|
lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if lock and tasks is not None:
|
|
with lock: tasks.append(data)
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "queued"}).encode("utf-8"))
|
|
elif self.path == "/api/gui/value":
|
|
field_tag = data.get("field")
|
|
event = threading.Event()
|
|
result = {"value": None}
|
|
def get_val():
|
|
try:
|
|
settable = _get_app_attr(app, "_settable_fields", {})
|
|
if field_tag in settable:
|
|
attr = settable[field_tag]
|
|
result["value"] = _get_app_attr(app, attr, None)
|
|
finally: event.set()
|
|
lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if lock and tasks is not None:
|
|
with lock: tasks.append({"action": "custom_callback", "callback": get_val})
|
|
if event.wait(timeout=10):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps(result).encode("utf-8"))
|
|
else:
|
|
self.send_response(504)
|
|
self.end_headers()
|
|
elif self.path == "/api/ask":
|
|
request_id = str(uuid.uuid4())
|
|
event = threading.Event()
|
|
pending_asks = _get_app_attr(app, "_pending_asks")
|
|
if pending_asks is None:
|
|
pending_asks = {}
|
|
_set_app_attr(app, "_pending_asks", pending_asks)
|
|
ask_responses = _get_app_attr(app, "_ask_responses")
|
|
if ask_responses is None:
|
|
ask_responses = {}
|
|
_set_app_attr(app, "_ask_responses", ask_responses)
|
|
pending_asks[request_id] = event
|
|
event_queue_lock = _get_app_attr(app, "_api_event_queue_lock")
|
|
event_queue = _get_app_attr(app, "_api_event_queue")
|
|
if event_queue is not None:
|
|
if event_queue_lock:
|
|
with event_queue_lock: event_queue.append({"type": "ask_received", "request_id": request_id, "data": data})
|
|
else:
|
|
event_queue.append({"type": "ask_received", "request_id": request_id, "data": data})
|
|
gui_tasks_lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
gui_tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if gui_tasks is not None:
|
|
if gui_tasks_lock:
|
|
with gui_tasks_lock: gui_tasks.append({"type": "ask", "request_id": request_id, "data": data})
|
|
else:
|
|
gui_tasks.append({"type": "ask", "request_id": request_id, "data": data})
|
|
if event.wait(timeout=60.0):
|
|
response_data = ask_responses.get(request_id)
|
|
if request_id in ask_responses: del ask_responses[request_id]
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "ok", "response": response_data}).encode("utf-8"))
|
|
else:
|
|
if request_id in pending_asks: del pending_asks[request_id]
|
|
self.send_response(504)
|
|
self.end_headers()
|
|
elif self.path == "/api/ask/respond":
|
|
request_id = data.get("request_id")
|
|
response_data = data.get("response")
|
|
pending_asks = _get_app_attr(app, "_pending_asks")
|
|
ask_responses = _get_app_attr(app, "_ask_responses")
|
|
if request_id and pending_asks and request_id in pending_asks:
|
|
ask_responses[request_id] = response_data
|
|
event = pending_asks[request_id]
|
|
event.set()
|
|
del pending_asks[request_id]
|
|
gui_tasks_lock = _get_app_attr(app, "_pending_gui_tasks_lock")
|
|
gui_tasks = _get_app_attr(app, "_pending_gui_tasks")
|
|
if gui_tasks is not None:
|
|
if gui_tasks_lock:
|
|
with gui_tasks_lock: gui_tasks.append({"action": "clear_ask", "request_id": request_id})
|
|
else:
|
|
gui_tasks.append({"action": "clear_ask", "request_id": request_id})
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"status": "ok"}).encode("utf-8"))
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
except Exception as e:
|
|
self.send_response(500)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"error": str(e)}).encode("utf-8"))
|
|
|
|
|
|
def log_message(self, format: str, *args: Any) -> None:
|
|
logging.info("Hook API: " + format % args)
|
|
|
|
class HookServer:
|
|
def __init__(self, app: Any, port: int = 8999) -> None:
|
|
self.app = app
|
|
self.port = port
|
|
self.server = None
|
|
self.thread = None
|
|
|
|
def start(self) -> None:
|
|
if self.thread and self.thread.is_alive():
|
|
return
|
|
is_gemini_cli = _get_app_attr(self.app, 'current_provider', '') == 'gemini_cli'
|
|
if not _get_app_attr(self.app, 'test_hooks_enabled', False) and not is_gemini_cli:
|
|
return
|
|
if not _has_app_attr(self.app, '_pending_gui_tasks'): _set_app_attr(self.app, '_pending_gui_tasks', [])
|
|
if not _has_app_attr(self.app, '_pending_gui_tasks_lock'): _set_app_attr(self.app, '_pending_gui_tasks_lock', threading.Lock())
|
|
if not _has_app_attr(self.app, '_pending_asks'): _set_app_attr(self.app, '_pending_asks', {})
|
|
if not _has_app_attr(self.app, '_ask_responses'): _set_app_attr(self.app, '_ask_responses', {})
|
|
if not _has_app_attr(self.app, '_api_event_queue'): _set_app_attr(self.app, '_api_event_queue', [])
|
|
if not _has_app_attr(self.app, '_api_event_queue_lock'): _set_app_attr(self.app, '_api_event_queue_lock', threading.Lock())
|
|
self.server = HookServerInstance(('127.0.0.1', self.port), HookHandler, self.app)
|
|
self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
|
|
self.thread.start()
|
|
logging.info(f"Hook server started on port {self.port}")
|
|
|
|
def stop(self) -> None:
|
|
if self.server:
|
|
self.server.shutdown()
|
|
self.server.server_close()
|
|
if self.thread:
|
|
self.thread.join()
|
|
logging.info("Hook server stopped")
|