shilo-cli 0.3.2 → 0.6.0

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);