indelible-mcp 2.2.0 → 2.2.1

package/README.md

@@ -6,41 +6,27 @@ Blockchain-backed memory for Claude Code. Save your AI conversations permanently
 
 ```bash
 npm install -g indelible-mcp
-indelible-mcp --show-config
+indelible-mcp setup
 ```
 
-Copy the config output and paste it into your Claude Code settings, then restart Claude Code.
-
 ## Setup
 
-### 1. Sign Up at indelible.one
-
-Sign in with Google at [indelible.one](https://indelible.one). Your BSV private key (WIF) is generated automatically and shown in Settings.
-
-### 2. Install
+### 1. Install & Create Wallet
 
 ```bash
 npm install -g indelible-mcp
+indelible-mcp setup
 ```
 
-### 3. Import Your Key
-
-```bash
-indelible-mcp setup --wif=YOUR_KEY
-```
-
-Paste the WIF from your indelible.one Settings page. This saves it to `~/.indelible/config.json`.
+This generates a BSV keypair locally (your private key never leaves your machine) and registers with the Indelible server.
 
-**Your key never leaves your machine.**
+### 2. Fund Your Wallet
 
-### 4. Configure Claude Code
+Send a small amount of BSV to the address shown after setup. Any BSV wallet works (HandCash, RelayX, etc.).
 
-Run:
-```bash
-indelible-mcp --show-config
-```
+### 3. Add MCP Config to Claude Code
 
-Add the output to your Claude Code settings:
+Run `indelible-mcp --show-config` to get your config, or add this to your Claude Code `settings.json`:
 
 ```json
 {
@@ -52,52 +38,45 @@ Add the output to your Claude Code settings:
 }
 ```
 
-### 5. Restart Claude Code
+## Usage
 
-Close and reopen VS Code (or your Claude Code client).
+Once configured, just talk to Claude Code naturally:
 
-### 6. Fund Your Wallet
+- **"Save this session to blockchain"** - saves your conversation
+- **"Load my previous context"** - restores past sessions
+- **"Delta save"** - saves only new messages (cheaper, faster)
 
-Send a small amount of BSV (~$0.01) to your address for transaction fees.
+### Auto-Save & Auto-Restore
 
-## Tools
+Indelible automatically saves before Claude Code compacts your context, and restores your sessions after compaction. Nothing is lost.
 
-### `setup_wallet`
-Import your BSV wallet from indelible.one. Only needed once.
+### CLI Commands
 
 ```
-"Import my wallet" or indelible-mcp setup --wif=YOUR_KEY
-```
-
-### `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"
+indelible-mcp setup              Generate wallet & register
+indelible-mcp setup --migrate    Derive API key from existing wallet
+indelible-mcp save               Save current session
+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 hook pre-compact   Pre-compaction save hook
+indelible-mcp hook post-compact  Post-compaction restore hook
 ```
 
 ## 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 sign in with Google to see all your saved sessions and code.
+1. Your conversation is encrypted locally with your WIF key
+2. An OP_RETURN transaction is built and signed locally using `@bsv/sdk`
+3. The signed transaction is broadcast via Indelible's SPV bridge
+4. Your private key **never** leaves your machine
 
-## Cost
+## Security
 
-~1 satoshi per byte. A typical session costs less than $0.01.
+- **Zero-knowledge encryption** - your WIF-derived AES-256-GCM key encrypts all data before it touches the network
+- **Self-sovereign keys** - generated locally with `@bsv/sdk`, never transmitted
+- **Immutable storage** - once on BSV, your data cannot be altered or deleted
 
-## License
+## Learn More
 
-MIT
+[indelible.one](https://indelible.one)

package/package.json

@@ -1,35 +1,39 @@
 {
   "name": "indelible-mcp",
-  "version": "2.2.0",
-  "description": "MCP server for Indelible AI - blockchain-backed memory for Claude Code",
+  "version": "2.2.1",
+  "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
-  "main": "index.js",
+  "main": "src/index.js",
   "bin": {
-    "indelible-mcp": "index.js"
+    "indelible-mcp": "src/index.js"
   },
   "files": [
-    "index.js",
-    "lib/",
-    "tools/",
-    "README.md"
+    "src/"
   ],
   "scripts": {
-    "start": "node index.js"
+    "start": "node src/index.js",
+    "build": "bun build --compile src/index.js --outfile dist/indelible.exe",
+    "build:all": "bun build --compile --target=bun-windows-x64 src/index.js --outfile dist/indelible-win-x64.exe && bun build --compile --target=bun-linux-x64 src/index.js --outfile dist/indelible-linux-x64 && bun build --compile --target=bun-darwin-arm64 src/index.js --outfile dist/indelible-darwin-arm64"
   },
   "keywords": [
+    "claude-code",
     "mcp",
-    "claude",
-    "indelible",
     "blockchain",
     "bsv",
-    "ai-memory"
+    "memory",
+    "context",
+    "indelible",
+    "code-vault",
+    "encrypted-storage"
   ],
-  "author": "",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/indelibleai/indelible-mcp"
+  },
+  "homepage": "https://indelible.one",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.52.0",
-    "@bsv/sdk": "^1.1.23",
-    "cross-keychain": "^1.1.0",
-    "node-fetch": "^3.3.2"
+    "@bsv/sdk": "1.10.1",
+    "cross-keychain": "^1.1.0"
   }
 }

package/src/index.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+/**
+ * Indelible CLI — Blockchain memory for Claude Code
+ *
+ * Modes:
+ *   indelible-mcp setup --wif=KEY     Import private key from indelible.one
+ *   indelible-mcp save [--summary]   Save current session to blockchain
+ *   indelible-mcp load [--sessions]  Load context from blockchain
+ *   indelible-mcp status             Show account status
+ *   indelible-mcp hook pre-compact   Pre-compaction save hook
+ *   indelible-mcp hook post-compact  Post-compaction restore hook
+ *   (stdin pipe, no TTY)         MCP stdio JSON-RPC server mode
+ */
+
+import { createInterface } from 'node:readline'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { loadConfig } from './lib/config.js'
+import { setupWallet } from './tools/setup_wallet.js'
+import { saveSession } from './tools/save_session.js'
+import { loadContext } from './tools/load_context.js'
+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'
+
+const CONTEXT_FILE = join(homedir(), '.indelible', 'indelible-context.jsonl')
+
+// ============ CLI MODE ============
+
+async function runCli(args) {
+  const command = args[0]
+
+  switch (command) {
+    case 'setup': {
+      const apiUrl = args.find(a => a.startsWith('--api='))?.split('=')[1]
+      const importWif = args.find(a => a.startsWith('--wif='))?.split('=')[1]
+      const pin = args.find(a => a.startsWith('--pin='))?.split('=')[1]
+      const result = await setupWallet(apiUrl || undefined, importWif, pin)
+      console.log(JSON.stringify(result, null, 2))
+      break
+    }
+
+    case 'save': {
+      const summaryIdx = args.indexOf('--summary')
+      const summary = summaryIdx !== -1 ? args.slice(summaryIdx + 1).join(' ') : undefined
+      const result = await saveSession(CONTEXT_FILE, summary)
+      console.log(JSON.stringify(result, null, 2))
+      break
+    }
+
+    case 'load': {
+      const sessionsArg = args.find(a => a.startsWith('--sessions='))
+      const numSessions = sessionsArg ? parseInt(sessionsArg.split('=')[1]) : 5
+      const result = await loadContext(numSessions)
+      if (result.context) {
+        // Output context to stdout (for piping)
+        console.log(result.context)
+      } else {
+        console.log(JSON.stringify(result, null, 2))
+      }
+      break
+    }
+
+    case 'status': {
+      const config = loadConfig()
+      if (!config?.wif_encrypted && !config?.wif) {
+        console.log(JSON.stringify({ error: 'Wallet not configured. Run: indelible-mcp setup' }))
+        break
+      }
+      console.log(JSON.stringify({
+        address: config.address,
+        encrypted: !!config.wif_encrypted,
+        api_key: config.api_key ? '***' + config.api_key.slice(-8) : 'not set',
+        api_url: config.api_url,
+        last_session_id: config.last_session_id || null,
+        last_saved_message_count: config.last_saved_message_count || 0
+      }, null, 2))
+      break
+    }
+
+    case 'vault': {
+      const subCmd = args[1]
+      if (subCmd === 'save-file') {
+        const filePath = args[2]
+        if (!filePath) { console.error('Usage: indelible-mcp vault save-file <path>'); break }
+        const result = await saveFile(filePath)
+        console.log(JSON.stringify(result, null, 2))
+      } else if (subCmd === 'save-project') {
+        const dirPath = args[2]
+        if (!dirPath) { console.error('Usage: indelible-mcp vault save-project <dir>'); break }
+        const nameArg = args.find(a => a.startsWith('--name='))
+        const name = nameArg ? nameArg.split('=')[1] : undefined
+        const result = await saveProject(dirPath, { name })
+        console.log(JSON.stringify(result, null, 2))
+      } else if (subCmd === 'load-file') {
+        const txId = args[2]
+        if (!txId) { console.error('Usage: indelible-mcp vault load-file <txid> [--output=path]'); break }
+        const outArg = args.find(a => a.startsWith('--output='))
+        const outputPath = outArg ? outArg.split('=')[1] : undefined
+        const result = await loadFile(txId, { outputPath })
+        console.log(JSON.stringify(result, null, 2))
+      } else if (subCmd === 'load-project') {
+        const txId = args[2]
+        if (!txId) { console.error('Usage: indelible-mcp vault load-project <txid> [--output-dir=path]'); break }
+        const outArg = args.find(a => a.startsWith('--output-dir='))
+        const outputDir = outArg ? outArg.split('=')[1] : undefined
+        const result = await loadProject(txId, { outputDir })
+        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
+`)
+      }
+      break
+    }
+
+    default:
+      printHelp()
+  }
+}
+
+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 hook pre-compact   Pre-compaction save hook
+  indelible-mcp hook post-compact  Post-compaction restore hook
+
+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
+
+Get your key: Sign in at indelible.one with Google → Settings → Private Key
+Learn more: https://indelible.one
+`)
+}
+
+// ============ HOOK MODE ============
+
+async function runPreCompactSave() {
+  // Read stdin for hook metadata (Claude Code sends JSON)
+  let trigger = 'auto'
+  try {
+    const stdin = await readStdin()
+    if (stdin) {
+      const meta = JSON.parse(stdin)
+      trigger = meta.trigger || 'auto'
+    }
+  } catch { /* no stdin or not JSON */ }
+
+  const config = loadConfig()
+  if (!config?.mcp_enabled && config?.mcp_enabled !== undefined) {
+    process.stderr.write('Indelible: MCP disabled, skipping save\n')
+    process.exit(0)
+  }
+
+  const result = await saveSession(CONTEXT_FILE, `Auto-save before ${trigger} compaction`)
+
+  if (result.success) {
+    process.stderr.write(`Indelible: Saved ${result.newMessages} messages (${result.saveType}) tx:${result.txId?.slice(0, 12)}...\n`)
+  } else {
+    process.stderr.write(`Indelible: Save failed: ${result.error}\n`)
+  }
+
+  process.exit(0)
+}
+
+async function runPostCompactRestore() {
+  const config = loadConfig()
+  if (!config?.mcp_enabled && config?.mcp_enabled !== undefined) {
+    process.stderr.write('Indelible: MCP disabled, skipping restore\n')
+    process.exit(0)
+  }
+
+  const result = await loadContext(5)
+
+  if (result.success && result.context) {
+    // Write to stdout — Claude Code injects this into context
+    process.stdout.write(result.context)
+    process.stderr.write(`Indelible: Restored ${result.sessionCount} session(s)\n`)
+  } else if (result.error) {
+    process.stderr.write(`Indelible: Restore failed: ${result.error}\n`)
+  }
+
+  process.exit(0)
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = ''
+    const timeout = setTimeout(() => resolve(data), 1000)
+    process.stdin.on('data', chunk => { data += chunk })
+    process.stdin.on('end', () => { clearTimeout(timeout); resolve(data) })
+    process.stdin.on('error', () => { clearTimeout(timeout); resolve('') })
+  })
+}
+
+// ============ MCP SERVER MODE ============
+
+const SERVER_INFO = {
+  name: 'indelible',
+  version: '2.0.0',
+  description: 'Blockchain-backed memory for Claude Code'
+}
+
+const TOOLS = [
+  {
+    name: 'setup_wallet',
+    description: 'Import your BSV private key from indelible.one. Get your key by signing in with Google at indelible.one.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        api_url: { type: 'string', description: 'Indelible API URL (default: https://indelible.one)' },
+        import_wif: { type: 'string', description: 'Your private key (WIF) from indelible.one' },
+        pin: { type: 'string', description: 'PIN to encrypt your private key (minimum 4 characters)' }
+      },
+      required: ['import_wif', 'pin']
+    }
+  },
+  {
+    name: 'save_session',
+    description: 'Save the current Claude Code session to the blockchain. Encrypts locally, broadcasts via SPV bridge.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        transcript_path: { type: 'string', description: 'Path to the JSONL transcript file' },
+        summary: { type: 'string', description: 'Brief summary of this session' }
+      },
+      required: ['transcript_path']
+    }
+  },
+  {
+    name: 'load_context',
+    description: 'Load previous session context from the blockchain. Returns summary of past sessions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        num_sessions: { type: 'number', description: 'Number of recent sessions to load (default: 5)' }
+      },
+      required: []
+    }
+  }
+]
+
+async function handleMcpRequest(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, args?.import_wif, args?.pin)
+            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':
+        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 } }
+  }
+}
+
+async function runMcpServer() {
+  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 handleMcpRequest(request)
+      if (response) console.log(JSON.stringify(response))
+    } catch {
+      console.log(JSON.stringify({
+        jsonrpc: '2.0', id: null,
+        error: { code: -32700, message: 'Parse error' }
+      }))
+    }
+  }
+}
+
+// ============ MAIN ============
+
+const args = process.argv.slice(2)
+
+if (args[0] === 'hook') {
+  if (args[1] === 'pre-compact') {
+    runPreCompactSave().catch(e => { process.stderr.write(`Indelible error: ${e.message}\n`); process.exit(0) })
+  } else if (args[1] === 'post-compact') {
+    runPostCompactRestore().catch(e => { process.stderr.write(`Indelible error: ${e.message}\n`); process.exit(0) })
+  } else {
+    console.error('Unknown hook:', args[1])
+    process.exit(1)
+  }
+} else if (args[0] === '--help' || args[0] === '-h') {
+  printHelp()
+} else if (args[0] === '--show-config') {
+  console.log(`
+Add this to your Claude Code settings.json:
+
+{
+  "mcpServers": {
+    "indelible": {
+      "command": "indelible-mcp"
+    }
+  }
+}
+`)
+} else if (args.length > 0) {
+  runCli(args).catch(e => { console.error('Error:', e.message); process.exit(1) })
+} else if (!process.stdin.isTTY) {
+  // No args, piped stdin = MCP server mode
+  runMcpServer().catch(console.error)
+} else {
+  printHelp()
+}

package/src/lib/api-client.js

@@ -0,0 +1,102 @@
+/**
+ * API client for Indelible CLI
+ * Handles registration, session indexing, and status checks.
+ * Blockchain operations go through SPV bridge (see spv.js).
+ */
+
+import { loadConfig } from './config.js'
+
+const DEFAULT_API_URL = 'https://indelible.one'
+
+function getApiUrl() {
+  const config = loadConfig()
+  return config?.api_url || DEFAULT_API_URL
+}
+
+function getHeaders(config) {
+  const headers = { 'Content-Type': 'application/json' }
+  if (config?.api_key) {
+    headers['Authorization'] = `Bearer ${config.api_key}`
+  }
+  return headers
+}
+
+/**
+ * Register API key with server (one-time, for SPV bridge access + web app)
+ */
+export async function register(address, apiKey) {
+  const res = await fetch(`${getApiUrl()}/api/cli/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ address, api_key: apiKey }),
+    signal: AbortSignal.timeout(10000)
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
+    throw new Error(err.error || `Registration failed: ${res.status}`)
+  }
+  return res.json()
+}
+
+/**
+ * Index a session on server for web app retrieval.
+ * Called after successful broadcast — best effort, doesn't block save.
+ */
+export async function indexSession(sessionData, config) {
+  const res = await fetch(`${getApiUrl()}/api/cli/index-session`, {
+    method: 'POST',
+    headers: getHeaders(config),
+    body: JSON.stringify(sessionData),
+    signal: AbortSignal.timeout(10000)
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
+    throw new Error(err.error || `Indexing failed: ${res.status}`)
+  }
+  return res.json()
+}
+
+/**
+ * Fetch session index from server (faster than scanning blockchain)
+ */
+export async function getSessions(address, limit, config) {
+  const res = await fetch(`${getApiUrl()}/api/cli/sessions`, {
+    method: 'POST',
+    headers: getHeaders(config),
+    body: JSON.stringify({ address, limit }),
+    signal: AbortSignal.timeout(10000)
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
+    throw new Error(err.error || `Fetch sessions failed: ${res.status}`)
+  }
+  return res.json()
+}
+
+/**
+ * Get account status
+ */
+export async function getStatus(config) {
+  const res = await fetch(`${getApiUrl()}/api/cli/status`, {
+    method: 'GET',
+    headers: getHeaders(config),
+    signal: AbortSignal.timeout(10000)
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
+    throw new Error(err.error || `Status check failed: ${res.status}`)
+  }
+  return res.json()
+}
+
+/**
+ * Check if server is reachable
+ */
+export async function checkConnection() {
+  try {
+    const res = await fetch(`${getApiUrl()}/api/health`, { signal: AbortSignal.timeout(5000) })
+    return res.ok
+  } catch {
+    return false
+  }
+}