indelible-mcp 4.8.1 → 4.8.2

package/package.json

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

@@ -1590,6 +1590,14 @@ function detectSaveFormat(payload) {
   if (payload && typeof payload.wrap_owner === "string" && payload.wrap_owner.length > 0) return "v2-wrapped";
   return "legacy";
 }
+function detectVaultFormat(payload) {
+  if (!payload) return "legacy";
+  return detectSaveFormat({
+    wrap_owner: payload.wrap_owner,
+    wrap_self: payload.wrap_self,
+    wrap_version: payload.wrap_version
+  });
+}
 function generateContentKey() {
   return randomBytes3(32);
 }
@@ -5244,12 +5252,41 @@ ${formatSaveReceipt(receipt)}`
 // mcp-server/tools/load_file.js
 init_config_customer();
 init_crypto();
-init_spv();
 import { gunzipSync as gunzipSync2 } from "zlib";
 import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 import { dirname as dirname2 } from "path";
-import { Transaction as Transaction6 } from "@bsv/sdk";
+import { Transaction as Transaction6, PrivateKey as PrivateKey8, CompletedProtoWallet as CompletedProtoWallet3 } from "@bsv/sdk";
+init_spv();
+async function unwrapVaultV3(payload, wif) {
+  let w = null;
+  try {
+    w = new CompletedProtoWallet3(PrivateKey8.fromWif(wif));
+  } catch {
+    w = null;
+  }
+  if (!w) return { ok: false, code: "WALLET_UNAVAILABLE" };
+  if (payload.owner_pubkey) {
+    let idPub = null;
+    try {
+      idPub = (await w.getPublicKey({ identityKey: true }))?.publicKey || null;
+    } catch {
+    }
+    if (idPub && idPub !== payload.owner_pubkey) {
+      if (payload.wrap_recovery) {
+        const rr = await unwrapRecoveryV3(payload.wrap_recovery, w, payload.key_id, payload.owner_pubkey);
+        if (rr.ok) return { ok: true, contentKey: rr.contentKey };
+      }
+      return { ok: false, code: "WALLET_UNAVAILABLE" };
+    }
+  }
+  let r = await unwrapForSelfV3(payload.wrap_self, w, payload.key_id);
+  if (!r.ok && r.reason === "corrupt" && payload.wrap_recovery && payload.owner_pubkey) {
+    r = await unwrapRecoveryV3(payload.wrap_recovery, w, payload.key_id, payload.owner_pubkey);
+  }
+  if (!r.ok) return { ok: false, code: r.reason === "wallet_unavailable" ? "WALLET_UNAVAILABLE" : "V3_CORRUPT" };
+  return { ok: true, contentKey: r.contentKey };
+}
 async function fetchJsonPayload(txId) {
   const cleanTxId = txId.trim();
   try {
@@ -5299,6 +5336,47 @@ async function loadFile(txId, options = {}) {
   if (payload.protocol !== "indelible.file") {
     return { success: false, error: `Not an indelible.file tx (got: ${payload.protocol || "unknown"})` };
   }
+  const vfmt = detectVaultFormat(payload);
+  if (vfmt === "v3-wallet") {
+    const uv = await unwrapVaultV3(payload, wif);
+    if (!uv.ok) {
+      return { success: false, code: uv.code, error: uv.code === "WALLET_UNAVAILABLE" ? "wallet-native file: not readable from this box \u2014 its key lives in an external wallet (open it in the web app), or this WIF is not the owner" : "wallet-native file: unwrap failed (corrupt or wrong wallet)" };
+    }
+    let outBuf2;
+    try {
+      const dec = decryptWithKey(payload.encrypted, Buffer.from(uv.contentKey));
+      outBuf2 = dec.startsWith("gz:") ? gunzipSync2(Buffer.from(dec.slice(3), "base64")) : Buffer.from(dec, "utf8");
+    } catch (err) {
+      return { success: false, code: "V3_CORRUPT", error: `wallet-native decrypt failed: ${err.message}` };
+    }
+    const contentHash2 = sha256(outBuf2);
+    let meta = {};
+    try {
+      meta = JSON.parse(decryptWithKey(payload.meta_enc, Buffer.from(uv.contentKey)));
+    } catch {
+    }
+    const verified2 = meta.sha256 ? contentHash2 === meta.sha256 : payload.content_hash ? contentHash2 === payload.content_hash.replace("sha256:", "") : null;
+    if (options.outputPath) {
+      const dir = dirname2(options.outputPath);
+      if (!existsSync11(dir)) await mkdir4(dir, { recursive: true });
+      await writeFile4(options.outputPath, outBuf2);
+    }
+    const isBinary2 = payload.enc === "b64";
+    return {
+      success: true,
+      txId,
+      wallet_native: true,
+      filename: meta.filename,
+      path: meta.path,
+      size: payload.size,
+      content_hash: payload.content_hash,
+      verified: verified2,
+      content: isBinary2 ? `[binary file: ${outBuf2.length} bytes${options.outputPath ? ", written to disk" : ""}]` : outBuf2.toString("utf8")
+    };
+  }
+  if (vfmt === "v3-malformed") {
+    return { success: false, code: "V3_CORRUPT", error: "file carries malformed v3 wrap fields \u2014 failing closed" };
+  }
   let encrypted;
   if (payload._chunks) {
     let encryptedParts = "";
@@ -5363,11 +5441,12 @@ async function loadFile(txId, options = {}) {
 // mcp-server/tools/load_project.js
 init_config_customer();
 init_crypto();
-init_spv();
+import { gunzipSync as gunzipSync3 } from "zlib";
 import { mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
 import { join as join11, dirname as dirname3 } from "path";
 import { Transaction as Transaction7 } from "@bsv/sdk";
+init_spv();
 async function fetchJsonPayload2(txId) {
   const cleanTxId = txId.trim();
   try {
@@ -5420,6 +5499,61 @@ async function loadProject(txId, options = {}) {
   if (!manifest.files || !Array.isArray(manifest.files)) {
     return { success: false, error: "Manifest has no files array" };
   }
+  if (detectVaultFormat(manifest) === "v3-wallet") {
+    const uv = await unwrapVaultV3(manifest, wif);
+    if (!uv.ok) {
+      return { success: false, code: uv.code, error: uv.code === "WALLET_UNAVAILABLE" ? "wallet-native project: not readable from this box \u2014 open it in the web app with the wallet that saved it" : "wallet-native project: manifest unwrap failed (corrupt or wrong wallet)" };
+    }
+    const ck = Buffer.from(uv.contentKey);
+    const dk = (s) => decryptWithKey(s, ck);
+    let sealed = {};
+    try {
+      sealed = JSON.parse(dk(manifest.name_enc));
+    } catch {
+    }
+    const v3Files = [];
+    const v3Errors = [];
+    for (const fileRef of manifest.files) {
+      try {
+        const meta = JSON.parse(dk(fileRef.meta_enc));
+        const dec = dk(fileRef.encrypted);
+        const outBuf = dec.startsWith("gz:") ? gunzipSync3(Buffer.from(dec.slice(3), "base64")) : Buffer.from(dec, "utf8");
+        const verified = meta.sha256 ? sha256(outBuf) === meta.sha256 : null;
+        if (verified === false) {
+          v3Errors.push({ path: "(tampered)", error: "content hash mismatch vs sealed meta" });
+          continue;
+        }
+        if (options.outputDir) {
+          const outputPath = join11(options.outputDir, sealed.name || "project", meta.path);
+          const dir = dirname3(outputPath);
+          if (!existsSync12(dir)) await mkdir5(dir, { recursive: true });
+          const { writeFile: writeFile5 } = await import("fs/promises");
+          await writeFile5(outputPath, outBuf);
+        }
+        const isBinary = fileRef.enc === "b64";
+        v3Files.push({ path: meta.path, size: fileRef.size, verified, content: options.outputDir ? void 0 : isBinary ? `[binary: ${outBuf.length} bytes]` : outBuf.toString("utf8") });
+      } catch (err) {
+        v3Errors.push({ path: "(locked)", error: err.message });
+      }
+    }
+    const setOk = sealed.file_count == null || sealed.file_count === manifest.files.length;
+    return {
+      success: true,
+      txId,
+      wallet_native: true,
+      projectName: sealed.name,
+      fileCount: sealed.file_count ?? manifest.files.length,
+      set_integrity: setOk ? "ok" : "FAILED",
+      totalSize: manifest.total_size,
+      loadedFiles: v3Files.length,
+      files: v3Files,
+      errors: v3Errors.length ? v3Errors : void 0,
+      message: `Project "${sealed.name || ""}" loaded (wallet-native): ${v3Files.length}/${sealed.file_count ?? manifest.files.length} files${setOk ? "" : " \u2014 \u26A0\uFE0F SET-INTEGRITY MISMATCH"}`
+    };
+  }
+  if (detectVaultFormat(manifest) === "v3-malformed") {
+    return { success: false, code: "V3_CORRUPT", error: "project manifest carries malformed v3 wrap fields \u2014 failing closed" };
+  }
   const isBundle = manifest.protocol === "indelible.project-bundle";
   const projectName = manifest.name_enc ? decrypt(manifest.name_enc, wif) : manifest.name;
   const loadedFiles = [];
@@ -5496,20 +5630,20 @@ async function updateVaultIndex() {
   if (!_gate.ok) return { success: false, gated: true, plan: _gate.plan, upsell: _gate.upsell, error: _gate.error };
   const files = config.file_txids || [];
   const projects = config.project_txids || [];
-  const encFiles = files.map((f) => ({
+  const encFiles = files.map((f) => f.filename ? {
     txid: f.txId,
-    filename_enc: encrypt(f.filename || "", wif),
-    path_enc: encrypt(f.path || "", wif),
+    filename_enc: encrypt(f.filename, wif),
+    path_enc: encrypt(f.path || f.filename, wif),
     size: f.size || 0,
     timestamp: f.timestamp || null
-  }));
-  const encProjects = projects.map((p) => ({
+  } : { txid: f.txId, size: f.size || 0, timestamp: f.timestamp || null, wrap: "v3" });
+  const encProjects = projects.map((p) => p.name ? {
     txid: p.txId,
-    name_enc: encrypt(p.name || "", wif),
+    name_enc: encrypt(p.name, wif),
     fileCount: p.fileCount || 0,
     totalSize: p.totalSize || 0,
     timestamp: p.timestamp || null
-  }));
+  } : { txid: p.txId, fileCount: p.fileCount || 0, totalSize: p.totalSize || 0, timestamp: p.timestamp || null, wrap: "v3" });
   const payload = {
     protocol: "indelible.vault-index",
     version: 1,
@@ -6168,7 +6302,7 @@ ${context}` });
 init_config_customer();
 init_spv();
 init_utxo_cache();
-import { PrivateKey as PrivateKey8 } from "@bsv/sdk";
+import { PrivateKey as PrivateKey9 } from "@bsv/sdk";
 var DEFAULT_MAX_SATS = 1e4;
 async function x402Fetch({ url, method = "GET", headers = {}, body, maxSats }) {
   const cap = typeof maxSats === "number" && maxSats > 0 ? maxSats : DEFAULT_MAX_SATS;
@@ -6229,7 +6363,7 @@ async function x402Fetch({ url, method = "GET", headers = {}, body, maxSats }) {
       pricing
     };
   }
-  const privateKey = PrivateKey8.fromWif(wif);
+  const privateKey = PrivateKey9.fromWif(wif);
   const address = privateKey.toPublicKey().toAddress();
   let utxos;
   try {
@@ -6314,10 +6448,10 @@ init_utxo_cache();
 init_config_customer();
 init_api_client();
 import crypto from "crypto";
-import { PrivateKey as PrivateKey9 } from "@bsv/sdk";
+import { PrivateKey as PrivateKey10 } from "@bsv/sdk";
 var GOALS_PATH2 = goalsPath("");
 function deriveAddress(wif) {
-  return PrivateKey9.fromWif(wif).toAddress().toString();
+  return PrivateKey10.fromWif(wif).toAddress().toString();
 }
 function encryptGoals(goalsData, wif) {
   const key = crypto.createHash("sha256").update(wif).digest();
@@ -6584,12 +6718,12 @@ init_spv();
 init_api_client();
 import {
   Transaction as Transaction8,
-  PrivateKey as PrivateKey10,
+  PrivateKey as PrivateKey11,
   P2PKH as P2PKH3,
   SatoshisPerKilobyte as SatoshisPerKilobyte3,
   LockingScript as LockingScript3,
   OP as OP3,
-  CompletedProtoWallet as CompletedProtoWallet3,
+  CompletedProtoWallet as CompletedProtoWallet4,
   AuthFetch as AuthFetch2
 } from "@bsv/sdk";
 var SHARE_DUST_SATS = 546;
@@ -6664,14 +6798,14 @@ async function shareSession({ session_txid, recipient_addr, expires_at = null })
   if (!wif) return { success: false, error: "wallet not configured \u2014 run setup_wallet first" };
   const _gate = await requireProForWrite(config.address);
   if (!_gate.ok) return { success: false, gated: true, plan: _gate.plan, upsell: _gate.upsell, error: _gate.error };
-  const ownerPriv = PrivateKey10.fromWif(wif);
+  const ownerPriv = PrivateKey11.fromWif(wif);
   const ownerAddr = ownerPriv.toPublicKey().toAddress();
   const payload = await fetchScopePayload(session_txid);
   if (!payload) return { success: false, error: `could not fetch scope tx ${session_txid}` };
   const fmt = detectSaveFormat({ wrap_owner: payload.wrap_owner, wrap_self: payload.wrap_self, wrap_version: payload.wrap_version });
   let contentKey;
   if (fmt === "v3-wallet") {
-    const rv3 = await unwrapForSelfV3(payload.wrap_self, new CompletedProtoWallet3(ownerPriv), payload.key_id);
+    const rv3 = await unwrapForSelfV3(payload.wrap_self, new CompletedProtoWallet4(ownerPriv), payload.key_id);
     if (!rv3.ok) {
       return { success: false, error: rv3.reason === "wallet_unavailable" ? "failed to unwrap own v3 content_key: no wallet available" : `failed to unwrap own v3 content_key: ${rv3.reason} (wallet-native saves made by an external wallet can only be shared from the web app)` };
     }
@@ -6764,7 +6898,7 @@ async function indexShareOnBridge(txId, envelope, ownerPriv) {
       // the envelope stamps ISO; the bridge index demands ms-epoch (putShare validation)
       issued_at: typeof envelope.issued_at === "number" ? envelope.issued_at : Date.parse(envelope.issued_at)
     };
-    const af = new AuthFetch2(new CompletedProtoWallet3(ownerPriv));
+    const af = new AuthFetch2(new CompletedProtoWallet4(ownerPriv));
     let lastErr = null;
     for (const b of bridges.slice(0, 3)) {
       try {
@@ -7083,7 +7217,7 @@ Commands:
 }
 function printHelp() {
   console.log(`
-Indelible MCP \u2014 Blockchain memory for Claude Code (v4.8.1)
+Indelible MCP \u2014 Blockchain memory for Claude Code (v4.8.2)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -7302,7 +7436,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "4.8.1",
+  version: "4.8.2",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [