shilo-cli 0.3.0 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
 # shilo-cli
 
-CLI para subir carpetas locales a repositorios de [Shilo](https://shilo-six.vercel.app),
+CLI para subir carpetas locales a repositorios de [Shilo](https://www.shilo.city),
 con una experiencia tipo git: `shilo login` una vez y después `shilo push`.
 
 > **Estado:** Fase 5 (colaboración asíncrona). Disponibles `login`, `whoami`, `logout`,

package/bin/shilo.js

@@ -28,7 +28,7 @@ ${ui.c.bold('Opciones de login:')}
   --email <e>        Email (si se omite, se pregunta).
   --password <p>     Contraseña (si se omite, se pregunta oculta).
   --token <pat>      Token de acceso personal (en vez de email + contraseña).
-  --base-url <url>   Servidor Shilo (default: https://shilo-six.vercel.app).
+  --base-url <url>   Servidor Shilo (default: https://www.shilo.city).
 
 ${ui.c.bold('Opciones de init:')}
   --project <uuid>   Id del proyecto de Shilo (requerido).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shilo-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log y diff.",
   "keywords": [
     "shilo",
@@ -13,7 +13,7 @@
     "upload",
     "repositorios"
   ],
-  "homepage": "https://shilo-six.vercel.app",
+  "homepage": "https://www.shilo.city",
   "bin": {
     "shilo": "bin/shilo.js"
   },

package/src/ShiloClient.js

@@ -18,9 +18,20 @@
  * con las credenciales posiblemente refrescadas, para que el caller las persista.
  */
 
-const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_BASE_URL = 'https://www.shilo.city';
 const DEFAULT_TIMEOUT_MS = 45000;
 
+/**
+ * El ápex https://shilo.city responde 307 hacia https://www.shilo.city. Como
+ * `fetch` sigue redirects pero descarta el header Authorization al cruzar de
+ * origen, apuntar al ápex haría fallar con 401 todo lo autenticado (push, pull,
+ * projects). Normalizamos a www para que nunca ocurra ese salto.
+ */
+function normalizeBaseURL(url) {
+  const clean = String(url).replace(/\/+$/, '');
+  return clean.replace(/^(https?:\/\/)shilo\.city(?=$|\/)/i, '$1www.shilo.city');
+}
+
 class ShiloError extends Error {
   constructor(message, { status = null, body = null } = {}) {
     super(message);
@@ -32,7 +43,7 @@ class ShiloError extends Error {
 
 class ShiloClient {
   constructor(options = {}) {
-    this.baseURL = (options.baseURL || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    this.baseURL = normalizeBaseURL(options.baseURL || DEFAULT_BASE_URL);
     this.timeoutMs = Number(options.timeoutMs) || DEFAULT_TIMEOUT_MS;
     // Opcionales: habilitan refresh de token sin re-login.
     this.supabaseUrl = options.supabaseUrl || null;

package/src/commands/init.js

@@ -8,7 +8,7 @@ const prompt = require('../prompt');
 const ui = require('../ui');
 const { ShiloClient } = require('../ShiloClient');
 
-const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_BASE_URL = 'https://www.shilo.city';
 
 // UUID v4 laxo (acepta cualquier versión). El backend valida de verdad; esto es
 // sólo un aviso temprano ante un typo evidente.

package/src/commands/login.js

@@ -5,7 +5,7 @@ const prompt = require('../prompt');
 const ui = require('../ui');
 const { ShiloClient } = require('../ShiloClient');
 
-const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_BASE_URL = 'https://www.shilo.city';
 
 /**
  * shilo login [--email <e>] [--password <p>] [--token <pat>] [--base-url <url>]

package/src/commands/push.js

@@ -11,7 +11,7 @@ const { walk } = require('../walk');
 const { classifyContent } = require('../textguard');
 const { ShiloClient } = require('../ShiloClient');
 
-const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_BASE_URL = 'https://www.shilo.city';
 const COMMIT_BATCH = 100; // máximo de archivos por commit (límite del backend)
 
 // Mapa mínimo extensión -> mime para texto. El backend default es text/plain.
@@ -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.

package/src/config.js

@@ -58,7 +58,7 @@ function decrypt(payload) {
  * Estructura en disco:
  * {
  *   version: 1,
- *   baseURL: "https://shilo-six.vercel.app",
+ *   baseURL: "https://www.shilo.city",
  *   supabaseUrl?: "...",        // opcional, habilita refresh de token
  *   supabaseAnonKey?: "...",    // opcional (valor público)
  *   credentials: { iv, data }   // cifrado -> { jwt, refreshToken, expiresAt, user }

package/src/context.js

@@ -17,7 +17,7 @@ const ui = require('./ui');
 const sync = require('./sync');
 const { ShiloClient } = require('./ShiloClient');
 
-const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_BASE_URL = 'https://www.shilo.city';
 
 /**
  * Devuelve `{ ok: true, dir, projectId, baseURL, cfg, client, mgr, savedRemote }`

package/src/remote.js

@@ -10,7 +10,7 @@
  * Estructura en disco:
  * {
  *   "projectId": "<uuid>",
- *   "baseURL": "https://shilo-six.vercel.app",
+ *   "baseURL": "https://www.shilo.city",
  *   "lastSync": "2026-07-27T12:00:00.000Z"
  * }
  *