indelible-mcp 3.0.0 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -223,7 +223,7 @@ Commands:
 
 function printHelp() {
   console.log(`
-Indelible MCP — Blockchain memory for Claude Code (v3.0.0)
+Indelible MCP — Blockchain memory for Claude Code (v3.1.0)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -324,7 +324,7 @@ function readStdin() {
 
 const SERVER_INFO = {
   name: 'indelible',
-  version: '3.0.0',
+  version: '3.1.0',
   description: 'Blockchain-backed memory and code storage for Claude Code'
 }
 

package/src/lib/spv.js

@@ -62,7 +62,21 @@ async function getBridges() {
     }))
   }
 
-  // No config — use gateway default
+  // No config or empty — use gateway default, auto-generate relay key if missing
+  if (!migrationDone && config?.address && (!apiKey || !apiKey.startsWith('relay_sk_'))) {
+    try {
+      const { ensureRelayKey } = await import('./api-client.js')
+      const result = await ensureRelayKey(config.address)
+      if (result) {
+        apiKey = result.key
+        config.spv_bridges = [GATEWAY_BRIDGE]
+        config.spv_api_key = apiKey
+        saveConfig(config)
+      }
+    } catch { /* backend unreachable */ }
+    migrationDone = true
+  }
+
   return [{ ...GATEWAY_BRIDGE, apiKey }]
 }
 

package/src/tools/load_context.js

@@ -8,6 +8,9 @@
  *   4. Format smart context (LOCAL)
  */
 
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
 import { loadConfig, getWif } from '../lib/config.js'
 import { decrypt } from '../lib/crypto.js'
 import { getSessions } from '../lib/api-client.js'
@@ -159,75 +162,92 @@ export async function loadContext(numSessions = 5) {
   }
 
   try {
-    // Try server index first (fast), fall back to SPV address scan
-    let sessions = []
-
-    try {
-      const result = await getSessions(config.address, numSessions, config)
-      sessions = result.sessions || []
-    } catch {
-      // Server unavailable — scan blockchain directly via SPV bridge
-      // Only check last 15 txs and stop once we have enough sessions
-      try {
-        const history = await spv.getAddressHistory(config.address)
-        const recent = history.slice(-15).reverse()
-        for (const tx of recent) {
-          if (sessions.length >= numSessions) break
-          try {
-            const txData = await spv.getTx(tx.tx_hash)
-            const encrypted = spv.extractEncryptedFromTx(txData)
-            if (encrypted) {
-              sessions.push({ txId: tx.tx_hash, encrypted })
-            }
-          } catch { continue }
-        }
-      } catch { /* SPV scan failed too */ }
-    }
-
-    if (sessions.length === 0) {
-      return {
-        success: true,
-        context: null,
-        message: 'No previous sessions found. This is a fresh start!',
-        sessionCount: 0
+    // LOCAL-FIRST: read from hard drive session index (zero network calls)
+    const indexPath = join(homedir(), '.indelible', 'session-index.json')
+    let decrypted = []
+    let source = 'local'
+
+    if (existsSync(indexPath)) {
+      const index = JSON.parse(readFileSync(indexPath, 'utf-8'))
+      const recent = index.slice(-numSessions)
+      for (const entry of recent) {
+        try {
+          if (entry.encrypted) {
+            const data = JSON.parse(decrypt(entry.encrypted, wif))
+            decrypted.push(data)
+          }
+        } catch { /* skip sessions that fail to decrypt */ }
       }
     }
 
-    // Decrypt locally — WIF never leaves
-    const decrypted = []
-    for (const session of sessions) {
+    // FALLBACK: if local index empty/missing, try server then SPV (disaster recovery)
+    if (decrypted.length === 0) {
+      source = 'blockchain'
+      let sessions = []
+
       try {
-        if (session.encrypted) {
-          const data = JSON.parse(decrypt(session.encrypted, wif))
-          decrypted.push(data)
-        } else if (session.txId) {
-          const encrypted = await fetchEncryptedFromChain(session.txId)
-          if (encrypted) {
-            const data = JSON.parse(decrypt(encrypted, wif))
-            decrypted.push(data)
+        const result = await getSessions(config.address, numSessions, config)
+        sessions = result.sessions || []
+      } catch {
+        try {
+          const history = await spv.getAddressHistory(config.address)
+          const recent = history.slice(-15).reverse()
+          for (const tx of recent) {
+            if (sessions.length >= numSessions) break
+            try {
+              const txData = await spv.getTx(tx.tx_hash)
+              const encrypted = spv.extractEncryptedFromTx(txData)
+              if (encrypted) {
+                sessions.push({ txId: tx.tx_hash, encrypted })
+              }
+            } catch { continue }
           }
+        } catch { /* SPV scan failed too */ }
+      }
+
+      if (sessions.length === 0) {
+        return {
+          success: true,
+          context: null,
+          message: 'No previous sessions found. This is a fresh start!',
+          sessionCount: 0
         }
-      } catch { /* skip sessions that fail to decrypt */ }
-    }
+      }
 
-    if (decrypted.length === 0) {
-      const contextParts = [
-        '# Restored from Blockchain Memory',
-        `Found ${sessions.length} session(s) but could not decrypt. Showing metadata only.`,
-        ''
-      ]
       for (const session of sessions) {
-        const date = session.timestamp ? new Date(session.timestamp).toLocaleDateString() : 'Unknown'
-        contextParts.push(`## Session: ${date}`)
-        contextParts.push(`Summary: ${session.summary || 'N/A'}`)
-        contextParts.push(`Messages: ${session.message_count || 'N/A'}`)
-        contextParts.push('')
+        try {
+          if (session.encrypted) {
+            const data = JSON.parse(decrypt(session.encrypted, wif))
+            decrypted.push(data)
+          } else if (session.txId) {
+            const encrypted = await fetchEncryptedFromChain(session.txId)
+            if (encrypted) {
+              const data = JSON.parse(decrypt(encrypted, wif))
+              decrypted.push(data)
+            }
+          }
+        } catch { /* skip sessions that fail to decrypt */ }
       }
-      return {
-        success: true,
-        context: contextParts.join('\n'),
-        sessionCount: sessions.length,
-        message: `Loaded ${sessions.length} session metadata from blockchain.`
+
+      if (decrypted.length === 0) {
+        const contextParts = [
+          '# Restored from Blockchain Memory',
+          `Found ${sessions.length} session(s) but could not decrypt. Showing metadata only.`,
+          ''
+        ]
+        for (const session of sessions) {
+          const date = session.timestamp ? new Date(session.timestamp).toLocaleDateString() : 'Unknown'
+          contextParts.push(`## Session: ${date}`)
+          contextParts.push(`Summary: ${session.summary || 'N/A'}`)
+          contextParts.push(`Messages: ${session.message_count || 'N/A'}`)
+          contextParts.push('')
+        }
+        return {
+          success: true,
+          context: contextParts.join('\n'),
+          sessionCount: sessions.length,
+          message: `Loaded ${sessions.length} session metadata from blockchain.`
+        }
       }
     }
 
@@ -268,7 +288,7 @@ export async function loadContext(numSessions = 5) {
         date: s.created_at,
         messageCount: s.message_count
       })),
-      message: `Smart restore: ${merged.length} conversation(s) from ${decrypted.length} blockchain chunks.`
+      message: `Smart restore (${source}): ${merged.length} conversation(s) from ${decrypted.length} chunks.`
     }
   } catch (error) {
     return { success: false, error: `Failed to load context: ${error.message}`, context: null }

package/src/tools/save_project.js

@@ -146,24 +146,6 @@ export async function saveProject(dirPath, options = {}) {
     })
     saveConfig({ ...config, project_txids: projects })
 
-    // Index in server Redis so Vault UI can see it
-    try {
-      const apiUrl = config.api_url || 'https://indelible.one'
-      await fetch(`${apiUrl}/api/files/project/index`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          address: config.address,
-          txId,
-          name: projectName,
-          fileCount: allFiles.length,
-          totalSize,
-          timestamp,
-          bundle: true
-        })
-      })
-    } catch { /* don't block save on index failure */ }
-
     return {
       success: true,
       txId,

package/src/tools/save_session.js

@@ -348,6 +348,27 @@ export async function saveSession(transcriptPath, summary) {
       messagesToCommit.length, finalTxId, structuredCtx
     )
 
+    // Append to local session index (hard drive = read cache)
+    try {
+      const indexPath = join(homedir(), '.indelible', 'session-index.json')
+      let index = []
+      if (existsSync(indexPath)) {
+        index = JSON.parse(readFileSync(indexPath, 'utf-8'))
+      }
+      index.push({
+        txId: finalTxId,
+        sessionId,
+        prevTxId: config.last_tx_id || null,
+        summary: session.summary,
+        messageCount: allMessages.length,
+        saveType: isDelta ? 'delta' : 'full',
+        newMessages: messagesToCommit.length,
+        encrypted,
+        timestamp: session.created_at
+      })
+      writeFileSync(indexPath, JSON.stringify(index, null, 2))
+    } catch { /* don't block on index failure */ }
+
     // Save memory files to blockchain via vault pipeline (UTXO chaining)
     let memoryTxId = config.memory_file_txid || null
     let historyTxId = config.session_history_txid || null