shilo-cli 0.2.0

package/src/config.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * Gestión del archivo de configuración/credenciales del CLI.
+ *
+ * Ubicación: ~/.shilo/config.json  (override con SHILO_CONFIG_DIR).
+ *
+ * Las credenciales se guardan cifradas con AES-256-CBC. La clave se deriva
+ * de SHILO_ENCRYPTION_KEY si está definida; si no, de un valor propio de la
+ * máquina (hostname + usuario del SO). En este segundo caso el cifrado es
+ * ofuscación-en-reposo (evita leer el token de un vistazo o copiar el archivo
+ * a otra máquina), NO secreto fuerte: para eso, exportá SHILO_ENCRYPTION_KEY.
+ * Además el archivo se escribe con permisos 0600.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const ALGORITHM = 'aes-256-cbc';
+
+function configDir() {
+  if (process.env.SHILO_CONFIG_DIR) return process.env.SHILO_CONFIG_DIR;
+  return path.join(os.homedir(), '.shilo');
+}
+
+function configPath() {
+  return path.join(configDir(), 'config.json');
+}
+
+function deriveKey() {
+  const base =
+    process.env.SHILO_ENCRYPTION_KEY ||
+    `${os.hostname()}::${os.userInfo().username}::shilo-cli`;
+  return crypto.scryptSync(base, 'shilo-cli-salt', 32);
+}
+
+function encrypt(obj) {
+  const key = deriveKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let data = cipher.update(JSON.stringify(obj), 'utf8', 'hex');
+  data += cipher.final('hex');
+  return { iv: iv.toString('hex'), data };
+}
+
+function decrypt(payload) {
+  const key = deriveKey();
+  const iv = Buffer.from(payload.iv, 'hex');
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  let out = decipher.update(payload.data, 'hex', 'utf8');
+  out += decipher.final('utf8');
+  return JSON.parse(out);
+}
+
+/**
+ * Estructura en disco:
+ * {
+ *   version: 1,
+ *   baseURL: "https://shilo-six.vercel.app",
+ *   supabaseUrl?: "...",        // opcional, habilita refresh de token
+ *   supabaseAnonKey?: "...",    // opcional (valor público)
+ *   credentials: { iv, data }   // cifrado -> { jwt, refreshToken, expiresAt, user }
+ * }
+ */
+
+function load() {
+  const p = configPath();
+  if (!fs.existsSync(p)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (e) {
+    throw new Error(`Config corrupta en ${p}: ${e.message}`);
+  }
+  let credentials = null;
+  if (raw.credentials) {
+    try {
+      credentials = decrypt(raw.credentials);
+    } catch (e) {
+      throw new Error(
+        `No se pudieron descifrar las credenciales (¿cambió SHILO_ENCRYPTION_KEY o la máquina?). ` +
+          `Ejecutá "shilo login" de nuevo. Detalle: ${e.message}`
+      );
+    }
+  }
+  return {
+    version: raw.version || 1,
+    baseURL: raw.baseURL || null,
+    supabaseUrl: raw.supabaseUrl || null,
+    supabaseAnonKey: raw.supabaseAnonKey || null,
+    credentials,
+  };
+}
+
+function save(cfg) {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const onDisk = {
+    version: 1,
+    baseURL: cfg.baseURL || null,
+  };
+  if (cfg.supabaseUrl) onDisk.supabaseUrl = cfg.supabaseUrl;
+  if (cfg.supabaseAnonKey) onDisk.supabaseAnonKey = cfg.supabaseAnonKey;
+  if (cfg.credentials) onDisk.credentials = encrypt(cfg.credentials);
+
+  const p = configPath();
+  // Escribir con permisos restrictivos (0600). En Windows los modos POSIX se
+  // ignoran en gran medida, pero no hace daño.
+  fs.writeFileSync(p, JSON.stringify(onDisk, null, 2), { mode: 0o600 });
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch (_) {
+    /* no-op en FS que no soportan chmod */
+  }
+  return p;
+}
+
+function clear() {
+  const p = configPath();
+  if (fs.existsSync(p)) {
+    fs.rmSync(p);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Re-guarda el config si el token cambió (p.ej. tras un refresh de JWT), y deja
+ * el `cfg` en memoria sincronizado para que la próxima comparación sea correcta.
+ * Los PAT nunca cambian, así que en la práctica es no-op para ellos.
+ */
+function persistCredsIfChanged(cfg, credentials) {
+  if (!credentials || !cfg || !cfg.credentials) return;
+  if (credentials.jwt === cfg.credentials.jwt) return;
+  save({
+    baseURL: cfg.baseURL,
+    supabaseUrl: cfg.supabaseUrl,
+    supabaseAnonKey: cfg.supabaseAnonKey,
+    credentials,
+  });
+  cfg.credentials = credentials;
+}
+
+/**
+ * Arma las credenciales para un Personal Access Token. `kind: 'pat'` es lo que
+ * hace que ShiloClient.ensureValidToken no intente refrescarlas.
+ */
+function patCredentials(token) {
+  return { jwt: token, kind: 'pat', refreshToken: null, expiresAt: null, user: null };
+}
+
+module.exports = {
+  configDir,
+  configPath,
+  load,
+  save,
+  clear,
+  encrypt,
+  decrypt,
+  persistCredsIfChanged,
+  patCredentials,
+};

package/src/prompt.js

@@ -0,0 +1,53 @@
+'use strict';
+
+/**
+ * Prompts interactivos mínimos sobre readline (sin dependencias).
+ */
+
+const readline = require('readline');
+
+function question(query) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Lee input ocultando lo tecleado (para contraseñas).
+ */
+function password(query) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const stdout = process.stdout;
+    // Mutar la salida: readline no expone masking nativo, así que interceptamos
+    // _writeToOutput para no imprimir los caracteres de la contraseña.
+    const originalWrite = rl._writeToOutput;
+    let muted = false;
+    rl._writeToOutput = function (str) {
+      if (muted) {
+        // Permitir el salto de línea final para no romper el layout.
+        if (str.includes('\n')) stdout.write('\n');
+        return;
+      }
+      originalWrite.call(rl, str);
+    };
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+    muted = true;
+  });
+}
+
+async function confirm(query, defaultYes = false) {
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  const ans = (await question(query + suffix)).toLowerCase();
+  if (!ans) return defaultYes;
+  return ans === 'y' || ans === 'yes' || ans === 's' || ans === 'si' || ans === 'sí';
+}
+
+module.exports = { question, password, confirm };

package/src/remote.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Manejo del archivo de remote del proyecto: `.shilo.json`.
+ *
+ * Vive en la carpeta que se sube (no en ~/.shilo) y ata esa carpeta a un
+ * repositorio de Shilo. Es el equivalente conceptual a `.git/config` pero
+ * mínimo: sólo el id del proyecto y el servidor.
+ *
+ * Estructura en disco:
+ * {
+ *   "projectId": "<uuid>",
+ *   "baseURL": "https://shilo-six.vercel.app"
+ * }
+ *
+ * NO contiene credenciales (esas están en ~/.shilo/config.json, cifradas), así
+ * que es seguro commitearlo al repo si el usuario quiere.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const REMOTE_FILENAME = '.shilo.json';
+
+function remotePath(dir) {
+  return path.join(dir, REMOTE_FILENAME);
+}
+
+/**
+ * Lee `.shilo.json` de `dir`. Devuelve el objeto o `null` si no existe.
+ * Lanza si existe pero está corrupto.
+ */
+function read(dir) {
+  const p = remotePath(dir);
+  if (!fs.existsSync(p)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (e) {
+    throw new Error(`Remote corrupto en ${p}: ${e.message}`);
+  }
+  return {
+    projectId: raw.projectId || null,
+    baseURL: raw.baseURL || null,
+  };
+}
+
+/**
+ * Escribe `.shilo.json` en `dir`. Devuelve la ruta escrita.
+ */
+function write(dir, { projectId, baseURL }) {
+  const p = remotePath(dir);
+  const onDisk = { projectId };
+  if (baseURL) onDisk.baseURL = baseURL;
+  fs.writeFileSync(p, JSON.stringify(onDisk, null, 2) + '\n', 'utf8');
+  return p;
+}
+
+module.exports = { REMOTE_FILENAME, remotePath, read, write };

package/src/textguard.js

@@ -0,0 +1,131 @@
+'use strict';
+
+/**
+ * Validación de nombres y detección de binarios para el push.
+ *
+ * Shilo sólo acepta contenido de texto (el endpoint path-based sube el body
+ * como utf8, así que un binario se corrompería) y restringe los nombres de
+ * archivo/carpeta a un charset acotado. Aquí filtramos ambos casos ANTES de
+ * tocar la red, para poder avisar y saltar.
+ */
+
+// Charset permitido por el backend (ver backend/api/files/[projectId].js):
+//   ^[a-zA-Z0-9._\-\[\]()@]+$  y ni "." ni ".." ni separadores de ruta.
+const VALID_NAME = /^[a-zA-Z0-9._\-[\]()@]+$/;
+const MAX_NAME_LEN = 255;
+const MAX_FILE_BYTES = 26214400; // 25 MB, igual que el backend
+const MAX_DEPTH = 10; // profundidad máxima de carpetas
+
+// Extensiones típicamente binarias: pre-filtro rápido antes de leer bytes.
+const BINARY_EXTENSIONS = new Set([
+  // imágenes
+  'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'tiff', 'tif', 'heic', 'avif',
+  // audio/video
+  'mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a', 'mp4', 'mov', 'avi', 'mkv', 'webm', 'wmv',
+  // comprimidos / paquetes
+  'zip', 'gz', 'tar', 'rar', '7z', 'bz2', 'xz', 'jar', 'war', 'apk', 'dmg', 'iso',
+  // ejecutables / libs
+  'exe', 'dll', 'so', 'dylib', 'bin', 'o', 'a', 'obj', 'class', 'wasm', 'node',
+  // documentos binarios
+  'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp',
+  // fuentes / otros
+  'ttf', 'otf', 'woff', 'woff2', 'eot', 'psd', 'ai', 'sketch', 'db', 'sqlite',
+]);
+
+/**
+ * Valida un nombre individual (archivo o carpeta) contra las reglas de Shilo.
+ * Devuelve `{ ok: true }` o `{ ok: false, reason }`.
+ */
+function validateName(name) {
+  if (!name || name === '.' || name === '..') {
+    return { ok: false, reason: 'nombre reservado (. o ..)' };
+  }
+  if (name.length > MAX_NAME_LEN) {
+    return { ok: false, reason: `nombre demasiado largo (>${MAX_NAME_LEN})` };
+  }
+  if (name.includes('/') || name.includes('\\')) {
+    return { ok: false, reason: 'contiene separador de ruta' };
+  }
+  if (!VALID_NAME.test(name)) {
+    return {
+      ok: false,
+      reason: 'caracteres no permitidos (usá solo A-Z a-z 0-9 . _ - [ ] ( ) @ y sin espacios/acentos)',
+    };
+  }
+  return { ok: true };
+}
+
+/**
+ * Valida cada segmento de una ruta relativa (POSIX, separada por `/`).
+ * Devuelve `{ ok, reason?, segment? }`.
+ */
+function validatePath(relPath) {
+  const segments = relPath.split('/').filter(Boolean);
+  if (segments.length > MAX_DEPTH + 1) {
+    // +1 porque el último segmento es el archivo, no una carpeta.
+    return { ok: false, reason: `profundidad de carpetas > ${MAX_DEPTH}` };
+  }
+  for (const seg of segments) {
+    const r = validateName(seg);
+    if (!r.ok) return { ok: false, reason: r.reason, segment: seg };
+  }
+  return { ok: true };
+}
+
+function extensionOf(name) {
+  const dot = name.lastIndexOf('.');
+  if (dot <= 0) return '';
+  return name.slice(dot + 1).toLowerCase();
+}
+
+/**
+ * Heurística de binario sobre un Buffer:
+ *   - un byte NUL (0x00) es señal casi segura de binario;
+ *   - una proporción alta de bytes de control no imprimibles también.
+ * Analiza como mucho los primeros `sample` bytes.
+ */
+function looksBinary(buffer, sample = 8000) {
+  const len = Math.min(buffer.length, sample);
+  if (len === 0) return false; // archivo vacío = texto válido
+  let suspicious = 0;
+  for (let i = 0; i < len; i++) {
+    const b = buffer[i];
+    if (b === 0) return true; // NUL → binario
+    // Permitir tab(9), LF(10), CR(13), y todo lo >= 32. El resto es control.
+    if (b < 9 || (b > 13 && b < 32)) suspicious++;
+  }
+  return suspicious / len > 0.3;
+}
+
+/**
+ * Decide si un archivo es texto apto para subir. Recibe el nombre (para la
+ * extensión) y el Buffer con su contenido. Devuelve:
+ *   { isText: true, content }                 -> subir `content` (utf8)
+ *   { isText: false, reason }                 -> saltar con aviso
+ */
+function classifyContent(name, buffer) {
+  const ext = extensionOf(name);
+  if (ext && BINARY_EXTENSIONS.has(ext)) {
+    return { isText: false, reason: `extensión binaria .${ext}` };
+  }
+  if (looksBinary(buffer)) {
+    return { isText: false, reason: 'contenido binario (bytes no imprimibles)' };
+  }
+  if (buffer.length > MAX_FILE_BYTES) {
+    return { isText: false, reason: `supera 25 MB (${buffer.length} bytes)` };
+  }
+  return { isText: true, content: buffer.toString('utf8') };
+}
+
+module.exports = {
+  VALID_NAME,
+  MAX_NAME_LEN,
+  MAX_FILE_BYTES,
+  MAX_DEPTH,
+  BINARY_EXTENSIONS,
+  validateName,
+  validatePath,
+  looksBinary,
+  classifyContent,
+  extensionOf,
+};

package/src/ui.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * Helpers de salida por consola. Colores ANSI que se auto-desactivan si no
+ * hay TTY o si se define NO_COLOR.
+ */
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+function paint(code, s) {
+  return useColor ? `\x1b[${code}m${s}\x1b[0m` : s;
+}
+
+const c = {
+  bold: (s) => paint('1', s),
+  dim: (s) => paint('2', s),
+  red: (s) => paint('31', s),
+  green: (s) => paint('32', s),
+  yellow: (s) => paint('33', s),
+  cyan: (s) => paint('36', s),
+};
+
+function info(msg) {
+  console.log(msg);
+}
+function success(msg) {
+  console.log(`${c.green('✓')} ${msg}`);
+}
+function warn(msg) {
+  console.warn(`${c.yellow('!')} ${msg}`);
+}
+function error(msg) {
+  console.error(`${c.red('✗')} ${msg}`);
+}
+
+module.exports = { c, info, success, warn, error };

package/src/walk.js

@@ -0,0 +1,213 @@
+'use strict';
+
+/**
+ * Recorrido de un directorio local para el push.
+ *
+ * Responsabilidades (todo offline, sin red):
+ *   - aplicar ignores por defecto (.git, node_modules, etc.) + `.shiloignore`;
+ *   - descartar nombres inválidos para Shilo (poda subárboles con carpeta inválida);
+ *   - respetar la profundidad máxima de carpetas;
+ *   - NO leer el contenido completo (eso lo hace el push al clasificar binarios),
+ *     sólo `stat` para el tamaño.
+ *
+ * Devuelve rutas relativas en formato POSIX (con `/`), que es lo que espera la
+ * API de Shilo.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { validateName, MAX_DEPTH } = require('./textguard');
+
+// Ignores por defecto (nombres de carpeta/archivo, a cualquier profundidad).
+const DEFAULT_IGNORES = [
+  '.git/',
+  'node_modules/',
+  '.shilo/',
+  '.shilo.json',
+  '.shiloignore',
+  '.DS_Store',
+  'Thumbs.db',
+  '.vercel/',
+];
+
+/**
+ * Compila una línea de patrón estilo .gitignore (subconjunto práctico) a una
+ * regla { negate, dirOnly, anchored, re }.
+ */
+function compileRule(raw) {
+  let line = raw.replace(/\r$/, '');
+  // Ignorar comentarios y líneas vacías.
+  if (!line.trim() || line.trim().startsWith('#')) return null;
+
+  let negate = false;
+  if (line.startsWith('!')) {
+    negate = true;
+    line = line.slice(1);
+  }
+  // Espacios finales no escapados se ignoran (simplificado: trim al final).
+  line = line.replace(/\s+$/, '');
+  if (!line) return null;
+
+  let dirOnly = false;
+  if (line.endsWith('/')) {
+    dirOnly = true;
+    line = line.slice(0, -1);
+  }
+
+  // Un patrón con `/` interno o inicial se ancla a la raíz; si no, matchea por
+  // basename a cualquier profundidad.
+  const hasSlash = line.includes('/');
+  let anchored = hasSlash;
+  if (line.startsWith('/')) {
+    line = line.slice(1);
+    anchored = true;
+  }
+
+  const re = globToRegExp(line);
+  return { negate, dirOnly, anchored, re };
+}
+
+function globToRegExp(glob) {
+  let out = '^';
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === '*') {
+      if (glob[i + 1] === '*') {
+        out += '.*'; // ** cruza separadores
+        i++;
+        if (glob[i + 1] === '/') i++; // consumir la barra que sigue a **/
+      } else {
+        out += '[^/]*'; // * no cruza separadores
+      }
+    } else if (ch === '?') {
+      out += '[^/]';
+    } else if ('\\^$.|+()[]{}'.includes(ch)) {
+      out += '\\' + ch;
+    } else {
+      out += ch;
+    }
+  }
+  out += '$';
+  return new RegExp(out);
+}
+
+/**
+ * Crea el matcher de ignores a partir de reglas compiladas. Devuelve
+ * `(relPath, isDir) => boolean` (true = ignorar).
+ */
+function makeMatcher(rules) {
+  return function isIgnored(relPath, isDir) {
+    const base = relPath.split('/').pop();
+    let ignored = false;
+    for (const rule of rules) {
+      if (!rule) continue;
+      if (rule.dirOnly && !isDir) continue;
+      const target = rule.anchored ? relPath : base;
+      if (rule.re.test(target)) {
+        ignored = !rule.negate;
+      }
+    }
+    return ignored;
+  };
+}
+
+/**
+ * Lee y compila reglas de un `.shiloignore` en la raíz (si existe), combinadas
+ * con los ignores por defecto.
+ */
+function loadIgnoreRules(rootDir, extraLines = []) {
+  const lines = [...DEFAULT_IGNORES, ...extraLines];
+  const ignorePath = path.join(rootDir, '.shiloignore');
+  if (fs.existsSync(ignorePath)) {
+    try {
+      const text = fs.readFileSync(ignorePath, 'utf8');
+      lines.push(...text.split('\n'));
+    } catch (_) {
+      /* si no se puede leer, seguimos con los defaults */
+    }
+  }
+  return lines.map(compileRule).filter(Boolean);
+}
+
+/**
+ * Recorre `rootDir` y devuelve:
+ *   {
+ *     files:   [{ relPath, absPath, size }],  // candidatos válidos a subir
+ *     skipped: [{ relPath, reason }],         // descartados (nombre/profundidad)
+ *     ignored: <número de entradas ignoradas por reglas>
+ *   }
+ *
+ * No sigue symlinks (se reportan como skipped).
+ */
+function walk(rootDir, { extraIgnore = [] } = {}) {
+  const rules = loadIgnoreRules(rootDir, extraIgnore);
+  const isIgnored = makeMatcher(rules);
+
+  const files = [];
+  const skipped = [];
+  let ignored = 0;
+
+  function recurse(absDir, relBase, folderDepth) {
+    let entries;
+    try {
+      entries = fs.readdirSync(absDir, { withFileTypes: true });
+    } catch (err) {
+      skipped.push({ relPath: relBase || '.', reason: `no se pudo leer: ${err.message}` });
+      return;
+    }
+
+    // Orden estable (carpetas y archivos alfabético) para salida determinista.
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const entry of entries) {
+      const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+      const absPath = path.join(absDir, entry.name);
+      const isDir = entry.isDirectory();
+
+      if (entry.isSymbolicLink()) {
+        skipped.push({ relPath, reason: 'symlink (no soportado)' });
+        continue;
+      }
+
+      if (isIgnored(relPath, isDir)) {
+        ignored++;
+        continue;
+      }
+
+      const nameCheck = validateName(entry.name);
+      if (!nameCheck.ok) {
+        skipped.push({ relPath, reason: nameCheck.reason });
+        continue; // si es carpeta, se poda todo el subárbol
+      }
+
+      if (isDir) {
+        if (folderDepth + 1 > MAX_DEPTH) {
+          skipped.push({ relPath, reason: `profundidad de carpetas > ${MAX_DEPTH}` });
+          continue;
+        }
+        recurse(absPath, relPath, folderDepth + 1);
+      } else if (entry.isFile()) {
+        let size = 0;
+        try {
+          size = fs.statSync(absPath).size;
+        } catch (_) {
+          /* si falla el stat, dejamos size en 0; el push lo detecta al leer */
+        }
+        files.push({ relPath, absPath, size });
+      }
+      // otros tipos (fifo, socket, device) se ignoran silenciosamente
+    }
+  }
+
+  recurse(rootDir, '', 0);
+  return { files, skipped, ignored };
+}
+
+module.exports = {
+  walk,
+  loadIgnoreRules,
+  makeMatcher,
+  compileRule,
+  globToRegExp,
+  DEFAULT_IGNORES,
+};