superlocalmemory 3.7.8 → 3.8.0

package/src/superlocalmemory/server/routes/config_api.py

@@ -0,0 +1,436 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Dashboard config endpoints — storage, daemon, mesh, trust, forgetting.
+
+Each section provides GET (read current) and PUT (validate + persist) routes.
+Writes use the same direct-JSON approach as the evolution config endpoint:
+  1. Read config.json as a raw dict (fail-open → defaults when absent/corrupt).
+  2. Update only the targeted keys; all other keys — including 'mode' — survive.
+  3. Atomic write via a temp file + os.replace (no torn writes).
+
+Auth: follows the same pattern as the auto-capture/auto-recall/auto-invoke
+config endpoints — no route-level auth guard.  Write-identity is enforced by
+the middleware layer wired in unified_daemon.py / ui.py for non-localhost
+callers.  Tests use a bare FastAPI app (no middleware) and monkeypatch
+MEMORY_DIR to a tmp_path.
+
+Restart-required semantics:
+  - graph_backend / vector_backend: changes take effect only on daemon restart.
+  - daemon_port / daemon_legacy_port: changes take effect only on daemon restart.
+  - All other fields: hot-applied on next engine reconfigure cycle.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Annotated, Literal, Optional
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+
+from superlocalmemory.server.routes.helpers import MEMORY_DIR
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v3", tags=["config"])
+
+
+def _require_admin(request: Request) -> None:
+    """SEC-H-01: system-configuration mutations are admin-only (MANAGE).
+
+    Machine auth (loopback / credential) is enforced by the daemon middleware;
+    this adds the RBAC layer so a logged-in non-admin (viewer/member) in company
+    mode cannot change the daemon port, swap the LLM key, or alter the forgetting
+    curve. The machine owner keeps MANAGE (personal mode is unaffected). Call
+    this BEFORE the handler's try/except so the 401/403 is not swallowed into a
+    500.
+    """
+    from superlocalmemory.server.rbac_enforce import require_manage
+    require_manage(request)
+
+# ---------------------------------------------------------------------------
+# Allowed backend values
+# ---------------------------------------------------------------------------
+
+_GRAPH_BACKENDS = frozenset({"auto", "sqlite", "cozo"})
+_VECTOR_BACKENDS = frozenset({"auto", "lancedb", "sqlite-vec"})
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _config_path() -> Path:
+    """Return the config.json path, resolved from the active MEMORY_DIR."""
+    return MEMORY_DIR / "config.json"
+
+
+def _read_config() -> dict:
+    """Read config.json as a raw dict.  Returns {} on missing/corrupt file."""
+    p = _config_path()
+    if not p.exists():
+        return {}
+    try:
+        return json.loads(p.read_text())
+    except (json.JSONDecodeError, OSError) as exc:
+        logger.warning("config_api: could not read config.json: %s", exc)
+        return {}
+
+
+def _atomic_write(data: dict) -> None:
+    """Atomic config.json write: .tmp → os.replace."""
+    p = _config_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    os.replace(tmp, p)
+
+
+# ---------------------------------------------------------------------------
+# Pydantic request models  (extra="forbid" → 422 on unknown keys)
+# ---------------------------------------------------------------------------
+
+
+class StorageConfigUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    graph_backend: Optional[Annotated[str, Field(pattern=r"^(auto|sqlite|cozo)$")]] = None
+    vector_backend: Optional[Annotated[str, Field(pattern=r"^(auto|lancedb|sqlite-vec)$")]] = None
+
+
+class DaemonConfigUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    idle_timeout: Optional[int] = Field(None, ge=0)
+    port: Optional[int] = Field(None, ge=1, le=65535)
+    legacy_port: Optional[int] = Field(None, ge=1, le=65535)
+    enable_legacy_port: Optional[StrictBool] = None
+
+
+class MeshConfigUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: StrictBool
+
+
+class TrustConfigUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    use_trust_weighting: Optional[StrictBool] = None
+    trust_first_party: Optional[StrictBool] = None
+    promotion_min_trust: Optional[float] = Field(None, ge=0.0, le=1.0)
+
+
+class ForgettingConfigUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: Optional[StrictBool] = None
+    alpha: Optional[float] = Field(None, gt=0.0)
+    beta: Optional[float] = Field(None, gt=0.0)
+    gamma: Optional[float] = Field(None, gt=0.0)
+    delta: Optional[float] = Field(None, gt=0.0)
+    min_strength: Optional[float] = Field(None, gt=0.0)
+    max_strength: Optional[float] = Field(None, gt=0.0)
+    archive_threshold: Optional[float] = Field(None, ge=0.0, le=1.0)
+    forget_threshold: Optional[float] = Field(None, ge=0.0, le=1.0)
+    learning_rate: Optional[float] = Field(None, gt=0.0)
+    forgetting_drift_scale: Optional[float] = Field(None, gt=0.0)
+    trust_kappa: Optional[float] = Field(None, gt=0.0)
+    scheduler_interval_minutes: Optional[int] = Field(None, ge=1)
+    core_memory_immune: Optional[StrictBool] = None
+
+
+# ---------------------------------------------------------------------------
+# Default value constants (mirrors ForgettingConfig dataclass defaults)
+# ---------------------------------------------------------------------------
+
+_FORGETTING_DEFAULTS: dict = {
+    "enabled": True,
+    "alpha": 2.0,
+    "beta": 1.5,
+    "gamma": 1.0,
+    "delta": 0.5,
+    "min_strength": 0.1,
+    "max_strength": 100.0,
+    "archive_threshold": 0.2,
+    "forget_threshold": 0.05,
+    "learning_rate": 1.0,
+    "forgetting_drift_scale": 0.5,
+    "trust_kappa": 2.0,
+    "scheduler_interval_minutes": 30,
+    "core_memory_immune": True,
+}
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v3/storage/config
+# ---------------------------------------------------------------------------
+
+
+@router.get("/storage/config")
+async def get_storage_config():
+    """Return current storage backend configuration.
+
+    base_dir is read-only — it is derived from the process namespace and
+    cannot be changed via this endpoint.
+    """
+    try:
+        data = _read_config()
+        return {
+            "graph_backend": data.get("graph_backend", "auto"),
+            "vector_backend": data.get("vector_backend", "auto"),
+            "base_dir": data.get("base_dir", str(MEMORY_DIR)),
+        }
+    except Exception as exc:
+        logger.exception("get_storage_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/v3/storage/config
+# ---------------------------------------------------------------------------
+
+
+@router.put("/storage/config")
+async def put_storage_config(request: Request, body: StorageConfigUpdate):
+    """Update graph_backend and/or vector_backend.
+
+    Both fields require a daemon restart to take effect.
+    Returns restart_required: true unconditionally.
+    """
+    _require_admin(request)
+    try:
+        data = _read_config()
+        if body.graph_backend is not None:
+            data["graph_backend"] = body.graph_backend
+        if body.vector_backend is not None:
+            data["vector_backend"] = body.vector_backend
+        _atomic_write(data)
+        return {
+            "graph_backend": data.get("graph_backend", "auto"),
+            "vector_backend": data.get("vector_backend", "auto"),
+            "base_dir": data.get("base_dir", str(MEMORY_DIR)),
+            "restart_required": True,
+        }
+    except Exception as exc:
+        logger.exception("put_storage_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v3/daemon/config
+# ---------------------------------------------------------------------------
+
+
+@router.get("/daemon/config")
+async def get_daemon_config():
+    """Return current daemon configuration."""
+    try:
+        data = _read_config()
+        return {
+            "idle_timeout": data.get("daemon_idle_timeout", 0),
+            "port": data.get("daemon_port", 8765),
+            "legacy_port": data.get("daemon_legacy_port", 8767),
+            "enable_legacy_port": data.get("daemon_enable_legacy_port", True),
+        }
+    except Exception as exc:
+        logger.exception("get_daemon_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/v3/daemon/config
+# ---------------------------------------------------------------------------
+
+
+@router.put("/daemon/config")
+async def put_daemon_config(request: Request, body: DaemonConfigUpdate):
+    """Update daemon configuration.
+
+    Port / legacy_port changes require a daemon restart.
+    restart_required is True if any port field is included in the request.
+    """
+    _require_admin(request)
+    try:
+        data = _read_config()
+        port_changed = False
+        if body.idle_timeout is not None:
+            data["daemon_idle_timeout"] = body.idle_timeout
+        if body.port is not None:
+            data["daemon_port"] = body.port
+            port_changed = True
+        if body.legacy_port is not None:
+            data["daemon_legacy_port"] = body.legacy_port
+            port_changed = True
+        if body.enable_legacy_port is not None:
+            data["daemon_enable_legacy_port"] = body.enable_legacy_port
+        _atomic_write(data)
+        return {
+            "idle_timeout": data.get("daemon_idle_timeout", 0),
+            "port": data.get("daemon_port", 8765),
+            "legacy_port": data.get("daemon_legacy_port", 8767),
+            "enable_legacy_port": data.get("daemon_enable_legacy_port", True),
+            "restart_required": port_changed,
+        }
+    except Exception as exc:
+        logger.exception("put_daemon_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v3/mesh/config
+# ---------------------------------------------------------------------------
+
+
+@router.get("/mesh/config")
+async def get_mesh_config():
+    """Return current mesh configuration."""
+    try:
+        data = _read_config()
+        return {"enabled": data.get("mesh_enabled", True)}
+    except Exception as exc:
+        logger.exception("get_mesh_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/v3/mesh/config
+# ---------------------------------------------------------------------------
+
+
+@router.put("/mesh/config")
+async def put_mesh_config(request: Request, body: MeshConfigUpdate):
+    """Enable or disable the mesh sync layer."""
+    _require_admin(request)
+    try:
+        data = _read_config()
+        data["mesh_enabled"] = body.enabled
+        _atomic_write(data)
+        return {"enabled": body.enabled}
+    except Exception as exc:
+        logger.exception("put_mesh_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v3/trust/config
+# ---------------------------------------------------------------------------
+
+
+@router.get("/trust/config")
+async def get_trust_config():
+    """Return current trust configuration.
+
+    Fields are spread across three config sections:
+      - retrieval.use_trust_weighting   (Bayesian trust in retrieval ranking)
+      - injection.trust_first_party     (framing of injected context)
+      - consolidation.promotion_min_trust (min trust required for promotion)
+    """
+    try:
+        data = _read_config()
+        retrieval = data.get("retrieval", {})
+        injection = data.get("injection", {})
+        consolidation = data.get("consolidation", {})
+        return {
+            "use_trust_weighting": retrieval.get("use_trust_weighting", True),
+            "trust_first_party": injection.get("trust_first_party", False),
+            "promotion_min_trust": consolidation.get("promotion_min_trust", 0.5),
+        }
+    except Exception as exc:
+        logger.exception("get_trust_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/v3/trust/config
+# ---------------------------------------------------------------------------
+
+
+@router.put("/trust/config")
+async def put_trust_config(request: Request, body: TrustConfigUpdate):
+    """Update trust configuration.
+
+    Each field is stored in its canonical config.json sub-section.
+    Unrelated keys in those sub-sections are preserved.
+    """
+    _require_admin(request)
+    try:
+        data = _read_config()
+        if body.use_trust_weighting is not None:
+            retrieval = data.setdefault("retrieval", {})
+            retrieval["use_trust_weighting"] = body.use_trust_weighting
+        if body.trust_first_party is not None:
+            injection = data.setdefault("injection", {})
+            injection["trust_first_party"] = body.trust_first_party
+        if body.promotion_min_trust is not None:
+            consolidation = data.setdefault("consolidation", {})
+            consolidation["promotion_min_trust"] = body.promotion_min_trust
+        _atomic_write(data)
+        retrieval = data.get("retrieval", {})
+        injection = data.get("injection", {})
+        consolidation = data.get("consolidation", {})
+        return {
+            "use_trust_weighting": retrieval.get("use_trust_weighting", True),
+            "trust_first_party": injection.get("trust_first_party", False),
+            "promotion_min_trust": consolidation.get("promotion_min_trust", 0.5),
+        }
+    except Exception as exc:
+        logger.exception("put_trust_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v3/forgetting/config
+# ---------------------------------------------------------------------------
+
+
+@router.get("/forgetting/config")
+async def get_forgetting_config():
+    """Return all Ebbinghaus forgetting configuration fields."""
+    try:
+        data = _read_config()
+        stored = data.get("forgetting", {})
+        # Return defaults for any field not yet in config.json
+        result = {**_FORGETTING_DEFAULTS, **stored}
+        # Keep only known fields
+        return {k: result[k] for k in _FORGETTING_DEFAULTS}
+    except Exception as exc:
+        logger.exception("get_forgetting_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/v3/forgetting/config
+# ---------------------------------------------------------------------------
+
+
+@router.put("/forgetting/config")
+async def put_forgetting_config(request: Request, body: ForgettingConfigUpdate):
+    """Update Ebbinghaus forgetting configuration.
+
+    Only provided fields are changed; all other forgetting fields are
+    preserved.  Changes take effect on the next daemon startup (or after
+    the scheduler fires its next cycle).
+    """
+    _require_admin(request)
+    try:
+        data = _read_config()
+        stored = data.get("forgetting", {})
+        # Apply defaults for missing fields, then overlay the stored values,
+        # then overlay the requested updates.
+        merged = {**_FORGETTING_DEFAULTS, **stored}
+        updates = body.model_dump(exclude_none=True)
+        merged.update(updates)
+        data["forgetting"] = merged
+        _atomic_write(data)
+        return {k: merged[k] for k in _FORGETTING_DEFAULTS}
+    except Exception as exc:
+        logger.exception("put_forgetting_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)

package/src/superlocalmemory/server/routes/data_io.py

@@ -27,6 +27,12 @@ from .helpers import (
 
 logger = logging.getLogger("superlocalmemory.routes.data_io")
 
+
+def _internal_error(detail: str = "Internal server error") -> HTTPException:
+    """SEC-H-02: log full traceback server-side; return a generic message to the client."""
+    logger.exception("data_io route error")
+    return HTTPException(status_code=500, detail=detail)
+
 # WebSocket manager reference (set by ui_server.py at startup)
 ws_manager = None
 
@@ -35,11 +41,19 @@ router = APIRouter()
 
 @router.get("/api/export")
 async def export_memories(
+    request: Request,
     format: str = Query("json", pattern="^(json|jsonl|csv)$"),
     category: Optional[str] = None,
     project_name: Optional[str] = None,
 ):
     """Export memories as JSON, JSONL, or CSV."""
+    # Bulk data export. This GET is not covered by the mutation middleware and
+    # is reached both by a plain fetch and a top-level navigation, neither of
+    # which carries a credential header — so gate on the loopback-trusted
+    # mutation boundary: local owner allowed, remote uncredentialed fails closed.
+    from superlocalmemory.server.write_identity import require_http_mutation_actor
+    require_http_mutation_actor(request, getattr(request.app.state, "daemon_descriptor", None),
+                                actor_kind="data-export")
     try:
         conn = get_db_connection()
         conn.row_factory = dict_factory
@@ -128,22 +142,29 @@ async def export_memories(
             },
         )
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Export error: {str(e)}")
+    except Exception:
+        raise _internal_error("Export error")
 
 
 @router.post("/api/import")
 async def import_memories(request: Request, file: UploadFile = File(...)):
     """Import memories from JSON file using V3 engine."""
     try:
-        content = await file.read()
+        # Bound the upload so a huge file cannot OOM the daemon (read one byte
+        # past the cap to detect oversize without buffering the whole payload).
+        _MAX_IMPORT_BYTES = 50 * 1024 * 1024
+        content = await file.read(_MAX_IMPORT_BYTES + 1)
+        if len(content) > _MAX_IMPORT_BYTES:
+            raise HTTPException(status_code=413,
+                                detail="Import file exceeds the 50 MB limit")
         if file.filename and file.filename.endswith('.gz'):
             content = gzip.decompress(content)
 
         try:
             data = json.loads(content)
-        except json.JSONDecodeError as e:
-            raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
+        except json.JSONDecodeError:
+            logger.warning("import: invalid JSON payload")
+            raise HTTPException(status_code=400, detail="Invalid JSON format")
 
         if isinstance(data, dict) and 'memories' in data:
             memories = data['memories']
@@ -224,7 +245,8 @@ async def import_memories(request: Request, file: UploadFile = File(...)):
                 if "UNIQUE constraint failed" in str(e):
                     skipped += 1
                 else:
-                    errors.append(f"Memory {idx}: {str(e)}")
+                    logger.warning("import: memory %d failed: %s", idx, e)
+                    errors.append(f"Memory {idx}: import failed")
 
         return {
             "success": True, "imported_count": imported,
@@ -234,5 +256,5 @@ async def import_memories(request: Request, file: UploadFile = File(...)):
 
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Import error: {str(e)}")
+    except Exception:
+        raise _internal_error("Import error")

package/src/superlocalmemory/server/routes/entity.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from fastapi import APIRouter, HTTPException, Request, Query
 
-from .helpers import require_engine
+from .helpers import require_engine, get_active_profile
 
 router = APIRouter(prefix="/api/entity", tags=["entity"])
 
@@ -16,12 +16,15 @@ router = APIRouter(prefix="/api/entity", tags=["entity"])
 @router.get("/list")
 async def list_entities(
     request: Request,
-    profile: str = Query(default="default"),
+    profile: str | None = Query(default=None),
     limit: int = Query(default=100, ge=1, le=1000),
     offset: int = Query(default=0, ge=0),
 ):
     """List all entities with basic info (canonical name, type, fact count)."""
     engine = require_engine(request)
+    # Default to the ACTIVE profile (request runtime truth), never the literal
+    # "default" — otherwise every profile sees the default profile's entities.
+    profile = profile or get_active_profile()
 
     import sqlite3
     import json
@@ -71,11 +74,12 @@ async def list_entities(
 async def get_entity(
     entity_name: str,
     request: Request,
-    profile: str = Query(default="default"),
+    profile: str | None = Query(default=None),
     project: str = Query(default=""),
 ):
     """Get compiled truth + timeline for an entity."""
     engine = require_engine(request)
+    profile = profile or get_active_profile()
 
     import sqlite3
     import json
@@ -115,11 +119,12 @@ async def get_entity(
 async def recompile_entity(
     entity_name: str,
     request: Request,
-    profile: str = Query(default="default"),
+    profile: str | None = Query(default=None),
     project: str = Query(default=""),
 ):
     """Force immediate recompilation of an entity."""
     engine = require_engine(request)
+    profile = profile or get_active_profile()
 
     import sqlite3
     conn = sqlite3.connect(str(engine._config.db_path))

package/src/superlocalmemory/server/routes/events.py

@@ -17,7 +17,7 @@ from datetime import datetime, timezone
 from fastapi import APIRouter, HTTPException, Query
 from fastapi.responses import StreamingResponse
 
-from .helpers import DB_PATH
+from .helpers import DB_PATH, get_active_profile
 
 logger = logging.getLogger("superlocalmemory.routes.events")
 router = APIRouter()
@@ -71,6 +71,11 @@ async def event_stream(
 
     import asyncio
 
+    # Scope this stream to the profile active at connect time. The dashboard
+    # opens a fresh stream after a profile switch, so a connection only ever
+    # surfaces ONE profile's events — never another profile's (GDPR).
+    active_profile = get_active_profile()
+
     client_queue = _queue.Queue(maxsize=100)
     with _sse_queues_lock:
         _sse_queues.add(client_queue)
@@ -86,6 +91,7 @@ async def event_stream(
                     bus = EventBus.get_instance(DB_PATH)
                     missed = bus.get_recent_events(
                         since_id=last_event_id, limit=50, event_type=event_type,
+                        profile_id=active_profile,
                     )
                     for evt in missed:
                         data = json.dumps(evt)
@@ -96,7 +102,9 @@ async def event_stream(
             else:
                 try:
                     bus = EventBus.get_instance(DB_PATH)
-                    recent = bus.get_recent_events(limit=1)
+                    recent = bus.get_recent_events(
+                        limit=1, profile_id=active_profile,
+                    )
                     if recent:
                         last_db_id = recent[-1].get('id', 0)
                 except Exception:
@@ -110,6 +118,9 @@ async def event_stream(
                         event = client_queue.get_nowait()
                         if event_type and event.get("event_type") != event_type:
                             continue
+                        # Profile isolation: never forward another profile's event.
+                        if event.get("profile_id", "default") != active_profile:
+                            continue
                         data = json.dumps(event)
                         event_id = event.get("id", event.get("seq", ""))
                         yield f"id: {event_id}\nevent: {event['event_type']}\ndata: {data}\n\n"
@@ -126,6 +137,7 @@ async def event_stream(
                         bus = EventBus.get_instance(DB_PATH)
                         new_events = bus.get_recent_events(
                             since_id=last_db_id, limit=10, event_type=event_type,
+                            profile_id=active_profile,
                         )
                         for evt in new_events:
                             data = json.dumps(evt)
@@ -162,13 +174,16 @@ async def get_events(
         return {"events": [], "count": 0, "message": "Event Bus not available"}
     try:
         bus = EventBus.get_instance(DB_PATH)
+        active_profile = get_active_profile()
         events = bus.get_recent_events(
             since_id=since_id, limit=limit, event_type=event_type,
+            profile_id=active_profile,
         )
-        stats = bus.get_event_stats()
+        stats = bus.get_event_stats(profile_id=active_profile)
         return {"events": events, "count": len(events), "stats": stats}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Event retrieval error: {str(e)}")
+    except Exception:
+        logger.exception("events route error")
+        raise HTTPException(status_code=500, detail="Event retrieval error")
 
 
 @router.get("/api/events/stats")
@@ -178,6 +193,7 @@ async def get_event_stats():
         return {"total_events": 0, "message": "Event Bus not available"}
     try:
         bus = EventBus.get_instance(DB_PATH)
-        return bus.get_event_stats()
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Event stats error: {str(e)}")
+        return bus.get_event_stats(profile_id=get_active_profile())
+    except Exception:
+        logger.exception("events route error")
+        raise HTTPException(status_code=500, detail="Event stats error")