@rel-time/mcp-server 1.2.11 → 1.2.13

package/README.md

@@ -40,7 +40,8 @@ Once paid via Lightning or Stripe (or if you pass an existing `rel_key_...` key)
 
 | Tool Name | Requires Key? | What It Does |
 | :--- | :---: | :--- |
-| `reltime_anchor_file` | Yes | Computes the SHA-256 hash of a local file **on your machine** (0 bytes uploaded), supports `biometric: true` for **Biometric Anchors** (TouchID/FaceID/YubiKey), anchors via `POST /v1/anchor`, saves `reltime-stamp-<filename>.svg` and `reltime-doomsday-proof-<filename>.json`, and automatically outputs a clickable **Stamped Copy** (`reltime-stamped-<name>.pdf` or `.png`). |
+| `reltime_anchor_file` | Yes | Computes the SHA-256 hash of a local file **on your machine** (0 bytes uploaded), supports `biometric: true` for **Biometric Anchors** (TouchID/FaceID/YubiKey), anchors via `POST /v1/anchor`, saves `reltime-stamp-<filename>.svg`, `reltime-certificate-<filename>.html`, and `reltime-doomsday-proof-<filename>.json`, and automatically outputs a clickable **Stamped Copy** (`reltime-stamped-<name>.pdf` or `.png`). |
+| `reltime_anchor_folder` | Yes | **Bulk folder anchoring (10 to 5,000+ files in one call):** Hashes all files in a local folder 100% locally, supports `biometric: true` (Passkey) or Anonymous mode, automatically skips already-anchored files (safe to resume), and keeps your directory clean by storing per-file Doomsday Proofs inside `<folder>/_reltime_proofs/` plus a master `reltime-batch-manifest.json`. |
 | `reltime_audit_trail` | Yes | Fetches the account's chronological anchor ledger (`GET /v1/account/history`), aggregates Bitcoin block settlements, VDF `T_index` ticks, and Corporate Hardware Passkey (`signer_public_key`) signatures, optionally verifies a local file or entire folder bit-for-bit (`verify_local_path`), and spins up a self-contained interactive HTML Audit Report (`reltime-audit-report-*.html`) in your browser. |
 | `reltime_link_passkey` | **No** | Opens `https://rel-time.com/mcp-passkey` in the system browser so the user can touch TouchID / FaceID / YubiKey once, saving `{ public_key_hex, passkey_signature }` to `~/.reltime/passkey.json` for seamless Biometric Anchors. |
 | `reltime_stamp_file` | **No** | Overlays the authentic 64-ray Sun-Stamp onto the bottom-right corner of any local PDF or Image (`.png`, `.jpg`, `.jpeg`, `.webp`, `.gif`) 100% locally. |

package/index.js

@@ -56,7 +56,7 @@ let LAST_INVOICE_PACK = null;
 
 const SERVER_INFO = {
   name: "rel-time-mcp-server",
-  version: "1.2.11",
+  version: "1.2.13",
 };
 
 /**
@@ -341,6 +341,30 @@ function injectPngVerifyBuffer(pngBuffer, verifyUrl) {
   ]);
 }
 
+/**
+ * Builds an OS-safe filename (<= 240 UTF-8 bytes) so macOS/Linux 255-byte limits
+ * (`ENAMETOOLONG`) never fail on long AI-prompt filenames.
+ */
+function safeArtifactFilename(prefix, rawName, ext, hashHex = "") {
+  const candidate = `${prefix}${rawName}${ext}`;
+  if (Buffer.byteLength(candidate, "utf8") <= 240) {
+    return candidate;
+  }
+  const suffixTag = hashHex
+    ? `~${String(hashHex).slice(0, 8)}`
+    : `~${crypto.createHash("sha256").update(String(rawName), "utf8").digest("hex").slice(0, 8)}`;
+  const maxBodyBytes = Math.max(32, 240 - Buffer.byteLength(prefix, "utf8") - Buffer.byteLength(suffixTag, "utf8") - Buffer.byteLength(ext, "utf8"));
+  let trimmed = "";
+  let usedBytes = 0;
+  for (const ch of String(rawName)) {
+    const chBytes = Buffer.byteLength(ch, "utf8");
+    if (usedBytes + chBytes > maxBodyBytes) break;
+    trimmed += ch;
+    usedBytes += chBytes;
+  }
+  return `${prefix}${trimmed.trim()}${suffixTag}${ext}`;
+}
+
 /**
  * Stamps the Option 1A (+14° Bitcoin Tilt, pure crisp 64-ray Sun-Stamp, 0% glare, no pill) onto a local Image or PDF.
  * Returns { stamped: true, output_path, format } or { stamped: false, reason }.
@@ -375,7 +399,9 @@ async function stampLocalFileOptionA(filePath, svgContent, customOutputPath = nu
     .replace(/<\/a>/gi, "");
 
   if (isImage) {
-    const outPath = customOutputPath ? path.resolve(customOutputPath) : path.join(dir, `reltime-stamped-${baseName}.png`);
+    const outPath = customOutputPath
+      ? path.resolve(customOutputPath)
+      : path.join(dir, safeArtifactFilename("reltime-stamped-", baseName, ".png", verifyHash));
     const img = sharp(filePath);
     const meta = await img.metadata();
     const w = (meta.autoOrient && meta.autoOrient.width) || meta.width || 1200;
@@ -410,7 +436,9 @@ async function stampLocalFileOptionA(filePath, svgContent, customOutputPath = nu
   }
 
   if (isPdf) {
-    const outPath = customOutputPath ? path.resolve(customOutputPath) : path.join(dir, `reltime-stamped-${baseName}.pdf`);
+    const outPath = customOutputPath
+      ? path.resolve(customOutputPath)
+      : path.join(dir, safeArtifactFilename("reltime-stamped-", baseName, ".pdf", verifyHash));
     const pdfBytes = fs.readFileSync(filePath);
     const pdfDoc = await PDFDocument.load(pdfBytes, { ignoreEncryption: true });
     const pages = pdfDoc.getPages();
@@ -1527,6 +1555,18 @@ function generateAuditReportHtml(audit) {
 </html>`;
 }
 
+function formatBytes(bytes) {
+  if (bytes === undefined || bytes === null || Number.isNaN(Number(bytes))) {
+    return "Zero-Knowledge (32-Byte Digest)";
+  }
+  const b = Number(bytes);
+  if (b === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.min(sizes.length - 1, Math.floor(Math.log(b) / Math.log(k)));
+  return `${parseFloat((b / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
 function inferMimeTypeFromFileName(fileName) {
   if (!fileName || fileName === "Zero-Knowledge Hash Payload") {
     return "application/octet-stream (Zero-Knowledge)";
@@ -2111,6 +2151,49 @@ const TOOLS = [
       required: ["file_path"],
     },
   },
+  {
+    name: "reltime_anchor_folder",
+    description:
+      "Bulk zero-knowledge folder anchoring (10 to 5,000+ files in a single call): Hashes all files in a local folder 100% locally (0 file bytes uploaded), supports Biometric (Passkey) or Anonymous anchoring, skips any files that are already anchored (safe to resume), and keeps the user's folder clean by storing per-file Doomsday Proofs inside a single `_reltime_proofs/` subfolder plus a master `reltime-batch-manifest.json`.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        folder_path: {
+          type: "string",
+          description: "Absolute path to the local directory to hash and anchor.",
+        },
+        recursive: {
+          type: "boolean",
+          description: "If true, recursively anchors files in subdirectories. Defaults to false (top-level files only).",
+        },
+        biometric: {
+          type: "boolean",
+          description:
+            "If true, performs Biometric Anchors using your linked hardware Passkey (`~/.reltime/passkey.json`) across the entire folder without repeated TouchID prompts.",
+        },
+        anchor_mode: {
+          type: "string",
+          enum: ["standard", "temporal"],
+          description: "Use 'standard' (default) or 'temporal' (VDF T_index sequential ordering for Superhighway & Autonomous Agents).",
+        },
+        artifact_mode: {
+          type: "string",
+          enum: ["proofs_subfolder", "manifest_only", "full"],
+          description:
+            "Controls local output files so bulk runs never clutter the folder: 'proofs_subfolder' (default) writes JSON proofs into `<folder>/_reltime_proofs/` + `reltime-batch-manifest.json`; 'manifest_only' writes only `reltime-batch-manifest.json`; 'full' also writes SVG Sun-Stamps and HTML certificates.",
+        },
+        concurrency: {
+          type: "number",
+          description: "Number of concurrent anchor requests (default: 5, max: 10).",
+        },
+        api_key: {
+          type: "string",
+          description: "Optional override for RELTIME_API_KEY.",
+        },
+      },
+      required: ["folder_path"],
+    },
+  },
   {
     name: "reltime_link_passkey",
     description:
@@ -2450,18 +2533,36 @@ async function executeTool(name, args = {}) {
     const verifyUrl = `https://rel-time.com/verify?t=${lookupHash}`;
     const stampEndpointUrl = `${API_BASE}/stamp/${lookupHash}`;
 
-    const svgContent = data.visual_fingerprint || (await (await fetch(stampEndpointUrl)).text());
+    let svgContent = data.visual_fingerprint || "";
+    const needsSvg = args.save_sun_stamp_svg !== false || args.save_stamped_copy !== false;
+    if (!svgContent && needsSvg) {
+      try {
+        const stampRes = await fetch(stampEndpointUrl);
+        if (stampRes.ok) {
+          svgContent = await stampRes.text();
+        }
+      } catch (e) {
+        // Ignore SVG fetch error if offline/rate-limited
+      }
+    }
 
     let savedSvgPath = null;
-    if (args.save_sun_stamp_svg !== false) {
-      savedSvgPath = path.join(path.dirname(filePath), `reltime-stamp-${path.basename(filePath)}.svg`);
-      fs.writeFileSync(savedSvgPath, svgContent, "utf8");
+    if (args.save_sun_stamp_svg !== false && svgContent) {
+      try {
+        savedSvgPath = path.join(
+          path.dirname(filePath),
+          safeArtifactFilename("reltime-stamp-", path.basename(filePath), ".svg", clientHash)
+        );
+        fs.writeFileSync(savedSvgPath, svgContent, "utf8");
+      } catch (e) {
+        savedSvgPath = null;
+      }
     }
 
     // Save initial Doomsday Proof JSON alongside the file
     const savedProofJsonPath = path.join(
       path.dirname(filePath),
-      `reltime-doomsday-proof-${path.basename(filePath)}.json`
+      safeArtifactFilename("reltime-doomsday-proof-", path.basename(filePath), ".json", clientHash)
     );
     fs.writeFileSync(
       savedProofJsonPath,
@@ -2489,40 +2590,48 @@ async function executeTool(name, args = {}) {
 
     // 3. Automatically generate Stamped Copy (.PDF or .PNG) for PDFs and Images
     let stampedCopyResult = null;
-    if (args.save_stamped_copy !== false) {
-      stampedCopyResult = await stampLocalFileOptionA(filePath, svgContent, null, clientHash);
+    if (args.save_stamped_copy !== false && svgContent) {
+      try {
+        stampedCopyResult = await stampLocalFileOptionA(filePath, svgContent, null, clientHash);
+      } catch (e) {
+        stampedCopyResult = { status: "skipped", error: e.message };
+      }
     }
 
     // 4. Generate 4-Plate Sovereign Cryptographic Provenance Certificate HTML
     let savedCertificateHtmlPath = null;
     if (args.save_certificate_html !== false) {
-      const certHtml = generateProvenanceCertificateHtml({
-        fileName: path.basename(filePath),
-        fileSize: formatBytes(fileBuffer.length),
-        mimeType: inferMimeTypeFromFileName(path.basename(filePath)),
-        originalFileHash,
-        attestedHash: clientHash,
-        signerPublicKey: passkeyCreds ? passkeyCreds.public_key_hex : null,
-        anchorMode: data.anchor_mode || anchorMode,
-        tIndex,
-        vdfTicks: data.vdf_ticks || data.solar_ticks || 0,
-        status: data.status || "pending_finality",
-        blockHeight: data.settlement?.bitcoin_block_height || null,
-        blockTimeUtc: data.settlement?.bitcoin_block_time
-          ? new Date(data.settlement.bitcoin_block_time * 1000).toISOString().replace("T", " ").slice(0, 19) + " UTC"
-          : null,
-        merkleProofCount: Array.isArray(data.settlement?.merkle_proof_path)
-          ? data.settlement.merkle_proof_path.length
-          : null,
-        txid: data.settlement?.bitcoin_txid || null,
-      });
-      savedCertificateHtmlPath = path.join(
-        path.dirname(filePath),
-        `reltime-certificate-${path.basename(filePath)}.html`
-      );
-      fs.writeFileSync(savedCertificateHtmlPath, certHtml, "utf8");
-      if (args.open_certificate_in_browser) {
-        openSystemBrowser(savedCertificateHtmlPath);
+      try {
+        const certHtml = generateProvenanceCertificateHtml({
+          fileName: path.basename(filePath),
+          fileSize: formatBytes(fileBuffer.length),
+          mimeType: inferMimeTypeFromFileName(path.basename(filePath)),
+          originalFileHash,
+          attestedHash: clientHash,
+          signerPublicKey: passkeyCreds ? passkeyCreds.public_key_hex : null,
+          anchorMode: data.anchor_mode || anchorMode,
+          tIndex,
+          vdfTicks: data.vdf_ticks || data.solar_ticks || 0,
+          status: data.status || "pending_finality",
+          blockHeight: data.settlement?.bitcoin_block_height || null,
+          blockTimeUtc: data.settlement?.bitcoin_block_time
+            ? new Date(data.settlement.bitcoin_block_time * 1000).toISOString().replace("T", " ").slice(0, 19) + " UTC"
+            : null,
+          merkleProofCount: Array.isArray(data.settlement?.merkle_proof_path)
+            ? data.settlement.merkle_proof_path.length
+            : null,
+          txid: data.settlement?.bitcoin_txid || null,
+        });
+        savedCertificateHtmlPath = path.join(
+          path.dirname(filePath),
+          safeArtifactFilename("reltime-certificate-", path.basename(filePath), ".html", clientHash)
+        );
+        fs.writeFileSync(savedCertificateHtmlPath, certHtml, "utf8");
+        if (args.open_certificate_in_browser) {
+          openSystemBrowser(savedCertificateHtmlPath);
+        }
+      } catch (e) {
+        savedCertificateHtmlPath = null;
       }
     }
 
@@ -2548,6 +2657,214 @@ async function executeTool(name, args = {}) {
     };
   }
 
+  if (name === "reltime_anchor_folder") {
+    if (!key) {
+      return buildPackSelectionPrompt(
+        "Before anchoring a folder of files, a Rel-Time API key is required. Ask the user which pack they want to provision first:"
+      );
+    }
+    const folderPath = resolveLocalFilePath(args.folder_path);
+    if (!fs.existsSync(folderPath) || !fs.statSync(folderPath).isDirectory()) {
+      throw new Error(`Directory not found at path: ${folderPath}`);
+    }
+
+    const recursive = Boolean(args.recursive);
+    const anchorMode = args.anchor_mode || "standard";
+    const artifactMode = args.artifact_mode || "proofs_subfolder";
+    const concurrency = Math.max(1, Math.min(10, Number(args.concurrency) || 5));
+
+    let passkeyCreds = null;
+    if (args.biometric) {
+      passkeyCreds = loadSavedPasskey();
+      if (!passkeyCreds) {
+        passkeyCreds = await launchBrowserPasskeyBridge();
+      }
+    }
+
+    const isReltimeGeneratedFile = (fname) => {
+      const lower = fname.toLowerCase();
+      return (
+        fname.startsWith(".") ||
+        lower.startsWith("reltime-stamp-") ||
+        lower.startsWith("reltime-doomsday-proof-") ||
+        lower.startsWith("reltime-certificate-") ||
+        lower.startsWith("reltime-stamped-") ||
+        lower.startsWith("reltime-audit-report-") ||
+        lower === "reltime-batch-manifest.json"
+      );
+    };
+
+    const targetFiles = [];
+    const walkDir = (dir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "_reltime_proofs" || entry.name === "node_modules") {
+          continue;
+        }
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (recursive) walkDir(fullPath);
+        } else if (entry.isFile() && !isReltimeGeneratedFile(entry.name)) {
+          targetFiles.push(fullPath);
+        }
+      }
+    };
+    walkDir(folderPath);
+
+    const proofsDir = path.join(folderPath, "_reltime_proofs");
+    if (artifactMode === "proofs_subfolder" && !fs.existsSync(proofsDir)) {
+      fs.mkdirSync(proofsDir, { recursive: true });
+    }
+
+    const manifestPath = path.join(folderPath, "reltime-batch-manifest.json");
+    let existingManifest = { anchored_files: {} };
+    if (fs.existsSync(manifestPath)) {
+      try {
+        existingManifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) || { anchored_files: {} };
+        if (!existingManifest.anchored_files) existingManifest.anchored_files = {};
+      } catch (e) {
+        existingManifest = { anchored_files: {} };
+      }
+    }
+
+    const results = [];
+    const skipped = [];
+    const errors = [];
+    let outOfCredits = false;
+
+    const toProcess = [];
+    for (const fPath of targetFiles) {
+      const relPath = path.relative(folderPath, fPath);
+      const baseName = path.basename(fPath);
+      const sidecarProof = path.join(
+        path.dirname(fPath),
+        safeArtifactFilename("reltime-doomsday-proof-", baseName, ".json")
+      );
+      const legacySidecarProof = path.join(path.dirname(fPath), `reltime-doomsday-proof-${baseName}.json`);
+      const subfolderProof = path.join(
+        proofsDir,
+        safeArtifactFilename("reltime-doomsday-proof-", relPath.replace(/[\\/]/g, "__"), ".json")
+      );
+      if (
+        existingManifest.anchored_files[relPath] ||
+        fs.existsSync(sidecarProof) ||
+        (Buffer.byteLength(`reltime-doomsday-proof-${baseName}.json`, "utf8") <= 255 && fs.existsSync(legacySidecarProof)) ||
+        fs.existsSync(subfolderProof)
+      ) {
+        skipped.push(relPath);
+      } else {
+        toProcess.push({ fPath, relPath, baseName, subfolderProof, sidecarProof });
+      }
+    }
+
+    let cursor = 0;
+    const worker = async () => {
+      while (cursor < toProcess.length && !outOfCredits) {
+        const idx = cursor++;
+        const item = toProcess[idx];
+        if (!item) break;
+        try {
+          const buf = fs.readFileSync(item.fPath);
+          const originalFileHash = crypto.createHash("sha256").update(buf).digest("hex");
+          const clientHash =
+            args.biometric && passkeyCreds
+              ? crypto.createHash("sha256").update(`${originalFileHash}${passkeyCreds.public_key_hex}`, "utf8").digest("hex")
+              : originalFileHash;
+
+          const reqBody = {
+            client_hash: clientHash,
+            anchor_mode: anchorMode,
+          };
+          if (args.biometric && passkeyCreds) {
+            reqBody.original_file_hash = originalFileHash;
+            reqBody.passkey_signature = passkeyCreds.passkey_signature;
+          }
+
+          const res = await fetch(`${API_BASE}/anchor`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify(reqBody),
+          });
+
+          if (res.status === 402) {
+            outOfCredits = true;
+            errors.push({ file: item.relPath, error: "Insufficient Hash Credits (HTTP 402)" });
+            break;
+          }
+
+          const data = await res.json();
+          if (!res.ok) {
+            errors.push({ file: item.relPath, error: `HTTP ${res.status}: ${JSON.stringify(data)}` });
+            continue;
+          }
+
+          const tIndex = data.t_index || data.thermodynamic_proof;
+          const lookupHash = (data.anchor_mode || anchorMode) === "temporal" ? tIndex : clientHash;
+          const verifyUrl = `https://rel-time.com/verify?t=${lookupHash}`;
+          const proofRecord = {
+            protocol: "Rel-Time Sovereign Provenance Protocol",
+            file_name: item.baseName,
+            relative_path: item.relPath,
+            identity_mode: args.biometric ? "BIOMETRIC_PASSKEY" : "ANONYMOUS",
+            original_file_sha256_hash: originalFileHash,
+            anchored_client_hash: clientHash,
+            signer_public_key: passkeyCreds ? passkeyCreds.public_key_hex : null,
+            t_index: tIndex,
+            vdf_ticks: data.vdf_ticks || data.solar_ticks,
+            anchor_mode: data.anchor_mode || anchorMode,
+            status: data.status || "pending_finality",
+            verify_url: verifyUrl,
+          };
+
+          if (artifactMode === "proofs_subfolder") {
+            fs.writeFileSync(item.subfolderProof, JSON.stringify(proofRecord, null, 2), "utf8");
+          } else if (artifactMode === "full") {
+            fs.writeFileSync(item.sidecarProof, JSON.stringify(proofRecord, null, 2), "utf8");
+          }
+
+          existingManifest.anchored_files[item.relPath] = proofRecord;
+          results.push(proofRecord);
+        } catch (err) {
+          errors.push({ file: item.relPath, error: err.message });
+        }
+      }
+    };
+
+    const workers = Array.from({ length: Math.min(concurrency, Math.max(1, toProcess.length)) }, () => worker());
+    await Promise.all(workers);
+
+    const manifestPayload = {
+      protocol: "Rel-Time Sovereign Provenance Protocol — Batch Folder Manifest",
+      folder_path: folderPath,
+      updated_at: new Date().toISOString(),
+      identity_mode: args.biometric ? "BIOMETRIC_PASSKEY" : "ANONYMOUS",
+      signer_public_key: passkeyCreds ? passkeyCreds.public_key_hex : null,
+      total_anchored_in_manifest: Object.keys(existingManifest.anchored_files).length,
+      anchored_files: existingManifest.anchored_files,
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifestPayload, null, 2), "utf8");
+
+    return {
+      status: outOfCredits ? "stopped_insufficient_credits" : "completed",
+      folder_path: folderPath,
+      total_files_found: targetFiles.length,
+      newly_anchored_count: results.length,
+      skipped_already_anchored_count: skipped.length,
+      error_count: errors.length,
+      identity_mode: args.biometric ? "BIOMETRIC_PASSKEY" : "ANONYMOUS",
+      signer_public_key: passkeyCreds ? passkeyCreds.public_key_hex : null,
+      artifact_mode: artifactMode,
+      manifest_path: manifestPath,
+      proofs_subfolder: artifactMode === "proofs_subfolder" ? proofsDir : null,
+      errors: errors.slice(0, 20),
+      next_step:
+        "You can now run `reltime_audit_trail` with `verify_local_path` set to this folder to generate the full interactive HTML Cryptographic Audit Report.",
+    };
+  }
+
   if (name === "reltime_stamp_file") {
     const filePath = resolveLocalFilePath(args.file_path);
     if (!fs.existsSync(filePath)) {
@@ -2813,7 +3130,7 @@ async function executeTool(name, args = {}) {
       };
     }
 
-    const maxEntries = Math.min(500, Math.max(1, Number(args.limit) || 100));
+    const maxEntries = Math.min(5000, Math.max(1, Number(args.limit) || 2000));
     const pageSize = Math.min(100, maxEntries);
     const pagesToFetch = Math.ceil(maxEntries / pageSize);
     let rawHistory = [];
@@ -2957,9 +3274,14 @@ async function executeTool(name, args = {}) {
           if (item.startsWith(".")) continue;
           if (
             item.startsWith("reltime-stamp-") ||
+            item.startsWith("reltime-stamped-") ||
             item.startsWith("reltime-doomsday-proof-") ||
             item.startsWith("reltime-proof-") ||
-            item.startsWith("reltime-audit-report-")
+            item.startsWith("reltime-certificate-") ||
+            item.startsWith("reltime-audit-report-") ||
+            item.startsWith("reltime-audit-trail-") ||
+            item === "reltime-batch-manifest.json" ||
+            item === "_reltime_proofs"
           ) {
             continue;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rel-time/mcp-server",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "mcpName": "io.github.relsun369-dev/rel-time",
   "description": "Official Model Context Protocol (MCP) server for Rel-Time (rel-time.com) — Zero-Knowledge Bitcoin & VDF Provenance, Local File Hashing, and Sun-Stamp Generation for Claude, Cursor, Windsurf, and Antigravity.",
   "main": "index.js",

package/server.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-10-17/server.schema.json",
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.relsun369-dev/rel-time",
   "title": "Rel-Time Protocol (Bitcoin & VDF Provenance)",
   "description": "Zero-knowledge Bitcoin Mainnet & VDF timestamping, Passkey signing, Sun-Stamps, and tamper audits.",
@@ -8,13 +8,13 @@
     "url": "https://github.com/relsun369-dev/reltime-mcp",
     "source": "github"
   },
-  "version": "1.2.11",
+  "version": "1.2.13",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@rel-time/mcp-server",
-      "version": "1.2.11",
+      "version": "1.2.13",
       "transport": {
         "type": "stdio"
       }