@wipcomputer/memory-crystal 0.7.32 → 0.7.33

package/dist/chunk-DACSKLY6.js

@@ -0,0 +1,219 @@
+// src/ldm.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+var HOME = process.env.HOME || "";
+var LDM_ROOT = join(HOME, ".ldm");
+function getAgentId() {
+  return process.env.CRYSTAL_AGENT_ID || "cc-mini";
+}
+function ldmPaths(agentId) {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, "agents", id);
+  return {
+    root: LDM_ROOT,
+    bin: join(LDM_ROOT, "bin"),
+    secrets: join(LDM_ROOT, "secrets"),
+    state: join(LDM_ROOT, "state"),
+    config: join(LDM_ROOT, "config.json"),
+    crystalDb: join(LDM_ROOT, "memory", "crystal.db"),
+    crystalLance: join(LDM_ROOT, "memory", "lance"),
+    agentRoot,
+    transcripts: join(agentRoot, "memory", "transcripts"),
+    sessions: join(agentRoot, "memory", "sessions"),
+    daily: join(agentRoot, "memory", "daily"),
+    journals: join(agentRoot, "memory", "journals"),
+    workspace: join(agentRoot, "memory", "workspace")
+  };
+}
+function loadConfig() {
+  const configPath = join(LDM_ROOT, "config.json");
+  try {
+    if (existsSync(configPath)) {
+      return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveConfig(config) {
+  const configPath = join(LDM_ROOT, "config.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function scaffoldLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  mkdirSync(join(paths.root, "memory"), { recursive: true });
+  mkdirSync(paths.crystalLance, { recursive: true });
+  mkdirSync(paths.bin, { recursive: true });
+  mkdirSync(paths.secrets, { recursive: true, mode: 448 });
+  mkdirSync(paths.state, { recursive: true });
+  mkdirSync(paths.transcripts, { recursive: true });
+  mkdirSync(paths.sessions, { recursive: true });
+  mkdirSync(paths.daily, { recursive: true });
+  mkdirSync(paths.journals, { recursive: true });
+  mkdirSync(paths.workspace, { recursive: true });
+  const id = agentId || getAgentId();
+  let config = loadConfig();
+  if (!config) {
+    config = {
+      version: "1.0.0",
+      agents: [id],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } else {
+    if (!config.agents.includes(id)) {
+      config.agents.push(id);
+    }
+    config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  saveConfig(config);
+  return paths;
+}
+function deployCaptureScript() {
+  const paths = ldmPaths();
+  mkdirSync(paths.bin, { recursive: true });
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  let scriptSrc = join(thisDir, "crystal-capture.sh");
+  if (!existsSync(scriptSrc)) {
+    scriptSrc = join(thisDir, "..", "scripts", "crystal-capture.sh");
+  }
+  const scriptDest = join(paths.bin, "crystal-capture.sh");
+  if (!existsSync(scriptSrc)) {
+    throw new Error(`crystal-capture.sh not found at ${scriptSrc}`);
+  }
+  copyFileSync(scriptSrc, scriptDest);
+  chmodSync(scriptDest, 493);
+  return scriptDest;
+}
+var CRON_TAG = "# crystal-capture";
+var CRON_ENTRY = "* * * * * ~/.ldm/bin/crystal-capture.sh >> /tmp/ldm-dev-tools/crystal-capture.log 2>&1";
+function isCrystalCaptureLine(line) {
+  return line === CRON_TAG || line.includes("crystal-capture.sh") && line.startsWith("*");
+}
+function installCron() {
+  mkdirSync("/tmp/ldm-dev-tools", { recursive: true });
+  let existing = "";
+  try {
+    existing = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+  }
+  const lines = existing.split("\n").filter((line) => !isCrystalCaptureLine(line));
+  lines.push(CRON_TAG);
+  lines.push(CRON_ENTRY);
+  const newCrontab = lines.filter((l, i, arr) => !(l === "" && i === arr.length - 1)).join("\n") + "\n";
+  execSync("crontab -", { input: newCrontab, encoding: "utf8" });
+}
+function removeCron() {
+  let existing = "";
+  try {
+    existing = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+    return;
+  }
+  const lines = existing.split("\n").filter((line) => !isCrystalCaptureLine(line));
+  const newCrontab = lines.join("\n");
+  execSync("crontab -", { input: newCrontab, encoding: "utf8" });
+}
+function deployBackupScript() {
+  const paths = ldmPaths();
+  mkdirSync(paths.bin, { recursive: true });
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  let scriptSrc = join(thisDir, "ldm-backup.sh");
+  if (!existsSync(scriptSrc)) {
+    scriptSrc = join(thisDir, "..", "scripts", "ldm-backup.sh");
+  }
+  const scriptDest = join(paths.bin, "ldm-backup.sh");
+  if (!existsSync(scriptSrc)) {
+    throw new Error(`ldm-backup.sh not found at ${scriptSrc}`);
+  }
+  copyFileSync(scriptSrc, scriptDest);
+  chmodSync(scriptDest, 493);
+  return scriptDest;
+}
+function installBackupLaunchAgent() {
+  const scriptPath = join(ldmPaths().bin, "ldm-backup.sh");
+  if (!existsSync(scriptPath)) {
+    throw new Error(`Backup script not found. Run crystal init first.`);
+  }
+  const launchAgentsDir = join(HOME, "Library", "LaunchAgents");
+  mkdirSync(launchAgentsDir, { recursive: true });
+  const plistPath = join(launchAgentsDir, "ai.openclaw.ldm-backup.plist");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.openclaw.ldm-backup</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>bash</string>
+    <string>${scriptPath}</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>3</integer>
+    <key>Minute</key>
+    <integer>0</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>/tmp/ldm-dev-tools/ldm-backup.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/ldm-dev-tools/ldm-backup.log</string>
+</dict>
+</plist>`;
+  writeFileSync(plistPath, plist);
+  try {
+    execSync(`launchctl unload ${plistPath} 2>/dev/null`);
+  } catch {
+  }
+  execSync(`launchctl load ${plistPath}`);
+  return plistPath;
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+function resolveStatePath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.state, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "memory", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function stateWritePath(filename) {
+  const paths = ldmPaths();
+  const dir = paths.state;
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, filename);
+}
+function resolveSecretPath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.secrets, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "secrets", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function ensureLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  if (existsSync(paths.transcripts) && existsSync(paths.config)) {
+    return paths;
+  }
+  return scaffoldLdm(agentId);
+}
+
+export {
+  getAgentId,
+  ldmPaths,
+  scaffoldLdm,
+  deployCaptureScript,
+  installCron,
+  removeCron,
+  deployBackupScript,
+  installBackupLaunchAgent,
+  resolveStatePath,
+  stateWritePath,
+  resolveSecretPath,
+  ensureLdm
+};

package/dist/chunk-DFQ72B7M.js

@@ -0,0 +1,248 @@
+// src/ldm.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+var HOME = process.env.HOME || "";
+var LDM_ROOT = join(HOME, ".ldm");
+function loadAgentConfig(id) {
+  const cfgPath = join(LDM_ROOT, "agents", id, "config.json");
+  try {
+    if (existsSync(cfgPath)) return JSON.parse(readFileSync(cfgPath, "utf-8"));
+  } catch {
+  }
+  return null;
+}
+function saveAgentConfig(id, config) {
+  const dir = join(LDM_ROOT, "agents", id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+}
+function getAgentId(harnessHint) {
+  if (process.env.CRYSTAL_AGENT_ID) return process.env.CRYSTAL_AGENT_ID;
+  const agentsDir = join(LDM_ROOT, "agents");
+  if (existsSync(agentsDir)) {
+    try {
+      for (const d of readdirSync(agentsDir)) {
+        const cfg = loadAgentConfig(d);
+        if (!cfg || !cfg.agentId) continue;
+        if (!harnessHint) return cfg.agentId;
+        if (harnessHint === "claude-code" && cfg.harness === "claude-code-cli") return cfg.agentId;
+        if (harnessHint === "openclaw" && cfg.harness === "openclaw") return cfg.agentId;
+      }
+    } catch {
+    }
+  }
+  return harnessHint === "openclaw" ? "oc-lesa-mini" : "cc-mini";
+}
+function ldmPaths(agentId) {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, "agents", id);
+  return {
+    root: LDM_ROOT,
+    bin: join(LDM_ROOT, "bin"),
+    secrets: join(LDM_ROOT, "secrets"),
+    state: join(LDM_ROOT, "state"),
+    config: join(LDM_ROOT, "config.json"),
+    crystalDb: join(LDM_ROOT, "memory", "crystal.db"),
+    crystalLance: join(LDM_ROOT, "memory", "lance"),
+    agentRoot,
+    transcripts: join(agentRoot, "memory", "transcripts"),
+    sessions: join(agentRoot, "memory", "sessions"),
+    daily: join(agentRoot, "memory", "daily"),
+    journals: join(agentRoot, "memory", "journals"),
+    workspace: join(agentRoot, "memory", "workspace")
+  };
+}
+function loadConfig() {
+  const configPath = join(LDM_ROOT, "config.json");
+  try {
+    if (existsSync(configPath)) {
+      return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveConfig(config) {
+  const configPath = join(LDM_ROOT, "config.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function scaffoldLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  mkdirSync(join(paths.root, "memory"), { recursive: true });
+  mkdirSync(paths.crystalLance, { recursive: true });
+  mkdirSync(paths.bin, { recursive: true });
+  mkdirSync(paths.secrets, { recursive: true, mode: 448 });
+  mkdirSync(paths.state, { recursive: true });
+  mkdirSync(paths.transcripts, { recursive: true });
+  mkdirSync(paths.sessions, { recursive: true });
+  mkdirSync(paths.daily, { recursive: true });
+  mkdirSync(paths.journals, { recursive: true });
+  mkdirSync(paths.workspace, { recursive: true });
+  const id = agentId || getAgentId();
+  let config = loadConfig();
+  if (!config) {
+    config = {
+      version: "1.0.0",
+      agents: [id],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } else {
+    if (!config.agents.includes(id)) {
+      config.agents.push(id);
+    }
+    config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  saveConfig(config);
+  return paths;
+}
+function deployCaptureScript() {
+  const paths = ldmPaths();
+  mkdirSync(paths.bin, { recursive: true });
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  let scriptSrc = join(thisDir, "crystal-capture.sh");
+  if (!existsSync(scriptSrc)) {
+    scriptSrc = join(thisDir, "..", "scripts", "crystal-capture.sh");
+  }
+  const scriptDest = join(paths.bin, "crystal-capture.sh");
+  if (!existsSync(scriptSrc)) {
+    throw new Error(`crystal-capture.sh not found at ${scriptSrc}`);
+  }
+  copyFileSync(scriptSrc, scriptDest);
+  chmodSync(scriptDest, 493);
+  return scriptDest;
+}
+var CRON_TAG = "# crystal-capture";
+var CRON_ENTRY = "* * * * * ~/.ldm/bin/crystal-capture.sh >> ~/.ldm/logs/crystal-capture.log 2>&1";
+function isCrystalCaptureLine(line) {
+  return line === CRON_TAG || line.includes("crystal-capture.sh") && line.startsWith("*");
+}
+function installCron() {
+  mkdirSync(join(HOME, ".ldm", "logs"), { recursive: true });
+  let existing = "";
+  try {
+    existing = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+  }
+  const lines = existing.split("\n").filter((line) => !isCrystalCaptureLine(line));
+  lines.push(CRON_TAG);
+  lines.push(CRON_ENTRY);
+  const newCrontab = lines.filter((l, i, arr) => !(l === "" && i === arr.length - 1)).join("\n") + "\n";
+  execSync("crontab -", { input: newCrontab, encoding: "utf8" });
+}
+function removeCron() {
+  let existing = "";
+  try {
+    existing = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+    return;
+  }
+  const lines = existing.split("\n").filter((line) => !isCrystalCaptureLine(line));
+  const newCrontab = lines.join("\n");
+  execSync("crontab -", { input: newCrontab, encoding: "utf8" });
+}
+function deployBackupScript() {
+  const paths = ldmPaths();
+  mkdirSync(paths.bin, { recursive: true });
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  let scriptSrc = join(thisDir, "ldm-backup.sh");
+  if (!existsSync(scriptSrc)) {
+    scriptSrc = join(thisDir, "..", "scripts", "ldm-backup.sh");
+  }
+  const scriptDest = join(paths.bin, "ldm-backup.sh");
+  if (!existsSync(scriptSrc)) {
+    throw new Error(`ldm-backup.sh not found at ${scriptSrc}`);
+  }
+  copyFileSync(scriptSrc, scriptDest);
+  chmodSync(scriptDest, 493);
+  return scriptDest;
+}
+function installBackupLaunchAgent() {
+  const scriptPath = join(ldmPaths().bin, "ldm-backup.sh");
+  if (!existsSync(scriptPath)) {
+    throw new Error(`Backup script not found. Run crystal init first.`);
+  }
+  const launchAgentsDir = join(HOME, "Library", "LaunchAgents");
+  mkdirSync(launchAgentsDir, { recursive: true });
+  const plistPath = join(launchAgentsDir, "ai.openclaw.ldm-backup.plist");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.openclaw.ldm-backup</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>bash</string>
+    <string>${scriptPath}</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>3</integer>
+    <key>Minute</key>
+    <integer>0</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${HOME}/.ldm/logs/ldm-backup.log</string>
+  <key>StandardErrorPath</key>
+  <string>${HOME}/.ldm/logs/ldm-backup.log</string>
+</dict>
+</plist>`;
+  writeFileSync(plistPath, plist);
+  try {
+    execSync(`launchctl unload ${plistPath} 2>/dev/null`);
+  } catch {
+  }
+  execSync(`launchctl load ${plistPath}`);
+  return plistPath;
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+function resolveStatePath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.state, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "memory", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function stateWritePath(filename) {
+  const paths = ldmPaths();
+  const dir = paths.state;
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, filename);
+}
+function resolveSecretPath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.secrets, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "secrets", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function ensureLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  if (existsSync(paths.transcripts) && existsSync(paths.config)) {
+    return paths;
+  }
+  return scaffoldLdm(agentId);
+}
+
+export {
+  loadAgentConfig,
+  saveAgentConfig,
+  getAgentId,
+  ldmPaths,
+  scaffoldLdm,
+  deployCaptureScript,
+  installCron,
+  removeCron,
+  deployBackupScript,
+  installBackupLaunchAgent,
+  resolveStatePath,
+  stateWritePath,
+  resolveSecretPath,
+  ensureLdm
+};

package/dist/chunk-DW5B4BL7.js

@@ -0,0 +1,108 @@
+import {
+  resolveSecretPath
+} from "./chunk-VNFXFQBB.js";
+
+// src/crypto.ts
+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
+};