Spaces:
Running
Running
| import logging | |
| import os | |
| import re | |
| from hashlib import sha1 | |
| from contextlib import asynccontextmanager | |
| from pathlib import Path | |
| import dotenv | |
| _project_root = Path(__file__).resolve().parent.parent.parent.parent | |
| dotenv.load_dotenv(_project_root / ".env") | |
| from fastapi import FastAPI, Response | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.responses import RedirectResponse | |
| from fastapi.routing import APIRoute | |
| from uvicorn import run | |
| from src.constants.data import BRAIN_VERSION | |
| from src.services.api.console_static import SPAStaticFiles | |
| from src.services.api.connection_docs import connection_docs_router | |
| from src.services.api.errors import install_error_handlers | |
| from src.services.api.openapi import install_openapi_contract | |
| from src.services.api.middlewares.auth import BrainPATMiddleware | |
| from src.services.api.middlewares.brains import BrainMiddleware | |
| from src.services.api.routes.auth import auth_router | |
| from src.services.api.routes.backup import backup_router | |
| from src.services.api.routes.access_tokens import access_token_router | |
| from src.services.api.routes.ingest import ingest_router | |
| from src.services.api.routes.meta import meta_router | |
| from src.services.api.routes.model import model_router | |
| from src.services.api.routes.public import public_router | |
| from src.services.api.routes.retrieve import retrieve_router | |
| from src.services.api.routes.system import system_router | |
| from src.services.api.routes.tasks import tasks_router | |
| from src.services.api.routes.workspaces import workspace_router | |
| from src.services.api.routes.workspace_api import workspace_api_router | |
| from src.services.api.routes.agent import agent_router | |
| from src.lib.tracing.middleware import TraceMiddleware | |
| from src.lib.tracing.runtime import start_runtime_monitoring, stop_runtime_monitoring | |
| logger = logging.getLogger("brainapi.plugins") | |
| PLUGINS_DIR = Path(os.getenv("PLUGINS_DIR", str(_project_root / "plugins"))) | |
| CONSOLE_DIST = _project_root / "console" / "dist" | |
| def _console_enabled() -> bool: | |
| return os.getenv("CONSOLE_ENABLED", "true").strip().lower() != "false" | |
| def _production_mode() -> bool: | |
| return os.getenv("ENV", "production").strip().lower() != "development" | |
| def _cors_allowed_origins() -> list[str]: | |
| configured = [ | |
| origin.strip() | |
| for origin in os.getenv("CORS_ALLOWED_ORIGINS", "").split(",") | |
| if origin.strip() | |
| ] | |
| if not configured and not _production_mode(): | |
| return ["*"] | |
| if "*" in configured and _production_mode(): | |
| raise RuntimeError( | |
| "CORS_ALLOWED_ORIGINS='*' is allowed only when ENV=development" | |
| ) | |
| return configured | |
| def _enforce_plugin_results(results: dict[str, bool]) -> None: | |
| failed = sorted(name for name, loaded in results.items() if not loaded) | |
| if not failed: | |
| return | |
| default_policy = "fail" if _production_mode() else "warn" | |
| policy = os.getenv("PLUGIN_FAILURE_POLICY", default_policy).strip().lower() | |
| if policy not in {"fail", "warn"}: | |
| raise RuntimeError("PLUGIN_FAILURE_POLICY must be 'fail' or 'warn'") | |
| if policy == "fail": | |
| raise RuntimeError(f"Required plugins failed to load: {', '.join(failed)}") | |
| def stable_operation_id(route: APIRoute) -> str: | |
| """Generate function-calling-safe IDs that are stable across schema exports.""" | |
| tag = route.tags[0] if route.tags else "api" | |
| method = sorted(route.methods or {"get"})[0].lower() | |
| raw = f"{tag}_{route.name}_{method}".lower() | |
| normalized = re.sub(r"[^a-z0-9_]+", "_", raw).strip("_") | |
| if len(normalized) <= 64: | |
| return normalized | |
| digest = sha1(normalized.encode("utf-8")).hexdigest()[:8] | |
| return f"{normalized[:55].rstrip('_')}_{digest}" | |
| async def lifespan(app: FastAPI): | |
| from src.services.brain_backup.state import require_startup_ready | |
| require_startup_ready() | |
| from src.core.plugins.context import PluginContext | |
| from src.core.plugins.loader import PluginLoader | |
| from src.services.persistence import enforce_persistence | |
| enforce_persistence() | |
| from src.services.auth_config import resolve_system_pat | |
| resolve_system_pat() | |
| from src.config import config | |
| if config.data_db == "postgresql": | |
| from src.services.credentials import token_repository | |
| token_repository.initialize() | |
| start_runtime_monitoring("brainapi-api") | |
| ctx = PluginContext.from_app(app) | |
| loader = PluginLoader(plugins_dir=PLUGINS_DIR, context=ctx) | |
| results = loader.load_all() | |
| try: | |
| from src.services.data.main import data_adapter | |
| from src.services.workspaces import WorkspaceService | |
| WorkspaceService(data_adapter).bootstrap() | |
| except Exception: | |
| logger.exception("Workspace bootstrap deferred; persistence is unavailable") | |
| _log_plugin_banner(loader, results) | |
| _enforce_plugin_results(results) | |
| for event_name, handlers in ctx._event_handlers.items(): | |
| if event_name == "startup": | |
| for handler in handlers: | |
| await handler() if _is_coroutine(handler) else handler() | |
| try: | |
| yield | |
| finally: | |
| stop_runtime_monitoring("brainapi-api") | |
| for event_name, handlers in ctx._event_handlers.items(): | |
| if event_name == "shutdown": | |
| for handler in handlers: | |
| await handler() if _is_coroutine(handler) else handler() | |
| def _is_coroutine(fn): | |
| import asyncio | |
| return asyncio.iscoroutinefunction(fn) | |
| def _log_plugin_banner(loader, results: dict[str, bool]): | |
| loaded = loader.loaded_plugins | |
| total = len(results) | |
| ok = sum(1 for v in results.values() if v) | |
| failed = total - ok | |
| lines = [ | |
| "", | |
| "\033[36m ╔══════════════════════════════════════════════════════╗\033[0m", | |
| "\033[36m ║\033[0m \033[1;36m⚡ BrainAPI Plugin System ⚡\033[0m \033[36m║\033[0m", | |
| "\033[36m ╠══════════════════════════════════════════════════════╣\033[0m", | |
| ] | |
| if total == 0: | |
| lines.append( | |
| "\033[36m ║\033[0m \033[2mNo plugins installed\033[0m \033[36m║\033[0m" | |
| ) | |
| else: | |
| for name, success in results.items(): | |
| manifest = loaded.get(name) | |
| if success and manifest: | |
| ver = f"v{manifest.version}" | |
| status = "\033[32m✔ loaded\033[0m" | |
| label = f"{manifest.name} ({ver})" | |
| else: | |
| status = "\033[31m✘ failed\033[0m" | |
| label = name | |
| padded = f" {status} {label}" | |
| visible_len = len(f" ✔ loaded {label}") | |
| pad = 54 - visible_len | |
| lines.append(f"\033[36m ║\033[0m{padded}{' ' * max(pad, 1)}\033[36m║\033[0m") | |
| lines.append("\033[36m ╠══════════════════════════════════════════════════════╣\033[0m") | |
| summary_parts = [f"\033[1;32m{ok} loaded\033[0m"] | |
| if failed: | |
| summary_parts.append(f"\033[1;31m{failed} failed\033[0m") | |
| summary_text = f" {' · '.join(summary_parts)}" | |
| visible_summary_len = len(f" {ok} loaded" + (f" · {failed} failed" if failed else "")) | |
| summary_pad = 54 - visible_summary_len | |
| lines.append(f"\033[36m ║\033[0m{summary_text}{' ' * max(summary_pad, 1)}\033[36m║\033[0m") | |
| lines.append("\033[36m ╚══════════════════════════════════════════════════════╝\033[0m") | |
| lines.append("") | |
| print("\n".join(lines)) | |
| app = FastAPI( | |
| title="BrainAPI", | |
| version=BRAIN_VERSION, | |
| description="Knowledge, memory, search, recommendation, and agent API.", | |
| debug=os.getenv("ENV") == "development", | |
| lifespan=lifespan, | |
| redirect_slashes=False, | |
| generate_unique_id_function=stable_operation_id, | |
| ) | |
| install_error_handlers(app) | |
| from src.services.brain_backup.middleware import ContentAdmissionMiddleware | |
| app.add_middleware(ContentAdmissionMiddleware) | |
| app.add_middleware(BrainPATMiddleware) | |
| app.add_middleware(BrainMiddleware) | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=_cors_allowed_origins(), | |
| allow_credentials=False, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| app.add_middleware(TraceMiddleware, service_name="brainapi-api") | |
| app.include_router(auth_router) | |
| app.include_router(access_token_router) | |
| app.include_router(ingest_router) | |
| app.include_router(retrieve_router) | |
| app.include_router(meta_router) | |
| app.include_router(model_router) | |
| app.include_router(system_router) | |
| app.include_router(backup_router) | |
| app.include_router(tasks_router) | |
| app.include_router(public_router) | |
| app.include_router(connection_docs_router) | |
| app.include_router(workspace_router) | |
| app.include_router(workspace_api_router) | |
| app.include_router(agent_router) | |
| install_openapi_contract(app) | |
| async def root(): | |
| return RedirectResponse(url="/console/", status_code=307) | |
| if _console_enabled(): | |
| async def console_redirect(): | |
| return RedirectResponse(url="/console/", status_code=307) | |
| if CONSOLE_DIST.is_dir(): | |
| app.mount( | |
| "/console", | |
| SPAStaticFiles(directory=str(CONSOLE_DIST), html=True), | |
| name="console", | |
| ) | |
| logger.info("Local console mounted at /console") | |
| else: | |
| logger.warning( | |
| "Console enabled but %s not found — run: make build-console", | |
| CONSOLE_DIST, | |
| ) | |
| elif os.getenv("CONSOLE_ENABLED", "").strip().lower() == "true": | |
| logger.warning( | |
| "CONSOLE_ENABLED=true but console is disabled — set CONSOLE_ENABLED=false to silence", | |
| ) | |
| if __name__ == "__main__": | |
| run(app, host="0.0.0.0", port=8000) | |