indelible-mcp 2.3.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "2.3.0",
+  "version": "2.4.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

@@ -24,6 +24,9 @@ import { saveFile } from './tools/save_file.js'
 import { saveProject } from './tools/save_project.js'
 import { loadFile } from './tools/load_file.js'
 import { loadProject } from './tools/load_project.js'
+import { saveStyle, saveStyleFromFile } from './tools/save_style.js'
+import { loadStyle } from './tools/load_style.js'
+import { updateVaultIndex } from './tools/update_vault_index.js'
 
 const CONTEXT_FILE = join(homedir(), '.indelible', 'indelible-context.jsonl')
 
@@ -162,15 +165,39 @@ async function runCli(args) {
         const outputDir = outArg ? outArg.split('=')[1] : undefined
         const result = await loadProject(txId, { outputDir })
         console.log(JSON.stringify(result, null, 2))
+      } else if (subCmd === 'save-style') {
+        const filePath = args[2]
+        const nameArg = args.find(a => a.startsWith('--name='))
+        const descArg = args.find(a => a.startsWith('--desc='))
+        const styleName = nameArg ? nameArg.split('=')[1] : 'default'
+        const description = descArg ? descArg.split('=')[1] : ''
+        let result
+        if (filePath) {
+          result = await saveStyleFromFile(filePath, styleName, description)
+        } else {
+          console.error('Usage: indelible-mcp vault save-style <file> [--name=NAME] [--desc=DESC]')
+          break
+        }
+        console.log(JSON.stringify(result, null, 2))
+      } else if (subCmd === 'load-style') {
+        const txId = args[2]
+        const result = await loadStyle(txId)
+        console.log(JSON.stringify(result, null, 2))
+      } else if (subCmd === 'update-index') {
+        const result = await updateVaultIndex()
+        console.log(JSON.stringify(result, null, 2))
       } else {
         console.log(`
 Code Vault — Encrypted code storage on BSV blockchain
 
 Commands:
-  vault save-file <path>                    Save a file to blockchain
-  vault save-project <dir> [--name=NAME]    Save a project directory to blockchain
-  vault load-file <txid> [--output=path]    Load a file from blockchain
-  vault load-project <txid> [--output-dir=path]  Load a project from blockchain
+  vault save-file <path>                          Save a file to blockchain
+  vault save-project <dir> [--name=NAME]          Save a project directory
+  vault load-file <txid> [--output=path]          Load a file from blockchain
+  vault load-project <txid> [--output-dir=path]   Load a project from blockchain
+  vault save-style <file> [--name=N] [--desc=D]   Save an AI style to blockchain
+  vault load-style [txid]                         Load an AI style from blockchain
+  vault update-index                              Update on-chain vault index
 `)
       }
       break
@@ -193,26 +220,34 @@ Commands:
 
 function printHelp() {
   console.log(`
-Indelible MCP — Blockchain memory for Claude Code
-
-Usage:
-  indelible-mcp setup --wif=KEY --pin=PIN  Import and encrypt your private key
-  indelible-mcp save               Save current session to blockchain
-  indelible-mcp save --summary XYZ Save with custom summary
-  indelible-mcp load               Load context from blockchain
-  indelible-mcp load --sessions=5  Load N sessions
-  indelible-mcp status             Show account status
-  indelible-mcp install-hooks      Install auto-save/restore hooks into Claude Code
-  indelible-mcp hook pre-compact   Pre-compaction save hook
-  indelible-mcp hook post-compact  Post-compaction restore hook
+Indelible MCP — Blockchain memory for Claude Code (v2.4.0)
 
-Code Vault:
-  indelible-mcp vault save-file <path>           Save a file to blockchain
-  indelible-mcp vault save-project <dir>         Save a project to blockchain
-  indelible-mcp vault load-file <txid>           Load a file from blockchain
-  indelible-mcp vault load-project <txid>        Load a project from blockchain
+Setup:
+  indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
+  indelible-mcp install-hooks                Install auto-save/restore hooks
+  indelible-mcp status                       Show account status
+  indelible-mcp --show-config                Show MCP config JSON
 
-Get your key: Sign in at indelible.one with Google → Settings → Private Key
+Sessions:
+  indelible-mcp save                         Save current session to blockchain
+  indelible-mcp save --summary "my note"     Save with custom summary
+  indelible-mcp load                         Load context from blockchain
+  indelible-mcp load --sessions=10           Load N sessions
+
+Code Vault:
+  indelible-mcp vault save-file <path>                        Save a file
+  indelible-mcp vault save-project <dir> [--name=NAME]        Save a project
+  indelible-mcp vault load-file <txid> [--output=path]        Load a file
+  indelible-mcp vault load-project <txid> [--output-dir=dir]  Load a project
+  indelible-mcp vault save-style <file> [--name=N] [--desc=D] Save an AI style
+  indelible-mcp vault load-style [txid]                       Load an AI style
+  indelible-mcp vault update-index                            Update vault index
+
+Hooks (auto-called by Claude Code):
+  indelible-mcp hook pre-compact             Auto-save before compaction
+  indelible-mcp hook post-compact            Auto-restore after compaction
+
+Get your key: Sign in at indelible.one → Settings → Private Key
 Learn more: https://indelible.one
 `)
 }
@@ -281,8 +316,8 @@ function readStdin() {
 
 const SERVER_INFO = {
   name: 'indelible',
-  version: '2.0.0',
-  description: 'Blockchain-backed memory for Claude Code'
+  version: '2.4.0',
+  description: 'Blockchain-backed memory and code storage for Claude Code'
 }
 
 const TOOLS = [
@@ -321,6 +356,30 @@ const TOOLS = [
       },
       required: []
     }
+  },
+  {
+    name: 'save_style',
+    description: 'Save an AI interaction style (rules/preferences) to blockchain. Encrypted with your key.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        rules_text: { type: 'string', description: 'The full rules/style text (markdown)' },
+        style_name: { type: 'string', description: 'Short name for this style' },
+        description: { type: 'string', description: 'One-line description' }
+      },
+      required: ['rules_text', 'style_name']
+    }
+  },
+  {
+    name: 'load_style',
+    description: 'Load an AI interaction style from blockchain. Returns rules text and metadata.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        txid: { type: 'string', description: 'Transaction ID of the style. If omitted, loads last saved style.' }
+      },
+      required: []
+    }
   }
 ]
 
@@ -356,6 +415,12 @@ async function handleMcpRequest(request) {
           case 'load_context':
             result = await loadContext(args?.num_sessions)
             break
+          case 'save_style':
+            result = await saveStyle(args?.rules_text, args?.style_name, args?.description)
+            break
+          case 'load_style':
+            result = await loadStyle(args?.txid)
+            break
           default:
             throw new Error(`Unknown tool: ${name}`)
         }

package/src/lib/spv.js

@@ -10,7 +10,12 @@
 import { Transaction, P2PKH, PrivateKey, SatoshisPerKilobyte, LockingScript, OP } from '@bsv/sdk'
 import { loadConfig } from './config.js'
 
-const DEFAULT_SPV_URL = 'http://107.191.49.18:8080'
+const DEFAULT_SPV_BRIDGES = [
+  { url: 'http://45.76.19.199:8080', name: 'SPV-NODE-THREE' },
+  { url: 'http://144.202.50.135:8080', name: 'SPV-RELAY-FOUR' },
+  { url: 'http://155.138.254.224:8080', name: 'BSV SPV Bridge' },
+  { url: 'http://107.191.49.18:8080', name: 'spv-bridge-2' },
+]
 
 function getBridges() {
   const config = loadConfig()
@@ -24,8 +29,7 @@ function getBridges() {
     }))
   }
 
-  const url = config?.spv_url || DEFAULT_SPV_URL
-  return [{ url, name: url, apiKey }]
+  return DEFAULT_SPV_BRIDGES.map(b => ({ ...b, apiKey }))
 }
 
 async function spvFetch(path, options = {}) {

package/src/tools/load_style.js

@@ -0,0 +1,106 @@
+/**
+ * load_style tool
+ * Load an AI interaction style from blockchain by txid.
+ * Protocol: INDELIBLE_STYLE_V1
+ *
+ * Fetches the tx, decrypts with the owner's WIF, returns the rules text.
+ * Used by post-compact hook to reload rules after context compaction.
+ */
+
+import { loadConfig, getWif } from '../lib/config.js'
+import { decrypt } from '../lib/crypto.js'
+import * as spv from '../lib/spv.js'
+
+/**
+ * Fetch and extract encrypted style data from a blockchain tx.
+ * Tries SPV bridge first, falls back to WhatsOnChain.
+ *
+ * @param {string} txId - Transaction ID
+ * @returns {Promise<string|null>} Encrypted data string or null
+ */
+async function fetchStyleFromChain(txId) {
+  const cleanTxId = txId.trim()
+
+  // Try SPV bridge first
+  try {
+    const tx = await spv.getTx(cleanTxId)
+    const encrypted = spv.extractEncryptedFromTx(tx)
+    if (encrypted) return encrypted
+  } catch {
+    // SPV bridge failed, try WhatsOnChain
+  }
+
+  // Fallback: WhatsOnChain — parse OP_RETURN for JSON payload
+  try {
+    const res = await fetch(`https://api.whatsonchain.com/v1/bsv/main/tx/${cleanTxId}`)
+    if (!res.ok) return null
+    const tx = await res.json()
+    const opReturn = tx.vout?.find(out => out.value === 0)
+    if (!opReturn) return null
+    const hex = opReturn.scriptPubKey?.hex
+    if (!hex) return null
+    const str = Buffer.from(hex, 'hex').toString('utf8')
+
+    // Try to parse as JSON payload (style format has encrypted field inside JSON)
+    try {
+      // Find the JSON object in the OP_RETURN data
+      const jsonStart = str.indexOf('{')
+      if (jsonStart === -1) return null
+      const json = JSON.parse(str.slice(jsonStart))
+      if (json.protocol === 'indelible.style' && json.encrypted) {
+        return json.encrypted
+      }
+    } catch {
+      // Not JSON format, try raw encrypted format (iv:tag:ciphertext)
+      const match = str.match(/([A-Za-z0-9+/=]{12,}):([A-Za-z0-9+/=]{20,}):([A-Za-z0-9+/=]{20,})/)
+      return match ? match[0] : null
+    }
+  } catch {
+    return null
+  }
+
+  return null
+}
+
+/**
+ * Load a style from blockchain.
+ *
+ * @param {string} [txId] - Transaction ID. If omitted, reads from config.style_txid
+ * @returns {Promise<Object>} Result with rules text and metadata
+ */
+export async function loadStyle(txId) {
+  const config = await loadConfig()
+  const wif = await getWif()
+  if (!wif) {
+    return { success: false, error: 'Wallet not configured or PIN incorrect.' }
+  }
+
+  // Use provided txId or fall back to config
+  const styleTxId = txId || config.style_txid
+  if (!styleTxId) {
+    return { success: false, error: 'No style txId provided and none saved in config.' }
+  }
+
+  try {
+    const encrypted = await fetchStyleFromChain(styleTxId)
+    if (!encrypted) {
+      return { success: false, error: `Could not fetch style from tx: ${styleTxId}` }
+    }
+
+    const decrypted = JSON.parse(decrypt(encrypted, wif))
+
+    return {
+      success: true,
+      txId: styleTxId,
+      styleId: decrypted.id,
+      name: decrypted.name,
+      description: decrypted.description,
+      owner: decrypted.owner,
+      createdAt: decrypted.created_at,
+      rules: decrypted.rules,
+      message: `Style "${decrypted.name}" loaded from blockchain.`
+    }
+  } catch (error) {
+    return { success: false, error: `Failed to load style: ${error.message}` }
+  }
+}

package/src/tools/save_style.js

@@ -0,0 +1,105 @@
+/**
+ * save_style tool
+ * Save an AI interaction style (rules/preferences) to blockchain.
+ * Protocol: INDELIBLE_STYLE_V1
+ *
+ * Styles are separate from session data — they define HOW the AI behaves,
+ * not WHAT was discussed. Owned by the user's WIF, retrievable by txid.
+ *
+ * Uses same encryption (AES-256-GCM) and broadcast (SPV bridge) as sessions.
+ */
+
+import { readFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import { loadConfig, saveConfig, getWif } from '../lib/config.js'
+import { encrypt, sha256 } from '../lib/crypto.js'
+import * as spv from '../lib/spv.js'
+
+/**
+ * Save a style ruleset to blockchain.
+ *
+ * @param {string} rulesText - The full rules text (markdown)
+ * @param {string} styleName - Short name for this style (e.g., "strict-control-flow")
+ * @param {string} description - One-line description
+ * @returns {Promise<Object>} Result with txId
+ */
+export async function saveStyle(rulesText, styleName, description) {
+  const config = await loadConfig()
+  const wif = await getWif()
+  if (!wif) {
+    return { success: false, error: 'Wallet not configured or PIN incorrect. Run setup_wallet first.' }
+  }
+
+  if (!rulesText || rulesText.trim().length === 0) {
+    return { success: false, error: 'No rules text provided.' }
+  }
+
+  // Build style object
+  const styleId = sha256(styleName + Date.now())
+  const style = {
+    id: styleId,
+    protocol: 'INDELIBLE_STYLE_V1',
+    name: styleName,
+    description: description || '',
+    owner: config.address,
+    created_at: new Date().toISOString(),
+    rules: rulesText
+  }
+
+  // Encrypt
+  const encrypted = encrypt(JSON.stringify(style), wif)
+
+  // Build OP_RETURN payload (metadata is plaintext, rules are encrypted)
+  const payload = {
+    protocol: 'indelible.style',
+    version: 1,
+    name: styleName,
+    description: description || '',
+    owner: config.address,
+    style_id: styleId,
+    encrypted,
+    timestamp: style.created_at
+  }
+
+  // Broadcast via SPV
+  try {
+    const utxos = await spv.getUtxos(config.address)
+    if (!utxos || utxos.length === 0) {
+      return { success: false, error: 'No UTXOs available. Fund your wallet first.' }
+    }
+
+    const { txHex, txId } = await spv.buildOpReturnTx(wif, utxos, JSON.stringify(payload))
+    await spv.broadcastTx(txHex)
+
+    // Store style txid in config for quick access
+    await saveConfig({
+      ...config,
+      style_txid: txId,
+      style_name: styleName,
+      style_id: styleId
+    })
+
+    return {
+      success: true,
+      txId,
+      styleId,
+      styleName,
+      rulesLength: rulesText.length,
+      message: `Style "${styleName}" saved to blockchain. txId: ${txId}`
+    }
+  } catch (error) {
+    return { success: false, error: `Failed to broadcast style: ${error.message}` }
+  }
+}
+
+/**
+ * Save style from a file path (convenience wrapper).
+ * Reads the file and calls saveStyle().
+ */
+export async function saveStyleFromFile(filePath, styleName, description) {
+  if (!existsSync(filePath)) {
+    return { success: false, error: `File not found: ${filePath}` }
+  }
+  const rulesText = await readFile(filePath, 'utf-8')
+  return saveStyle(rulesText, styleName, description)
+}

package/src/tools/update_vault_index.js

@@ -0,0 +1,71 @@
+/**
+ * update_vault_index — Broadcast a vault index tx to BSV blockchain.
+ * Contains encrypted metadata for all files + projects.
+ * Server can fetch this single tx to rebuild the entire file listing.
+ */
+
+import { loadConfig, saveConfig, getWif } from '../lib/config.js'
+import { encrypt } from '../lib/crypto.js'
+import * as spv from '../lib/spv.js'
+
+export async function updateVaultIndex() {
+  const config = await loadConfig()
+  const wif = await getWif()
+  if (!wif) return { success: false, error: 'Wallet not configured' }
+
+  const files = config.file_txids || []
+  const projects = config.project_txids || []
+
+  // Encrypt file metadata for on-chain storage
+  const encFiles = files.map(f => ({
+    txid: f.txId,
+    filename_enc: encrypt(f.filename || '', wif),
+    path_enc: encrypt(f.path || '', wif),
+    size: f.size || 0,
+    timestamp: f.timestamp || null
+  }))
+
+  const encProjects = projects.map(p => ({
+    txid: p.txId,
+    name_enc: encrypt(p.name || '', wif),
+    fileCount: p.fileCount || 0,
+    totalSize: p.totalSize || 0,
+    timestamp: p.timestamp || null
+  }))
+
+  const payload = {
+    protocol: 'indelible.vault-index',
+    version: 1,
+    files: encFiles,
+    projects: encProjects,
+    prev_index: config.vault_index_txid || null,
+    owner: config.address,
+    timestamp: new Date().toISOString()
+  }
+
+  try {
+    let utxos = await spv.getUtxos(config.address)
+    if (!utxos || utxos.length === 0) {
+      return { success: false, error: 'No UTXOs for vault index tx' }
+    }
+
+    const { txHex, txId } = await spv.buildOpReturnTx(
+      wif, utxos, JSON.stringify(payload)
+    )
+    const result = await spv.broadcastTx(txHex)
+    const indexTxId = result.txid || txId
+
+    // Save to config
+    await saveConfig({ ...config, vault_index_txid: indexTxId })
+
+    return {
+      success: true,
+      txId: indexTxId,
+      files: files.length,
+      projects: projects.length,
+      message: `Vault index updated: ${files.length} files, ${projects.length} projects. txId: ${indexTxId}`
+    }
+  } catch (error) {
+    return { success: false, error: `Failed to update vault index: ${error.message}` }
+  }
+}