shilo-cli 0.3.0 → 0.3.1

package/package.json

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

package/src/commands/push.js

@@ -138,40 +138,45 @@ async function push(args) {
 
   // 5) Clasificar contra el remote (added / modified / unchanged) para planear.
   //    Esto ya toca la red (getFileMeta / readFile) pero no escribe nada.
-  let creds = cfg.credentials;
+  //    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.
+  const mgr = sync.makeCredsManager(client, cfg);
   const plan = { added: [], modified: [], unchanged: [], failed: [] };
 
-  for (const u of uploads) {
-    try {
-      const meta = await client.getFileMeta(projectId, u.relPath, creds);
-      creds = meta.credentials;
+  const planResults = await sync.runPool(uploads, sync.CONCURRENCY, async (u) => {
+    const creds = await mgr.valid();
+    const meta = await client.getFileMeta(projectId, u.relPath, creds);
 
-      if (!meta.exists) {
-        plan.added.push(u);
-        continue;
-      }
-      if (meta.file && meta.file.type === 'folder') {
-        plan.failed.push({ ...u, reason: 'ya existe una carpeta con ese nombre' });
-        continue;
-      }
+    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' };
+    }
 
-      // 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 remoteRead = await client.readFile(projectId, u.relPath, creds);
-        creds = remoteRead.credentials;
-        if (remoteRead.file && remoteRead.file.content === u.content) {
-          plan.unchanged.push(u);
-          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 };
       }
-      plan.modified.push({ ...u, remote: meta.file });
-    } catch (e) {
-      plan.failed.push({ ...u, reason: e.message });
     }
+    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 });
+      continue;
+    }
+    if (r.kind === 'failed') plan.failed.push({ ...r.u, reason: r.reason });
+    else plan[r.kind].push(r.u);
   }
 
-  config.persistCredsIfChanged(cfg, creds);
+  config.persistCredsIfChanged(cfg, mgr.current);
 
   // 5b) 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
@@ -179,7 +184,6 @@ async function push(args) {
   let attribution = { index: new Map() };
   const myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
   if (plan.modified.length > 0) {
-    const mgr = sync.makeCredsManager(client, cfg);
     attribution = await sync.buildAuthorIndex(client, projectId, mgr, { commits: 50 });
     config.persistCredsIfChanged(cfg, mgr.current);
   }
@@ -266,57 +270,94 @@ async function push(args) {
   const ensuredCache = new Set();
   const failedWrites = [];
 
+  // 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 {
-      creds = await client.ensurePath(projectId, u.relPath, creds, ensuredCache);
-      const created = await client.createFile(
-        projectId, u.relPath, u.content, u.mimeType, creds
-      );
-      creds = created.credentials;
-
-      if (created.created && created.file) {
-        changes.push({
-          file_id: created.file.id,
-          action: 'added',
-          new_storage_path: created.file.storage_path,
-        });
-        ui.success(`${ui.c.green('+')} ${u.relPath}`);
-      } else {
-        // 409: apareció entremedio; caemos a update.
-        const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
-        creds = upd.credentials;
-        changes.push({
-          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,
-        });
-        ui.success(`${ui.c.yellow('~')} ${u.relPath}`);
-      }
-      config.persistCredsIfChanged(cfg, creds);
+      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}`);
     }
   }
+  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 creds = await mgr.valid();
+    const created = await client.createFile(projectId, u.relPath, u.content, u.mimeType, creds);
+
+    if (created.created && created.file) {
+      return {
+        u,
+        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, 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 u of plan.modified) {
-    try {
-      const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
-      creds = upd.credentials;
-      changes.push({
+  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;
+    }
+    changes.push(r.change);
+    ui.success(`${ui.c[r.symbol === '+' ? 'green' : 'yellow'](r.symbol)} ${r.u.relPath}`);
+  }
+  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,
-      });
-      ui.success(`${ui.c.yellow('~')} ${u.relPath}`);
-      config.persistCredsIfChanged(cfg, creds);
-    } catch (e) {
-      failedWrites.push({ relPath: u.relPath, reason: e.message });
-      ui.error(`${u.relPath} — ${e.message}`);
+      },
+    };
+  });
+
+  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;
     }
+    changes.push(r.change);
+    ui.success(`${ui.c.yellow('~')} ${r.u.relPath}`);
   }
+  config.persistCredsIfChanged(cfg, mgr.current);
 
   // 9) Commit(s) en lotes de <=100.
   let committed = 0;
@@ -328,10 +369,10 @@ async function push(args) {
       const partNo = Math.floor(i / COMMIT_BATCH) + 1;
       const msg = buildMessage(message, batch.length, total, partNo, nBatches, card);
       try {
-        const result = await client.createCommit(projectId, msg, batch, creds);
-        creds = result.credentials;
+        const creds = await mgr.valid();
+        await client.createCommit(projectId, msg, batch, creds);
         committed += batch.length;
-        config.persistCredsIfChanged(cfg, creds);
+        config.persistCredsIfChanged(cfg, mgr.current);
       } catch (e) {
         ui.error(`Fallo al crear el commit (lote ${partNo}/${nBatches}): ${e.message}`);
         failedWrites.push({ relPath: `<commit lote ${partNo}>`, reason: e.message });
@@ -339,7 +380,7 @@ async function push(args) {
     }
   }
 
-  config.persistCredsIfChanged(cfg, creds);
+  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.