indelible-mcp 1.0.0

package/README.md

@@ -0,0 +1,99 @@
+# Indelible MCP Server
+
+Blockchain-backed memory for Claude Code. Save your AI conversations permanently on BSV.
+
+## Quick Start
+
+```bash
+npm install -g @indelible/mcp-server
+indelible-mcp --show-config
+```
+
+Copy the config output and paste it into your Claude Code settings, then restart Claude Code.
+
+## Setup
+
+### 1. Install
+
+```bash
+npm install -g @indelible/mcp-server
+```
+
+### 2. Configure Claude Code
+
+Run:
+```bash
+indelible-mcp --show-config
+```
+
+This outputs the config to add to your Claude Code settings:
+
+```json
+{
+  "mcpServers": {
+    "indelible": {
+      "command": "indelible-mcp"
+    }
+  }
+}
+```
+
+### 3. Restart Claude Code
+
+Close and reopen VS Code (or your Claude Code client).
+
+### 4. Set Up Your Wallet
+
+In Claude Code, say:
+
+> "Set up my wallet"
+
+This generates a new BSV keypair and saves it to `~/.indelible/config.json`.
+
+**Important:** Save your WIF (private key) somewhere safe. This is your identity.
+
+### 5. Fund Your Wallet
+
+Send a small amount of BSV (~$0.01) to your address for transaction fees.
+
+## Tools
+
+### `setup_wallet`
+Generate a new BSV wallet. Only needed once.
+
+```
+"Set up my wallet"
+```
+
+### `save_session`
+Save the current conversation to the blockchain.
+
+```
+"Save this session to blockchain"
+```
+
+### `load_context`
+Load previous sessions from the blockchain.
+
+```
+"Load my previous context"
+```
+
+## How It Works
+
+1. Your conversations are encrypted with AES-256-GCM using your WIF-derived key
+2. Encrypted data is stored on the BSV blockchain via OP_RETURN
+3. Only you can decrypt your data (using your WIF)
+4. Sessions are chained together for continuity
+
+## View Your Data
+
+Visit [indelible.one](https://indelible.one) and log in with your WIF to see all your saved sessions and code.
+
+## Cost
+
+~1 satoshi per byte. A typical session costs less than $0.01.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * Indelible MCP Server
+ *
+ * Provides blockchain-backed memory for Claude Code sessions.
+ * Communicates via stdio using JSON-RPC (MCP protocol).
+ *
+ * Tools:
+ *   - setup_wallet: Generate BSV keypair, save to ~/.indelible/config.json
+ *   - save_session: Read transcript, encrypt, commit to chain
+ *   - load_context: Fetch latest checkpoint, decrypt, return summary
+ */
+
+// Handle CLI flags before loading MCP
+if (process.argv.includes('--show-config')) {
+  console.log(`
+Add this to your Claude Code settings.json:
+
+{
+  "mcpServers": {
+    "indelible": {
+      "command": "indelible-mcp"
+    }
+  }
+}
+
+Then restart Claude Code and say "set up my wallet" to get started.
+`)
+  process.exit(0)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+Indelible MCP Server - Blockchain memory for Claude Code
+
+Usage:
+  indelible-mcp              Start MCP server (used by Claude Code)
+  indelible-mcp --show-config  Show Claude Code configuration
+  indelible-mcp --help         Show this help message
+
+After installing, run 'indelible-mcp --show-config' and paste
+the output into your Claude Code settings.
+
+Learn more: https://indelible.one
+`)
+  process.exit(0)
+}
+
+import { createInterface } from 'readline'
+import { setupWallet } from './tools/setup_wallet.js'
+import { saveSession } from './tools/save_session.js'
+import { loadContext } from './tools/load_context.js'
+
+// MCP Server metadata
+const SERVER_INFO = {
+  name: 'indelible-mcp',
+  version: '1.0.0',
+  description: 'Blockchain-backed memory for Claude Code'
+}
+
+// Available tools
+const TOOLS = [
+  {
+    name: 'setup_wallet',
+    description: 'Generate a new BSV wallet for Indelible AI. Creates keypair and saves to ~/.indelible/config.json. Only run once per machine.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        api_url: {
+          type: 'string',
+          description: 'Indelible API URL (default: https://indelible.one)'
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'save_session',
+    description: 'Save the current Claude Code session to the blockchain. Encrypts transcript and commits to BSV chain.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        transcript_path: {
+          type: 'string',
+          description: 'Path to the JSONL transcript file'
+        },
+        summary: {
+          type: 'string',
+          description: 'Brief summary of what was accomplished in this session'
+        }
+      },
+      required: ['transcript_path']
+    }
+  },
+  {
+    name: 'load_context',
+    description: 'Load previous session context from the blockchain. Returns summary of past sessions to restore memory.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        num_sessions: {
+          type: 'number',
+          description: 'Number of recent sessions to load (default: 3)'
+        }
+      },
+      required: []
+    }
+  }
+]
+
+// Handle MCP requests
+async function handleRequest(request) {
+  const { method, params, id } = request
+
+  try {
+    switch (method) {
+      case 'initialize':
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: SERVER_INFO,
+            capabilities: {
+              tools: {}
+            }
+          }
+        }
+
+      case 'tools/list':
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: { tools: TOOLS }
+        }
+
+      case 'tools/call':
+        const { name, arguments: args } = params
+        let result
+
+        switch (name) {
+          case 'setup_wallet':
+            result = await setupWallet(args?.api_url)
+            break
+          case 'save_session':
+            result = await saveSession(args?.transcript_path, args?.summary)
+            break
+          case 'load_context':
+            result = await loadContext(args?.num_sessions)
+            break
+          default:
+            throw new Error(`Unknown tool: ${name}`)
+        }
+
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+          }
+        }
+
+      case 'notifications/initialized':
+        // Client acknowledged initialization - no response needed
+        return null
+
+      default:
+        return {
+          jsonrpc: '2.0',
+          id,
+          error: { code: -32601, message: `Method not found: ${method}` }
+        }
+    }
+  } catch (error) {
+    return {
+      jsonrpc: '2.0',
+      id,
+      error: { code: -32000, message: error.message }
+    }
+  }
+}
+
+// Main: stdio JSON-RPC loop
+async function main() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  })
+
+  for await (const line of rl) {
+    if (!line.trim()) continue
+
+    try {
+      const request = JSON.parse(line)
+      const response = await handleRequest(request)
+
+      if (response) {
+        console.log(JSON.stringify(response))
+      }
+    } catch (error) {
+      console.log(JSON.stringify({
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32700, message: 'Parse error' }
+      }))
+    }
+  }
+}
+
+main().catch(console.error)

package/lib/api.js

@@ -0,0 +1,83 @@
+/**
+ * Indelible API client for MCP Server
+ */
+
+import fetch from 'node-fetch'
+import { loadConfig } from './config.js'
+
+const DEFAULT_API_URL = 'https://indelible.one'
+
+/**
+ * Get API base URL from config
+ */
+async function getApiUrl() {
+  const config = await loadConfig()
+  return config?.api_url || DEFAULT_API_URL
+}
+
+/**
+ * Commit a session to the blockchain
+ * @param {Object} session - Session data to commit
+ * @param {string} wif - WIF for signing/encryption
+ * @returns {Promise<{success: boolean, txId?: string, error?: string}>}
+ */
+export async function commitSession(session, wif) {
+  const apiUrl = await getApiUrl()
+
+  const response = await fetch(`${apiUrl}/api/claude-code/commit`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ session, wif })
+  })
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(error || `Commit failed: ${response.status}`)
+  }
+
+  return response.json()
+}
+
+/**
+ * Get latest sessions for an address
+ * @param {string} address - BSV address
+ * @param {string} wif - WIF for decryption
+ * @param {number} limit - Number of sessions to fetch
+ * @returns {Promise<{sessions: Array}>}
+ */
+export async function getLatestSessions(address, wif, limit = 3) {
+  const apiUrl = await getApiUrl()
+
+  const response = await fetch(`${apiUrl}/api/claude-code/latest`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ address, wif, limit })
+  })
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      return { sessions: [] }
+    }
+    throw new Error(`Failed to fetch sessions: ${response.status}`)
+  }
+
+  return response.json()
+}
+
+/**
+ * Check if API is reachable
+ * @returns {Promise<boolean>}
+ */
+export async function checkConnection() {
+  try {
+    const apiUrl = await getApiUrl()
+    const response = await fetch(`${apiUrl}/api/health`, { method: 'GET' })
+    return response.ok
+  } catch {
+    return false
+  }
+}

package/lib/config.js

@@ -0,0 +1,57 @@
+/**
+ * Config management for Indelible MCP Server
+ * Stores WIF and settings in ~/.indelible/config.json
+ */
+
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+const CONFIG_DIR = join(homedir(), '.indelible')
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
+
+/**
+ * Get config file path
+ */
+export function getConfigPath() {
+  return CONFIG_FILE
+}
+
+/**
+ * Load config from disk
+ * @returns {Promise<Object|null>} Config object or null if not found
+ */
+export async function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) {
+      return null
+    }
+    const data = await readFile(CONFIG_FILE, 'utf-8')
+    return JSON.parse(data)
+  } catch (error) {
+    return null
+  }
+}
+
+/**
+ * Save config to disk
+ * @param {Object} config - Config object to save
+ */
+export async function saveConfig(config) {
+  // Ensure directory exists
+  if (!existsSync(CONFIG_DIR)) {
+    await mkdir(CONFIG_DIR, { recursive: true })
+  }
+
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8')
+}
+
+/**
+ * Check if wallet is configured
+ * @returns {Promise<boolean>}
+ */
+export async function hasWallet() {
+  const config = await loadConfig()
+  return config?.wif != null
+}

package/lib/crypto.js

@@ -0,0 +1,64 @@
+/**
+ * Crypto utilities for Indelible MCP Server
+ * WIF-derived AES-256-GCM encryption
+ */
+
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'crypto'
+
+/**
+ * Derive encryption key from WIF
+ * @param {string} wif - Wallet Import Format private key
+ * @returns {Buffer} 32-byte key
+ */
+export function deriveKey(wif) {
+  return createHash('sha256').update(wif).digest()
+}
+
+/**
+ * Encrypt data with WIF-derived key
+ * @param {string} plaintext - Data to encrypt
+ * @param {string} wif - WIF for key derivation
+ * @returns {string} Base64 encoded encrypted data (iv:tag:ciphertext)
+ */
+export function encrypt(plaintext, wif) {
+  const key = deriveKey(wif)
+  const iv = randomBytes(12)
+  const cipher = createCipheriv('aes-256-gcm', key, iv)
+
+  let encrypted = cipher.update(plaintext, 'utf8', 'base64')
+  encrypted += cipher.final('base64')
+  const tag = cipher.getAuthTag()
+
+  // Format: iv:tag:ciphertext (all base64)
+  return `${iv.toString('base64')}:${tag.toString('base64')}:${encrypted}`
+}
+
+/**
+ * Decrypt data with WIF-derived key
+ * @param {string} encrypted - Base64 encoded encrypted data (iv:tag:ciphertext)
+ * @param {string} wif - WIF for key derivation
+ * @returns {string} Decrypted plaintext
+ */
+export function decrypt(encrypted, wif) {
+  const [ivB64, tagB64, ciphertext] = encrypted.split(':')
+  const key = deriveKey(wif)
+  const iv = Buffer.from(ivB64, 'base64')
+  const tag = Buffer.from(tagB64, 'base64')
+
+  const decipher = createDecipheriv('aes-256-gcm', key, iv)
+  decipher.setAuthTag(tag)
+
+  let decrypted = decipher.update(ciphertext, 'base64', 'utf8')
+  decrypted += decipher.final('utf8')
+
+  return decrypted
+}
+
+/**
+ * Hash data with SHA256
+ * @param {string} data - Data to hash
+ * @returns {string} Hex-encoded hash
+ */
+export function sha256(data) {
+  return createHash('sha256').update(data).digest('hex')
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "indelible-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Indelible AI - blockchain-backed memory for Claude Code",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "indelible-mcp": "index.js"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "tools/",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "indelible",
+    "blockchain",
+    "bsv",
+    "ai-memory"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@bsv/sdk": "^1.1.23",
+    "node-fetch": "^3.3.2"
+  }
+}

package/tools/load_context.js

@@ -0,0 +1,124 @@
+/**
+ * load_context tool
+ * Fetch latest checkpoints from blockchain, decrypt, and return context summary
+ */
+
+import { loadConfig } from '../lib/config.js'
+import { decrypt } from '../lib/crypto.js'
+import { getLatestSessions } from '../lib/api.js'
+
+/**
+ * Format session for context injection
+ * @param {Object} session - Decrypted session object
+ * @returns {string} Formatted session summary
+ */
+function formatSession(session) {
+  const date = new Date(session.created_at).toLocaleDateString()
+  const lines = [
+    `## Session: ${date}`,
+    `Summary: ${session.summary}`,
+    `Messages: ${session.message_count}`,
+    ''
+  ]
+
+  // Include key exchanges (first 3 user/assistant pairs)
+  if (session.messages?.length > 0) {
+    lines.push('### Key points:')
+    let count = 0
+    for (const msg of session.messages) {
+      if (count >= 6) break // 3 pairs max
+      const role = msg.role === 'user' ? 'User' : 'Assistant'
+      const content = typeof msg.content === 'string'
+        ? msg.content.slice(0, 150)
+        : JSON.stringify(msg.content).slice(0, 150)
+      lines.push(`- ${role}: ${content}${content.length >= 150 ? '...' : ''}`)
+      count++
+    }
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Load previous session context from blockchain
+ * @param {number} numSessions - Number of recent sessions to load (default: 3)
+ * @returns {Promise<Object>} Result with context and status
+ */
+export async function loadContext(numSessions = 3) {
+  // Load config
+  const config = await loadConfig()
+  if (!config?.wif) {
+    return {
+      success: false,
+      error: 'Wallet not configured. Run setup_wallet first.',
+      context: null
+    }
+  }
+
+  try {
+    // Fetch sessions from API
+    const { sessions } = await getLatestSessions(config.address, config.wif, numSessions)
+
+    if (!sessions || sessions.length === 0) {
+      return {
+        success: true,
+        context: null,
+        message: 'No previous sessions found. This is a fresh start!',
+        sessionCount: 0
+      }
+    }
+
+    // Decrypt and format each session
+    const decrypted = []
+    for (const session of sessions) {
+      try {
+        const data = JSON.parse(decrypt(session.encrypted, config.wif))
+        decrypted.push(data)
+      } catch {
+        // Skip sessions that fail to decrypt
+      }
+    }
+
+    if (decrypted.length === 0) {
+      return {
+        success: true,
+        context: null,
+        message: 'Found sessions but could not decrypt. Key mismatch?',
+        sessionCount: sessions.length
+      }
+    }
+
+    // Build context string
+    const contextParts = [
+      '# Previous Session Context',
+      `Loaded ${decrypted.length} recent session(s) from blockchain.`,
+      ''
+    ]
+
+    for (const session of decrypted) {
+      contextParts.push(formatSession(session))
+    }
+
+    const context = contextParts.join('\n')
+
+    return {
+      success: true,
+      context,
+      sessionCount: decrypted.length,
+      sessions: decrypted.map(s => ({
+        id: s.id,
+        summary: s.summary,
+        date: s.created_at,
+        messageCount: s.message_count
+      })),
+      message: `Loaded ${decrypted.length} session(s) from blockchain memory.`
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to load context: ${error.message}`,
+      context: null
+    }
+  }
+}

package/tools/save_session.js

@@ -0,0 +1,165 @@
+/**
+ * save_session tool
+ * Read transcript JSONL, encrypt, and commit to blockchain
+ * Supports session chaining via prev_session_id
+ */
+
+import { readFile, writeFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import { loadConfig, saveConfig } from '../lib/config.js'
+import { encrypt, sha256 } from '../lib/crypto.js'
+import { commitSession } from '../lib/api.js'
+
+/**
+ * Parse JSONL transcript file
+ * @param {string} path - Path to JSONL file
+ * @returns {Promise<Array>} Array of message objects
+ */
+async function parseTranscript(path) {
+  const content = await readFile(path, 'utf-8')
+  const lines = content.trim().split('\n')
+  const messages = []
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+    try {
+      const entry = JSON.parse(line)
+      // Extract relevant fields from Claude Code transcript format
+      // Claude Code uses type: "user" and type: "assistant"
+      if (entry.type === 'user' || entry.type === 'assistant') {
+        // Extract content from message object
+        let content = ''
+        if (entry.message?.content) {
+          // Content can be array of content blocks or string
+          if (Array.isArray(entry.message.content)) {
+            content = entry.message.content
+              .filter(c => c.type === 'text')
+              .map(c => c.text)
+              .join('\n')
+          } else {
+            content = entry.message.content
+          }
+        }
+
+        if (content) {
+          messages.push({
+            role: entry.type === 'user' ? 'user' : 'assistant',
+            content,
+            timestamp: entry.timestamp || new Date().toISOString()
+          })
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return messages
+}
+
+/**
+ * Create session summary from messages
+ * @param {Array} messages - Array of messages
+ * @param {string} userSummary - Optional user-provided summary
+ * @returns {string} Session summary
+ */
+function createSummary(messages, userSummary) {
+  if (userSummary) return userSummary
+
+  // Auto-generate summary from first user message
+  const firstUser = messages.find(m => m.role === 'user')
+  if (firstUser) {
+    const preview = typeof firstUser.content === 'string'
+      ? firstUser.content.slice(0, 200)
+      : JSON.stringify(firstUser.content).slice(0, 200)
+    return preview + (preview.length >= 200 ? '...' : '')
+  }
+
+  return 'Claude Code session'
+}
+
+/**
+ * Save current session to blockchain
+ * @param {string} transcriptPath - Path to JSONL transcript
+ * @param {string} summary - Optional session summary
+ * @returns {Promise<Object>} Result with txId and status
+ */
+export async function saveSession(transcriptPath, summary) {
+  // Load config
+  const config = await loadConfig()
+  if (!config?.wif) {
+    return {
+      success: false,
+      error: 'Wallet not configured. Run setup_wallet first.'
+    }
+  }
+
+  // Check transcript exists
+  if (!transcriptPath || !existsSync(transcriptPath)) {
+    return {
+      success: false,
+      error: `Transcript not found: ${transcriptPath}`
+    }
+  }
+
+  // Parse transcript
+  const messages = await parseTranscript(transcriptPath)
+  if (messages.length === 0) {
+    return {
+      success: false,
+      error: 'No messages found in transcript'
+    }
+  }
+
+  // Get previous session ID for chaining
+  const prevSessionId = config.last_session_id || null
+
+  // Create session object
+  const sessionId = sha256(transcriptPath + Date.now())
+  const session = {
+    id: sessionId,
+    type: 'claude-code',
+    prev_session_id: prevSessionId,
+    summary: createSummary(messages, summary),
+    message_count: messages.length,
+    created_at: new Date().toISOString(),
+    messages: messages
+  }
+
+  // Encrypt session data
+  const encrypted = encrypt(JSON.stringify(session), config.wif)
+
+  // Commit to chain
+  try {
+    const result = await commitSession({
+      address: config.address,
+      encrypted,
+      summary: session.summary,
+      message_count: session.message_count,
+      session_id: sessionId,
+      prev_session_id: prevSessionId
+    }, config.wif)
+
+    // Update config with new session ID for chaining
+    await saveConfig({
+      ...config,
+      last_session_id: sessionId,
+      last_tx_id: result.txId
+    })
+
+    return {
+      success: true,
+      txId: result.txId,
+      sessionId: sessionId,
+      prevSessionId: prevSessionId,
+      messageCount: messages.length,
+      summary: session.summary,
+      message: `Session saved! ${messages.length} messages committed to blockchain.${prevSessionId ? ' Linked to previous session.' : ' (First session)'}`
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to commit: ${error.message}`
+    }
+  }
+}

package/tools/setup_wallet.js

@@ -0,0 +1,57 @@
+/**
+ * setup_wallet tool
+ * Generate BSV keypair and save to ~/.indelible/config.json
+ */
+
+import { PrivateKey } from '@bsv/sdk'
+import { loadConfig, saveConfig, getConfigPath } from '../lib/config.js'
+import { checkConnection } from '../lib/api.js'
+
+const DEFAULT_API_URL = 'https://indelible.one'
+
+/**
+ * Generate a new BSV wallet for Indelible AI
+ * @param {string} apiUrl - Optional API URL override
+ * @returns {Promise<Object>} Result with address and status
+ */
+export async function setupWallet(apiUrl = DEFAULT_API_URL) {
+  // Check if wallet already exists
+  const existing = await loadConfig()
+  if (existing?.wif) {
+    return {
+      success: false,
+      error: 'Wallet already configured',
+      address: existing.address,
+      configPath: getConfigPath(),
+      hint: 'Delete ~/.indelible/config.json to reset'
+    }
+  }
+
+  // Generate new keypair
+  const privateKey = PrivateKey.fromRandom()
+  const wif = privateKey.toWif()
+  const address = privateKey.toPublicKey().toAddress()
+
+  // Save config
+  const config = {
+    wif,
+    address,
+    api_url: apiUrl,
+    created_at: new Date().toISOString()
+  }
+
+  await saveConfig(config)
+
+  // Check API connection
+  const connected = await checkConnection()
+
+  return {
+    success: true,
+    address,
+    configPath: getConfigPath(),
+    apiConnected: connected,
+    message: connected
+      ? `Wallet created! Address: ${address}. Connected to ${apiUrl}`
+      : `Wallet created! Address: ${address}. Warning: Could not connect to ${apiUrl}`
+  }
+}