prism-mcp-server 20.7.0 → 20.7.1

package/dist/storage/index.js

@@ -158,12 +158,36 @@ export async function getStorage() {
     return storageInstance;
 }
 export async function closeStorage() {
-    if (storageInstance) {
-        await storageInstance.close();
+    if (!storageInstance)
+        return;
+    const closing = storageInstance;
+    // Clear the slot in `finally`: if close() throws, the previous code left a
+    // DEAD instance installed as the singleton, and every later getStorage()
+    // handed that broken connection to callers. An empty slot is strictly
+    // safer — the next getStorage() re-opens cleanly. The error still
+    // propagates, so a caller like restoreFromBackup can abort before swapping
+    // the database file.
+    try {
+        await closing.close();
+    }
+    finally {
         storageInstance = null;
     }
 }
-/** Test-only: inject a pre-initialized storage instance into the singleton slot. */
+/**
+ * Test-only: inject a pre-initialized storage instance into the singleton slot.
+ *
+ * CONTRACT: the CALLER owns the lifecycle of what it injects. This function
+ * deliberately does NOT close the instance it replaces — callers pair the
+ * injection with their own cleanup (see createTestDb().cleanup), so closing
+ * here would double-close a storage the test still owns.
+ *
+ * Worth knowing when auditing handle leaks: an instance dropped without
+ * close() keeps its sqlite lock, and on Windows that lock blocks unlink of
+ * the database file until the process exits (libsql close() does not release
+ * it either — tursodatabase/libsql-js#228 — so closing is hygiene, not a
+ * guarantee).
+ */
 export function _setStorageForTesting(instance) {
     storageInstance = instance;
 }

package/dist/utils/backup.js

@@ -165,7 +165,24 @@ export async function restoreFromBackup(dbPath, backupPath) {
         // Create pre-restore backup
         const preRestoreResult = await createBackup(dbPath);
         debugLog(`Pre-restore backup: ${preRestoreResult.success ? "OK" : "FAILED"}`);
-        // Copy backup over current database
+        // Release the live connection BEFORE swapping the file underneath it.
+        //
+        // NOT a platform workaround. Measured on windows-x64 (2026-08-05):
+        // overwriting the database while a connection is open SUCCEEDS on
+        // every platform — SQLite shares the file for reading and writing,
+        // and only unlink/rename are blocked. So restore was never broken.
+        //
+        // The reason is correctness: replacing a database file beneath a live
+        // connection leaves that connection pointing at bytes it did not
+        // read, with a stale page cache and a WAL that no longer describes
+        // the file. SQLite documents this as unsafe. closeStorage() makes the
+        // swap atomic from the connection's point of view — the next
+        // getStorage() opens the restored file cleanly.
+        const { closeStorage } = await import("../storage/index.js");
+        await closeStorage();
+        // Copy backup over current database. closeStorage() cleared the
+        // singleton, so the next getStorage() re-opens against the restored
+        // file and no caller retains a handle to the replaced one.
         copyFileSync(backupPath, dbPath);
         return {
             success: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.7.0",
+  "version": "20.7.1",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder \u2014 Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B\u201332B open-weights LLM fleet.",
   "module": "index.ts",