shilo-cli 0.7.0 → 0.9.0

package/src/args.js

@@ -10,14 +10,32 @@
  *   -m "msg"          -> alias corto (ver `aliases`)
  *   positionals       -> array de argumentos sueltos
  *
+ * Las claves de `multiple` acumulan en un array en vez de pisarse, y quedan
+ * SIEMPRE como array (aunque haya una sola aparición, o ninguna): así el
+ * consumidor no tiene que distinguir "uno" de "varios", que es justo donde se
+ * cuelan los bugs de `--only`.
+ *
  * Devuelve { _: [positionals...], ...flags }.
  */
-function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
+function parseArgs(argv, { booleans = [], aliases = {}, multiple = [] } = {}) {
   const out = { _: [] };
   const boolSet = new Set(booleans);
+  const multiSet = new Set(multiple);
 
   const canonical = (k) => aliases[k] || k;
 
+  const set = (key, value) => {
+    if (!multiSet.has(key)) {
+      out[key] = value;
+      return;
+    }
+    // `--only` sin valor (`--only --yes`) no es una lista de nada: se descarta
+    // en vez de meter un `true` que el consumidor tendría que filtrar.
+    if (value === true) return;
+    if (!Array.isArray(out[key])) out[key] = [];
+    out[key].push(value);
+  };
+
   for (let i = 0; i < argv.length; i++) {
     let token = argv[i];
 
@@ -37,17 +55,17 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
       }
       key = canonical(key);
       if (value !== undefined) {
-        out[key] = value;
+        set(key, value);
       } else if (boolSet.has(key)) {
-        out[key] = true;
+        set(key, true);
       } else {
         const next = argv[i + 1];
         // `-` a secas es un valor legítimo ("leer de stdin"), no otra bandera.
         if (next !== undefined && (next === '-' || !next.startsWith('-'))) {
-          out[key] = next;
+          set(key, next);
           i++;
         } else {
-          out[key] = true;
+          set(key, true);
         }
       }
       continue;
@@ -56,15 +74,15 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
     if (token.startsWith('-') && token.length > 1) {
       const key = canonical(token.slice(1));
       if (boolSet.has(key)) {
-        out[key] = true;
+        set(key, true);
       } else {
         const next = argv[i + 1];
         // `-` a secas es un valor legítimo ("leer de stdin"), no otra bandera.
         if (next !== undefined && (next === '-' || !next.startsWith('-'))) {
-          out[key] = next;
+          set(key, next);
           i++;
         } else {
-          out[key] = true;
+          set(key, true);
         }
       }
       continue;
@@ -73,6 +91,12 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
     out._.push(token);
   }
 
+  // Normalización: una clave `multiple` que no apareció igual llega como array
+  // vacío, para que el consumidor pueda hacer `.length` sin chequear antes.
+  for (const key of multiSet) {
+    if (!Array.isArray(out[key])) out[key] = [];
+  }
+
   return out;
 }
 

package/src/checks.js

@@ -0,0 +1,57 @@
+/**
+ * Chequeos de propuesta (EP-S2, MU-93).
+ *
+ * Un proyecto declara en `shilo.config.json` los comandos que tienen que pasar
+ * antes de proponer (`"chequeos": ["npm test"]`). `shilo push` los corre en la
+ * carpeta, uno por uno y en orden, con la salida a la vista, y el resultado
+ * viaja con la propuesta: la web la muestra verificada o fallida, y aplicar una
+ * fallida exige forzar.
+ *
+ * Se corta en el primero que falla, como un hook de git: lo que viene después
+ * suele depender de lo anterior (instalar, compilar, probar) y correrlo sólo
+ * hace más largo el error. El resultado registra lo que se corrió.
+ *
+ * `run` se inyecta para probarlo sin lanzar procesos.
+ */
+
+'use strict';
+
+const childProcess = require('child_process');
+
+// Un chequeo colgado no puede dejar colgado el push: a los diez minutos se corta
+// y cuenta como fallido.
+const CHECK_TIMEOUT_MS = 10 * 60 * 1000;
+
+function spawnCheck(comando, dir) {
+  const r = childProcess.spawnSync(comando, {
+    cwd: dir,
+    shell: true,
+    stdio: 'inherit',
+    timeout: CHECK_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  // Sin `status` = no llegó a terminar (no se pudo lanzar, o se cortó por tiempo).
+  return { codigo: typeof r.status === 'number' ? r.status : null };
+}
+
+/**
+ * @param {string} dir - la carpeta donde se corren
+ * @param {string[]} comandos
+ * @param {{ run?: Function, now?: Function, onStart?: Function }} [opts]
+ * @returns {{ resultado: 'ok'|'fallido', comandos: Array<{ comando, ok, codigo?, ms }> }}
+ */
+function runChecks(dir, comandos, { run = spawnCheck, now = Date.now, onStart = () => {} } = {}) {
+  const out = [];
+  for (const comando of comandos) {
+    onStart(comando, out.length + 1, comandos.length);
+    const t0 = now();
+    const { codigo } = run(comando, dir);
+    const entry = { comando, ok: codigo === 0, ms: Math.max(0, Math.round(now() - t0)) };
+    if (codigo !== null) entry.codigo = codigo;
+    out.push(entry);
+    if (!entry.ok) break;
+  }
+  return { resultado: out.every((c) => c.ok) ? 'ok' : 'fallido', comandos: out };
+}
+
+module.exports = { runChecks, CHECK_TIMEOUT_MS };

package/src/commands/deploys.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const { resolveContext } = require('../context');
+
+const DEFAULT_LIMIT = 10;
+
+const STATUS = {
+  queued: (s) => ui.c.dim(s),
+  running: (s) => ui.c.cyan(s),
+  uploading: (s) => ui.c.cyan(s),
+  building: (s) => ui.c.cyan(s),
+  ready: (s) => ui.c.green(s),
+  error: (s) => ui.c.red(s),
+  canceled: (s) => ui.c.dim(s),
+  superseded: (s) => ui.c.dim(s),
+};
+
+const AUTO = {
+  off: 'sólo manual',
+  preview: 'preview en cada guardado',
+  production: 'producción en cada guardado',
+};
+
+/**
+ * shilo deploys [-n <N>] [--project <uuid>] [--json]
+ *
+ * Destino e historial de deploys a Vercel del proyecto (PLAN_DEPLOY_VERCEL,
+ * Etapa 4.2). Sólo lectura. El servidor devuelve como mucho los últimos 20.
+ */
+async function deploys(args) {
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+
+  const { projectId, baseURL, cfg, client, mgr } = ctx;
+
+  const limit = parseLimit(args.n || args.number);
+  if (limit === null) {
+    ui.error('El valor de -n debe ser un entero entre 1 y 20.');
+    return 1;
+  }
+
+  let info;
+  try {
+    info = await client.getDeploys(projectId, await mgr.valid());
+  } catch (e) {
+    ui.error(e.notSupported ? 'Este servidor de Shilo todavía no tiene deploys.' : e.message);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  const list = info.deployments.slice(0, limit);
+
+  if (args.json) {
+    console.log(JSON.stringify({ projectId, connected: info.connected, target: info.target, deployments: list }, null, 2));
+    return 0;
+  }
+
+  ui.info(`Deploys del proyecto — ${ui.c.cyan(baseURL)}`);
+  if (!info.target) {
+    ui.info('');
+    ui.info('Este proyecto no despliega a ningún lado. El owner lo configura en la');
+    ui.info('pestaña "Deploys" del proyecto en la web.');
+    return 0;
+  }
+
+  const t = info.target;
+  ui.info(`Vercel: ${ui.c.bold(t.vercel_project_name || t.vercel_project)} · ${AUTO[t.auto_target] || t.auto_target}`);
+  if (!info.connected) {
+    ui.warn('La conexión con Vercel no está activa: el owner tiene que volver a conectar.');
+  }
+  ui.info('');
+
+  if (list.length === 0) {
+    ui.info('Todavía no hubo deploys.');
+    return 0;
+  }
+
+  for (const d of list) {
+    const paint = STATUS[d.status] || ((s) => s);
+    const commit = d.commit_oid ? String(d.commit_oid).slice(0, 8) : '--------';
+    const target = d.target === 'production' ? ui.c.bold('prod   ') : 'preview';
+    const card = d.card ? ui.c.dim(` [card: ${d.card}]`) : '';
+    ui.info(`${paint(pad(d.status, 10))} ${target}  ${ui.c.yellow(commit)}  ${ui.c.dim(sync.formatDate(d.created_at))}${card}`);
+    if (d.url) ui.info(`    ${d.url}`);
+    if (d.error) ui.info(`    ${ui.c.red(d.error)}`);
+  }
+  return 0;
+}
+
+function pad(s, n) {
+  return String(s).padEnd(n);
+}
+
+function parseLimit(raw) {
+  if (raw === undefined || raw === null || raw === '') return DEFAULT_LIMIT;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > 20) return null;
+  return n;
+}
+
+module.exports = deploys;

package/src/commands/diff.js

@@ -126,17 +126,33 @@ async function diffAll({ dir, projectId, baseURL, cfg, client, mgr }) {
     config.persistCredsIfChanged(cfg, mgr.current);
   }
 
-  const cmp = sync.compareTrees(local.files, tree.files);
-  const total = cmp.onlyLocal.length + cmp.onlyRemote.length + cmp.differing.length;
+  const cmp = sync.refineByHash(sync.compareTrees(local.files, tree.files), { dir, projectId, baseURL });
+
+  // Un archivo ignorado localmente no es una diferencia que haya que resolver:
+  // el push no lo sube y el pull no lo baja. Se nombra aparte, no como "sólo
+  // remoto", que invita a un pull que igual no lo traería.
+  const isIgnoredPath = sync.makePathMatcher(dir);
+  const onlyRemote = cmp.onlyRemote.filter((i) => !isIgnoredPath(i.repoPath));
+  const ignoredRemote = cmp.onlyRemote.filter((i) => isIgnoredPath(i.repoPath));
+
+  const total = cmp.onlyLocal.length + onlyRemote.length + cmp.differing.length;
 
   ui.info('');
   if (total === 0) {
     ui.success('Sin diferencias de tamaño ni de archivos entre local y remoto.');
+    if (ignoredRemote.length > 0) {
+      ui.info(
+        ui.c.dim(`(${ignoredRemote.length} archivo(s) del remoto están ignorados localmente.)`)
+      );
+    }
     return 0;
   }
 
   for (const item of cmp.onlyLocal) ui.info(`  ${ui.c.green('+')} ${item.repoPath} ${ui.c.dim('(sólo local)')}`);
-  for (const item of cmp.onlyRemote) ui.info(`  ${ui.c.red('-')} ${item.repoPath} ${ui.c.dim('(sólo remoto)')}`);
+  for (const item of onlyRemote) ui.info(`  ${ui.c.red('-')} ${item.repoPath} ${ui.c.dim('(sólo remoto)')}`);
+  for (const item of ignoredRemote) {
+    ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(`${item.repoPath} (sólo remoto, ignorado localmente)`)}`);
+  }
   for (const item of cmp.differing) {
     const delta = item.local.size - item.remote.size;
     const sign = delta > 0 ? `+${delta}` : String(delta);

package/src/commands/export.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const path = require('path');
+const config = require('../config');
+const remote = require('../remote');
+const ui = require('../ui');
+const sync = require('../sync');
+const { ShiloClient } = require('../ShiloClient');
+const { DEFAULT_BASE_URL } = require('../context');
+const { exportarProyecto, leerMapa } = require('../exportgit');
+
+/**
+ * shilo export <carpeta> [--project <uuid>] [--base-url <url>] [--json]
+ *
+ * Escribe la historia del proyecto como un repositorio Git en `carpeta`, con
+ * `main` y `refs/notes/shilo`. La primera vez la carpeta tiene que estar vacía
+ * o no existir; después, repetir el comando sobre la misma carpeta trae sólo
+ * lo nuevo. No toca el proyecto: es de sólo lectura.
+ *
+ * El proyecto sale de `--project`, de la exportación anterior que haya en la
+ * carpeta, o del `.shilo.json` de la carpeta actual, en ese orden. Un proyecto
+ * público se exporta sin sesión.
+ */
+async function exportCmd(args) {
+  const destinoArg = typeof args._[0] === 'string' ? args._[0] : null;
+  if (!destinoArg) {
+    ui.error('Falta la carpeta de destino: shilo export <carpeta>.');
+    return 1;
+  }
+  const destino = path.resolve(destinoArg);
+  const asJson = !!args.json;
+
+  let previo = null;
+  let atada = null;
+  try {
+    previo = leerMapa(path.join(destino, '.git'));
+    atada = remote.read(process.cwd());
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  const pedido = typeof args.project === 'string' && args.project.trim() ? args.project.trim() : null;
+  if (pedido && previo && previo.projectId !== pedido) {
+    ui.error(`${destino} ya tiene la exportación de otro proyecto (${previo.projectId}).`);
+    ui.info('Exportá a una carpeta nueva.');
+    return 1;
+  }
+  const projectId = pedido || (previo && previo.projectId) || (atada && atada.projectId) || null;
+  if (!projectId) {
+    ui.error('No sé qué proyecto exportar.');
+    ui.info('Pasá --project <uuid>, o corré el comando dentro de una carpeta atada con "shilo init".');
+    return 1;
+  }
+
+  const cfg = config.load() || {};
+  const baseURL = args['base-url'] || (previo && previo.baseURL) || (atada && atada.baseURL) || cfg.baseURL || DEFAULT_BASE_URL;
+  const client = new ShiloClient({
+    baseURL,
+    supabaseUrl: cfg.supabaseUrl || null,
+    supabaseAnonKey: cfg.supabaseAnonKey || null,
+  });
+
+  // Sin sesión se intenta igual: un proyecto público se exporta sin cuenta.
+  let creds = null;
+  if (cfg.credentials) {
+    try {
+      creds = await sync.makeCredsManager(client, cfg).valid();
+    } catch (e) {
+      ui.error(`La sesión guardada no sirve: ${e.message}`);
+      ui.info('Corré "shilo login" de nuevo.');
+      return 1;
+    }
+  }
+
+  let progreso = null;
+  if (!asJson) {
+    ui.info(`${previo ? 'Actualizando la exportación' : 'Exportando'} de ${ui.c.bold(projectId)} en ${ui.c.bold(destino)}`);
+    ui.info(ui.c.dim(`Servidor: ${baseURL}`));
+  }
+
+  let informe;
+  try {
+    informe = await exportarProyecto({
+      client,
+      projectId,
+      creds,
+      destino,
+      baseURL,
+      onEtapa: (nombre, detalle) => {
+        if (asJson) return;
+        if (nombre === 'archivos' && detalle > 0) {
+          ui.info(`Bajando ${detalle} archivo(s)…`);
+          progreso = ui.progress(detalle, 'archivos');
+        }
+      },
+      onProgreso: (hechos) => { if (progreso) progreso.update(hechos); },
+    });
+  } catch (e) {
+    if (progreso) progreso.clear();
+    return explicarError(e, { destino, projectId, conSesion: Boolean(creds), asJson });
+  } finally {
+    if (creds) config.persistCredsIfChanged(cfg, creds);
+  }
+  if (progreso) progreso.clear();
+  if (informe.credentials) config.persistCredsIfChanged(cfg, informe.credentials);
+
+  if (asJson) {
+    const { credentials, ...resto } = informe;
+    console.log(JSON.stringify({ projectId, ...resto }, null, 2));
+    return 0;
+  }
+
+  mostrarInforme(informe);
+  return 0;
+}
+
+function mostrarInforme(inf) {
+  ui.info('');
+  if (inf.incremental && inf.mainAntes === inf.main) {
+    ui.success('Ya estaba al día: no hay puntos de guardado nuevos.');
+  } else if (inf.incremental) {
+    ui.success(`${inf.nuevos} punto(s) de guardado nuevo(s); ${inf.commits} en total.`);
+  } else {
+    ui.success(`${inf.commits} punto(s) de guardado exportado(s).`);
+  }
+  ui.info(`  main           ${ui.c.yellow(inf.main.slice(0, 12))}`);
+  if (inf.notas) ui.info(`  procedencia    ${ui.c.yellow(inf.notas.slice(0, 12))} ${ui.c.dim('(refs/notes/shilo)')}`);
+  ui.info(ui.c.dim(`  ${inf.archivos} archivo(s) y ${inf.carpetas} carpeta(s) bajados, ${formatoBytes(inf.bytes)}.`));
+
+  if (inf.vacias.length > 0) {
+    ui.info('');
+    ui.warn(`Git no guarda carpetas vacías; quedaron afuera ${inf.vacias.length}:`);
+    for (const r of inf.vacias.slice(0, 20)) ui.info(`  ${r}/`);
+    if (inf.vacias.length > 20) ui.info(ui.c.dim(`  … y ${inf.vacias.length - 20} más.`));
+  }
+
+  if (!inf.carpetaActualizada) {
+    ui.info('');
+    ui.info(ui.c.dim('La carpeta no está en main: se movió la rama pero no se tocaron tus archivos.'));
+  }
+
+  ui.info('');
+  ui.info('Para subirlo a otro servidor Git:');
+  ui.info(ui.c.cyan(`  git -C "${inf.destino}" push <remoto> main`));
+  if (inf.notas) {
+    // La ref de notas se rehace entera en cada exportación (no tiene padre),
+    // así que un push normal la rechaza a partir de la segunda: va con `+`.
+    ui.info(ui.c.cyan(`  git -C "${inf.destino}" push <remoto> +refs/notes/shilo`));
+    if (inf.notasReemplazadas) {
+      ui.info(ui.c.dim('  La procedencia se reemplazó entera; por eso el + en el push.'));
+    }
+  }
+}
+
+function explicarError(e, { destino, projectId, conSesion, asJson }) {
+  const code = e && e.code;
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: false, code: code || null, status: (e && e.status) || null, message: e.message, path: e.path || null,
+    }, null, 2));
+    return 1;
+  }
+
+  ui.error(e.message);
+  switch (code) {
+    case 'SIN_GIT':
+      ui.info('Instalá Git (https://git-scm.com) y volvé a correr el comando.');
+      break;
+    case 'DESTINO_OCUPADO':
+      ui.info('La primera exportación va a una carpeta vacía o que no existe.');
+      break;
+    case 'OTRO_PROYECTO':
+      ui.info('Exportá a una carpeta nueva.');
+      break;
+    case 'MAIN_AJENA':
+      ui.info('Hay puntos de guardado en main que no vienen de Shilo. Llevalos a otra rama');
+      ui.info('(git branch <nombre> main) y devolvé main a lo exportado, o exportá a una carpeta nueva.');
+      break;
+    case 'CAMBIOS_LOCALES':
+      ui.info('Guardalos o descartalos (git stash) antes de actualizar la exportación.');
+      break;
+    case 'MAPA_ILEGIBLE':
+    case 'REPO_INCOMPLETO':
+      ui.info('La exportación anterior está dañada. Exportá a una carpeta nueva.');
+      break;
+    case 'SIN_IDENTIDADES':
+      ui.info('Hay que aplicar la migración 018 en el servidor antes de exportar.');
+      break;
+    case 'PROYECTO_VACIO':
+      ui.info('Guardá una versión primero.');
+      break;
+    case 'NOMBRE_INVALIDO':
+      ui.info(`Git no acepta «${e.path || e.name}». Renombralo en Shilo y exportá de nuevo.`);
+      break;
+    case 'SHA1_MOVIDO':
+      ui.info('Lo ya exportado daría otro resultado: es un error de Shilo, no de tu carpeta. Avisanos.');
+      break;
+    case 'GRAFO_INCOMPLETO':
+    case 'BLOB_CORRUPTO':
+    case 'ARBOL_CORRUPTO':
+    case 'FALTA_OBJETO':
+      ui.info('A la historia del proyecto le falta algo en el servidor. No se escribió ninguna rama.');
+      break;
+    default:
+      if (e && e.status === 404) {
+        ui.info(conSesion
+          ? `El proyecto ${projectId} no existe o no tenés acceso.`
+          : 'Si el proyecto es privado, iniciá sesión con "shilo login".');
+      } else if (e && e.status === 401) {
+        ui.info('Corré "shilo login" de nuevo.');
+      }
+  }
+  if (code && code !== 'DESTINO_OCUPADO' && code !== 'SIN_GIT' && code !== 'OTRO_PROYECTO') {
+    ui.info(ui.c.dim(`Carpeta: ${destino}`));
+  }
+  return 1;
+}
+
+function formatoBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+module.exports = exportCmd;

package/src/commands/init.js

@@ -106,6 +106,14 @@ async function init(args) {
   const written = remote.write(dir, { projectId, baseURL });
   ui.success(`Carpeta atada al proyecto ${ui.c.bold(projectId)}.`);
   ui.info(ui.c.dim(`Remote guardado en ${written}`));
+  // Se lee siempre (ver walk.js), pero no decirlo hacía que la gente copiara
+  // a mano cada línea del .gitignore al .shiloignore.
+  if (fs.existsSync(path.join(dir, '.gitignore'))) {
+    ui.info(
+      ui.c.dim('Se respeta tu .gitignore: lo que git ignora tampoco se sube. ') +
+        ui.c.dim('.shiloignore es sólo para exclusiones extra.')
+    );
+  }
 
   // --push/--pull no implican confirmación: el usuario pidió *encadenar* el
   // comando, no saltearse su preflight. Sin --yes, push muestra el plan (y el

package/src/commands/log.js

@@ -4,6 +4,7 @@ const config = require('../config');
 const ui = require('../ui');
 const sync = require('../sync');
 const { resolveContext } = require('../context');
+const { marcaDeRevision } = require('./review');
 
 const DEFAULT_LIMIT = 20;
 
@@ -90,6 +91,7 @@ async function log(args) {
             message: c.message,
             author: sync.describeAuthor(c.users),
             date: c.created_at,
+            reviews: Array.isArray(c.reviews) ? c.reviews : [],
             files: (c.files || []).map((cf) => ({
               name: cf.files ? cf.files.name : null,
               action: cf.action,
@@ -122,6 +124,8 @@ async function log(args) {
     const hash = commit.hash ? String(commit.hash).slice(0, 8) : '(sin hash)';
     ui.info(`${ui.c.yellow(hash)}  ${ui.c.bold(sync.describeAuthor(commit.users))}  ${ui.c.dim(sync.formatDate(commit.created_at))}`);
     ui.info(`    ${commit.message}`);
+    const marca = marcaDeRevision(commit.reviews);
+    if (marca) ui.info(`    ${ui.c.dim('revisión:')} ${marca}`);
     if (showFiles && Array.isArray(commit.files) && commit.files.length > 0) {
       const shown = repoPath
         ? commit.files.filter((cf) => cf.files && cf.files.id === targetId)