shilo-cli 0.2.0

package/README.md

@@ -0,0 +1,80 @@
+# shilo-cli
+
+CLI para subir carpetas locales a repositorios de [Shilo](https://shilo-six.vercel.app),
+con una experiencia tipo git: `shilo login` una vez y después `shilo push`.
+
+> **Estado:** Fase 3 (push). Disponibles `login`, `whoami`, `logout`, `init`, `push`.
+> El flujo completo tipo git ya funciona: `shilo login` → `shilo init` → `shilo push`.
+
+## Requisitos
+
+- Node.js **>= 18** (usa `fetch` y `crypto` nativos; sin dependencias de runtime).
+
+## Instalación (local, durante desarrollo)
+
+```bash
+cd cli
+npm link          # expone el comando `shilo` global
+# o, sin link:
+node bin/shilo.js <comando>
+```
+
+## Uso
+
+```bash
+shilo login                 # pregunta email y contraseña (oculta)
+shilo login --email you@example.com
+shilo whoami                # muestra la sesión activa
+shilo logout                # borra las credenciales locales
+```
+
+### Subir una carpeta (flujo tipo git)
+
+```bash
+cd mi-carpeta
+shilo init --project <uuid>       # ata la carpeta al repo (escribe .shilo.json)
+shilo push                        # sube: crea/actualiza + commit
+shilo push -m "mi mensaje"        # con mensaje de commit
+shilo push --dry-run              # muestra qué haría sin subir
+shilo push --yes                  # sin pedir confirmación
+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`).
+
+### Servidor alternativo
+
+```bash
+shilo login --base-url https://mi-shilo.vercel.app
+```
+
+## Credenciales
+
+Se guardan en `~/.shilo/config.json` (override con `SHILO_CONFIG_DIR`), **cifradas**
+con AES-256-CBC y con permisos `0600`.
+
+- Por defecto la clave de cifrado se deriva de la máquina (hostname + usuario).
+  Esto es **ofuscación en reposo**, no secreto fuerte.
+- Para cifrado fuerte, exportá `SHILO_ENCRYPTION_KEY` (una passphrase propia) antes
+  de `shilo login`; necesitarás la misma variable para futuras ejecuciones.
+
+Se almacena el JWT, el refresh token, la expiración y el email; **no** se guarda la
+contraseña.
+
+## Variables de entorno
+
+| Variable                | Efecto                                                        |
+| ----------------------- | ------------------------------------------------------------- |
+| `SHILO_CONFIG_DIR`      | Directorio de config (default `~/.shilo`).                    |
+| `SHILO_ENCRYPTION_KEY`  | Passphrase para cifrar credenciales (recomendado).            |
+| `NO_COLOR`              | Desactiva colores ANSI.                                       |
+
+## Roadmap
+
+- **Fase 1 — auth** *(hecho)*: `login`, `whoami`, `logout` + config cifrada.
+- **Fase 2 — motor** *(hecho)*: cliente de archivos (`list`/`getMeta`/`create`/`write`/
+  `ensurePath`/`commit`) + recorrido de árbol (`.shiloignore`) + detección de binarios.
+- **Fase 3 — push** *(hecho)*: `shilo init` + `shilo push` (crea/actualiza + commit,
+  detección de cambios, `.shiloignore`, `--dry-run`).

package/bin/shilo.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+const { parseArgs } = require('../src/args');
+const ui = require('../src/ui');
+
+const VERSION = require('../package.json').version;
+
+const HELP = `
+${ui.c.bold('shilo')} — sube carpetas locales a repositorios de Shilo.
+
+${ui.c.bold('Uso:')}
+  shilo <comando> [opciones]
+
+${ui.c.bold('Comandos:')}
+  login              Inicia sesión y guarda credenciales cifradas (~/.shilo/config.json).
+  whoami             Muestra la sesión activa.
+  logout             Cierra sesión (borra credenciales locales).
+  init [carpeta]     Ata una carpeta a un repo de Shilo (--project <uuid>).
+  push [carpeta]     Sube una carpeta al repo de Shilo (crea/actualiza + commit).
+  help               Muestra esta ayuda.
+
+${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).
+
+${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.
+  --base-url <url>   Servidor Shilo.
+  --force            No verifica acceso ni pregunta antes de sobrescribir.
+
+${ui.c.bold('Opciones de push:')}
+  --project <uuid>   Proyecto destino (pisa el .shilo.json de la carpeta).
+  -m, --message <m>  Mensaje del commit.
+  --dry-run          Muestra qué haría, sin subir nada.
+  --yes              No pide confirmación.
+  --base-url <url>   Servidor Shilo.
+
+${ui.c.bold('Globales:')}
+  -v, --version      Versión del CLI.
+  -h, --help         Ayuda.
+`;
+
+const COMMANDS = {
+  login: () => require('../src/commands/login'),
+  whoami: () => require('../src/commands/whoami'),
+  logout: () => require('../src/commands/logout'),
+  init: () => require('../src/commands/init'),
+  push: () => require('../src/commands/push'),
+};
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const parsed = parseArgs(argv, {
+    // 'push' tiene que estar acá: la lista de booleanos es global, y sin
+    // registrarlo `shilo init --project X --push .` se comería el `.` como
+    // valor de --push, perdiendo el positional de la carpeta.
+    booleans: ['help', 'version', 'h', 'v', 'dry-run', 'yes', 'force', 'push'],
+    aliases: { h: 'help', v: 'version', m: 'message' },
+  });
+
+  const cmd = parsed._[0];
+
+  if (parsed.version && !cmd) {
+    console.log(VERSION);
+    return 0;
+  }
+  if (!cmd || cmd === 'help' || (parsed.help && !cmd)) {
+    console.log(HELP);
+    return 0;
+  }
+
+  const loader = COMMANDS[cmd];
+  if (!loader) {
+    ui.error(`Comando desconocido: "${cmd}".`);
+    console.log(HELP);
+    return 1;
+  }
+
+  if (parsed.help) {
+    console.log(HELP);
+    return 0;
+  }
+
+  // Los positionals del comando (sin el nombre del comando).
+  const commandArgs = { ...parsed, _: parsed._.slice(1) };
+  const handler = loader();
+  return handler(commandArgs);
+}
+
+main()
+  .then((code) => process.exit(typeof code === 'number' ? code : 0))
+  .catch((err) => {
+    ui.error(err && err.message ? err.message : String(err));
+    process.exit(1);
+  });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "shilo-cli",
+  "version": "0.2.0",
+  "description": "CLI para subir carpetas locales a repositorios de Shilo (login + push tipo git).",
+  "keywords": [
+    "shilo",
+    "cli",
+    "push",
+    "upload",
+    "repositorios"
+  ],
+  "homepage": "https://shilo-six.vercel.app",
+  "bin": {
+    "shilo": "bin/shilo.js"
+  },
+  "type": "commonjs",
+  "main": "src/index.js",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/shilo.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}

package/src/ShiloClient.js

@@ -0,0 +1,427 @@
+'use strict';
+
+/**
+ * Cliente HTTP para la API de Shilo. Portado del ShiloClient de
+ * Bnei-Yerushalaim-Cloud, adaptado a `fetch` nativo (Node >=18, cero deps).
+ *
+ * Autenticación (Fase 1):
+ *   - authenticate(email, password)
+ *   - refreshToken(refreshToken)         (requiere supabaseUrl + anonKey)
+ *   - ensureValidToken(credentials)
+ *
+ * Archivos y commits (Fase 2):
+ *   - listFiles / getFileMeta / readFile
+ *   - createFile / writeFile / createFolder / ensurePath
+ *   - createCommit
+ *
+ * Todos los métodos de red toman `credentials` y devuelven `{ ..., credentials }`
+ * con las credenciales posiblemente refrescadas, para que el caller las persista.
+ */
+
+const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_TIMEOUT_MS = 45000;
+
+class ShiloError extends Error {
+  constructor(message, { status = null, body = null } = {}) {
+    super(message);
+    this.name = 'ShiloError';
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class ShiloClient {
+  constructor(options = {}) {
+    this.baseURL = (options.baseURL || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    this.timeoutMs = Number(options.timeoutMs) || DEFAULT_TIMEOUT_MS;
+    // Opcionales: habilitan refresh de token sin re-login.
+    this.supabaseUrl = options.supabaseUrl || null;
+    this.supabaseAnonKey = options.supabaseAnonKey || null;
+  }
+
+  async _fetch(url, { method = 'GET', headers = {}, body = null } = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await fetch(url, {
+        method,
+        headers,
+        body: body != null ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      if (err.name === 'AbortError') {
+        throw new ShiloError(`Timeout tras ${this.timeoutMs}ms: ${method} ${url}`);
+      }
+      throw new ShiloError(`Fallo de red: ${err.message}`);
+    }
+    clearTimeout(timer);
+
+    const text = await res.text();
+    let data = null;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch (_) {
+        data = text;
+      }
+    }
+    return { res, data };
+  }
+
+  _errMessage(data, fallback) {
+    if (data && typeof data === 'object') {
+      if (typeof data.error === 'string') return data.error;
+      if (typeof data.message === 'string') return data.message;
+      return JSON.stringify(data);
+    }
+    if (typeof data === 'string' && data) return data;
+    return fallback;
+  }
+
+  /**
+   * Autentica contra /api/auth/login. Devuelve credenciales normalizadas.
+   */
+  async authenticate(email, password) {
+    const { res, data } = await this._fetch(`${this.baseURL}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: { email, password },
+    });
+
+    if (!res.ok) {
+      throw new ShiloError(
+        `Autenticación fallida: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+
+    const session = data && data.data && data.data.session;
+    const user = data && data.data && data.data.user;
+    if (!session || !session.access_token) {
+      throw new ShiloError('Respuesta de login inesperada (sin session.access_token)', {
+        status: res.status,
+        body: data,
+      });
+    }
+
+    const expiresAt = new Date(Date.now() + (session.expires_in || 3600) * 1000).toISOString();
+    return {
+      jwt: session.access_token,
+      refreshToken: session.refresh_token || null,
+      expiresAt,
+      user: user ? { id: user.id, email: user.email } : null,
+    };
+  }
+
+  /**
+   * Refresca el JWT con el refresh_token vía Supabase. Requiere supabaseUrl +
+   * supabaseAnonKey configurados; si no, lanza para que el caller pida re-login.
+   */
+  async refreshToken(refreshToken) {
+    if (!this.supabaseUrl || !this.supabaseAnonKey) {
+      throw new ShiloError(
+        'Refresh no configurado (falta supabaseUrl/anonKey). Ejecutá "shilo login" de nuevo.'
+      );
+    }
+    const { res, data } = await this._fetch(
+      `${this.supabaseUrl.replace(/\/+$/, '')}/auth/v1/token?grant_type=refresh_token`,
+      {
+        method: 'POST',
+        headers: {
+          apikey: this.supabaseAnonKey,
+          'Content-Type': 'application/json',
+        },
+        body: { refresh_token: refreshToken },
+      }
+    );
+    if (!res.ok || !data || !data.access_token) {
+      throw new ShiloError('No se pudo refrescar el token. Re-autenticación requerida.', {
+        status: res.status,
+        body: data,
+      });
+    }
+    const expiresAt = new Date(Date.now() + (data.expires_in || 3600) * 1000).toISOString();
+    return {
+      jwt: data.access_token,
+      refreshToken: data.refresh_token || refreshToken,
+      expiresAt,
+    };
+  }
+
+  /**
+   * Devuelve credenciales con JWT válido, refrescando si faltan <5min.
+   * Si el refresh no está disponible/falla, propaga para que el CLI pida login.
+   *
+   * Un PAT no tiene refresh ni expiración local: la validez la decide el
+   * servidor en cada request, así que se devuelve tal cual.
+   */
+  async ensureValidToken(credentials) {
+    if (credentials && credentials.kind === 'pat') return credentials;
+
+    if (!credentials || !credentials.jwt) {
+      throw new ShiloError('No hay sesión. Ejecutá "shilo login".');
+    }
+    const msLeft = new Date(credentials.expiresAt).getTime() - Date.now();
+    if (msLeft >= 5 * 60 * 1000) return credentials;
+
+    if (!credentials.refreshToken) {
+      throw new ShiloError('Sesión expirada. Ejecutá "shilo login" de nuevo.');
+    }
+    const fresh = await this.refreshToken(credentials.refreshToken);
+    return { ...credentials, ...fresh };
+  }
+
+  /**
+   * Verifica que unas credenciales sean aceptadas por el servidor, listando los
+   * proyectos del usuario. Sirve tanto para JWT como para PAT.
+   * Devuelve `{ ok: <bool>, status, error }` — no lanza por credenciales malas.
+   */
+  async verifyCredentials(credentials) {
+    const headers = { Authorization: `Bearer ${credentials.jwt}` };
+    const { res, data } = await this._fetch(`${this.baseURL}/api/projects`, { headers });
+    if (res.ok) return { ok: true, status: res.status, error: null };
+    return {
+      ok: false,
+      status: res.status,
+      error: this._errMessage(data, `HTTP ${res.status}`),
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Helpers de archivos
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Codifica una ruta de repo (segmentos separados por `/`) para la URL,
+   * escapando cada segmento pero conservando los separadores. Los nombres
+   * válidos en Shilo pueden incluir `[ ] ( ) @`, que conviene escapar.
+   */
+  _encodePath(repoPath) {
+    if (!repoPath) return '';
+    return repoPath
+      .split('/')
+      .filter(Boolean)
+      .map((seg) => encodeURIComponent(seg))
+      .join('/');
+  }
+
+  _fileUrl(projectId, repoPath = '') {
+    const enc = this._encodePath(repoPath);
+    return enc
+      ? `${this.baseURL}/api/files/${projectId}/${enc}`
+      : `${this.baseURL}/api/files/${projectId}`;
+  }
+
+  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';
+    const { res, data } = await this._fetch(url, { method, headers, body });
+    return { res, data, credentials: validCreds };
+  }
+
+  /**
+   * Lista el contenido directo de una carpeta (no recursa). Raíz responde
+   * `{ files }`, una carpeta responde `{ folder, files }`.
+   * Devuelve `{ files: [...], credentials }`.
+   */
+  async listFiles(projectId, credentials, folderPath = '') {
+    const url = this._fileUrl(projectId, folderPath);
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudieron listar archivos: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const files = data && Array.isArray(data.files) ? data.files : Array.isArray(data) ? data : [];
+    return { files, credentials: creds };
+  }
+
+  /**
+   * Obtiene la metadata de un archivo/carpeta por ruta SIN descargar contenido.
+   * Devuelve `{ file: <obj|null>, exists: <bool>, credentials }`.
+   * Un 404 no es error: significa que la ruta no existe todavía (archivo nuevo).
+   */
+  async getFileMeta(projectId, filePath, credentials) {
+    const url = this._fileUrl(projectId, filePath);
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (res.status === 404) {
+      return { file: null, exists: false, credentials: creds };
+    }
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo consultar "${filePath}": ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const file = data && data.file ? data.file : data;
+    return { file: file || null, exists: !!file, credentials: creds };
+  }
+
+  /**
+   * Lee metadata + contenido de un archivo (`?content=true`).
+   * Devuelve `{ file: { ...meta, content }, credentials }`.
+   */
+  async readFile(projectId, filePath, credentials) {
+    const url = `${this._fileUrl(projectId, filePath)}?content=true`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials);
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo leer "${filePath}": ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const file = data && data.file ? data.file : {};
+    const content = data && data.content !== undefined ? data.content : null;
+    return { file: { ...file, content }, credentials: creds };
+  }
+
+  /**
+   * Crea un archivo nuevo (POST a la carpeta padre). Idempotente en el server:
+   * si ya existe, responde 409 con el objeto existente. Aquí tratamos el 409
+   * como "ya existía" y devolvemos `{ file, created: false }` para que el caller
+   * decida (normalmente, hacer un PUT).
+   * Devuelve `{ file, created: <bool>, credentials }`.
+   */
+  async createFile(projectId, filePath, content, mimeType, credentials) {
+    const parts = filePath.split('/').filter(Boolean);
+    const fileName = parts.pop();
+    const parentPath = parts.join('/');
+    const url = this._fileUrl(projectId, parentPath);
+
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { name: fileName, type: 'file', content, mimeType },
+    });
+
+    if (res.status === 409) {
+      const existing = (data && (data.file || data.folder)) || null;
+      return { file: existing, created: false, credentials: creds };
+    }
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo crear "${filePath}": ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const file = (data && (data.file || data)) || null;
+    return { file, created: true, credentials: creds };
+  }
+
+  /**
+   * Actualiza el contenido de un archivo existente (PUT). Devuelve el archivo
+   * con su NUEVO `storage_path`. `{ file, credentials }`.
+   */
+  async writeFile(projectId, filePath, content, mimeType, credentials) {
+    const url = this._fileUrl(projectId, filePath);
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'PUT',
+      body: { content, mimeType },
+    });
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo actualizar "${filePath}": ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const file = (data && (data.file || data)) || null;
+    return { file, credentials: creds };
+  }
+
+  /**
+   * Crea una carpeta bajo `parentPath` (vacío = raíz). Un 409 significa que ya
+   * existe: no es fatal, devolvemos `{ folder, existed: true }`.
+   * `{ folder, existed: <bool>, credentials }`.
+   */
+  async createFolder(projectId, folderName, parentPath = '', credentials) {
+    const url = this._fileUrl(projectId, parentPath);
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { name: folderName, type: 'folder' },
+    });
+    if (res.status === 409) {
+      const existing = (data && (data.folder || data.file)) || { name: folderName };
+      return { folder: existing, existed: true, credentials: creds };
+    }
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo crear la carpeta "${folderName}": ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const folder = (data && (data.file || data)) || null;
+    return { folder, existed: false, credentials: creds };
+  }
+
+  /**
+   * Asegura que existan todas las carpetas del path de un archivo.
+   * Estrategia anti-duplicados: Shilo puede no devolver 409 fiable, así que
+   * listamos el padre antes de crear y reutilizamos la carpeta si ya existe.
+   * `ensuredCache` (Set de rutas completas) evita re-listar dentro de una corrida.
+   * Devuelve las credenciales (posiblemente refrescadas).
+   */
+  async ensurePath(projectId, filePath, credentials, ensuredCache = null) {
+    const parts = filePath.split('/').filter(Boolean);
+    parts.pop(); // quitar el nombre del archivo
+    if (parts.length === 0) return credentials;
+
+    let currentCreds = credentials;
+    let parentPath = '';
+
+    for (const folderName of parts) {
+      const fullPath = parentPath ? `${parentPath}/${folderName}` : folderName;
+
+      if (ensuredCache && ensuredCache.has(fullPath)) {
+        parentPath = fullPath;
+        continue;
+      }
+
+      let exists = false;
+      try {
+        const listResult = await this.listFiles(projectId, currentCreds, parentPath);
+        currentCreds = listResult.credentials;
+        exists = listResult.files.some((e) => e && e.type === 'folder' && e.name === folderName);
+      } catch (_) {
+        // El padre puede no existir aún: dejamos que createFolder lo cree.
+        exists = false;
+      }
+
+      if (!exists) {
+        const result = await this.createFolder(projectId, folderName, parentPath, currentCreds);
+        currentCreds = result.credentials;
+      }
+
+      if (ensuredCache) ensuredCache.add(fullPath);
+      parentPath = fullPath;
+    }
+
+    return currentCreds;
+  }
+
+  /**
+   * Crea un commit con la lista de cambios de archivos (máx 100 por lote).
+   * `changes`: [{ file_id, action, previous_storage_path?, new_storage_path? }].
+   * Devuelve `{ commit, credentials }`.
+   */
+  async createCommit(projectId, message, changes, credentials) {
+    const url = `${this.baseURL}/api/commits/${projectId}`;
+    const { res, data, credentials: creds } = await this._authFetch(url, credentials, {
+      method: 'POST',
+      body: { message, files: changes },
+    });
+    if (!res.ok) {
+      throw new ShiloError(
+        `No se pudo crear el commit: ${this._errMessage(data, `HTTP ${res.status}`)}`,
+        { status: res.status, body: data }
+      );
+    }
+    const commit = (data && data.commit) || data;
+    return { commit, credentials: creds };
+  }
+}
+
+module.exports = { ShiloClient, ShiloError };