indelible-mcp 3.1.0 → 3.2.1

package/README.md

@@ -1,82 +1,158 @@
-# Indelible MCP Server
-
-Blockchain-backed memory for Claude Code. Save your AI conversations permanently on BSV.
-
-## Quick Start
-
-```bash
-npm install -g indelible-mcp
-indelible-mcp setup
-```
-
-## Setup
-
-### 1. Install & Create Wallet
-
-```bash
-npm install -g indelible-mcp
-indelible-mcp setup
-```
-
-This generates a BSV keypair locally (your private key never leaves your machine) and registers with the Indelible server.
-
-### 2. Fund Your Wallet
-
-Send a small amount of BSV to the address shown after setup. Any BSV wallet works (HandCash, RelayX, etc.).
-
-### 3. Add MCP Config to Claude Code
-
-Run `indelible-mcp --show-config` to get your config, or add this to your Claude Code `settings.json`:
-
-```json
-{
-  "mcpServers": {
-    "indelible": {
-      "command": "indelible-mcp"
-    }
-  }
-}
-```
-
-## Usage
-
-Once configured, just talk to Claude Code naturally:
-
-- **"Save this session to blockchain"** - saves your conversation
-- **"Load my previous context"** - restores past sessions
-- **"Delta save"** - saves only new messages (cheaper, faster)
-
-### Auto-Save & Auto-Restore
-
-Indelible automatically saves before Claude Code compacts your context, and restores your sessions after compaction. Nothing is lost.
-
-### CLI Commands
-
-```
-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 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
-
-## Security
-
-- **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
-
-## Learn More
-
-[indelible.one](https://indelible.one)
+# Indelible MCP Server
+
+Blockchain-backed memory for Claude Code. Save your AI conversations permanently on BSV.
+
+## Quick Start
+
+```bash
+npm install -g indelible-mcp
+indelible-mcp --show-config
+```
+
+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
+
+```bash
+npm install -g indelible-mcp
+```
+
+### 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`.
+
+**Your key never leaves your machine.**
+
+### 4. Configure Claude Code
+
+Run:
+```bash
+indelible-mcp --show-config
+```
+
+Add the output to your Claude Code settings:
+
+```json
+{
+  "mcpServers": {
+    "indelible": {
+      "command": "indelible-mcp"
+    }
+  }
+}
+```
+
+### 5. Restart Claude Code
+
+Close and reopen VS Code (or your Claude Code client).
+
+### 6. Fund Your Wallet
+
+Send a small amount of BSV (~$0.01) to your address for transaction fees.
+
+## Tools
+
+### `setup_wallet`
+Import your BSV wallet from indelible.one. Only needed once.
+
+```
+"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. Automatically includes your active AI style if one is saved.
+
+```
+"Load my previous context"
+```
+
+### `save_file`
+Save a single file to the blockchain, encrypted with your key.
+
+```
+"Save this file to the blockchain"
+```
+
+### `load_file`
+Load a file from the blockchain by transaction ID.
+
+```
+"Load file from tx abc123..."
+```
+
+### `save_project`
+Save an entire project directory to the blockchain.
+
+```
+"Save this project to the blockchain"
+```
+
+### `load_project`
+Load a project from the blockchain by transaction ID.
+
+```
+"Load project from tx abc123..."
+```
+
+### `save_style`
+Save an AI interaction style (rules/preferences) to blockchain.
+
+```
+"Save my AI style to blockchain"
+```
+
+### `load_style`
+Load an AI interaction style from blockchain. Called automatically by `load_context`.
+
+```
+"Load my AI style"
+```
+
+### `update_vault_index`
+Update the on-chain vault index with metadata for all saved files and projects.
+
+```
+"Update my vault index"
+```
+
+## 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.
+
+## Cost
+
+~1 satoshi per byte. A typical session costs less than $0.01.
+
+## Changelog
+
+### 3.2.1
+- Security fix: removed remote fallback paths
+- All operations now route exclusively through SPV bridge
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,404 @@
+#!/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'
+import { saveFile } from './tools/save_file.js'
+import { loadFile } from './tools/load_file.js'
+import { saveProject } from './tools/save_project.js'
+import { loadProject } from './tools/load_project.js'
+import { saveStyle } from './tools/save_style.js'
+import { loadStyle } from './tools/load_style.js'
+import { updateVaultIndex } from './tools/update_vault_index.js'
+import { diaryConnect } from './tools/diary_connect.js'
+import { diaryChat } from './tools/diary_chat.js'
+import { diarySave } from './tools/diary_save.js'
+
+// MCP Server metadata
+const SERVER_INFO = {
+  name: 'indelible-mcp',
+  version: '3.1.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: []
+    }
+  },
+  {
+    name: 'save_file',
+    description: 'Save a file to the BSV blockchain. Encrypts content with your wallet key and stores permanently on-chain. Supports chunking for large files.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_path: {
+          type: 'string',
+          description: 'Absolute path to the file to save'
+        },
+        relative_path: {
+          type: 'string',
+          description: 'Path relative to project root (for display/restore). Defaults to file_path.'
+        }
+      },
+      required: ['file_path']
+    }
+  },
+  {
+    name: 'load_file',
+    description: 'Load a file from the BSV blockchain by its transaction ID. Decrypts and returns the file contents, with optional write to disk.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        tx_id: {
+          type: 'string',
+          description: 'Transaction ID of the saved file (from save_file result)'
+        },
+        output_path: {
+          type: 'string',
+          description: 'Optional: write the restored file to this path on disk'
+        }
+      },
+      required: ['tx_id']
+    }
+  },
+  {
+    name: 'save_project',
+    description: 'Save an entire project directory to the BSV blockchain. Walks the directory (respecting .gitignore), encrypts all files client-side, and bundles into a single OP_RETURN transaction.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dir_path: {
+          type: 'string',
+          description: 'Absolute path to the project directory'
+        },
+        name: {
+          type: 'string',
+          description: 'Project name (default: directory name)'
+        }
+      },
+      required: ['dir_path']
+    }
+  },
+  {
+    name: 'load_project',
+    description: 'Load an entire project from the BSV blockchain by its manifest transaction ID. Downloads, decrypts, and optionally restores all files to disk.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        tx_id: {
+          type: 'string',
+          description: 'Transaction ID of the project bundle (from save_project result)'
+        },
+        output_dir: {
+          type: 'string',
+          description: 'Optional: restore all project files to this directory'
+        }
+      },
+      required: ['tx_id']
+    }
+  },
+  {
+    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: []
+    }
+  },
+  {
+    name: 'update_vault_index',
+    description: 'Update the on-chain vault index with metadata for all saved files and projects.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'diary_connect',
+    description: 'Connect Diary AI companion (Codex/ChatGPT). Stores your OpenAI API key and model preference so diary_chat can reach your AI.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        api_key: { type: 'string', description: 'OpenAI API key (sk-...)' },
+        model: { type: 'string', description: 'Model ID (default: gpt-4o). Options: gpt-5.2, gpt-5, gpt-5-nano, gpt-4o, gpt-4o-mini, o1' },
+        name: { type: 'string', description: 'Display name for the AI companion (default: Codex)' }
+      },
+      required: ['api_key']
+    }
+  },
+  {
+    name: 'diary_chat',
+    description: 'Send a message to Diary AI (Codex/ChatGPT). Returns the response formatted with a name badge. Use this when the user says "ask codex", "what does codex think", or wants the AI companion\'s input.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'The question or message to send to the AI companion' },
+        context: { type: 'string', description: 'Optional context about current work to help the AI understand the situation' },
+        system_prompt: { type: 'string', description: 'Optional system prompt override' }
+      },
+      required: ['message']
+    }
+  },
+  {
+    name: 'diary_save',
+    description: 'Save a Diary AI (Codex) exchange to the blockchain. Uses the same WIF as Claude sessions. Tagged with source so both AIs share one memory chain.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        messages: {
+          type: 'array',
+          description: 'Array of message objects: [{ role: "user"|"assistant", content: "..." }]',
+          items: {
+            type: 'object',
+            properties: {
+              role: { type: 'string' },
+              content: { type: 'string' }
+            }
+          }
+        },
+        summary: { type: 'string', description: 'Brief summary of the exchange' }
+      },
+      required: ['messages']
+    }
+  }
+]
+
+// 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
+          case 'save_file':
+            result = await saveFile(args.file_path, { relativePath: args.relative_path })
+            break
+          case 'load_file':
+            result = await loadFile(args.tx_id, { outputPath: args.output_path })
+            break
+          case 'save_project':
+            result = await saveProject(args.dir_path, { name: args.name })
+            break
+          case 'load_project':
+            result = await loadProject(args.tx_id, { outputDir: args.output_dir })
+            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
+          case 'update_vault_index':
+            result = await updateVaultIndex()
+            break
+          case 'diary_connect':
+            result = await diaryConnect({ apiKey: args?.api_key, model: args?.model, name: args?.name })
+            break
+          case 'diary_chat':
+            result = await diaryChat({ message: args?.message, context: args?.context, systemPrompt: args?.system_prompt })
+            break
+          case 'diary_save':
+            result = await diarySave({ messages: args?.messages, summary: args?.summary })
+            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)