@wipcomputer/memory-crystal 0.7.32 → 0.7.34-alpha.1

package/dist/chunk-3G3SFYYI.js

@@ -0,0 +1,288 @@
+import {
+  decrypt,
+  decryptJSON,
+  encrypt,
+  encryptJSON,
+  loadRelayKey
+} from "./chunk-KCQUXVYT.js";
+import {
+  ldmPaths,
+  resolveStatePath,
+  stateWritePath
+} from "./chunk-EXEZZADG.js";
+
+// src/file-sync.ts
+import { createHash } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  readdirSync,
+  statSync
+} from "fs";
+import { join, relative, dirname } from "path";
+var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
+var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
+var EXCLUDE_PATTERNS = [
+  "memory/crystal.db",
+  // DB syncs via delta chunks, not file copy
+  "memory/crystal.db-wal",
+  "memory/crystal.db-shm",
+  "memory/crystal.db.bak",
+  "memory/crystal.db.tmp",
+  "memory/lance/",
+  // LanceDB (deprecated, not synced)
+  "state/",
+  // Local state files (watermarks, etc.)
+  "secrets/",
+  // Encryption keys, tokens
+  "staging/",
+  // Staging pipeline (Core-only)
+  "bin/",
+  // Local scripts
+  ".DS_Store"
+];
+function shouldExclude(relativePath) {
+  for (const pattern of EXCLUDE_PATTERNS) {
+    if (relativePath === pattern || relativePath.startsWith(pattern)) return true;
+  }
+  const parts = relativePath.split("/");
+  for (const part of parts) {
+    if (part.startsWith(".") && part !== ".ldm") return true;
+  }
+  return false;
+}
+function scanDir(baseDir, currentDir, entries) {
+  if (!existsSync(currentDir)) return;
+  const items = readdirSync(currentDir);
+  for (const item of items) {
+    const fullPath = join(currentDir, item);
+    const relPath = relative(baseDir, fullPath);
+    if (shouldExclude(relPath)) continue;
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      scanDir(baseDir, fullPath, entries);
+    } else if (stat.isFile()) {
+      if (stat.size > 50 * 1024 * 1024) continue;
+      const content = readFileSync(fullPath);
+      const sha256 = createHash("sha256").update(content).digest("hex");
+      entries.push({ path: relPath, sha256, size: stat.size });
+    }
+  }
+}
+function generateManifest() {
+  const paths = ldmPaths();
+  const entries = [];
+  scanDir(paths.root, paths.root, entries);
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fileCount: entries.length,
+    entries
+  };
+}
+function compareManifest(coreManifest) {
+  const paths = ldmPaths();
+  const upsert = [];
+  const toDelete = [];
+  const localManifest = generateManifest();
+  const localMap = new Map(localManifest.entries.map((e) => [e.path, e]));
+  const coreMap = new Map(coreManifest.entries.map((e) => [e.path, e]));
+  for (const entry of coreManifest.entries) {
+    const local = localMap.get(entry.path);
+    if (!local || local.sha256 !== entry.sha256) {
+      upsert.push({ path: entry.path, sha256: entry.sha256 });
+    }
+  }
+  for (const entry of localManifest.entries) {
+    if (!coreMap.has(entry.path)) {
+      toDelete.push(entry.path);
+    }
+  }
+  return { upsert, delete: toDelete };
+}
+function loadFileSyncState() {
+  const statePath = resolveStatePath("file-sync-state.json");
+  try {
+    if (existsSync(statePath)) {
+      return JSON.parse(readFileSync(statePath, "utf-8"));
+    }
+  } catch {
+  }
+  return { lastSync: null, lastManifestHash: null, filesTransferred: 0, filesDeleted: 0 };
+}
+function saveFileSyncState(state) {
+  const writePath = stateWritePath("file-sync-state.json");
+  writeFileSync(writePath, JSON.stringify(state, null, 2));
+}
+async function pushFileSync() {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const paths = ldmPaths();
+  const manifest = generateManifest();
+  const manifestJson = JSON.stringify(manifest.entries.map((e) => `${e.path}:${e.sha256}`));
+  const manifestHash = createHash("sha256").update(manifestJson).digest("hex");
+  const state = loadFileSyncState();
+  if (state.lastManifestHash === manifestHash) {
+    return { manifest: 0, files: 0 };
+  }
+  const encryptedManifest = encryptJSON(manifest, relayKey);
+  const manifestResp = await fetch(`${RELAY_URL}/drop/files`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${RELAY_TOKEN}`,
+      "Content-Type": "application/octet-stream",
+      "X-File-Type": "manifest"
+    },
+    body: JSON.stringify(encryptedManifest)
+  });
+  if (!manifestResp.ok) {
+    throw new Error(`Manifest push failed: ${manifestResp.status} ${await manifestResp.text()}`);
+  }
+  let filesPushed = 0;
+  for (const entry of manifest.entries) {
+    const fullPath = join(paths.root, entry.path);
+    if (!existsSync(fullPath)) continue;
+    const content = readFileSync(fullPath);
+    const encrypted = encrypt(content, relayKey);
+    const filePayload = JSON.stringify({
+      path: entry.path,
+      sha256: entry.sha256,
+      size: entry.size,
+      data: encrypted
+    });
+    const fileResp = await fetch(`${RELAY_URL}/drop/files`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${RELAY_TOKEN}`,
+        "Content-Type": "application/octet-stream",
+        "X-File-Type": "file"
+      },
+      body: filePayload
+    });
+    if (fileResp.ok) filesPushed++;
+  }
+  state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  state.lastManifestHash = manifestHash;
+  state.filesTransferred += filesPushed;
+  saveFileSyncState(state);
+  return { manifest: manifest.fileCount, files: filesPushed };
+}
+async function pullFileSync() {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const paths = ldmPaths();
+  const listResp = await fetch(`${RELAY_URL}/pickup/files`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!listResp.ok) {
+    throw new Error(`File sync list failed: ${listResp.status} ${await listResp.text()}`);
+  }
+  const listData = await listResp.json();
+  if (listData.count === 0) {
+    return { imported: 0, deleted: 0 };
+  }
+  let coreManifest = null;
+  const fileBlobs = [];
+  for (const blob of listData.blobs) {
+    try {
+      const blobResp = await fetch(`${RELAY_URL}/pickup/files/${blob.id}`, {
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      if (!blobResp.ok) continue;
+      const text = await blobResp.text();
+      const parsed = JSON.parse(text);
+      if (parsed.v !== void 0 && parsed.nonce !== void 0) {
+        try {
+          const manifest = decryptJSON(parsed, relayKey);
+          if (manifest.version && manifest.entries) {
+            coreManifest = manifest;
+          }
+        } catch {
+        }
+      } else if (parsed.path && parsed.data) {
+        fileBlobs.push({
+          id: blob.id,
+          path: parsed.path,
+          sha256: parsed.sha256,
+          data: parsed.data
+        });
+      }
+      await fetch(`${RELAY_URL}/confirm/files/${blob.id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+    } catch (err) {
+      process.stderr.write(`[file-sync] error processing blob ${blob.id}: ${err.message}
+`);
+    }
+  }
+  if (!coreManifest) {
+    process.stderr.write("[file-sync] no manifest found in relay\n");
+    return { imported: 0, deleted: 0 };
+  }
+  const delta = compareManifest(coreManifest);
+  const fileBlobMap = new Map(fileBlobs.map((f) => [f.path, f]));
+  let imported = 0;
+  for (const entry of delta.upsert) {
+    const fileBlob = fileBlobMap.get(entry.path);
+    if (!fileBlob) {
+      continue;
+    }
+    try {
+      const content = decrypt(fileBlob.data, relayKey);
+      const actualHash = createHash("sha256").update(content).digest("hex");
+      if (actualHash !== entry.sha256) {
+        process.stderr.write(`[file-sync] hash mismatch for ${entry.path}, skipping
+`);
+        continue;
+      }
+      const destPath = join(paths.root, entry.path);
+      mkdirSync(dirname(destPath), { recursive: true });
+      writeFileSync(destPath, content);
+      imported++;
+    } catch (err) {
+      process.stderr.write(`[file-sync] failed to write ${entry.path}: ${err.message}
+`);
+    }
+  }
+  let deleted = 0;
+  for (const path of delta.delete) {
+    const destPath = join(paths.root, path);
+    if (existsSync(destPath)) {
+      try {
+        unlinkSync(destPath);
+        deleted++;
+      } catch (err) {
+        process.stderr.write(`[file-sync] failed to delete ${path}: ${err.message}
+`);
+      }
+    }
+  }
+  const state = loadFileSyncState();
+  state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  state.filesTransferred += imported;
+  state.filesDeleted += deleted;
+  saveFileSyncState(state);
+  return { imported, deleted };
+}
+
+export {
+  generateManifest,
+  compareManifest,
+  loadFileSyncState,
+  saveFileSyncState,
+  pushFileSync,
+  pullFileSync
+};

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-3S6TI23B.js

@@ -0,0 +1,97 @@
+import {
+  getAgentId,
+  ldmPaths,
+  resolveSecretPath,
+  resolveStatePath,
+  stateWritePath
+} from "./chunk-EXEZZADG.js";
+
+// src/role.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var STATE_FILE = "crystal-role.json";
+function loadRoleState() {
+  try {
+    const path = resolveStatePath(STATE_FILE);
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveRoleState(state) {
+  const writePath = stateWritePath(STATE_FILE);
+  writeFileSync(writePath, JSON.stringify(state, null, 2) + "\n");
+}
+function hasLocalEmbeddingProvider() {
+  if (process.env.OPENAI_API_KEY) return true;
+  if (process.env.GOOGLE_API_KEY && process.env.CRYSTAL_EMBEDDING_PROVIDER === "google") return true;
+  if (process.env.CRYSTAL_EMBEDDING_PROVIDER === "ollama") return true;
+  return false;
+}
+function hasRelayKey() {
+  const keyPath = resolveSecretPath("crystal-relay-key");
+  return existsSync(keyPath);
+}
+function detectRole() {
+  const agentId = getAgentId();
+  const paths = ldmPaths(agentId);
+  const relayUrl = process.env.CRYSTAL_RELAY_URL || null;
+  const relayToken = !!process.env.CRYSTAL_RELAY_TOKEN;
+  const relayKeyExists = hasRelayKey();
+  const localEmbeddings = hasLocalEmbeddingProvider();
+  const localDb = existsSync(paths.crystalDb);
+  const state = loadRoleState();
+  if (state && state.override) {
+    return {
+      role: state.role,
+      source: "state-file",
+      relayUrl,
+      relayToken,
+      relayKeyExists,
+      agentId,
+      hasLocalEmbeddings: localEmbeddings,
+      hasLocalDb: localDb
+    };
+  }
+  let role = "standalone";
+  if (relayUrl && !localEmbeddings) {
+    role = "node";
+  } else if (relayUrl && localEmbeddings) {
+    role = "core";
+  }
+  return {
+    role,
+    source: "auto-detected",
+    relayUrl,
+    relayToken,
+    relayKeyExists,
+    agentId,
+    hasLocalEmbeddings: localEmbeddings,
+    hasLocalDb: localDb
+  };
+}
+function promoteToCore() {
+  saveRoleState({
+    role: "core",
+    override: true,
+    agentId: getAgentId(),
+    setAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function demoteToNode(relayUrl) {
+  saveRoleState({
+    role: "node",
+    override: true,
+    relayUrl,
+    agentId: getAgentId(),
+    setAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+export {
+  loadRoleState,
+  detectRole,
+  promoteToCore,
+  demoteToNode
+};