@wipcomputer/memory-crystal 0.7.30 → 0.7.32

package/dist/installer.js

@@ -1,676 +0,0 @@
-import {
-  deployBackupScript,
-  deployCaptureScript,
-  getAgentId,
-  installCron,
-  ldmPaths,
-  loadAgentConfig,
-  saveAgentConfig,
-  scaffoldLdm
-} from "./chunk-EXEZZADG.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 = "standalone";
-  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 standalone.");
-    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}`);
-  }
-  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 === "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 (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
-};