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

package/dist/installer.js

@@ -0,0 +1,772 @@
+import {
+  deployBackupScript,
+  deployCaptureScript,
+  getAgentId,
+  installCron,
+  ldmPaths,
+  loadAgentConfig,
+  saveAgentConfig,
+  scaffoldLdm
+} from "./chunk-DFQ72B7M.js";
+
+// src/installer.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, copyFileSync, readdirSync, statSync } 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");
+var OC_ROOT = join(HOME, ".openclaw");
+var CC_SETTINGS = join(HOME, ".claude", "settings.json");
+var CC_MCP = join(HOME, ".claude", ".mcp.json");
+var OC_MCP = join(OC_ROOT, ".mcp.json");
+function readVersion(pkgPath) {
+  try {
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      return pkg.version || null;
+    }
+  } catch {
+  }
+  return null;
+}
+function getRepoRoot() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  let dir = thisDir;
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@wipcomputer/memory-crystal") return dir;
+      } catch {
+      }
+    }
+    dir = dirname(dir);
+  }
+  return dirname(thisDir);
+}
+function semverCompare(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+function getLatestNpmVersion() {
+  const names = ["@wipcomputer/memory-crystal", "memory-crystal"];
+  for (const name of names) {
+    try {
+      const v = execSync(`npm view ${name} version 2>/dev/null`, { encoding: "utf-8", timeout: 1e4 }).trim();
+      if (v) return v;
+    } catch {
+    }
+  }
+  return null;
+}
+function detectInstallState() {
+  const ldmExtDir = join(LDM_ROOT, "extensions", "memory-crystal");
+  const ocExtDir = join(OC_ROOT, "extensions", "memory-crystal");
+  const paths = ldmPaths();
+  const installedVersion = readVersion(join(ldmExtDir, "package.json"));
+  const repoRoot = getRepoRoot();
+  let repoVersion = readVersion(join(repoRoot, "package.json")) || "0.0.0";
+  const npmVersion = getLatestNpmVersion();
+  if (npmVersion && semverCompare(npmVersion, repoVersion) > 0) repoVersion = npmVersion;
+  const ccHookDeployed = existsSync(join(ldmExtDir, "dist", "cc-hook.js"));
+  let ccHookConfigured = false;
+  try {
+    if (existsSync(CC_SETTINGS)) {
+      const settings = JSON.parse(readFileSync(CC_SETTINGS, "utf-8"));
+      const stopHooks = settings?.hooks?.Stop;
+      if (Array.isArray(stopHooks)) {
+        ccHookConfigured = stopHooks.some((entry) => {
+          const hooks = entry?.hooks;
+          if (!Array.isArray(hooks)) return false;
+          return hooks.some((h) => h?.command?.includes("memory-crystal") && h?.command?.includes("cc-hook"));
+        });
+      }
+    }
+  } catch {
+  }
+  let mcpRegistered = false;
+  for (const mcpPath of [CC_MCP, OC_MCP, join(process.cwd(), ".mcp.json")]) {
+    try {
+      if (existsSync(mcpPath)) {
+        const config = JSON.parse(readFileSync(mcpPath, "utf-8"));
+        if (config?.mcpServers?.["memory-crystal"]) {
+          mcpRegistered = true;
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  if (!mcpRegistered) {
+    try {
+      execSync("claude mcp get memory-crystal 2>/dev/null", { encoding: "utf-8", timeout: 5e3, stdio: "pipe" });
+      mcpRegistered = true;
+    } catch {
+    }
+  }
+  const ocDetected = existsSync(join(OC_ROOT, "openclaw.json"));
+  const ocPluginDeployed = existsSync(join(ocExtDir, "dist", "openclaw.js"));
+  let cronInstalled = false;
+  try {
+    const crontab = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
+    cronInstalled = crontab.includes("crystal-capture");
+  } catch {
+  }
+  const role = "core";
+  const relayKeyExists = existsSync(join(LDM_ROOT, "secrets", "crystal-relay-key"));
+  return {
+    ldmExists: existsSync(LDM_ROOT),
+    crystalDbExists: existsSync(paths.crystalDb),
+    ccHookDeployed,
+    ccHookConfigured,
+    mcpRegistered,
+    ocDetected,
+    ocPluginDeployed,
+    cronInstalled,
+    installedVersion,
+    repoVersion,
+    needsUpdate: installedVersion !== null && installedVersion !== repoVersion,
+    role,
+    relayKeyExists
+  };
+}
+function deployToLdm() {
+  const repoRoot = getRepoRoot();
+  const sourceDir = join(repoRoot, "dist");
+  const extDir = join(LDM_ROOT, "extensions", "memory-crystal");
+  const destDist = join(extDir, "dist");
+  if (!existsSync(sourceDir)) {
+    throw new Error(`dist/ not found at ${sourceDir}. Run "npm run build" first.`);
+  }
+  mkdirSync(destDist, { recursive: true });
+  const distFiles = readdirSync(sourceDir);
+  for (const file of distFiles) {
+    const srcPath = join(sourceDir, file);
+    const destPath = join(destDist, file);
+    const stat = statSync(srcPath);
+    if (stat.isFile()) {
+      copyFileSync(srcPath, destPath);
+    } else if (stat.isDirectory()) {
+      cpSync(srcPath, destPath, { recursive: true });
+    }
+  }
+  copyFileSync(join(repoRoot, "package.json"), join(extDir, "package.json"));
+  const pluginJson = join(repoRoot, "openclaw.plugin.json");
+  if (existsSync(pluginJson)) {
+    copyFileSync(pluginJson, join(extDir, "openclaw.plugin.json"));
+  }
+  const skillsDir = join(repoRoot, "skills");
+  if (existsSync(skillsDir)) {
+    cpSync(skillsDir, join(extDir, "skills"), { recursive: true });
+  }
+  const version = readVersion(join(extDir, "package.json")) || "unknown";
+  return { extensionDir: extDir, version };
+}
+function installLdmDeps() {
+  const extDir = join(LDM_ROOT, "extensions", "memory-crystal");
+  if (!existsSync(join(extDir, "package.json"))) {
+    throw new Error("package.json not found in LDM extension dir. Deploy first.");
+  }
+  execSync("npm install --omit=dev", {
+    cwd: extDir,
+    encoding: "utf-8",
+    stdio: "pipe",
+    timeout: 12e4
+  });
+}
+function deployToOpenClaw() {
+  const repoRoot = getRepoRoot();
+  const sourceDir = join(repoRoot, "dist");
+  const extDir = join(OC_ROOT, "extensions", "memory-crystal");
+  const destDist = join(extDir, "dist");
+  if (!existsSync(sourceDir)) {
+    throw new Error(`dist/ not found at ${sourceDir}. Run "npm run build" first.`);
+  }
+  mkdirSync(destDist, { recursive: true });
+  const distFiles = readdirSync(sourceDir);
+  for (const file of distFiles) {
+    const srcPath = join(sourceDir, file);
+    const destPath = join(destDist, file);
+    const stat = statSync(srcPath);
+    if (stat.isFile()) {
+      copyFileSync(srcPath, destPath);
+    } else if (stat.isDirectory()) {
+      cpSync(srcPath, destPath, { recursive: true });
+    }
+  }
+  copyFileSync(join(repoRoot, "package.json"), join(extDir, "package.json"));
+  const pluginJson = join(repoRoot, "openclaw.plugin.json");
+  if (existsSync(pluginJson)) {
+    copyFileSync(pluginJson, join(extDir, "openclaw.plugin.json"));
+  }
+  const skillsDir = join(repoRoot, "skills");
+  if (existsSync(skillsDir)) {
+    cpSync(skillsDir, join(extDir, "skills"), { recursive: true });
+  }
+  const version = readVersion(join(extDir, "package.json")) || "unknown";
+  return { extensionDir: extDir, version };
+}
+function installOcDeps() {
+  const extDir = join(OC_ROOT, "extensions", "memory-crystal");
+  if (!existsSync(join(extDir, "package.json"))) {
+    throw new Error("package.json not found in OC extension dir. Deploy first.");
+  }
+  execSync("npm install --omit=dev", {
+    cwd: extDir,
+    encoding: "utf-8",
+    stdio: "pipe",
+    timeout: 12e4
+  });
+}
+function configureCCHook() {
+  const hookCommand = `node ${join(LDM_ROOT, "extensions", "memory-crystal", "dist", "cc-hook.js")}`;
+  let settings = {};
+  if (existsSync(CC_SETTINGS)) {
+    try {
+      settings = JSON.parse(readFileSync(CC_SETTINGS, "utf-8"));
+    } catch {
+      throw new Error(`~/.claude/settings.json exists but is not valid JSON. Fix it manually before proceeding.`);
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.Stop)) settings.hooks.Stop = [];
+  const existingIdx = settings.hooks.Stop.findIndex((entry) => {
+    const hooks = entry?.hooks;
+    if (!Array.isArray(hooks)) return false;
+    return hooks.some((h) => h?.command?.includes("memory-crystal") || h?.command?.includes("cc-hook"));
+  });
+  const hookEntry = {
+    hooks: [{
+      type: "command",
+      command: hookCommand,
+      timeout: 30
+    }]
+  };
+  if (existingIdx >= 0) {
+    settings.hooks.Stop[existingIdx] = hookEntry;
+  } else {
+    settings.hooks.Stop.push(hookEntry);
+  }
+  mkdirSync(join(HOME, ".claude"), { recursive: true });
+  writeFileSync(CC_SETTINGS, JSON.stringify(settings, null, 2) + "\n");
+}
+function registerMCPServer() {
+  const mcpServerPath = join(LDM_ROOT, "extensions", "memory-crystal", "dist", "mcp-server.js");
+  const addCmd = `claude mcp add --scope user -e OPENCLAW_HOME=${OC_ROOT} memory-crystal -- node "${mcpServerPath}"`;
+  try {
+    execSync(addCmd, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 15e3
+    });
+    return;
+  } catch (err) {
+    const output = (err.stderr || "") + (err.stdout || "");
+    if (output.includes("already exists")) {
+      try {
+        execSync("claude mcp remove memory-crystal --scope user", { encoding: "utf-8", stdio: "pipe", timeout: 1e4 });
+        execSync(addCmd, { encoding: "utf-8", stdio: "pipe", timeout: 15e3 });
+      } catch {
+      }
+      return;
+    }
+  }
+  let config = {};
+  if (existsSync(CC_MCP)) {
+    try {
+      config = JSON.parse(readFileSync(CC_MCP, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["memory-crystal"] = {
+    command: "node",
+    args: [mcpServerPath],
+    env: { OPENCLAW_HOME: OC_ROOT }
+  };
+  mkdirSync(join(HOME, ".claude"), { recursive: true });
+  writeFileSync(CC_MCP, JSON.stringify(config, null, 2) + "\n");
+}
+function registerOcMCPServer() {
+  const mcpServerPath = join(OC_ROOT, "extensions", "memory-crystal", "dist", "mcp-server.js");
+  let config = {};
+  if (existsSync(OC_MCP)) {
+    try {
+      config = JSON.parse(readFileSync(OC_MCP, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["memory-crystal"] = {
+    command: "node",
+    args: [mcpServerPath],
+    env: { OPENCLAW_HOME: OC_ROOT }
+  };
+  writeFileSync(OC_MCP, JSON.stringify(config, null, 2) + "\n");
+}
+function backupCrystalDb() {
+  const paths = ldmPaths();
+  const dbPath = paths.crystalDb;
+  if (!existsSync(dbPath)) {
+    throw new Error(`crystal.db not found at ${dbPath}`);
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupPath = `${dbPath}.pre-update-${timestamp}`;
+  copyFileSync(dbPath, backupPath);
+  const walPath = dbPath + "-wal";
+  const shmPath = dbPath + "-shm";
+  if (existsSync(walPath)) copyFileSync(walPath, backupPath + "-wal");
+  if (existsSync(shmPath)) copyFileSync(shmPath, backupPath + "-shm");
+  const origSize = statSync(dbPath).size;
+  const backupSize = statSync(backupPath).size;
+  if (backupSize !== origSize) {
+    throw new Error(`Backup size mismatch: original ${origSize}, backup ${backupSize}`);
+  }
+  return backupPath;
+}
+async function verifyCrystalDbReadable() {
+  const paths = ldmPaths();
+  const dbPath = paths.crystalDb;
+  if (!existsSync(dbPath)) return;
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const row = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+    if (typeof row.count !== "number") {
+      throw new Error("chunks table returned unexpected data");
+    }
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table'"
+    ).all();
+    const tableNames = tables.map((t) => t.name);
+    if (!tableNames.includes("chunks")) {
+      throw new Error("chunks table missing from database");
+    }
+  } finally {
+    db.close();
+  }
+}
+function formatUpdateSummary(oldVersion, newVersion) {
+  const lines = [];
+  lines.push(`Updating v${oldVersion} -> v${newVersion}`);
+  lines.push("");
+  lines.push("What will be updated:");
+  lines.push("  - Code in ~/.ldm/extensions/memory-crystal/dist/");
+  lines.push("  - Skills in ~/.ldm/extensions/memory-crystal/skills/");
+  lines.push("  - package.json (version tracking)");
+  lines.push("");
+  lines.push("What will NOT be touched:");
+  lines.push("  - ~/.ldm/memory/crystal.db (your data)");
+  lines.push("  - ~/.ldm/state/* (watermarks, role)");
+  lines.push("  - ~/.ldm/secrets/* (relay key)");
+  lines.push("  - ~/.ldm/agents/* (agent data)");
+  return lines.join("\n");
+}
+function ldmCliAvailable() {
+  try {
+    execSync("ldm --version", { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function bootstrapLdmOs(steps) {
+  try {
+    steps.push("Installing LDM OS infrastructure...");
+    execSync("npm install -g @wipcomputer/wip-ldm-os", { stdio: "pipe", timeout: 12e4 });
+    execSync("ldm --version", { stdio: "pipe", timeout: 5e3 });
+    steps.push("LDM OS installed.");
+    return true;
+  } catch {
+    steps.push("LDM OS install skipped (npm offline or permissions issue). Using core mode.");
+    return false;
+  }
+}
+function runLdmInstall(repoDir) {
+  const steps = [];
+  try {
+    execSync("ldm init --yes --none", { stdio: "pipe", timeout: 3e4 });
+    steps.push("LDM initialized via ldm CLI");
+  } catch (err) {
+    const msg = (err.stderr || err.message || "").toString().trim();
+    if (!msg.includes("already")) {
+      steps.push(`ldm init warning: ${msg.slice(0, 120)}`);
+    }
+  }
+  try {
+    execSync(`ldm install "${repoDir}"`, { stdio: "pipe", timeout: 6e4 });
+    steps.push("Generic deployment handled by ldm install (extensions, MCP, hooks)");
+    return { ok: true, steps };
+  } catch (err) {
+    const msg = (err.stderr || err.message || "").toString().trim();
+    steps.push(`ldm install failed: ${msg.slice(0, 200)}`);
+    return { ok: false, steps };
+  }
+}
+async function runInstallOrUpdate(options) {
+  const agentId = options.agentId || getAgentId();
+  const state = detectInstallState();
+  const steps = [];
+  const deployedTo = [];
+  let dbStatus = "none";
+  let chunkCount = 0;
+  const isFresh = !state.ldmExists || state.installedVersion === null;
+  const isUpdate = !isFresh && state.needsUpdate;
+  if (!isFresh && !isUpdate) {
+    return {
+      action: "up-to-date",
+      version: state.repoVersion,
+      deployedTo: [],
+      steps: [`Already at v${state.repoVersion}. Nothing to do.`]
+    };
+  }
+  if (isUpdate && state.installedVersion) {
+    const npmV = getLatestNpmVersion();
+    if (npmV && semverCompare(npmV, state.installedVersion) > 0) {
+      steps.push(`Upgrading v${state.installedVersion} -> v${npmV} via npm...`);
+      try {
+        execSync("npm install -g @wipcomputer/memory-crystal 2>&1", { encoding: "utf-8", timeout: 6e4, stdio: "pipe" });
+        steps.push(`Installed @wipcomputer/memory-crystal@${npmV}`);
+        steps.push("Continuing with updated code...");
+      } catch (err) {
+        steps.push(`npm upgrade failed: ${err.message}. Continuing with local code.`);
+      }
+    }
+  }
+  let hasLdmCli = ldmCliAvailable();
+  if (!hasLdmCli) {
+    hasLdmCli = bootstrapLdmOs(steps);
+  }
+  let ldmDelegated = false;
+  if (hasLdmCli) {
+    steps.push("LDM OS detected. Using ldm install for deployment...");
+    const repoRoot = getRepoRoot();
+    const delegateResult = runLdmInstall(repoRoot);
+    steps.push(...delegateResult.steps);
+    if (delegateResult.ok) {
+      ldmDelegated = true;
+      const ldmExtDir = join(LDM_ROOT, "extensions", "memory-crystal");
+      if (existsSync(ldmExtDir)) deployedTo.push(ldmExtDir);
+      const ocExtDir = join(OC_ROOT, "extensions", "memory-crystal");
+      if (existsSync(ocExtDir)) deployedTo.push(ocExtDir);
+    }
+  }
+  if (ldmDelegated) {
+    steps.push("Scaffold + agent config handled by ldm CLI");
+  } else {
+    scaffoldLdm(agentId);
+    steps.push(`LDM scaffolded for agent "${agentId}"`);
+    const existingCfg = loadAgentConfig(agentId);
+    if (existingCfg && !existingCfg.agentId) {
+      existingCfg.agentId = agentId;
+      saveAgentConfig(agentId, existingCfg);
+      steps.push(`Added agentId "${agentId}" to existing config.json`);
+    } else if (!existingCfg) {
+      const harness = agentId.startsWith("oc-") ? "openclaw" : "claude-code-cli";
+      saveAgentConfig(agentId, {
+        agentId,
+        agent: agentId.startsWith("oc-") ? agentId.replace(/^oc-/, "").replace(/-[^-]+$/, "") : "cc",
+        harness,
+        created: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+      });
+      steps.push(`Created config.json for agent "${agentId}"`);
+    }
+  }
+  if (state.crystalDbExists) {
+    try {
+      const { default: Database } = await import("better-sqlite3");
+      const db = new Database(ldmPaths().crystalDb, { readonly: true });
+      const row = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+      chunkCount = row.count;
+      db.close();
+      dbStatus = "existing";
+      steps.push(`Existing database found: ${chunkCount.toLocaleString()} chunks in crystal.db`);
+    } catch {
+      dbStatus = "existing";
+      steps.push("Existing database found (could not read chunk count)");
+    }
+    try {
+      const backupPath = backupCrystalDb();
+      steps.push(`Database backed up to ${backupPath}`);
+    } catch (err) {
+      steps.push(`Database backup FAILED: ${err.message}`);
+      return {
+        action: "up-to-date",
+        version: state.repoVersion,
+        deployedTo: [],
+        steps: [...steps, "Aborted. Fix the backup issue before retrying."],
+        dbStatus
+      };
+    }
+    try {
+      await verifyCrystalDbReadable();
+      steps.push("Database read verification passed");
+    } catch (err) {
+      steps.push(`Database read verification FAILED: ${err.message}`);
+      return {
+        action: "up-to-date",
+        version: state.repoVersion,
+        deployedTo: [],
+        steps: [...steps, "Aborted. New code cannot read existing database."],
+        dbStatus
+      };
+    }
+  } else if (options.importDb) {
+    const importPath = options.importDb;
+    if (!existsSync(importPath)) {
+      steps.push(`Import path not found: ${importPath}`);
+    } else {
+      try {
+        const paths = ldmPaths();
+        mkdirSync(join(paths.root, "memory"), { recursive: true });
+        copyFileSync(importPath, paths.crystalDb);
+        const { default: Database } = await import("better-sqlite3");
+        const db = new Database(paths.crystalDb, { readonly: true });
+        const row = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+        chunkCount = row.count;
+        db.close();
+        dbStatus = "imported";
+        steps.push(`Database imported: ${chunkCount.toLocaleString()} chunks from ${importPath}`);
+      } catch (err) {
+        steps.push(`Database import failed: ${err.message}`);
+      }
+    }
+  } else {
+    dbStatus = "fresh";
+    steps.push("No existing database. A new one will be created on first capture.");
+  }
+  if (ldmDelegated) {
+    const repoRoot = getRepoRoot();
+    const ldmExtDir = join(LDM_ROOT, "extensions", "memory-crystal");
+    if (existsSync(ldmExtDir)) copyFileSync(join(repoRoot, "package.json"), join(ldmExtDir, "package.json"));
+    const ocExtDir = join(OC_ROOT, "extensions", "memory-crystal");
+    if (existsSync(ocExtDir)) copyFileSync(join(repoRoot, "package.json"), join(ocExtDir, "package.json"));
+    steps.push(`Version synced to v${readVersion(join(repoRoot, "package.json")) || "unknown"}`);
+  }
+  if (!ldmDelegated) {
+    const ldmResult = deployToLdm();
+    steps.push(`Code deployed to ${ldmResult.extensionDir}`);
+    deployedTo.push(ldmResult.extensionDir);
+    try {
+      installLdmDeps();
+      steps.push("Dependencies installed (LDM)");
+    } catch (err) {
+      steps.push(`Dependencies install failed (LDM): ${err.message}`);
+    }
+    try {
+      configureCCHook();
+      steps.push("CC Stop hook configured in ~/.claude/settings.json");
+    } catch (err) {
+      steps.push(`CC Stop hook config failed: ${err.message}`);
+    }
+    if (!state.mcpRegistered || isUpdate) {
+      try {
+        registerMCPServer();
+        steps.push("MCP server registered with Claude Code");
+      } catch (err) {
+        steps.push(`MCP registration failed: ${err.message}`);
+      }
+    } else {
+      steps.push("MCP server already registered");
+    }
+  }
+  try {
+    deployCaptureScript();
+    steps.push("Capture script deployed");
+  } catch (err) {
+    steps.push(`Capture script failed: ${err.message}`);
+  }
+  if (!state.cronInstalled || isFresh) {
+    try {
+      installCron();
+      steps.push("Cron job installed (every minute)");
+    } catch (err) {
+      steps.push(`Cron install failed: ${err.message}`);
+    }
+  } else {
+    steps.push("Cron job already installed");
+  }
+  try {
+    deployBackupScript();
+    steps.push("Backup script deployed");
+  } catch (err) {
+    steps.push(`Backup script failed: ${err.message}`);
+  }
+  try {
+    const { canRunMlx, isMlxLmInstalled, isServerRunning } = await import("./mlx-setup-XKU67WCT.js");
+    if (canRunMlx()) {
+      if (isServerRunning()) {
+        steps.push("MLX LLM: already running");
+      } else if (isMlxLmInstalled()) {
+        steps.push("MLX LLM: installed but not running. Start with: launchctl kickstart -kp gui/$(id -u)/ai.ldm.mlx-server");
+      } else {
+        steps.push('MLX LLM: Apple Silicon detected. Run "crystal mlx setup" to install local LLM for free, fast, offline search quality.');
+      }
+    }
+  } catch {
+  }
+  if (!ldmDelegated && state.ocDetected) {
+    try {
+      const ocResult = deployToOpenClaw();
+      steps.push(`OC plugin deployed to ${ocResult.extensionDir}`);
+      deployedTo.push(ocResult.extensionDir);
+    } catch (err) {
+      steps.push(`OC plugin deploy failed: ${err.message}`);
+    }
+    try {
+      installOcDeps();
+      steps.push("Dependencies installed (OC)");
+    } catch (err) {
+      steps.push(`Dependencies install failed (OC): ${err.message}`);
+    }
+    try {
+      registerOcMCPServer();
+      steps.push("OC MCP server config updated");
+    } catch (err) {
+      steps.push(`OC MCP config failed: ${err.message}`);
+    }
+  }
+  if (!options.role && process.stdin.isTTY) {
+    const { createInterface } = await import("readline");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question("\n  Is this your primary machine (always on), or adding a device?\n  [1] Primary (Crystal Core)\n  [2] Adding a device (Crystal Node)\n  > ", resolve);
+    });
+    rl.close();
+    if (answer.trim() === "2") {
+      options.role = "node";
+      const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+      options.pairCode = await new Promise((resolve) => {
+        rl2.question('  Pairing code from Core (run "crystal pair" on Core): ', resolve);
+      });
+      rl2.close();
+    } else {
+      options.role = "core";
+    }
+  }
+  if (options.role === "core") {
+    try {
+      const { promoteToCore } = await import("./role.js");
+      promoteToCore();
+      steps.push("Role set to Core");
+    } catch (err) {
+      steps.push(`Role setup failed: ${err.message}`);
+    }
+  } else if (options.role === "node") {
+    try {
+      const { demoteToNode } = await import("./role.js");
+      demoteToNode();
+      steps.push("Role set to Node");
+    } catch (err) {
+      steps.push(`Role setup failed: ${err.message}`);
+    }
+  }
+  if (options.pairCode) {
+    try {
+      const { pairReceive } = await import("./pair.js");
+      pairReceive(options.pairCode);
+      steps.push("Pairing code accepted");
+    } catch (err) {
+      steps.push(`Pairing failed: ${err.message}`);
+    }
+  }
+  if (options.role === "node" || process.env.CRYSTAL_RELAY_URL) {
+    const secretsDir = join(LDM_ROOT, "secrets");
+    const envPath = join(secretsDir, "crystal-relay.env");
+    if (!existsSync(envPath)) {
+      const relayUrl = "https://memory-crystal-relay.wipcomputer.workers.dev";
+      let token = "";
+      try {
+        const saTokenPath = join(OC_ROOT, "secrets", "op-sa-token");
+        if (existsSync(saTokenPath)) {
+          const saToken = readFileSync(saTokenPath, "utf8").trim();
+          token = execSync(
+            `OP_SERVICE_ACCOUNT_TOKEN=${saToken} op item get "Memory Crystal Relay Auth Tokens" --vault "Agent Secrets" --fields label=${agentId}-token --reveal 2>/dev/null`,
+            { encoding: "utf8", timeout: 15e3 }
+          ).trim();
+        }
+      } catch {
+      }
+      if (!token && process.stdin.isTTY) {
+        const { createInterface } = await import("readline");
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        token = await new Promise((resolve) => {
+          rl.question("  Relay auth token: ", resolve);
+        });
+        rl.close();
+        token = token.trim();
+      }
+      if (token) {
+        mkdirSync(secretsDir, { recursive: true });
+        writeFileSync(envPath, `export CRYSTAL_RELAY_URL=${relayUrl}
+export CRYSTAL_RELAY_TOKEN=${token}
+export CRYSTAL_AGENT_ID=${agentId}
+`);
+        process.env.CRYSTAL_RELAY_URL = relayUrl;
+        process.env.CRYSTAL_RELAY_TOKEN = token;
+        steps.push("Relay config written to ~/.ldm/secrets/crystal-relay.env");
+        const shellProfile = join(HOME, ".zshrc");
+        const sourceLine = `source ${envPath}`;
+        let alreadySourced = false;
+        try {
+          alreadySourced = readFileSync(shellProfile, "utf8").includes(sourceLine);
+        } catch {
+        }
+        if (!alreadySourced && process.stdin.isTTY) {
+          const { createInterface: createRL } = await import("readline");
+          const rl2 = createRL({ input: process.stdin, output: process.stdout });
+          const ans = await new Promise((resolve) => {
+            rl2.question("  Add relay config to ~/.zshrc? [Y/n] ", resolve);
+          });
+          rl2.close();
+          if (ans.trim().toLowerCase() !== "n") {
+            const { appendFileSync } = await import("fs");
+            appendFileSync(shellProfile, `
+# Memory Crystal relay
+${sourceLine}
+`);
+            steps.push("Added relay source to ~/.zshrc");
+          }
+        }
+      } else {
+        steps.push("No relay token. Set CRYSTAL_RELAY_TOKEN manually.");
+      }
+    } else {
+      steps.push("Relay config exists at ~/.ldm/secrets/crystal-relay.env");
+    }
+  }
+  if (hasLdmCli) {
+    steps.push('Tip: Run "ldm install" to see more components you can add.');
+  } else if (!ldmDelegated) {
+    steps.push("Tip: Install LDM OS for more components: npm install -g @wipcomputer/wip-ldm-os");
+  }
+  return {
+    action: isFresh ? "installed" : "updated",
+    version: state.repoVersion,
+    deployedTo,
+    steps,
+    dbStatus,
+    chunkCount
+  };
+}
+export {
+  backupCrystalDb,
+  configureCCHook,
+  deployToLdm,
+  deployToOpenClaw,
+  detectInstallState,
+  formatUpdateSummary,
+  installLdmDeps,
+  installOcDeps,
+  registerMCPServer,
+  registerOcMCPServer,
+  runInstallOrUpdate,
+  verifyCrystalDbReadable
+};