@wipcomputer/memory-crystal 0.7.32 → 0.7.34-alpha.1

package/dist/mirror-sync.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import {
+  pullFileSync
+} from "./chunk-CGIDSAJB.js";
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-2GBYLMEF.js";
+import {
+  decryptJSON,
+  loadRelayKey
+} from "./chunk-D3MACYZ4.js";
+import {
+  ldmPaths,
+  resolveStatePath,
+  stateWritePath
+} from "./chunk-DFQ72B7M.js";
+
+// src/mirror-sync.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
+var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
+var _ldmPaths = ldmPaths();
+var MIRROR_STATE_PATH = resolveStatePath("mirror-sync-state.json");
+function loadState() {
+  try {
+    if (existsSync(MIRROR_STATE_PATH)) {
+      const state = JSON.parse(readFileSync(MIRROR_STATE_PATH, "utf-8"));
+      return {
+        lastSync: state.lastSync || null,
+        lastHash: state.lastHash || null,
+        lastSize: state.lastSize || null,
+        lastDeltaChunkId: state.lastDeltaChunkId || 0,
+        totalImported: state.totalImported || 0
+      };
+    }
+  } catch {
+  }
+  return { lastSync: null, lastHash: null, lastSize: null, lastDeltaChunkId: 0, totalImported: 0 };
+}
+function saveState(state) {
+  const writePath = stateWritePath("mirror-sync-state.json");
+  writeFileSync(writePath, JSON.stringify(state, null, 2));
+}
+async function pullDelta(force2) {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const listResp = await fetch(`${RELAY_URL}/pickup/mirror`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!listResp.ok) {
+    throw new Error(`Relay list failed: ${listResp.status} ${await listResp.text()}`);
+  }
+  const listData = await listResp.json();
+  if (listData.count === 0) {
+    process.stderr.write("[mirror-sync] no delta available\n");
+    return false;
+  }
+  const config = resolveConfig();
+  const crystal = new Crystal(config);
+  await crystal.init();
+  const state = loadState();
+  let totalImported = 0;
+  for (const blob of listData.blobs) {
+    try {
+      const blobResp = await fetch(`${RELAY_URL}/pickup/mirror/${blob.id}`, {
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      if (!blobResp.ok) {
+        process.stderr.write(`[mirror-sync] failed to fetch blob ${blob.id}: ${blobResp.status}
+`);
+        continue;
+      }
+      const encryptedText = await blobResp.text();
+      const encrypted = JSON.parse(encryptedText);
+      let delta;
+      try {
+        delta = decryptJSON(encrypted, relayKey);
+      } catch (err) {
+        process.stderr.write(`[mirror-sync] blob ${blob.id} failed verification: ${err.message} \u2014 DISCARDED
+`);
+        await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
+          method: "DELETE",
+          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+        });
+        continue;
+      }
+      if (!force2 && delta.maxId <= state.lastDeltaChunkId) {
+        process.stderr.write(`[mirror-sync] blob ${blob.id} already applied (maxId ${delta.maxId} <= watermark ${state.lastDeltaChunkId})
+`);
+        await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
+          method: "DELETE",
+          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+        });
+        continue;
+      }
+      const imported = crystal.importChunks(delta.chunks);
+      totalImported += imported;
+      if (delta.maxId > state.lastDeltaChunkId) {
+        state.lastDeltaChunkId = delta.maxId;
+      }
+      process.stderr.write(
+        `[mirror-sync] blob ${blob.id}: ${imported}/${delta.chunkCount} chunks imported (ID ${delta.sinceId + 1}..${delta.maxId}), pushed=${delta.pushedAt}
+`
+      );
+      await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+    } catch (err) {
+      process.stderr.write(`[mirror-sync] error processing blob ${blob.id}: ${err.message}
+`);
+    }
+  }
+  state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  state.totalImported += totalImported;
+  saveState(state);
+  if (totalImported > 0) {
+    process.stderr.write(`[mirror-sync] done: ${totalImported} chunks imported, watermark=${state.lastDeltaChunkId}
+`);
+  }
+  return totalImported > 0;
+}
+var args = process.argv.slice(2);
+if (args.includes("--status")) {
+  const state = loadState();
+  const paths = ldmPaths();
+  const hasDb = existsSync(paths.crystalDb);
+  console.log("Mirror sync status:");
+  console.log(`  Relay URL:       ${RELAY_URL || "(not set)"}`);
+  console.log(`  Local crystal:   ${hasDb ? paths.crystalDb : "(none)"}`);
+  console.log(`  Last sync:       ${state.lastSync || "never"}`);
+  console.log(`  Delta watermark: chunk ID ${state.lastDeltaChunkId}`);
+  console.log(`  Total imported:  ${state.totalImported}`);
+  process.exit(0);
+}
+var force = args.includes("--force");
+pullDelta(force).then(async (updated) => {
+  try {
+    const { imported, deleted } = await pullFileSync();
+    if (imported > 0 || deleted > 0) {
+      process.stderr.write(`[mirror-sync] file sync: ${imported} imported, ${deleted} deleted
+`);
+    }
+  } catch (err) {
+    process.stderr.write(`[mirror-sync] file sync failed (non-fatal): ${err.message}
+`);
+  }
+  if (updated) {
+    process.stderr.write("[mirror-sync] done\n");
+  }
+  process.exit(0);
+}).catch((err) => {
+  process.stderr.write(`[mirror-sync] error: ${err.message}
+`);
+  process.exit(1);
+});

package/dist/mlx-setup-XKU67WCT.js

@@ -0,0 +1,289 @@
+// src/mlx-setup.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { execSync } from "child_process";
+import { join } from "path";
+import { homedir } from "os";
+var HOME = homedir();
+var MLX_PORT = 18791;
+var MLX_MODEL = "mlx-community/Qwen2.5-3B-Instruct-4bit";
+var MLX_STATE_FILE = join(HOME, ".ldm", "state", "mlx-server.json");
+var MLX_PLIST_LABEL = "ai.ldm.mlx-server";
+var MLX_PLIST_PATH = join(HOME, "Library", "LaunchAgents", `${MLX_PLIST_LABEL}.plist`);
+var MLX_LOG_PATH = "/tmp/mlx-server.log";
+function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin") {
+    return arch === "arm64" ? "apple-silicon" : "intel-mac";
+  }
+  if (platform === "linux") return "linux";
+  return "other";
+}
+function canRunMlx() {
+  return detectPlatform() === "apple-silicon";
+}
+function findPython() {
+  const candidates = ["python3", "/opt/homebrew/bin/python3", "/usr/local/bin/python3"];
+  for (const cmd of candidates) {
+    try {
+      const version = execSync(`${cmd} --version 2>&1`, { encoding: "utf-8", timeout: 5e3 }).trim();
+      const match = version.match(/Python (\d+)\.(\d+)/);
+      if (match && parseInt(match[1]) >= 3 && parseInt(match[2]) >= 10) {
+        const realPath = execSync(`which ${cmd} 2>/dev/null`, { encoding: "utf-8", timeout: 3e3 }).trim();
+        return realPath || cmd;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function findInstaller() {
+  try {
+    execSync("uv --version 2>/dev/null", { encoding: "utf-8", timeout: 3e3 });
+    return "uv";
+  } catch {
+  }
+  try {
+    execSync("pip3 --version 2>/dev/null", { encoding: "utf-8", timeout: 3e3 });
+    return "pip3";
+  } catch {
+  }
+  return null;
+}
+function isMlxLmInstalled() {
+  try {
+    execSync('python3 -c "import mlx_lm" 2>/dev/null', { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installMlxLm(steps) {
+  const installer = findInstaller();
+  if (!installer) {
+    steps.push("No pip3 or uv found. Cannot install mlx-lm.");
+    return false;
+  }
+  const cmd = installer === "uv" ? "uv pip install mlx-lm" : "pip3 install mlx-lm";
+  steps.push(`Installing mlx-lm via ${installer}...`);
+  try {
+    execSync(cmd, { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
+    steps.push("mlx-lm installed successfully.");
+    return true;
+  } catch (err) {
+    if (installer === "pip3") {
+      try {
+        execSync("pip3 install --user mlx-lm", { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
+        steps.push("mlx-lm installed (--user) successfully.");
+        return true;
+      } catch {
+      }
+    }
+    steps.push(`mlx-lm install failed: ${err.message.slice(0, 200)}`);
+    return false;
+  }
+}
+function isServerRunning() {
+  try {
+    const state = loadState();
+    const port = state?.port || MLX_PORT;
+    execSync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${port}/v1/models`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createLaunchAgent(pythonPath, steps) {
+  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>${MLX_PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${pythonPath}</string>
+    <string>-m</string>
+    <string>mlx_lm.server</string>
+    <string>--model</string>
+    <string>${MLX_MODEL}</string>
+    <string>--port</string>
+    <string>${MLX_PORT}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${MLX_LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${MLX_LOG_PATH}</string>
+</dict>
+</plist>`;
+  try {
+    writeFileSync(MLX_PLIST_PATH, plist);
+    execSync(`launchctl load "${MLX_PLIST_PATH}" 2>/dev/null`, { timeout: 5e3 });
+    steps.push(`LaunchAgent installed at ${MLX_PLIST_PATH}`);
+    steps.push(`MLX server will start on port ${MLX_PORT}`);
+    return true;
+  } catch (err) {
+    steps.push(`LaunchAgent install failed: ${err.message}`);
+    return false;
+  }
+}
+function startServer(steps) {
+  try {
+    execSync(`launchctl kickstart -kp gui/$(id -u)/${MLX_PLIST_LABEL} 2>/dev/null`, { timeout: 1e4 });
+    steps.push("MLX server started.");
+    return true;
+  } catch {
+    steps.push("MLX server start failed. Check /tmp/mlx-server.log");
+    return false;
+  }
+}
+function stopServer() {
+  try {
+    execSync(`launchctl unload "${MLX_PLIST_PATH}" 2>/dev/null`, { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadState() {
+  try {
+    if (existsSync(MLX_STATE_FILE)) {
+      return JSON.parse(readFileSync(MLX_STATE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveState(state) {
+  const dir = join(HOME, ".ldm", "state");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(MLX_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+async function verifyServer(steps) {
+  const state = loadState();
+  const port = state?.port || MLX_PORT;
+  for (let i = 0; i < 15; i++) {
+    try {
+      const resp = await fetch(`http://localhost:${port}/v1/models`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        const model = data?.data?.[0]?.id || "unknown";
+        steps.push(`MLX server verified: ${model} on port ${port}`);
+        return true;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  steps.push("MLX server did not respond within 30 seconds. Check /tmp/mlx-server.log");
+  return false;
+}
+async function setupMlx(options) {
+  const steps = [];
+  const platform = detectPlatform();
+  if (platform !== "apple-silicon") {
+    steps.push(`Platform: ${platform}. MLX requires Apple Silicon. Skipping.`);
+    return { ok: false, steps };
+  }
+  steps.push("Platform: Apple Silicon detected.");
+  const pythonPath = findPython();
+  if (!pythonPath) {
+    steps.push("Python 3.10+ not found. Install via: brew install python3");
+    return { ok: false, steps };
+  }
+  steps.push(`Python: ${pythonPath}`);
+  if (!isMlxLmInstalled()) {
+    if (!options?.yes) {
+      steps.push("mlx-lm not installed. Run with --yes to auto-install, or: pip3 install mlx-lm");
+      return { ok: false, steps };
+    }
+    const installed = installMlxLm(steps);
+    if (!installed) return { ok: false, steps };
+  } else {
+    steps.push("mlx-lm: already installed.");
+  }
+  if (!existsSync(MLX_PLIST_PATH)) {
+    const created = createLaunchAgent(pythonPath, steps);
+    if (!created) return { ok: false, steps };
+  } else {
+    steps.push("LaunchAgent: already installed.");
+  }
+  saveState({
+    installed: true,
+    port: MLX_PORT,
+    model: MLX_MODEL,
+    pythonPath,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (!isServerRunning()) {
+    startServer(steps);
+    steps.push(`Waiting for model to load (~1.5 GB on first run)...`);
+    const verified = await verifyServer(steps);
+    if (!verified) {
+      steps.push("Server started but not yet responding. It may still be downloading the model.");
+      steps.push(`Check: tail -f ${MLX_LOG_PATH}`);
+    }
+  } else {
+    steps.push(`MLX server: already running on port ${MLX_PORT}`);
+  }
+  return { ok: true, steps };
+}
+function doctorCheck() {
+  const platform = detectPlatform();
+  if (platform !== "apple-silicon") {
+    return { status: "skip", detail: `${platform} (MLX requires Apple Silicon)` };
+  }
+  const state = loadState();
+  if (!state || !state.installed) {
+    return {
+      status: "warn",
+      detail: "not installed",
+      fix: "crystal init (will offer MLX setup)"
+    };
+  }
+  if (isServerRunning()) {
+    return { status: "ok", detail: `running on port ${state.port} (${state.model})` };
+  }
+  if (existsSync(MLX_PLIST_PATH)) {
+    return {
+      status: "warn",
+      detail: "installed but not running",
+      fix: `launchctl kickstart -kp gui/$(id -u)/${MLX_PLIST_LABEL}`
+    };
+  }
+  return {
+    status: "warn",
+    detail: "installed but LaunchAgent missing",
+    fix: "crystal init (will recreate LaunchAgent)"
+  };
+}
+var MLX_CONFIG = {
+  port: MLX_PORT,
+  model: MLX_MODEL,
+  plistPath: MLX_PLIST_PATH,
+  logPath: MLX_LOG_PATH,
+  stateFile: MLX_STATE_FILE
+};
+export {
+  MLX_CONFIG,
+  canRunMlx,
+  createLaunchAgent,
+  detectPlatform,
+  doctorCheck,
+  installMlxLm,
+  isMlxLmInstalled,
+  isServerRunning,
+  setupMlx,
+  startServer,
+  stopServer,
+  verifyServer
+};

package/dist/oc-backfill.d.ts

@@ -0,0 +1,19 @@
+interface ExtractedMessage {
+    role: string;
+    text: string;
+    timestamp: string;
+    sessionId: string;
+}
+/** Extract messages from an OpenClaw session JSONL file.
+ *  Reads from lastByteOffset for incremental processing.
+ *  Returns extracted messages and new byte offset. */
+declare function extractOpenClawMessages(filePath: string, lastByteOffset?: number): {
+    messages: ExtractedMessage[];
+    newByteOffset: number;
+};
+/** Detect whether a JSONL file is OpenClaw format.
+ *  Checks the first line for type:"session" with version field
+ *  (OpenClaw uses this header; Claude Code does not). */
+declare function isOpenClawJsonl(filePath: string): boolean;
+
+export { type ExtractedMessage, extractOpenClawMessages, isOpenClawJsonl };

package/dist/oc-backfill.js

@@ -0,0 +1,74 @@
+// src/oc-backfill.ts
+import { existsSync, statSync, openSync, readSync, closeSync } from "fs";
+function extractOpenClawMessages(filePath, lastByteOffset = 0) {
+  if (!existsSync(filePath)) {
+    return { messages: [], newByteOffset: 0 };
+  }
+  const fileSize = statSync(filePath).size;
+  if (lastByteOffset >= fileSize) {
+    return { messages: [], newByteOffset: fileSize };
+  }
+  const fd = openSync(filePath, "r");
+  const bufSize = fileSize - lastByteOffset;
+  const buf = Buffer.alloc(bufSize);
+  readSync(fd, buf, 0, bufSize, lastByteOffset);
+  closeSync(fd);
+  const lines = buf.toString("utf-8").split("\n").filter(Boolean);
+  const messages = [];
+  let sessionId = "unknown";
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "session" && obj.id) {
+        sessionId = obj.id;
+        continue;
+      }
+      if (obj.type !== "message") continue;
+      const msg = obj.message;
+      if (!msg || !msg.role) continue;
+      if (msg.role === "system" || msg.role === "tool") continue;
+      let text = "";
+      if (typeof msg.content === "string") {
+        text = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) {
+            parts.push(block.text);
+          }
+          if (block.type === "thinking" && block.thinking) {
+            parts.push(`[thinking] ${block.thinking}`);
+          }
+        }
+        text = parts.join("\n\n");
+      }
+      if (text.length < 20) continue;
+      messages.push({
+        role: msg.role,
+        text,
+        timestamp: obj.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: obj.id || sessionId
+      });
+    } catch {
+    }
+  }
+  return { messages, newByteOffset: fileSize };
+}
+function isOpenClawJsonl(filePath) {
+  try {
+    const fd = openSync(filePath, "r");
+    const buf = Buffer.alloc(Math.min(1024, statSync(filePath).size));
+    const bytesRead = readSync(fd, buf, 0, buf.length, 0);
+    closeSync(fd);
+    const firstLine = buf.toString("utf-8", 0, bytesRead).split("\n")[0];
+    if (!firstLine) return false;
+    const obj = JSON.parse(firstLine);
+    return obj.type === "session" && typeof obj.version === "number";
+  } catch {
+    return false;
+  }
+}
+export {
+  extractOpenClawMessages,
+  isOpenClawJsonl
+};

package/dist/openclaw.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    register(api: any): void;
+};
+
+export { _default as default };