superlocalmemory 2.5.0 → 2.6.0

package/src/graph_engine.py

@@ -15,12 +15,12 @@ Implements GraphRAG with Leiden community detection to:
 All processing is local - no external APIs.
 
 LIMITS:
-- MAX_MEMORIES_FOR_GRAPH: 5000 (prevents O(n²) explosion)
+- MAX_MEMORIES_FOR_GRAPH: 10000 (prevents O(n²) explosion)
 - For larger datasets, use incremental updates
 """
 
 # SECURITY: Graph build limits to prevent resource exhaustion
-MAX_MEMORIES_FOR_GRAPH = 5000
+MAX_MEMORIES_FOR_GRAPH = 10000
 
 import sqlite3
 import json
@@ -157,43 +157,82 @@ class EdgeBuilder:
             logger.warning("Need at least 2 memories to build edges")
             return 0
 
-        # Compute pairwise cosine similarity
-        similarity_matrix = cosine_similarity(vectors)
+        # Try HNSW-accelerated edge building first (O(n log n))
+        use_hnsw = False
+        try:
+            from hnsw_index import HNSWIndex
+            if len(memory_ids) >= 50:  # HNSW overhead not worth it for small sets
+                use_hnsw = True
+        except ImportError:
+            pass
 
         edges_added = 0
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
         try:
-            for i in range(len(memory_ids)):
-                for j in range(i + 1, len(memory_ids)):
-                    sim = similarity_matrix[i, j]
-
-                    if sim >= self.min_similarity:
-                        # Find shared entities
-                        entities_i = set(entities_list[i])
-                        entities_j = set(entities_list[j])
-                        shared = list(entities_i & entities_j)
-
-                        # Classify relationship type
-                        rel_type = self._classify_relationship(sim, shared)
-
-                        # Insert edge (or update if exists)
-                        cursor.execute('''
-                            INSERT OR REPLACE INTO graph_edges
-                            (source_memory_id, target_memory_id, relationship_type,
-                             weight, shared_entities, similarity_score)
-                            VALUES (?, ?, ?, ?, ?, ?)
-                        ''', (
-                            memory_ids[i],
-                            memory_ids[j],
-                            rel_type,
-                            float(sim),
-                            json.dumps(shared),
-                            float(sim)
-                        ))
-
-                        edges_added += 1
+            if use_hnsw:
+                logger.info("Using HNSW-accelerated edge building for %d memories", len(memory_ids))
+                try:
+                    dim = vectors.shape[1]
+                    hnsw = HNSWIndex(dimension=dim, max_elements=len(memory_ids))
+                    hnsw.build(vectors, memory_ids)
+
+                    for i in range(len(memory_ids)):
+                        neighbors = hnsw.search(vectors[i], k=min(20, len(memory_ids) - 1))
+                        for neighbor_id, similarity in neighbors:
+                            if neighbor_id == memory_ids[i]:
+                                continue  # Skip self
+                            # Only process each pair once (lower ID first)
+                            if memory_ids[i] > neighbor_id:
+                                continue
+                            if similarity >= self.min_similarity:
+                                # Find indices for entity lookup
+                                j = memory_ids.index(neighbor_id)
+                                entities_i = set(entities_list[i])
+                                entities_j = set(entities_list[j])
+                                shared = list(entities_i & entities_j)
+                                rel_type = self._classify_relationship(similarity, shared)
+
+                                cursor.execute('''
+                                    INSERT OR REPLACE INTO graph_edges
+                                    (source_memory_id, target_memory_id, relationship_type,
+                                     weight, shared_entities, similarity_score)
+                                    VALUES (?, ?, ?, ?, ?, ?)
+                                ''', (
+                                    memory_ids[i], neighbor_id, rel_type,
+                                    float(similarity), json.dumps(shared), float(similarity)
+                                ))
+                                edges_added += 1
+
+                except Exception as e:
+                    logger.warning("HNSW edge building failed, falling back to O(n²): %s", e)
+                    use_hnsw = False  # Fall through to O(n²) below
+
+            if not use_hnsw:
+                # Fallback: O(n²) pairwise cosine similarity
+                similarity_matrix = cosine_similarity(vectors)
+
+                for i in range(len(memory_ids)):
+                    for j in range(i + 1, len(memory_ids)):
+                        sim = similarity_matrix[i, j]
+
+                        if sim >= self.min_similarity:
+                            entities_i = set(entities_list[i])
+                            entities_j = set(entities_list[j])
+                            shared = list(entities_i & entities_j)
+                            rel_type = self._classify_relationship(sim, shared)
+
+                            cursor.execute('''
+                                INSERT OR REPLACE INTO graph_edges
+                                (source_memory_id, target_memory_id, relationship_type,
+                                 weight, shared_entities, similarity_score)
+                                VALUES (?, ?, ?, ?, ?, ?)
+                            ''', (
+                                memory_ids[i], memory_ids[j], rel_type,
+                                float(sim), json.dumps(shared), float(sim)
+                            ))
+                            edges_added += 1
 
             conn.commit()
             logger.info(f"Created {edges_added} edges")
@@ -829,7 +868,7 @@ class GraphEngine:
             Dictionary with build statistics
 
         Raises:
-            ValueError: If too many memories (>5000) for safe processing
+            ValueError: If too many memories (>10000) for safe processing
         """
         start_time = time.time()
         logger.info("Starting full graph build...")
@@ -882,17 +921,47 @@ class GraphEngine:
                     'fix': "Add more memories: superlocalmemoryv2:remember 'Your content here'"
                 }
 
-            # SECURITY: Prevent O(n²) explosion for large datasets
+            # SCALABILITY: Intelligent sampling for large datasets (v2.6)
             if len(memories) > MAX_MEMORIES_FOR_GRAPH:
-                logger.error(f"Too many memories for graph build: {len(memories)}")
-                return {
-                    'success': False,
-                    'error': 'too_many_memories',
-                    'message': f"Graph build limited to {MAX_MEMORIES_FOR_GRAPH} memories for performance.",
-                    'memories': len(memories),
-                    'limit': MAX_MEMORIES_FOR_GRAPH,
-                    'fix': "Use incremental updates or reduce memory count with compression."
-                }
+                logger.warning(
+                    "Memory count (%d) exceeds graph cap (%d). Using intelligent sampling.",
+                    len(memories), MAX_MEMORIES_FOR_GRAPH
+                )
+                # Sample: 60% most recent + 40% highest importance (with overlap dedup)
+                recent_count = int(MAX_MEMORIES_FOR_GRAPH * 0.6)
+                important_count = int(MAX_MEMORIES_FOR_GRAPH * 0.4)
+
+                recent_memories = cursor.execute('''
+                    SELECT id, content, summary FROM memories
+                    WHERE profile = ?
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                ''', (active_profile, recent_count)).fetchall()
+
+                important_memories = cursor.execute('''
+                    SELECT id, content, summary FROM memories
+                    WHERE profile = ?
+                    ORDER BY importance DESC, access_count DESC
+                    LIMIT ?
+                ''', (active_profile, important_count)).fetchall()
+
+                # Deduplicate by ID, preserving order
+                seen_ids = set()
+                memories = []
+                for m in recent_memories + important_memories:
+                    if m[0] not in seen_ids:
+                        seen_ids.add(m[0])
+                        memories.append(m)
+                memories = memories[:MAX_MEMORIES_FOR_GRAPH]
+                logger.info("Sampled %d memories for graph build", len(memories))
+
+            elif len(memories) > MAX_MEMORIES_FOR_GRAPH * 0.8:
+                logger.warning(
+                    "Approaching graph cap: %d/%d memories (%.0f%%). "
+                    "Consider running memory compression.",
+                    len(memories), MAX_MEMORIES_FOR_GRAPH,
+                    len(memories) / MAX_MEMORIES_FOR_GRAPH * 100
+                )
 
             # Clear existing graph data for this profile's memories
             profile_memory_ids = [m[0] for m in memories]

package/src/hybrid_search.py

@@ -150,7 +150,7 @@ class HybridSearchEngine:
                 try:
                     tags = json.loads(row[3])
                     text_parts.extend(tags)
-                except:
+                except Exception:
                     pass
 
             doc_text = ' '.join(text_parts)
@@ -334,7 +334,7 @@ class HybridSearchEngine:
                         new_score = current_score * similarity * (0.7 ** depth)
                         queue.append((rel_id, new_score, depth + 1))
 
-            except:
+            except Exception:
                 # Graph operation failed - skip
                 continue
 

package/src/memory-reset.py

@@ -81,9 +81,13 @@ class MemoryReset:
             'sessions'
         ]
 
+        VALID_TABLES = frozenset(tables)  # Whitelist from hardcoded list above
+
         for table in tables:
             try:
-                cursor.execute(f'DELETE FROM {table}')
+                if table not in VALID_TABLES:
+                    raise ValueError(f"Invalid table name: {table}")
+                cursor.execute(f'DELETE FROM {table}')  # Safe: validated against whitelist
                 count = cursor.rowcount
                 print(f"  ✓ Cleared {table}: {count} rows deleted")
             except sqlite3.OperationalError as e:
@@ -141,12 +145,18 @@ class MemoryReset:
             'archive': ['memory_archive']
         }
 
+        VALID_LAYER_TABLES = frozenset(
+            t for tables_list in layer_tables.values() for t in tables_list
+        )  # Whitelist from hardcoded dict above
+
         for layer in layers:
             if layer in layer_tables:
                 print(f"\n  Clearing Layer: {layer.upper()}")
                 for table in layer_tables[layer]:
                     try:
-                        cursor.execute(f'DELETE FROM {table}')
+                        if table not in VALID_LAYER_TABLES:
+                            raise ValueError(f"Invalid table name: {table}")
+                        cursor.execute(f'DELETE FROM {table}')  # Safe: validated against whitelist
                         count = cursor.rowcount
                         print(f"    ✓ Cleared {table}: {count} rows")
                     except sqlite3.OperationalError as e:
@@ -378,10 +388,14 @@ class MemoryReset:
             'Archived Memories': 'memory_archive'
         }
 
+        VALID_STAT_TABLES = frozenset(tables.values())  # Whitelist from hardcoded dict above
+
         print("\nTable Statistics:")
         for name, table in tables.items():
             try:
-                cursor.execute(f'SELECT COUNT(*) FROM {table}')
+                if table not in VALID_STAT_TABLES:
+                    raise ValueError(f"Invalid table name: {table}")
+                cursor.execute(f'SELECT COUNT(*) FROM {table}')  # Safe: validated against whitelist
                 count = cursor.fetchone()[0]
                 print(f"  {name:20s}: {count:>5} rows")
             except sqlite3.OperationalError:

package/src/memory_store_v2.py

@@ -66,6 +66,9 @@ try:
 except ImportError:
     SKLEARN_AVAILABLE = False
 
+import logging
+logger = logging.getLogger(__name__)
+
 MEMORY_DIR = Path.home() / ".claude-memory"
 DB_PATH = MEMORY_DIR / "memory.db"
 VECTORS_PATH = MEMORY_DIR / "vectors"
@@ -137,8 +140,22 @@ class MemoryStoreV2:
         self.vectorizer = None
         self.vectors = None
         self.memory_ids = []
+        self._last_vector_count = 0
         self._load_vectors()
 
+        # HNSW index for O(log n) search (v2.6, optional)
+        self._hnsw_index = None
+        try:
+            from hnsw_index import HNSWIndex
+            if self.vectors is not None and len(self.memory_ids) > 0:
+                dim = self.vectors.shape[1]
+                self._hnsw_index = HNSWIndex(dimension=dim, max_elements=max(len(self.memory_ids) * 2, 1000))
+                self._hnsw_index.build(self.vectors.toarray() if hasattr(self.vectors, 'toarray') else self.vectors, self.memory_ids)
+                logger.info("HNSW index built with %d vectors", len(self.memory_ids))
+        except (ImportError, Exception) as e:
+            logger.debug("HNSW index not available: %s", e)
+            self._hnsw_index = None
+
     # =========================================================================
     # Connection helpers — abstract ConnectionManager vs direct sqlite3
     # =========================================================================
@@ -227,6 +244,14 @@ class MemoryStoreV2:
         def _do_init(conn):
             cursor = conn.cursor()
 
+            # Database integrity check (v2.6: detect corruption early)
+            try:
+                result = cursor.execute('PRAGMA quick_check').fetchone()
+                if result[0] != 'ok':
+                    logger.warning("Database integrity issue detected: %s", result[0])
+            except Exception:
+                logger.warning("Could not run database integrity check")
+
             # Check if we need to add V2 columns to existing table
             cursor.execute("PRAGMA table_info(memories)")
             existing_columns = {row[1] for row in cursor.fetchall()}
@@ -520,7 +545,7 @@ class MemoryStoreV2:
 
         # Emit event (v2.5 — Event Bus)
         self._emit_event("memory.created", memory_id=memory_id,
-                         content_preview=content[:100], tags=tags,
+                         content_preview="[redacted]", tags=tags,
                          project=project_name, importance=importance)
 
         # Record provenance (v2.5 — who created this memory)
@@ -600,8 +625,34 @@ class MemoryStoreV2:
         active_profile = self._get_active_profile()
 
         with self._read_connection() as conn:
-            # Method 1: TF-IDF semantic search
+            # Method 0: HNSW accelerated search (O(log n), v2.6)
+            _hnsw_used = False
             if SKLEARN_AVAILABLE and self.vectorizer is not None and self.vectors is not None:
+                try:
+                    from hnsw_index import HNSWIndex
+                    if hasattr(self, '_hnsw_index') and self._hnsw_index is not None:
+                        query_vec = self.vectorizer.transform([query]).toarray().flatten()
+                        hnsw_results = self._hnsw_index.search(query_vec, k=limit * 2)
+                        cursor = conn.cursor()
+                        for memory_id, score in hnsw_results:
+                            if score > 0.05:
+                                cursor.execute('''
+                                    SELECT id, content, summary, project_path, project_name, tags,
+                                           category, parent_id, tree_path, depth,
+                                           memory_type, importance, created_at, cluster_id,
+                                           last_accessed, access_count
+                                    FROM memories WHERE id = ? AND profile = ?
+                                ''', (memory_id, active_profile))
+                                row = cursor.fetchone()
+                                if row and self._apply_filters(row, project_path, memory_type,
+                                                              category, cluster_id, min_importance):
+                                    results.append(self._row_to_dict(row, score, 'hnsw'))
+                        _hnsw_used = len(results) > 0
+                except (ImportError, Exception):
+                    pass  # HNSW not available, fall through to TF-IDF
+
+            # Method 1: TF-IDF semantic search (fallback if HNSW unavailable or returned no results)
+            if not _hnsw_used and SKLEARN_AVAILABLE and self.vectorizer is not None and self.vectors is not None:
                 try:
                     query_vec = self.vectorizer.transform([query])
                     similarities = cosine_similarity(query_vec, self.vectors).flatten()
@@ -865,6 +916,25 @@ class MemoryStoreV2:
         if not SKLEARN_AVAILABLE:
             return
 
+        # Incremental optimization: skip rebuild if memory count hasn't changed much (v2.6)
+        if hasattr(self, '_last_vector_count') and self._last_vector_count > 0:
+            with self._read_connection() as conn:
+                cursor = conn.cursor()
+                active_profile = self._get_active_profile()
+                cursor.execute("PRAGMA table_info(memories)")
+                columns = {row[1] for row in cursor.fetchall()}
+                if 'profile' in columns:
+                    cursor.execute('SELECT COUNT(*) FROM memories WHERE profile = ?', (active_profile,))
+                else:
+                    cursor.execute('SELECT COUNT(*) FROM memories')
+                current_count = cursor.fetchone()[0]
+
+            # Only rebuild if count changed by more than 5% or is the first few memories
+            if self._last_vector_count > 10:
+                change_ratio = abs(current_count - self._last_vector_count) / self._last_vector_count
+                if change_ratio < 0.05:
+                    return  # Skip rebuild — vectors are still accurate enough
+
         active_profile = self._get_active_profile()
 
         with self._read_connection() as conn:
@@ -903,6 +973,7 @@ class MemoryStoreV2:
             ngram_range=(1, 2)
         )
         self.vectors = self.vectorizer.fit_transform(texts)
+        self._last_vector_count = len(self.memory_ids)
 
         # Save memory IDs as JSON (safe serialization)
         self.vectors_path.mkdir(exist_ok=True)
@@ -944,7 +1015,8 @@ class MemoryStoreV2:
         return results
 
     def get_by_id(self, memory_id: int) -> Optional[Dict[str, Any]]:
-        """Get a specific memory by ID (V1 compatible)."""
+        """Get a specific memory by ID (V1 compatible, profile-aware)."""
+        active_profile = self._get_active_profile()
         with self._read_connection() as conn:
             cursor = conn.cursor()
 
@@ -952,8 +1024,8 @@ class MemoryStoreV2:
                 SELECT id, content, summary, project_path, project_name, tags,
                        category, parent_id, tree_path, depth, memory_type, importance,
                        created_at, cluster_id, last_accessed, access_count
-                FROM memories WHERE id = ?
-            ''', (memory_id,))
+                FROM memories WHERE id = ? AND profile = ?
+            ''', (memory_id, active_profile))
 
             row = cursor.fetchone()
 
@@ -966,10 +1038,11 @@ class MemoryStoreV2:
         return self._row_to_dict(row, 1.0, 'direct')
 
     def delete_memory(self, memory_id: int) -> bool:
-        """Delete a specific memory (V1 compatible)."""
+        """Delete a specific memory (V1 compatible, profile-aware)."""
+        active_profile = self._get_active_profile()
         def _do_delete(conn):
             cursor = conn.cursor()
-            cursor.execute('DELETE FROM memories WHERE id = ?', (memory_id,))
+            cursor.execute('DELETE FROM memories WHERE id = ? AND profile = ?', (memory_id, active_profile))
             deleted = cursor.rowcount > 0
             conn.commit()
             return deleted

package/src/rate_limiter.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - Rate Limiter
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Licensed under MIT License
+"""
+
+"""
+Lightweight rate limiter using sliding window algorithm.
+Pure stdlib — no external dependencies.
+
+Defaults:
+    Write endpoints: 100 req/min per IP
+    Read endpoints: 300 req/min per IP
+
+Configurable via environment variables:
+    SLM_RATE_LIMIT_WRITE=100
+    SLM_RATE_LIMIT_READ=300
+    SLM_RATE_LIMIT_WINDOW=60
+"""
+
+import os
+import time
+import threading
+from collections import defaultdict
+from typing import Tuple
+
+import logging
+logger = logging.getLogger("superlocalmemory.ratelimit")
+
+# Configurable via env vars
+WRITE_LIMIT = int(os.environ.get('SLM_RATE_LIMIT_WRITE', '100'))
+READ_LIMIT = int(os.environ.get('SLM_RATE_LIMIT_READ', '300'))
+WINDOW_SECONDS = int(os.environ.get('SLM_RATE_LIMIT_WINDOW', '60'))
+
+
+class RateLimiter:
+    """Thread-safe sliding window rate limiter."""
+
+    def __init__(self, max_requests: int = 100, window_seconds: int = 60):
+        self.max_requests = max_requests
+        self.window = window_seconds
+        self._requests: dict = defaultdict(list)
+        self._lock = threading.Lock()
+
+    def is_allowed(self, client_id: str) -> Tuple[bool, int]:
+        """
+        Check if request is allowed for this client.
+
+        Returns:
+            (allowed: bool, remaining: int) — whether request is allowed
+            and how many requests remain in the window
+        """
+        now = time.time()
+        cutoff = now - self.window
+
+        with self._lock:
+            # Remove expired entries
+            self._requests[client_id] = [
+                t for t in self._requests[client_id] if t > cutoff
+            ]
+
+            current = len(self._requests[client_id])
+
+            if current >= self.max_requests:
+                return False, 0
+
+            self._requests[client_id].append(now)
+            return True, self.max_requests - current - 1
+
+    def cleanup(self):
+        """Remove stale entries for clients that haven't made requests recently."""
+        now = time.time()
+        cutoff = now - self.window * 2  # Keep 2 windows of data
+
+        with self._lock:
+            stale_keys = [
+                k for k, v in self._requests.items()
+                if not v or max(v) < cutoff
+            ]
+            for k in stale_keys:
+                del self._requests[k]
+
+
+# Singleton instances for write and read endpoints
+write_limiter = RateLimiter(max_requests=WRITE_LIMIT, window_seconds=WINDOW_SECONDS)
+read_limiter = RateLimiter(max_requests=READ_LIMIT, window_seconds=WINDOW_SECONDS)

package/src/trust_scorer.py

@@ -20,13 +20,14 @@ v2.5 BEHAVIOR (this version):
     - Trust scores are updated in agent_registry.trust_score
     - Dashboard shows scores but they don't affect recall ordering yet
 
-v2.6 BEHAVIOR (future):
+v2.6 BEHAVIOR (this version):
     - Trust scores visible in dashboard
-    - Recall results ranked by trust (higher trust = higher in results)
+    - Active enforcement: agents with trust < 0.3 blocked from write/delete operations
+    - Quarantine and admin approval deferred to v3.0
 
 v3.0 BEHAVIOR (future):
-    - Active enforcement: quarantine low-trust memories, rate limiting
-    - Admin approval for untrusted agents
+    - Quarantine low-trust memories for manual review
+    - Admin approval workflow for untrusted agents
 
 Trust Signals (all silently collected):
     POSITIVE (increase trust):
@@ -200,7 +201,7 @@ class TrustScorer:
         agent_id: str,
         signal_type: str,
         context: Optional[dict] = None,
-    ):
+    ) -> bool:
         """
         Record a trust signal for an agent.
 
@@ -376,6 +377,37 @@ class TrustScorer:
         score = self._get_agent_trust(agent_id)
         return score if score is not None else 1.0
 
+    def check_trust(self, agent_id: str, operation: str = "write") -> bool:
+        """
+        Check if agent is trusted enough for the given operation.
+
+        v2.6 enforcement: blocks write/delete for agents with trust < 0.3.
+        New agents start at 1.0 — only repeated bad behavior triggers blocking.
+
+        Args:
+            agent_id: The agent identifier
+            operation: One of "read", "write", "delete"
+
+        Returns:
+            True if operation is allowed, False if blocked
+        """
+        if operation == "read":
+            return True  # Reads are always allowed
+
+        score = self._get_agent_trust(agent_id)
+        if score is None:
+            return True  # Unknown agent = first-time = allowed (starts at 1.0)
+
+        threshold = 0.3  # Block write/delete below this
+        if score < threshold:
+            logger.warning(
+                "Trust enforcement: agent '%s' blocked from '%s' (trust=%.2f < %.2f)",
+                agent_id, operation, score, threshold
+            )
+            return False
+
+        return True
+
     def get_signals(self, agent_id: str, limit: int = 50) -> List[dict]:
         """Get recent trust signals for an agent."""
         try:
@@ -448,7 +480,7 @@ class TrustScorer:
                 "by_signal_type": by_type,
                 "by_agent": by_agent,
                 "avg_trust_score": round(avg, 4) if avg else 1.0,
-                "enforcement": "disabled (v2.5 — silent collection only)",
+                "enforcement": "enabled (v2.6 — write/delete blocked below 0.3 trust)",
             }
 
         except Exception as e:

package/src/webhook_dispatcher.py

@@ -24,10 +24,13 @@ Security:
     - No private/internal IP blocking in v2.5 (added in v2.6 with trust enforcement)
 """
 
+import ipaddress
 import json
 import logging
+import socket
 import threading
 import time
+import urllib.parse
 from queue import Queue, Empty
 from typing import Optional, Dict
 from datetime import datetime
@@ -49,6 +52,16 @@ except ImportError:
     HTTP_AVAILABLE = False
 
 
+def _is_private_ip(hostname: str) -> bool:
+    """Check if hostname resolves to a private/internal IP address."""
+    try:
+        ip_str = socket.gethostbyname(hostname)
+        ip = ipaddress.ip_address(ip_str)
+        return ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved
+    except (socket.gaierror, ValueError):
+        return False  # DNS resolution failed — allow (might be valid external hostname)
+
+
 class WebhookDispatcher:
     """
     Background webhook delivery with retry logic.
@@ -119,6 +132,10 @@ class WebhookDispatcher:
         if not webhook_url or not (webhook_url.startswith("http://") or webhook_url.startswith("https://")):
             raise ValueError(f"Invalid webhook URL: {webhook_url}")
 
+        parsed = urllib.parse.urlparse(webhook_url)
+        if parsed.hostname and _is_private_ip(parsed.hostname):
+            raise ValueError(f"Webhook URL points to private/internal network: {webhook_url}")
+
         try:
             self._queue.put_nowait({
                 "event": event,