shilo-cli 0.5.0 → 0.7.0

package/README.md

@@ -54,10 +54,19 @@ control, `.`/`..`, nombres de dispositivo de Windows (`CON`, `NUL`, `COM1`…) y
 final. Los nombres se normalizan a NFC, igual que el backend, para que el mismo archivo
 subido desde macOS y desde Windows sea uno solo.
 
-La subida va **por lotes** (hasta 100 archivos o 4 MB por request) y **cada lote se
-commitea apenas termina**: si el push se corta a la mitad, lo ya escrito queda en el
-historial en vez de quedar suelto en storage. Contra un servidor viejo que no conoce el
-endpoint de lotes, el CLI avisa y sigue archivo por archivo.
+Guardar es **proponer**: el push manda todo lo que cambió como una propuesta que parte
+de la versión que esta carpeta vio por última vez (`base` en `.shilo.json`, que
+`pull` y `push` van anotando). El servidor la aplica solo si combina limpio con la
+versión actual. Si otra persona cambió alguno de los **mismos archivos** desde esa
+base, la propuesta **queda abierta y no se pisa nada**: el CLI dice qué archivos son,
+tus cambios quedan guardados en esa propuesta para que el dueño decida, y vos podés
+traer la versión actual con `shilo pull`, ajustar y volver a `push`. Un push nuevo
+reemplaza tus propuestas abiertas anteriores.
+
+El texto viaja inline (hasta 500 archivos o 4 MB por propuesta; más que eso son varias
+propuestas de la misma base); los binarios y los textos de más de 1 MB se suben por URL
+firmada y entran por su identificador de contenido. Contra un servidor anterior a las
+propuestas, el CLI avisa y cae al camino viejo (escribir + commit), que sí puede pisar.
 
 #### Qué se ignora
 
@@ -97,10 +106,9 @@ que es lo que hace rápido el segundo push de una carpeta grande. Se puede ignor
 `--no-index` para recomparar todo contra el servidor. Agregá `.shilo/` a tu
 `.gitignore` (el CLI ya no lo sube).
 
-En `--dry-run` (y antes de la confirmación interactiva) cada archivo modificado
-muestra **quién lo tocó por última vez y cuándo**, y se avisa explícitamente si vas
-a pisar el trabajo de otra persona. Con token de acceso personal el autor se muestra
-igual, pero no se puede marcar cuál sos vos (el PAT no expone tu id de usuario).
+`--dry-run` lista qué se crearía y qué se actualizaría, sin tocar la red más que para
+leer el árbol. Ya no hace falta adivinar si vas a pisar a alguien: eso lo decide el
+servidor con la base exacta, y si pasa, no pisa.
 
 ### ¿Estoy desactualizado? (status)
 
@@ -231,6 +239,10 @@ SHILO_TOKEN=<pat> shilo init --project <uuid>   # variable de entorno (lo natura
   `.shilo/index.json`, lectura perezosa del contenido, reintentos con backoff ante
   429/5xx, concurrencia adaptativa, barra de progreso y confirmación real en
   `init --push`.
+- **Fase 7 — propuestas** *(hecho)*: `push` deja de escribir archivo por archivo y
+  manda una propuesta con la base exacta; el servidor la combina con la versión actual
+  y nunca pisa un archivo que otra persona cambió. `base` en `.shilo.json`,
+  `registerBlob` para binarios, camino viejo sólo como reserva.
 
 ## Exit codes
 

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.7.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,153 @@ 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 staged = await this._stageBlob(projectId, entry, credentials);
+    const done = await this._authFetch(staged.url, staged.credentials, {
+      method: 'POST',
+      body: { action: 'commit', ...staged.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: staged.uploaded, credentials: done.credentials };
+  }
+
+  /**
+   * Deja el contenido de un archivo en el proyecto SIN tocar la versión actual:
+   * los mismos pasos que `uploadBinary` pero el tercero es `register`, que
+   * verifica e inventaria el blob y no escribe ninguna fila de `files`. Es
+   * como un binario (o un texto demasiado grande para ir inline) entra a una
+   * propuesta: por su oid.
+   *
+   * Devuelve `{ oid, uploaded, credentials }`.
+   */
+  async registerBlob(projectId, entry, credentials) {
+    const staged = await this._stageBlob(projectId, entry, credentials);
+    const done = await this._authFetch(staged.url, staged.credentials, {
+      method: 'POST',
+      body: { action: 'register', ...staged.payload },
+    });
+
+    if (!done.res.ok) {
+      throw new ShiloError(
+        `No se pudo registrar el contenido de "${entry.path}": ${this._errMessage(done.data, `HTTP ${done.res.status}`)}`,
+        {
+          status: done.res.status,
+          body: done.data,
+          notSupported: done.res.status === 404 || done.res.status === 405,
+        }
+      );
+    }
+
+    return {
+      oid: (done.data && done.data.oid) || entry.contentHash,
+      uploaded: staged.uploaded,
+      credentials: done.credentials,
+    };
+  }
+
+  /** Pasos 1 y 2 de la subida directa: `begin` y, si hace falta, el PUT. */
+  async _stageBlob(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;
+    }
+
+    return { url, payload, uploaded, credentials: begun.credentials };
+  }
+
   /**
    * Crea una carpeta bajo `parentPath` (vacío = raíz). Un 409 significa que ya
    * existe: no es fatal, devolvemos `{ folder, existed: true }`.
@@ -571,6 +741,97 @@ class ShiloClient {
     const commit = (data && data.commit) || data;
     return { commit, credentials: creds };
   }
+
+  /**
+   * Propuestas (Etapa 3). Guardar es proponer: el cliente dice de qué versión
+   * partió (`base`, el oid de la versión actual que vio) y qué cambió, y el
+   * servidor decide si lo aplica solo o si lo deja abierto porque alguien más
+   * cambió los mismos archivos. Es lo que hace que un push nunca pise trabajo
+   * ajeno.
+   */
+
+  /**
+   * Lista las propuestas del proyecto y, de paso, la versión actual (`main`).
+   * Devuelve `{ main, proposals, credentials }`. Un servidor sin la Etapa 3
+   * responde 404: se marca `notSupported`.
+   */
+  async listProposals(projectId, credentials, { state = null } = {}) {
+    const params = new URLSearchParams({ projectId });
+    if (state) params.set('state', state);
+    const url = `${this.baseURL}/api/projects/proposals?${params.toString()}`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo leer la versión actual: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data, notSupported: res.status === 404 || res.status === 405 }
+      );
+    }
+    return {
+      main: (data && data.main) || null,
+      proposals: data && Array.isArray(data.proposals) ? data.proposals : [],
+      credentials: creds,
+    };
+  }
+
+  /**
+   * Abre una propuesta y deja que el servidor intente aplicarla.
+   *
+   * `changes`: [{ path, content, mime_type? } | { path, oid } | { path, delete: true }].
+   * Devuelve `{ applied, empty, proposal, conflicts, blockedBy, main, message,
+   * credentials }`. Los 200 y 202 son respuestas normales (aplicada / quedó
+   * abierta); cualquier otro estado es error.
+   */
+  async propose(projectId, { base, title, summary, changes }, credentials) {
+    const url = `${this.baseURL}/api/projects/proposals`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { projectId, base, title, summary, changes },
+    });
+    if (!res.ok && res.status !== 202) {
+      throw new ShiloError(
+        `No se pudo proponer el cambio: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data, notSupported: res.status === 404 || res.status === 405 }
+      );
+    }
+    return {
+      applied: !!(data && data.applied),
+      empty: !!(data && data.empty),
+      proposal: (data && data.proposal) || null,
+      conflicts: data && Array.isArray(data.conflicts) ? data.conflicts : [],
+      blockedBy: data && Array.isArray(data.blocked_by) ? data.blocked_by : [],
+      main: (data && data.main) || null,
+      message: (data && data.message) || '',
+      credentials: creds,
+    };
+  }
+
+  /**
+   * Resuelve una propuesta abierta: `apply` (dueño) o `discard` (dueño o
+   * autor). Devuelve `{ applied, proposal, conflicts, main, credentials }`; con
+   * `apply` un 409 significa que sigue en conflicto y viene con los datos.
+   */
+  async resolveProposal(projectId, id, action, credentials) {
+    const url = `${this.baseURL}/api/projects/proposals`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { projectId, id, action },
+    });
+    const stillOpen = action === 'apply' && res.status === 409 && data && data.proposal;
+    if (!res.ok && !stillOpen) {
+      throw new ShiloError(
+        `No se pudo resolver la propuesta: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    return {
+      applied: !!(data && data.applied),
+      proposal: (data && data.proposal) || null,
+      conflicts: data && Array.isArray(data.conflicts) ? data.conflicts : [],
+      main: (data && data.main) || null,
+      message: (data && data.message) || '',
+      credentials: creds,
+    };
+  }
 }
 
 module.exports = { ShiloClient, ShiloError };

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]
  *
@@ -45,7 +55,7 @@ async function pull(args) {
   const ctx = resolveContext(args, { requireDir: false });
   if (!ctx.ok) return ctx.code;
 
-  const { dir, projectId, baseURL, cfg, client, mgr } = ctx;
+  const { dir, projectId, baseURL, cfg, client, mgr, savedRemote } = ctx;
 
   // La carpeta destino puede no existir todavía: la creamos al escribir. Si
   // existe pero es un archivo, es un error del usuario.
@@ -58,6 +68,19 @@ async function pull(args) {
 
   ui.info(`Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — recorriendo árbol ...`);
 
+  // La versión actual ANTES de recorrer el árbol: si alguien guarda en el
+  // medio, la base que anotamos queda más vieja que los archivos que bajamos,
+  // y eso sólo puede hacer que el push siguiente vea un conflicto de más, nunca
+  // uno de menos. Un servidor sin la Etapa 3 no la tiene; se sigue sin base.
+  let main = null;
+  try {
+    const creds = await mgr.valid();
+    const listed = await client.listProposals(projectId, creds, { state: 'abierta' });
+    main = listed.main;
+  } catch (e) {
+    if (!e.notSupported) ui.warn(`No se pudo leer la versión actual: ${e.message}`);
+  }
+
   let tree;
   try {
     tree = await sync.walkRemote(client, projectId, mgr);
@@ -72,9 +95,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 +109,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 +140,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 +210,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);
@@ -217,9 +258,12 @@ async function pull(args) {
   const complete = failed.length === 0 && (args.force || conflicting.length === 0);
   try {
     if (complete) {
-      remote.write(dir, { projectId, baseURL, lastSync: new Date().toISOString() });
+      remote.write(dir, { projectId, baseURL, lastSync: new Date().toISOString(), base: main });
     } else if (written.length > 0) {
-      remote.write(dir, { projectId, baseURL });
+      // Carpeta a medias: se conserva la base anterior. Lo que sí se bajó ya
+      // coincide con la versión actual, así que en el próximo push no cuenta
+      // como cambio propio.
+      remote.write(dir, { projectId, baseURL, base: (savedRemote && savedRemote.base) || null });
     }
   } catch (e) {
     ui.warn(`No se pudo escribir ${remote.REMOTE_FILENAME}: ${e.message}`);