superlocalmemory 3.4.3 → 3.4.5

package/README.md

@@ -2,9 +2,9 @@
   <img src="https://superlocalmemory.com/assets/logo-mark.png" alt="SuperLocalMemory" width="200"/>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.3</h1>
+<h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf & 17+ AI tools.</em></p>
-<p align="center"><code>v3.3.26</code> — Install once. Every session remembers the last. Automatically.</p>
+<p align="center"><code>v3.4.4 "Neural Glass"</code> — Install once. Every session remembers the last. Automatically.</p>
 <p align="center"><strong>Backed by 3 peer-reviewed research papers</strong> · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -22,6 +22,10 @@
   <a href="#dual-interface-mcp--cli"><img src="https://img.shields.io/badge/CLI-Agent--Native-green?style=for-the-badge" alt="CLI Agent-Native"/></a>
 </p>
 
+<p align="center">
+  <video src="https://github.com/user-attachments/assets/c3b54a1d-f62a-4ea7-bba7-900435e7b3ab" width="800" autoplay loop muted playsinline></video>
+</p>
+
 ---
 
 ## Why SuperLocalMemory?
@@ -339,21 +343,7 @@ Built-in compliance tools: GDPR Article 15/17 export + complete erasure, tamper-
 slm dashboard    # Opens at http://localhost:8765
 ```
 
-<details open>
-<summary><strong>Dashboard Screenshots</strong> (click to collapse)</summary>
-<p align="center"><img src="docs/screenshots/01-dashboard-main.png" alt="Dashboard Overview — 3,100+ memories, 430K connections" width="600"/></p>
-<p align="center">
-<img src="docs/screenshots/02-knowledge-graph.png" alt="Knowledge Graph — Sigma.js WebGL with community detection, chat, quick actions, timeline" width="290"/>
-<img src="docs/screenshots/06-graph-communities.png" alt="Graph Communities — Louvain clustering with colored nodes" width="290"/>
-</p>
-<p align="center">
-<img src="docs/screenshots/03-patterns-learning.png" alt="Patterns — 50 learned behavioral patterns with confidence bars" width="190"/>
-<img src="docs/screenshots/04-learning-dashboard.png" alt="Learning — 722 signals, ML Model phase, tech preferences" width="190"/>
-<img src="docs/screenshots/05-behavioral-analysis.png" alt="Behavioral — pattern analysis with confidence distribution" width="190"/>
-</p>
-</details>
-
-**v3.4.1 Visual Intelligence:** Sigma.js WebGL knowledge graph with community detection (Louvain/Leiden), 5 quick insight actions, D3 memory timeline, graph-enhanced retrieval (PageRank bias + community boost + contradiction suppression), and 56 auto-mined behavioral patterns. 23+ tabs. Runs locally — no data leaves your machine.
+**v3.4.4 "Neural Glass":** 21-tab sidebar dashboard with light + dark theme. Knowledge Graph (Sigma.js WebGL, community detection), Health Monitor, Entity Explorer (1,300+ entities), Mesh Peers (P2P agent communication), Ingestion Status (Gmail/Calendar/Transcript management), Privacy blur mode. Always-on daemon with auto-start. 8 mesh MCP tools built-in. Cross-platform: macOS + Windows + Linux. All data stays local.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.3",
+  "version": "3.4.5",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.3"
+version = "3.4.5"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/cli/commands.py

@@ -96,6 +96,35 @@ def cmd_serve(args: Namespace) -> None:
                 print("Daemon: RUNNING (could not get status)")
         else:
             print("Daemon: NOT RUNNING")
+        # Also show OS service status
+        try:
+            from superlocalmemory.cli.service_installer import service_status
+            svc = service_status()
+            installed = svc.get("installed", False)
+            print(f"OS Service: {'INSTALLED' if installed else 'NOT INSTALLED'} "
+                  f"({svc.get('service_type', svc.get('platform', '?'))})")
+        except Exception:
+            pass
+        return
+
+    if action == 'install':
+        # Install OS-level service for auto-start on boot/login
+        from superlocalmemory.cli.service_installer import install_service
+        print("Installing SLM as OS service (auto-start on login)...")
+        if install_service():
+            print("Service installed \u2713 — SLM will auto-start on login.")
+            print("  slm serve status    — check service status")
+            print("  slm serve uninstall — remove auto-start")
+        else:
+            print("Failed to install service. Check logs.")
+        return
+
+    if action == 'uninstall':
+        from superlocalmemory.cli.service_installer import uninstall_service
+        if uninstall_service():
+            print("OS service removed \u2713 — SLM will no longer auto-start.")
+        else:
+            print("Failed to remove service.")
         return
 
     # Default: start

package/src/superlocalmemory/cli/daemon.py

@@ -45,67 +45,65 @@ _PORT_FILE = Path.home() / ".superlocalmemory" / "daemon.port"
 # Client: check if daemon running + send requests
 # ---------------------------------------------------------------------------
 
+def _is_pid_alive(pid: int) -> bool:
+    """Cross-platform check if a process with given PID exists."""
+    try:
+        import psutil
+        return psutil.pid_exists(pid)
+    except ImportError:
+        try:
+            os.kill(pid, 0)
+            return True
+        except (ProcessLookupError, PermissionError):
+            return False
+
+
 def is_daemon_running() -> bool:
     """Check if daemon is alive via PID file + HTTP health check.
 
-    v3.4.3: Checks both port 8765 (new) and 8767 (legacy) for upgrade compat.
-    Also checks ports directly if PID file is missing (daemon started by MCP/hook).
+    v3.4.4 FIX: If PID is alive, returns True EVEN IF health check fails.
+    This prevents starting duplicate daemons when the existing one is
+    warming up (Ollama processing, model download, embedding init).
+
+    Priority:
+      1. PID file exists AND process alive → True (daemon warming up or ready)
+      2. No PID file → try health check on known ports (MCP/hook started daemon)
+      3. PID file stale (process dead) → clean up, return False
     """
-    if not _PID_FILE.exists():
-        # PID file missing but daemon might still be running (started by MCP/hook)
-        # Try health check on known ports
-        for try_port in (_DEFAULT_PORT, _LEGACY_PORT):
-            try:
-                import urllib.request
-                resp = urllib.request.urlopen(
-                    f"http://127.0.0.1:{try_port}/health", timeout=2,
-                )
-                if resp.status == 200:
-                    # Daemon is running without PID file — write one for future checks
-                    try:
-                        import json as _json
-                        data = _json.loads(resp.read().decode())
-                        pid = data.get("pid")
-                        if pid:
-                            _PID_FILE.parent.mkdir(parents=True, exist_ok=True)
-                            _PID_FILE.write_text(str(pid))
-                            _PORT_FILE.write_text(str(try_port))
-                    except Exception:
-                        pass
-                    return True
-            except Exception:
-                continue
-        return False
-    try:
-        pid = int(_PID_FILE.read_text().strip())
-        # Cross-platform PID check via psutil if available, else os.kill
+    if _PID_FILE.exists():
         try:
-            import psutil
-            if not psutil.pid_exists(pid):
-                _PID_FILE.unlink(missing_ok=True)
-                return False
-        except ImportError:
-            try:
-                os.kill(pid, 0)
-            except (ProcessLookupError, PermissionError):
+            pid = int(_PID_FILE.read_text().strip())
+            if _is_pid_alive(pid):
+                # PID alive = daemon exists. Don't check health — it might be warming up.
+                # This is the critical fix: NEVER start a second daemon if PID is alive.
+                return True
+            else:
+                # Process died — clean up stale PID file
                 _PID_FILE.unlink(missing_ok=True)
-                return False
-    except ValueError:
-        _PID_FILE.unlink(missing_ok=True)
-        return False
+                _PORT_FILE.unlink(missing_ok=True)
+        except (ValueError, OSError):
+            _PID_FILE.unlink(missing_ok=True)
 
-    # PID exists — verify HTTP health on primary port
-    port = _get_port()
-    for try_port in (port, _DEFAULT_PORT, _LEGACY_PORT):
+    # No PID file — maybe daemon was started by MCP/hook without PID file.
+    # Try health check on known ports as last resort.
+    for try_port in (_DEFAULT_PORT, _LEGACY_PORT):
         try:
             import urllib.request
             resp = urllib.request.urlopen(
                 f"http://127.0.0.1:{try_port}/health", timeout=2,
             )
             if resp.status == 200:
-                # Update port file if it was stale (upgrade from 8767 → 8765)
-                if try_port != port:
-                    _PORT_FILE.write_text(str(try_port))
+                # Daemon running without PID file — write one for future checks
+                try:
+                    import json as _json
+                    data = _json.loads(resp.read().decode())
+                    pid = data.get("pid")
+                    if pid:
+                        _PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+                        _PID_FILE.write_text(str(pid))
+                        _PORT_FILE.write_text(str(try_port))
+                except Exception:
+                    pass
                 return True
         except Exception:
             continue
@@ -136,38 +134,100 @@ def daemon_request(method: str, path: str, body: dict | None = None) -> dict | N
         return None
 
 
+_LOCK_FILE = Path.home() / ".superlocalmemory" / "daemon.lock"
+
+
 def ensure_daemon() -> bool:
     """Start daemon if not running. Returns True if daemon is ready.
 
-    v3.4.3: Starts unified daemon (server/unified_daemon.py) instead of
-    old stdlib daemon. Cross-platform subprocess flags.
+    v3.4.4 BULLETPROOF:
+      1. If PID alive → return True immediately (even if warming up)
+      2. File lock prevents two callers from starting concurrent daemons
+      3. After starting, waits for PID file (not health check) — fast detection
+      4. Cross-platform: macOS + Windows + Linux
     """
     if is_daemon_running():
         return True
 
-    # Start unified daemon in background
-    import subprocess
-    cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
-    log_dir = Path.home() / ".superlocalmemory" / "logs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    log_file = log_dir / "daemon.log"
-
-    # Cross-platform background process flags
-    kwargs: dict = {}
-    if sys.platform == "win32":
-        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
-    else:
-        kwargs["start_new_session"] = True
+    # File lock — prevent concurrent starts from multiple CLI/MCP calls
+    lock_fd = None
+    try:
+        _LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+        lock_fd = open(_LOCK_FILE, "w")
 
-    with open(log_file, "a") as lf:
-        subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
+        # Cross-platform file locking
+        if sys.platform == "win32":
+            import msvcrt
+            try:
+                msvcrt.locking(lock_fd.fileno(), msvcrt.LK_NBLCK, 1)
+            except (IOError, OSError):
+                # Another process is starting the daemon — just wait for it
+                lock_fd.close()
+                return _wait_for_daemon(timeout=60)
+        else:
+            import fcntl
+            try:
+                fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except (IOError, OSError):
+                lock_fd.close()
+                return _wait_for_daemon(timeout=60)
 
-    # Wait for daemon to become ready (max 30s for cold start)
-    for _ in range(60):
-        time.sleep(0.5)
+        # Re-check after acquiring lock (another process may have started it)
         if is_daemon_running():
             return True
 
+        # Start unified daemon in background
+        import subprocess
+        cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
+        log_dir = Path.home() / ".superlocalmemory" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "daemon.log"
+
+        kwargs: dict = {}
+        if sys.platform == "win32":
+            kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+        else:
+            kwargs["start_new_session"] = True
+
+        with open(log_file, "a") as lf:
+            proc = subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
+
+        # Write PID immediately so other callers see it during warmup
+        _PID_FILE.write_text(str(proc.pid))
+        _PORT_FILE.write_text(str(_DEFAULT_PORT))
+
+        return _wait_for_daemon(timeout=60)
+
+    except Exception as exc:
+        logger.debug("ensure_daemon error: %s", exc)
+        return False
+    finally:
+        if lock_fd:
+            try:
+                lock_fd.close()
+            except Exception:
+                pass
+            try:
+                _LOCK_FILE.unlink(missing_ok=True)
+            except Exception:
+                pass
+
+
+def _wait_for_daemon(timeout: int = 60) -> bool:
+    """Wait for daemon to become reachable. Checks PID alive first (fast),
+    then health endpoint (confirms HTTP server is bound)."""
+    for _ in range(timeout * 2):  # check every 0.5s
+        time.sleep(0.5)
+        if is_daemon_running():
+            # PID is alive — now optionally check if HTTP is ready
+            port = _get_port()
+            try:
+                import urllib.request
+                urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=2)
+                return True  # HTTP is ready
+            except Exception:
+                # PID alive but HTTP not ready — daemon is warming up, that's OK
+                return True
     return False
 
 

package/src/superlocalmemory/cli/main.py

@@ -195,8 +195,8 @@ def main() -> None:
     serve_p = sub.add_parser("serve", help="Start/stop daemon for instant CLI response (~600MB RAM)")
     serve_p.add_argument(
         "action", nargs="?", default="start",
-        choices=["start", "stop", "status"],
-        help="start (default), stop, or status",
+        choices=["start", "stop", "status", "install", "uninstall"],
+        help="start (default), stop, status, install (OS service), uninstall",
     )
 
     # -- Profiles ------------------------------------------------------
@@ -292,6 +292,19 @@ def main() -> None:
     from superlocalmemory.cli.setup_wizard import check_first_use
     check_first_use(args.command)
 
+    # V3.4.4: Auto-start daemon for all commands that need it.
+    # SLM is always-on — close laptop, reboot, crash: daemon auto-recovers.
+    # Cross-platform: macOS + Windows + Linux.
+    _NO_DAEMON_COMMANDS = {
+        "setup", "mode", "provider", "connect", "migrate", "mcp", "warmup",
+    }
+    if args.command not in _NO_DAEMON_COMMANDS:
+        try:
+            from superlocalmemory.cli.daemon import ensure_daemon
+            ensure_daemon()  # Starts daemon if not running; no-op if already up
+        except Exception:
+            pass  # Don't block CLI if daemon start fails — commands have fallbacks
+
     from superlocalmemory.cli.commands import dispatch
 
     dispatch(args)