shilo-cli 0.5.0 → 0.7.0

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/remote.js

@@ -11,13 +11,22 @@
  * {
  *   "projectId": "<uuid>",
  *   "baseURL": "https://www.shilo.city",
- *   "lastSync": "2026-07-27T12:00:00.000Z"
+ *   "lastSync": "2026-07-27T12:00:00.000Z",
+ *   "base": "<oid de la versión actual que esta carpeta vio por última vez>"
  * }
  *
  * `lastSync` es la marca de la última vez que esta carpeta quedó alineada con
  * el remoto (fin de un push o pull exitoso). `status` la usa para distinguir
  * "el remoto cambió desde que sincronicé" de "esto lo subí yo".
  *
+ * `base` es lo mismo pero exacto: el punto de guardado del que parte esta
+ * carpeta. `push` lo manda con cada propuesta para que el servidor sepa contra
+ * qué comparar — un archivo que otra persona cambió después de esa base y que
+ * acá también se cambió es un conflicto, no una sobreescritura. Va acá y no en
+ * `.shilo/index.json` porque el índice es una optimización descartable
+ * (`--no-index` lo ignora) y la base es un dato: perderla no rompe nada, pero
+ * vuelve el push siguiente ciego a lo que cambiaron los demás.
+ *
  * NO contiene credenciales (esas están en ~/.shilo/config.json, cifradas), así
  * que es seguro commitearlo al repo si el usuario quiere.
  */
@@ -49,17 +58,19 @@ function read(dir) {
     projectId: raw.projectId || null,
     baseURL: raw.baseURL || null,
     lastSync: raw.lastSync || null,
+    base: typeof raw.base === 'string' && /^[0-9a-f]{64}$/.test(raw.base) ? raw.base : null,
   };
 }
 
 /**
  * Escribe `.shilo.json` en `dir`. Devuelve la ruta escrita.
  */
-function write(dir, { projectId, baseURL, lastSync }) {
+function write(dir, { projectId, baseURL, lastSync, base }) {
   const p = remotePath(dir);
   const onDisk = { projectId };
   if (baseURL) onDisk.baseURL = baseURL;
   if (lastSync) onDisk.lastSync = lastSync;
+  if (base) onDisk.base = base;
   fs.writeFileSync(p, JSON.stringify(onDisk, null, 2) + '\n', 'utf8');
   return p;
 }
@@ -69,13 +80,14 @@ function write(dir, { projectId, baseURL, lastSync }) {
  * remote. No es fatal si falla (la carpeta puede ser de sólo lectura): devuelve
  * `false` y el caller decide si avisar.
  */
-function touchSync(dir, { projectId, baseURL } = {}) {
+function touchSync(dir, { projectId, baseURL, base } = {}) {
   try {
     const current = read(dir) || {};
     write(dir, {
       projectId: projectId || current.projectId,
       baseURL: baseURL || current.baseURL,
       lastSync: new Date().toISOString(),
+      base: base || current.base || null,
     });
     return true;
   } catch (_) {

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,
 };