indelible-mcp 4.1.5 → 4.2.0

package/package.json

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

@@ -31,6 +31,7 @@ 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'
+import { x402Fetch } from './tools/x402_fetch.js'
 import * as spv from './lib/spv.js'
 
 const CONTEXT_FILE = join(homedir(), '.indelible', 'indelible-context.jsonl')
@@ -269,7 +270,7 @@ Commands:
 
 function printHelp() {
   console.log(`
-Indelible MCP — Blockchain memory for Claude Code (v4.1.5)
+Indelible MCP — Blockchain memory for Claude Code (v4.2.0)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -297,6 +298,9 @@ Diary AI (Codex/ChatGPT companion):
   indelible-mcp diary chat "message"                  Ask the AI companion
   indelible-mcp diary save                            Save exchange to blockchain
 
+Payments:
+  x402_fetch (MCP only)                      Fetch URL with automatic x402 payment
+
 Hooks (auto-called by Claude Code):
   indelible-mcp hook pre-compact             Auto-save before compaction
   indelible-mcp hook post-compact            Auto-restore after compaction
@@ -481,7 +485,7 @@ function readStdin() {
 
 const SERVER_INFO = {
   name: 'indelible',
-  version: '4.1.5',
+  version: '4.2.0',
   description: 'Blockchain-backed memory and code storage for Claude Code'
 }
 
@@ -643,6 +647,21 @@ const TOOLS = [
       },
       required: ['messages']
     }
+  },
+  {
+    name: 'x402_fetch',
+    description: 'Fetch a URL with automatic x402 payment. If the endpoint returns 402, the tool pays the required sats from your Indelible wallet, then re-requests with proof. Returns content and payment details.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to fetch (the x402-protected endpoint)' },
+        method: { type: 'string', description: 'HTTP method (default: GET)' },
+        headers: { type: 'object', description: 'Extra headers to include' },
+        body: { type: 'string', description: 'Request body (for POST requests)' },
+        maxSats: { type: 'number', description: 'Maximum sats to pay per request (default: 10000, safety cap)' }
+      },
+      required: ['url']
+    }
   }
 ]
 
@@ -708,6 +727,9 @@ async function handleMcpRequest(request) {
           case 'diary_save':
             result = await diarySave({ messages: args?.messages, summary: args?.summary })
             break
+          case 'x402_fetch':
+            result = await x402Fetch({ url: args?.url, method: args?.method, headers: args?.headers, body: args?.body, maxSats: args?.maxSats })
+            break
           default:
             throw new Error(`Unknown tool: ${name}`)
         }

package/src/lib/api-client.js

@@ -1,293 +1,293 @@
-/**
- * API client for Indelible CLI
- * Handles registration, session indexing, and status checks.
- * Blockchain operations go through SPV bridge (see spv.js).
- */
-
-import { Transaction } from '@bsv/sdk'
-import { loadConfig } from './config.js'
-import * as spv from './spv.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
-}
-
-/**
- * Check tier/usage with Indelible server before saving.
- * Returns { ok, tier, usage, limit } or throws on rate limit.
- */
-export async function checkTier(apiKey) {
-  if (!apiKey) return { ok: true, tier: 'unknown', usage: 0, limit: null } // no key = legacy, allow
-  const apiUrl = getApiUrl()
-  try {
-    const res = await fetch(`${apiUrl}/api/cli/status`, {
-      headers: { 'Authorization': `Bearer ${apiKey}` },
-      signal: AbortSignal.timeout(5000)
-    })
-    if (res.status === 429) {
-      const data = await res.json().catch(() => ({}))
-      throw new Error(`Monthly save limit reached (${data.limit || 50}). Upgrade at indelible.one/pricing`)
-    }
-    if (res.ok) {
-      const data = await res.json()
-      return { ok: true, tier: data.tier, usage: data.saves_this_month, limit: data.saves_limit }
-    }
-  } catch (err) {
-    if (err.message.includes('save limit')) throw err
-    // Server unreachable — allow save (offline-first)
-  }
-  return { ok: true, tier: 'unknown', usage: 0, limit: null }
-}
-
-/**
- * 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()
-}
-
-/**
- * Commit a session to the blockchain
- * Checks tier limits first, then builds tx locally and broadcasts via SPV bridge.
- * WIF never leaves the machine — no remote fallback.
- * @param {Object} session - Session data to commit (must include address, encrypted)
- * @param {string} wif - WIF for signing/encryption
- * @returns {Promise<{success: boolean, txId?: string, error?: string}>}
- */
-export async function commitSession(session, wif) {
-  const config = loadConfig()
-  const apiKey = config?.api_key || null
-
-  // Check tier/usage before broadcasting
-  await checkTier(apiKey)
-
-  // Build tx locally and broadcast via SPV bridge
-  try {
-    const utxos = await spv.getUtxos(session.address)
-    if (utxos && utxos.length > 0) {
-      const payload = {
-        protocol: 'indelible.claude-code',
-        encrypted: session.encrypted
-      }
-      const { txHex, txId, changeUtxos } = await spv.buildOpReturnTxWithChange(wif, utxos, JSON.stringify(payload))
-      await spv.broadcastTx(txHex)
-
-      // Index session for usage tracking
-      await indexSession({
-        txId,
-        address: session.address,
-        encrypted: session.encrypted,
-        session_id: session.session_id,
-        prev_session_id: session.prev_session_id,
-        summary: session.summary,
-        message_count: session.message_count,
-        save_type: session.type || 'full',
-        timestamp: new Date().toISOString()
-      }, config)
-
-      return { success: true, txId, changeUtxos }
-    }
-  } catch (err) {
-    if (err.message.includes('save limit')) throw err
-    throw new Error('Gateway unreachable, save failed. Check your SPV bridge connection.')
-  }
-
-  throw new Error('No UTXOs available. Fund your wallet or check gateway connection.')
-}
-
-/**
- * Get latest sessions for an address
- * Scans address history via SPV bridge — no remote fallback
- * @param {string} address - BSV address
- * @param {string} wif - WIF for decryption (local only)
- * @param {number} limit - Number of sessions to fetch
- * @returns {Promise<{sessions: Array}>}
- */
-export async function getLatestSessions(address, wif, limit = 3) {
-  try {
-    const history = await spv.getAddressHistory(address)
-    if (history && history.length > 0) {
-      // Sort by height descending (most recent first), unconfirmed (height 0 or -1) first
-      history.sort((a, b) => (b.height > 0 ? b.height : Infinity) - (a.height > 0 ? a.height : Infinity))
-
-      const sessions = []
-      for (const txInfo of history) {
-        if (sessions.length >= limit) break
-        try {
-          const rawHex = await spv.getRawTx(txInfo.tx_hash)
-          const tx = Transaction.fromHex(rawHex)
-          let encrypted = null
-          for (const output of tx.outputs) {
-            if (output.satoshis === 0) {
-              const hex = output.lockingScript.toHex()
-              const str = Buffer.from(hex, 'hex').toString('utf8')
-              const match = str.match(/([A-Za-z0-9+/=]{12,}):([A-Za-z0-9+/=]{20,}):([A-Za-z0-9+/=]{20,})/)
-              if (match) { encrypted = match[0]; break }
-            }
-          }
-          if (encrypted) {
-            sessions.push({
-              txId: txInfo.tx_hash,
-              encrypted,
-              timestamp: null,
-              summary: null,
-              message_count: null
-            })
-          }
-        } catch {
-          // Skip txs we can't fetch
-        }
-      }
-
-      if (sessions.length > 0) {
-        return { sessions }
-      }
-    }
-  } catch {
-    // SPV bridge failed — no fallback, WIF never leaves the machine
-  }
-
-  return { sessions: [] }
-}
-
-/**
- * Check if user has Pro or Developer tier (required for Diary AI tools)
- * @param {string} address - User's BSV address
- * @returns {Promise<{ok: boolean, plan: string, error?: string}>}
- */
-export async function checkProTier(address) {
-  try {
-    const res = await fetch(`${getApiUrl()}/api/stripe/subscription-status-wif`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ address }),
-      signal: AbortSignal.timeout(5000)
-    })
-    if (res.ok) {
-      const data = await res.json()
-      if (data.plan === 'admin' || data.plan === 'pro' || data.plan === 'developer') {
-        return { ok: true, plan: data.plan }
-      }
-      return { ok: false, plan: data.plan || 'free', error: 'Pro tier required for Diary AI companion. Upgrade at indelible.one/pricing' }
-    }
-  } catch {
-    // Server unreachable — allow (offline-first)
-    return { ok: true, plan: 'unknown' }
-  }
-  return { ok: true, plan: 'unknown' }
-}
-
-/**
- * Auto-generate relay API key for SPV bridge access
- * Logs in with address, then calls generate-key endpoint
- * @param {string} address - BSV address
- * @param {string} apiUrl - Optional API URL override
- * @returns {Promise<{key: string, tier: string}|null>}
- */
-export async function ensureRelayKey(address, apiUrl) {
-  if (!apiUrl) apiUrl = getApiUrl()
-  try {
-    const authRes = await fetch(`${apiUrl}/api/auth/wif`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ address }),
-      signal: AbortSignal.timeout(10000)
-    })
-    if (!authRes.ok) return null
-    const { token } = await authRes.json()
-    if (!token) return null
-    const keyRes = await fetch(`${apiUrl}/api/relay/generate-key`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
-      body: JSON.stringify({}),
-      signal: AbortSignal.timeout(10000)
-    })
-    if (!keyRes.ok) return null
-    const keyData = await keyRes.json()
-    return { key: keyData.key, tier: keyData.tier }
-  } catch { return null }
-}
-
-/**
- * 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
-  }
-}
+/**
+ * API client for Indelible CLI
+ * Handles registration, session indexing, and status checks.
+ * Blockchain operations go through SPV bridge (see spv.js).
+ */
+
+import { Transaction } from '@bsv/sdk'
+import { loadConfig } from './config.js'
+import * as spv from './spv.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
+}
+
+/**
+ * Check tier/usage with Indelible server before saving.
+ * Returns { ok, tier, usage, limit } or throws on rate limit.
+ */
+export async function checkTier(apiKey) {
+  if (!apiKey) return { ok: true, tier: 'unknown', usage: 0, limit: null } // no key = legacy, allow
+  const apiUrl = getApiUrl()
+  try {
+    const res = await fetch(`${apiUrl}/api/cli/status`, {
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(5000)
+    })
+    if (res.status === 429) {
+      const data = await res.json().catch(() => ({}))
+      throw new Error(`Monthly save limit reached (${data.limit || 50}). Upgrade at indelible.one/pricing`)
+    }
+    if (res.ok) {
+      const data = await res.json()
+      return { ok: true, tier: data.tier, usage: data.saves_this_month, limit: data.saves_limit }
+    }
+  } catch (err) {
+    if (err.message.includes('save limit')) throw err
+    // Server unreachable — allow save (offline-first)
+  }
+  return { ok: true, tier: 'unknown', usage: 0, limit: null }
+}
+
+/**
+ * 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()
+}
+
+/**
+ * Commit a session to the blockchain
+ * Checks tier limits first, then builds tx locally and broadcasts via SPV bridge.
+ * WIF never leaves the machine — no remote fallback.
+ * @param {Object} session - Session data to commit (must include address, encrypted)
+ * @param {string} wif - WIF for signing/encryption
+ * @returns {Promise<{success: boolean, txId?: string, error?: string}>}
+ */
+export async function commitSession(session, wif) {
+  const config = loadConfig()
+  const apiKey = config?.api_key || null
+
+  // Check tier/usage before broadcasting
+  await checkTier(apiKey)
+
+  // Build tx locally and broadcast via SPV bridge
+  try {
+    const utxos = await spv.getUtxos(session.address)
+    if (utxos && utxos.length > 0) {
+      const payload = {
+        protocol: 'indelible.claude-code',
+        encrypted: session.encrypted
+      }
+      const { txHex, txId, changeUtxos } = await spv.buildOpReturnTxWithChange(wif, utxos, JSON.stringify(payload))
+      await spv.broadcastTx(txHex)
+
+      // Index session for usage tracking
+      await indexSession({
+        txId,
+        address: session.address,
+        encrypted: session.encrypted,
+        session_id: session.session_id,
+        prev_session_id: session.prev_session_id,
+        summary: session.summary,
+        message_count: session.message_count,
+        save_type: session.type || 'full',
+        timestamp: new Date().toISOString()
+      }, config)
+
+      return { success: true, txId, changeUtxos }
+    }
+  } catch (err) {
+    if (err.message.includes('save limit')) throw err
+    throw new Error('Gateway unreachable, save failed. Check your SPV bridge connection.')
+  }
+
+  throw new Error('No UTXOs available. Fund your wallet or check gateway connection.')
+}
+
+/**
+ * Get latest sessions for an address
+ * Scans address history via SPV bridge — no remote fallback
+ * @param {string} address - BSV address
+ * @param {string} wif - WIF for decryption (local only)
+ * @param {number} limit - Number of sessions to fetch
+ * @returns {Promise<{sessions: Array}>}
+ */
+export async function getLatestSessions(address, wif, limit = 3) {
+  try {
+    const history = await spv.getAddressHistory(address)
+    if (history && history.length > 0) {
+      // Sort by height descending (most recent first), unconfirmed (height 0 or -1) first
+      history.sort((a, b) => (b.height > 0 ? b.height : Infinity) - (a.height > 0 ? a.height : Infinity))
+
+      const sessions = []
+      for (const txInfo of history) {
+        if (sessions.length >= limit) break
+        try {
+          const rawHex = await spv.getRawTx(txInfo.tx_hash)
+          const tx = Transaction.fromHex(rawHex)
+          let encrypted = null
+          for (const output of tx.outputs) {
+            if (output.satoshis === 0) {
+              const hex = output.lockingScript.toHex()
+              const str = Buffer.from(hex, 'hex').toString('utf8')
+              const match = str.match(/([A-Za-z0-9+/=]{12,}):([A-Za-z0-9+/=]{20,}):([A-Za-z0-9+/=]{20,})/)
+              if (match) { encrypted = match[0]; break }
+            }
+          }
+          if (encrypted) {
+            sessions.push({
+              txId: txInfo.tx_hash,
+              encrypted,
+              timestamp: null,
+              summary: null,
+              message_count: null
+            })
+          }
+        } catch {
+          // Skip txs we can't fetch
+        }
+      }
+
+      if (sessions.length > 0) {
+        return { sessions }
+      }
+    }
+  } catch {
+    // SPV bridge failed — no fallback, WIF never leaves the machine
+  }
+
+  return { sessions: [] }
+}
+
+/**
+ * Check if user has Pro or Developer tier (required for Diary AI tools)
+ * @param {string} address - User's BSV address
+ * @returns {Promise<{ok: boolean, plan: string, error?: string}>}
+ */
+export async function checkProTier(address) {
+  try {
+    const res = await fetch(`${getApiUrl()}/api/stripe/subscription-status-wif`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ address }),
+      signal: AbortSignal.timeout(5000)
+    })
+    if (res.ok) {
+      const data = await res.json()
+      if (data.plan === 'admin' || data.plan === 'pro' || data.plan === 'developer') {
+        return { ok: true, plan: data.plan }
+      }
+      return { ok: false, plan: data.plan || 'free', error: 'Pro tier required for Diary AI companion. Upgrade at indelible.one/pricing' }
+    }
+  } catch {
+    // Server unreachable — allow (offline-first)
+    return { ok: true, plan: 'unknown' }
+  }
+  return { ok: true, plan: 'unknown' }
+}
+
+/**
+ * Auto-generate relay API key for SPV bridge access
+ * Logs in with address, then calls generate-key endpoint
+ * @param {string} address - BSV address
+ * @param {string} apiUrl - Optional API URL override
+ * @returns {Promise<{key: string, tier: string}|null>}
+ */
+export async function ensureRelayKey(address, apiUrl) {
+  if (!apiUrl) apiUrl = getApiUrl()
+  try {
+    const authRes = await fetch(`${apiUrl}/api/auth/wif`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ address }),
+      signal: AbortSignal.timeout(10000)
+    })
+    if (!authRes.ok) return null
+    const { token } = await authRes.json()
+    if (!token) return null
+    const keyRes = await fetch(`${apiUrl}/api/relay/generate-key`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(10000)
+    })
+    if (!keyRes.ok) return null
+    const keyData = await keyRes.json()
+    return { key: keyData.key, tier: keyData.tier }
+  } catch { return null }
+}
+
+/**
+ * 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
+  }
+}