shilo-cli 0.5.0 → 0.6.0

package/bin/shilo.js

@@ -138,9 +138,28 @@ async function main() {
   return handler(commandArgs);
 }
 
+/**
+ * Termina con `code` sin llamar a `process.exit()` de inmediato.
+ *
+ * Llamarlo justo después de un `fetch` aborta el proceso en Windows con
+ * `Assertion failed: !(handle->flags & UV_HANDLE_CLOSING)`: libuv cierra dos
+ * veces el handle del pool de conexiones de undici. El comando ya imprimió todo
+ * y hasta guardó en disco, pero el shell recibe 127 en vez de 0 — o sea que
+ * cualquier script o CI que chequee el resultado de `shilo push` lee basura.
+ *
+ * Dejar que el loop se vacíe solo evita el crash y no cuesta nada: las conexiones
+ * de undici no tienen ref, así que el proceso sale igual de rápido. El timer es
+ * el paracaídas por si algo queda colgado; sin ref, no mantiene vivo al proceso
+ * por sí mismo, sólo actúa si ya lo estaba.
+ */
+function finish(code) {
+  process.exitCode = code;
+  setTimeout(() => process.exit(code), 5000).unref();
+}
+
 main()
-  .then((code) => process.exit(typeof code === 'number' ? code : 0))
+  .then((code) => finish(typeof code === 'number' ? code : 0))
   .catch((err) => {
     ui.error(err && err.message ? err.message : String(err));
-    process.exit(1);
+    finish(1);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shilo-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log y diff.",
   "keywords": [
     "shilo",

package/src/ShiloClient.js

@@ -89,7 +89,7 @@ class ShiloClient {
   }
 
   /** Un intento único, sin reintentos. */
-  async _fetchOnce(url, { method = 'GET', headers = {}, body = null } = {}) {
+  async _fetchOnce(url, { method = 'GET', headers = {}, body = null, raw = false } = {}) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     let res;
@@ -97,7 +97,11 @@ class ShiloClient {
       res = await fetch(url, {
         method,
         headers,
-        body: body != null ? JSON.stringify(body) : undefined,
+        // Un Buffer va tal cual: es el cuerpo de una subida a URL firmada, y
+        // pasarlo por JSON.stringify lo convertiría en el texto "{\"type\":
+        // \"Buffer\",\"data\":[...]}", que es exactamente la corrupción
+        // silenciosa que la subida directa vino a evitar.
+        body: body == null ? undefined : Buffer.isBuffer(body) ? body : JSON.stringify(body),
         signal: controller.signal,
       });
     } catch (err) {
@@ -111,6 +115,14 @@ class ShiloClient {
     }
     clearTimeout(timer);
 
+    // `raw`: la respuesta son bytes (un binario bajado de una URL firmada) y
+    // leerla como texto la decodificaría como UTF-8, que es destruirla. Los
+    // errores tampoco se parsean acá: con `raw` el llamador mira `res.status`.
+    if (raw) {
+      const buffer = res.ok ? Buffer.from(await res.arrayBuffer()) : null;
+      return { res, data: buffer };
+    }
+
     const text = await res.text();
     let data = null;
     if (text) {
@@ -307,7 +319,7 @@ class ShiloClient {
   async _authFetch(url, credentials, { method = 'GET', body = null } = {}) {
     const validCreds = await this.ensureValidToken(credentials);
     const headers = { Authorization: `Bearer ${validCreds.jwt}` };
-    if (body != null) headers['Content-Type'] = 'application/json';
+    if (body != null && !Buffer.isBuffer(body)) headers['Content-Type'] = 'application/json';
     const { res, data } = await this._fetch(url, { method, headers, body });
     return { res, data, credentials: validCreds };
   }
@@ -366,7 +378,18 @@ class ShiloClient {
     }
     const file = data && data.file ? data.file : {};
     const content = data && data.content !== undefined ? data.content : null;
-    return { file: { ...file, content }, credentials: creds };
+    // Un binario no viene con contenido: viene con una URL firmada para bajarlo
+    // directo de Storage (ver `downloadBinary`). Los dos campos se pegan al
+    // `file` para que el llamador decida con un solo objeto en la mano.
+    return {
+      file: {
+        ...file,
+        content,
+        is_binary: Boolean(data && data.is_binary),
+        download_url: (data && data.download_url) || null,
+      },
+      credentials: creds,
+    };
   }
 
   /**
@@ -459,6 +482,113 @@ class ShiloClient {
     return { results, summary, credentials: creds };
   }
 
+  /**
+   * Baja los bytes de una URL firmada. Devuelve un Buffer.
+   *
+   * No lleva `Authorization`: la firma ES la autorización, y mandar el JWT a una
+   * URL de Storage sería filtrarlo a un origen que no lo necesita.
+   */
+  async downloadBinary(signedUrl) {
+    const { res, data } = await this._fetch(signedUrl, { method: 'GET', raw: true });
+    if (!res.ok || !data) {
+      throw new ShiloError(`No se pudo descargar el contenido: HTTP ${res.status}`, {
+        status: res.status,
+      });
+    }
+    return data;
+  }
+
+  /**
+   * Sube un archivo binario: URL firmada, tres pasos.
+   *
+   * El contenido NO puede viajar por `writeBatch` ni por `writeFile`: esos
+   * mandan el archivo como string dentro de un JSON, y el backend lo hashea con
+   * `Buffer.from(content, 'utf8')`. Un binario se corrompe ahí, ANTES de
+   * hashearse, y el grafo registra el resultado corrupto como válido — no hay
+   * verificador que lo note, porque para el motor no pasó nada raro. Por eso el
+   * byte va directo a Storage y nunca entra en un payload JSON.
+   *
+   * Los tres pasos:
+   *   1. `begin`  — el servidor firma una URL contra la ruta por contenido del
+   *                  blob. Si ese contenido ya está en el proyecto responde
+   *                  `exists: true` y no hay nada que transferir: el archivo ya
+   *                  está ahí, aunque sea con otro nombre.
+   *   2. PUT      — los bytes, directo a Storage. No pasa por la función
+   *                  serverless, así que el límite de payload de Vercel deja de
+   *                  aplicar.
+   *   3. `commit` — el servidor verifica y apunta la fila de `files` al blob.
+   *
+   * `entry`: { path, buffer, mimeType }.
+   * Devuelve `{ result, uploaded, credentials }`, donde `result` tiene la misma
+   * forma que un elemento de `writeBatch` (`ok`, `action`, `file`) y `uploaded`
+   * dice si hubo bytes en el aire.
+   */
+  async uploadBinary(projectId, entry, credentials) {
+    const url = `${this.baseURL}/api/files/${projectId}/direct`;
+    const payload = {
+      path: entry.path,
+      size: entry.buffer.length,
+      content_hash: entry.contentHash,
+      mime_type: entry.mimeType || 'application/octet-stream',
+    };
+
+    const begun = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { action: 'begin', ...payload },
+    });
+
+    if (!begun.res.ok) {
+      throw new ShiloError(
+        `No se pudo preparar la subida de "${entry.path}": ${this._errMessage(begun.data, `HTTP ${begun.res.status}`)}`,
+        {
+          status: begun.res.status,
+          body: begun.data,
+          notSupported: begun.res.status === 404 || begun.res.status === 405,
+        }
+      );
+    }
+
+    let uploaded = false;
+    const upload = begun.data && begun.data.upload;
+
+    if (upload && upload.url) {
+      const { res } = await this._fetch(upload.url, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': entry.mimeType || 'application/octet-stream',
+          // `x-upsert: false` es el default de una URL firmada de subida y se
+          // deja explícito: si el objeto ya existiera, pisarlo reemplazaría el
+          // contenido de un blob conservando su identidad, que es justo el
+          // ataque que el direccionamiento por contenido tiene que impedir.
+          'x-upsert': 'false',
+        },
+        body: entry.buffer,
+      });
+
+      if (!res.ok) {
+        throw new ShiloError(
+          `No se pudo subir el contenido de "${entry.path}": HTTP ${res.status}`,
+          { status: res.status }
+        );
+      }
+      uploaded = true;
+    }
+
+    const done = await this._authFetch(url, begun.credentials, {
+      method: 'POST',
+      body: { action: 'commit', ...payload },
+    });
+
+    if (!done.res.ok) {
+      throw new ShiloError(
+        `No se pudo registrar "${entry.path}": ${this._errMessage(done.data, `HTTP ${done.res.status}`)}`,
+        { status: done.res.status, body: done.data }
+      );
+    }
+
+    return { result: done.data, uploaded, credentials: done.credentials };
+  }
+
   /**
    * Crea una carpeta bajo `parentPath` (vacío = raíz). Un 409 significa que ya
    * existe: no es fatal, devolvemos `{ folder, existed: true }`.

package/src/commands/pull.js

@@ -30,6 +30,16 @@ function safeTarget(destDir, repoPath) {
   return { ok: true, target };
 }
 
+/** Los bytes de un archivo local, o null si no existe o no se puede leer. */
+function readLocalBytes(absPath) {
+  try {
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) return null;
+    return fs.readFileSync(absPath);
+  } catch (_) {
+    return null;
+  }
+}
+
 /**
  * shilo pull [carpeta] [--project <uuid>] [--base-url <url>] [--dry-run] [--yes] [--force]
  *
@@ -72,9 +82,13 @@ async function pull(args) {
     ui.warn(`no se pudo listar ${ui.c.dim(err.folderPath || '(raíz)')} — ${err.reason}`);
   }
 
-  // 1) Separar texto (descargable) de lo que no se puede bajar sin corromper.
+  // 1) Descartar sólo lo que no se puede escribir con seguridad.
+  //
+  //    Los binarios ya NO se saltean (Etapa 2 del PLAN_MOTOR_SHILO): el GET
+  //    devuelve una URL firmada en vez de contenido, y se bajan como bytes. Lo
+  //    que se saltaba antes no era una limitación del formato sino del camino:
+  //    el contenido viajaba como texto y un PNG volvía mutilado.
   const candidates = [];
-  const skippedBinary = [];
   const unsafe = [];
   for (const f of tree.files) {
     const safe = safeTarget(dir, f.repoPath);
@@ -82,15 +96,12 @@ async function pull(args) {
       unsafe.push({ repoPath: f.repoPath, reason: safe.reason });
       continue;
     }
-    if (!sync.isTextMime(f.mime_type)) {
-      skippedBinary.push({ repoPath: f.repoPath, reason: `mime no textual (${f.mime_type})` });
-      continue;
-    }
-    candidates.push({ ...f, target: safe.target });
+    candidates.push({ ...f, target: safe.target, binary: !sync.isTextMime(f.mime_type) });
   }
 
   for (const u of unsafe) ui.warn(`saltado ${ui.c.dim(u.repoPath)} — ${u.reason}`);
-  for (const s of skippedBinary) ui.warn(`saltado ${ui.c.dim(s.repoPath)} — ${s.reason}`);
+
+  const binaryCount = candidates.filter((f) => f.binary).length;
 
   // 2) Clasificar contra lo que hay en disco, sin bajar nada todavía.
   //    `maybeSame` (mismo tamaño) se confirma recién al descargar el contenido.
@@ -116,7 +127,7 @@ async function pull(args) {
       `  ${ui.c.yellow('en conflicto:')}    ${conflicting.length}   ${ui.c.dim('(difieren en tamaño del local)')}\n` +
       `  ${ui.c.dim('posiblemente iguales:')} ${maybeSame.length}\n` +
       `  ${ui.c.dim('sólo locales:')}     ${onlyLocal.length}   ${ui.c.dim('(el pull no los toca)')}` +
-      (skippedBinary.length ? `\n  ${ui.c.dim('binarios saltados:')} ${skippedBinary.length}` : '') +
+      (binaryCount ? `\n  ${ui.c.dim('binarios:')}        ${binaryCount}` : '') +
       (unsafe.length ? `\n  ${ui.c.red('inseguros:')}       ${unsafe.length}` : '')
   );
   ui.info('');
@@ -186,6 +197,23 @@ async function pull(args) {
   const outcomes = await sync.runPool(toDownload, CONCURRENCY, async (f) => {
     const creds = await mgr.valid();
     const read = await client.readFile(projectId, f.repoPath, creds);
+
+    // Binario: el servidor no manda contenido, manda una URL firmada. Los bytes
+    // se escriben tal cual, sin encoding: pasarlos por 'utf8' es exactamente lo
+    // que corrompía los binarios antes de esta etapa.
+    if (read.file && read.file.is_binary && read.file.download_url) {
+      const bytes = await client.downloadBinary(read.file.download_url);
+
+      const currentBytes = readLocalBytes(f.target);
+      if (currentBytes !== null && currentBytes.equals(bytes)) {
+        return { repoPath: f.repoPath, skipped: true };
+      }
+
+      fs.mkdirSync(path.dirname(f.target), { recursive: true });
+      fs.writeFileSync(f.target, bytes);
+      return { repoPath: f.repoPath, skipped: false };
+    }
+
     const content = read.file && read.file.content != null ? read.file.content : '';
 
     const current = sync.readLocalText(f.target);

package/src/commands/push.js

@@ -13,6 +13,7 @@ const { walk } = require('../walk');
 const {
   classifyContent,
   looksBinary,
+  binaryMimeType,
   extensionOf,
   BINARY_EXTENSIONS,
   MAX_FILE_BYTES,
@@ -54,7 +55,9 @@ const SKIP_LABELS = {
   symlink: 'symlinks (no soportados)',
   name: 'nombre no permitido por Shilo',
   depth: 'demasiado anidados',
-  binary: 'binarios o mayores a 25 MB',
+  // 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. */
@@ -78,6 +81,12 @@ function readHead(absPath, 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);
@@ -89,41 +98,43 @@ function preflight(dir) {
   for (const f of files) {
     const name = path.basename(f.relPath);
 
-    const ext = extensionOf(name);
-    if (ext && BINARY_EXTENSIONS.has(ext)) {
-      skips.push({ relPath: f.relPath, reason: `extensión binaria .${ext}`, code: 'binary' });
-      continue;
-    }
     if (f.size > MAX_FILE_BYTES) {
-      skips.push({ relPath: f.relPath, reason: `supera 25 MB (${f.size} bytes)`, code: 'binary' });
-      continue;
-    }
-
-    let head;
-    try {
-      head = readHead(f.absPath, HEAD_BYTES);
-    } catch (e) {
-      skips.push({ relPath: f.relPath, reason: `no se pudo leer: ${e.message}`, code: 'unreadable' });
-      continue;
-    }
-
-    if (looksBinary(head)) {
       skips.push({
         relPath: f.relPath,
-        reason: 'contenido binario (bytes no imprimibles)',
-        code: 'binary',
+        reason: `supera ${MAX_FILE_BYTES / (1024 * 1024)} MB (${f.size} bytes)`,
+        code: 'size',
       });
       continue;
     }
 
-    findings.push(...secrets.inspect(f.relPath, head.toString('utf8')));
+    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,
-      mimeType: guessMime(f.relPath),
+      binary,
+      mimeType: binary ? binaryMimeType(name) : guessMime(f.relPath),
       content: null,
     });
   }
@@ -301,7 +312,7 @@ async function push(args) {
   }
 
   if (uploads.length === 0) {
-    ui.info('No hay archivos de texto para subir.');
+    ui.info('No hay archivos para subir.');
     ui.info(ui.c.dim(`(${ignored} ignorados, ${skipped.length} salteados)`));
     return 0;
   }
@@ -323,7 +334,8 @@ async function push(args) {
 
   ui.info(
     `Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — ` +
-      `${uploads.length} archivo(s) de texto, ${ignored} ignorado(s), ` +
+      `${uploads.length} archivo(s) (${uploads.filter((u) => u.binary).length} binario(s)), ` +
+      `${ignored} ignorado(s), ` +
       `${skipped.length} salteado(s).`
   );
 
@@ -457,6 +469,19 @@ async function push(args) {
         }
 
         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) {
@@ -666,13 +691,23 @@ async function push(args) {
 
   // 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, que admite hasta 25 MB.
+  // 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 toUpload) {
-      const bytes = typeof e.u.size === 'number' ? e.u.size : 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) {
@@ -719,11 +754,63 @@ async function push(args) {
         // 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();
@@ -780,6 +867,10 @@ async function push(args) {
           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 }
+            : {}),
         },
       };
     });
@@ -811,32 +902,50 @@ async function push(args) {
     }
     if (loaded.length === 0) continue;
 
-    const oversize =
-      loaded.length === 1 && Buffer.byteLength(loaded[0].content, 'utf8') > BATCH_MAX_BYTES;
-    let outcomes = null;
+    // 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 (batchSupported && !oversize) {
-      try {
-        outcomes = await writeViaBatch(loaded);
-      } 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 del
-          // lote se escribió.
-          for (const e of loaded) {
-            failedWrites.push({ relPath: e.u.relPath, reason: err.message });
-            logError(upProg, `${e.u.relPath} — ${err.message}`);
+    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 }));
           }
-          tickUp(loaded.length);
-          continue;
         }
       }
+
+      if (!res) res = await writeViaSingle(texts);
+      texts.forEach((e, i) => outcomeByEntry.set(e, res[i]));
     }
 
-    if (!outcomes) outcomes = await writeViaSingle(loaded);
+    const outcomes = loaded.map((e) => outcomeByEntry.get(e));
     config.persistCredsIfChanged(cfg, mgr.current);
 
     const batchChanges = [];
@@ -923,13 +1032,32 @@ async function push(args) {
 
 /**
  * Lee el contenido completo de un archivo, cacheado en la propia entrada.
- * Re-valida que siga siendo texto: entre el preflight y la subida pudo cambiar.
+ *
+ * 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;
 }

package/src/pushindex.js

@@ -40,7 +40,12 @@ function indexPath(dir) {
 
 /** SHA-256 hex de un contenido utf8. */
 function hashContent(content) {
-  return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+  // Un binario llega como Buffer y un archivo de texto como string. Se hashean
+  // los BYTES en los dos casos: el hash tiene que ser el mismo que calcula el
+  // backend sobre el contenido crudo (`files.content_hash`, migración 010), o
+  // el push reportaría "modificado" en cada corrida.
+  const buf = Buffer.isBuffer(content) ? content : Buffer.from(String(content), 'utf8');
+  return crypto.createHash('sha256').update(buf).digest('hex');
 }
 
 /**

package/src/textguard.js

@@ -1,12 +1,24 @@
 'use strict';
 
 /**
- * Validación de nombres y detección de binarios para el push.
+ * Validación de nombres y clasificación de contenido para el push.
  *
- * Shilo sólo acepta contenido de texto (el endpoint path-based sube el body
- * como utf8, así que un binario se corrompería) y rechaza los nombres de
- * archivo/carpeta que rompen una ruta o no son portables. Aquí filtramos ambos
- * casos ANTES de tocar la red, para poder avisar y saltar.
+ * Hasta la Etapa 2 del PLAN_MOTOR_SHILO, Shilo sólo aceptaba texto: el endpoint
+ * por ruta sube el body como utf8, así que un binario se corrompía. Ahora los
+ * binarios SÍ se suben, pero por otro camino —`POST /api/files/:id/direct`, con
+ * URL firmada, sin pasar por JSON— y por eso este módulo ya no los rechaza:
+ * los CLASIFICA, para que el push sepa por dónde mandar cada archivo.
+ *
+ * Lo que sigue rechazando, y no cambió: los nombres que rompen una ruta o no son
+ * portables, y los archivos que superan el techo de tamaño. El escaneo de
+ * secretos también se queda; vive en `secrets.js` y sólo corre sobre texto,
+ * porque buscar patrones de credenciales en un JPEG es ruido.
+ *
+ * Espejo de `backend/utils/binary.js`: mismas constantes, misma heurística. Son
+ * dos paquetes sin dependencia entre sí (el CLI se publica solo y no tiene un
+ * solo `dependencies`), así que la duplicación es deliberada — pero si cambia
+ * una tiene que cambiar la otra, o un archivo se clasifica de un modo en el
+ * cliente y de otro en el servidor.
  */
 
 // Espejo de `backend/utils/filenames.js`: lista negra, no lista blanca. El
@@ -19,7 +31,9 @@ const ILLEGAL_CHARS = /[<>:"/\\|?*]/;
 const WIN_RESERVED = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|$)/i;
 
 const MAX_NAME_LEN = 255;
-const MAX_FILE_BYTES = 26214400; // 25 MB, igual que el backend
+// Espejo de MAX_FILE_BYTES en backend/utils/binary.js y del CHECK
+// `file_size_valid` de la migración 014. Los tres son el mismo número.
+const MAX_FILE_BYTES = 52428800; // 50 MB, igual que el backend
 const MAX_DEPTH = 10; // profundidad máxima de carpetas
 
 // Extensiones típicamente binarias: pre-filtro rápido antes de leer bytes.
@@ -126,23 +140,58 @@ function looksBinary(buffer, sample = 8000) {
 }
 
 /**
- * Decide si un archivo es texto apto para subir. Recibe el nombre (para la
- * extensión) y el Buffer con su contenido. Devuelve:
- *   { isText: true, content }                 -> subir `content` (utf8)
- *   { isText: false, reason }                 -> saltar con aviso
+ * Mapa mínimo extensión -> mime. El backend vuelve a adivinar por su cuenta con
+ * `mime-types`, pero mandar el tipo desde acá es mejor: el cliente vio los bytes
+ * y el servidor, en una subida directa, sólo ve el nombre.
+ */
+const MIME_BY_EXT = {
+  png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif',
+  webp: 'image/webp', avif: 'image/avif', bmp: 'image/bmp', ico: 'image/x-icon',
+  tiff: 'image/tiff', tif: 'image/tiff', heic: 'image/heic',
+  pdf: 'application/pdf', zip: 'application/zip', gz: 'application/gzip',
+  tar: 'application/x-tar', mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg',
+  mp4: 'video/mp4', mov: 'video/quicktime', webm: 'video/webm',
+  ttf: 'font/ttf', otf: 'font/otf', woff: 'font/woff', woff2: 'font/woff2',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+};
+
+/** Tipo de contenido de un binario. `octet-stream` cuando no se sabe. */
+function binaryMimeType(name) {
+  return MIME_BY_EXT[extensionOf(name)] || 'application/octet-stream';
+}
+
+/**
+ * Clasifica el contenido de un archivo. Recibe el nombre (para la extensión) y
+ * el Buffer con su contenido. Devuelve:
+ *   { isText: true,  content }                 -> sube por JSON (batch)
+ *   { isText: false, isBinary: true, buffer, mimeType }
+ *                                              -> sube por URL firmada (direct)
+ *   { isText: false, isBinary: false, reason }  -> saltar con aviso
+ *
+ * El techo de tamaño se comprueba PRIMERO, antes de decidir texto o binario: un
+ * archivo demasiado grande se saltea sea lo que sea, y ponerlo después haría que
+ * el mensaje dijera "binario" cuando el problema es el tamaño.
  */
 function classifyContent(name, buffer) {
-  const ext = extensionOf(name);
-  if (ext && BINARY_EXTENSIONS.has(ext)) {
-    return { isText: false, reason: `extensión binaria .${ext}` };
-  }
-  if (looksBinary(buffer)) {
-    return { isText: false, reason: 'contenido binario (bytes no imprimibles)' };
-  }
   if (buffer.length > MAX_FILE_BYTES) {
-    return { isText: false, reason: `supera 25 MB (${buffer.length} bytes)` };
+    return {
+      isText: false,
+      isBinary: false,
+      reason: `supera ${MAX_FILE_BYTES / (1024 * 1024)} MB (${buffer.length} bytes)`,
+    };
   }
-  return { isText: true, content: buffer.toString('utf8') };
+
+  const ext = extensionOf(name);
+  if ((ext && BINARY_EXTENSIONS.has(ext)) || looksBinary(buffer)) {
+    return { isText: false, isBinary: true, buffer, mimeType: binaryMimeType(name) };
+  }
+
+  return { isText: true, isBinary: false, content: buffer.toString('utf8') };
 }
 
 module.exports = {
@@ -157,5 +206,7 @@ module.exports = {
   validatePath,
   looksBinary,
   classifyContent,
+  binaryMimeType,
+  MIME_BY_EXT,
   extensionOf,
 };