superlocalmemory 2.8.1 → 2.8.3

package/src/tree/queries.py

@@ -28,60 +28,61 @@ class TreeQueriesMixin:
             Nested dictionary representing tree structure
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Build query
-        if project_name:
-            # Find project node
-            cursor.execute('''
-                SELECT id, tree_path FROM memory_tree
-                WHERE node_type = 'project' AND name = ?
-            ''', (project_name,))
-            result = cursor.fetchone()
-
-            if not result:
-                conn.close()
-                return {'error': f"Project '{project_name}' not found"}
-
-            project_id, project_path = result
-
-            # Get subtree
-            if max_depth is not None:
+            # Build query
+            if project_name:
+                # Find project node
                 cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    WHERE (id = ? OR tree_path LIKE ?) AND depth <= ?
-                    ORDER BY tree_path
-                ''', (project_id, f"{project_path}.%", max_depth))
+                    SELECT id, tree_path FROM memory_tree
+                    WHERE node_type = 'project' AND name = ?
+                ''', (project_name,))
+                result = cursor.fetchone()
+
+                if not result:
+                    return {'error': f"Project '{project_name}' not found"}
+
+                project_id, project_path = result
+
+                # Get subtree
+                if max_depth is not None:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        WHERE (id = ? OR tree_path LIKE ?) AND depth <= ?
+                        ORDER BY tree_path
+                    ''', (project_id, f"{project_path}.%", max_depth))
+                else:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        WHERE id = ? OR tree_path LIKE ?
+                        ORDER BY tree_path
+                    ''', (project_id, f"{project_path}.%"))
             else:
-                cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    WHERE id = ? OR tree_path LIKE ?
-                    ORDER BY tree_path
-                ''', (project_id, f"{project_path}.%"))
-        else:
-            # Get entire tree
-            if max_depth is not None:
-                cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    WHERE depth <= ?
-                    ORDER BY tree_path
-                ''', (max_depth,))
-            else:
-                cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    ORDER BY tree_path
-                ''')
-
-        rows = cursor.fetchall()
-        conn.close()
+                # Get entire tree
+                if max_depth is not None:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        WHERE depth <= ?
+                        ORDER BY tree_path
+                    ''', (max_depth,))
+                else:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        ORDER BY tree_path
+                    ''')
+
+            rows = cursor.fetchall()
+        finally:
+            conn.close()
 
         if not rows:
             return {'error': 'No tree nodes found'}
@@ -125,44 +126,45 @@ class TreeQueriesMixin:
             List of descendant nodes
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
+
+            # Get node's tree_path
+            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
+            result = cursor.fetchone()
+
+            if not result:
+                return []
 
-        # Get node's tree_path
-        cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-        result = cursor.fetchone()
+            tree_path = result[0]
 
-        if not result:
+            # Get all descendants
+            cursor.execute('''
+                SELECT id, node_type, name, description, parent_id, tree_path,
+                       depth, memory_count, total_size, last_updated, memory_id
+                FROM memory_tree
+                WHERE tree_path LIKE ?
+                ORDER BY tree_path
+            ''', (f"{tree_path}.%",))
+
+            results = []
+            for row in cursor.fetchall():
+                results.append({
+                    'id': row[0],
+                    'type': row[1],
+                    'name': row[2],
+                    'description': row[3],
+                    'parent_id': row[4],
+                    'tree_path': row[5],
+                    'depth': row[6],
+                    'memory_count': row[7],
+                    'total_size': row[8],
+                    'last_updated': row[9],
+                    'memory_id': row[10]
+                })
+        finally:
             conn.close()
-            return []
-
-        tree_path = result[0]
-
-        # Get all descendants
-        cursor.execute('''
-            SELECT id, node_type, name, description, parent_id, tree_path,
-                   depth, memory_count, total_size, last_updated, memory_id
-            FROM memory_tree
-            WHERE tree_path LIKE ?
-            ORDER BY tree_path
-        ''', (f"{tree_path}.%",))
-
-        results = []
-        for row in cursor.fetchall():
-            results.append({
-                'id': row[0],
-                'type': row[1],
-                'name': row[2],
-                'description': row[3],
-                'parent_id': row[4],
-                'tree_path': row[5],
-                'depth': row[6],
-                'memory_count': row[7],
-                'total_size': row[8],
-                'last_updated': row[9],
-                'memory_id': row[10]
-            })
 
-        conn.close()
         return results
 
     def get_path_to_root(self, node_id: int) -> List[Dict[str, Any]]:
@@ -176,72 +178,75 @@ class TreeQueriesMixin:
             List of nodes from root to target node
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Get node's tree_path
-        cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-        result = cursor.fetchone()
+            # Get node's tree_path
+            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
+            result = cursor.fetchone()
 
-        if not result:
+            if not result:
+                return []
+
+            tree_path = result[0]
+
+            # Parse path to get all ancestor IDs
+            path_ids = [int(x) for x in tree_path.split('.')]
+
+            # Get all ancestor nodes
+            placeholders = ','.join('?' * len(path_ids))
+            cursor.execute(f'''
+                SELECT id, node_type, name, description, parent_id, tree_path,
+                       depth, memory_count, total_size, last_updated, memory_id
+                FROM memory_tree
+                WHERE id IN ({placeholders})
+                ORDER BY depth
+            ''', path_ids)
+
+            results = []
+            for row in cursor.fetchall():
+                results.append({
+                    'id': row[0],
+                    'type': row[1],
+                    'name': row[2],
+                    'description': row[3],
+                    'parent_id': row[4],
+                    'tree_path': row[5],
+                    'depth': row[6],
+                    'memory_count': row[7],
+                    'total_size': row[8],
+                    'last_updated': row[9],
+                    'memory_id': row[10]
+                })
+        finally:
             conn.close()
-            return []
-
-        tree_path = result[0]
-
-        # Parse path to get all ancestor IDs
-        path_ids = [int(x) for x in tree_path.split('.')]
-
-        # Get all ancestor nodes
-        placeholders = ','.join('?' * len(path_ids))
-        cursor.execute(f'''
-            SELECT id, node_type, name, description, parent_id, tree_path,
-                   depth, memory_count, total_size, last_updated, memory_id
-            FROM memory_tree
-            WHERE id IN ({placeholders})
-            ORDER BY depth
-        ''', path_ids)
-
-        results = []
-        for row in cursor.fetchall():
-            results.append({
-                'id': row[0],
-                'type': row[1],
-                'name': row[2],
-                'description': row[3],
-                'parent_id': row[4],
-                'tree_path': row[5],
-                'depth': row[6],
-                'memory_count': row[7],
-                'total_size': row[8],
-                'last_updated': row[9],
-                'memory_id': row[10]
-            })
 
-        conn.close()
         return results
 
     def get_stats(self) -> Dict[str, Any]:
         """Get tree statistics."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        cursor.execute('SELECT COUNT(*) FROM memory_tree')
-        total_nodes = cursor.fetchone()[0]
+            cursor.execute('SELECT COUNT(*) FROM memory_tree')
+            total_nodes = cursor.fetchone()[0]
 
-        cursor.execute('SELECT node_type, COUNT(*) FROM memory_tree GROUP BY node_type')
-        by_type = dict(cursor.fetchall())
+            cursor.execute('SELECT node_type, COUNT(*) FROM memory_tree GROUP BY node_type')
+            by_type = dict(cursor.fetchall())
 
-        cursor.execute('SELECT MAX(depth) FROM memory_tree')
-        max_depth = cursor.fetchone()[0] or 0
+            cursor.execute('SELECT MAX(depth) FROM memory_tree')
+            max_depth = cursor.fetchone()[0] or 0
 
-        cursor.execute('''
-            SELECT SUM(memory_count), SUM(total_size)
-            FROM memory_tree
-            WHERE node_type = 'root'
-        ''')
-        total_memories, total_size = cursor.fetchone()
+            cursor.execute('''
+                SELECT SUM(memory_count), SUM(total_size)
+                FROM memory_tree
+                WHERE node_type = 'root'
+            ''')
+            total_memories, total_size = cursor.fetchone()
 
-        conn.close()
+        finally:
+            conn.close()
 
         return {
             'total_nodes': total_nodes,

package/src/tree/schema.py

@@ -20,57 +20,61 @@ class TreeSchemaMixin:
     def _init_db(self):
         """Initialize memory_tree table."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS memory_tree (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                node_type TEXT NOT NULL,
-                name TEXT NOT NULL,
-                description TEXT,
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS memory_tree (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    node_type TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    description TEXT,
 
-                parent_id INTEGER,
-                tree_path TEXT NOT NULL,
-                depth INTEGER DEFAULT 0,
+                    parent_id INTEGER,
+                    tree_path TEXT NOT NULL,
+                    depth INTEGER DEFAULT 0,
 
-                memory_count INTEGER DEFAULT 0,
-                total_size INTEGER DEFAULT 0,
-                last_updated TIMESTAMP,
+                    memory_count INTEGER DEFAULT 0,
+                    total_size INTEGER DEFAULT 0,
+                    last_updated TIMESTAMP,
 
-                memory_id INTEGER,
+                    memory_id INTEGER,
 
-                FOREIGN KEY (parent_id) REFERENCES memory_tree(id) ON DELETE CASCADE,
-                FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
-            )
-        ''')
+                    FOREIGN KEY (parent_id) REFERENCES memory_tree(id) ON DELETE CASCADE,
+                    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+                )
+            ''')
 
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_tree_path_layer2 ON memory_tree(tree_path)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_node_type ON memory_tree(node_type)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_parent_id_tree ON memory_tree(parent_id)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_tree_path_layer2 ON memory_tree(tree_path)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_node_type ON memory_tree(node_type)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_parent_id_tree ON memory_tree(parent_id)')
 
-        conn.commit()
-        conn.close()
+            conn.commit()
+        finally:
+            conn.close()
 
     def _ensure_root(self) -> int:
         """Ensure root node exists and return its ID."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        cursor.execute('SELECT id FROM memory_tree WHERE node_type = ? AND parent_id IS NULL', ('root',))
-        result = cursor.fetchone()
-
-        if result:
-            root_id = result[0]
-        else:
-            cursor.execute('''
-                INSERT INTO memory_tree (node_type, name, tree_path, depth, last_updated)
-                VALUES (?, ?, ?, ?, ?)
-            ''', ('root', 'Root', '1', 0, datetime.now().isoformat()))
-            root_id = cursor.lastrowid
-
-            # Update tree_path with actual ID
-            cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (str(root_id), root_id))
-            conn.commit()
-
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            cursor.execute('SELECT id FROM memory_tree WHERE node_type = ? AND parent_id IS NULL', ('root',))
+            result = cursor.fetchone()
+
+            if result:
+                root_id = result[0]
+            else:
+                cursor.execute('''
+                    INSERT INTO memory_tree (node_type, name, tree_path, depth, last_updated)
+                    VALUES (?, ?, ?, ?, ?)
+                ''', ('root', 'Root', '1', 0, datetime.now().isoformat()))
+                root_id = cursor.lastrowid
+
+                # Update tree_path with actual ID
+                cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (str(root_id), root_id))
+                conn.commit()
+
+        finally:
+            conn.close()
         return root_id

package/src/webhook_dispatcher.py

@@ -73,7 +73,7 @@ class WebhookDispatcher:
             return cls._instances[name]
 
     @classmethod
-    def reset_instance(cls, name: Optional[str] = None):
+    def reset_instance(cls, name: Optional[str] = None) -> None:
         """Remove singleton(s). Used for testing."""
         with cls._instances_lock:
             if name is None:
@@ -104,7 +104,7 @@ class WebhookDispatcher:
         self._worker.start()
         logger.info("WebhookDispatcher started")
 
-    def dispatch(self, event: dict, webhook_url: str):
+    def dispatch(self, event: dict, webhook_url: str) -> None:
         """
         Enqueue a webhook delivery.
 
@@ -217,7 +217,7 @@ class WebhookDispatcher:
         with self._stats_lock:
             return dict(self._stats)
 
-    def close(self):
+    def close(self) -> None:
         """Shut down the dispatcher. Drains remaining items."""
         if self._closed:
             return

package/ui_server.py

@@ -33,6 +33,8 @@ except ImportError:
         "Install with: pip install 'fastapi[all]' uvicorn websockets"
     )
 
+from security_middleware import SecurityHeadersMiddleware
+
 # Add src/ and routes/ to path
 sys.path.insert(0, str(Path(__file__).parent / "src"))
 sys.path.insert(0, str(Path(__file__).parent))
@@ -51,7 +53,9 @@ app = FastAPI(
     redoc_url="/api/redoc"
 )
 
-# Middleware
+# Middleware (order matters: security headers should be outermost)
+app.add_middleware(SecurityHeadersMiddleware)
+app.add_middleware(GZipMiddleware, minimum_size=1000)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=[
@@ -61,10 +65,9 @@ app.add_middleware(
         "http://127.0.0.1:8417",
     ],
     allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    allow_headers=["Content-Type", "Authorization", "X-SLM-API-Key"],
 )
-app.add_middleware(GZipMiddleware, minimum_size=1000)
 
 # Rate limiting (v2.6)
 try: