shilo-cli 0.3.2 → 0.6.0

package/src/commands/push.js

@@ -7,13 +7,33 @@ const remote = require('../remote');
 const prompt = require('../prompt');
 const ui = require('../ui');
 const sync = require('../sync');
+const secrets = require('../secrets');
+const pushindex = require('../pushindex');
 const { walk } = require('../walk');
-const { classifyContent } = require('../textguard');
+const {
+  classifyContent,
+  looksBinary,
+  binaryMimeType,
+  extensionOf,
+  BINARY_EXTENSIONS,
+  MAX_FILE_BYTES,
+} = require('../textguard');
 const { ShiloClient } = require('../ShiloClient');
 
 const DEFAULT_BASE_URL = 'https://www.shilo.city';
 const COMMIT_BATCH = 100; // máximo de archivos por commit (límite del backend)
 
+// Cuánto se lee de cada archivo en el preflight: alcanza para decidir binario
+// (looksBinary mira 8000 bytes) y para escanear secretos, sin cargar el repo
+// entero en memoria antes de saber si hay algo para subir.
+const HEAD_BYTES = 8192;
+
+// Cuántos ejemplos se muestran por cada motivo de salteo.
+const SKIP_EXAMPLES = 5;
+// A partir de cuántos salteos en una misma carpeta de primer nivel sugerimos
+// ignorarla entera.
+const SUGGEST_MIN = 20;
+
 // Mapa mínimo extensión -> mime para texto. El backend default es text/plain.
 const TEXT_MIME = {
   js: 'text/javascript', mjs: 'text/javascript', cjs: 'text/javascript',
@@ -30,8 +50,192 @@ function guessMime(name) {
   return TEXT_MIME[ext] || 'text/plain';
 }
 
+const SKIP_LABELS = {
+  unreadable: 'no se pudieron leer',
+  symlink: 'symlinks (no soportados)',
+  name: 'nombre no permitido por Shilo',
+  depth: 'demasiado anidados',
+  // Los binarios ya NO se saltean: desde la Etapa 2 suben por URL firmada. Este
+  // motivo quedó sólo para lo que supera el techo de tamaño.
+  size: `mayores a ${MAX_FILE_BYTES / (1024 * 1024)} MB`,
+};
+
+/** Lee como mucho `n` bytes del principio del archivo. */
+function readHead(absPath, n) {
+  const fd = fs.openSync(absPath, 'r');
+  try {
+    const buf = Buffer.allocUnsafe(n);
+    const read = fs.readSync(fd, buf, 0, n, 0);
+    return buf.subarray(0, read);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/**
+ * Fase offline: recorre, filtra y clasifica SIN tocar la red.
+ *
+ * Todo lo que puede hacer fracasar o cancelar un push (nombres inválidos,
+ * binarios, secretos, "no hay nada para subir") se decide acá, antes del primer
+ * request. Un push que iba a terminar en nada no debería costar ni una conexión.
+ *
+ * Sólo se leen los primeros KB de cada archivo; el contenido completo se lee
+ * recién cuando se sabe que ese archivo se sube.
+ *
+ * Desde la Etapa 2 esta fase ya no descarta binarios: los MARCA. Un archivo con
+ * `binary: true` sube por URL firmada (`client.uploadBinary`) en vez de por el
+ * lote JSON, porque el lote hashea el contenido como utf8 y ahí un binario se
+ * corrompe antes de que nadie pueda notarlo. Lo único que sigue siendo motivo de
+ * salteo es superar el techo de tamaño.
+ */
+function preflight(dir) {
+  const { files, skipped, ignored, gitDirs } = walk(dir);
+
+  const uploads = [];
+  const skips = skipped.slice();
+  const findings = [];
+
+  for (const f of files) {
+    const name = path.basename(f.relPath);
+
+    if (f.size > MAX_FILE_BYTES) {
+      skips.push({
+        relPath: f.relPath,
+        reason: `supera ${MAX_FILE_BYTES / (1024 * 1024)} MB (${f.size} bytes)`,
+        code: 'size',
+      });
+      continue;
+    }
+
+    const ext = extensionOf(name);
+    let binary = Boolean(ext && BINARY_EXTENSIONS.has(ext));
+    let head = null;
+
+    // Un archivo cuya extensión ya dice que es binario no hace falta leerlo para
+    // saberlo, y leerlo sólo serviría para escanearle secretos — que en un JPEG
+    // son ruido.
+    if (!binary) {
+      try {
+        head = readHead(f.absPath, HEAD_BYTES);
+      } catch (e) {
+        skips.push({ relPath: f.relPath, reason: `no se pudo leer: ${e.message}`, code: 'unreadable' });
+        continue;
+      }
+      binary = looksBinary(head);
+    }
+
+    if (!binary) {
+      findings.push(...secrets.inspect(f.relPath, head.toString('utf8')));
+    }
+
+    uploads.push({
+      relPath: f.relPath,
+      absPath: f.absPath,
+      size: f.size,
+      mtimeMs: f.mtimeMs,
+      binary,
+      mimeType: binary ? binaryMimeType(name) : guessMime(f.relPath),
+      content: null,
+    });
+  }
+
+  return { uploads, skipped: skips, ignored, gitDirs, findings };
+}
+
+/**
+ * Reporte agrupado de salteos. Un repo con un `venv/` adentro generaba miles de
+ * líneas "saltado …" que tapaban todo lo demás; acá se resume por motivo, con
+ * unos pocos ejemplos, y se sugiere qué ignorar.
+ */
+function reportSkipped(skips, { verbose }) {
+  if (skips.length === 0) return;
+
+  if (verbose) {
+    for (const s of skips) ui.warn(`saltado ${ui.c.dim(s.relPath)} — ${s.reason}`);
+    return;
+  }
+
+  const byCode = new Map();
+  for (const s of skips) {
+    const code = s.code || 'otros';
+    if (!byCode.has(code)) byCode.set(code, []);
+    byCode.get(code).push(s);
+  }
+
+  ui.warn(`${skips.length} entrada(s) salteada(s):`);
+  for (const [code, list] of byCode) {
+    ui.info(`  ${ui.c.dim('·')} ${list.length} ${SKIP_LABELS[code] || code}`);
+    for (const s of list.slice(0, SKIP_EXAMPLES)) {
+      ui.info(`      ${ui.c.dim(s.relPath)} — ${s.reason}`);
+    }
+    if (list.length > SKIP_EXAMPLES) {
+      ui.info(ui.c.dim(`      … y ${list.length - SKIP_EXAMPLES} más`));
+    }
+  }
+
+  suggestIgnore(skips);
+  ui.info(ui.c.dim('(--verbose muestra la lista completa)'));
+}
+
+/** Si los salteos se concentran en una carpeta de primer nivel, decirlo. */
+function suggestIgnore(skips) {
+  const bySegment = new Map();
+  for (const s of skips) {
+    const seg = s.relPath.split('/')[0];
+    if (!seg || seg === s.relPath) continue; // sueltos en la raíz: no hay carpeta que ignorar
+    bySegment.set(seg, (bySegment.get(seg) || 0) + 1);
+  }
+
+  const worst = [...bySegment.entries()]
+    .filter(([, n]) => n >= SUGGEST_MIN)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3);
+  if (worst.length === 0) return;
+
+  ui.info('');
+  ui.info('Si esas carpetas no van al repo, agregalas a .shiloignore:');
+  for (const [seg, n] of worst) {
+    ui.info(`  ${ui.c.bold(`${seg}/`)}   ${ui.c.dim(`(${n} salteados)`)}`);
+  }
+}
+
+/** Muestra los hallazgos de secretos. Nunca imprime el valor detectado. */
+function reportSecrets(findings) {
+  const groups = secrets.groupByFile(findings);
+  ui.error(`Posibles secretos en ${groups.length} archivo(s):`);
+  for (const g of groups) {
+    if (g.name) {
+      ui.info(`  ${ui.c.red('!')} ${g.relPath} ${ui.c.dim(`(coincide con "${g.name}")`)}`);
+    }
+    for (const hit of g.content) {
+      ui.info(`  ${ui.c.red('!')} ${g.relPath}:${hit.line} ${ui.c.dim(`— parece ${hit.label}`)}`);
+    }
+  }
+  ui.info('');
+  ui.info('No se subió nada. Opciones:');
+  ui.info('  · agregar esos archivos a .shiloignore (lo más común)');
+  ui.info('  · sacar el secreto del contenido y volver a intentar');
+  ui.info('  · si es un falso positivo, repetir con --allow-secrets');
+}
+
+/** Todas las carpetas ancestro de un conjunto de rutas de archivo. */
+function neededFolders(relPaths) {
+  const set = new Set();
+  for (const p of relPaths) {
+    const parts = p.split('/');
+    parts.pop(); // el nombre del archivo
+    let acc = '';
+    for (const part of parts) {
+      acc = acc ? `${acc}/${part}` : part;
+      set.add(acc);
+    }
+  }
+  return set;
+}
+
 /**
- * shilo push [carpeta] [--project <uuid>] [-m <msg>] [--dry-run] [--yes] [--base-url <url>]
+ * shilo push [carpeta] [--project <uuid>] [-m <msg>] [--dry-run] [--yes]
+ *            [--allow-secrets] [--concurrency <n>] [--no-index] [--verbose]
  *
  * Replica una carpeta local a un repo de Shilo: crea archivos nuevos, actualiza
  * los que cambiaron, salta binarios/oversize/nombres inválidos, y registra todo
@@ -44,6 +248,8 @@ async function push(args) {
     return 1;
   }
 
+  const verbose = !!args.verbose;
+
   // 1) Resolver remote: --project pisa a .shilo.json.
   const savedRemote = remote.read(dir);
   const projectId =
@@ -77,108 +283,228 @@ async function push(args) {
     return 1;
   }
 
-  // 3) Recorrer la carpeta.
-  const { files, skipped, ignored } = walk(dir);
+  // 3) PREFLIGHT: todo offline. Recién después de esto se toca la red.
+  const { uploads, skipped, ignored, gitDirs, findings } = preflight(dir);
 
-  if (skipped.length > 0) {
-    for (const s of skipped) {
-      ui.warn(`saltado ${ui.c.dim(s.relPath)} — ${s.reason}`);
+  if (gitDirs.length > 0) {
+    ui.warn(
+      `${gitDirs.length} repositorio(s) git podado(s) (traen todo el historial, ` +
+        `incluidos secretos ya borrados del árbol de trabajo):`
+    );
+    for (const g of gitDirs.slice(0, SKIP_EXAMPLES)) ui.info(`      ${ui.c.dim(g)}`);
+    if (gitDirs.length > SKIP_EXAMPLES) {
+      ui.info(ui.c.dim(`      … y ${gitDirs.length - SKIP_EXAMPLES} más`));
     }
   }
 
-  // 4) Leer y clasificar (texto vs binario/oversize).
-  const uploads = []; // { relPath, absPath, content, mimeType }
-  const skippedBinary = [];
-  for (const f of files) {
-    let buf;
-    try {
-      buf = fs.readFileSync(f.absPath);
-    } catch (e) {
-      skippedBinary.push({ relPath: f.relPath, reason: `no se pudo leer: ${e.message}` });
-      continue;
-    }
-    const cls = classifyContent(path.basename(f.relPath), buf);
-    if (!cls.isText) {
-      skippedBinary.push({ relPath: f.relPath, reason: cls.reason });
-      continue;
-    }
-    uploads.push({
-      relPath: f.relPath,
-      absPath: f.absPath,
-      content: cls.content,
-      mimeType: guessMime(f.relPath),
-    });
-  }
+  reportSkipped(skipped, { verbose });
 
-  for (const s of skippedBinary) {
-    ui.warn(`saltado ${ui.c.dim(s.relPath)} — ${s.reason}`);
+  if (findings.length > 0 && !args['allow-secrets']) {
+    ui.info('');
+    reportSecrets(findings);
+    return 1;
+  }
+  if (findings.length > 0) {
+    ui.warn(
+      `${secrets.groupByFile(findings).length} archivo(s) con posibles secretos ` +
+        `se van a subir igual (--allow-secrets).`
+    );
   }
 
   if (uploads.length === 0) {
-    ui.info('No hay archivos de texto para subir.');
-    ui.info(
-      ui.c.dim(
-        `(${ignored} ignorados, ${skipped.length + skippedBinary.length} saltados)`
-      )
-    );
+    ui.info('No hay archivos para subir.');
+    ui.info(ui.c.dim(`(${ignored} ignorados, ${skipped.length} salteados)`));
     return 0;
   }
 
+  // 4) Cliente + control de ritmo. `onThrottle` baja la concurrencia sola si el
+  //    servidor empieza a responder 429, en vez de insistir hasta que corte.
+  const limit = sync.resolveConcurrency(args);
+  const throttle = sync.makeThrottle(limit);
   const client = new ShiloClient({
     baseURL,
     supabaseUrl: cfg.supabaseUrl || null,
     supabaseAnonKey: cfg.supabaseAnonKey || null,
+    onThrottle: () => {
+      if (throttle.reduce()) {
+        ui.warn('El servidor está limitando el ritmo (429): bajando la concurrencia.');
+      }
+    },
   });
 
   ui.info(
     `Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — ` +
-      `${uploads.length} archivo(s) de texto, ${ignored} ignorado(s), ` +
-      `${skipped.length + skippedBinary.length} saltado(s).`
+      `${uploads.length} archivo(s) (${uploads.filter((u) => u.binary).length} binario(s)), ` +
+      `${ignored} ignorado(s), ` +
+      `${skipped.length} salteado(s).`
   );
 
-  // 5) Clasificar contra el remote (added / modified / unchanged) para planear.
-  //    Esto ya toca la red (getFileMeta / readFile) pero no escribe nada.
-  //    Se hace con un pool de concurrencia (mismo patrón que walkRemote en
-  //    pull/status) en vez de un archivo a la vez: es lo que hacía que un push
-  //    de muchos archivos tardara minutos por puro round-trip secuencial.
-  //    `mgr` serializa el refresh del JWT para que llamadas paralelas no
-  //    quemen el mismo refresh_token.
+  // 5) Planificación. `mgr` serializa el refresh del JWT para que las llamadas
+  //    paralelas no quemen el mismo refresh_token.
   const mgr = sync.makeCredsManager(client, cfg);
   const plan = { added: [], modified: [], unchanged: [], failed: [] };
 
-  const planResults = await sync.runPool(uploads, sync.CONCURRENCY, async (u) => {
-    const creds = await mgr.valid();
-    const meta = await client.getFileMeta(projectId, u.relPath, creds);
+  // 5a) Árbol remoto completo en un solo recorrido (un request por CARPETA).
+  //     Antes esto era un getFileMeta por ARCHIVO: para 142 archivos en 30
+  //     carpetas, 142 requests pasan a 30.
+  let tree;
+  try {
+    tree = await sync.walkRemote(client, projectId, mgr, { concurrency: throttle });
+  } catch (e) {
+    ui.error(`No se pudo leer el estado del proyecto: ${e.message}`);
+    return 1;
+  }
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  const treeComplete = tree.errors.length === 0;
+  if (!treeComplete) {
+    ui.warn(
+      `No se pudieron listar ${tree.errors.length} carpeta(s) del proyecto: ` +
+        `la planificación puede quedar incompleta.`
+    );
+    if (verbose) {
+      for (const e of tree.errors) ui.info(`      ${ui.c.dim(e.folderPath || '/')} — ${e.reason}`);
+    }
+  }
+
+  const remoteByPath = new Map(tree.files.map((f) => [f.repoPath, f]));
+
+  // 5b) Índice local: un archivo cuyo size+mtime son los del último push exitoso
+  //     no cambió, así que si además el remoto tiene ese mismo tamaño, no hace
+  //     falta bajar contenido para compararlo. Es lo que hace que un push sin
+  //     cambios sea casi gratis.
+  const useIndex = !args['no-index'];
+  const index = useIndex
+    ? pushindex.read(dir, { projectId, baseURL })
+    : { version: pushindex.INDEX_VERSION, projectId, baseURL, entries: {} };
 
-    if (!meta.exists) return { kind: 'added', u };
-    if (meta.file && meta.file.type === 'folder') {
-      return { kind: 'failed', u, reason: 'ya existe una carpeta con ese nombre' };
+  const toCompare = []; // mismo tamaño, hay que mirar el contenido
+  const toResolve = []; // distinto tamaño: sólo falta su storage_path
+
+  for (const u of uploads) {
+    if (tree.folders.has(u.relPath)) {
+      plan.failed.push({ ...u, reason: 'ya existe una carpeta con ese nombre' });
+      continue;
     }
 
-    // Existe como archivo: ver si cambió comparando tamaño y luego contenido.
-    const localSize = Buffer.byteLength(u.content, 'utf8');
-    if (meta.file && typeof meta.file.size === 'number' && meta.file.size === localSize) {
-      const readCreds = await mgr.valid();
-      const remoteRead = await client.readFile(projectId, u.relPath, readCreds);
-      if (remoteRead.file && remoteRead.file.content === u.content) {
-        return { kind: 'unchanged', u };
+    const r = remoteByPath.get(u.relPath);
+    if (!r) {
+      plan.added.push(u);
+      continue;
+    }
+
+    // Servidor viejo: el listado no trae storage_path, y el commit lo exige para
+    // las modificaciones. Se resuelve con un getFileMeta, como antes.
+    if (!r.storage_path) {
+      if (typeof r.size === 'number' && r.size !== u.size) {
+        toResolve.push({ ...u, remote: r });
+      } else if (useIndex && pushindex.isFresh(index, u).fresh) {
+        plan.unchanged.push(u);
+      } else {
+        toCompare.push({ ...u, remote: r });
       }
+      continue;
     }
-    return { kind: 'modified', u: { ...u, remote: meta.file } };
-  });
 
-  for (const r of planResults) {
-    if (r && r.__error) {
-      plan.failed.push({ ...r.item, reason: r.__error });
+    // Camino rápido: el remoto publica el SHA-256 de su contenido, así que
+    // "¿cambió?" se responde con aritmética local. Cero requests, cero bytes
+    // bajados — antes esto era descargar el archivo entero para comparar.
+    if (r.content_hash) {
+      // Mejor aún: si el índice dice que el archivo local está intacto y su hash
+      // ya coincide con el del servidor, ni siquiera hace falta leerlo del disco.
+      if (useIndex) {
+        const { fresh, entry } = pushindex.isFresh(index, u);
+        if (fresh && entry && entry.hash === r.content_hash) {
+          plan.unchanged.push({ ...u, remote: r });
+          continue;
+        }
+      }
+
+      let content;
+      try {
+        content = await loadContent(u);
+      } catch (e) {
+        plan.failed.push({ ...u, reason: e.message });
+        continue;
+      }
+
+      if (pushindex.hashContent(content) === r.content_hash) {
+        plan.unchanged.push({ ...u, content, remote: r });
+      } else {
+        plan.modified.push({ ...u, content, remote: r });
+      }
       continue;
     }
-    if (r.kind === 'failed') plan.failed.push({ ...r.u, reason: r.reason });
-    else plan[r.kind].push(r.u);
+
+    // Archivo anterior a la migración 010: no tiene hash. Camino viejo, pero ya
+    // sin el request extra para el storage_path.
+    if (typeof r.size === 'number' && r.size !== u.size) {
+      plan.modified.push({ ...u, remote: r });
+      continue;
+    }
+
+    if (useIndex && pushindex.isFresh(index, u).fresh) {
+      plan.unchanged.push(u);
+      continue;
+    }
+    toCompare.push({ ...u, remote: r });
+  }
+
+  // 5c) Los que quedaron: un request cada uno, pero sólo por los candidatos a
+  //     cambio, no por todo el repo.
+  const pending = toCompare.concat(toResolve);
+  if (pending.length > 0) {
+    const prog = ui.progress(pending.length, 'comparando');
+    const results = await sync.runPool(
+      pending,
+      throttle,
+      async (u) => {
+        // Distinto tamaño: ya sabemos que cambió, sólo hace falta la metadata
+        // (el commit exige el storage_path anterior).
+        if (typeof u.remote.size === 'number' && u.remote.size !== u.size) {
+          const creds = await mgr.valid();
+          const meta = await client.getFileMeta(projectId, u.relPath, creds);
+          if (!meta.exists) return { kind: 'added', u };
+          return { kind: 'modified', u: { ...u, remote: meta.file } };
+        }
+
+        const content = await loadContent(u);
+
+        // Un binario no se compara bajando el contenido: el GET devuelve una URL
+        // firmada, no bytes, justamente para no arrastrar el archivo por el
+        // payload de la función. Sin `content_hash` remoto no queda con qué
+        // comparar, así que se asume modificado. El servidor deduplica: si el
+        // contenido es el mismo, el blob ya existe y no se transfiere un byte.
+        if (u.binary) {
+          const creds = await mgr.valid();
+          const meta = await client.getFileMeta(projectId, u.relPath, creds);
+          if (!meta.exists) return { kind: 'added', u: { ...u, content } };
+          return { kind: 'modified', u: { ...u, content, remote: meta.file } };
+        }
+
+        const creds = await mgr.valid();
+        const read = await client.readFile(projectId, u.relPath, creds);
+        if (read.file && read.file.content === content) {
+          return { kind: 'unchanged', u: { ...u, content, remote: read.file } };
+        }
+        return { kind: 'modified', u: { ...u, content, remote: read.file } };
+      },
+      { onProgress: (done) => prog.update(done) }
+    );
+    prog.clear();
+
+    for (const r of results) {
+      if (r && r.__error) {
+        plan.failed.push({ ...r.item, reason: r.__error });
+        continue;
+      }
+      plan[r.kind].push(r.u);
+    }
   }
 
   config.persistCredsIfChanged(cfg, mgr.current);
 
-  // 5b) Atribución: para los archivos que vamos a pisar, quién los tocó último.
+  // 5d) Atribución: para los archivos que vamos a pisar, quién los tocó último.
   //     Es lo que distingue "esto lo subí yo antes" de "esto lo va a perder un
   //     compañero". Best-effort: si el historial no se puede leer, seguimos.
   let attribution = { index: new Map() };
@@ -219,6 +545,7 @@ async function push(args) {
       for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
       return 1;
     }
+    if (useIndex && !dryRun) saveIndex(dir, index, plan, uploads);
     ui.success('Todo al día. Nada para subir.');
     return 0;
   }
@@ -265,142 +592,490 @@ async function push(args) {
     }
   }
 
-  // 8) Ejecutar subidas. Se acumulan los cambios para el/los commit(s).
-  const changes = []; // { file_id, action, previous_storage_path?, new_storage_path? }
-  const ensuredCache = new Set();
+  // 8) Ejecutar subidas. Cada lote se commitea apenas termina (ver paso 9): si
+  //    el push se corta a la mitad, lo ya escrito queda en el historial en vez
+  //    de quedar en storage sin ningún commit que lo referencie.
   const failedWrites = [];
+  const pushedAt = Date.now();
+  let committed = 0;
+  let commitCount = 0;
 
-  // 8a) Asegurar carpetas primero, EN SERIE. `ensuredCache` evita re-listar una
-  //     carpeta ya confirmada, pero además evita la carrera real: el backend no
-  //     siempre responde 409 de forma confiable si dos requests intentan crear
-  //     la misma carpeta al mismo tiempo, así que esta fase no se paraleliza.
-  //     Como la mayoría de los archivos comparten carpetas, el cache hace que
-  //     esto sea barato (proporcional a carpetas únicas, no a archivos).
-  const ensureFailed = new Set();
-  for (const u of plan.added) {
-    try {
-      const creds = await mgr.valid();
-      await client.ensurePath(projectId, u.relPath, creds, ensuredCache);
-    } catch (e) {
-      ensureFailed.add(u.relPath);
-      failedWrites.push({ relPath: u.relPath, reason: e.message });
-      ui.error(`${u.relPath} — ${e.message}`);
+  /** Log por archivo: en TTY lo tapa la barra de progreso, así que va sólo con --verbose. */
+  const logFile = (prog, msg) => {
+    if (verbose) {
+      prog.clear();
+      ui.success(msg);
+    } else {
+      prog.line(`✓ ${msg}`);
     }
+  };
+  const logError = (prog, msg) => {
+    prog.clear();
+    ui.error(msg);
+  };
+
+  // 8a) Carpetas faltantes, por nivel. El árbol remoto ya nos dice cuáles
+  //     existen, así que no hace falta listar antes de crear cada una; y crear
+  //     nivel por nivel (paralelo dentro del nivel, serie entre niveles)
+  //     garantiza que el padre exista sin depender del 409 del backend, que no
+  //     es confiable ante dos creaciones simultáneas de la misma carpeta.
+  //
+  //     Se ejecuta a demanda: el endpoint de lote hace mkdir -p por su cuenta,
+  //     así que estos requests sólo hacen falta en el camino archivo-por-archivo.
+  const failedFolders = [];
+  let foldersEnsured = false;
+
+  async function ensureFolders() {
+    if (foldersEnsured) return;
+    foldersEnsured = true;
+    if (plan.added.length === 0) return;
+
+    if (treeComplete) {
+      const missing = [...neededFolders(plan.added.map((u) => u.relPath))].filter(
+        (f) => !tree.folders.has(f)
+      );
+      const byDepth = new Map();
+      for (const f of missing) {
+        const d = f.split('/').length;
+        if (!byDepth.has(d)) byDepth.set(d, []);
+        byDepth.get(d).push(f);
+      }
+
+      for (const depth of [...byDepth.keys()].sort((a, b) => a - b)) {
+        const level = byDepth.get(depth);
+        const results = await sync.runPool(level, throttle, async (folderPath) => {
+          const parts = folderPath.split('/');
+          const name = parts.pop();
+          const creds = await mgr.valid();
+          await client.createFolder(projectId, name, parts.join('/'), creds);
+          return folderPath;
+        });
+        for (const r of results) {
+          if (r && r.__error) {
+            failedFolders.push({ folderPath: r.item, reason: r.__error });
+            ui.error(`carpeta ${r.item} — ${r.__error}`);
+          }
+        }
+      }
+    } else {
+      // Árbol incompleto: no sabemos qué existe. Volvemos al camino conservador.
+      const ensuredCache = new Set();
+      for (const u of plan.added) {
+        try {
+          const creds = await mgr.valid();
+          await client.ensurePath(projectId, u.relPath, creds, ensuredCache);
+        } catch (e) {
+          failedFolders.push({ folderPath: path.posix.dirname(u.relPath), reason: e.message });
+          ui.error(`${u.relPath} — ${e.message}`);
+        }
+      }
+    }
+    config.persistCredsIfChanged(cfg, mgr.current);
   }
-  config.persistCredsIfChanged(cfg, mgr.current);
 
-  // 8b) Subidas propiamente dichas, en paralelo: acá es donde vive el grueso
-  //     del tiempo (un request por archivo), y a diferencia de ensurePath no
-  //     hay riesgo de carrera porque cada archivo tiene una ruta propia.
-  const addedReady = plan.added.filter((u) => !ensureFailed.has(u.relPath));
-  const addedResults = await sync.runPool(addedReady, sync.CONCURRENCY, async (u) => {
+  const blocked = (relPath) =>
+    failedFolders.some((f) => f.folderPath && relPath.startsWith(`${f.folderPath}/`));
+
+  // 8b) Subidas. El costo dominante no es el trabajo del servidor sino la
+  //     latencia de cada round-trip, así que van agrupadas: el endpoint de lote
+  //     escribe hasta 100 archivos por request y crea las carpetas que falten.
+  //     El contenido se lee lote por lote, no todo de una: un repo grande no
+  //     tiene por qué entrar entero en memoria.
+  const BATCH_MAX_FILES = COMMIT_BATCH; // 100: mismo techo que el commit
+  const BATCH_MAX_BYTES = 4 * 1024 * 1024; // el server corta en 5 MB; margen
+
+  const toUpload = [
+    ...plan.added.map((u) => ({ u, isNew: true })),
+    ...plan.modified.map((u) => ({ u, isNew: false })),
+  ];
+
+  // Empaquetado por cantidad Y por tamaño. Un archivo más grande que el
+  // presupuesto termina solo en su lote, y ahí se sube por el endpoint
+  // individual.
+  //
+  // Los lotes son HOMOGÉNEOS: o todo texto, o todo binario. Los dos grupos se
+  // escriben por caminos distintos —lote JSON contra URL firmada— y un lote
+  // mezclado obligaría a partirlo en el momento de escribir, justo donde después
+  // hay que volver a juntar los cambios para un solo commit. Separarlos acá
+  // deja esa parte sin ramas.
+  //
+  // El presupuesto de bytes no se le aplica a los binarios: su contenido nunca
+  // entra en el payload de un request, así que un lote de diez PDF de 30 MB son
+  // diez subidas directas y ningún JSON grande.
+  const batches = [];
+  for (const group of [toUpload.filter((e) => !e.u.binary), toUpload.filter((e) => e.u.binary)]) {
+    let current = [];
+    let currentBytes = 0;
+    for (const e of group) {
+      const bytes = e.u.binary ? 0 : typeof e.u.size === 'number' ? e.u.size : 0;
+      const full =
+        current.length >= BATCH_MAX_FILES || currentBytes + bytes > BATCH_MAX_BYTES;
+      if (current.length > 0 && full) {
+        batches.push(current);
+        current = [];
+        currentBytes = 0;
+      }
+      current.push(e);
+      currentBytes += bytes;
+    }
+    if (current.length > 0) batches.push(current);
+  }
+
+  const upProg = ui.progress(toUpload.length, 'subiendo');
+  let upDone = 0;
+  const tickUp = (n = 1) => {
+    upDone += n;
+    upProg.update(upDone);
+  };
+
+  const uploaded = []; // { relPath, size, mtimeMs, hash } para el índice
+  let batchSupported = true; // se descubre en el primer lote
+
+  /** Escribe un lote entero en un request. Devuelve un resultado por archivo. */
+  async function writeViaBatch(entries) {
+    const payload = entries.map((e) => ({
+      path: e.u.relPath,
+      content: e.content,
+      mimeType: e.u.mimeType,
+    }));
     const creds = await mgr.valid();
-    const created = await client.createFile(projectId, u.relPath, u.content, u.mimeType, creds);
+    const { results } = await client.writeBatch(projectId, payload, creds);
+
+    return entries.map((e, i) => {
+      const r = results[i];
+      if (!r || !r.ok) {
+        return { ok: false, reason: (r && r.error) || 'el servidor no devolvió resultado' };
+      }
+      const f = r.file || {};
+      const action = r.action === 'created' ? 'added' : 'modified';
+      const change = { file_id: f.id, action, new_storage_path: f.storage_path };
+      if (action === 'modified') {
+        // El backend devuelve el storage_path que acaba de reemplazar; sólo si
+        // faltara caemos a lo que sabíamos del árbol remoto.
+        change.previous_storage_path =
+          f.previous_storage_path || (e.u.remote && e.u.remote.storage_path) || f.storage_path;
+        // El hash del contenido que estamos reemplazando lo sabe únicamente el
+        // cliente: cuando el commit llega al servidor, `files.content_hash` ya
+        // fue pisado con el contenido nuevo. Puede ser null en archivos
+        // anteriores a la migración 010.
+        if (e.u.remote && e.u.remote.content_hash) {
+          change.previous_content_hash = e.u.remote.content_hash;
+        }
+      }
+      return { ok: true, change, symbol: action === 'added' ? '+' : '~' };
+    });
+  }
+
+  /**
+   * Camino de los binarios: URL firmada, un archivo a la vez y en paralelo.
+   *
+   * No se agrupan en un request como el texto porque no hay nada que agrupar:
+   * cada byte va directo a Storage. Lo que sí se comparte es el control de
+   * ritmo, que es el que evita que veinte subidas de 30 MB salgan juntas.
+   *
+   * El endpoint crea las carpetas intermedias por su cuenta, igual que el lote,
+   * así que acá no hace falta `ensureFolders()`.
+   */
+  async function writeViaDirect(entries) {
+    const results = await sync.runPool(entries, throttle, async (e) => {
+      const creds = await mgr.valid();
+      const { result } = await client.uploadBinary(
+        projectId,
+        {
+          path: e.u.relPath,
+          buffer: e.content,
+          contentHash: pushindex.hashContent(e.content),
+          mimeType: e.u.mimeType,
+        },
+        creds
+      );
+
+      const f = (result && result.file) || {};
+      const action = result && result.action === 'created' ? 'added' : 'modified';
+      const change = { file_id: f.id, action, new_storage_path: f.storage_path };
+
+      if (action === 'modified') {
+        change.previous_storage_path =
+          f.previous_storage_path || (e.u.remote && e.u.remote.storage_path) || f.storage_path;
+        // El hash de lo que estamos reemplazando: el servidor lo lee antes de
+        // pisar la fila, que es el único momento en que existe. Si no vino, lo
+        // sabemos por el árbol remoto.
+        const previous =
+          f.previous_content_hash || (e.u.remote && e.u.remote.content_hash) || null;
+        if (previous) change.previous_content_hash = previous;
+      }
+
+      return { ok: true, change, symbol: action === 'added' ? '+' : '~' };
+    });
+
+    return results.map((r) => (r && r.__error ? { ok: false, reason: r.__error } : r));
+  }
+
+  /** Camino archivo-por-archivo: server sin /batch, o archivo demasiado grande. */
+  async function writeViaSingle(entries) {
+    await ensureFolders();
 
-    if (created.created && created.file) {
+    const outcomes = new Array(entries.length);
+    const queue = [];
+    entries.forEach((e, i) => {
+      if (e.isNew && blocked(e.u.relPath)) {
+        outcomes[i] = { ok: false, reason: 'no se pudo crear su carpeta' };
+      } else {
+        queue.push({ e, i });
+      }
+    });
+
+    const results = await sync.runPool(queue, throttle, async ({ e }) => {
+      const u = e.u;
+      if (e.isNew) {
+        const creds = await mgr.valid();
+        const created = await client.createFile(projectId, u.relPath, e.content, u.mimeType, creds);
+        if (created.created && created.file) {
+          return {
+            ok: true,
+            symbol: '+',
+            change: {
+              file_id: created.file.id,
+              action: 'added',
+              new_storage_path: created.file.storage_path,
+            },
+          };
+        }
+        // 409: apareció entremedio; caemos a update.
+        const writeCreds = await mgr.valid();
+        const upd = await client.writeFile(projectId, u.relPath, e.content, u.mimeType, writeCreds);
+        return {
+          ok: true,
+          symbol: '~',
+          change: {
+            file_id: upd.file.id,
+            action: 'modified',
+            previous_storage_path:
+              (created.file && created.file.storage_path) || upd.file.storage_path,
+            new_storage_path: upd.file.storage_path,
+          },
+        };
+      }
+
+      const creds = await mgr.valid();
+      const upd = await client.writeFile(projectId, u.relPath, e.content, u.mimeType, creds);
       return {
-        u,
-        symbol: '+',
+        ok: true,
+        symbol: '~',
         change: {
-          file_id: created.file.id,
-          action: 'added',
-          new_storage_path: created.file.storage_path,
+          file_id: upd.file.id,
+          action: 'modified',
+          previous_storage_path: u.remote ? u.remote.storage_path : upd.file.storage_path,
+          new_storage_path: upd.file.storage_path,
+          // Ver la nota en writeViaBatch: el hash previo sólo existe acá.
+          ...(u.remote && u.remote.content_hash
+            ? { previous_content_hash: u.remote.content_hash }
+            : {}),
         },
       };
-    }
-    // 409: apareció entremedio; caemos a update.
-    const writeCreds = await mgr.valid();
-    const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, writeCreds);
-    return {
-      u,
-      symbol: '~',
-      change: {
-        file_id: upd.file.id,
-        action: 'modified',
-        previous_storage_path: (created.file && created.file.storage_path) || upd.file.storage_path,
-        new_storage_path: upd.file.storage_path,
-      },
-    };
-  });
+    });
 
-  for (const r of addedResults) {
-    if (r && r.__error) {
-      failedWrites.push({ relPath: r.item.relPath, reason: r.__error });
-      ui.error(`${r.item.relPath} — ${r.__error}`);
-      continue;
+    // `runPool` devuelve los resultados alineados con la entrada, así que el
+    // índice de `queue` alcanza para volver a la posición original.
+    for (let k = 0; k < results.length; k += 1) {
+      const r = results[k];
+      outcomes[queue[k].i] = r && r.__error ? { ok: false, reason: r.__error } : r;
     }
-    changes.push(r.change);
-    ui.success(`${ui.c[r.symbol === '+' ? 'green' : 'yellow'](r.symbol)} ${r.u.relPath}`);
+    return outcomes;
   }
-  config.persistCredsIfChanged(cfg, mgr.current);
 
-  const modifiedResults = await sync.runPool(plan.modified, sync.CONCURRENCY, async (u) => {
-    const creds = await mgr.valid();
-    const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
-    return {
-      u,
-      change: {
-        file_id: upd.file.id,
-        action: 'modified',
-        previous_storage_path: u.remote ? u.remote.storage_path : undefined,
-        new_storage_path: upd.file.storage_path,
-      },
-    };
-  });
+  for (let bi = 0; bi < batches.length; bi += 1) {
+    const entries = batches[bi];
 
-  for (const r of modifiedResults) {
-    if (r && r.__error) {
-      failedWrites.push({ relPath: r.item.relPath, reason: r.__error });
-      ui.error(`${r.item.relPath} — ${r.__error}`);
-      continue;
+    // Un fallo de lectura (dejó de ser texto, permisos) saca a ese archivo del
+    // lote pero no arrastra a los demás.
+    const loaded = [];
+    for (const e of entries) {
+      try {
+        e.content = await loadContent(e.u);
+        loaded.push(e);
+      } catch (err) {
+        failedWrites.push({ relPath: e.u.relPath, reason: err.message });
+        logError(upProg, `${e.u.relPath} — ${err.message}`);
+        tickUp();
+      }
     }
-    changes.push(r.change);
-    ui.success(`${ui.c.yellow('~')} ${r.u.relPath}`);
-  }
-  config.persistCredsIfChanged(cfg, mgr.current);
+    if (loaded.length === 0) continue;
 
-  // 9) Commit(s) en lotes de <=100.
-  let committed = 0;
-  if (changes.length > 0) {
-    const total = changes.length;
-    const nBatches = Math.ceil(total / COMMIT_BATCH);
-    for (let i = 0; i < total; i += COMMIT_BATCH) {
-      const batch = changes.slice(i, i + COMMIT_BATCH);
-      const partNo = Math.floor(i / COMMIT_BATCH) + 1;
-      const msg = buildMessage(message, batch.length, total, partNo, nBatches, card);
+    // El lote se armó con lo que dijo el preflight, que sólo miró los primeros
+    // 8 KB. `loadContent` acaba de leer el archivo entero y pudo reclasificarlo,
+    // así que la partición se rehace ACÁ, sobre el contenido de verdad. Mandar
+    // un Buffer por el lote JSON lo convertiría en `{"type":"Buffer",...}`, que
+    // es la corrupción silenciosa que toda esta etapa existe para evitar.
+    const binaries = loaded.filter((e) => e.u.binary);
+    const texts = loaded.filter((e) => !e.u.binary);
+
+    const outcomeByEntry = new Map();
+
+    if (binaries.length > 0) {
+      // Un fallo acá es por archivo, no del lote: `writeViaDirect` devuelve un
+      // resultado por entrada y los errores ya vienen adentro.
+      const res = await writeViaDirect(binaries);
+      binaries.forEach((e, i) => outcomeByEntry.set(e, res[i]));
+    }
+
+    if (texts.length > 0) {
+      const oversize =
+        texts.length === 1 && Buffer.byteLength(texts[0].content, 'utf8') > BATCH_MAX_BYTES;
+      let res = null;
+
+      if (batchSupported && !oversize) {
+        try {
+          res = await writeViaBatch(texts);
+        } catch (err) {
+          if (err.notSupported) {
+            batchSupported = false;
+            upProg.clear();
+            ui.warn('El servidor no acepta escritura por lotes; se sube archivo por archivo.');
+          } else {
+            // Falla del request entero (red, 5xx, permisos): ningún archivo de
+            // texto del lote se escribió. Los binarios ya se resolvieron aparte
+            // y no los arrastra.
+            res = texts.map(() => ({ ok: false, reason: err.message }));
+          }
+        }
+      }
+
+      if (!res) res = await writeViaSingle(texts);
+      texts.forEach((e, i) => outcomeByEntry.set(e, res[i]));
+    }
+
+    const outcomes = loaded.map((e) => outcomeByEntry.get(e));
+    config.persistCredsIfChanged(cfg, mgr.current);
+
+    const batchChanges = [];
+    for (let i = 0; i < loaded.length; i += 1) {
+      const e = loaded[i];
+      const o = outcomes[i];
+      if (!o || !o.ok) {
+        const reason = (o && o.reason) || 'error desconocido';
+        failedWrites.push({ relPath: e.u.relPath, reason });
+        logError(upProg, `${e.u.relPath} — ${reason}`);
+        continue;
+      }
+      batchChanges.push(o.change);
+      uploaded.push({ ...e.u, hash: pushindex.hashContent(e.content) });
+      logFile(upProg, `${ui.c[o.symbol === '+' ? 'green' : 'yellow'](o.symbol)} ${e.u.relPath}`);
+    }
+    tickUp(loaded.length);
+
+    // 9) Commit del lote, apenas termina de escribirse. Juntar todos los cambios
+    //    para un commit final ahorraba requests, pero dejaba una ventana larga
+    //    en la que los archivos ya estaban escritos y ningún commit los
+    //    mencionaba; si el push moría ahí, el historial quedaba mintiendo.
+    if (batchChanges.length > 0) {
+      const partNo = bi + 1;
+      const msg = buildMessage(
+        message,
+        batchChanges.length,
+        toUpload.length,
+        partNo,
+        batches.length,
+        card
+      );
       try {
         const creds = await mgr.valid();
-        await client.createCommit(projectId, msg, batch, creds);
-        committed += batch.length;
+        await client.createCommit(projectId, msg, batchChanges, creds);
+        committed += batchChanges.length;
+        commitCount += 1;
         config.persistCredsIfChanged(cfg, mgr.current);
       } catch (e) {
-        ui.error(`Fallo al crear el commit (lote ${partNo}/${nBatches}): ${e.message}`);
+        ui.error(`Fallo al crear el commit (lote ${partNo}/${batches.length}): ${e.message}`);
         failedWrites.push({ relPath: `<commit lote ${partNo}>`, reason: e.message });
       }
     }
+
+    // El contenido ya se hasheó y se subió: soltarlo mantiene el pico de memoria
+    // atado al tamaño del lote y no al del repo.
+    for (const e of loaded) {
+      e.content = null;
+      e.u.content = null;
+    }
   }
+  upProg.clear();
 
   config.persistCredsIfChanged(cfg, mgr.current);
 
-  // 10) Anotar la sincronización: `status` la usa después para saber qué del
-  //     remoto es posterior a lo último que subimos.
-  if (failedWrites.length === 0) {
+  // 10) Índice local: lo que subimos bien y lo que ya estaba igual. El próximo
+  //     push arranca sabiendo qué no hace falta ni leer.
+  if (useIndex) {
+    for (const u of uploaded) {
+      pushindex.record(index, u, pushedAt);
+    }
+    saveIndex(dir, index, plan, uploads, pushedAt);
+  }
+
+  // 11) Anotar la sincronización: `status` la usa después para saber qué del
+  //     remoto es posterior a lo último que subimos. Sólo si TODO salió bien:
+  //     con archivos fallados, marcar "sincronizado" haría que status mienta.
+  if (failedWrites.length === 0 && plan.failed.length === 0) {
     remote.touchSync(dir, { projectId, baseURL });
   }
 
-  // 11) Resumen final.
+  // 12) Resumen final.
   ui.info('');
-  const nCommits = Math.ceil(changes.length / COMMIT_BATCH);
-  if (failedWrites.length === 0) {
-    ui.success(
-      `Push completo: ${committed} archivo(s) en ${nCommits} commit(s).`
-    );
+  if (failedWrites.length === 0 && plan.failed.length === 0) {
+    ui.success(`Push completo: ${committed} archivo(s) en ${commitCount} commit(s).`);
     return 0;
   }
-  ui.warn(`Push con problemas: ${failedWrites.length} archivo(s)/commit(s) fallaron.`);
+  for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
+  ui.warn(
+    `Push con problemas: ${failedWrites.length + plan.failed.length} archivo(s)/commit(s) fallaron.`
+  );
   return 1;
 }
 
+/**
+ * Lee el contenido completo de un archivo, cacheado en la propia entrada.
+ *
+ * Devuelve un `string` para texto y un `Buffer` para binarios. Esa diferencia
+ * es la que decide por qué camino sube el archivo, así que se re-clasifica acá y
+ * no se confía en lo que dijo el preflight: entre una cosa y la otra el archivo
+ * pudo cambiar, y el preflight sólo miró los primeros 8 KB.
+ *
+ * `u.binary` y `u.mimeType` se corrigen con lo que digan los bytes completos.
+ * Un archivo que el preflight leyó como texto y resultó binario tiene que
+ * cambiar de camino, no subirse mal por el que ya tenía asignado.
+ */
+async function loadContent(u) {
+  if (u.content != null) return u.content;
+
+  const buf = await fs.promises.readFile(u.absPath);
+  const cls = classifyContent(path.basename(u.relPath), buf);
+
+  if (cls.isBinary) {
+    u.binary = true;
+    u.mimeType = cls.mimeType;
+    u.content = cls.buffer;
+    return u.content;
+  }
+
+  if (!cls.isText) throw new Error(cls.reason);
+
+  u.binary = false;
+  u.content = cls.content;
+  return u.content;
+}
+
+/**
+ * Registra en el índice los archivos que ya estaban idénticos (para no volver a
+ * compararlos), saca los que ya no existen y lo escribe.
+ */
+function saveIndex(dir, index, plan, uploads, pushedAt = Date.now()) {
+  for (const u of plan.unchanged) {
+    if (u.content != null) {
+      pushindex.record(index, { ...u, hash: pushindex.hashContent(u.content) }, pushedAt);
+    }
+  }
+  pushindex.prune(index, new Set(uploads.map((u) => u.relPath)));
+  pushindex.write(dir, index);
+}
+
 /**
  * Arma el mensaje del commit. Si vino `--card`, se agrega como trailer
  * `[card: <id>]` al final: queda visible en el historial y es fácil de grepear