@wipcomputer/memory-crystal 0.7.30 → 0.7.32

package/dist/chunk-TMDZJJKV.js

@@ -1,288 +0,0 @@
-import {
-  decrypt,
-  decryptJSON,
-  encrypt,
-  encryptJSON,
-  loadRelayKey
-} from "./chunk-7RMLKZIS.js";
-import {
-  ldmPaths,
-  resolveStatePath,
-  stateWritePath
-} from "./chunk-DACSKLY6.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-UNHVZB5G.js

@@ -1,411 +0,0 @@
-// src/core.ts
-import * as lancedb from "@lancedb/lancedb";
-import Database from "better-sqlite3";
-import { readFileSync, existsSync, mkdirSync } from "fs";
-import { execSync } from "child_process";
-import { join } from "path";
-import http from "http";
-import https from "https";
-async function embedOpenAI(texts, apiKey, model) {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify({ input: texts, model });
-    const req = https.request({
-      hostname: "api.openai.com",
-      path: "/v1/embeddings",
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`,
-        "Content-Length": Buffer.byteLength(body)
-      },
-      timeout: 3e4
-    }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(`OpenAI API error ${res.statusCode}: ${data.slice(0, 200)}`));
-          return;
-        }
-        const parsed = JSON.parse(data);
-        resolve(parsed.data.map((d) => d.embedding));
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("OpenAI timeout"));
-    });
-    req.write(body);
-    req.end();
-  });
-}
-async function embedOllama(texts, host, model) {
-  const results = [];
-  for (const text of texts) {
-    const result = await new Promise((resolve, reject) => {
-      const url = new URL("/api/embeddings", host);
-      const body = JSON.stringify({ model, prompt: text });
-      const req = http.request({
-        hostname: url.hostname,
-        port: url.port,
-        path: url.pathname,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body)
-        },
-        timeout: 15e3
-      }, (res) => {
-        let data = "";
-        res.on("data", (chunk) => data += chunk);
-        res.on("end", () => {
-          if (res.statusCode !== 200) {
-            reject(new Error(`Ollama error ${res.statusCode}: ${data.slice(0, 200)}`));
-            return;
-          }
-          resolve(JSON.parse(data).embedding);
-        });
-      });
-      req.on("error", reject);
-      req.on("timeout", () => {
-        req.destroy();
-        reject(new Error("Ollama timeout"));
-      });
-      req.write(body);
-      req.end();
-    });
-    results.push(result);
-  }
-  return results;
-}
-async function embedGoogle(texts, apiKey, model) {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify({
-      requests: texts.map((text) => ({ model: `models/${model}`, content: { parts: [{ text }] } }))
-    });
-    const req = https.request({
-      hostname: "generativelanguage.googleapis.com",
-      path: `/v1beta/models/${model}:batchEmbedContents?key=${apiKey}`,
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(body)
-      },
-      timeout: 3e4
-    }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        if (res.statusCode !== 200) {
-          reject(new Error(`Google API error ${res.statusCode}: ${data.slice(0, 200)}`));
-          return;
-        }
-        const parsed = JSON.parse(data);
-        resolve(parsed.embeddings.map((e) => e.values));
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Google timeout"));
-    });
-    req.write(body);
-    req.end();
-  });
-}
-var Crystal = class {
-  config;
-  lanceDb = null;
-  sqliteDb = null;
-  chunksTable = null;
-  constructor(config) {
-    this.config = config;
-    if (!existsSync(config.dataDir)) {
-      mkdirSync(config.dataDir, { recursive: true });
-    }
-  }
-  // ── Initialization ──
-  async init() {
-    const lanceDir = join(this.config.dataDir, "lance");
-    const sqlitePath = join(this.config.dataDir, "crystal.db");
-    if (!existsSync(lanceDir)) mkdirSync(lanceDir, { recursive: true });
-    this.lanceDb = await lancedb.connect(lanceDir);
-    this.sqliteDb = new Database(sqlitePath);
-    this.sqliteDb.pragma("journal_mode = WAL");
-    this.initSqliteTables();
-    await this.initLanceTables();
-  }
-  initSqliteTables() {
-    const db = this.sqliteDb;
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS sources (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        type TEXT NOT NULL,
-        uri TEXT NOT NULL,
-        title TEXT,
-        agent_id TEXT NOT NULL,
-        metadata TEXT DEFAULT '{}',
-        ingested_at TEXT NOT NULL,
-        chunk_count INTEGER DEFAULT 0
-      );
-
-      CREATE TABLE IF NOT EXISTS capture_state (
-        agent_id TEXT NOT NULL,
-        source_id TEXT NOT NULL,
-        last_message_count INTEGER DEFAULT 0,
-        capture_count INTEGER DEFAULT 0,
-        last_capture_at TEXT,
-        PRIMARY KEY (agent_id, source_id)
-      );
-
-      CREATE TABLE IF NOT EXISTS memories (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        text TEXT NOT NULL,
-        category TEXT NOT NULL DEFAULT 'fact',
-        confidence REAL NOT NULL DEFAULT 1.0,
-        source_ids TEXT DEFAULT '[]',
-        status TEXT NOT NULL DEFAULT 'active',
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS entities (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL UNIQUE,
-        type TEXT NOT NULL DEFAULT 'concept',
-        description TEXT,
-        properties TEXT DEFAULT '{}',
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS relationships (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_id INTEGER NOT NULL REFERENCES entities(id),
-        target_id INTEGER NOT NULL REFERENCES entities(id),
-        type TEXT NOT NULL,
-        description TEXT,
-        weight REAL DEFAULT 1.0,
-        valid_from TEXT NOT NULL,
-        valid_until TEXT,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_sources_agent ON sources(agent_id);
-      CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
-      CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
-      CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_id);
-      CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_id);
-    `);
-  }
-  async initLanceTables() {
-    const db = this.lanceDb;
-    const tableNames = await db.tableNames();
-    if (tableNames.includes("chunks")) {
-      this.chunksTable = await db.openTable("chunks");
-    }
-  }
-  // ── Embedding ──
-  async embed(texts) {
-    if (texts.length === 0) return [];
-    const cfg = this.config;
-    switch (cfg.embeddingProvider) {
-      case "openai":
-        if (!cfg.openaiApiKey) throw new Error("OpenAI API key required");
-        return embedOpenAI(texts, cfg.openaiApiKey, cfg.openaiModel || "text-embedding-3-small");
-      case "ollama":
-        return embedOllama(texts, cfg.ollamaHost || "http://localhost:11434", cfg.ollamaModel || "nomic-embed-text");
-      case "google":
-        if (!cfg.googleApiKey) throw new Error("Google API key required");
-        return embedGoogle(texts, cfg.googleApiKey, cfg.googleModel || "text-embedding-004");
-      default:
-        throw new Error(`Unknown embedding provider: ${cfg.embeddingProvider}`);
-    }
-  }
-  // ── Chunking ──
-  chunkText(text, targetTokens = 400, overlapTokens = 80) {
-    const targetChars = targetTokens * 4;
-    const overlapChars = overlapTokens * 4;
-    const chunks = [];
-    let start = 0;
-    while (start < text.length) {
-      let end = Math.min(start + targetChars, text.length);
-      if (end < text.length) {
-        const minBreak = start + Math.floor(targetChars * 0.5);
-        const paraBreak = text.lastIndexOf("\n\n", end);
-        if (paraBreak > minBreak) {
-          end = paraBreak;
-        } else {
-          const sentBreak = text.lastIndexOf(". ", end);
-          if (sentBreak > minBreak) {
-            end = sentBreak + 1;
-          }
-        }
-      }
-      const chunk = text.slice(start, end).trim();
-      if (chunk.length > 0) chunks.push(chunk);
-      if (end >= text.length) break;
-      start = end - overlapChars;
-      if (start <= (chunks.length > 0 ? end - targetChars : 0)) {
-        start = end;
-      }
-    }
-    return chunks;
-  }
-  // ── Ingest ──
-  async ingest(chunks) {
-    if (chunks.length === 0) return 0;
-    const texts = chunks.map((c) => c.text);
-    const embeddings = await this.embed(texts);
-    const records = chunks.map((chunk, i) => ({
-      text: chunk.text,
-      vector: embeddings[i],
-      role: chunk.role,
-      source_type: chunk.source_type,
-      source_id: chunk.source_id,
-      agent_id: chunk.agent_id,
-      token_count: chunk.token_count,
-      created_at: chunk.created_at || (/* @__PURE__ */ new Date()).toISOString()
-    }));
-    if (!this.chunksTable) {
-      this.chunksTable = await this.lanceDb.createTable("chunks", records);
-    } else {
-      await this.chunksTable.add(records);
-    }
-    return records.length;
-  }
-  // ── Search ──
-  async search(query, limit = 5, filter) {
-    if (!this.chunksTable) return [];
-    const [embedding] = await this.embed([query]);
-    let queryBuilder = this.chunksTable.vectorSearch(embedding).distanceType("cosine").limit(limit);
-    if (filter?.agent_id) {
-      queryBuilder = queryBuilder.where(`agent_id = '${filter.agent_id}'`);
-    }
-    if (filter?.source_type) {
-      queryBuilder = queryBuilder.where(`source_type = '${filter.source_type}'`);
-    }
-    const results = await queryBuilder.toArray();
-    return results.map((row) => ({
-      text: row.text,
-      role: row.role,
-      score: row._distance != null ? 1 - row._distance : 0,
-      source_type: row.source_type,
-      source_id: row.source_id,
-      agent_id: row.agent_id,
-      created_at: row.created_at
-    }));
-  }
-  // ── Remember (explicit fact storage) ──
-  async remember(text, category = "fact") {
-    const db = this.sqliteDb;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const stmt = db.prepare(`
-      INSERT INTO memories (text, category, confidence, source_ids, status, created_at, updated_at)
-      VALUES (?, ?, 1.0, '[]', 'active', ?, ?)
-    `);
-    const result = stmt.run(text, category, now, now);
-    await this.ingest([{
-      text,
-      role: "system",
-      source_type: "manual",
-      source_id: `memory:${result.lastInsertRowid}`,
-      agent_id: "system",
-      token_count: Math.ceil(text.length / 4),
-      created_at: now
-    }]);
-    return result.lastInsertRowid;
-  }
-  // ── Forget (deprecate a memory) ──
-  forget(memoryId) {
-    const db = this.sqliteDb;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const result = db.prepare(`
-      UPDATE memories SET status = 'deprecated', updated_at = ? WHERE id = ? AND status = 'active'
-    `).run(now, memoryId);
-    return result.changes > 0;
-  }
-  // ── Status ──
-  async status() {
-    const db = this.sqliteDb;
-    let chunks = 0;
-    let oldestChunk = null;
-    let newestChunk = null;
-    const agents = [];
-    if (this.chunksTable) {
-      chunks = await this.chunksTable.countRows();
-      try {
-        const sample = await this.chunksTable.search([]).limit(1).toArray();
-      } catch {
-      }
-    }
-    const memories = db.prepare("SELECT COUNT(*) as count FROM memories WHERE status = ?").get("active")?.count || 0;
-    const sources = db.prepare("SELECT COUNT(*) as count FROM sources").get()?.count || 0;
-    const agentRows = db.prepare("SELECT DISTINCT agent_id FROM sources").all();
-    agents.push(...agentRows.map((r) => r.agent_id));
-    return {
-      chunks,
-      memories,
-      sources,
-      agents,
-      oldestChunk,
-      newestChunk,
-      embeddingProvider: this.config.embeddingProvider,
-      dataDir: this.config.dataDir
-    };
-  }
-  // ── Capture State (for incremental ingestion) ──
-  getCaptureState(agentId, sourceId) {
-    const db = this.sqliteDb;
-    const row = db.prepare("SELECT last_message_count, capture_count FROM capture_state WHERE agent_id = ? AND source_id = ?").get(agentId, sourceId);
-    return row || { lastMessageCount: 0, captureCount: 0 };
-  }
-  setCaptureState(agentId, sourceId, messageCount, captureCount) {
-    const db = this.sqliteDb;
-    db.prepare(`
-      INSERT OR REPLACE INTO capture_state (agent_id, source_id, last_message_count, capture_count, last_capture_at)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(agentId, sourceId, messageCount, captureCount, (/* @__PURE__ */ new Date()).toISOString());
-  }
-  // ── Cleanup ──
-  close() {
-    this.sqliteDb?.close();
-  }
-};
-function resolveConfig(overrides) {
-  const openclawHome = process.env.OPENCLAW_HOME || join(process.env.HOME || "/Users/lesa", ".openclaw");
-  const dataDir = overrides?.dataDir || join(openclawHome, "memory-crystal");
-  let openaiApiKey = overrides?.openaiApiKey || process.env.OPENAI_API_KEY;
-  if (!openaiApiKey) {
-    try {
-      const saTokenPath = join(openclawHome, "secrets", "op-sa-token");
-      if (existsSync(saTokenPath)) {
-        const saToken = readFileSync(saTokenPath, "utf8").trim();
-        openaiApiKey = execSync('op read "op://Agent Secrets/OpenAI API/api key"', {
-          encoding: "utf8",
-          env: { ...process.env, OP_SERVICE_ACCOUNT_TOKEN: saToken },
-          timeout: 1e4
-        }).trim();
-      }
-    } catch {
-    }
-  }
-  return {
-    dataDir,
-    embeddingProvider: overrides?.embeddingProvider || process.env.CRYSTAL_EMBEDDING_PROVIDER || "openai",
-    openaiApiKey,
-    openaiModel: overrides?.openaiModel || process.env.CRYSTAL_OPENAI_MODEL || "text-embedding-3-small",
-    ollamaHost: overrides?.ollamaHost || process.env.CRYSTAL_OLLAMA_HOST || "http://localhost:11434",
-    ollamaModel: overrides?.ollamaModel || process.env.CRYSTAL_OLLAMA_MODEL || "nomic-embed-text",
-    googleApiKey: overrides?.googleApiKey || process.env.GOOGLE_API_KEY,
-    googleModel: overrides?.googleModel || process.env.CRYSTAL_GOOGLE_MODEL || "text-embedding-004",
-    remoteUrl: overrides?.remoteUrl || process.env.CRYSTAL_REMOTE_URL,
-    remoteToken: overrides?.remoteToken || process.env.CRYSTAL_REMOTE_TOKEN
-  };
-}
-
-export {
-  Crystal,
-  resolveConfig
-};