@wipcomputer/memory-crystal 0.7.29 → 0.7.32

package/dist/cc-poller.js

@@ -1,550 +0,0 @@
-#!/usr/bin/env node
-import {
-  createCrystal,
-  resolveConfig
-} from "./chunk-FBQWSDPC.js";
-import {
-  ensureLdm,
-  ldmPaths,
-  resolveStatePath,
-  stateWritePath
-} from "./chunk-EXEZZADG.js";
-
-// src/cc-poller.ts
-import {
-  readFileSync,
-  writeFileSync,
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  statSync,
-  openSync,
-  readSync,
-  closeSync,
-  copyFileSync,
-  readdirSync
-} from "fs";
-import { join, basename } from "path";
-var HOME = process.env.HOME || "";
-var CC_AGENT_ID = process.env.CRYSTAL_AGENT_ID || "cc-mini";
-var PRIVATE_MODE_PATH = resolveStatePath("memory-capture-state.json");
-var WATERMARK_PATH = resolveStatePath("cc-capture-watermark.json");
-var CC_ENABLED_PATH = resolveStatePath("cc-capture-enabled.json");
-var CC_PROJECTS_DIR = join(HOME, ".claude", "projects");
-var SESSION_EXPORT_DIR = process.env.CRYSTAL_SESSION_EXPORT_DIR || join(ldmPaths().agentRoot, "memory", "sessions");
-var EXPORT_WATERMARK_PATH = resolveStatePath("cc-export-watermark.json");
-function isPrivateMode() {
-  try {
-    if (existsSync(PRIVATE_MODE_PATH)) {
-      const state = JSON.parse(readFileSync(PRIVATE_MODE_PATH, "utf-8"));
-      return state.enabled === false;
-    }
-  } catch {
-  }
-  return false;
-}
-function isCaptureEnabled() {
-  try {
-    if (existsSync(CC_ENABLED_PATH)) {
-      const state = JSON.parse(readFileSync(CC_ENABLED_PATH, "utf-8"));
-      return state.enabled !== false;
-    }
-  } catch {
-  }
-  return true;
-}
-function loadWatermark() {
-  try {
-    if (existsSync(WATERMARK_PATH)) {
-      return JSON.parse(readFileSync(WATERMARK_PATH, "utf-8"));
-    }
-  } catch {
-  }
-  return { files: {}, lastRun: null };
-}
-function saveWatermark(wm) {
-  const writePath = stateWritePath("cc-capture-watermark.json");
-  wm.lastRun = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync(writePath, JSON.stringify(wm, null, 2));
-}
-function extractMessages(filePath, lastByteOffset) {
-  const fileSize = statSync(filePath).size;
-  if (lastByteOffset >= fileSize) {
-    return { messages: [], newByteOffset: fileSize };
-  }
-  const fd = openSync(filePath, "r");
-  const bufSize = fileSize - lastByteOffset;
-  const buf = Buffer.alloc(bufSize);
-  readSync(fd, buf, 0, bufSize, lastByteOffset);
-  closeSync(fd);
-  const lines = buf.toString("utf-8").split("\n").filter(Boolean);
-  const messages = [];
-  for (const line of lines) {
-    try {
-      const obj = JSON.parse(line);
-      if (obj.type !== "user" && obj.type !== "assistant") continue;
-      const msg = obj.message;
-      if (!msg) continue;
-      let text = "";
-      if (typeof msg.content === "string") {
-        text = msg.content;
-      } else if (Array.isArray(msg.content)) {
-        const parts = [];
-        for (const block of msg.content) {
-          if (block.type === "text" && block.text) parts.push(block.text);
-          if (block.type === "thinking" && block.thinking) parts.push(`[thinking] ${block.thinking}`);
-        }
-        text = parts.join("\n\n");
-      }
-      if (text.length < 20) continue;
-      messages.push({
-        role: msg.role || obj.type,
-        text,
-        timestamp: obj.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        sessionId: obj.sessionId || "unknown"
-      });
-    } catch {
-    }
-  }
-  return { messages, newByteOffset: fileSize };
-}
-function discoverSessionFiles() {
-  const files = [];
-  if (!existsSync(CC_PROJECTS_DIR)) return files;
-  try {
-    for (const projectDir of readdirSync(CC_PROJECTS_DIR)) {
-      const projectPath = join(CC_PROJECTS_DIR, projectDir);
-      try {
-        if (!statSync(projectPath).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-      try {
-        for (const file of readdirSync(projectPath)) {
-          if (file.endsWith(".jsonl") && !file.startsWith(".")) {
-            files.push(join(projectPath, file));
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-  }
-  return files;
-}
-function appendDailyLog(messages, sessionFile) {
-  try {
-    const paths = ldmPaths();
-    if (!existsSync(paths.root)) return;
-    if (!existsSync(paths.daily)) mkdirSync(paths.daily, { recursive: true });
-    const now = /* @__PURE__ */ new Date();
-    const dateStr = now.toISOString().slice(0, 10);
-    const timeStr = now.toLocaleTimeString("en-US", {
-      hour: "2-digit",
-      minute: "2-digit",
-      hour12: false,
-      timeZone: "America/Los_Angeles"
-    });
-    const logPath = join(paths.daily, `${dateStr}.md`);
-    const userMsg = messages.find((m) => m.role === "user");
-    if (!userMsg) return;
-    const snippet = userMsg.text.slice(0, 120).replace(/\n/g, " ").trim();
-    const sessionId = basename(sessionFile, ".jsonl").slice(0, 8);
-    const line = `- **${timeStr}** [${sessionId}] ${snippet}${userMsg.text.length > 120 ? "..." : ""}
-`;
-    if (!existsSync(logPath)) {
-      writeFileSync(logPath, `# ${dateStr} - CC Daily Log
-
-`);
-    }
-    appendFileSync(logPath, line);
-  } catch {
-  }
-}
-function archiveTranscript(transcriptPath) {
-  try {
-    if (isPrivateMode()) return;
-    const paths = ensureLdm();
-    const dest = join(paths.transcripts, basename(transcriptPath));
-    if (existsSync(dest)) {
-      const srcMtime = statSync(transcriptPath).mtimeMs;
-      const dstMtime = statSync(dest).mtimeMs;
-      if (srcMtime <= dstMtime) return;
-    }
-    copyFileSync(transcriptPath, dest);
-  } catch {
-  }
-}
-function loadExportWatermark() {
-  try {
-    if (existsSync(EXPORT_WATERMARK_PATH)) {
-      return JSON.parse(readFileSync(EXPORT_WATERMARK_PATH, "utf-8"));
-    }
-  } catch {
-  }
-  return {};
-}
-function saveExportWatermark(data) {
-  const writePath = stateWritePath("cc-export-watermark.json");
-  writeFileSync(writePath, JSON.stringify(data, null, 2));
-}
-function formatTimestamp(ts) {
-  if (!ts) return "";
-  return new Date(ts).toLocaleString("en-US", {
-    weekday: "short",
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-    hour: "2-digit",
-    minute: "2-digit",
-    timeZoneName: "short"
-  });
-}
-function exportSessionToMarkdown(filePath) {
-  try {
-    const exportWm = loadExportWatermark();
-    const fileName = basename(filePath);
-    const currentSize = statSync(filePath).size;
-    const lastSize = exportWm[fileName] || 0;
-    if (currentSize === lastSize) return;
-    if (!existsSync(SESSION_EXPORT_DIR)) mkdirSync(SESSION_EXPORT_DIR, { recursive: true });
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.split("\n").filter((l) => l.trim());
-    const sessionId = basename(filePath, ".jsonl");
-    let firstTs = null;
-    let lastTs = null;
-    let model = "unknown";
-    const turns = [];
-    for (const line of lines) {
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (entry.type === "file-history-snapshot") continue;
-      if (entry.type === "summary") {
-        turns.push({ role: "system", content: `*[Session continued. Summary provided.]*
-
-${entry.summary || ""}`, timestamp: entry.timestamp });
-        continue;
-      }
-      const ts = entry.timestamp;
-      if (ts && !firstTs) firstTs = ts;
-      if (ts) lastTs = ts;
-      if (entry.message?.model) model = entry.message.model;
-      if (entry.type === "user") {
-        const text = extractContentText(entry.message?.content);
-        if (text && !text.startsWith("<system-reminder>")) {
-          turns.push({ role: "human", content: text, timestamp: ts });
-        }
-      } else if (entry.type === "assistant") {
-        const text = extractContentText(entry.message?.content);
-        if (text) turns.push({ role: "assistant", content: text, timestamp: ts });
-      }
-    }
-    let md = `# Claude Code Session
-
-`;
-    md += `**Session ID:** \`${sessionId}\`
-`;
-    md += `**Model:** ${model}
-`;
-    md += `**Started:** ${formatTimestamp(firstTs)}
-`;
-    md += `**Ended:** ${formatTimestamp(lastTs)}
-`;
-    md += `**Turns:** ${turns.length}
-
----
-
-`;
-    for (const t of turns) {
-      const time = t.timestamp ? `*${formatTimestamp(t.timestamp)}*` : "";
-      if (t.role === "human") {
-        md += `## Parker
-${time ? time + "\n\n" : ""}${t.content}
-
-`;
-      } else if (t.role === "assistant") {
-        md += `## Claude Code
-${time ? time + "\n\n" : ""}${t.content}
-
-`;
-      } else {
-        md += `---
-
-${t.content}
-
----
-
-`;
-      }
-    }
-    const mtime = statSync(filePath).mtime;
-    const date = mtime.toISOString().split("T")[0];
-    const shortId = sessionId.slice(0, 8);
-    const outPath = join(SESSION_EXPORT_DIR, `${date}-session-${shortId}.md`);
-    writeFileSync(outPath, md);
-    exportWm[fileName] = currentSize;
-    saveExportWatermark(exportWm);
-  } catch {
-  }
-}
-function extractContentText(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((b) => {
-      if (typeof b === "string") return b;
-      if (b.type === "text") return b.text;
-      if (b.type === "tool_use") return `\`[Tool: ${b.name}]\``;
-      return "";
-    }).filter(Boolean).join("\n\n");
-  }
-  return "";
-}
-var BATCH_SIZE = 200;
-async function ingestLocal(messages, crystal) {
-  const maxSingleChunkChars = 2e3 * 4;
-  const chunks = [];
-  for (const msg of messages) {
-    if (msg.text.length <= maxSingleChunkChars) {
-      chunks.push({
-        text: msg.text,
-        role: msg.role,
-        source_type: "conversation",
-        source_id: `cc:${msg.sessionId}`,
-        agent_id: CC_AGENT_ID,
-        token_count: Math.ceil(msg.text.length / 4),
-        created_at: msg.timestamp
-      });
-    } else {
-      for (const ct of crystal.chunkText(msg.text)) {
-        chunks.push({
-          text: ct,
-          role: msg.role,
-          source_type: "conversation",
-          source_id: `cc:${msg.sessionId}`,
-          agent_id: CC_AGENT_ID,
-          token_count: Math.ceil(ct.length / 4),
-          created_at: msg.timestamp
-        });
-      }
-    }
-  }
-  let total = 0;
-  for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
-    const batch = chunks.slice(i, i + BATCH_SIZE);
-    let retries = 0;
-    while (retries < 4) {
-      try {
-        total += await crystal.ingest(batch);
-        break;
-      } catch (err) {
-        retries++;
-        if (retries >= 4) throw err;
-        const delay = Math.min(1e3 * 2 ** retries, 3e4);
-        process.stderr.write(`  [retry ${retries}] ${err.message}, waiting ${delay}ms
-`);
-        await new Promise((r) => setTimeout(r, delay));
-      }
-    }
-  }
-  return total;
-}
-async function pollOnce() {
-  if (isPrivateMode() || !isCaptureEnabled()) {
-    return { filesScanned: 0, chunksIngested: 0, errors: [] };
-  }
-  const wm = loadWatermark();
-  const sessionFiles = discoverSessionFiles();
-  let totalChunks = 0;
-  let filesScanned = 0;
-  const errors = [];
-  let crystal = null;
-  for (const filePath of sessionFiles) {
-    filesScanned++;
-    if (!wm.files[filePath]) {
-      wm.files[filePath] = { lastByteOffset: 0, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
-    }
-    const lastOffset = wm.files[filePath].lastByteOffset;
-    const fileSize = statSync(filePath).size;
-    if (lastOffset >= fileSize) continue;
-    const { messages, newByteOffset } = extractMessages(filePath, lastOffset);
-    if (messages.length === 0) {
-      wm.files[filePath] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
-      continue;
-    }
-    const totalTokens = messages.reduce((sum, m) => sum + Math.ceil(m.text.length / 4), 0);
-    if (totalTokens < 100) {
-      wm.files[filePath] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
-      continue;
-    }
-    try {
-      if (!crystal) {
-        const config = resolveConfig();
-        crystal = createCrystal(config);
-        await crystal.init();
-      }
-      const count = await ingestLocal(messages, crystal);
-      totalChunks += count;
-      wm.files[filePath] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
-      archiveTranscript(filePath);
-      appendDailyLog(messages, filePath);
-      exportSessionToMarkdown(filePath);
-      process.stderr.write(`[cc-poller] ${count} chunks (${totalTokens} tokens) from ${basename(filePath)}
-`);
-    } catch (err) {
-      errors.push(`${basename(filePath)}: ${err.message}`);
-      process.stderr.write(`[cc-poller] error on ${basename(filePath)}: ${err.message}
-`);
-    }
-  }
-  saveWatermark(wm);
-  return { filesScanned, chunksIngested: totalChunks, errors };
-}
-function showStatus() {
-  const wm = loadWatermark();
-  const sessionFiles = discoverSessionFiles();
-  console.log("CC Poller Status");
-  console.log("================\n");
-  console.log(`Capture: ${isCaptureEnabled() ? "ON" : "OFF"}`);
-  console.log(`Private mode: ${isPrivateMode() ? "ON (blocks capture)" : "OFF"}`);
-  console.log(`Agent ID: ${CC_AGENT_ID}`);
-  console.log(`Last run: ${wm.lastRun || "never"}`);
-  console.log(`
-Session files: ${sessionFiles.length}
-`);
-  for (const filePath of sessionFiles) {
-    const fileSize = statSync(filePath).size;
-    const wmEntry = wm.files[filePath];
-    const lastOffset = wmEntry?.lastByteOffset || 0;
-    const behind = fileSize - lastOffset;
-    const mtime = statSync(filePath).mtime;
-    const age = Date.now() - mtime.getTime();
-    const ageStr = age < 6e4 ? `${Math.round(age / 1e3)}s ago` : age < 36e5 ? `${Math.round(age / 6e4)}m ago` : age < 864e5 ? `${Math.round(age / 36e5)}h ago` : `${Math.round(age / 864e5)}d ago`;
-    const status = behind === 0 ? "IN SYNC" : behind < 1024 ? `${behind}B behind` : behind < 1048576 ? `${(behind / 1024).toFixed(1)}KB behind` : `${(behind / 1048576).toFixed(1)}MB behind`;
-    const statusIcon = behind === 0 ? "OK" : behind > 1048576 ? "CRITICAL" : "BEHIND";
-    console.log(`  ${basename(filePath, ".jsonl").slice(0, 8)}  ${(fileSize / 1048576).toFixed(1)}MB  modified ${ageStr}  ${status}  ${statusIcon}`);
-  }
-}
-async function healthCheck() {
-  const wm = loadWatermark();
-  const sessionFiles = discoverSessionFiles();
-  console.log("Memory Crystal Health Check");
-  console.log("===========================\n");
-  console.log("JSONL Sessions:");
-  let activeFiles = 0;
-  let totalBehind = 0;
-  for (const filePath of sessionFiles) {
-    const fileSize = statSync(filePath).size;
-    const mtime = statSync(filePath).mtime;
-    const age = Date.now() - mtime.getTime();
-    const isActive = age < 72e5;
-    if (isActive) activeFiles++;
-    const wmEntry = wm.files[filePath];
-    const lastOffset = wmEntry?.lastByteOffset || 0;
-    const behind = fileSize - lastOffset;
-    totalBehind += behind;
-    if (isActive || behind > 0) {
-      const ageStr = age < 36e5 ? `${Math.round(age / 6e4)}m ago` : `${Math.round(age / 36e5)}h ago`;
-      const statusIcon = behind === 0 ? "OK" : behind > 1048576 ? "CRITICAL" : "WARNING";
-      console.log(`  ${basename(filePath, ".jsonl").slice(0, 8)}  ${(fileSize / 1048576).toFixed(1)}MB  last write: ${ageStr}  ${statusIcon}`);
-    }
-  }
-  console.log("\nDaily MD Logs:");
-  const paths = ldmPaths();
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const todayLog = join(paths.daily, `${today}.md`);
-  if (existsSync(todayLog)) {
-    const content = readFileSync(todayLog, "utf-8");
-    const lineCount = content.split("\n").filter((l) => l.startsWith("- ")).length;
-    console.log(`  ${today}.md exists, ${lineCount} entries  OK`);
-  } else if (activeFiles > 0) {
-    console.log(`  ${today}.md MISSING  WARNING: active sessions but no daily log`);
-  } else {
-    console.log(`  ${today}.md not created (no active sessions)  OK`);
-  }
-  console.log("\nCrystal Chunks:");
-  try {
-    const config = resolveConfig();
-    const crystal = createCrystal(config);
-    await crystal.init();
-    const status = await crystal.status();
-    console.log(`  Total chunks: ${status.chunks}`);
-    console.log(`  Total memories: ${status.memories}`);
-    if (crystal.db) {
-      const recentRow = crystal.db.prepare(
-        "SELECT COUNT(*) as cnt FROM chunks WHERE created_at > datetime('now', '-2 hours')"
-      ).get();
-      const latestRow = crystal.db.prepare(
-        "SELECT MAX(created_at) as latest FROM chunks"
-      ).get();
-      if (recentRow.cnt > 0) {
-        console.log(`  Chunks in last 2h: ${recentRow.cnt}  OK`);
-      } else if (activeFiles > 0) {
-        console.log(`  Chunks in last 2h: 0  CRITICAL: active sessions but no recent chunks`);
-      }
-      console.log(`  Latest chunk: ${latestRow.latest || "none"}`);
-    }
-  } catch (err) {
-    console.log(`  Error checking Crystal: ${err.message}  CRITICAL`);
-  }
-  console.log("\nSync Status:");
-  if (totalBehind === 0) {
-    console.log("  All sessions in sync  OK");
-  } else {
-    const behindStr = totalBehind > 1048576 ? `${(totalBehind / 1048576).toFixed(1)}MB` : `${(totalBehind / 1024).toFixed(1)}KB`;
-    console.log(`  Total data behind: ${behindStr}  ${totalBehind > 1048576 ? "CRITICAL" : "WARNING"}`);
-  }
-  console.log(`
-Last poller run: ${wm.lastRun || "never"}`);
-}
-async function watchMode() {
-  const intervalMs = parseInt(process.env.CRYSTAL_POLL_INTERVAL || "30000", 10);
-  process.stderr.write(`[cc-poller] watching every ${intervalMs / 1e3}s. Ctrl+C to stop.
-`);
-  while (true) {
-    try {
-      const result = await pollOnce();
-      if (result.chunksIngested > 0) {
-        process.stderr.write(`[cc-poller] ingested ${result.chunksIngested} chunks from ${result.filesScanned} files
-`);
-      }
-    } catch (err) {
-      process.stderr.write(`[cc-poller] poll error: ${err.message}
-`);
-    }
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-}
-var args = process.argv.slice(2);
-if (args.includes("--status")) {
-  showStatus();
-  process.exit(0);
-}
-if (args.includes("--health")) {
-  healthCheck().then(() => process.exit(0)).catch((err) => {
-    console.error(err.message);
-    process.exit(1);
-  });
-} else if (args.includes("--watch")) {
-  watchMode().catch((err) => {
-    process.stderr.write(`[cc-poller] fatal: ${err.message}
-`);
-    process.exit(1);
-  });
-} else {
-  pollOnce().then((result) => {
-    if (result.chunksIngested > 0 || result.errors.length > 0) {
-      process.stderr.write(`[cc-poller] done: ${result.chunksIngested} chunks, ${result.filesScanned} files, ${result.errors.length} errors
-`);
-    }
-    process.exit(result.errors.length > 0 ? 1 : 0);
-  }).catch((err) => {
-    process.stderr.write(`[cc-poller] fatal: ${err.message}
-`);
-    process.exit(1);
-  });
-}

package/dist/chunk-25LXQJ4Z.js

@@ -1,110 +0,0 @@
-import {
-  init_ldm,
-  resolveSecretPath
-} from "./chunk-PSQZURHO.js";
-
-// src/crypto.ts
-init_ldm();
-import { readFileSync, existsSync } from "fs";
-import { createCipheriv, createDecipheriv, createHmac, randomBytes, hkdfSync } from "crypto";
-import { createHash } from "crypto";
-var KEY_PATH = process.env.CRYSTAL_RELAY_KEY_PATH || resolveSecretPath("crystal-relay-key");
-function loadRelayKey() {
-  if (!existsSync(KEY_PATH)) {
-    throw new Error(
-      `Relay key not found at ${KEY_PATH}
-Generate one: openssl rand -base64 32 > ${KEY_PATH} && chmod 600 ${KEY_PATH}
-Copy the same key to all trusted machines.`
-    );
-  }
-  const raw = readFileSync(KEY_PATH, "utf-8").trim();
-  const key = Buffer.from(raw, "base64");
-  if (key.length !== 32) {
-    throw new Error(`Relay key must be 32 bytes (256 bits). Got ${key.length} bytes. Regenerate with: openssl rand -base64 32`);
-  }
-  return key;
-}
-function deriveSigningKey(masterKey) {
-  return Buffer.from(hkdfSync("sha256", masterKey, "", "crystal-relay-sign", 32));
-}
-function encrypt(plaintext, masterKey) {
-  const nonce = randomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", masterKey, nonce);
-  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  const signingKey = deriveSigningKey(masterKey);
-  const hmacData = Buffer.concat([nonce, ciphertext, tag]);
-  const hmac = createHmac("sha256", signingKey).update(hmacData).digest("hex");
-  return {
-    v: 1,
-    nonce: nonce.toString("base64"),
-    ciphertext: ciphertext.toString("base64"),
-    tag: tag.toString("base64"),
-    hmac
-  };
-}
-function decrypt(payload, masterKey) {
-  if (payload.v !== 1) {
-    throw new Error(`Unknown payload version: ${payload.v}`);
-  }
-  const nonce = Buffer.from(payload.nonce, "base64");
-  const ciphertext = Buffer.from(payload.ciphertext, "base64");
-  const tag = Buffer.from(payload.tag, "base64");
-  const signingKey = deriveSigningKey(masterKey);
-  const hmacData = Buffer.concat([nonce, ciphertext, tag]);
-  const expectedHmac = createHmac("sha256", signingKey).update(hmacData).digest("hex");
-  if (payload.hmac !== expectedHmac) {
-    throw new Error("HMAC verification failed \u2014 blob rejected (tampered or wrong key)");
-  }
-  const decipher = createDecipheriv("aes-256-gcm", masterKey, nonce);
-  decipher.setAuthTag(tag);
-  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-}
-function encryptJSON(data, masterKey) {
-  const plaintext = Buffer.from(JSON.stringify(data), "utf-8");
-  return encrypt(plaintext, masterKey);
-}
-function decryptJSON(payload, masterKey) {
-  const plaintext = decrypt(payload, masterKey);
-  return JSON.parse(plaintext.toString("utf-8"));
-}
-function encryptFile(filePath, masterKey) {
-  const plaintext = readFileSync(filePath);
-  return encrypt(plaintext, masterKey);
-}
-var RELAY_KEY_PATH = KEY_PATH;
-function generateRelayKey() {
-  return randomBytes(32);
-}
-function encodePairingString(key) {
-  if (key.length !== 32) throw new Error("Key must be 32 bytes");
-  return `mc1:${key.toString("base64")}`;
-}
-function decodePairingString(str) {
-  const trimmed = str.trim();
-  if (!trimmed.startsWith("mc1:")) {
-    throw new Error("Invalid pairing string (expected mc1: prefix)");
-  }
-  const key = Buffer.from(trimmed.slice(4), "base64");
-  if (key.length !== 32) {
-    throw new Error(`Invalid key length: expected 32 bytes, got ${key.length}`);
-  }
-  return key;
-}
-function hashBuffer(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-
-export {
-  loadRelayKey,
-  encrypt,
-  decrypt,
-  encryptJSON,
-  decryptJSON,
-  encryptFile,
-  RELAY_KEY_PATH,
-  generateRelayKey,
-  encodePairingString,
-  decodePairingString,
-  hashBuffer
-};