superlocalmemory 3.4.3 → 3.4.5

package/src/superlocalmemory/mcp/tools_mesh.py

@@ -0,0 +1,249 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SLM Mesh MCP Tools — P2P agent communication via the unified daemon.
+
+v3.4.4: These tools ship WITH SuperLocalMemory, no separate slm-mesh install needed.
+End users get full mesh functionality from `pip install superlocalmemory`.
+
+All tools communicate with the daemon's Python mesh broker on port 8765.
+Auto-heartbeat keeps the session alive as long as the MCP server is running.
+
+8 tools: mesh_summary, mesh_peers, mesh_send, mesh_inbox,
+         mesh_state, mesh_lock, mesh_events, mesh_status
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import time
+import uuid
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+# Unique peer ID for this MCP server session
+_PEER_ID = str(uuid.uuid4())[:12]
+_SESSION_SUMMARY = ""
+_HEARTBEAT_INTERVAL = 25  # seconds (broker marks stale at 30s, dead at 60s)
+_HEARTBEAT_THREAD: threading.Thread | None = None
+_REGISTERED = False
+
+
+def _daemon_url() -> str:
+    """Get the daemon base URL."""
+    port = 8765
+    try:
+        port_file = os.path.join(os.path.expanduser("~"), ".superlocalmemory", "daemon.port")
+        if os.path.exists(port_file):
+            port = int(open(port_file).read().strip())
+    except Exception:
+        pass
+    return f"http://127.0.0.1:{port}"
+
+
+def _mesh_request(method: str, path: str, body: dict | None = None) -> dict | None:
+    """Send request to daemon mesh broker."""
+    import urllib.request
+    url = f"{_daemon_url()}/mesh{path}"
+    try:
+        data = json.dumps(body).encode() if body else None
+        headers = {"Content-Type": "application/json"} if data else {}
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        resp = urllib.request.urlopen(req, timeout=10)
+        return json.loads(resp.read().decode())
+    except Exception as exc:
+        logger.debug("Mesh request failed: %s %s — %s", method, path, exc)
+        return None
+
+
+def _ensure_registered() -> None:
+    """Register this session with the mesh broker if not already."""
+    global _REGISTERED
+    if _REGISTERED:
+        return
+
+    result = _mesh_request("POST", "/register", {
+        "peer_id": _PEER_ID,
+        "session_id": os.environ.get("CLAUDE_SESSION_ID", _PEER_ID),
+        "summary": _SESSION_SUMMARY or "SLM MCP session",
+    })
+    if result:
+        _REGISTERED = True
+        _start_heartbeat()
+
+
+def _start_heartbeat() -> None:
+    """Background thread that sends heartbeat to keep session alive."""
+    global _HEARTBEAT_THREAD
+    if _HEARTBEAT_THREAD is not None:
+        return
+
+    def heartbeat_loop():
+        while True:
+            time.sleep(_HEARTBEAT_INTERVAL)
+            try:
+                _mesh_request("POST", "/heartbeat", {"peer_id": _PEER_ID})
+            except Exception:
+                pass
+
+    _HEARTBEAT_THREAD = threading.Thread(target=heartbeat_loop, daemon=True, name="mesh-heartbeat")
+    _HEARTBEAT_THREAD.start()
+    logger.info("Mesh heartbeat started (peer_id=%s, interval=%ds)", _PEER_ID, _HEARTBEAT_INTERVAL)
+
+
+def register_mesh_tools(server, get_engine: Callable) -> None:
+    """Register all 8 mesh MCP tools."""
+
+    @server.tool()
+    async def mesh_summary(summary: str = "") -> dict:
+        """Register this session and describe what you're working on.
+
+        Call this at the start of every session. Other agents can see your summary
+        and send you messages. The session stays alive via automatic heartbeat.
+
+        Args:
+            summary: What this session is working on (e.g. "Fixing auth bug in api.py")
+        """
+        global _SESSION_SUMMARY
+        _SESSION_SUMMARY = summary or "Active session"
+
+        _ensure_registered()
+
+        # Update summary
+        result = _mesh_request("POST", "/summary", {
+            "peer_id": _PEER_ID,
+            "summary": _SESSION_SUMMARY,
+        })
+
+        return {
+            "peer_id": _PEER_ID,
+            "summary": _SESSION_SUMMARY,
+            "registered": True,
+            "heartbeat_active": _HEARTBEAT_THREAD is not None,
+            "broker_response": result,
+        }
+
+    @server.tool()
+    async def mesh_peers() -> dict:
+        """List all active peer sessions on this machine.
+
+        Shows other Claude Code, Cursor, or AI agent sessions that are
+        connected to the same SLM mesh network.
+        """
+        _ensure_registered()
+        result = _mesh_request("GET", "/peers")
+        peers = (result or {}).get("peers", [])
+        return {
+            "peers": peers,
+            "count": len(peers),
+            "my_peer_id": _PEER_ID,
+        }
+
+    @server.tool()
+    async def mesh_send(to: str, message: str) -> dict:
+        """Send a message to another peer session.
+
+        Args:
+            to: The peer_id of the recipient (from mesh_peers)
+            message: The message content to send
+        """
+        _ensure_registered()
+        result = _mesh_request("POST", "/send", {
+            "from_peer": _PEER_ID,
+            "to_peer": to,
+            "content": message,
+        })
+        return result or {"error": "Failed to send message"}
+
+    @server.tool()
+    async def mesh_inbox() -> dict:
+        """Read messages sent to this session.
+
+        Returns unread messages from other peer sessions.
+        Messages are marked as read after retrieval.
+        """
+        _ensure_registered()
+        messages = _mesh_request("GET", f"/inbox/{_PEER_ID}")
+        if messages:
+            # Mark as read
+            _mesh_request("POST", f"/inbox/{_PEER_ID}/read")
+        return messages or {"messages": [], "count": 0}
+
+    @server.tool()
+    async def mesh_state(key: str = "", value: str = "", action: str = "get") -> dict:
+        """Get or set shared state across all sessions.
+
+        Shared state is visible to all peers. Use for coordinating work:
+        server IPs, API keys, feature flags, task assignments.
+
+        Args:
+            key: State key name
+            value: Value to set (only for action="set")
+            action: "get" (read all or one key), "set" (write a key)
+        """
+        _ensure_registered()
+
+        if action == "set" and key:
+            result = _mesh_request("POST", "/state", {
+                "key": key,
+                "value": value,
+                "set_by": _PEER_ID,
+            })
+            return result or {"error": "Failed to set state"}
+
+        if key:
+            result = _mesh_request("GET", f"/state/{key}")
+            return result or {"key": key, "value": None}
+
+        result = _mesh_request("GET", "/state")
+        return result or {"state": {}}
+
+    @server.tool()
+    async def mesh_lock(
+        file_path: str,
+        action: str = "query",
+    ) -> dict:
+        """Manage file locks across sessions.
+
+        Before editing a shared file, check if another session has it locked.
+
+        Args:
+            file_path: Path to the file
+            action: "query" (check lock), "acquire" (lock file), "release" (unlock)
+        """
+        _ensure_registered()
+        result = _mesh_request("POST", "/lock", {
+            "file_path": file_path,
+            "action": action,
+            "locked_by": _PEER_ID,
+        })
+        return result or {"error": "Lock operation failed"}
+
+    @server.tool()
+    async def mesh_events() -> dict:
+        """Get recent mesh events (peer joins, leaves, messages, state changes).
+
+        Shows the activity log of the mesh network.
+        """
+        result = _mesh_request("GET", "/events")
+        return result or {"events": []}
+
+    @server.tool()
+    async def mesh_status() -> dict:
+        """Get mesh broker health and statistics.
+
+        Shows broker uptime, peer count, and connection status.
+        """
+        result = _mesh_request("GET", "/status")
+        if result:
+            result["my_peer_id"] = _PEER_ID
+            result["heartbeat_active"] = _HEARTBEAT_THREAD is not None
+        return result or {
+            "broker_up": False,
+            "error": "Cannot reach mesh broker. Is the daemon running? (slm serve start)",
+        }

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

@@ -0,0 +1,63 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Ingestion adapter management API — enable/disable/start/stop from dashboard.
+
+v3.4.4: Users can manage Gmail, Calendar, Transcript adapters entirely from
+the dashboard UI — no CLI needed. The best product experience.
+
+Endpoints:
+  GET  /api/adapters         — list all adapters with status
+  POST /api/adapters/enable  — enable an adapter
+  POST /api/adapters/disable — disable an adapter
+  POST /api/adapters/start   — start a running adapter
+  POST /api/adapters/stop    — stop a running adapter
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+router = APIRouter(tags=["adapters"])
+
+
+class AdapterAction(BaseModel):
+    name: str
+
+
+@router.get("/api/adapters")
+async def list_adapters_api():
+    """List all adapters with their enabled/running status."""
+    from superlocalmemory.ingestion.adapter_manager import list_adapters
+    adapters = list_adapters()
+    return {"adapters": adapters}
+
+
+@router.post("/api/adapters/enable")
+async def enable_adapter_api(body: AdapterAction):
+    """Enable an adapter (doesn't start it yet)."""
+    from superlocalmemory.ingestion.adapter_manager import enable_adapter
+    return enable_adapter(body.name)
+
+
+@router.post("/api/adapters/disable")
+async def disable_adapter_api(body: AdapterAction):
+    """Disable and stop an adapter."""
+    from superlocalmemory.ingestion.adapter_manager import disable_adapter
+    return disable_adapter(body.name)
+
+
+@router.post("/api/adapters/start")
+async def start_adapter_api(body: AdapterAction):
+    """Start a running adapter subprocess."""
+    from superlocalmemory.ingestion.adapter_manager import start_adapter
+    return start_adapter(body.name)
+
+
+@router.post("/api/adapters/stop")
+async def stop_adapter_api(body: AdapterAction):
+    """Stop a running adapter."""
+    from superlocalmemory.ingestion.adapter_manager import stop_adapter
+    return stop_adapter(body.name)

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

@@ -11,6 +11,62 @@ from fastapi import APIRouter, HTTPException, Request, Query
 router = APIRouter(prefix="/api/entity", tags=["entity"])
 
 
+@router.get("/list")
+async def list_entities(
+    request: Request,
+    profile: str = Query(default="default"),
+    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 = request.app.state.engine
+    if engine is None:
+        raise HTTPException(503, detail="Engine not initialized")
+
+    import sqlite3
+    import json
+    conn = sqlite3.connect(str(engine._config.db_path))
+    conn.row_factory = sqlite3.Row
+    try:
+        total = conn.execute(
+            "SELECT COUNT(*) FROM canonical_entities WHERE profile_id = ?",
+            (profile,),
+        ).fetchone()[0]
+
+        rows = conn.execute("""
+            SELECT ce.entity_id, ce.canonical_name, ce.entity_type,
+                   ce.fact_count, ce.first_seen, ce.last_seen,
+                   ep.knowledge_summary, ep.compiled_truth,
+                   ep.compilation_confidence, ep.last_compiled_at
+            FROM canonical_entities ce
+            LEFT JOIN entity_profiles ep
+              ON ce.entity_id = ep.entity_id AND ep.profile_id = ce.profile_id
+            WHERE ce.profile_id = ?
+            ORDER BY ce.fact_count DESC
+            LIMIT ? OFFSET ?
+        """, (profile, limit, offset)).fetchall()
+
+        entities = []
+        for r in rows:
+            summary = r["knowledge_summary"] or ""
+            entities.append({
+                "entity_id": r["entity_id"],
+                "name": r["canonical_name"],
+                "type": r["entity_type"] or "unknown",
+                "fact_count": r["fact_count"] or 0,
+                "first_seen": r["first_seen"],
+                "last_seen": r["last_seen"],
+                "summary_preview": summary[:200] if summary else "",
+                "has_compiled_truth": bool(r["compiled_truth"]),
+                "confidence": r["compilation_confidence"] or 0.5,
+                "last_compiled_at": r["last_compiled_at"],
+            })
+
+        return {"entities": entities, "total": total, "limit": limit, "offset": offset}
+    finally:
+        conn.close()
+
+
 @router.get("/{entity_name}")
 async def get_entity(
     entity_name: str,

package/src/superlocalmemory/server/unified_daemon.py

@@ -465,6 +465,7 @@ def _register_dashboard_routes(application: FastAPI) -> None:
     from superlocalmemory.server.routes.agents import router as agents_router
     from superlocalmemory.server.routes.ws import router as ws_router, manager as ws_manager
     from superlocalmemory.server.routes.v3_api import router as v3_router
+    from superlocalmemory.server.routes.adapters import router as adapters_router
 
     application.include_router(memories_router)
     application.include_router(stats_router)
@@ -475,6 +476,7 @@ def _register_dashboard_routes(application: FastAPI) -> None:
     application.include_router(agents_router)
     application.include_router(ws_router)
     application.include_router(v3_router)
+    application.include_router(adapters_router)
 
     # v3.4.1 chat SSE
     for _mod_name in ("chat",):