shilo-cli 0.3.2 → 0.6.0

package/README.md

@@ -39,12 +39,63 @@ shilo push -m "mi mensaje"        # con mensaje de commit
 shilo push --dry-run              # muestra qué haría sin subir
 shilo push --card ABC-123         # agrega "[card: ABC-123]" al mensaje del commit
 shilo push --yes                  # sin pedir confirmación
+shilo push --verbose              # lista archivo por archivo en vez de resumir
+shilo push --concurrency 4        # requests en paralelo (1-32, default 8)
 shilo push ./otra-carpeta --project <uuid>   # sin init, proyecto explícito
 ```
 
 Sólo se suben archivos de **texto**; binarios, oversize (>25 MB) y nombres con
 caracteres no permitidos se saltan con aviso. Los archivos sin cambios no se
-re-suben. Ignorá rutas con un `.shiloignore` (sintaxis estilo `.gitignore`).
+re-suben.
+
+Los nombres aceptan **espacios, acentos y Unicode** (`Notas Metrónomo.txt`, `日本語.md`):
+sólo se rechaza lo que rompe una ruta o no es portable — `/ \ : * ? " < > |`, bytes de
+control, `.`/`..`, nombres de dispositivo de Windows (`CON`, `NUL`, `COM1`…) y el punto
+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.
+
+#### Qué se ignora
+
+`push` respeta **`.gitignore` y `.shiloignore`**, incluidos los de subcarpetas (una
+regla de `src/.gitignore` sólo alcanza a `src/`). `.shiloignore` se lee último, así que
+podés re-incluir con `!` algo que git ignora. Por defecto ya se saltean `.git/`,
+`node_modules/`, `.shilo/`, `.vercel/`, `.DS_Store` y `Thumbs.db`.
+
+También se poda cualquier carpeta que **tenga forma de repo git** (`HEAD` + `objects/`
++ `refs/`), aunque no se llame `.git`: un `.git-ORIGINAL-BACKUP/` trae todo el
+historial, incluidos secretos de commits ya borrados del árbol de trabajo.
+
+> **Limitación conocida:** la negación `!` se evalúa por regla, no por directorio. Como
+> en git, `!` no puede re-incluir un archivo si su carpeta padre ya está excluida
+> (`dist/` + `!dist/keep.txt` no funciona); excluí el contenido en vez de la carpeta
+> (`dist/*` + `!dist/keep.txt`).
+
+Lo salteado se reporta **agrupado por motivo** (binario, ilegible, symlink, nombre
+inválido, profundidad) con unos pocos ejemplos; si una carpeta concentra muchos
+descartes, el CLI sugiere la línea de `.shiloignore` que la cubre. Con `--verbose` ves
+la lista completa.
+
+#### Escaneo de secretos
+
+Antes de tocar la red, `push` revisa nombres sospechosos (`.env`, `id_rsa`,
+`*.pem`, credenciales de service account…) y los primeros 8 KB de cada archivo
+buscando patrones de claves (AWS, JWT de Supabase, tokens de GitHub, claves privadas
+PEM…). Si encuentra algo, **no sube nada** y sale con código 1, indicando archivo y
+línea — nunca el valor detectado. Salidas: agregarlo a `.shiloignore`, sacar el
+secreto, o `--allow-secrets` si es un falso positivo.
+
+#### Índice local
+
+`push` guarda un índice en `.shilo/index.json` (tamaño + mtime + hash de lo último
+subido). Los archivos que no cambiaron se resuelven sin bajar el contenido remoto,
+que es lo que hace rápido el segundo push de una carpeta grande. Se puede ignorar con
+`--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
@@ -137,12 +188,25 @@ con AES-256-CBC y con permisos `0600`.
 Se almacena el JWT, el refresh token, la expiración y el email; **no** se guarda la
 contraseña.
 
+### Tokens de acceso personal (PAT)
+
+Un token pasado como `--token abc123` queda en el historial del shell y en la lista de
+procesos (`ps` lo muestra a cualquier usuario de la máquina). El CLI lo acepta —es la
+forma que se copia desde la web— pero avisa. Alternativas:
+
+```bash
+cat pat.txt | shilo login --token -     # lee el token de stdin
+SHILO_TOKEN=<pat> shilo init --project <uuid>   # variable de entorno (lo natural en CI)
+```
+
 ## Variables de entorno
 
 | Variable                | Efecto                                                        |
 | ----------------------- | ------------------------------------------------------------- |
 | `SHILO_CONFIG_DIR`      | Directorio de config (default `~/.shilo`).                    |
 | `SHILO_ENCRYPTION_KEY`  | Passphrase para cifrar credenciales (recomendado).            |
+| `SHILO_TOKEN`           | Token de acceso personal (evita pasarlo por `--token`).       |
+| `SHILO_CONCURRENCY`     | Requests en paralelo del push (1-32, default 8).              |
 | `NO_COLOR`              | Desactiva colores ANSI.                                       |
 
 ## Roadmap
@@ -160,6 +224,13 @@ contraseña.
   de contenido + exit code 1), atribución de autor en `push --dry-run`, `pull` que
   resuelve conflictos por archivo en vez de abortar, `lastSync` en `.shilo.json` y
   `push --card <id>` para cruzar commits con un tablero externo (Metrónomo).
+- **Fase 6 — robustez del push** *(hecho)*: `.gitignore` (incluidos los anidados),
+  poda de repos git por forma, escaneo de secretos con corte del push, preflight
+  100 % offline antes de tocar la red, planificación con un recorrido del árbol
+  remoto (una request por carpeta en vez de una por archivo), índice local
+  `.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`.
 
 ## Exit codes
 
@@ -168,4 +239,5 @@ contraseña.
 | `status` | 2      | El remoto tiene cambios que no tenés.        |
 | `diff`   | 1      | Hay diferencias entre local y remoto.        |
 | `pull`   | 1      | Quedaron conflictos sin bajar (o fallas).    |
+| `push`   | 1      | Se detectaron posibles secretos (nada subido). |
 | cualquiera | 1    | Error.                                       |

package/bin/shilo.js

@@ -28,13 +28,15 @@ ${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).
+  --token -          Lee el token de stdin (no queda en el historial del shell).
   --base-url <url>   Servidor Shilo (default: https://www.shilo.city).
+  ${ui.c.dim('También se lee de la variable de entorno SHILO_TOKEN.')}
 
 ${ui.c.bold('Opciones de init:')}
   --project <uuid>   Id del proyecto de Shilo (requerido).
-  --token <pat>      Token de acceso personal (evita el "login" previo).
-  --push             Sube la carpeta apenas queda atada.
-  --pull             Baja la carpeta apenas queda atada.
+  --token <pat>      Token de acceso personal (evita el "login" previo; o SHILO_TOKEN).
+  --push             Sube la carpeta apenas queda atada (pregunta, salvo --yes).
+  --pull             Baja la carpeta apenas queda atada (pregunta, salvo --yes).
   --base-url <url>   Servidor Shilo.
   --force            No verifica acceso ni pregunta antes de sobrescribir.
 
@@ -51,7 +53,12 @@ ${ui.c.bold('Opciones de push:')}
   --card <id>        Id de tarjeta/tablero; se agrega al mensaje como [card: id].
   --dry-run          Muestra qué haría (y quién tocó cada archivo), sin subir nada.
   --yes              No pide confirmación.
+  --allow-secrets    Sube igual los archivos donde se detectaron posibles secretos.
+  --concurrency <n>  Requests en paralelo (1-32, default 8; o SHILO_CONCURRENCY).
+  --no-index         Ignora el índice local (.shilo/index.json) y recompara todo.
+  --verbose          Lista archivo por archivo en vez de resumir.
   --base-url <url>   Servidor Shilo.
+  ${ui.c.dim('Respeta .gitignore y .shiloignore, incluidos los de subcarpetas.')}
 
 ${ui.c.bold('Opciones de pull:')}
   --project <uuid>   Proyecto origen (pisa el .shilo.json de la carpeta).
@@ -97,7 +104,7 @@ async function main() {
     // valor de --push, perdiendo el positional de la carpeta.
     booleans: [
       'help', 'version', 'h', 'v', 'dry-run', 'yes', 'force', 'push', 'pull',
-      'json', 'short', 'stat', 'files',
+      'json', 'short', 'stat', 'files', 'allow-secrets', 'no-index', 'verbose',
     ],
     aliases: { h: 'help', v: 'version', m: 'message' },
   });
@@ -131,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.3.2",
+  "version": "0.6.0",
   "description": "CLI para sincronizar carpetas locales con repositorios de Shilo: push, pull, status, log y diff.",
   "keywords": [
     "shilo",

package/src/ShiloClient.js

@@ -11,7 +11,7 @@
  *
  * Archivos y commits (Fase 2):
  *   - listFiles / getFileMeta / readFile
- *   - createFile / writeFile / createFolder / ensurePath
+ *   - createFile / writeFile / writeBatch / createFolder / ensurePath
  *   - createCommit
  *
  * Todos los métodos de red toman `credentials` y devuelven `{ ..., credentials }`
@@ -21,6 +21,36 @@
 const DEFAULT_BASE_URL = 'https://www.shilo.city';
 const DEFAULT_TIMEOUT_MS = 45000;
 
+// Reintentos: sólo para fallos que pueden desaparecer solos (red, timeout, 429,
+// 5xx). Un 4xx que no sea 429 es un error del cliente —ruta inválida, permisos,
+// body mal formado— y repetirlo sólo gasta tiempo.
+const DEFAULT_RETRIES = 3;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 8000;
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Backoff exponencial con jitter completo. El jitter importa: sin él, N
+ * requests que chocan con el mismo 429 reintentan todos en el mismo
+ * milisegundo y vuelven a chocar.
+ */
+function backoffDelay(attempt) {
+  const ceiling = Math.min(RETRY_BASE_MS * Math.pow(4, attempt), RETRY_MAX_MS);
+  return Math.round(ceiling * (0.5 + Math.random() * 0.5));
+}
+
+/** Lee `Retry-After` (segundos o fecha HTTP). Devuelve ms, o null. */
+function retryAfterMs(res) {
+  const raw = res && res.headers && res.headers.get && res.headers.get('retry-after');
+  if (!raw) return null;
+  const secs = Number(raw);
+  if (Number.isFinite(secs)) return Math.max(0, Math.min(secs * 1000, 60000));
+  const when = Date.parse(raw);
+  if (!Number.isNaN(when)) return Math.max(0, Math.min(when - Date.now(), 60000));
+  return null;
+}
+
 /**
  * El ápex https://shilo.city responde 307 hacia https://www.shilo.city. Como
  * `fetch` sigue redirects pero descarta el header Authorization al cruzar de
@@ -33,11 +63,15 @@ function normalizeBaseURL(url) {
 }
 
 class ShiloError extends Error {
-  constructor(message, { status = null, body = null } = {}) {
+  constructor(message, { status = null, body = null, retryable = false, notSupported = false } = {}) {
     super(message);
     this.name = 'ShiloError';
     this.status = status;
     this.body = body;
+    this.retryable = retryable;
+    // El servidor no conoce el endpoint (deploy viejo): el caller puede usar
+    // el camino alternativo en vez de abortar.
+    this.notSupported = notSupported;
   }
 }
 
@@ -48,9 +82,14 @@ class ShiloClient {
     // Opcionales: habilitan refresh de token sin re-login.
     this.supabaseUrl = options.supabaseUrl || null;
     this.supabaseAnonKey = options.supabaseAnonKey || null;
+    this.retries = options.retries != null ? Number(options.retries) : DEFAULT_RETRIES;
+    // Se avisa de cada 429 para que el caller pueda bajar la concurrencia en vez
+    // de seguir martillando al servidor con la misma cadencia.
+    this.onThrottle = typeof options.onThrottle === 'function' ? options.onThrottle : null;
   }
 
-  async _fetch(url, { method = 'GET', headers = {}, body = null } = {}) {
+  /** Un intento único, sin reintentos. */
+  async _fetchOnce(url, { method = 'GET', headers = {}, body = null, raw = false } = {}) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     let res;
@@ -58,18 +97,32 @@ 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) {
       clearTimeout(timer);
       if (err.name === 'AbortError') {
-        throw new ShiloError(`Timeout tras ${this.timeoutMs}ms: ${method} ${url}`);
+        throw new ShiloError(`Timeout tras ${this.timeoutMs}ms: ${method} ${url}`, {
+          retryable: true,
+        });
       }
-      throw new ShiloError(`Fallo de red: ${err.message}`);
+      throw new ShiloError(`Fallo de red: ${err.message}`, { retryable: true });
     }
     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) {
@@ -82,6 +135,43 @@ class ShiloClient {
     return { res, data };
   }
 
+  /**
+   * `_fetchOnce` + reintentos con backoff exponencial y jitter. Un 502
+   * transitorio o un microcorte de red dejaban de forma permanente ese archivo
+   * afuera del push —y si pasaba en la fase de commit, quedaban archivos
+   * escritos sin commit que los registrara.
+   */
+  async _fetch(url, options = {}) {
+    const maxAttempts = Math.max(1, this.retries);
+    let nextDelay = 0;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const isLast = attempt === maxAttempts - 1;
+      if (attempt > 0) await sleep(nextDelay);
+
+      let result;
+      try {
+        result = await this._fetchOnce(url, options);
+      } catch (err) {
+        if (!err.retryable || isLast) throw err;
+        nextDelay = backoffDelay(attempt);
+        continue;
+      }
+
+      const { res } = result;
+      const throttled = res.status === 429;
+      if (throttled && this.onThrottle) this.onThrottle();
+
+      if ((!throttled && res.status < 500) || isLast) return result;
+
+      const hinted = retryAfterMs(res);
+      nextDelay = hinted != null ? hinted : backoffDelay(attempt);
+    }
+
+    /* istanbul ignore next — el bucle siempre sale por return o throw */
+    throw new ShiloError(`No se pudo completar la petición a ${url}`);
+  }
+
   _errMessage(data, fallback) {
     if (data && typeof data === 'object') {
       if (typeof data.error === 'string') return data.error;
@@ -229,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 };
   }
@@ -288,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,
+    };
   }
 
   /**
@@ -343,6 +444,151 @@ class ShiloClient {
     return { file, credentials: creds };
   }
 
+  /**
+   * Escribe varios archivos en una sola llamada (`POST /api/files/:id/batch`).
+   * Crea las carpetas intermedias por su cuenta, así que no hace falta un
+   * `ensurePath` previo.
+   *
+   * `files`: [{ path, content, mimeType? }] — máximo 100 y 5 MB por lote.
+   *
+   * El endpoint responde 200 aunque algunos archivos fallen: el resultado viene
+   * POR ARCHIVO, en el mismo orden que se mandó. Los `ok:true` traen
+   * `file.previous_storage_path`, que es lo que después pide el commit.
+   * Devuelve `{ results, summary, credentials }`.
+   *
+   * Un servidor viejo (sin el endpoint) responde 404/405: se marca en el error
+   * con `notSupported` para que el caller pueda caer al camino de a un archivo.
+   */
+  async writeBatch(projectId, files, credentials) {
+    const url = `${this.baseURL}/api/files/${projectId}/batch`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { files },
+    });
+
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo escribir el lote: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data, notSupported: res.status === 404 || res.status === 405 }
+      );
+    }
+
+    const results = data && Array.isArray(data.results) ? data.results : [];
+    const summary = (data && data.summary) || {
+      total: results.length,
+      succeeded: results.filter((r) => r && r.ok).length,
+      failed: results.filter((r) => r && !r.ok).length,
+    };
+    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 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;
+    }
+
+    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 };
+  }
+
   /**
    * Crea una carpeta bajo `parentPath` (vacío = raíz). Un 409 significa que ya
    * existe: no es fatal, devolvemos `{ folder, existed: true }`.

package/src/args.js

@@ -42,7 +42,8 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
         out[key] = true;
       } else {
         const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('-')) {
+        // `-` a secas es un valor legítimo ("leer de stdin"), no otra bandera.
+        if (next !== undefined && (next === '-' || !next.startsWith('-'))) {
           out[key] = next;
           i++;
         } else {
@@ -58,7 +59,8 @@ function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
         out[key] = true;
       } else {
         const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('-')) {
+        // `-` a secas es un valor legítimo ("leer de stdin"), no otra bandera.
+        if (next !== undefined && (next === '-' || !next.startsWith('-'))) {
           out[key] = next;
           i++;
         } else {

package/src/commands/init.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const config = require('../config');
 const remote = require('../remote');
 const prompt = require('../prompt');
+const tokens = require('../token');
 const ui = require('../ui');
 const { ShiloClient } = require('../ShiloClient');
 
@@ -43,8 +44,16 @@ async function init(args) {
 
   // --token: persistir credenciales antes del chequeo de sesión, para que el
   // comando de una línea copiado desde la web ande sin "shilo login" previo.
-  const token = typeof args.token === 'string' ? args.token.trim() : '';
+  let token = '';
+  let tokenSource = null;
+  try {
+    ({ token, source: tokenSource } = await tokens.resolveToken(args));
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
   if (token) {
+    tokens.warnIfExposed(tokenSource, ui);
     const existing = config.load() || {};
     config.save({
       baseURL: args['base-url'] || existing.baseURL || DEFAULT_BASE_URL,
@@ -98,14 +107,16 @@ async function init(args) {
   ui.success(`Carpeta atada al proyecto ${ui.c.bold(projectId)}.`);
   ui.info(ui.c.dim(`Remote guardado en ${written}`));
 
+  // --push/--pull no implican confirmación: el usuario pidió *encadenar* el
+  // comando, no saltearse su preflight. Sin --yes, push muestra el plan (y el
+  // resultado del escaneo de secretos) y pregunta como si se hubiera invocado
+  // a mano. `args.yes` viaja tal cual en el spread.
   if (args.push) {
-    // El usuario ya confirmó al pasar --push: no volvemos a preguntar.
-    return require('./push')({ ...args, _: [dir], yes: true });
+    return require('./push')({ ...args, _: [dir] });
   }
 
   if (args.pull) {
-    // Espejo de --push: el usuario ya confirmó al pasar --pull.
-    return require('./pull')({ ...args, _: [dir], yes: true });
+    return require('./pull')({ ...args, _: [dir] });
   }
 
   ui.info(`Ahora podés subir con: ${ui.c.bold('shilo push')}`);

package/src/commands/login.js

@@ -2,6 +2,7 @@
 
 const config = require('../config');
 const prompt = require('../prompt');
+const tokens = require('../token');
 const ui = require('../ui');
 const { ShiloClient } = require('../ShiloClient');
 
@@ -17,8 +18,18 @@ const DEFAULT_BASE_URL = 'https://www.shilo.city';
 async function login(args) {
   const baseURL = args['base-url'] || (config.load() || {}).baseURL || DEFAULT_BASE_URL;
 
-  const token = typeof args.token === 'string' ? args.token.trim() : '';
-  if (token) return loginWithToken(token, baseURL);
+  let token = '';
+  let source = null;
+  try {
+    ({ token, source } = await tokens.resolveToken(args));
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+  if (token) {
+    tokens.warnIfExposed(source, ui);
+    return loginWithToken(token, baseURL);
+  }
 
   let email = args.email;
   let pass = args.password;