superlocalmemory 4.1.13 → 4.1.15

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

@@ -1,171 +0,0 @@
-# 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
-"""SuperLocalMemory V3 - WebSocket Routes
- - AGPL-3.0-or-later
-
-Routes: /ws/updates
-"""
-import logging
-from typing import Set
-from datetime import datetime, timezone
-
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect
-
-logger = logging.getLogger("superlocalmemory.routes.ws")
-router = APIRouter()
-
-
-class ConnectionManager:
-    """Manages WebSocket connections for real-time updates."""
-
-    def __init__(self):
-        self.active_connections: Set[WebSocket] = set()
-
-    async def connect(self, websocket: WebSocket):
-        await websocket.accept()
-        self.active_connections.add(websocket)
-
-    def disconnect(self, websocket: WebSocket):
-        self.active_connections.discard(websocket)
-
-    async def broadcast(self, message: dict):
-        disconnected = set()
-        for connection in self.active_connections:
-            try:
-                await connection.send_json(message)
-            except Exception:
-                disconnected.add(connection)
-        self.active_connections -= disconnected
-
-
-manager = ConnectionManager()
-
-
-def _ws_origin_allowed(websocket: WebSocket) -> bool:
-    """Return True when the WebSocket upgrade Origin is permitted.
-
-    Non-browser clients (CLI, MCP tools) carry no Origin header and are
-    always allowed.  Browser-originated connections must come from a
-    loopback address or a host in the configured remote allowlist.
-    """
-    origin = websocket.headers.get("origin", "")
-    if not origin:
-        return True  # non-browser caller (CLI/MCP) — no origin to validate
-
-    try:
-        from superlocalmemory.server.origin import origin_is_loopback
-        if origin_is_loopback(origin):
-            return True
-    except Exception:
-        # If the helper is unavailable, fall through to the remote check.
-        if "127.0.0.1" in origin or "::1" in origin or "localhost" in origin:
-            return True
-
-    try:
-        from superlocalmemory.core.remote_mode import is_remote_origin_allowed
-        if is_remote_origin_allowed(origin):
-            return True
-    except Exception:
-        pass
-
-    return False
-
-
-def _ws_rbac_allowed(websocket: WebSocket, app_state) -> bool:
-    """Return True when the caller is authorised to open a WS connection.
-
-    Mirrors _rbac_read_gate in unified_daemon.py: no-op in single-operator
-    installations (zero RBAC users), requires a valid session in company /
-    require_login mode.  Fails closed on RBAC errors.
-    """
-    rbac = getattr(app_state, "rbac", None)
-    if rbac is None:
-        return True  # single-operator mode — no auth layer active
-
-    try:
-        active = rbac.user_count() > 0
-    except Exception:
-        logger.warning("ws: RBAC state unavailable — rejecting handshake (fail closed)")
-        return False  # fail closed
-
-    if not active:
-        return True  # no users registered — single-operator mode
-
-    token = (
-        websocket.headers.get("x-slm-user-session", "")
-        or websocket.cookies.get("slm_session", "")
-    )
-    user = rbac.resolve_session(token) if token else None
-
-    if user is None:
-        if rbac.require_login():
-            return False  # login required and no valid session
-        return True  # personal / owner mode — no session needed
-
-    try:
-        from superlocalmemory.access.rbac import Permission
-        from superlocalmemory.server.routes.helpers import get_active_profile
-        return rbac.has_permission(user["user_id"], get_active_profile(), Permission.READ)
-    except Exception:
-        logger.warning("ws: permission check failed — rejecting handshake (fail closed)")
-        return False
-
-
-@router.websocket("/ws/updates")
-async def websocket_updates(websocket: WebSocket):
-    """WebSocket endpoint for real-time memory updates."""
-    app_state = getattr(websocket, "app", None)
-    app_state = getattr(app_state, "state", None)
-
-    # --- Reject disallowed origins before accepting the handshake. ---
-    if not _ws_origin_allowed(websocket):
-        logger.info("ws: rejected handshake from disallowed origin %s",
-                    websocket.headers.get("origin", ""))
-        await websocket.close(code=1008)  # 1008 = Policy Violation
-        return
-
-    # --- Reject unauthenticated callers when login is required. ---
-    if not _ws_rbac_allowed(websocket, app_state):
-        logger.info("ws: rejected unauthenticated or unauthorised handshake")
-        await websocket.close(code=4001)  # 4001 = custom: Unauthorized
-        return
-
-    await manager.connect(websocket)
-
-    try:
-        await websocket.send_json({
-            "type": "connected",
-            "message": "WebSocket connection established",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        })
-
-        while True:
-            try:
-                data = await websocket.receive_json()
-
-                if data.get('type') == 'ping':
-                    await websocket.send_json({
-                        "type": "pong",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    })
-
-                elif data.get('type') == 'get_stats':
-                    await websocket.send_json({
-                        "type": "stats_update",
-                        "message": "Use /api/stats endpoint for stats",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    })
-
-            except WebSocketDisconnect:
-                break
-            except Exception:
-                logger.exception("ws route error")
-                await websocket.send_json({
-                    "type": "error",
-                    "message": "Internal server error",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                })
-
-    finally:
-        manager.disconnect(websocket)

package/src/superlocalmemory/server/security_middleware.py

@@ -1,89 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-or-later
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Part of Qualixar | Author: Varun Pratap Bhardwaj (qualixar.com | varunpratap.com)
-"""Security headers middleware for FastAPI servers.
-
-Adds comprehensive security headers to all HTTP responses:
-- X-Content-Type-Options: Prevents MIME type sniffing
-- X-Frame-Options: Prevents clickjacking attacks
-- X-XSS-Protection: Enables browser XSS filters
-- Content-Security-Policy: Restricts resource loading
-- Referrer-Policy: Controls referrer information leakage
-"""
-
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-
-class SecurityHeadersMiddleware(BaseHTTPMiddleware):
-    """Add security headers to all HTTP responses."""
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        """Process request and add security headers to response."""
-        response = await call_next(request)
-
-        # Prevent MIME type sniffing
-        response.headers["X-Content-Type-Options"] = "nosniff"
-
-        # Prevent clickjacking attacks
-        response.headers["X-Frame-Options"] = "DENY"
-
-        # Enable browser XSS filter (legacy, but doesn't hurt)
-        response.headers["X-XSS-Protection"] = "1; mode=block"
-
-        # Content Security Policy (v3.4.22 — vendored assets, no CDN hosts).
-        # All Bootstrap/D3/Sigma/graphology/Inter assets ship locally under
-        # /static/vendor/, so we drop every CDN host from the allow-list.
-        #
-        # v3.7.9 (B2): 'unsafe-inline' removed from script-src. Every inline
-        # on*= event handler was migrated to data-act-* attributes dispatched
-        # by js/event-delegation.js (nonces cannot authorise inline event-
-        # handler attributes, so delegation is the only real fix). A stored-XSS
-        # payload can no longer execute inline script here.
-        # 'unsafe-inline' is retained on style-src only: 82 inline style=
-        # attributes remain, style injection is far lower risk than script
-        # injection, and inline style attributes cannot be nonce'd either
-        # (GitHub/GitLab keep the same script-locked / style-inline posture).
-        # img-src drops the https: wildcard now that nothing remote loads.
-        csp_directives = [
-            "default-src 'self'",
-            "script-src 'self'",
-            "style-src 'self' 'unsafe-inline'",
-            "font-src 'self'",
-            "img-src 'self' data:",
-            "connect-src 'self' ws://localhost:* ws://127.0.0.1:*",
-            "frame-ancestors 'none'",
-            "base-uri 'self'",
-            "form-action 'self'",
-        ]
-        response.headers["Content-Security-Policy"] = "; ".join(csp_directives)
-
-        # Control referrer information leakage
-        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
-
-        # v3.4.23: Cache-Control strategy
-        # ---------------------------------------------------------------
-        # Three classes of paths, three policies:
-        #
-        #   /api/*        -> no-store (sensitive data, never cache)
-        #   index.html    -> no-cache, must-revalidate (always revalidate)
-        #   /static/*     -> no-cache, must-revalidate (always revalidate
-        #                    with ETag; fast reloads but never stale-after-
-        #                    upgrade)
-        #
-        # Before v3.4.23 only /api/* had cache headers. Browsers then cached
-        # JS/CSS/HTML aggressively via default heuristics, and after a daemon
-        # upgrade the dashboard showed an infinite spinner because old cached
-        # JS was calling endpoints with stale response shapes. "no-cache"
-        # (not "no-store") still allows 304s on unchanged files, so reload
-        # cost stays low.
-        path = request.url.path
-        if path.startswith("/api/"):
-            response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate"
-            response.headers["Pragma"] = "no-cache"
-        elif path == "/" or path.endswith(".html") or path.startswith("/static/"):
-            response.headers["Cache-Control"] = "no-cache, must-revalidate"
-
-        return response

package/src/superlocalmemory/server/ui.py

@@ -1,354 +0,0 @@
-#!/usr/bin/env python3
-# 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
-"""
-SuperLocalMemory V3 - FastAPI UI Server
-App initialization, middleware, static mount, and router registration.
-
-All route handlers live in routes/ directory:
-    routes/memories.py  -- /api/memories, /api/graph, /api/search, /api/clusters
-    routes/stats.py     -- /api/stats, /api/timeline, /api/patterns
-    routes/profiles.py  -- /api/profiles (CRUD + switch)
-    routes/backup.py    -- /api/backup (status, create, configure, list)
-    routes/data_io.py   -- /api/export, /api/import
-    routes/events.py    -- /events/stream (SSE), /api/events [v2.5]
-    routes/agents.py    -- /api/agents, /api/trust [v2.5]
-    routes/ws.py        -- /ws/updates (WebSocket)
-
-v3.7.8 (WS3 F4): ``create_app()`` in this module is a standalone/legacy app
-factory, NOT the app the running daemon serves -- that is
-``superlocalmemory.server.unified_daemon:create_app`` (see that module's
-uvicorn config). This module's ``auth_middleware`` keeps the older,
-unconditional ``check_api_key``-only write gate (no daemon-capability /
-install-token identity layer, no ``SLM_REQUIRE_API_KEY_LOOPBACK`` opt-in --
-see ``infra/auth_middleware.py`` for that). Treat this file as a standalone
-entry point only; the production write-auth boundary lives in
-``unified_daemon.py``.
-"""
-
-import logging
-import sys
-from pathlib import Path
-from datetime import datetime, timezone
-
-logger = logging.getLogger(__name__)
-
-
-from superlocalmemory.server.routes.helpers import SLM_VERSION  # noqa: E402
-
-_script_dir = str(Path(__file__).parent.resolve())
-sys.path = [p for p in sys.path if p not in ("", _script_dir)]
-
-try:
-    from fastapi import FastAPI
-    from fastapi.staticfiles import StaticFiles
-    from fastapi.responses import HTMLResponse, RedirectResponse
-    from fastapi.middleware.cors import CORSMiddleware
-    from fastapi.middleware.gzip import GZipMiddleware
-    import uvicorn
-except ImportError:
-    raise ImportError(
-        "FastAPI dependencies not installed. "
-        "Install with: pip install 'fastapi[all]' uvicorn websockets"
-    )
-
-from superlocalmemory.server.security_middleware import SecurityHeadersMiddleware
-
-# V3 Paths — reuse the lazy resolvers from routes.helpers so the dashboard
-# honours SLM_DATA_DIR / SL_MEMORY_PATH / SLM_HOME / config.json:base_dir
-# exactly like the CLI. Previously this hardcoded ~/.superlocalmemory, which
-# caused dashboard-created profiles to land in a different memory.db than
-# `slm profile list` reads when a custom data dir was configured.
-from superlocalmemory.server.routes.helpers import MEMORY_DIR, DB_PATH
-# V3.3.21+: the dashboard ships inside the package (superlocalmemory/ui) for
-# every install path — pip, npm, and editable checkouts. The legacy repo-root
-# ui/ dev fallback was retired in v3.8.0 when that copy was deleted; the
-# packaged directory is authoritative. A missing dir is surfaced at request
-# time (see the "UI not found" handler below).
-UI_DIR = Path(__file__).resolve().parent.parent / "ui"
-
-
-def create_app() -> FastAPI:
-    """Create and configure the FastAPI application."""
-    application = FastAPI(
-        title="SuperLocalMemory V4 UI Server",
-        description="Governed memory dashboard with trust, learning, and compliance controls.",
-        version=SLM_VERSION,
-        docs_url="/api/docs",
-        redoc_url="/api/redoc",
-    )
-
-    # Middleware (order matters: security headers should be outermost)
-    application.add_middleware(SecurityHeadersMiddleware)
-    application.add_middleware(GZipMiddleware, minimum_size=1000)
-    application.add_middleware(
-        CORSMiddleware,
-        allow_origins=[
-            "http://localhost:8765", "http://127.0.0.1:8765",
-            "http://localhost:8417", "http://127.0.0.1:8417",
-        ],
-        allow_credentials=True,
-        allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
-        allow_headers=["Content-Type", "Authorization", "X-SLM-API-Key"],
-    )
-
-    # Rate limiting (graceful)
-    try:
-        from superlocalmemory.infra.rate_limiter import RateLimiter
-        from superlocalmemory.core.remote_mode import (
-            rate_limit_config,
-            is_rate_limit_exempt,
-        )
-        # v3.6.12 (issue #40): env-tunable thresholds (defaults unchanged).
-        _rl_write, _rl_read, _rl_window = rate_limit_config()
-        _write_limiter = RateLimiter(max_requests=_rl_write, window_seconds=_rl_window)
-        _read_limiter = RateLimiter(max_requests=_rl_read, window_seconds=_rl_window)
-
-        # Task #47: register for runtime reconfiguration via the dashboard.
-        try:
-            from superlocalmemory.infra.rate_limiter import (
-                register_managed as _reg_rl,
-            )
-            _reg_rl("write", _write_limiter)
-            _reg_rl("read", _read_limiter)
-        except Exception:
-            pass
-
-        @application.middleware("http")
-        async def rate_limit_middleware(request, call_next):
-            client_ip = request.client.host if request.client else "unknown"
-            if is_rate_limit_exempt(client_ip):
-                return await call_next(request)
-            is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
-            limiter = _write_limiter if is_write else _read_limiter
-            allowed, remaining = limiter.is_allowed(client_ip)
-            if not allowed:
-                from fastapi.responses import JSONResponse
-                return JSONResponse(
-                    status_code=429,
-                    content={"error": "Too many requests. Please slow down."},
-                    headers={"Retry-After": str(limiter.window)},
-                )
-            response = await call_next(request)
-            response.headers["X-RateLimit-Remaining"] = str(remaining)
-            return response
-    except (ImportError, Exception):
-        pass
-
-    # Auth middleware (graceful)
-    try:
-        from superlocalmemory.infra.auth_middleware import check_api_key
-
-        @application.middleware("http")
-        async def auth_middleware(request, call_next):
-            is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
-            headers = dict(request.headers)
-            if not check_api_key(headers, is_write=is_write):
-                from fastapi.responses import JSONResponse
-                return JSONResponse(
-                    status_code=401,
-                    content={"error": "Invalid or missing API key."},
-                )
-            response = await call_next(request)
-            return response
-    except (ImportError, Exception):
-        pass
-
-    # Mount static files (UI directory)
-    UI_DIR.mkdir(exist_ok=True)
-    application.mount("/static", StaticFiles(directory=str(UI_DIR)), name="static")
-
-    # ========================================================================
-    # Register Route Modules
-    # ========================================================================
-    from superlocalmemory.server.routes.memories import router as memories_router
-    from superlocalmemory.server.routes.stats import router as stats_router
-    from superlocalmemory.server.routes.profiles import router as profiles_router
-    from superlocalmemory.server.routes.backup import router as backup_router
-    from superlocalmemory.server.routes.data_io import router as data_io_router
-    from superlocalmemory.server.routes.events import router as events_router, register_event_listener
-    from superlocalmemory.server.routes.agents import router as agents_router
-    from superlocalmemory.server.routes.ws import router as ws_router, manager as ws_manager
-
-    application.include_router(memories_router)
-    application.include_router(stats_router)
-    application.include_router(profiles_router)
-    application.include_router(backup_router)
-    application.include_router(data_io_router)
-    application.include_router(events_router)
-    application.include_router(agents_router)
-    application.include_router(ws_router)
-
-    # V3 API endpoints (dashboard, mode, trust, math, etc.)
-    from superlocalmemory.server.routes.v3_api import router as v3_router
-    application.include_router(v3_router)
-
-    # Config endpoints (storage, daemon, mesh, trust, forgetting)
-    from superlocalmemory.server.routes.config_api import router as config_api_router
-    application.include_router(config_api_router)
-
-    # v3.4.1: Chat SSE + Insights + Timeline endpoints
-    for _module_name_v341 in ("chat",):
-        try:
-            _mod_v341 = __import__(f"superlocalmemory.server.routes.{_module_name_v341}", fromlist=["router"])
-            application.include_router(_mod_v341.router)
-        except (ImportError, Exception) as _exc:
-            logger.warning("Optional router %s failed: %s", _module_name_v341, _exc)
-
-    # Graceful optional routers
-    for _module_name in ("learning", "lifecycle", "behavioral", "compliance"):
-        try:
-            _mod = __import__(f"superlocalmemory.server.routes.{_module_name}", fromlist=["router"])
-            application.include_router(_mod.router)
-        except (ImportError, Exception) as _exc:
-            # v3.6.12 (settings-3): was a silent `pass` — a transient import
-            # error in learning.py alone 404s 3 dashboard panes (Learning,
-            # Patterns, Feedback) with no trace. Log it like the chat loop above.
-            logger.warning("Optional router %s failed: %s", _module_name, _exc)
-
-    # Wire WebSocket manager into routes that need broadcast capability
-    import superlocalmemory.server.routes.profiles as _profiles_mod
-    import superlocalmemory.server.routes.data_io as _data_io_mod
-    _profiles_mod.ws_manager = ws_manager
-    _data_io_mod.ws_manager = ws_manager
-
-    # ========================================================================
-    # Basic Routes (root page + health check)
-    # ========================================================================
-
-    @application.get("/", response_class=HTMLResponse)
-    async def root():
-        """Serve main UI page."""
-        index_path = UI_DIR / "index.html"
-        if not index_path.exists():
-            return (
-                "<!DOCTYPE html><html><head>"
-                "<title>SuperLocalMemory V4</title></head>"
-                "<body style='font-family:Arial;padding:40px'>"
-                "<h1>SuperLocalMemory V4 UI Server Running</h1>"
-                "<p>UI not found. Check ui/index.html</p>"
-                "<p><a href='/api/docs'>API Documentation</a></p>"
-                "</body></html>"
-            )
-        from superlocalmemory import __version__ as _v
-
-        # __SLM_VERSION__ was substituted only by the unified daemon, so the
-        # dashboard's upgrade detector did nothing when served from here.
-        # Asset versioning is cosmetic. It must never be why this page 500s.
-        #
-        # The import is deferred (house style, keeps startup lean), which means
-        # it resolves at REQUEST time — so when `pip install -e .` replaced the
-        # installed package underneath a running daemon, this route began
-        # answering "Internal Server Error" on the dashboard while every other
-        # endpoint was fine. A stale hand-written version string is a trifle; a
-        # blank page is not. Fall back to the file as written.
-        try:
-            from superlocalmemory.server.asset_versions import render_index
-
-            return render_index(
-                index_path, UI_DIR, substitutions={"__SLM_VERSION__": _v},
-            )
-        except Exception as exc:  # noqa: BLE001 — serve the page regardless
-            logger.warning(
-                "asset version rewrite unavailable, serving index.html as "
-                "written: %s: %s", type(exc).__name__, exc,
-            )
-            return index_path.read_text().replace("__SLM_VERSION__", _v)
-
-    @application.get("/favicon.ico", include_in_schema=False)
-    async def favicon():
-        """Serve the packaged SVG icon for browsers that request favicon.ico."""
-        return RedirectResponse(url="/static/favicon.svg", status_code=307)
-
-    @application.get("/health")
-    async def health_check():
-        """Health check endpoint."""
-        return {
-            "status": "healthy",
-            "version": SLM_VERSION,
-            "database": "connected" if DB_PATH.exists() else "missing",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
-
-    # ========================================================================
-    # Startup Events
-    # ========================================================================
-
-    @application.on_event("startup")
-    async def startup_event():
-        """Initialize event bus and warm up worker subprocess.
-
-        Engine runs in subprocess worker (never in this process).
-        Background warmup pre-loads PyTorch + models so first recall is fast.
-        """
-        application.state.engine = None
-        logger.info("Dashboard started (~60 MB, engine runs in subprocess worker)")
-        register_event_listener()
-
-        # Background warmup: pre-spawn worker and load all models.
-        # This runs in a daemon thread — dashboard is responsive immediately.
-        # Worker will be ready by the time user does first search (~10-30s).
-        try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            WorkerPool.shared().warmup()
-            logger.info("Worker warmup initiated (background)")
-        except Exception as exc:
-            logger.warning("Worker warmup failed to start: %s", exc)
-
-    @application.on_event("shutdown")
-    async def shutdown_event():
-        """Kill worker subprocess on dashboard shutdown."""
-        try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            WorkerPool.shared().shutdown()
-        except Exception:
-            pass
-
-    return application
-
-
-app = create_app()
-
-# ============================================================================
-# Server Startup
-# ============================================================================
-
-if __name__ == "__main__":
-    import argparse
-    import socket
-
-    parser = argparse.ArgumentParser(description="SuperLocalMemory V4 - Web Dashboard")
-    parser.add_argument("--port", type=int, default=8765, help="Port (default 8765)")
-    parser.add_argument("--profile", type=str, default=None, help="Memory profile")
-    args = parser.parse_args()
-
-    def find_available_port(preferred: int) -> int:
-        for port in [preferred] + list(range(preferred + 1, preferred + 20)):
-            try:
-                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                    s.bind(("127.0.0.1", port))
-                    return port
-            except OSError:
-                continue
-        return preferred
-
-    ui_port = find_available_port(args.port)
-    if ui_port != args.port:
-        print(f"\n  Port {args.port} in use -- using {ui_port} instead\n")
-
-    print("=" * 70)
-    print("  SuperLocalMemory V4 - Web Dashboard")
-    print("  Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar")
-    print("=" * 70)
-    print(f"  Database:  {DB_PATH}")
-    print(f"  UI:        {UI_DIR}")
-    print("=" * 70)
-    print(f"\n  Dashboard:   http://localhost:{ui_port}")
-    print(f"  API Docs:    http://localhost:{ui_port}/api/docs")
-    print(f"  Health:      http://localhost:{ui_port}/health")
-    print(f"  SSE Stream:  http://localhost:{ui_port}/events/stream")
-    print(f"  WebSocket:   ws://localhost:{ui_port}/ws/updates")
-    print("\n  Press Ctrl+C to stop\n")
-
-    uvicorn.run(app, host="127.0.0.1", port=ui_port, log_level="info", access_log=True)