jorgex-stack 1.9.61 → 1.9.63

package/dist/chunk-B76ZJXXD.js

@@ -1,989 +0,0 @@
-#!/usr/bin/env node
-import {
-  HOME,
-  dataDir
-} from "./chunk-NQZVJFV2.js";
-
-// src/lib/official-engram-setup.ts
-import fs3 from "fs";
-import path3 from "path";
-import { execFileSync } from "child_process";
-
-// src/lib/backup.ts
-import fs2 from "fs";
-import path2 from "path";
-import crypto from "crypto";
-
-// src/lib/fsx.ts
-import fs from "fs";
-import path from "path";
-function readTextIfExists(file) {
-  try {
-    return fs.readFileSync(file, "utf8");
-  } catch {
-    return null;
-  }
-}
-function ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-}
-var tmpCounter = 0;
-function tmpPath(target) {
-  return path.join(path.dirname(target), `.jorgex-${process.pid}-${tmpCounter++}.tmp`);
-}
-function renameInto(tmp, target) {
-  try {
-    fs.renameSync(tmp, target);
-  } catch (err) {
-    fs.rmSync(tmp, { force: true });
-    throw err;
-  }
-}
-function writeText(file, content, mode) {
-  ensureDir(path.dirname(file));
-  const tmp = tmpPath(file);
-  fs.writeFileSync(tmp, content, { encoding: "utf8", mode });
-  renameInto(tmp, file);
-}
-function copyFile(source, target) {
-  ensureDir(path.dirname(target));
-  const tmp = tmpPath(target);
-  fs.copyFileSync(source, tmp);
-  renameInto(tmp, target);
-}
-function isContainedIn(child, root) {
-  const rel = path.relative(path.resolve(root), path.resolve(child));
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
-}
-function pruneEmptyDirs(file, root) {
-  let dir = path.dirname(file);
-  while (dir.startsWith(root) && dir !== root) {
-    try {
-      if (fs.readdirSync(dir).length > 0) return;
-      fs.rmdirSync(dir);
-    } catch {
-      return;
-    }
-    dir = path.dirname(dir);
-  }
-}
-function sameFileContent(a, b) {
-  try {
-    const bufA = fs.readFileSync(a);
-    const bufB = fs.readFileSync(b);
-    return bufA.equals(bufB);
-  } catch {
-    return false;
-  }
-}
-function listFilesRecursive(dir) {
-  const out = [];
-  if (!fs.existsSync(dir)) return out;
-  const walk = (d) => {
-    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-      const p = path.join(d, entry.name);
-      if (entry.isDirectory()) walk(p);
-      else out.push(p);
-    }
-  };
-  walk(dir);
-  return out;
-}
-
-// src/lib/backup.ts
-var KEEP_BACKUPS = 10;
-function backupsRoot() {
-  return path2.join(dataDir(), "backups");
-}
-function compositeChecksum(files) {
-  const hash = crypto.createHash("sha256");
-  for (const file of [...files].sort()) {
-    const content = crypto.createHash("sha256").update(fs2.readFileSync(file)).digest("hex");
-    hash.update(`${file}:${content}
-`);
-  }
-  return hash.digest("hex");
-}
-function createBackup(files, label, root = backupsRoot()) {
-  const existing = [...new Set(files)].filter((f) => fs2.existsSync(f));
-  if (existing.length === 0) return null;
-  const checksum = compositeChecksum(existing);
-  const latest = listBackups(root)[0];
-  if (latest?.checksum === checksum) return latest;
-  const base = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${label}`;
-  let id = base;
-  let dir = path2.join(root, id);
-  for (let n = 1; fs2.existsSync(dir); n++) {
-    id = `${base}-${n}`;
-    dir = path2.join(root, id);
-  }
-  ensureDir(path2.join(dir, "files"));
-  const entries = existing.map((original, i) => {
-    const stored = path2.join(dir, "files", `${String(i).padStart(4, "0")}-${path2.basename(original)}`);
-    fs2.copyFileSync(original, stored);
-    return { original, stored };
-  });
-  const info = { id, label, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files: entries, checksum };
-  writeText(path2.join(dir, "manifest.json"), JSON.stringify(info, null, 2) + "\n");
-  pruneBackups(root);
-  return info;
-}
-function listBackups(root = backupsRoot()) {
-  if (!fs2.existsSync(root)) return [];
-  const infos = [];
-  for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const manifest = readTextIfExists(path2.join(root, entry.name, "manifest.json"));
-    if (manifest === null) continue;
-    try {
-      infos.push(JSON.parse(manifest));
-    } catch {
-      infos.push({ id: entry.name, label: "(manifest corrupto)", createdAt: "", files: [] });
-    }
-  }
-  return infos.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}
-function restoreBackup(id, root = backupsRoot(), boundary = HOME) {
-  const info = listBackups(root).find((b) => b.id === id);
-  if (!info) throw new Error(`Backup no encontrado: ${id}`);
-  const boundaryResolved = path2.resolve(boundary);
-  const hasSymlinkAncestor = (file) => {
-    let dir = path2.dirname(path2.resolve(file));
-    while (dir !== boundaryResolved && isContainedIn(dir, boundaryResolved)) {
-      try {
-        if (fs2.lstatSync(dir).isSymbolicLink()) return true;
-      } catch (error) {
-        const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
-        if (code !== "ENOENT") return true;
-      }
-      const parent = path2.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    return false;
-  };
-  let restored = 0;
-  for (const { original, stored } of info.files) {
-    if (!fs2.existsSync(stored)) continue;
-    if (!isContainedIn(original, boundary)) continue;
-    try {
-      if (fs2.lstatSync(original).isSymbolicLink()) continue;
-    } catch (error) {
-      const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
-      if (code !== "ENOENT") continue;
-    }
-    if (hasSymlinkAncestor(original)) continue;
-    ensureDir(path2.dirname(original));
-    fs2.copyFileSync(stored, original);
-    restored++;
-  }
-  return restored;
-}
-function pruneBackups(root) {
-  const all = listBackups(root);
-  for (const old of all.slice(KEEP_BACKUPS)) {
-    fs2.rmSync(path2.join(root, old.id), { recursive: true, force: true });
-  }
-}
-
-// src/lib/official-engram-setup.ts
-var OFFICIAL_SETUP_RUNTIMES = [
-  "claude-code",
-  "codex",
-  "opencode",
-  "pi"
-];
-function isOfficialSetupRuntime(runtime) {
-  return OFFICIAL_SETUP_RUNTIMES.includes(runtime);
-}
-function resolveOfficialSetupArgv(runtime) {
-  switch (runtime) {
-    case "claude-code":
-      return ["setup", "claude-code"];
-    case "codex":
-      return ["setup", "codex"];
-    case "opencode":
-      return ["setup", "opencode"];
-    case "pi":
-      return ["setup", "pi"];
-    default:
-      throw new Error(`Runtime setup oficial desconocido: ${runtime}.`);
-  }
-}
-function shouldRunOfficialSetup(opts) {
-  return opts.command === "install" && opts.dryRun === false && opts.targetDir === void 0;
-}
-function snapshotDirEntries(dir) {
-  const out = /* @__PURE__ */ new Set();
-  try {
-    const walk = (current) => {
-      for (const entry of fs3.readdirSync(current, { withFileTypes: true })) {
-        const full = path3.resolve(path3.join(current, entry.name));
-        out.add(full);
-        if (entry.isDirectory()) walk(full);
-      }
-    };
-    walk(path3.resolve(dir));
-    return out;
-  } catch {
-    return null;
-  }
-}
-function errnoCode(error) {
-  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
-}
-function resolveTrustedNpmRoots(runtime, preciseTargets) {
-  if (runtime !== "pi") return [];
-  const roots = /* @__PURE__ */ new Set();
-  for (const t of preciseTargets) {
-    const resolved = path3.resolve(t);
-    if (path3.basename(resolved) === "npm") roots.add(resolved);
-  }
-  return [...roots];
-}
-function findTrustedRootFor(linkPath, trustedRoots) {
-  const resolved = path3.resolve(linkPath);
-  for (const root of trustedRoots) {
-    if (isContainedIn(resolved, root)) return root;
-  }
-  return null;
-}
-function validateTrustedNpmSymlink(linkPath, trustedRoots) {
-  const resolvedLink = path3.resolve(linkPath);
-  const root = findTrustedRootFor(resolvedLink, trustedRoots);
-  if (root === null) return `${resolvedLink}: symlink fuera de npm trusted (rechazado)`;
-  let raw;
-  try {
-    raw = fs3.readlinkSync(resolvedLink);
-  } catch (error) {
-    return `${resolvedLink}: symlink ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-  }
-  if (path3.isAbsolute(raw)) {
-    return `${resolvedLink}: symlink absoluto con escape fuera de npm trusted (rechazado)`;
-  }
-  const logical = path3.resolve(path3.dirname(resolvedLink), raw);
-  if (logical !== root && !isContainedIn(logical, root)) {
-    return `${resolvedLink}: symlink con escape fuera de npm trusted (${raw}, rechazado)`;
-  }
-  let canonical;
-  try {
-    canonical = fs3.realpathSync(resolvedLink);
-  } catch (error) {
-    const code = errnoCode(error);
-    if (code === "ENOENT") {
-      return `${resolvedLink}: symlink roto/broken hacia ${raw} (rechazado, no resuelve)`;
-    }
-    if (code === "ELOOP" || code === "EAGAIN" || code === "ENAMETOOLONG") {
-      return `${resolvedLink}: symlink con ciclo/cycle/loop hacia ${raw} (rechazado)`;
-    }
-    return `${resolvedLink}: symlink ilegible (${code}, no se puede descartar alias)`;
-  }
-  if (canonical !== root && !isContainedIn(canonical, root)) {
-    return `${resolvedLink}: symlink con escape fuera de npm trusted tras resolver (rechazado)`;
-  }
-  return null;
-}
-function findSymlinkInTree(root, trustedRoots = []) {
-  const resolvedRoot = path3.resolve(root);
-  try {
-    if (fs3.lstatSync(resolvedRoot).isSymbolicLink()) {
-      return `${resolvedRoot}: el target es un symlink (no se respalda ni se ejecuta setup)`;
-    }
-  } catch (error) {
-    if (errnoCode(error) !== "ENOENT") {
-      return `${resolvedRoot}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-    }
-    return null;
-  }
-  const stack = [resolvedRoot];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    let entries;
-    try {
-      entries = fs3.readdirSync(current, { withFileTypes: true });
-    } catch (error) {
-      if (errnoCode(error) === "ENOENT") continue;
-      return `${current}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-    }
-    for (const entry of entries) {
-      const full = path3.join(current, entry.name);
-      let st;
-      try {
-        st = fs3.lstatSync(full);
-      } catch (error) {
-        if (errnoCode(error) === "ENOENT") continue;
-        return `${full}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-      }
-      if (st.isSymbolicLink()) {
-        if (trustedRoots.length > 0) {
-          const allowed = validateTrustedNpmSymlink(full, trustedRoots);
-          if (allowed === null) continue;
-          return allowed;
-        }
-        return `${full}: es un symlink (no se sigue ni se copia)`;
-      }
-      if (st.isDirectory()) stack.push(full);
-    }
-  }
-  return null;
-}
-function snapshotTrustedSymlinks(trustedRoots) {
-  const out = /* @__PURE__ */ new Map();
-  try {
-    for (const root of trustedRoots) {
-      const resolvedRoot = path3.resolve(root);
-      try {
-        if (fs3.lstatSync(resolvedRoot).isSymbolicLink()) return null;
-      } catch (error) {
-        if (errnoCode(error) === "ENOENT") continue;
-        return null;
-      }
-      let isDir = false;
-      try {
-        isDir = fs3.statSync(resolvedRoot).isDirectory();
-      } catch {
-        continue;
-      }
-      if (!isDir) continue;
-      const stack = [resolvedRoot];
-      while (stack.length > 0) {
-        const current = stack.pop();
-        let names;
-        try {
-          names = fs3.readdirSync(current);
-        } catch (error) {
-          if (errnoCode(error) === "ENOENT") continue;
-          return null;
-        }
-        for (const name of names) {
-          const full = path3.join(current, name);
-          let st;
-          try {
-            st = fs3.lstatSync(full);
-          } catch (error) {
-            if (errnoCode(error) === "ENOENT") continue;
-            return null;
-          }
-          if (st.isSymbolicLink()) {
-            try {
-              out.set(path3.resolve(full), fs3.readlinkSync(full));
-            } catch {
-              return null;
-            }
-            continue;
-          }
-          if (st.isDirectory()) stack.push(full);
-        }
-      }
-    }
-    return out;
-  } catch {
-    return null;
-  }
-}
-function restoreTrustedSymlinks(snapshot, trustedRoots) {
-  if (snapshot === null) {
-    return { ok: false, error: "symlink snapshot ilegible (no se puede restaurar a ciegas)" };
-  }
-  for (const [linkPath, rawTarget] of snapshot) {
-    const resolvedLink = path3.resolve(linkPath);
-    const root = findTrustedRootFor(resolvedLink, trustedRoots);
-    if (root === null) {
-      return { ok: false, error: `symlink ${resolvedLink} fuera de npm trusted (restore omitido)` };
-    }
-    if (path3.isAbsolute(rawTarget)) {
-      return { ok: false, error: `symlink ${resolvedLink} con target absoluto (restore omitido)` };
-    }
-    const logical = path3.resolve(path3.dirname(resolvedLink), rawTarget);
-    const stop = path3.resolve(root);
-    if (logical !== stop && !isContainedIn(logical, stop)) {
-      return { ok: false, error: `symlink ${resolvedLink} con escape fuera de npm trusted (restore omitido)` };
-    }
-    let dir = path3.dirname(resolvedLink);
-    let unsafe = null;
-    while (true) {
-      if (dir === stop) {
-        try {
-          if (fs3.lstatSync(dir).isSymbolicLink()) unsafe = dir;
-        } catch (error) {
-          unsafe = errnoCode(error) === "ENOENT" ? `${dir}: ra\xEDz ausente` : `${dir}: ilegible`;
-        }
-        break;
-      }
-      if (!isContainedIn(dir, stop)) break;
-      try {
-        if (fs3.lstatSync(dir).isSymbolicLink()) {
-          unsafe = dir;
-          break;
-        }
-      } catch (error) {
-        if (errnoCode(error) !== "ENOENT") {
-          unsafe = `${dir}: ilegible`;
-          break;
-        }
-      }
-      const parent = path3.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    if (unsafe !== null) {
-      return { ok: false, error: `symlink ${resolvedLink}: ancestro inseguro ${unsafe} (restore omitido)` };
-    }
-    try {
-      fs3.mkdirSync(path3.dirname(resolvedLink), { recursive: true });
-      try {
-        if (fs3.lstatSync(path3.dirname(resolvedLink)).isSymbolicLink()) {
-          return { ok: false, error: `symlink ${resolvedLink}: padre es symlink tras mkdir (restore omitido)` };
-        }
-      } catch (error) {
-        return { ok: false, error: `symlink ${resolvedLink}: padre ilegible tras mkdir (${errnoCode(error)})` };
-      }
-      try {
-        const re = fs3.lstatSync(resolvedLink);
-        if (re.isSymbolicLink()) {
-          try {
-            if (fs3.readlinkSync(resolvedLink) === rawTarget) continue;
-          } catch {
-          }
-          fs3.rmSync(resolvedLink, { recursive: true, force: true });
-        } else {
-          fs3.rmSync(resolvedLink, { recursive: true, force: true });
-        }
-      } catch (error) {
-        if (errnoCode(error) !== "ENOENT") {
-          return { ok: false, error: `symlink ${resolvedLink} ilegible antes de recrear (${errnoCode(error)})` };
-        }
-      }
-      try {
-        fs3.symlinkSync(rawTarget, resolvedLink);
-      } catch (error) {
-        return { ok: false, error: `symlink ${resolvedLink}: no se pudo restaurar target (${errnoCode(error)})` };
-      }
-    } catch (error) {
-      return { ok: false, error: `symlink ${resolvedLink}: restore fall\xF3 (${errnoCode(error)})` };
-    }
-  }
-  return { ok: true };
-}
-function findSetupSymlinkViolation(targets, homeDir, trustedRoots = []) {
-  const homeResolved = path3.resolve(homeDir);
-  for (const target of targets) {
-    const resolved = path3.resolve(target);
-    try {
-      if (fs3.lstatSync(resolved).isSymbolicLink()) {
-        return `${resolved}: el target es un symlink (no se respalda ni se ejecuta setup)`;
-      }
-    } catch (error) {
-      if (errnoCode(error) !== "ENOENT") {
-        return `${resolved}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-      }
-    }
-    let dir = path3.dirname(resolved);
-    while (dir !== homeResolved && isContainedIn(dir, homeResolved)) {
-      try {
-        if (fs3.lstatSync(dir).isSymbolicLink()) {
-          return `${dir}: ancestro existente es un symlink (no se atraviesa)`;
-        }
-      } catch (error) {
-        if (errnoCode(error) !== "ENOENT") {
-          return `${dir}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-        }
-      }
-      const parent = path3.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    try {
-      if (fs3.statSync(resolved).isDirectory()) {
-        const bad = findSymlinkInTree(resolved, trustedRoots);
-        if (bad !== null) return bad;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function runOfficialSetup(runtime, deps) {
-  if (typeof deps.engramBin !== "string" || !path3.isAbsolute(deps.engramBin)) {
-    throw new Error(`runOfficialSetup: engramBin absoluto requerido (runtime ${runtime}).`);
-  }
-  const argv = resolveOfficialSetupArgv(runtime);
-  if (!Array.isArray(deps.targets) || deps.targets.length === 0) {
-    throw new Error(`runOfficialSetup: targets expl\xEDcitos no vac\xEDos requeridos (runtime ${runtime}).`);
-  }
-  const preciseTargets = [...new Set(deps.targets.map((t) => path3.resolve(t)))];
-  const homeResolved = path3.resolve(deps.homeDir);
-  const outside = preciseTargets.filter(
-    (t) => path3.resolve(t) !== homeResolved && !isContainedIn(t, homeResolved)
-  );
-  if (outside.length > 0) {
-    const detail2 = `runOfficialSetup: target fuera de la frontera de restore (${homeResolved}): ${outside[0]}. Bloqueado antes del setup.`;
-    return {
-      ok: false,
-      ownershipTransferred: false,
-      stderr: detail2,
-      reason: detail2,
-      recovery: "none",
-      backupId: null
-    };
-  }
-  const trustedNpmRoots = resolveTrustedNpmRoots(runtime, preciseTargets);
-  const preViolation = findSetupSymlinkViolation(preciseTargets, homeResolved, trustedNpmRoots);
-  if (preViolation !== null) {
-    const detail2 = `runOfficialSetup: symlink rechazado antes del setup (${preViolation}). Bloqueado antes del backup.`;
-    return {
-      ok: false,
-      ownershipTransferred: false,
-      stderr: detail2,
-      reason: detail2,
-      recovery: "none",
-      backupId: null
-    };
-  }
-  let backupId = null;
-  try {
-    const backup = await deps.backup();
-    backupId = backup?.id !== void 0 ? String(backup.id) : null;
-  } catch (error) {
-    const detail2 = error instanceof Error ? error.message : String(error);
-    return {
-      ok: false,
-      ownershipTransferred: false,
-      stderr: detail2,
-      reason: detail2,
-      recovery: "none",
-      backupId: null,
-      backupError: detail2
-    };
-  }
-  const existedBefore = new Set(preciseTargets.filter((t) => {
-    try {
-      return fs3.existsSync(t);
-    } catch {
-      return false;
-    }
-  }));
-  const dirSnapshots = /* @__PURE__ */ new Map();
-  for (const t of preciseTargets) {
-    if (!existedBefore.has(t)) continue;
-    try {
-      if (fs3.statSync(t).isDirectory()) dirSnapshots.set(t, snapshotDirEntries(t));
-    } catch {
-      dirSnapshots.set(t, null);
-    }
-  }
-  const trustedSymlinkSnapshot = snapshotTrustedSymlinks(trustedNpmRoots);
-  let spawnResult;
-  try {
-    spawnResult = await deps.spawn(deps.engramBin, argv, { shell: false });
-  } catch (error) {
-    const detail2 = error instanceof Error ? error.message : String(error);
-    spawnResult = { ok: false, stdout: "", stderr: detail2 };
-  }
-  let verifyResult;
-  try {
-    verifyResult = await deps.verify();
-  } catch (error) {
-    const detail2 = error instanceof Error ? error.message : String(error);
-    verifyResult = { ok: false, reason: detail2 };
-  }
-  const postViolation = findSetupSymlinkViolation(preciseTargets, homeResolved, trustedNpmRoots);
-  const tainted = /* @__PURE__ */ new Set();
-  if (postViolation !== null) {
-    for (const t of preciseTargets) {
-      if (findSetupSymlinkViolation([t], homeResolved, trustedNpmRoots) !== null) tainted.add(t);
-    }
-  }
-  const ok = spawnResult.ok === true && verifyResult.ok === true && postViolation === null;
-  if (ok) {
-    return {
-      ok: true,
-      ownershipTransferred: verifyResult.ownershipTransferred ?? true,
-      stdout: spawnResult.stdout,
-      stderr: spawnResult.stderr,
-      ...verifyResult.layers === void 0 ? {} : { layers: verifyResult.layers },
-      recovery: "none",
-      backupId
-    };
-  }
-  let restoreError;
-  let restoreFailed = false;
-  let symlinkRestoreFailed = false;
-  let symlinkRestoreError;
-  if (postViolation !== null) {
-    restoreFailed = true;
-    restoreError = `symlink post-setup (${postViolation}); restore omitido para no escribir a trav\xE9s del enlace`;
-  } else {
-    try {
-      await deps.restore?.();
-    } catch (error) {
-      restoreFailed = true;
-      restoreError = error instanceof Error ? error.message : String(error);
-    }
-    if (trustedNpmRoots.length > 0) {
-      const symRes = restoreTrustedSymlinks(trustedSymlinkSnapshot, trustedNpmRoots);
-      if (!symRes.ok) {
-        symlinkRestoreFailed = true;
-        symlinkRestoreError = symRes.error;
-      }
-    } else if (trustedSymlinkSnapshot !== null && trustedSymlinkSnapshot.size > 0) {
-      symlinkRestoreFailed = true;
-      symlinkRestoreError = "symlink snapshot inesperado fuera de Pi (restore omitido)";
-    }
-  }
-  let cleanupFailed = tainted.size > 0;
-  for (const t of preciseTargets) {
-    if (tainted.has(t)) continue;
-    try {
-      if (!existedBefore.has(t)) {
-        try {
-          fs3.lstatSync(t);
-          fs3.rmSync(t, { recursive: true, force: true });
-        } catch (error) {
-          if (errnoCode(error) !== "ENOENT") cleanupFailed = true;
-        }
-        continue;
-      }
-      if (!dirSnapshots.has(t)) continue;
-      const before = dirSnapshots.get(t);
-      if (before === null || before === void 0) {
-        cleanupFailed = true;
-        continue;
-      }
-      const after = snapshotDirEntries(t);
-      if (after === null) {
-        cleanupFailed = true;
-        continue;
-      }
-      const created = [...after].filter((p) => !before.has(p));
-      created.sort((a, b) => {
-        const depthA = a.split(path3.sep).length;
-        const depthB = b.split(path3.sep).length;
-        if (depthA !== depthB) return depthB - depthA;
-        return b.length - a.length;
-      });
-      for (const p of created) {
-        try {
-          try {
-            fs3.lstatSync(p);
-          } catch (error) {
-            if (errnoCode(error) === "ENOENT") continue;
-            cleanupFailed = true;
-            continue;
-          }
-          fs3.rmSync(p, { recursive: true, force: true });
-        } catch {
-          cleanupFailed = true;
-        }
-      }
-    } catch {
-      cleanupFailed = true;
-    }
-  }
-  const incomplete = restoreFailed || symlinkRestoreFailed || cleanupFailed;
-  const combinedRestoreError = [restoreError, symlinkRestoreError].filter((p) => p !== void 0).join("; ") || void 0;
-  restoreError = combinedRestoreError;
-  const detail = [spawnResult.stderr, verifyResult.stderr, verifyResult.reason, (verifyResult.layers ?? []).join(", ")].map((part) => (part ?? "").trim()).filter((part) => part !== "").join("; ") || "setup oficial fall\xF3";
-  const recoveryDetail = incomplete ? `${detail}; recuperaci\xF3n incompleta${restoreError !== void 0 ? `: ${restoreError}` : ""}` : detail;
-  return {
-    ok: false,
-    ownershipTransferred: false,
-    stdout: spawnResult.stdout,
-    stderr: recoveryDetail,
-    reason: recoveryDetail,
-    ...verifyResult.layers === void 0 ? {} : { layers: verifyResult.layers },
-    ...incomplete ? { incompleteRecovery: true } : {},
-    recovery: incomplete ? "incomplete" : "complete",
-    backupId,
-    ...restoreError === void 0 ? {} : { restoreError }
-  };
-}
-function isExplicitClaudeConfigDirEnv(explicit) {
-  if (explicit !== void 0) return explicit;
-  return process.env.CLAUDE_CONFIG_DIR !== void 0;
-}
-var officialSetupVerifiers = {};
-function registerOfficialSetupVerifier(runtime, fn) {
-  officialSetupVerifiers[runtime] = fn;
-}
-function collectOfficialSetupBackupTargets(runtime, configDir, homeDir, isExplicitClaudeConfigDir) {
-  switch (runtime) {
-    case "claude-code": {
-      const explicit = isExplicitClaudeConfigDirEnv(isExplicitClaudeConfigDir);
-      const pathIsDefault = homeDir !== void 0 ? path3.resolve(configDir) === path3.resolve(path3.join(homeDir, ".claude")) : path3.basename(path3.resolve(configDir)) === ".claude";
-      const isDefault = !explicit && pathIsDefault;
-      const nested = path3.join(configDir, ".claude.json");
-      const sibling = path3.join(path3.dirname(configDir), ".claude.json");
-      const targets = [
-        path3.join(configDir, "settings.json"),
-        path3.join(configDir, "plugins", "installed_plugins.json"),
-        path3.join(configDir, "plugins", "known_marketplaces.json"),
-        path3.join(configDir, "plugins", "marketplaces", "engram"),
-        path3.join(configDir, "plugins", "cache", "engram"),
-        path3.join(configDir, "mcp", "engram.json"),
-        // El MCP exacto puede estar en el archivo hermano (modo predeterminado)
-        // o en la ruta anidada (modo explícito); se respaldan ambas ubicaciones.
-        nested,
-        // En el modo predeterminado se añade el archivo hermano efectivo
-        // (`HOME/.claude.json`).
-        ...isDefault && path3.resolve(sibling) !== path3.resolve(nested) ? [sibling] : []
-      ];
-      if (homeDir !== void 0 && !isDefault) {
-        const fallback = path3.join(path3.resolve(homeDir), ".claude.json");
-        if (!targets.map((t) => path3.resolve(t)).includes(path3.resolve(fallback))) {
-          targets.push(fallback);
-        }
-      }
-      return [...new Set(targets)];
-    }
-    case "codex":
-      return [
-        path3.join(configDir, "config.toml"),
-        path3.join(configDir, "engram-instructions.md"),
-        path3.join(configDir, "engram-compact-prompt.md"),
-        path3.join(configDir, "AGENTS.md"),
-        path3.join(configDir, "hooks.json")
-      ];
-    case "opencode":
-      return [
-        path3.join(configDir, "opencode.json"),
-        path3.join(configDir, "opencode.jsonc"),
-        path3.join(configDir, "tui.json"),
-        path3.join(configDir, "tui.jsonc"),
-        path3.join(configDir, "plugins", "engram.ts")
-      ];
-    case "pi":
-      return [
-        path3.join(configDir, "settings.json"),
-        path3.join(configDir, "mcp.json"),
-        path3.join(configDir, "npm")
-      ];
-  }
-}
-function validateOfficialSetupDestination(runtime, configDir, homeDir) {
-  if (runtime === "codex") {
-    const expected = path3.resolve(path3.join(homeDir, ".codex"));
-    if (path3.resolve(configDir) !== expected) {
-      return `runOfficialSetupIfNeeded: Codex custom CODEX_HOME (${configDir}) is not supported: the provider ignores CODEX_HOME and 'engram setup codex' always writes ${expected}; use the default <home>/.codex.`;
-    }
-    return null;
-  }
-  if (runtime === "opencode" && path3.basename(path3.resolve(configDir)) !== "opencode") {
-    return `runOfficialSetupIfNeeded: configDir OpenCode incompatible (${configDir}); el provider solo alinea <parent>/opencode v\xEDa XDG_CONFIG_HOME.`;
-  }
-  if (runtime === "pi") {
-    const resolved = path3.resolve(configDir);
-    const homeResolved = path3.resolve(homeDir);
-    if (resolved !== homeResolved && !isContainedIn(resolved, homeResolved)) {
-      return `runOfficialSetupIfNeeded: Pi PI_CODING_AGENT_DIR (${configDir}) fuera de HOME (${homeDir}): queda fuera de la frontera de restore acotada a HOME; usa un PI_CODING_AGENT_DIR dentro de HOME o ajusta HOME antes de reintentar.`;
-    }
-    return null;
-  }
-  return null;
-}
-function resolveOfficialSetupEnv(runtime, configDir, homeDir, isExplicitClaudeConfigDir) {
-  switch (runtime) {
-    case "claude-code": {
-      const home = homeDir ?? HOME;
-      const explicit = isExplicitClaudeConfigDirEnv(isExplicitClaudeConfigDir);
-      if (explicit) return { CLAUDE_CONFIG_DIR: configDir };
-      if (path3.resolve(configDir) === path3.resolve(path3.join(home, ".claude"))) {
-        return { CLAUDE_CONFIG_DIR: void 0 };
-      }
-      return { CLAUDE_CONFIG_DIR: configDir };
-    }
-    case "codex":
-      return { CODEX_HOME: void 0 };
-    case "opencode":
-      return { OPENCODE_CONFIG_DIR: configDir, XDG_CONFIG_HOME: path3.dirname(configDir) };
-    case "pi":
-      return { PI_CODING_AGENT_DIR: configDir };
-  }
-}
-async function spawnOfficialSetupBin(bin, argv, env) {
-  try {
-    let childEnv;
-    if (env !== void 0) {
-      childEnv = { ...process.env };
-      for (const [key, value] of Object.entries(env)) {
-        if (value === void 0) delete childEnv[key];
-        else childEnv[key] = value;
-      }
-    }
-    const stdout = execFileSync(bin, argv, {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 12e4,
-      shell: false,
-      ...childEnv === void 0 ? {} : { env: childEnv }
-    });
-    return { ok: true, stdout: stdout ?? "", stderr: "" };
-  } catch (error) {
-    const stdout = error?.stdout;
-    const stderr = error?.stderr;
-    const toText = (value) => {
-      if (typeof value === "string") return value;
-      if (value instanceof Buffer) return value.toString("utf8");
-      return "";
-    };
-    const errText = error instanceof Error ? error.message : String(error);
-    const captured = toText(stderr).trim();
-    return { ok: false, stdout: toText(stdout), stderr: captured !== "" ? captured : errText };
-  }
-}
-function isClaudeEngramVersionSupported(version) {
-  const trimmed = version.trim();
-  if (trimmed === "") return false;
-  if (trimmed.includes("-")) return false;
-  const match = /(\d+)\.(\d+)\.(\d+)/.exec(trimmed);
-  if (!match) return false;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
-  if (major > 2) return true;
-  if (major < 2) return false;
-  return minor >= 0;
-}
-async function runOfficialSetupIfNeeded(runtime, opts) {
-  if (!shouldRunOfficialSetup({ command: opts.command, dryRun: opts.dryRun, targetDir: opts.targetDir })) {
-    return { ran: false };
-  }
-  if (!isOfficialSetupRuntime(runtime)) {
-    const detail = `runOfficialSetupIfNeeded: runtime desconocido en install real: ${runtime}.`;
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: detail, reason: detail, recovery: "none" };
-  }
-  if (typeof opts.engramBin !== "string" || !path3.isAbsolute(opts.engramBin)) {
-    const detail = `runOfficialSetupIfNeeded: engramBin absoluto requerido en install real (runtime ${runtime}).`;
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: detail, reason: detail, recovery: "none" };
-  }
-  const verify = officialSetupVerifiers[runtime];
-  if (!verify) {
-    const detail = `runOfficialSetupIfNeeded: sin verificador registrado en install real (runtime ${runtime}).`;
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: detail, reason: detail, recovery: "none" };
-  }
-  if (runtime === "claude-code") {
-    const raw = opts.engramVersion;
-    const provided = typeof raw === "string" ? raw.trim() : "";
-    if (provided === "" || !isClaudeEngramVersionSupported(provided)) {
-      const shown = provided === "" ? "unknown/unreadable" : provided;
-      const detail = `runOfficialSetupIfNeeded: Engram ${shown} no registra el MCP de Claude Code; check engram --version and update to Engram 2.0.0+ and rerun install; existing binary was not replaced.`;
-      return {
-        ran: true,
-        ok: false,
-        ownershipTransferred: false,
-        stderr: detail,
-        reason: detail,
-        recovery: "none",
-        backupId: null
-      };
-    }
-  }
-  const engramBin = opts.engramBin;
-  const configDir = opts.configDir;
-  const destinationError = validateOfficialSetupDestination(runtime, configDir, opts.homeDir);
-  if (destinationError !== null) {
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: destinationError, reason: destinationError, recovery: "none", backupId: null };
-  }
-  const explicitClaude = runtime === "claude-code" ? isExplicitClaudeConfigDirEnv(opts.isExplicitClaudeConfigDir) : void 0;
-  const targets = collectOfficialSetupBackupTargets(runtime, configDir, opts.homeDir, explicitClaude);
-  const setupEnv = resolveOfficialSetupEnv(runtime, configDir, opts.homeDir, explicitClaude);
-  let backupId = null;
-  let expectedBackupFiles = 0;
-  const expandBackupTargets = (files) => {
-    const out = [];
-    for (const file of files) {
-      try {
-        const stat = fs3.lstatSync(file);
-        if (stat.isSymbolicLink()) continue;
-        if (stat.isDirectory()) {
-          const walk = (dir) => {
-            for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-              const full = path3.join(dir, entry.name);
-              let entryStat;
-              try {
-                entryStat = fs3.lstatSync(full);
-              } catch {
-                continue;
-              }
-              if (entryStat.isSymbolicLink()) continue;
-              if (entryStat.isDirectory()) walk(full);
-              else out.push(full);
-            }
-          };
-          walk(file);
-          continue;
-        }
-      } catch {
-      }
-      out.push(file);
-    }
-    return out;
-  };
-  const result = await runOfficialSetup(runtime, {
-    homeDir: opts.homeDir,
-    engramBin,
-    backup: async () => {
-      const backup = createBackup(expandBackupTargets(targets), `official-engram-setup-${runtime}`);
-      backupId = backup?.id ?? null;
-      expectedBackupFiles = backup?.files.length ?? 0;
-      return { id: backupId ?? "no-backup" };
-    },
-    spawn: async (bin, argv) => spawnOfficialSetupBin(bin, argv, setupEnv),
-    verify: async () => verify({
-      configDir,
-      engramBin,
-      homeDir: opts.homeDir,
-      ...explicitClaude === void 0 ? {} : { isExplicitClaudeConfigDir: explicitClaude }
-    }),
-    restore: async () => {
-      if (backupId === null) return { restored: false };
-      const restored = restoreBackup(backupId);
-      if (restored !== expectedBackupFiles) {
-        throw new Error(
-          `restore incompleto: ${restored}/${expectedBackupFiles} archivos (backup ${backupId}).`
-        );
-      }
-      return { restored: true };
-    },
-    targets
-  });
-  return {
-    ran: true,
-    ok: result.ok,
-    ownershipTransferred: result.ownershipTransferred,
-    ...result.stderr === void 0 ? {} : { stderr: result.stderr },
-    ...result.reason === void 0 ? {} : { reason: result.reason },
-    ...result.incompleteRecovery === void 0 ? {} : { incompleteRecovery: result.incompleteRecovery },
-    ...result.recovery === void 0 ? {} : { recovery: result.recovery },
-    ...result.backupId === void 0 ? {} : { backupId: result.backupId },
-    ...result.restoreError === void 0 ? {} : { restoreError: result.restoreError }
-  };
-}
-
-export {
-  readTextIfExists,
-  ensureDir,
-  writeText,
-  copyFile,
-  isContainedIn,
-  pruneEmptyDirs,
-  sameFileContent,
-  listFilesRecursive,
-  createBackup,
-  listBackups,
-  restoreBackup,
-  OFFICIAL_SETUP_RUNTIMES,
-  isOfficialSetupRuntime,
-  resolveOfficialSetupArgv,
-  shouldRunOfficialSetup,
-  runOfficialSetup,
-  isExplicitClaudeConfigDirEnv,
-  officialSetupVerifiers,
-  registerOfficialSetupVerifier,
-  collectOfficialSetupBackupTargets,
-  validateOfficialSetupDestination,
-  resolveOfficialSetupEnv,
-  spawnOfficialSetupBin,
-  isClaudeEngramVersionSupported,
-  runOfficialSetupIfNeeded
-};