shilo-cli 0.3.1 → 0.5.0

package/src/token.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Resolución del token de acceso personal (PAT).
+ *
+ * Un PAT pasado como `--token abc123` queda en el historial del shell, en la
+ * lista de procesos (`ps` lo muestra a cualquier usuario de la máquina) y en
+ * los logs de CI. Por eso se aceptan dos formas más discretas:
+ *
+ *   --token -            lee el token de stdin  (`cat pat.txt | shilo login --token -`)
+ *   SHILO_TOKEN=<pat>    variable de entorno    (lo natural en CI)
+ *
+ * La forma inline sigue funcionando —es la que se copia desde la web— pero
+ * avisa una vez.
+ */
+
+const STDIN_SENTINEL = '-';
+
+/** Lee stdin completo (hasta EOF) y devuelve la primera línea no vacía. */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      reject(new Error('--token - espera el token por stdin, pero la entrada es una terminal.'));
+      return;
+    }
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+function firstLine(text) {
+  for (const line of String(text).split(/\r?\n/)) {
+    const t = line.trim();
+    if (t) return t;
+  }
+  return '';
+}
+
+/**
+ * Devuelve `{ token, source }` con source ∈ 'flag' | 'stdin' | 'env' | null.
+ * Lanza si `--token -` no encuentra nada que leer.
+ */
+async function resolveToken(args) {
+  const raw = typeof args.token === 'string' ? args.token.trim() : '';
+
+  if (raw === STDIN_SENTINEL) {
+    const token = firstLine(await readStdin());
+    if (!token) throw new Error('No llegó ningún token por stdin.');
+    return { token, source: 'stdin' };
+  }
+
+  if (raw) return { token: raw, source: 'flag' };
+
+  const env = (process.env.SHILO_TOKEN || '').trim();
+  if (env) return { token: env, source: 'env' };
+
+  return { token: '', source: null };
+}
+
+/** Aviso (una sola línea) cuando el token viajó de la forma más expuesta. */
+function warnIfExposed(source, ui) {
+  if (source !== 'flag') return;
+  ui.warn('El token quedó en el historial del shell y en la lista de procesos.');
+  ui.info(ui.c.dim('Alternativas: SHILO_TOKEN=<pat> o `cat pat.txt | shilo login --token -`.'));
+}
+
+module.exports = { resolveToken, warnIfExposed, readStdin, firstLine, STDIN_SENTINEL };

package/src/ui.js

@@ -33,4 +33,64 @@ function error(msg) {
   console.error(`${c.red('✗')} ${msg}`);
 }
 
-module.exports = { c, info, success, warn, error };
+/** ¿La salida es una terminal interactiva? (redirigida a archivo/CI: no) */
+const isTTY = !!process.stdout.isTTY;
+
+function formatEta(secs) {
+  if (!Number.isFinite(secs) || secs < 0) return '';
+  if (secs < 60) return `${Math.max(1, Math.round(secs))}s`;
+  const mins = Math.floor(secs / 60);
+  const rest = Math.round(secs % 60);
+  return `${mins}m ${rest}s`;
+}
+
+/**
+ * Contador de progreso de una sola línea.
+ *
+ * En una terminal reescribe la misma línea con porcentaje y ETA; sin TTY no
+ * dibuja nada (una barra con `\r` en un log de CI es ruido ilegible) y en su
+ * lugar `line()` emite una línea por ítem. Así el mismo código sirve para el
+ * uso interactivo y para el registro.
+ *
+ * El repintado se limita a ~10 fps: con cientos de archivos, escribir en cada
+ * uno cuesta más que el trabajo que reporta.
+ */
+function progress(total, label = '') {
+  const start = Date.now();
+  let lastLen = 0;
+  let lastDraw = 0;
+
+  return {
+    tty: isTTY,
+    update(done) {
+      if (!isTTY || total <= 0) return;
+      const now = Date.now();
+      if (done < total && now - lastDraw < 100) return;
+      lastDraw = now;
+
+      const pct = Math.round((done / total) * 100);
+      let eta = '';
+      if (done > 0 && done < total) {
+        const elapsed = (now - start) / 1000;
+        const left = formatEta((elapsed / done) * (total - done));
+        if (left) eta = `, faltan ~${left}`;
+      }
+      const line = `  ${label} ${done}/${total} (${pct}%${eta})`;
+      const pad = Math.max(0, lastLen - line.length);
+      process.stdout.write(`\r${c.dim(line)}${' '.repeat(pad)}`);
+      lastLen = line.length;
+    },
+    /** Borra la línea de progreso para que el mensaje siguiente arranque limpio. */
+    clear() {
+      if (!isTTY || lastLen === 0) return;
+      process.stdout.write(`\r${' '.repeat(lastLen)}\r`);
+      lastLen = 0;
+    },
+    /** Línea por ítem: sólo cuando no hay barra que la pisaría. */
+    line(msg) {
+      if (!isTTY) console.log(msg);
+    },
+  };
+}
+
+module.exports = { c, info, success, warn, error, isTTY, progress, formatEta };

package/src/walk.js

@@ -4,7 +4,13 @@
  * Recorrido de un directorio local para el push.
  *
  * Responsabilidades (todo offline, sin red):
- *   - aplicar ignores por defecto (.git, node_modules, etc.) + `.shiloignore`;
+ *   - aplicar ignores por defecto (.git, node_modules, etc.) + `.gitignore` +
+ *     `.shiloignore`, incluyendo los anidados de cada subcarpeta;
+ *   - podar repositorios git detectados por su FORMA (HEAD + objects/ + refs/),
+ *     no por el nombre `.git`: un `.git-ORIGINAL-BACKUP/` trae todo el historial
+ *     y renombrarlo no lo vuelve inocuo;
+ *   - descartar nombres reservados de Windows (`nul`, `con`, `com1`…), que en
+ *     esa plataforma son dispositivos y no archivos;
  *   - descartar nombres inválidos para Shilo (poda subárboles con carpeta inválida);
  *   - respetar la profundidad máxima de carpetas;
  *   - NO leer el contenido completo (eso lo hace el push al clasificar binarios),
@@ -16,7 +22,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { validateName, MAX_DEPTH } = require('./textguard');
+const { validateName, MAX_DEPTH, WIN_RESERVED } = require('./textguard');
 
 // Ignores por defecto (nombres de carpeta/archivo, a cualquier profundidad).
 const DEFAULT_IGNORES = [
@@ -30,11 +36,40 @@ const DEFAULT_IGNORES = [
   '.vercel/',
 ];
 
+// Archivos de ignores que se leen en cada directorio, en orden de precedencia:
+// `.shiloignore` va último para poder re-incluir con `!` algo que git ignora.
+const IGNORE_FILES = ['.gitignore', '.shiloignore'];
+
+// `WIN_RESERVED` (CON, NUL, COM1…) vive en textguard porque el backend también
+// los rechaza. Acá se usan además para PODAR: abrir `nul` no devuelve un archivo
+// sino el dispositivo nulo (`readFileSync` da vacío, `statSync` es inconsistente),
+// así que se saltean en toda plataforma y no sólo en Windows.
+
+/**
+ * ¿Este directorio es un repositorio git (bare o no), sin importar cómo se llame?
+ * Un `.git-ORIGINAL-BACKUP/`, `.git.bak/` o un submódulo tienen la misma forma.
+ */
+function looksLikeGitDir(absDir) {
+  try {
+    return (
+      fs.existsSync(path.join(absDir, 'HEAD')) &&
+      fs.existsSync(path.join(absDir, 'objects')) &&
+      fs.existsSync(path.join(absDir, 'refs'))
+    );
+  } catch (_) {
+    return false;
+  }
+}
+
 /**
  * Compila una línea de patrón estilo .gitignore (subconjunto práctico) a una
- * regla { negate, dirOnly, anchored, re }.
+ * regla { negate, dirOnly, anchored, base, re }.
+ *
+ * `base` es el prefijo de ruta (POSIX, con `/` final) del directorio donde vive
+ * el archivo de ignores: una regla de `public/.gitignore` sólo aplica bajo
+ * `public/`.
  */
-function compileRule(raw) {
+function compileRule(raw, base = '') {
   let line = raw.replace(/\r$/, '');
   // Ignorar comentarios y líneas vacías.
   if (!line.trim() || line.trim().startsWith('#')) return null;
@@ -63,8 +98,10 @@ function compileRule(raw) {
     anchored = true;
   }
 
-  const re = globToRegExp(line);
-  return { negate, dirOnly, anchored, re };
+  // Los anclados se comparan contra la ruta completa, así que llevan el base
+  // incorporado; los de basename se filtran por `base` en el matcher.
+  const re = globToRegExp(anchored ? base + line : line);
+  return { negate, dirOnly, anchored, base, re };
 }
 
 function globToRegExp(glob) {
@@ -97,12 +134,14 @@ function globToRegExp(glob) {
  */
 function makeMatcher(rules) {
   return function isIgnored(relPath, isDir) {
-    const base = relPath.split('/').pop();
+    const name = relPath.split('/').pop();
     let ignored = false;
     for (const rule of rules) {
       if (!rule) continue;
       if (rule.dirOnly && !isDir) continue;
-      const target = rule.anchored ? relPath : base;
+      // Una regla de un ignore anidado sólo alcanza a su propio subárbol.
+      if (rule.base && !relPath.startsWith(rule.base)) continue;
+      const target = rule.anchored ? relPath : name;
       if (rule.re.test(target)) {
         ignored = !rule.negate;
       }
@@ -112,47 +151,86 @@ function makeMatcher(rules) {
 }
 
 /**
- * Lee y compila reglas de un `.shiloignore` en la raíz (si existe), combinadas
- * con los ignores por defecto.
+ * Compila las reglas de los archivos de ignores presentes en `absDir`.
+ * `relBase` es la ruta POSIX del directorio relativa a la raíz ('' para la raíz).
  */
-function loadIgnoreRules(rootDir, extraLines = []) {
-  const lines = [...DEFAULT_IGNORES, ...extraLines];
-  const ignorePath = path.join(rootDir, '.shiloignore');
-  if (fs.existsSync(ignorePath)) {
+function loadDirRules(absDir, relBase = '') {
+  const base = relBase ? `${relBase}/` : '';
+  const rules = [];
+  for (const fileName of IGNORE_FILES) {
+    const ignorePath = path.join(absDir, fileName);
+    let text;
     try {
-      const text = fs.readFileSync(ignorePath, 'utf8');
-      lines.push(...text.split('\n'));
+      if (!fs.existsSync(ignorePath)) continue;
+      // Sin sacar el BOM (Notepad, PowerShell) el primer patrón del archivo se
+      // compila con un caracter invisible al frente y nunca matchea.
+      text = fs.readFileSync(ignorePath, 'utf8').replace(/^/, '');
     } catch (_) {
-      /* si no se puede leer, seguimos con los defaults */
+      continue; // si no se puede leer, seguimos con lo que haya
+    }
+    for (const line of text.split('\n')) {
+      const rule = compileRule(line, base);
+      if (rule) rules.push(rule);
     }
   }
-  return lines.map(compileRule).filter(Boolean);
+  return rules;
+}
+
+/**
+ * Reglas de la raíz: defaults + `.gitignore` + `.shiloignore` + extras.
+ * Se mantiene exportada porque es la forma de inspeccionar qué se va a ignorar
+ * sin recorrer nada.
+ */
+function loadIgnoreRules(rootDir, extraLines = []) {
+  const rules = [];
+  for (const line of DEFAULT_IGNORES) {
+    const rule = compileRule(line);
+    if (rule) rules.push(rule);
+  }
+  rules.push(...loadDirRules(rootDir, ''));
+  for (const line of extraLines) {
+    const rule = compileRule(line);
+    if (rule) rules.push(rule);
+  }
+  return rules;
 }
 
 /**
  * Recorre `rootDir` y devuelve:
  *   {
- *     files:   [{ relPath, absPath, size }],  // candidatos válidos a subir
- *     skipped: [{ relPath, reason }],         // descartados (nombre/profundidad)
+ *     files:   [{ relPath, absPath, size }],       // candidatos válidos a subir
+ *     skipped: [{ relPath, reason, code }],        // descartados
  *     ignored: <número de entradas ignoradas por reglas>
+ *     gitDirs: [<rutas de repos git podados>]
  *   }
  *
  * No sigue symlinks (se reportan como skipped).
  */
 function walk(rootDir, { extraIgnore = [] } = {}) {
-  const rules = loadIgnoreRules(rootDir, extraIgnore);
-  const isIgnored = makeMatcher(rules);
+  const rootRules = loadIgnoreRules(rootDir, extraIgnore);
 
   const files = [];
   const skipped = [];
+  const gitDirs = [];
   let ignored = 0;
 
-  function recurse(absDir, relBase, folderDepth) {
+  function recurse(absDir, relBase, folderDepth, inheritedRules) {
+    // Los ignores de este directorio se suman a los heredados y valen sólo de
+    // acá para abajo: por eso se copia el array en vez de mutarlo.
+    const rules = relBase
+      ? inheritedRules.concat(loadDirRules(absDir, relBase))
+      : inheritedRules;
+    const isIgnored = makeMatcher(rules);
+
     let entries;
     try {
       entries = fs.readdirSync(absDir, { withFileTypes: true });
     } catch (err) {
-      skipped.push({ relPath: relBase || '.', reason: `no se pudo leer: ${err.message}` });
+      skipped.push({
+        relPath: relBase || '.',
+        reason: `no se pudo leer: ${err.message}`,
+        code: 'unreadable',
+      });
       return;
     }
 
@@ -160,12 +238,24 @@ function walk(rootDir, { extraIgnore = [] } = {}) {
     entries.sort((a, b) => a.name.localeCompare(b.name));
 
     for (const entry of entries) {
-      const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+      // El nombre lógico (el que viaja al repo) se normaliza igual que en el
+      // backend —NFC y sin espacios al borde— porque es la forma que se guarda:
+      // macOS devuelve NFD, y sin esto "café.md" local y "café.md" remoto no se
+      // reconocen como el mismo archivo. `absPath` usa el nombre tal cual lo dio
+      // el SO, que es el que hay que abrir.
+      const logicalName = entry.name.normalize('NFC').trim();
+      const relPath = relBase ? `${relBase}/${logicalName}` : logicalName;
       const absPath = path.join(absDir, entry.name);
       const isDir = entry.isDirectory();
 
       if (entry.isSymbolicLink()) {
-        skipped.push({ relPath, reason: 'symlink (no soportado)' });
+        skipped.push({ relPath, reason: 'symlink (no soportado)', code: 'symlink' });
+        continue;
+      }
+
+      if (WIN_RESERVED.test(entry.name)) {
+        // No es un archivo real en Windows; leerlo devolvería el dispositivo nulo.
+        ignored++;
         continue;
       }
 
@@ -174,40 +264,58 @@ function walk(rootDir, { extraIgnore = [] } = {}) {
         continue;
       }
 
-      const nameCheck = validateName(entry.name);
+      if (isDir && looksLikeGitDir(absPath)) {
+        // Todo el historial del repo, incluidos secretos de commits ya purgados
+        // del árbol de trabajo. Se poda entero y se avisa una sola vez.
+        gitDirs.push(relPath);
+        continue;
+      }
+
+      const nameCheck = validateName(logicalName);
       if (!nameCheck.ok) {
-        skipped.push({ relPath, reason: nameCheck.reason });
+        skipped.push({ relPath, reason: nameCheck.reason, code: 'name' });
         continue; // si es carpeta, se poda todo el subárbol
       }
 
       if (isDir) {
         if (folderDepth + 1 > MAX_DEPTH) {
-          skipped.push({ relPath, reason: `profundidad de carpetas > ${MAX_DEPTH}` });
+          skipped.push({
+            relPath,
+            reason: `profundidad de carpetas > ${MAX_DEPTH}`,
+            code: 'depth',
+          });
           continue;
         }
-        recurse(absPath, relPath, folderDepth + 1);
+        recurse(absPath, relPath, folderDepth + 1, rules);
       } else if (entry.isFile()) {
         let size = 0;
+        let mtimeMs = 0;
         try {
-          size = fs.statSync(absPath).size;
+          const st = fs.statSync(absPath);
+          size = st.size;
+          mtimeMs = st.mtimeMs;
         } catch (_) {
           /* si falla el stat, dejamos size en 0; el push lo detecta al leer */
         }
-        files.push({ relPath, absPath, size });
+        files.push({ relPath, absPath, size, mtimeMs });
       }
       // otros tipos (fifo, socket, device) se ignoran silenciosamente
     }
   }
 
-  recurse(rootDir, '', 0);
-  return { files, skipped, ignored };
+  recurse(rootDir, '', 0, rootRules);
+  return { files, skipped, ignored, gitDirs };
 }
 
 module.exports = {
   walk,
   loadIgnoreRules,
+  loadDirRules,
   makeMatcher,
   compileRule,
   globToRegExp,
+  looksLikeGitDir,
   DEFAULT_IGNORES,
+  IGNORE_FILES,
+  WIN_RESERVED,
 };