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

package/dist/pair.js

@@ -1,15 +1,111 @@
-import {
-  RELAY_KEY_PATH,
-  decodePairingString,
-  encodePairingString,
-  generateRelayKey,
-  loadRelayKey
-} from "./chunk-D3MACYZ4.js";
-import "./chunk-DFQ72B7M.js";
+// src/pair.ts
+import { existsSync as existsSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+
+// src/crypto.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { createCipheriv, createDecipheriv, createHmac, randomBytes, hkdfSync } from "crypto";
+
+// 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 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")
+  };
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+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;
+}
+
+// src/crypto.ts
+import { createHash } from "crypto";
+var KEY_PATH = process.env.CRYSTAL_RELAY_KEY_PATH || resolveSecretPath("crystal-relay-key");
+function loadRelayKey() {
+  if (!existsSync2(KEY_PATH)) {
+    throw new Error(
+      `Relay key not found at ${KEY_PATH}
+Generate one: mkdir -p ~/.ldm/secrets && openssl rand -base64 32 > ~/.ldm/secrets/crystal-relay-key && chmod 600 ~/.ldm/secrets/crystal-relay-key
+Or run: crystal pair`
+    );
+  }
+  const raw = readFileSync2(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;
+}
+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;
+}
 
 // src/pair.ts
-import { existsSync, writeFileSync, mkdirSync, chmodSync } from "fs";
-import { dirname } from "path";
 import qrcode from "qrcode-terminal";
 function generateQR(text) {
   return new Promise((resolve) => {
@@ -19,13 +115,13 @@ function generateQR(text) {
   });
 }
 function saveKey(key) {
-  const dir = dirname(RELAY_KEY_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  const dir = dirname2(RELAY_KEY_PATH);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync(RELAY_KEY_PATH, key.toString("base64") + "\n", { mode: 384 });
+  writeFileSync2(RELAY_KEY_PATH, key.toString("base64") + "\n", { mode: 384 });
   try {
-    chmodSync(RELAY_KEY_PATH, 384);
+    chmodSync2(RELAY_KEY_PATH, 384);
   } catch {
   }
 }
@@ -54,7 +150,7 @@ async function pairShow() {
 }
 function pairReceive(code) {
   const key = decodePairingString(code);
-  if (existsSync(RELAY_KEY_PATH)) {
+  if (existsSync3(RELAY_KEY_PATH)) {
     try {
       const existing = loadRelayKey();
       if (existing.equals(key)) {