superlocalmemory 4.1.13 → 4.1.15

package/src/superlocalmemory/hooks/prewarm_auth.py

@@ -1,187 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-01 §4.5
-
-"""Authentication primitives for the /internal/prewarm daemon route.
-
-
-Four gates, applied in order, BEFORE any engine work:
-  1. Loopback-only — client address must be 127.0.0.1 / ::1.
-  2. Origin-header CSRF guard — browsers always send Origin on CORS
-     requests; hooks using stdlib urllib do not. Present Origin ⇒ reject.
-  3. Install-token match — X-SLM-Hook-Token constant-time compared to
-     the bytes stored at ``~/.superlocalmemory/.install_token``.
-  4. Body-size cap — requests > ``MAX_BODY_BYTES`` rejected upfront.
-
-Framework-agnostic. The FastAPI route composes these primitives; tests
-exercise them without starting an HTTP server.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Mapping
-
-from superlocalmemory.core.security_primitives import verify_install_token
-
-# Headers we consider equivalent for the install-token lookup. Covers the
-# common normalizations (exact, lowercase, title-case).
-_TOKEN_HEADER_VARIANTS: tuple[str, ...] = (
-    "X-SLM-Hook-Token",
-    "x-slm-hook-token",
-    "X-Slm-Hook-Token",
-)
-
-_ORIGIN_HEADER_VARIANTS: tuple[str, ...] = ("Origin", "origin")
-
-# Loopback addresses accepted by LLD-01. ``localhost`` is NOT included per
-# SEC-01-02 — we want literal IPs only to avoid DNS-based bypass tricks.
-# Note: ::ffff:127.x.x.x is handled dynamically via ipaddress.ip_address()
-# in is_loopback() below to cover dual-stack container deployments (#90).
-_LOOPBACK_ADDRS: frozenset[str] = frozenset({"127.0.0.1", "::1"})
-
-# Body-size cap: LLD-01 §4.5 step 4 → 8 KB.
-MAX_BODY_BYTES: int = 8 * 1024
-
-
-@dataclass(frozen=True, slots=True)
-class AuthDecision:
-    """Outcome of ``authorize``.
-
-    - ``allowed`` — True when the request passes every gate.
-    - ``status`` — suggested HTTP status when ``allowed`` is False
-      (``200`` otherwise).
-    - ``reason`` — short machine-readable tag. Never echoes secrets.
-    """
-
-    allowed: bool
-    status: int
-    reason: str = ""
-
-
-# ---------------------------------------------------------------------------
-# Gate 1: Loopback-only
-# ---------------------------------------------------------------------------
-
-
-def is_loopback(client_host: str) -> bool:
-    """Return True iff ``client_host`` is an accepted loopback literal.
-
-    Deliberately excludes ``"localhost"`` per SEC-01-02 — /internal/prewarm
-    callers are in-process hooks that always connect to a literal IP, so
-    hostname aliases are rejected to prevent DNS-based bypass tricks.
-
-    Accepts IPv4-mapped IPv6 loopback (``::ffff:127.x.x.x``) for dual-stack
-    correctness (issue #90), while still excluding ``"localhost"``.
-    """
-    if not isinstance(client_host, str) or not client_host:
-        return False
-    if client_host in _LOOPBACK_ADDRS:
-        return True
-    # Handle IPv4-mapped IPv6 loopback (::ffff:127.x.x.x) — dual-stack fix.
-    # Intentionally NOT accepting "localhost" (SEC-01-02 preserved).
-    try:
-        import ipaddress as _ipa
-        ip = _ipa.ip_address(client_host)
-        return ip.is_loopback
-    except ValueError:
-        return False
-
-
-# ---------------------------------------------------------------------------
-# Gate 2: Origin CSRF guard
-# ---------------------------------------------------------------------------
-
-
-def is_browser_originated(headers: Mapping[str, str]) -> bool:
-    """True if the request carries a non-empty ``Origin`` header.
-
-    Defensive against accidental case variants. We treat an explicit empty
-    Origin as non-browser per LLD-01 §4.5 — real browsers always send a
-    non-empty origin on cross-origin requests.
-    """
-    if not headers:
-        return False
-    for name in _ORIGIN_HEADER_VARIANTS:
-        val = headers.get(name)
-        if val:
-            return True
-    return False
-
-
-# ---------------------------------------------------------------------------
-# Gate 3: Install-token
-# ---------------------------------------------------------------------------
-
-
-def _extract_token(headers: Mapping[str, str]) -> str:
-    """Return the presented X-SLM-Hook-Token across casing variants."""
-    if not headers:
-        return ""
-    for name in _TOKEN_HEADER_VARIANTS:
-        val = headers.get(name)
-        if val:
-            return val
-    return ""
-
-
-# ---------------------------------------------------------------------------
-# Gate 4: Body size
-# ---------------------------------------------------------------------------
-
-
-def check_body_size(body: bytes) -> tuple[bool, str]:
-    """Verify request body is within ``MAX_BODY_BYTES``.
-
-    Returns ``(True, "")`` on pass and ``(False, reason)`` on fail.
-    """
-    if not isinstance(body, (bytes, bytearray)):
-        return False, "body must be bytes"
-    if len(body) > MAX_BODY_BYTES:
-        return False, f"body size {len(body)} exceeds {MAX_BODY_BYTES}"
-    return True, ""
-
-
-# ---------------------------------------------------------------------------
-# Composite authorize()
-# ---------------------------------------------------------------------------
-
-
-def authorize(
-    *,
-    client_host: str,
-    headers: Mapping[str, str],
-) -> AuthDecision:
-    """Run gates 1 → 2 → 3 in order and return the first failure.
-
-    Order rationale:
-      - Loopback check runs first so we reject off-host traffic with 403
-        before touching any user-supplied header material.
-      - Origin check runs second to neutralize browser-driven CSRF even
-        when the attacker somehow obtained the install token.
-      - Token check runs last; constant-time compared via
-        ``verify_install_token``.
-    """
-    if not is_loopback(client_host):
-        return AuthDecision(False, 403, "loopback only")
-
-    if is_browser_originated(headers):
-        return AuthDecision(False, 403, "origin header not allowed")
-
-    token = _extract_token(headers)
-    if not token:
-        return AuthDecision(False, 401, "unauthorized: missing token")
-    if not verify_install_token(token):
-        return AuthDecision(False, 401, "unauthorized: token mismatch")
-
-    return AuthDecision(True, 200, "")
-
-
-__all__ = (
-    "AuthDecision",
-    "MAX_BODY_BYTES",
-    "authorize",
-    "check_body_size",
-    "is_browser_originated",
-    "is_loopback",
-)

package/src/superlocalmemory/hooks/rules_engine.py

@@ -1,99 +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
-
-"""Rules engine for configurable auto-capture and auto-recall behavior."""
-
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_RULES = {
-    "auto_recall": {
-        "enabled": True,
-        "on_session_start": True,
-        "on_every_prompt": False,
-        "max_memories_injected": 10,
-        "relevance_threshold": 0.3,
-    },
-    "auto_capture": {
-        "enabled": True,
-        "capture_decisions": True,
-        "capture_bugs": True,
-        "capture_preferences": True,
-        "capture_session_summary": True,
-        "min_confidence": 0.5,
-    },
-}
-
-
-class RulesEngine:
-    """Manage configurable rules for auto-capture and auto-recall."""
-
-    def __init__(self, config: dict | None = None, config_path: Path | None = None):
-        if config:
-            self._rules = {**DEFAULT_RULES, **config}
-        elif config_path and config_path.exists():
-            data = json.loads(config_path.read_text())
-            self._rules = {**DEFAULT_RULES, **data.get("rules", {})}
-        else:
-            self._rules = dict(DEFAULT_RULES)
-
-    def should_capture(self, category: str, confidence: float) -> bool:
-        """Check if a category should be captured based on rules."""
-        capture_rules = self._rules.get("auto_capture", {})
-        if not capture_rules.get("enabled", True):
-            return False
-
-        category_key = f"capture_{category}s" if not category.endswith("s") else f"capture_{category}"
-        if not capture_rules.get(category_key, True):
-            return False
-
-        min_conf = capture_rules.get("min_confidence", 0.5)
-        return confidence >= min_conf
-
-    def should_recall(self, trigger: str) -> bool:
-        """Check if auto-recall should fire for a trigger."""
-        recall_rules = self._rules.get("auto_recall", {})
-        if not recall_rules.get("enabled", True):
-            return False
-
-        if trigger == "session_start":
-            return recall_rules.get("on_session_start", True)
-        if trigger == "every_prompt":
-            return recall_rules.get("on_every_prompt", False)
-
-        return True
-
-    def get_recall_config(self) -> dict:
-        """Get auto-recall configuration."""
-        return dict(self._rules.get("auto_recall", DEFAULT_RULES["auto_recall"]))
-
-    def get_capture_config(self) -> dict:
-        """Get auto-capture configuration."""
-        return dict(self._rules.get("auto_capture", DEFAULT_RULES["auto_capture"]))
-
-    def update_rule(self, section: str, key: str, value: Any) -> None:
-        """Update a specific rule."""
-        if section not in self._rules:
-            self._rules[section] = {}
-        self._rules[section][key] = value
-
-    def save(self, config_path: Path) -> None:
-        """Save rules to config file."""
-        if config_path.exists():
-            data = json.loads(config_path.read_text())
-        else:
-            data = {}
-        data["rules"] = self._rules
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        config_path.write_text(json.dumps(data, indent=2))
-
-    def to_dict(self) -> dict:
-        """Export rules as dict."""
-        return dict(self._rules)

package/src/superlocalmemory/hooks/session_registry.py

@@ -1,330 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — S9-DASH-10
-
-"""Lightweight session registry for cross-process session_id handoff.
-
-**Problem.** Claude Code (and Cursor/Antigravity) invoke two separate
-SLM surfaces per user turn:
-
-1. ``user_prompt_hook`` — receives ``session_id`` via stdin JSON
-   (Claude Code's hook payload). This is the real session id.
-2. MCP ``recall`` tool — invoked by the AI mid-turn. The MCP protocol
-   does NOT thread ``CLAUDE_SESSION_ID`` into tool arguments by
-   default, so the MCP tool cannot see what session it is serving.
-
-Result: ``record_recall`` writes ``pending_outcomes`` with
-``session_id='mcp:mcp_client'`` while the Stop hook queries by the
-real session id — they never match, so cite/edit/dwell signals are
-lost (reaper finalizes everything at neutral 0.5).
-
-**Fix (this module).** A simple file-based registry:
-
-* ``mark_active(session_id, agent_type, profile_id)`` — called by hooks on
-  every prompt/tool event. Writes ``(session_id, agent_type, profile_id,
-  ts_ns, pid)``
-  to ``~/.superlocalmemory/.active_sessions.json``.
-* ``most_recent_active(agent_type, within_seconds=60)`` — queries the
-  registry for the most recently seen session of the named agent.
-  MCP uses this as the default when the tool caller omits
-  ``session_id``.
-
-Concurrency: each write is atomic via write-temp + ``os.replace`` (atomic on
-POSIX/Windows), so a concurrent reader never sees a half-written file —
-last-writer-wins. This is best-effort, not lock-serialised: a concurrent
-read-modify-write may lose an interleaved update, which is acceptable because
-the registry only drives session attribution for closed-loop learning, not
-memory correctness. Rollover: entries older than 1 hour are pruned on every
-write. Fail-soft: every error path returns empty or the passed default — the
-learning loop must never crash the hot path.
-
-This is not a perfect correlation channel; two Claude sessions
-typing in the same second can race. For single-user workstations
-(the overwhelming SLM case) it is 99%+ accurate.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import time
-from pathlib import Path
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-_PRUNE_AFTER_SEC = 3600  # 1h — anything older is dead
-
-# Keep the public host vocabulary small and stable.  Callers can still use an
-# unknown value internally, but the Living Brain must not turn arbitrary hook
-# input into a new UI label or expose a host identifier verbatim.
-_PUBLIC_CLIENT_KINDS = {
-    "claude": "claude_code",
-    "claude_code": "claude_code",
-    "codex": "codex",
-    "cursor": "cursor",
-    "antigravity": "antigravity",
-    "copilot": "copilot",
-    "cli": "cli",
-    "mcp": "mcp",
-}
-
-
-def _registry_file() -> Path:
-    from superlocalmemory.infra.data_root import state_path
-
-    return state_path(".active_sessions.json")
-
-
-def _profiles_file() -> Path:
-    """Return the profile cache updated atomically by daemon switches."""
-    from superlocalmemory.infra.data_root import state_path
-
-    return state_path("profiles.json")
-
-
-def resolve_active_profile() -> str | None:
-    """Read the canonical active profile without relying on host env wiring.
-
-    Hooks are separate host processes, so daemon-managed profile changes are
-    not reliably reflected in their environment.  The profile runtime writes
-    this compatibility cache atomically on every successful switch; using it
-    keeps ephemeral presence scoped like the durable memory stores.
-    """
-    try:
-        payload = json.loads(_profiles_file().read_text(encoding="utf-8"))
-        if not isinstance(payload, dict):
-            return None
-        modern_pointer = payload.get("active_profile")
-        legacy_pointer = payload.get("active")
-        pointer = (
-            modern_pointer.strip()
-            if isinstance(modern_pointer, str) and modern_pointer.strip()
-            else legacy_pointer.strip()
-            if isinstance(legacy_pointer, str) and legacy_pointer.strip()
-            else None
-        )
-        if pointer is None:
-            return None
-        profiles = payload.get("profiles")
-        catalog_present = "profiles" in payload
-        entries = []
-        if isinstance(profiles, list):
-            entries = [(None, profile) for profile in profiles]
-        elif isinstance(profiles, dict):
-            entries = list(profiles.items())
-        canonical: list[tuple[str, str | None]] = []
-        for key, profile in entries:
-            if not isinstance(profile, dict):
-                continue
-            profile_id = profile.get("profile_id")
-            if not isinstance(profile_id, str) or not profile_id.strip():
-                profile_id = key if isinstance(key, str) and key.strip() else None
-            name = profile.get("name")
-            if isinstance(profile_id, str) and profile_id.strip():
-                canonical.append((profile_id.strip(), name if isinstance(name, str) else None))
-        id_matches = {profile_id for profile_id, _name in canonical if profile_id == pointer}
-        if len(id_matches) == 1:
-            return id_matches.pop()
-        name_matches = {profile_id for profile_id, name in canonical if name == pointer}
-        if len(name_matches) == 1:
-            return name_matches.pop()
-        # The current runtime writes an ``active_profile`` ID even when its
-        # catalog has not been materialized yet. With no catalog at all it is
-        # the only available authority; a partially present catalog instead
-        # fails closed to avoid treating an unmapped display name as an ID.
-        if not catalog_present and isinstance(modern_pointer, str) and modern_pointer.strip():
-            return modern_pointer.strip()
-    except (OSError, TypeError, ValueError):
-        pass
-    return None
-
-
-def _now_ns() -> int:
-    return time.time_ns()
-
-
-def _load() -> dict:
-    try:
-        registry_file = _registry_file()
-        if not registry_file.exists():
-            return {}
-        return json.loads(registry_file.read_text(encoding="utf-8"))
-    except Exception:
-        return {}
-
-
-def _save(data: dict) -> None:
-    try:
-        registry_file = _registry_file()
-        registry_file.parent.mkdir(parents=True, exist_ok=True)
-        tmp = registry_file.with_suffix(
-            f".{os.getpid()}.{time.time_ns()}.tmp",
-        )
-        tmp.write_text(json.dumps(data), encoding="utf-8")
-        os.replace(tmp, registry_file)
-        try:
-            os.chmod(registry_file, 0o600)
-        except OSError:
-            pass
-    except Exception as exc:  # pragma: no cover — defensive
-        logger.debug("session_registry save failed: %s", exc)
-
-
-def _prune(data: dict) -> dict:
-    cutoff_ns = _now_ns() - (_PRUNE_AFTER_SEC * 1_000_000_000)
-    return {
-        sid: row for sid, row in data.items()
-        if isinstance(row, dict) and int(row.get("ts_ns", 0)) >= cutoff_ns
-    }
-
-
-def mark_active(
-    session_id: str,
-    agent_type: str = "claude",
-    profile_id: str | None = None,
-) -> None:
-    """Record ``session_id`` keyed by the CALLING process PID.
-
-    Called from UserPromptSubmit + PostToolUse hooks — those hooks run
-    INSIDE the Claude Code / IDE process. So ``os.getpid()`` is the
-    IDE's PID. The MCP server spawned BY that same IDE process has
-    ``os.getppid() == IDE_PID``. Keying by PID means two parallel
-    Claude Code windows never collide — each MCP server reads only
-    its own parent's entry.
-
-    Hot-path safe — returns within <2 ms on a warm cache. Never raises.
-    """
-    if not session_id or not isinstance(session_id, str):
-        return
-    try:
-        data = _load()
-        key = str(os.getpid())  # the IDE / hook process PID
-        row = {
-            "session_id": session_id,
-            "agent_type": agent_type or "unknown",
-            "ts_ns": _now_ns(),
-        }
-        if isinstance(profile_id, str) and profile_id.strip():
-            row["profile_id"] = profile_id.strip()
-        data[key] = row
-        data = _prune(data)
-        _save(data)
-    except Exception as exc:  # pragma: no cover — defensive
-        logger.debug("mark_active failed: %s", exc)
-
-
-def lookup_by_parent(within_seconds: int = 60) -> Optional[str]:
-    """Return the session_id whose registry key == ``os.getppid()``.
-
-    Called from the MCP server process. ``os.getppid()`` is the PID of
-    the IDE that spawned the MCP server — exactly the same PID that
-    the hook used as its key in ``mark_active``. Collision-free across
-    multiple parallel Claude Code / IDE sessions.
-    """
-    try:
-        parent_key = str(os.getppid())
-        data = _load()
-        row = data.get(parent_key)
-        if not isinstance(row, dict):
-            return None
-        ts = int(row.get("ts_ns", 0))
-        if _now_ns() - ts > within_seconds * 1_000_000_000:
-            return None  # stale — IDE likely restarted
-        return row.get("session_id") or None
-    except Exception:
-        return None
-
-
-def most_recent_active(
-    agent_type: Optional[str] = None,
-    within_seconds: int = 60,
-) -> Optional[str]:
-    """Fallback: most-recently-written entry of the given agent_type.
-
-    Used by surfaces that DON'T have a stable parent-PID linkage (e.g.
-    CLI tools invoked ad-hoc). Prefer ``lookup_by_parent`` for MCP.
-    """
-    try:
-        data = _load()
-        if not data:
-            return None
-        cutoff_ns = _now_ns() - (within_seconds * 1_000_000_000)
-        candidates = []
-        for _key, row in data.items():
-            if not isinstance(row, dict):
-                continue
-            ts = int(row.get("ts_ns", 0))
-            if ts < cutoff_ns:
-                continue
-            if agent_type and row.get("agent_type") != agent_type:
-                continue
-            sid = row.get("session_id")
-            if sid:
-                candidates.append((ts, sid))
-        if not candidates:
-            return None
-        candidates.sort(reverse=True)
-        return candidates[0][1]
-    except Exception:
-        return None
-
-
-def active_client_summary(
-    profile_id: str | None = None,
-    within_seconds: int = 60,
-) -> list[dict[str, object]]:
-    """Return privacy-safe, recently active hosts for the Living Brain.
-
-    This is deliberately a *presence* signal, not durable product analytics:
-    registry entries expire within an hour and session identifiers never leave
-    the local registry.  The dashboard therefore distinguishes these active
-    clients from configured adapters, which only prove installation.
-    """
-    # Compatibility-safe default for any out-of-tree caller that used the
-    # original no-argument helper: no profile means no visibility, never a
-    # silent cross-profile aggregate.
-    if not profile_id:
-        return []
-    try:
-        cutoff_ns = _now_ns() - (max(0, int(within_seconds)) * 1_000_000_000)
-        newest_by_kind: dict[str, int] = {}
-        for row in _load().values():
-            if not isinstance(row, dict):
-                continue
-            # Entries written before profile attribution are intentionally
-            # invisible here: guessing a profile would leak client metadata.
-            if str(row.get("profile_id", "")) != profile_id:
-                continue
-            try:
-                ts_ns = int(row.get("ts_ns", 0))
-            except (TypeError, ValueError):
-                continue
-            if ts_ns < cutoff_ns:
-                continue
-            raw_kind = str(row.get("agent_type", "")).strip().lower()
-            kind = _PUBLIC_CLIENT_KINDS.get(raw_kind, "other")
-            newest_by_kind[kind] = max(newest_by_kind.get(kind, 0), ts_ns)
-        now_ns = _now_ns()
-        return [
-            {
-                "kind": kind,
-                "active": True,
-                "last_seen_seconds_ago": max(0, int((now_ns - ts_ns) / 1_000_000_000)),
-                "source": "session_registry",
-                "is_real": True,
-            }
-            for kind, ts_ns in sorted(newest_by_kind.items())
-        ]
-    except Exception:
-        return []
-
-
-def _reset_for_testing() -> None:
-    """TEST-ONLY: wipe registry."""
-    try:
-        _registry_file().unlink(missing_ok=True)
-    except Exception:
-        pass