@wipcomputer/memory-crystal 0.7.32 → 0.7.33

package/dist/chunk-J7MRSZIO.js

@@ -0,0 +1,167 @@
+// src/cloud-crystal.ts
+async function embed(text, apiKey) {
+  const resp = await fetch("https://api.openai.com/v1/embeddings", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "text-embedding-3-small",
+      input: text,
+      dimensions: 1024
+    })
+  });
+  if (!resp.ok) {
+    const err = await resp.text();
+    throw new Error(`Embedding failed: ${resp.status} ${err}`);
+  }
+  const data = await resp.json();
+  return data.data[0].embedding;
+}
+var CloudCrystal = class {
+  constructor(db, vectorize, apiKey) {
+    this.db = db;
+    this.vectorize = vectorize;
+    this.apiKey = apiKey;
+  }
+  // Hybrid search: BM25 (FTS5) + vector (Vectorize) + RRF fusion + recency
+  async search(userId, query, limit = 5, agentId) {
+    const agentFilter = agentId ? "AND c.agent_id = ?" : "";
+    const bm25Params = [userId, query];
+    if (agentId) bm25Params.push(agentId);
+    const bm25Results = await this.db.prepare(`
+      SELECT c.id, c.text, c.role, c.agent_id, c.created_at, c.source_type,
+             rank AS bm25_score
+      FROM chunks_fts f
+      JOIN chunks c ON c.id = f.rowid
+      WHERE f.text MATCH ? AND c.user_id = ? ${agentFilter}
+      ORDER BY rank
+      LIMIT ?
+    `).bind(query, userId, ...agentId ? [agentId] : [], limit * 3).all();
+    const queryVec = await embed(query, this.apiKey);
+    const vecResults = await this.vectorize.query(queryVec, {
+      topK: limit * 3,
+      filter: { user_id: userId, ...agentId ? { agent_id: agentId } : {} },
+      returnMetadata: "all"
+    });
+    const k = 60;
+    const scores = /* @__PURE__ */ new Map();
+    const bm25Rows = bm25Results.results || [];
+    for (let i = 0; i < bm25Rows.length; i++) {
+      const id = bm25Rows[i].id;
+      const existing = scores.get(id) || { score: 0, data: bm25Rows[i] };
+      existing.score += 1 / (k + i + 1);
+      scores.set(id, existing);
+    }
+    for (let i = 0; i < vecResults.matches.length; i++) {
+      const match = vecResults.matches[i];
+      const id = parseInt(match.id, 10);
+      const existing = scores.get(id) || { score: 0 };
+      existing.score += 1 / (k + i + 1);
+      scores.set(id, existing);
+    }
+    const now = Date.now();
+    for (const [id, entry] of scores) {
+      if (entry.data?.created_at) {
+        const age = now - new Date(entry.data.created_at).getTime();
+        const dayAge = age / (1e3 * 60 * 60 * 24);
+        const recencyBoost = Math.max(0, 1 - dayAge / 90) * 0.15;
+        entry.score += recencyBoost;
+      }
+    }
+    const ranked = [...scores.entries()].sort((a, b) => b[1].score - a[1].score).slice(0, limit);
+    const needFetch = ranked.filter(([_, v]) => !v.data).map(([id]) => id);
+    if (needFetch.length > 0) {
+      const placeholders = needFetch.map(() => "?").join(",");
+      const rows = await this.db.prepare(
+        `SELECT id, text, role, agent_id, created_at, source_type FROM chunks WHERE id IN (${placeholders})`
+      ).bind(...needFetch).all();
+      const rowMap = new Map(rows.results.map((r) => [r.id, r]));
+      for (const [id, entry] of scores) {
+        if (!entry.data && rowMap.has(id)) {
+          entry.data = rowMap.get(id);
+        }
+      }
+    }
+    return ranked.map(([id, entry]) => ({
+      id,
+      text: entry.data?.text || "",
+      score: entry.score,
+      role: entry.data?.role || "unknown",
+      agent_id: entry.data?.agent_id || "unknown",
+      created_at: entry.data?.created_at || "",
+      source_type: entry.data?.source_type || "unknown"
+    }));
+  }
+  // Ingest chunks (conversation turns)
+  async ingest(userId, chunks) {
+    let ingested = 0;
+    for (const chunk of chunks) {
+      const result = await this.db.prepare(`
+        INSERT INTO chunks (user_id, text, role, agent_id, source_type, token_count)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).bind(
+        userId,
+        chunk.text,
+        chunk.role,
+        chunk.agent_id,
+        chunk.source_type || "chatgpt",
+        Math.ceil(chunk.text.length / 4)
+        // rough token estimate
+      ).run();
+      const chunkId = result.meta.last_row_id;
+      const vec = await embed(chunk.text, this.apiKey);
+      await this.vectorize.upsert([{
+        id: String(chunkId),
+        values: vec,
+        metadata: {
+          user_id: userId,
+          agent_id: chunk.agent_id,
+          role: chunk.role,
+          source_type: chunk.source_type || "chatgpt"
+        }
+      }]);
+      ingested++;
+    }
+    return ingested;
+  }
+  // Remember a fact/preference/event
+  async remember(userId, text, category = "fact") {
+    const result = await this.db.prepare(`
+      INSERT INTO memories (user_id, text, category) VALUES (?, ?, ?)
+    `).bind(userId, text, category).run();
+    return result.meta.last_row_id;
+  }
+  // Forget (deprecate) a memory
+  async forget(userId, memoryId) {
+    const result = await this.db.prepare(`
+      UPDATE memories SET status = 'deprecated', updated_at = datetime('now')
+      WHERE id = ? AND user_id = ? AND status = 'active'
+    `).bind(memoryId, userId).run();
+    return (result.meta.changes || 0) > 0;
+  }
+  // Status
+  async status(userId) {
+    const chunkCount = await this.db.prepare(
+      "SELECT COUNT(*) as count FROM chunks WHERE user_id = ?"
+    ).bind(userId).first();
+    const memoryCount = await this.db.prepare(
+      "SELECT COUNT(*) as count FROM memories WHERE user_id = ? AND status = ?"
+    ).bind(userId, "active").first();
+    const agents = await this.db.prepare(
+      "SELECT DISTINCT agent_id FROM chunks WHERE user_id = ?"
+    ).bind(userId).all();
+    return {
+      chunks: chunkCount?.count || 0,
+      memories: memoryCount?.count || 0,
+      agents: (agents.results || []).map((r) => r.agent_id),
+      tier: "convenience"
+      // Tier 2 users only
+    };
+  }
+};
+
+export {
+  CloudCrystal
+};

package/dist/chunk-JITKI2OI.js

@@ -0,0 +1,106 @@
+// src/crypto.ts
+import { readFileSync, existsSync } from "fs";
+import { createCipheriv, createDecipheriv, createHmac, randomBytes, hkdfSync } from "crypto";
+import { join } from "path";
+import { createHash } from "crypto";
+var HOME = process.env.HOME || "";
+var KEY_PATH = process.env.CRYSTAL_RELAY_KEY_PATH || join(HOME, ".openclaw", "secrets", "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
+};