shilo-cli 0.7.0 → 0.8.0

package/src/exportgit.js

@@ -0,0 +1,417 @@
+'use strict';
+
+/**
+ * Etapa 5, B3: escribir el grafo de un proyecto como un repositorio Git.
+ *
+ * Lee por la API (B1), convierte con la Parte A (`gitobjects.js`) y firma con
+ * las identidades congeladas (B2). El resultado es un repo Git normal con
+ * `main` y `refs/notes/shilo`; llevarlo a GitHub es un `git push` que hace la
+ * persona con sus credenciales.
+ *
+ * Incremental: la correspondencia `oid → sha1` queda en `.git/shilo/mapa`, por
+ * tipo. La segunda vez sólo se bajan los árboles y archivos nuevos; los puntos
+ * de guardado se bajan y se recalculan todos (son filas, es barato), y cada
+ * uno tiene que dar el mismo SHA-1 que la vez anterior (`SHA1_MOVIDO`).
+ *
+ * Los objetos se escriben sueltos, a mano (zlib en `.git/objects/xx/…`), sin
+ * un proceso de `git` por objeto. `git` hace falta igual para crear el repo,
+ * mover las refs con compare-and-swap y actualizar la carpeta de trabajo.
+ *
+ * Los errores llevan `code` estable, que lee el comando para explicar qué
+ * hacer. Los de la conversión (`ErrorConversion`) pasan tal cual.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const { createHash } = require('crypto');
+const { execFileSync } = require('child_process');
+const { convertirGrafo, gitBlob, gitNotas, REF_NOTAS } = require('./gitobjects');
+
+const VERSION_MAPA = 1;
+const REF_MAIN = 'refs/heads/main';
+const OID_VACIO = createHash('sha256').update('').digest('hex');
+const CERO = '0'.repeat(40);
+const DESCARGAS_EN_PARALELO = 8;
+
+class ErrorExportacion extends Error {
+  constructor(code, message, extra = {}) {
+    super(message);
+    this.name = 'ErrorExportacion';
+    this.code = code;
+    Object.assign(this, extra);
+  }
+}
+
+const sha256 = (buf) => createHash('sha256').update(buf).digest('hex');
+
+// ---------------------------------------------------------------------------
+// Git
+// ---------------------------------------------------------------------------
+
+function gitEn(dir) {
+  return (args, { input } = {}) => execFileSync('git', ['-C', dir, ...args], {
+    encoding: 'utf8',
+    input,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+/** `null` si `git` no está en el PATH. */
+function versionDeGit() {
+  try {
+    return execFileSync('git', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/** El SHA-1 de una ref, o `null` si no existe. */
+function leerRef(git, ref) {
+  try {
+    return git(['rev-parse', '-q', '--verify', `${ref}^{commit}`]).trim();
+  } catch {
+    return null;
+  }
+}
+
+/** Un objeto suelto: `.git/objects/xx/yyyy`, comprimido con zlib. Si ya está, no se toca. */
+function escribirObjeto(gitDir, { tipo, cuerpo, sha1 }) {
+  const dir = path.join(gitDir, 'objects', sha1.slice(0, 2));
+  const destino = path.join(dir, sha1.slice(2));
+  if (fs.existsSync(destino)) return false;
+  fs.mkdirSync(dir, { recursive: true });
+  const crudo = Buffer.concat([Buffer.from(`${tipo} ${cuerpo.length}\0`), cuerpo]);
+  // Temporal y rename, como Git: un corte a la mitad no deja un objeto trunco
+  // con el nombre de uno bueno.
+  const tmp = `${destino}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, zlib.deflateSync(crudo));
+  fs.renameSync(tmp, destino);
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// El mapa
+// ---------------------------------------------------------------------------
+
+function rutaMapa(gitDir) {
+  return path.join(gitDir, 'shilo', 'mapa');
+}
+
+function leerMapa(gitDir) {
+  const p = rutaMapa(gitDir);
+  if (!fs.existsSync(p)) return null;
+  let mapa;
+  try {
+    mapa = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (e) {
+    throw new ErrorExportacion('MAPA_ILEGIBLE', `No se pudo leer ${p}: ${e.message}`, { path: p });
+  }
+  if (!mapa || mapa.version !== VERSION_MAPA || !mapa.commits || !mapa.trees || !mapa.blobs) {
+    throw new ErrorExportacion('MAPA_ILEGIBLE', `${p} no tiene la forma esperada.`, { path: p });
+  }
+  return mapa;
+}
+
+function guardarMapa(gitDir, mapa) {
+  const p = rutaMapa(gitDir);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}`;
+  // Claves ordenadas: los archivos se bajan en paralelo y entran al mapa en el
+  // orden en que llegan. Ordenado, el mismo grafo da el mismo archivo.
+  const ordenado = (o) => Object.fromEntries(Object.keys(o).sort().map((k) => [k, o[k]]));
+  const salida = { ...mapa };
+  for (const tipo of ['commits', 'trees', 'blobs']) salida[tipo] = ordenado(mapa[tipo]);
+  fs.writeFileSync(tmp, `${JSON.stringify(salida)}\n`);
+  fs.renameSync(tmp, p);
+}
+
+// ---------------------------------------------------------------------------
+// Lectura del grafo
+// ---------------------------------------------------------------------------
+
+/**
+ * Los árboles que faltan, por niveles: se arranca por las raíces que no están
+ * en el mapa y se corta en cada subárbol que ya se exportó.
+ */
+async function bajarArboles(client, projectId, creds, raices, yaExportados) {
+  const trees = {};
+  let nivel = [...new Set(raices)].filter((oid) => oid !== OID_VACIO && !yaExportados[oid]);
+
+  while (nivel.length > 0) {
+    // eslint-disable-next-line no-await-in-loop
+    const r = await client.graphTrees(projectId, nivel, creds);
+    creds = r.credentials || creds;
+    if (r.faltan.length > 0) {
+      throw new ErrorExportacion('GRAFO_INCOMPLETO', `El servidor no tiene ${r.faltan.length} carpeta(s) de la historia.`, { oids: r.faltan });
+    }
+    Object.assign(trees, r.trees);
+    nivel = [...new Set(Object.values(r.trees).flat().filter((e) => e.type === 'tree').map((e) => e.oid))]
+      .filter((oid) => oid !== OID_VACIO && !trees[oid] && !yaExportados[oid]);
+  }
+
+  return { trees, creds };
+}
+
+/**
+ * Baja los archivos nuevos y los escribe como blobs de Git a medida que llegan,
+ * así la memoria no crece con el tamaño del proyecto. Cada uno se compara
+ * contra su oid antes de escribirlo. Devuelve `oid → sha1` de lo escrito.
+ */
+async function bajarArchivos(client, projectId, creds, oids, gitDir, onProgreso) {
+  const escritos = {};
+  let bytes = 0;
+  if (oids.length === 0) return { escritos, bytes, creds };
+
+  const r = await client.graphBlobs(projectId, oids, creds);
+  creds = r.credentials || creds;
+  if (r.faltan.length > 0) {
+    throw new ErrorExportacion('GRAFO_INCOMPLETO', `El servidor no tiene ${r.faltan.length} archivo(s) de la historia.`, { oids: r.faltan });
+  }
+
+  let hechos = 0;
+  const cola = [...oids];
+  const trabajador = async () => {
+    while (cola.length > 0) {
+      const oid = cola.shift();
+      const { url } = r.blobs[oid];
+      // eslint-disable-next-line no-await-in-loop
+      const contenido = url ? await client.downloadBinary(url) : Buffer.alloc(0);
+      if (sha256(contenido) !== oid) {
+        throw new ErrorExportacion('BLOB_CORRUPTO', `Un archivo bajado no coincide con su identidad (${oid.slice(0, 12)}).`, { oid });
+      }
+      const blob = gitBlob(contenido);
+      escribirObjeto(gitDir, blob);
+      escritos[oid] = blob.sha1;
+      bytes += contenido.length;
+      hechos += 1;
+      if (onProgreso) onProgreso(hechos, oids.length);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(DESCARGAS_EN_PARALELO, oids.length) }, trabajador));
+
+  return { escritos, bytes, creds };
+}
+
+// ---------------------------------------------------------------------------
+// La exportación
+// ---------------------------------------------------------------------------
+
+/**
+ * Prepara la carpeta: un repo nuevo, o uno exportado antes de este mismo
+ * proyecto. Cualquier otra cosa se rechaza: no se escribe sobre lo ajeno.
+ */
+function prepararDestino(destino, projectId) {
+  const gitDir = path.join(destino, '.git');
+  const git = gitEn(destino);
+
+  if (fs.existsSync(rutaMapa(gitDir))) {
+    const previo = leerMapa(gitDir);
+    if (previo.projectId !== projectId) {
+      throw new ErrorExportacion('OTRO_PROYECTO', `${destino} tiene la exportación de otro proyecto (${previo.projectId}).`, { projectId: previo.projectId });
+    }
+    return { gitDir, git, previo };
+  }
+
+  if (fs.existsSync(destino)) {
+    if (!fs.statSync(destino).isDirectory()) {
+      throw new ErrorExportacion('DESTINO_OCUPADO', `${destino} existe y no es una carpeta.`);
+    }
+    if (fs.readdirSync(destino).length > 0) {
+      throw new ErrorExportacion('DESTINO_OCUPADO', `${destino} no está vacía y no tiene una exportación anterior.`);
+    }
+  }
+
+  fs.mkdirSync(destino, { recursive: true });
+  git(['init', '-q', '--object-format=sha1']);
+  git(['symbolic-ref', 'HEAD', REF_MAIN]);
+  // A15: los bytes van crudos. Sin esto, un `core.autocrlf=true` global (el
+  // default de Git para Windows) cambiaría los finales de línea al sacar los
+  // archivos a la carpeta, y `git status` los mostraría modificados.
+  git(['config', 'core.autocrlf', 'false']);
+  return { gitDir, git, previo: null };
+}
+
+/**
+ * La `main` de la carpeta tiene que ser algo que exportamos nosotros: si
+ * alguien guardó encima, pisarla le borraría ese trabajo. Se acepta cualquier
+ * punto de guardado del mapa, no sólo el último, para que una exportación
+ * cortada entre guardar el mapa y mover la ref se pueda reintentar.
+ */
+function comprobarMain(git, previo) {
+  const actual = leerRef(git, REF_MAIN);
+  if (!actual) return null;
+  const nuestros = new Set(Object.values(previo ? previo.commits : {}));
+  if (!nuestros.has(actual)) {
+    throw new ErrorExportacion('MAIN_AJENA', `main apunta a ${actual.slice(0, 12)}, que no salió de Shilo.`, { sha1: actual });
+  }
+  return actual;
+}
+
+function hayCambiosLocales(git) {
+  return git(['status', '--porcelain', '--untracked-files=no']).trim() !== '';
+}
+
+/**
+ * Exporta el proyecto a `destino`.
+ *
+ * @param {Object} opciones
+ * @param {import('./ShiloClient').ShiloClient} opciones.client
+ * @param {string} opciones.projectId
+ * @param {Object|null} opciones.creds - `null` para un proyecto público sin sesión
+ * @param {string} opciones.destino
+ * @param {string} [opciones.baseURL] - se anota en el mapa
+ * @param {function} [opciones.onEtapa] - `(nombre, detalle)` para el informe en vivo
+ * @param {function} [opciones.onProgreso] - `(hechos, total)` al bajar archivos
+ * @returns {Promise<Object>} el informe
+ */
+async function exportarProyecto({ client, projectId, creds, destino, baseURL = null, onEtapa, onProgreso }) {
+  const etapa = (nombre, detalle) => { if (onEtapa) onEtapa(nombre, detalle); };
+
+  if (!versionDeGit()) {
+    throw new ErrorExportacion('SIN_GIT', 'No se encontró git en el PATH.');
+  }
+
+  const dest = path.resolve(destino);
+  const existia = fs.existsSync(dest);
+  const preparado = prepararDestino(dest, projectId);
+  try {
+    return await exportarEn(preparado, { client, projectId, creds, dest, baseURL, etapa, onProgreso });
+  } catch (e) {
+    // Una primera exportación que no terminó no deja nada: si quedara el
+    // `.git` a medias, el reintento vería la carpeta ocupada.
+    if (!preparado.previo) fs.rmSync(existia ? preparado.gitDir : dest, { recursive: true, force: true });
+    throw e;
+  }
+}
+
+async function exportarEn({ gitDir, git, previo }, { client, projectId, creds, dest, baseURL, etapa, onProgreso }) {
+  const mainAntes = comprobarMain(git, previo);
+  const enMain = (() => {
+    try {
+      return git(['symbolic-ref', '-q', 'HEAD']).trim() === REF_MAIN;
+    } catch {
+      return false;
+    }
+  })();
+  if (enMain && mainAntes && hayCambiosLocales(git)) {
+    throw new ErrorExportacion('CAMBIOS_LOCALES', `${dest} tiene cambios sin guardar sobre main.`);
+  }
+
+  // 1. La historia entera, siempre: los puntos de guardado no se siembran.
+  etapa('historia');
+  const hist = await client.graphHistory(projectId, creds);
+  creds = hist.credentials || creds;
+  if (!hist.refs.main || hist.commits.length === 0) {
+    throw new ErrorExportacion('PROYECTO_VACIO', 'El proyecto todavía no tiene puntos de guardado.');
+  }
+  if (!hist.identities) {
+    throw new ErrorExportacion('SIN_IDENTIDADES', 'El servidor todavía no puede firmar la exportación (falta la migración 018).');
+  }
+  const commits = Object.fromEntries(hist.commits.map((c) => [c.oid, c]));
+
+  const semilla = {
+    commits: previo ? previo.commits : {},
+    trees: { ...(previo ? previo.trees : {}) },
+    blobs: { ...(previo ? previo.blobs : {}) },
+  };
+
+  // 2. Los árboles que no se exportaron antes.
+  etapa('carpetas');
+  const arboles = await bajarArboles(client, projectId, creds, hist.commits.map((c) => c.tree_oid), semilla.trees);
+  creds = arboles.creds;
+
+  // 3. Los archivos que no se exportaron antes, escritos a medida que llegan.
+  const faltantes = [...new Set(Object.values(arboles.trees).flat().filter((e) => e.type === 'blob').map((e) => e.oid))]
+    .filter((oid) => oid !== OID_VACIO && !semilla.blobs[oid]);
+  etapa('archivos', faltantes.length);
+  const archivos = await bajarArchivos(client, projectId, creds, faltantes, gitDir, onProgreso);
+  creds = archivos.creds;
+  Object.assign(semilla.blobs, archivos.escritos);
+
+  // 4. La conversión. Lo bajado recién ya está escrito, así que entra como
+  // sembrado; el archivo vacío no se baja nunca.
+  etapa('conversion');
+  const convertido = convertirGrafo({
+    commits,
+    trees: arboles.trees,
+    blobs: { [OID_VACIO]: Buffer.alloc(0) },
+    heads: { main: hist.refs.main },
+    identidades: hist.identities,
+    mapaPrevio: semilla,
+  });
+
+  // 5. Los objetos, y la ref de notas: sin padre y fechada en el punto de
+  // guardado anotado más reciente, para que dependa sólo del grafo.
+  etapa('escritura');
+  let escritos = Object.keys(archivos.escritos).length;
+  for (const objeto of convertido.objetos.values()) {
+    if (escribirObjeto(gitDir, objeto)) escritos += 1;
+  }
+  const porSha1 = new Map(Object.entries(convertido.mapa.commits).map(([oid, sha1]) => [sha1, oid]));
+  const fechas = Object.keys(convertido.notas).map((sha1) => commits[porSha1.get(sha1)].created_at);
+  const ultima = fechas.reduce((a, b) => (new Date(b) > new Date(a) ? b : a), fechas[0]);
+  const notas = fechas.length > 0 ? gitNotas(convertido.notas, ultima) : null;
+  if (notas) for (const objeto of notas.objetos) if (escribirObjeto(gitDir, objeto)) escritos += 1;
+
+  // Todo lo que `main` alcanza tiene que estar: lo sembrado incluido. Si falta
+  // algo acá, la carpeta perdió objetos desde la última vez (un `git gc` con
+  // la ref movida a mano, por ejemplo) y el mapa miente.
+  const mainNueva = convertido.refs.main;
+  try {
+    git(['rev-list', '--objects', '--quiet', mainNueva]);
+  } catch (e) {
+    throw new ErrorExportacion('REPO_INCOMPLETO', `Faltan objetos en ${dest}: ${String(e.stderr || e.message).trim().split('\n')[0]}`);
+  }
+
+  // 6. El mapa antes que las refs: si se corta entre los dos, la próxima vez
+  // `main` sigue siendo un punto de guardado del mapa y se puede reintentar.
+  guardarMapa(gitDir, {
+    version: VERSION_MAPA,
+    projectId,
+    baseURL,
+    refs: { main: mainNueva, notas: notas ? notas.sha1 : null },
+    ...convertido.mapa,
+  });
+
+  // 7. La carpeta de trabajo, si está en main, y las refs con compare-and-swap.
+  if (enMain && mainAntes !== mainNueva) {
+    if (mainAntes) git(['read-tree', '-m', '-u', mainAntes, mainNueva]);
+    else git(['read-tree', '-u', '--reset', mainNueva]);
+  }
+  try {
+    git(['update-ref', '-m', 'shilo export', REF_MAIN, mainNueva, mainAntes || CERO]);
+  } catch (e) {
+    throw new ErrorExportacion('MAIN_AJENA', `main se movió mientras se exportaba: ${String(e.stderr || e.message).trim()}`);
+  }
+  const notasAntes = leerRef(git, REF_NOTAS);
+  if (notas && notasAntes !== notas.sha1) git(['update-ref', '-m', 'shilo export', REF_NOTAS, notas.sha1]);
+
+  const nuevos = hist.commits.filter((c) => !semilla.commits[c.oid]).length;
+  return {
+    destino: dest,
+    incremental: Boolean(previo),
+    commits: hist.commits.length,
+    nuevos,
+    carpetas: Object.keys(arboles.trees).length,
+    archivos: faltantes.length,
+    bytes: archivos.bytes,
+    objetos: escritos,
+    vacias: convertido.vacias,
+    main: mainNueva,
+    mainAntes,
+    notas: notas ? notas.sha1 : null,
+    notasReemplazadas: Boolean(notas && notasAntes && notasAntes !== notas.sha1),
+    carpetaActualizada: enMain,
+    credentials: creds,
+  };
+}
+
+module.exports = {
+  exportarProyecto,
+  escribirObjeto,
+  leerMapa,
+  versionDeGit,
+  ErrorExportacion,
+  REF_MAIN,
+};