shilo-cli 0.2.0

package/src/args.js

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * Parser de argumentos minimalista (sin dependencias).
+ *
+ * Soporta:
+ *   --flag            -> { flag: true }
+ *   --key value       -> { key: "value" }
+ *   --key=value       -> { key: "value" }
+ *   -m "msg"          -> alias corto (ver `aliases`)
+ *   positionals       -> array de argumentos sueltos
+ *
+ * Devuelve { _: [positionals...], ...flags }.
+ */
+function parseArgs(argv, { booleans = [], aliases = {} } = {}) {
+  const out = { _: [] };
+  const boolSet = new Set(booleans);
+
+  const canonical = (k) => aliases[k] || k;
+
+  for (let i = 0; i < argv.length; i++) {
+    let token = argv[i];
+
+    if (token === '--') {
+      // Todo lo que sigue son posicionales.
+      out._.push(...argv.slice(i + 1));
+      break;
+    }
+
+    if (token.startsWith('--')) {
+      let key = token.slice(2);
+      let value;
+      const eq = key.indexOf('=');
+      if (eq !== -1) {
+        value = key.slice(eq + 1);
+        key = key.slice(0, eq);
+      }
+      key = canonical(key);
+      if (value !== undefined) {
+        out[key] = value;
+      } else if (boolSet.has(key)) {
+        out[key] = true;
+      } else {
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('-')) {
+          out[key] = next;
+          i++;
+        } else {
+          out[key] = true;
+        }
+      }
+      continue;
+    }
+
+    if (token.startsWith('-') && token.length > 1) {
+      const key = canonical(token.slice(1));
+      if (boolSet.has(key)) {
+        out[key] = true;
+      } else {
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('-')) {
+          out[key] = next;
+          i++;
+        } else {
+          out[key] = true;
+        }
+      }
+      continue;
+    }
+
+    out._.push(token);
+  }
+
+  return out;
+}
+
+module.exports = { parseArgs };

package/src/commands/init.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const config = require('../config');
+const remote = require('../remote');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const { ShiloClient } = require('../ShiloClient');
+
+const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+
+// UUID v4 laxo (acepta cualquier versión). El backend valida de verdad; esto es
+// sólo un aviso temprano ante un typo evidente.
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * shilo init --project <uuid> [carpeta] [--token <pat>] [--push] [--base-url <url>] [--force]
+ *
+ * Ata una carpeta local a un repositorio de Shilo escribiendo `.shilo.json`.
+ * El projectId se pasa directo (por ID). Antes de escribir, verifica que el
+ * proyecto sea accesible con la sesión actual (salvo --force).
+ *
+ * Con --token guarda las credenciales antes de verificar, de modo que el
+ * comando de una línea que se copia desde la web funcione sin "login" previo.
+ * Con --push, sube la carpeta al terminar.
+ */
+async function init(args) {
+  const dir = path.resolve(args._[0] || '.');
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    ui.error(`No es una carpeta válida: ${dir}`);
+    return 1;
+  }
+
+  const projectId = typeof args.project === 'string' ? args.project.trim() : '';
+  if (!projectId) {
+    ui.error('Falta el id del proyecto. Usá: shilo init --project <uuid> [carpeta]');
+    return 1;
+  }
+  if (!UUID_RE.test(projectId)) {
+    ui.warn(`"${projectId}" no parece un UUID. Continúo igual (el servidor validará).`);
+  }
+
+  // --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() : '';
+  if (token) {
+    const existing = config.load() || {};
+    config.save({
+      baseURL: args['base-url'] || existing.baseURL || DEFAULT_BASE_URL,
+      supabaseUrl: existing.supabaseUrl || null,
+      supabaseAnonKey: existing.supabaseAnonKey || null,
+      credentials: config.patCredentials(token),
+    });
+  }
+
+  const cfg = config.load();
+  if (!cfg || !cfg.credentials) {
+    ui.error('No hay sesión activa. Ejecutá "shilo login" primero.');
+    return 1;
+  }
+
+  const baseURL = args['base-url'] || (cfg && cfg.baseURL) || DEFAULT_BASE_URL;
+
+  // Aviso si ya hay un remote configurado.
+  const existing = remote.read(dir);
+  if (existing && existing.projectId && !args.force) {
+    ui.warn(
+      `Esta carpeta ya apunta al proyecto ${ui.c.bold(existing.projectId)}` +
+        (existing.baseURL ? ` en ${existing.baseURL}` : '') + '.'
+    );
+    const ok = await prompt.confirm('¿Sobrescribir el remote?', false);
+    if (!ok) {
+      ui.info('Cancelado.');
+      return 0;
+    }
+  }
+
+  // Verificar acceso al proyecto (salvo --force), listando la raíz.
+  if (!args.force) {
+    const client = new ShiloClient({
+      baseURL,
+      supabaseUrl: cfg.supabaseUrl || null,
+      supabaseAnonKey: cfg.supabaseAnonKey || null,
+    });
+    ui.info(`Verificando acceso al proyecto en ${ui.c.cyan(baseURL)} ...`);
+    try {
+      const { credentials } = await client.listFiles(projectId, cfg.credentials, '');
+      config.persistCredsIfChanged(cfg, credentials);
+    } catch (e) {
+      ui.error(`No se pudo acceder al proyecto: ${e.message}`);
+      ui.info(ui.c.dim('Revisá el id, tus permisos o la conexión. Podés forzar con --force.'));
+      return 1;
+    }
+  }
+
+  const written = remote.write(dir, { projectId, baseURL });
+  ui.success(`Carpeta atada al proyecto ${ui.c.bold(projectId)}.`);
+  ui.info(ui.c.dim(`Remote guardado en ${written}`));
+
+  if (args.push) {
+    // El usuario ya confirmó al pasar --push: no volvemos a preguntar.
+    return require('./push')({ ...args, _: [dir], yes: true });
+  }
+
+  ui.info(`Ahora podés subir con: ${ui.c.bold('shilo push')}`);
+  return 0;
+}
+
+module.exports = init;

package/src/commands/login.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const config = require('../config');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const { ShiloClient } = require('../ShiloClient');
+
+const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+
+/**
+ * shilo login [--email <e>] [--password <p>] [--token <pat>] [--base-url <url>]
+ *
+ * Autentica contra Shilo y guarda las credenciales cifradas en ~/.shilo/config.json.
+ * Con --token usa un Personal Access Token (generado desde la web) en lugar de
+ * email + contraseña.
+ */
+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 email = args.email;
+  let pass = args.password;
+
+  if (!email) email = await prompt.question('Email: ');
+  if (!email) {
+    ui.error('Email requerido.');
+    return 1;
+  }
+  if (!pass) pass = await prompt.password('Contraseña: ');
+  if (!pass) {
+    ui.error('Contraseña requerida.');
+    return 1;
+  }
+
+  const client = new ShiloClient({ baseURL });
+  ui.info(`Autenticando en ${ui.c.cyan(baseURL)} ...`);
+
+  let creds;
+  try {
+    creds = await client.authenticate(email, pass);
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  // Preservar supabaseUrl/anonKey si el usuario los configuró antes (habilitan refresh).
+  const existing = config.load() || {};
+  const saved = config.save({
+    baseURL,
+    supabaseUrl: existing.supabaseUrl || null,
+    supabaseAnonKey: existing.supabaseAnonKey || null,
+    credentials: creds,
+  });
+
+  const who = creds.user && creds.user.email ? creds.user.email : email;
+  ui.success(`Sesión iniciada como ${ui.c.bold(who)}.`);
+  ui.info(ui.c.dim(`Credenciales guardadas (cifradas) en ${saved}`));
+  return 0;
+}
+
+/**
+ * Guarda un PAT como credenciales, verificándolo contra el servidor antes de
+ * declarar éxito (un token inválido no debe quedar persistido en silencio).
+ */
+async function loginWithToken(token, baseURL) {
+  const client = new ShiloClient({ baseURL });
+  ui.info(`Verificando token en ${ui.c.cyan(baseURL)} ...`);
+
+  const creds = config.patCredentials(token);
+  let check;
+  try {
+    check = await client.verifyCredentials(creds);
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  if (!check.ok) {
+    ui.error(`El token no es válido: ${check.error}`);
+    ui.info(ui.c.dim('Generá uno nuevo desde Shilo (Ajustes → tokens de acceso).'));
+    return 1;
+  }
+
+  const existing = config.load() || {};
+  const saved = config.save({
+    baseURL,
+    supabaseUrl: existing.supabaseUrl || null,
+    supabaseAnonKey: existing.supabaseAnonKey || null,
+    credentials: creds,
+  });
+
+  ui.success('Token de acceso guardado.');
+  ui.info(ui.c.dim(`Credenciales guardadas (cifradas) en ${saved}`));
+  return 0;
+}
+
+module.exports = login;

package/src/commands/logout.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+
+/**
+ * shilo logout — borra el archivo de credenciales local.
+ */
+async function logout() {
+  const removed = config.clear();
+  if (removed) {
+    ui.success('Sesión cerrada. Credenciales locales eliminadas.');
+  } else {
+    ui.info('No había credenciales guardadas.');
+  }
+  return 0;
+}
+
+module.exports = logout;

package/src/commands/push.js

@@ -0,0 +1,306 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const config = require('../config');
+const remote = require('../remote');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const { walk } = require('../walk');
+const { classifyContent } = require('../textguard');
+const { ShiloClient } = require('../ShiloClient');
+
+const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const COMMIT_BATCH = 100; // máximo de archivos por commit (límite del backend)
+
+// Mapa mínimo extensión -> mime para texto. El backend default es text/plain.
+const TEXT_MIME = {
+  js: 'text/javascript', mjs: 'text/javascript', cjs: 'text/javascript',
+  ts: 'text/typescript', jsx: 'text/javascript', tsx: 'text/typescript',
+  json: 'application/json', html: 'text/html', htm: 'text/html',
+  css: 'text/css', md: 'text/markdown', markdown: 'text/markdown',
+  csv: 'text/csv', xml: 'application/xml', yml: 'text/yaml', yaml: 'text/yaml',
+  svg: 'image/svg+xml', txt: 'text/plain',
+};
+
+function guessMime(name) {
+  const dot = name.lastIndexOf('.');
+  const ext = dot > 0 ? name.slice(dot + 1).toLowerCase() : '';
+  return TEXT_MIME[ext] || 'text/plain';
+}
+
+/**
+ * shilo push [carpeta] [--project <uuid>] [-m <msg>] [--dry-run] [--yes] [--base-url <url>]
+ *
+ * Replica una carpeta local a un repo de Shilo: crea archivos nuevos, actualiza
+ * los que cambiaron, salta binarios/oversize/nombres inválidos, y registra todo
+ * en uno o más commits.
+ */
+async function push(args) {
+  const dir = path.resolve(args._[0] || '.');
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    ui.error(`No es una carpeta válida: ${dir}`);
+    return 1;
+  }
+
+  // 1) Resolver remote: --project pisa a .shilo.json.
+  const savedRemote = remote.read(dir);
+  const projectId =
+    (typeof args.project === 'string' && args.project.trim()) ||
+    (savedRemote && savedRemote.projectId) ||
+    null;
+
+  if (!projectId) {
+    ui.error('No hay proyecto configurado en esta carpeta.');
+    ui.info('Corré "shilo init --project <uuid>" o pasá --project <uuid>.');
+    return 1;
+  }
+
+  // 2) Sesión.
+  const cfg = config.load();
+  if (!cfg || !cfg.credentials) {
+    ui.error('No hay sesión activa. Ejecutá "shilo login" primero.');
+    return 1;
+  }
+
+  const baseURL =
+    args['base-url'] || (savedRemote && savedRemote.baseURL) || cfg.baseURL || DEFAULT_BASE_URL;
+
+  const dryRun = !!args['dry-run'];
+  const message =
+    typeof args.message === 'string' && args.message.trim() ? args.message.trim() : null;
+
+  // 3) Recorrer la carpeta.
+  const { files, skipped, ignored } = walk(dir);
+
+  if (skipped.length > 0) {
+    for (const s of skipped) {
+      ui.warn(`saltado ${ui.c.dim(s.relPath)} — ${s.reason}`);
+    }
+  }
+
+  // 4) Leer y clasificar (texto vs binario/oversize).
+  const uploads = []; // { relPath, absPath, content, mimeType }
+  const skippedBinary = [];
+  for (const f of files) {
+    let buf;
+    try {
+      buf = fs.readFileSync(f.absPath);
+    } catch (e) {
+      skippedBinary.push({ relPath: f.relPath, reason: `no se pudo leer: ${e.message}` });
+      continue;
+    }
+    const cls = classifyContent(path.basename(f.relPath), buf);
+    if (!cls.isText) {
+      skippedBinary.push({ relPath: f.relPath, reason: cls.reason });
+      continue;
+    }
+    uploads.push({
+      relPath: f.relPath,
+      absPath: f.absPath,
+      content: cls.content,
+      mimeType: guessMime(f.relPath),
+    });
+  }
+
+  for (const s of skippedBinary) {
+    ui.warn(`saltado ${ui.c.dim(s.relPath)} — ${s.reason}`);
+  }
+
+  if (uploads.length === 0) {
+    ui.info('No hay archivos de texto para subir.');
+    ui.info(
+      ui.c.dim(
+        `(${ignored} ignorados, ${skipped.length + skippedBinary.length} saltados)`
+      )
+    );
+    return 0;
+  }
+
+  const client = new ShiloClient({
+    baseURL,
+    supabaseUrl: cfg.supabaseUrl || null,
+    supabaseAnonKey: cfg.supabaseAnonKey || null,
+  });
+
+  ui.info(
+    `Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — ` +
+      `${uploads.length} archivo(s) de texto, ${ignored} ignorado(s), ` +
+      `${skipped.length + skippedBinary.length} saltado(s).`
+  );
+
+  // 5) Clasificar contra el remote (added / modified / unchanged) para planear.
+  //    Esto ya toca la red (getFileMeta / readFile) pero no escribe nada.
+  let creds = cfg.credentials;
+  const plan = { added: [], modified: [], unchanged: [], failed: [] };
+
+  for (const u of uploads) {
+    try {
+      const meta = await client.getFileMeta(projectId, u.relPath, creds);
+      creds = meta.credentials;
+
+      if (!meta.exists) {
+        plan.added.push(u);
+        continue;
+      }
+      if (meta.file && meta.file.type === 'folder') {
+        plan.failed.push({ ...u, reason: 'ya existe una carpeta con ese nombre' });
+        continue;
+      }
+
+      // Existe como archivo: ver si cambió comparando tamaño y luego contenido.
+      const localSize = Buffer.byteLength(u.content, 'utf8');
+      if (meta.file && typeof meta.file.size === 'number' && meta.file.size === localSize) {
+        const remoteRead = await client.readFile(projectId, u.relPath, creds);
+        creds = remoteRead.credentials;
+        if (remoteRead.file && remoteRead.file.content === u.content) {
+          plan.unchanged.push(u);
+          continue;
+        }
+      }
+      plan.modified.push({ ...u, remote: meta.file });
+    } catch (e) {
+      plan.failed.push({ ...u, reason: e.message });
+    }
+  }
+
+  config.persistCredsIfChanged(cfg, creds);
+
+  // 6) Reporte del plan.
+  ui.info('');
+  ui.info(`  ${ui.c.green('nuevos:')}       ${plan.added.length}`);
+  ui.info(`  ${ui.c.yellow('modificados:')}  ${plan.modified.length}`);
+  ui.info(`  ${ui.c.dim('sin cambios:')}  ${plan.unchanged.length}`);
+  if (plan.failed.length) {
+    ui.info(`  ${ui.c.red('con error:')}    ${plan.failed.length}`);
+  }
+  ui.info('');
+
+  const toWrite = plan.added.length + plan.modified.length;
+  if (toWrite === 0) {
+    if (plan.failed.length) {
+      for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
+      return 1;
+    }
+    ui.success('Todo al día. Nada para subir.');
+    return 0;
+  }
+
+  if (dryRun) {
+    for (const u of plan.added) ui.info(`  ${ui.c.green('+')} ${u.relPath}`);
+    for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}`);
+    for (const f of plan.failed) ui.info(`  ${ui.c.red('!')} ${f.relPath} — ${f.reason}`);
+    ui.info('');
+    ui.info(ui.c.dim('(--dry-run: no se subió nada)'));
+    return plan.failed.length ? 1 : 0;
+  }
+
+  // 7) Confirmar (salvo --yes).
+  if (!args.yes) {
+    const ok = await prompt.confirm(`¿Subir ${toWrite} archivo(s) al proyecto?`, true);
+    if (!ok) {
+      ui.info('Cancelado.');
+      return 0;
+    }
+  }
+
+  // 8) Ejecutar subidas. Se acumulan los cambios para el/los commit(s).
+  const changes = []; // { file_id, action, previous_storage_path?, new_storage_path? }
+  const ensuredCache = new Set();
+  const failedWrites = [];
+
+  for (const u of plan.added) {
+    try {
+      creds = await client.ensurePath(projectId, u.relPath, creds, ensuredCache);
+      const created = await client.createFile(
+        projectId, u.relPath, u.content, u.mimeType, creds
+      );
+      creds = created.credentials;
+
+      if (created.created && created.file) {
+        changes.push({
+          file_id: created.file.id,
+          action: 'added',
+          new_storage_path: created.file.storage_path,
+        });
+        ui.success(`${ui.c.green('+')} ${u.relPath}`);
+      } else {
+        // 409: apareció entremedio; caemos a update.
+        const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
+        creds = upd.credentials;
+        changes.push({
+          file_id: upd.file.id,
+          action: 'modified',
+          previous_storage_path: (created.file && created.file.storage_path) || upd.file.storage_path,
+          new_storage_path: upd.file.storage_path,
+        });
+        ui.success(`${ui.c.yellow('~')} ${u.relPath}`);
+      }
+      config.persistCredsIfChanged(cfg, creds);
+    } catch (e) {
+      failedWrites.push({ relPath: u.relPath, reason: e.message });
+      ui.error(`${u.relPath} — ${e.message}`);
+    }
+  }
+
+  for (const u of plan.modified) {
+    try {
+      const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
+      creds = upd.credentials;
+      changes.push({
+        file_id: upd.file.id,
+        action: 'modified',
+        previous_storage_path: u.remote ? u.remote.storage_path : undefined,
+        new_storage_path: upd.file.storage_path,
+      });
+      ui.success(`${ui.c.yellow('~')} ${u.relPath}`);
+      config.persistCredsIfChanged(cfg, creds);
+    } catch (e) {
+      failedWrites.push({ relPath: u.relPath, reason: e.message });
+      ui.error(`${u.relPath} — ${e.message}`);
+    }
+  }
+
+  // 9) Commit(s) en lotes de <=100.
+  let committed = 0;
+  if (changes.length > 0) {
+    const total = changes.length;
+    const nBatches = Math.ceil(total / COMMIT_BATCH);
+    for (let i = 0; i < total; i += COMMIT_BATCH) {
+      const batch = changes.slice(i, i + COMMIT_BATCH);
+      const partNo = Math.floor(i / COMMIT_BATCH) + 1;
+      const msg = buildMessage(message, batch.length, total, partNo, nBatches);
+      try {
+        const result = await client.createCommit(projectId, msg, batch, creds);
+        creds = result.credentials;
+        committed += batch.length;
+        config.persistCredsIfChanged(cfg, creds);
+      } catch (e) {
+        ui.error(`Fallo al crear el commit (lote ${partNo}/${nBatches}): ${e.message}`);
+        failedWrites.push({ relPath: `<commit lote ${partNo}>`, reason: e.message });
+      }
+    }
+  }
+
+  config.persistCredsIfChanged(cfg, creds);
+
+  // 10) Resumen final.
+  ui.info('');
+  const nCommits = Math.ceil(changes.length / COMMIT_BATCH);
+  if (failedWrites.length === 0) {
+    ui.success(
+      `Push completo: ${committed} archivo(s) en ${nCommits} commit(s).`
+    );
+    return 0;
+  }
+  ui.warn(`Push con problemas: ${failedWrites.length} archivo(s)/commit(s) fallaron.`);
+  return 1;
+}
+
+function buildMessage(userMsg, batchCount, total, partNo, nBatches) {
+  const base = userMsg || `shilo push: ${total} archivo(s)`;
+  if (nBatches > 1) return `${base} (${partNo}/${nBatches})`;
+  return base;
+}
+
+module.exports = push;

package/src/commands/whoami.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+
+/**
+ * shilo whoami — muestra la sesión activa (si la hay) sin exponer el token.
+ */
+async function whoami() {
+  let cfg;
+  try {
+    cfg = config.load();
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  }
+
+  if (!cfg || !cfg.credentials) {
+    ui.warn('No hay sesión activa. Ejecutá "shilo login".');
+    return 1;
+  }
+
+  const { user, expiresAt, kind } = cfg.credentials;
+  const email = (user && user.email) || '(desconocido)';
+
+  // Un PAT no lleva expiración local: la valida el servidor en cada request.
+  if (kind === 'pat') {
+    ui.info(`Usuario:  ${ui.c.bold(email)}`);
+    ui.info(`Servidor: ${cfg.baseURL || '(default)'}`);
+    ui.info(`Token:    ${ui.c.green('token de acceso personal')}`);
+    return 0;
+  }
+
+  const expDate = new Date(expiresAt);
+  const msLeft = expDate.getTime() - Date.now();
+  const estado =
+    msLeft <= 0
+      ? ui.c.red('expirado')
+      : msLeft < 5 * 60 * 1000
+        ? ui.c.yellow('expira pronto')
+        : ui.c.green('válido');
+
+  ui.info(`Usuario:  ${ui.c.bold(email)}`);
+  ui.info(`Servidor: ${cfg.baseURL || '(default)'}`);
+  ui.info(`Token:    ${estado} ${ui.c.dim(`(exp. ${expDate.toLocaleString()})`)}`);
+  return 0;
+}
+
+module.exports = whoami;