shilo-cli 0.6.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shilo-cli",
-  "version": "0.6.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

@@ -524,6 +524,58 @@ class ShiloClient {
    * 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,
@@ -574,19 +626,7 @@ class ShiloClient {
       uploaded = true;
     }
 
-    const done = await this._authFetch(url, begun.credentials, {
-      method: 'POST',
-      body: { action: 'commit', ...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, credentials: done.credentials };
+    return { url, payload, uploaded, credentials: begun.credentials };
   }
 
   /**
@@ -701,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

@@ -55,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.
@@ -68,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);
@@ -245,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}`);