@wipcomputer/memory-crystal 0.7.34-alpha.3 → 0.7.34-alpha.4

package/dist/chunk-3G3SFYYI.js

@@ -1,288 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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
-};