superlocalmemory 3.8.3 → 3.8.6

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

@@ -11,7 +11,7 @@ import logging
 import os
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse
-from superlocalmemory.server.routes.helpers import SLM_VERSION
+from superlocalmemory.server.routes.helpers import SLM_VERSION, get_read_connection
 from superlocalmemory.server.route_mutations import authorize_route_mutation
 
 logger = logging.getLogger(__name__)
@@ -101,13 +101,12 @@ async def dashboard(request: Request):
         active_profile = get_profile_runtime(request.app.state).snapshot.profile_id
 
         # Read stats directly from SQLite (dashboard doesn't load engine)
-        import sqlite3
         memory_count = 0
         fact_count = 0
         db_path = config.base_dir / "memory.db"
         if db_path.exists():
             try:
-                conn = sqlite3.connect(str(db_path))
+                conn = get_read_connection(db_path)
                 cursor = conn.cursor()
                 try:
                     cursor.execute(
@@ -358,7 +357,10 @@ async def get_embedding_config(request: Request):
     """Return current embedding configuration."""
     try:
         from superlocalmemory.core.config import SLMConfig
-        config = SLMConfig.load()
+        # The daemon may already be running a freshly hot-swapped config while
+        # a profile update is still being persisted.  The dashboard must show
+        # that live truth, never silently replace it with disk defaults.
+        config = getattr(request.app.state, "config", None) or SLMConfig.load()
         emb = config.embedding
         return {
             "provider": emb.provider,
@@ -382,7 +384,7 @@ async def set_embedding_config(request: Request):
     try:
         body = await request.json()
         from superlocalmemory.core.config import SLMConfig, EmbeddingConfig
-        config = SLMConfig.load()
+        config = getattr(request.app.state, "config", None) or SLMConfig.load()
 
         new_provider = body.get("provider", config.embedding.provider)
         new_model = body.get("model_name", config.embedding.model_name)
@@ -596,7 +598,9 @@ def _validate_provider_url(url: str, client_host: str) -> str | None:
     host = p.hostname or ""
     if host.lower() in ("169.254.169.254", "metadata.google.internal", "metadata"):
         return "Cloud metadata endpoints are not allowed"
-    if client_host in ("127.0.0.1", "::1", "localhost"):
+    from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
+
+    if _is_loopback_host(client_host):
         return None  # local dashboard may target its own local/LAN endpoints
     # SLM_REMOTE residue (#40): an allowlisted LAN dashboard is trusted exactly
     # like the loopback one and may probe its own LAN LLM endpoint. This does
@@ -1420,7 +1424,7 @@ async def get_associations(
         if not DB_PATH.exists():
             return {"edges": [], "total": 0}
 
-        conn = sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = sqlite3.Row
 
         # Build query with optional type filter (parameterized)
@@ -1493,7 +1497,7 @@ async def get_association_stats(request: Request, profile: str = ""):
                 "top_connected_facts": [],
             }
 
-        conn = sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = sqlite3.Row
 
         # Total edges
@@ -1605,7 +1609,7 @@ async def get_consolidation_status(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return result
 
-        conn = sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = sqlite3.Row
 
         # Last consolidation log entry
@@ -1757,7 +1761,7 @@ async def get_core_memory(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return {"blocks": [], "total_chars": 0, "char_limit": 2000}
 
-        conn = sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = sqlite3.Row
 
         rows = conn.execute(
@@ -1808,7 +1812,7 @@ async def update_core_memory_block(block_id: str, request: Request):
             )
 
         from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile
-        import sqlite3
+        from superlocalmemory.storage.memory_write import memory_write
         from datetime import datetime, timezone
 
         if not DB_PATH.exists():
@@ -1827,46 +1831,38 @@ async def update_core_memory_block(block_id: str, request: Request):
             content_preview=str(content),
         )
 
-        conn = sqlite3.connect(str(DB_PATH))
-        conn.row_factory = sqlite3.Row
-
-        # Verify block exists
-        existing = conn.execute(
-            "SELECT block_id, profile_id, block_type, version "
-            "FROM core_memory_blocks WHERE block_id = ? AND profile_id = ?",
-            (block_id, pid),
-        ).fetchone()
-
-        if not existing:
-            conn.close()
-            return JSONResponse(
-                {"error": f"Block {block_id} not found"},
-                status_code=404,
-            )
-
-        existing_dict = dict(existing)
-        new_version = existing_dict["version"] + 1
         now = datetime.now(timezone.utc).isoformat()
+        # memory_write: process write lock + busy_timeout.
+        # SELECT + UPDATE + read-back are atomic inside the same connection.
+        with memory_write(DB_PATH) as conn:
+            # Verify block exists
+            existing = conn.execute(
+                "SELECT block_id, profile_id, block_type, version "
+                "FROM core_memory_blocks WHERE block_id = ? AND profile_id = ?",
+                (block_id, pid),
+            ).fetchone()
 
-        conn.execute(
-            "UPDATE core_memory_blocks SET content = ?, char_count = ?, "
-            "version = ?, compiled_by = 'manual', updated_at = ? "
-            "WHERE block_id = ? AND profile_id = ?",
-            (content, len(content), new_version, now, block_id, pid),
-        )
-        conn.commit()
+            if not existing:
+                raise HTTPException(status_code=404, detail=f"Block {block_id} not found")
 
-        # Read back updated block
-        updated = conn.execute(
-            "SELECT block_id, block_type, content, char_count, version, "
-            "compiled_by, updated_at FROM core_memory_blocks "
-            "WHERE block_id = ? AND profile_id = ?",
-            (block_id, pid),
-        ).fetchone()
-        conn.close()
+            new_version = dict(existing)["version"] + 1
+            conn.execute(
+                "UPDATE core_memory_blocks SET content = ?, char_count = ?, "
+                "version = ?, compiled_by = 'manual', updated_at = ? "
+                "WHERE block_id = ? AND profile_id = ?",
+                (content, len(content), new_version, now, block_id, pid),
+            )
+            # Read back updated block while connection is still open.
+            updated = conn.execute(
+                "SELECT block_id, block_type, content, char_count, version, "
+                "compiled_by, updated_at FROM core_memory_blocks "
+                "WHERE block_id = ? AND profile_id = ?",
+                (block_id, pid),
+            ).fetchone()
+            updated_dict = dict(updated) if updated else {"block_id": block_id, "updated": True}
 
         authorization.complete()
-        return dict(updated) if updated else {"block_id": block_id, "updated": True}
+        return updated_dict
     except HTTPException:
         raise
     except Exception as e:
@@ -1907,7 +1903,7 @@ async def get_vector_store_status(request: Request, profile: str = ""):
         # Count vectors in embedding_metadata
         if DB_PATH.exists():
             try:
-                conn = sqlite3.connect(str(DB_PATH))
+                conn = get_read_connection(DB_PATH)
                 count = conn.execute(
                     "SELECT COUNT(*) FROM embedding_metadata WHERE profile_id = ?",
                     (pid,),
@@ -1951,7 +1947,7 @@ async def forgetting_stats(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return {"total": total, "zones": zones}
 
-        conn = _sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = _sqlite3.Row
 
         try:
@@ -1990,7 +1986,7 @@ async def run_forgetting(request: Request):
         profile = body.get("profile", "")
 
         from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
+        from superlocalmemory.storage.memory_write import memory_write as _memory_write
         pid = _resolve_mutation_profile(profile)
         _require_manage_for_profile(request, pid)
 
@@ -2003,59 +1999,55 @@ async def run_forgetting(request: Request):
             source_agent_id="http-forgetting-run",
             profile_id=pid,
         )
-        conn = _sqlite3.connect(str(DB_PATH))
-        conn.row_factory = _sqlite3.Row
 
+        # memory_write: process write lock + busy_timeout — all UPDATEs atomic.
         updated = 0
         try:
-            # Apply Ebbinghaus decay: reduce retention for facts not accessed recently
-            # Formula: retention *= exp(-0.1) for each cycle (simplified batch decay)
-            conn.execute(
-                "UPDATE fact_retention "
-                "SET retention_score = MAX(0.0, retention_score * 0.9), "
-                "    last_computed_at = datetime('now') "
-                "WHERE profile_id = ? "
-                "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                (pid,),
-            )
-            updated = conn.total_changes
-
-            # Transition zones based on new retention scores
-            zone_thresholds = [
-                ("forgotten", 0.05),
-                ("archive", 0.15),
-                ("cold", 0.35),
-                ("warm", 0.65),
-            ]
-            for zone, threshold in zone_thresholds:
+            with _memory_write(DB_PATH) as conn:
+                # Apply Ebbinghaus decay: reduce retention for facts not accessed recently
+                # Formula: retention *= exp(-0.1) for each cycle (simplified batch decay)
                 conn.execute(
                     "UPDATE fact_retention "
-                    "SET lifecycle_zone = ? "
+                    "SET retention_score = MAX(0.0, retention_score * 0.9), "
+                    "    last_computed_at = datetime('now') "
                     "WHERE profile_id = ? "
-                    "AND retention_score < ? "
                     "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                    (zone, pid, threshold),
+                    (pid,),
                 )
+                updated = conn.total_changes
+
+                # Transition zones based on new retention scores
+                zone_thresholds = [
+                    ("forgotten", 0.05),
+                    ("archive", 0.15),
+                    ("cold", 0.35),
+                    ("warm", 0.65),
+                ]
+                for zone, threshold in zone_thresholds:
+                    conn.execute(
+                        "UPDATE fact_retention "
+                        "SET lifecycle_zone = ? "
+                        "WHERE profile_id = ? "
+                        "AND retention_score < ? "
+                        "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
+                        (zone, pid, threshold),
+                    )
 
-            # Ensure high-retention facts are active
-            conn.execute(
-                "UPDATE fact_retention "
-                "SET lifecycle_zone = 'active' "
-                "WHERE profile_id = ? AND retention_score >= 0.65 "
-                "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                (pid,),
-            )
-
-            from superlocalmemory.core.lifecycle_state import reconcile_profile_lifecycle
-            reconcile_profile_lifecycle(conn, pid)
+                # Ensure high-retention facts are active
+                conn.execute(
+                    "UPDATE fact_retention "
+                    "SET lifecycle_zone = 'active' "
+                    "WHERE profile_id = ? AND retention_score >= 0.65 "
+                    "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
+                    (pid,),
+                )
 
-            conn.commit()
+                from superlocalmemory.core.lifecycle_state import reconcile_profile_lifecycle
+                reconcile_profile_lifecycle(conn, pid)
         except Exception as exc:
             logger.exception("run_forgetting decay failed")
-            conn.close()
             return {"success": False, "error": "internal error"}
 
-        conn.close()
         authorization.complete()
         return {"success": True, "facts_decayed": updated, "profile": pid}
     except HTTPException:
@@ -2081,7 +2073,7 @@ async def quantization_stats(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return {"total": total, "tiers": tiers, "compression_ratio": compression_ratio}
 
-        conn = _sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = _sqlite3.Row
 
         try:
@@ -2140,7 +2132,7 @@ async def ccq_blocks(request: Request, profile: str = "", limit: int = 50):
         if not DB_PATH.exists():
             return {"blocks": [], "total": 0}
 
-        conn = _sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = _sqlite3.Row
 
         blocks = []
@@ -2200,7 +2192,7 @@ async def get_soft_prompts(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return {"prompts": [], "total": 0, "total_tokens": 0}
 
-        conn = _sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = _sqlite3.Row
 
         prompts = []
@@ -2308,7 +2300,7 @@ async def get_graph_communities(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return {"communities": [], "total": 0}
 
-        conn = sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = sqlite3.Row
 
         # Get community member counts and average pagerank
@@ -2475,7 +2467,7 @@ async def v33_overview(request: Request, profile: str = ""):
         if not DB_PATH.exists():
             return overview
 
-        conn = _sqlite3.connect(str(DB_PATH))
+        conn = get_read_connection(DB_PATH)
         conn.row_factory = _sqlite3.Row
 
         # Forgetting stats