superlocalmemory 3.7.8 → 3.8.1

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

@@ -12,13 +12,17 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 from __future__ import annotations
 
 import re
-from typing import Optional
+from datetime import datetime, timedelta, timezone
 
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
 router = APIRouter(prefix="/mesh", tags=["mesh"])
 
+_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
+_STALE_AFTER = timedelta(minutes=5)
+_EXPIRE_AFTER = timedelta(minutes=30)
+
 
 # -- Request models --
 
@@ -88,6 +92,7 @@ def _get_broker(request: Request):
         client_host = request.client.host if request.client else ""
         if client_host not in ("127.0.0.1", "::1", "localhost"):
             import hmac
+
             from superlocalmemory.core.security_primitives import verify_install_token
 
             # Path 1: install token — dashboard/browser callers hold this and
@@ -120,6 +125,19 @@ def _get_broker(request: Request):
     return broker
 
 
+def _active_profile() -> str:
+    """Resolve the tenant (profile) for this mesh request.
+
+    The mesh is a per-tenant coordination bus: peers, messages, shared state,
+    and locks are all scoped to the active profile so one tenant never sees
+    another's coordination traffic. Resolved from the request ContextVar set by
+    ProfileRuntimeMiddleware (falls back to the configured active profile).
+    """
+    from superlocalmemory.server.routes.helpers import get_active_profile
+
+    return get_active_profile()
+
+
 _SECRET_KEY = re.compile(
     r"(?:^|[_\-.])(api[_\-.]?key|secret|token|password|credential)(?:$|[_\-.])",
     re.IGNORECASE,
@@ -140,56 +158,195 @@ def _reject_secret_state(key: str, value: str) -> None:
 # -- Routes --
 
 @router.post("/register")
-async def register(req: RegisterRequest, request: Request):
+def register(req: RegisterRequest, request: Request):
     broker = _get_broker(request)
     if not req.session_id:
         raise HTTPException(400, detail="session_id required")
     return broker.register_peer(
         req.session_id, req.summary, req.host, req.port,
-        req.project_path, req.agent_type,
+        req.project_path, req.agent_type, profile_id=_active_profile(),
     )
 
 
 @router.post("/deregister")
-async def deregister(req: DeregisterRequest, request: Request):
+def deregister(req: DeregisterRequest, request: Request):
     broker = _get_broker(request)
-    result = broker.deregister_peer(req.peer_id)
+    result = broker.deregister_peer(req.peer_id, profile_id=_active_profile())
     if not result.get("ok"):
         raise HTTPException(404, detail=result.get("error", "peer not found"))
     return result
 
 
+def _peer_activity_counts(request: Request, session_ids: list[str]) -> dict:
+    """Per-session {tool_count, memory_count} for the active profile.
+
+    Each mesh peer IS an agent session, so its activity is the tool events it
+    logged and the memories it contributed under the current profile. Batched
+    to a single grouped query per table. Fail-soft: returns {} on any error so
+    the peer list still renders.
+    """
+    if not session_ids:
+        return {}
+    try:
+        from superlocalmemory.server.routes.helpers import (
+            get_active_profile,
+            get_engine_lazy,
+        )
+        engine = get_engine_lazy(request.app.state)
+        if engine is None:
+            return {}
+        profile = get_active_profile()
+        placeholders = ",".join("?" * len(session_ids))
+        params = [profile, *session_ids]
+        counts: dict[str, dict] = {sid: {"tool_count": 0, "memory_count": 0}
+                                   for sid in session_ids}
+        for table, key in (("tool_events", "tool_count"),
+                            ("memories", "memory_count")):
+            try:
+                rows = engine._db.execute(
+                    f"SELECT session_id, COUNT(*) AS n FROM {table} "
+                    f"WHERE profile_id = ? AND session_id IN ({placeholders}) "
+                    "GROUP BY session_id",
+                    tuple(params),
+                )
+                for r in rows:
+                    d = dict(r)
+                    sid = d.get("session_id")
+                    if sid in counts:
+                        counts[sid][key] = d.get("n", 0)
+            except Exception:
+                continue
+        return counts
+    except Exception:
+        return {}
+
+
+def _parse_heartbeat(value: object) -> datetime | None:
+    """Parse a stored heartbeat as UTC without trusting malformed values."""
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _mesh_read_model(records: list[dict]) -> tuple[list[dict], list[dict]]:
+    """Return bounded remote peers and local sessions with read-time liveness.
+
+    The broker persists local agent sessions in ``mesh_peers`` for messaging.
+    That storage detail must not make them look like remote mesh neighbours in
+    the dashboard. Classification is read-only so an ordinary dashboard GET
+    neither mutates a live database nor waits for the five-minute cleanup loop.
+    """
+    now = datetime.now(timezone.utc)
+    remote: list[dict] = []
+    local: list[dict] = []
+    for record in records:
+        heartbeat = _parse_heartbeat(record.get("last_heartbeat"))
+        if heartbeat is None:
+            continue
+        age = now - heartbeat
+        if age >= _EXPIRE_AFTER:
+            continue
+        stale_at = heartbeat + _STALE_AFTER
+        expires_at = heartbeat + _EXPIRE_AFTER
+        status = "active" if age < _STALE_AFTER else "stale"
+        normalized = {
+            **record,
+            "status": status,
+            "stale_at": stale_at.isoformat(),
+            "expires_at": expires_at.isoformat(),
+        }
+        if str(record.get("host") or "").lower() in _LOOPBACK_HOSTS:
+            local.append(normalized)
+        else:
+            remote.append(normalized)
+    return remote, local
+
+
+def _mesh_counts(remote: list[dict], local: list[dict]) -> dict:
+    """Expose active counts separately while retaining the legacy total key."""
+    active_remote = sum(peer["status"] == "active" for peer in remote)
+    active_local = sum(session["status"] == "active" for session in local)
+    return {
+        "peer_count": active_remote + active_local,
+        "active_peer_count": active_remote + active_local,
+        "remote_peer_count": active_remote,
+        "local_session_count": active_local,
+        "stale_peer_count": sum(peer["status"] == "stale" for peer in remote),
+        "stale_local_session_count": sum(session["status"] == "stale" for session in local),
+    }
+
+
 @router.get("/peers")
-async def peers(request: Request):
+def peers(request: Request, view: str = "all"):
     broker = _get_broker(request)
-    return {"peers": broker.list_all_peers()}
+    if view not in {"all", "remote", "local"}:
+        raise HTTPException(422, detail="view must be all, remote, or local")
+    remote_peers, local_sessions = _mesh_read_model(
+        broker.list_all_peers(_active_profile()),
+    )
+    peer_list = (
+        remote_peers if view == "remote" else
+        local_sessions if view == "local" else
+        [*remote_peers, *local_sessions]
+    )
+    session_ids = [p.get("session_id") for p in peer_list if p.get("session_id")]
+    counts = _peer_activity_counts(request, session_ids)
+    enriched = []
+    for p in peer_list:
+        c = counts.get(p.get("session_id"), {})
+        enriched.append({
+            **p,
+            "tool_count": c.get("tool_count", 0),
+            "memory_count": c.get("memory_count", 0),
+        })
+    return {
+        "peers": enriched,
+        "remote_peers": remote_peers,
+        "local_sessions": local_sessions,
+        "view": view,
+        **_mesh_counts(remote_peers, local_sessions),
+    }
 
 
 @router.post("/heartbeat")
-async def heartbeat(req: HeartbeatRequest, request: Request):
+def heartbeat(req: HeartbeatRequest, request: Request):
+    """Update peer liveness without blocking the daemon's async event loop."""
     broker = _get_broker(request)
-    result = broker.heartbeat(req.peer_id)
+    result = broker.heartbeat(req.peer_id, profile_id=_active_profile())
     if not result.get("ok"):
         raise HTTPException(404, detail=result.get("error", "peer not found"))
     return result
 
 
 @router.post("/summary")
-async def summary(req: SummaryRequest, request: Request):
+def summary(req: SummaryRequest, request: Request):
     broker = _get_broker(request)
-    result = broker.update_summary(req.peer_id, req.summary)
+    result = broker.update_summary(req.peer_id, req.summary,
+                                   profile_id=_active_profile())
     if not result.get("ok"):
         raise HTTPException(404, detail=result.get("error", "peer not found"))
     return result
 
 
 @router.post("/send")
-async def send(req: SendRequest, request: Request):
+def send(req: SendRequest, request: Request):
     broker = _get_broker(request)
     to_target = req.to_peer or req.to  # v3.4.6: accept both field names
     if not to_target:
         raise HTTPException(400, detail="'to' or 'to_peer' required")
-    result = broker.send_message(req.from_peer, to_target, req.content, req.type)
+    profile = _active_profile()
+    # This sync FastAPI route already runs in the worker thread pool, so the
+    # broker's SQLite retries and optional remote HTTP delivery cannot block
+    # the daemon event loop.
+    result = broker.send_message(
+        req.from_peer, to_target, req.content, req.type, "", profile,
+    )
     if not result.get("ok"):
         status = 413 if "too large" in result.get("error", "") else 404
         raise HTTPException(status, detail=result.get("error", ""))
@@ -197,66 +354,78 @@ async def send(req: SendRequest, request: Request):
 
 
 @router.get("/inbox/{peer_id}")
-async def inbox(peer_id: str, request: Request, project_path: str = ""):
+def inbox(peer_id: str, request: Request, project_path: str = ""):
     broker = _get_broker(request)
-    return {"messages": broker.get_inbox(peer_id, project_path)}
+    return {"messages": broker.get_inbox(peer_id, project_path,
+                                         profile_id=_active_profile())}
 
 
 @router.post("/inbox/{peer_id}/read")
-async def mark_read(peer_id: str, req: ReadRequest, request: Request):
+def mark_read(peer_id: str, req: ReadRequest, request: Request):
     broker = _get_broker(request)
-    return broker.mark_read(peer_id, req.message_ids)
+    return broker.mark_read(peer_id, req.message_ids,
+                            profile_id=_active_profile())
 
 
 @router.get("/pending/{peer_id}")
-async def pending(peer_id: str, request: Request, project_path: str = ""):
+def pending(peer_id: str, request: Request, project_path: str = ""):
     """Get pending broadcast/project messages for this peer."""
     broker = _get_broker(request)
-    messages = broker.get_pending(peer_id, project_path)
+    messages = broker.get_pending(peer_id, project_path,
+                                  profile_id=_active_profile())
     return {"messages": messages, "count": len(messages)}
 
 
 @router.get("/state")
-async def state_all(request: Request):
+def state_all(request: Request):
     broker = _get_broker(request)
-    return {"state": broker.get_state()}
+    return {"state": broker.get_state(profile_id=_active_profile())}
 
 
 @router.post("/state")
-async def state_set(req: StateSetRequest, request: Request):
+def state_set(req: StateSetRequest, request: Request):
     broker = _get_broker(request)
     if not req.key:
         raise HTTPException(400, detail="key required")
     _reject_secret_state(req.key, req.value)
-    return broker.set_state(req.key, req.value, req.set_by)
+    return broker.set_state(req.key, req.value, req.set_by,
+                            profile_id=_active_profile())
 
 
 @router.get("/state/{key}")
-async def state_get(key: str, request: Request):
+def state_get(key: str, request: Request):
     broker = _get_broker(request)
-    result = broker.get_state_key(key)
+    result = broker.get_state_key(key, profile_id=_active_profile())
     if result is None:
         raise HTTPException(404, detail="key not found")
     return result
 
 
 @router.post("/lock")
-async def lock(req: LockRequest, request: Request):
+def lock(req: LockRequest, request: Request):
     broker = _get_broker(request)
     if not req.file_path or not req.locked_by:
         raise HTTPException(400, detail="file_path and locked_by required")
     if req.action not in ("acquire", "release", "query"):
         raise HTTPException(400, detail="action must be acquire, release, or query")
-    return broker.lock_action(req.file_path, req.locked_by, req.action)
+    return broker.lock_action(req.file_path, req.locked_by, req.action,
+                              profile_id=_active_profile())
 
 
 @router.get("/events")
-async def events(request: Request):
+def events(request: Request):
     broker = _get_broker(request)
-    return {"events": broker.get_events()}
+    return {"events": broker.get_events(profile_id=_active_profile())}
 
 
 @router.get("/status")
-async def status(request: Request):
+def status(request: Request):
     broker = _get_broker(request)
-    return broker.get_status()
+    broker_status = broker.get_status(profile_id=_active_profile())
+    remote_peers, local_sessions = _mesh_read_model(
+        broker.list_all_peers(_active_profile()),
+    )
+    return {
+        **broker_status,
+        **_mesh_counts(remote_peers, local_sessions),
+    }

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

@@ -71,6 +71,36 @@ async def put_config(body: ConfigUpdateRequest) -> dict[str, Any]:
         raise HTTPException(status_code=500, detail=str(exc))
 
 
+@router.get("/status")
+async def get_status() -> dict[str, Any]:
+    """Concise enabled/disabled summary of each optimize sub-feature (M3).
+
+    REST-convention companion to `slm optimize status` (which reads config
+    locally). Returns a per-feature on/off view, the compression mode, and a
+    top-level `healthy` flag so external pollers have a stable endpoint.
+    """
+    try:
+        from superlocalmemory.optimize.config import get_shared_store
+        cfg = get_shared_store().get()
+        return {
+            "healthy": True,
+            "enabled": cfg.enabled,
+            "features": {
+                "proxy": cfg.proxy_enabled,
+                "cache": cfg.cache_enabled,
+                "compression": cfg.compress_enabled,
+                "semantic_cache": cfg.semantic_enabled,
+            },
+            "compress_mode": cfg.compress_mode,
+            "config_version": cfg.config_version,
+        }
+    except Exception as exc:
+        logger.warning("GET /api/optimize/status failed: %s", exc)
+        # Fail-open: report unhealthy rather than 500 so a poller can
+        # distinguish "daemon up but optimize degraded" from "daemon down".
+        return {"healthy": False, "error": "internal error"}
+
+
 @router.get("/savings")
 async def get_savings() -> dict[str, Any]:
     """Return savings estimates from live metrics + CacheDB.
@@ -91,7 +121,9 @@ async def get_savings() -> dict[str, Any]:
         )
 
         # F-03 fix: use module-level singleton instead of per-request instantiation
-        active_model = getattr(cfg, "active_model", "anthropic")
+        # DASH-V6 fix: attribute may EXIST but be None; getattr default only
+        # covers the missing case, so coerce None -> default to avoid .lower() crash.
+        active_model = getattr(cfg, "active_model", None) or "anthropic"
         # Determine provider from model
         provider = "anthropic"
         for key in ("anthropic", "openai", "gemini"):

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

@@ -154,6 +154,7 @@ def _upsert_cache(
     content: str, fact_ids: list[str],
 ) -> None:
     from superlocalmemory.core.context_cache import CacheEntry, ContextCache
+    from superlocalmemory.server.routes.helpers import get_active_profile
     cache = ContextCache()
     try:
         cache.upsert(CacheEntry(
@@ -163,6 +164,7 @@ def _upsert_cache(
             fact_ids=tuple(fact_ids),
             provenance="prewarm_post_tool",
             computed_at=int(time.time()),
+            profile_id=get_active_profile(),  # so non-default profiles hit
         ))
     finally:
         cache.close()

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

@@ -28,11 +28,18 @@ from .helpers import (
 from superlocalmemory.server.profile_runtime import (
     commit_daemon_profile_switch,
     get_profile_runtime,
+    TransitionDrainTimeout,
 )
 
 logger = logging.getLogger("superlocalmemory.routes.profiles")
 router = APIRouter()
 
+
+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("profiles route error")
+    return HTTPException(status_code=500, detail=detail)
+
 # WebSocket manager reference (set by ui_server.py at startup)
 ws_manager = None
 
@@ -85,8 +92,8 @@ async def list_profiles(request: Request):
             "total_profiles": len(profiles),
         }
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Profile list error: {str(e)}")
+    except Exception:
+        raise _internal_error("Profile list error")
 
 
 @router.post("/api/profiles/{name}/switch")
@@ -112,17 +119,36 @@ async def switch_profile(name: str, request: Request):
             source_agent_id="http-profile-switch",
             profile_id=name,
         )
+        # RBAC (C4): a logged-in user may only activate a workspace they belong
+        # to — this is the read boundary. Switching sets the active tenant for
+        # subsequent reads, so a non-member must not be able to enter it. The
+        # machine owner (no user session) switches freely.
+        from superlocalmemory.server.rbac_enforce import resolve_principal
+        _principal = resolve_principal(request)
+        if _principal.get("kind") == "user":
+            _rbac = getattr(request.app.state, "rbac", None)
+            if _rbac is not None and _rbac.get_role(_principal["user_id"], name) is None:
+                raise HTTPException(
+                    status_code=403,
+                    detail="You are not a member of this workspace.",
+                )
         runtime = get_profile_runtime(request.app.state)
         previous = runtime.snapshot.profile_id
-        snapshot = await asyncio.to_thread(
-            runtime.transition,
-            name,
-            lambda prior, target: commit_daemon_profile_switch(
-                request.app.state,
-                prior,
-                target,
-            ),
-        )
+        try:
+            snapshot = await asyncio.to_thread(
+                runtime.transition,
+                name,
+                lambda prior, target: commit_daemon_profile_switch(
+                    request.app.state,
+                    prior,
+                    target,
+                ),
+            )
+        except TransitionDrainTimeout as exc:
+            raise HTTPException(
+                status_code=503,
+                detail=str(exc),
+            )
 
         count = _get_memory_count(name)
 
@@ -143,8 +169,8 @@ async def switch_profile(name: str, request: Request):
 
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Profile switch error: {str(e)}")
+    except Exception:
+        raise _internal_error("Profile switch error")
 
 
 @router.post("/api/profiles/create")
@@ -166,18 +192,34 @@ async def create_profile(body: ProfileSwitch, request: Request):
             operation="update",
             source_agent_id="http-profile-create",
         )
+        # RBAC (C3): creating a tenant is an administrative action.
+        from superlocalmemory.access.rbac import Permission as _Perm
+        from superlocalmemory.server.rbac_enforce import require_manage as _rbac_manage
+        _principal = _rbac_manage(request)
         # Write to BOTH stores atomically
         desc = f'Memory profile: {name}'
         ensure_profile_in_db(name, desc)
         ensure_profile_in_json(name, desc)
 
+        # A logged-in user who creates a workspace becomes its admin so they
+        # can manage it immediately (profile_id == name here). The machine
+        # owner needs no membership row (implicit root).
+        if _principal.get("kind") == "user":
+            rbac = getattr(request.app.state, "rbac", None)
+            if rbac is not None:
+                try:
+                    rbac.set_membership(name, _principal["user_id"], "admin",
+                                        added_by=_principal["username"])
+                except Exception:
+                    pass
+
         authorization.complete()
         return {"success": True, "profile": name, "message": f"Profile '{name}' created"}
 
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Profile create error: {str(e)}")
+    except Exception:
+        raise _internal_error("Profile create error")
 
 
 @router.delete("/api/profiles/{name}")
@@ -204,6 +246,10 @@ async def delete_profile(name: str, request: Request):
             source_agent_id="http-profile-delete",
             profile_id=name,
         )
+        # RBAC (C3): deleting a tenant is administrative. Check MANAGE on the
+        # profile being deleted (not the active one).
+        from superlocalmemory.server.rbac_enforce import require_manage as _rbac_manage
+        _rbac_manage(request, profile=name)
         # Move data to default before deleting (bypasses CASCADE)
         conn = get_db_connection()
         cursor = conn.cursor()
@@ -243,5 +289,5 @@ async def delete_profile(name: str, request: Request):
 
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Profile delete error: {str(e)}")
+    except Exception:
+        raise _internal_error("Profile delete error")