entexto-cli 1.1.0 → 1.3.0

package/bin/entexto.js

@@ -29,6 +29,7 @@ program
   .option('-d, --dir <path>',  'Carpeta a subir (default: carpeta actual)', '.')
   .option('-w, --watch',       'Modo live: detecta cambios y re-sube automáticamente')
   .option('-p, --publish',     'Publicar el proyecto después del deploy')
+  .option('-f, --full',        'Subir todos los archivos sin comparar hashes (sin delta)')
   .action(require('../lib/commands/deploy'));
 
 // ─── entexto whoami ──────────────────────────────────────────
@@ -67,6 +68,15 @@ const pullAction = require('../lib/commands/pull');
     .option('-d, --dir <path>', 'Carpeta destino (default: carpeta actual)', '.')
     .action(pullAction);
 });
+// ─── entexto sync ────────────────────────────────────────────
+program
+  .command('sync')
+  .description('Sincronización bidireccional en tiempo real (local ↔ remoto)')
+  .option('-i, --id <uuid>',   'UUID del proyecto')
+  .option('-d, --dir <path>',  'Carpeta local (default: carpeta actual)', '.')
+  .option('-f, --full',        'Subir todos los archivos en el delta inicial (sin comparación)')
+  .action(require('../lib/commands/sync'));
+
 program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {

package/lib/commands/deploy.js

@@ -1,203 +1,205 @@
-'use strict';
-
-const fs       = require('fs');
-const path     = require('path');
-const inquirer = require('inquirer');
-const chalk    = require('chalk');
-const ora      = require('ora');
-const FormData = require('form-data');
-const chokidar = require('chokidar');
-const { getToken }      = require('../utils/config');
-const { getProjects, deployWithPublish, deployFiles, publishProject } = require('../utils/api');
-
-// Archivos/carpetas que nunca se suben
-const IGNORE_NAMES = new Set([
-  'node_modules', '.git', '.env', '.env.local', '.DS_Store',
-  'dist', '.next', 'build', 'coverage', '.cache', '.turbo',
-  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
-  '.entexto', 'Thumbs.db',
-]);
-
-// Extensiones que se excluyen por seguridad
-const IGNORE_EXT = new Set([
-  '.key', '.pem', '.cert', '.p12', '.pfx', '.sqlite', '.sqlite3',
-  '.db', '.log', '.bak', '.backup',
-]);
-
-function debeIgnorar(nombre) {
-  if (IGNORE_NAMES.has(nombre)) return true;
-  const ext = path.extname(nombre).toLowerCase();
-  if (IGNORE_EXT.has(ext)) return true;
-  if (nombre.startsWith('.') && nombre !== '.htaccess') return true;
-  return false;
-}
-
-function recolectarArchivos(dir, base) {
-  base = base || dir;
-  const resultado = [];
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return resultado;
-  }
-  for (const entry of entries) {
-    if (debeIgnorar(entry.name)) continue;
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      resultado.push(...recolectarArchivos(fullPath, base));
-    } else if (entry.isFile()) {
-      resultado.push(fullPath);
-    }
-  }
-  return resultado;
-}
-
-async function ejecutarDeploy(uuid, dir, publish) {
-  const absDir = path.resolve(dir);
-  const archivos = recolectarArchivos(absDir);
-
-  if (!archivos.length) {
-    console.log(chalk.yellow('  No se encontraron archivos para subir.'));
-    return false;
-  }
-
-  const spinner = ora(`Subiendo ${archivos.length} archivo(s)...`).start();
-
-  try {
-    const form = new FormData();
-
-    for (const filePath of archivos) {
-      const ruta = path.relative(absDir, filePath).replace(/\\/g, '/');
-      form.append(ruta, fs.createReadStream(filePath), { filename: ruta });
-    }
-
-    let result;
-    if (publish) {
-      result = await deployWithPublish(uuid, form);
-    } else {
-      result = await deployFiles(uuid, form, false);
-    }
-
-    spinner.stop();
-    (result.archivos || []).forEach(r => {
-      console.log('  ' + chalk.green('✓') + ' ' + chalk.white(r));
-    });
-    console.log(
-      chalk.bold.green(`\n  🚀 Deploy completado — ${result.total} archivo(s)\n`)
-    );
-    if (result.publicado && result.publicado.url) {
-      console.log('  ' + chalk.bold.cyan('🌐 ' + result.publicado.url) + '\n');
-    }
-    return true;
-  } catch (err) {
-    const msg = err.response?.data?.error || err.message;
-    spinner.fail(chalk.red('Error en deploy: ' + msg));
-    return false;
-  }
-}
-
-module.exports = async function (options) {
-  if (!getToken()) {
-    console.log(chalk.red('\n  No has iniciado sesión. Ejecuta: entexto login\n'));
-    process.exit(1);
-  }
-
-  // ── Resolver proyecto destino ─────────────────────────────
-  let uuid = options.id;
-
-  if (!uuid) {
-    const spinner = ora('Cargando proyectos...').start();
-    let projects;
-    try {
-      projects = await getProjects();
-      spinner.stop();
-    } catch (err) {
-      const msg = err.response?.data?.error || err.message;
-      spinner.fail(chalk.red('Error cargando proyectos: ' + msg));
-      process.exit(1);
-    }
-
-    if (!projects.length) {
-      console.log(chalk.yellow('\n  No tienes proyectos. Crea uno primero en entexto.com\n'));
-      process.exit(0);
-    }
-
-    const { selectedUuid } = await inquirer.prompt([{
-      type:    'list',
-      name:    'selectedUuid',
-      message: '¿A qué proyecto deseas subir los archivos?',
-      pageSize: 10,
-      choices: projects.map(p => ({
-        name: [
-          (p.project_uuid || String(p.id)).padEnd(20),
-          (p.name || 'Sin nombre').slice(0, 28).padEnd(30),
-          p.is_published ? chalk.green('📡') : chalk.yellow('🔒'),
-        ].join(' '),
-        value: p.project_uuid || String(p.id),
-      })),
-    }]);
-
-    uuid = selectedUuid;
-  }
-
-  // ── Carpeta a subir ──────────────────────────────────────
-  const dir = options.dir || '.';
-  if (!fs.existsSync(path.resolve(dir))) {
-    console.log(chalk.red(`  La carpeta "${dir}" no existe.\n`));
-    process.exit(1);
-  }
-
-  // ── Preguntar publicar (solo si no está en modo watch ni --publish) ──
-  let publish = !!options.publish;
-  if (!publish && !options.watch) {
-    const { shouldPublish } = await inquirer.prompt([{
-      type:    'confirm',
-      name:    'shouldPublish',
-      message: '¿Publicar el proyecto después del deploy?',
-      default: true,
-    }]);
-    publish = shouldPublish;
-  }
-
-  // ── Modo normal ─────────────────────────────────────────
-  if (!options.watch) {
-    await ejecutarDeploy(uuid, dir, publish);
-    return;
-  }
-
-  // ── Modo --watch ─────────────────────────────────────────
-  console.log(chalk.bold.cyan('\n  👀 Modo watch activo. Ctrl+C para detener.\n'));
-  await ejecutarDeploy(uuid, dir, publish);
-
-  let debounce = null;
-  const changed = new Set();
-
-  const watcher = chokidar.watch(path.resolve(dir), {
-    ignored: (filePath) => {
-      const name = path.basename(filePath);
-      return debeIgnorar(name);
-    },
-    ignoreInitial: true,
-    usePolling:    false,
-    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
-  });
-
-  watcher.on('all', (event, filePath) => {
-    changed.add(filePath);
-    clearTimeout(debounce);
-    debounce = setTimeout(async () => {
-      const files   = [...changed];
-      changed.clear();
-      const nombres = files
-        .map(f => path.relative(path.resolve(dir), f))
-        .join(', ');
-      console.log(chalk.gray(`  [watch] ${event}: ${nombres}`));
-      await ejecutarDeploy(uuid, dir, false);
-    }, 300);
-  });
-
-  watcher.on('error', err => {
-    console.error(chalk.red('  [watch] Error: ' + err.message));
-  });
-};
+'use strict';
+
+const fs       = require('fs');
+const path     = require('path');
+const inquirer = require('inquirer');
+const chalk    = require('chalk');
+const ora      = require('ora');
+const FormData = require('form-data');
+const chokidar = require('chokidar');
+const { getToken }      = require('../utils/config');
+const { getProjects, deployWithPublish, deployFiles, publishProject, getManifest } = require('../utils/api');
+const { hashFile } = require('../utils/delta');
+
+// Archivos/carpetas que nunca se suben
+const IGNORE_NAMES = new Set([
+  'node_modules', '.git', '.env', '.env.local', '.DS_Store',
+  'dist', '.next', 'build', 'coverage', '.cache', '.turbo',
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+  '.entexto', 'Thumbs.db',
+]);
+
+// Extensiones que se excluyen por seguridad
+const IGNORE_EXT = new Set([
+  '.key', '.pem', '.cert', '.p12', '.pfx', '.sqlite', '.sqlite3',
+  '.db', '.log', '.bak', '.backup',
+]);
+
+function debeIgnorar(nombre) {
+  if (IGNORE_NAMES.has(nombre)) return true;
+  const ext = path.extname(nombre).toLowerCase();
+  if (IGNORE_EXT.has(ext)) return true;
+  if (nombre.startsWith('.') && nombre !== '.htaccess') return true;
+  return false;
+}
+
+function recolectarArchivos(dir) {
+  const resultado = [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return resultado; }
+  for (const entry of entries) {
+    if (debeIgnorar(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) resultado.push(...recolectarArchivos(fullPath));
+    else if (entry.isFile()) resultado.push(fullPath);
+  }
+  return resultado;
+}
+
+/** Sube UN archivo (para watch mode) */
+async function subirArchivoSolo(uuid, absDir, filePath, publish) {
+  if (!fs.existsSync(filePath)) return;
+  const ruta = path.relative(absDir, filePath).replace(/\\/g, '/');
+  if (debeIgnorar(path.basename(filePath))) return;
+  try {
+    const form = new FormData();
+    form.append(ruta, fs.createReadStream(filePath), { filename: ruta });
+    if (publish) {
+      await deployWithPublish(uuid, form);
+    } else {
+      await deployFiles(uuid, form, false);
+    }
+    console.log('  ' + chalk.green('') + ' ' + chalk.white(ruta));
+  } catch (err) {
+    const msg = err.response?.data?.error || err.message;
+    console.log('  ' + chalk.red('') + ' ' + chalk.white(ruta) + chalk.red(' ' + msg));
+  }
+}
+
+/**
+ * Deploy principal.
+ * @param {string} uuid
+ * @param {string} dir
+ * @param {boolean} publish
+ * @param {boolean} full   true = subir todo, false = solo cambios (delta)
+ */
+async function ejecutarDeploy(uuid, dir, publish, full) {
+  const absDir = path.resolve(dir);
+  const archivos = recolectarArchivos(absDir);
+
+  if (!archivos.length) {
+    console.log(chalk.yellow('  No se encontraron archivos para subir.'));
+    return false;
+  }
+
+  // Delta: obtener manifest del servidor
+  let manifest = {};
+  if (!full) {
+    try { manifest = await getManifest(uuid); } catch {}
+  }
+
+  const aSubir   = [];
+  const omitidos = [];
+
+  for (const filePath of archivos) {
+    const ruta = path.relative(absDir, filePath).replace(/\\/g, '/');
+    if (!full && manifest[ruta]) {
+      const localHash = hashFile(filePath);
+      if (localHash && manifest[ruta] === localHash) { omitidos.push(ruta); continue; }
+    }
+    aSubir.push({ filePath, ruta });
+  }
+
+  omitidos.forEach(ruta => console.log('  ' + chalk.gray('') + ' ' + chalk.gray(ruta)));
+
+  if (!aSubir.length) {
+    console.log(chalk.green.bold('\n   Todo al día  ningún archivo cambió.\n'));
+    if (publish) {
+      const sp2 = ora('Publicando...').start();
+      try {
+        const r = await publishProject(uuid);
+        sp2.succeed('Publicado: ' + chalk.cyan(r.url || ''));
+      } catch (e) { sp2.fail('Error: ' + (e.response?.data?.error || e.message)); }
+    }
+    return true;
+  }
+
+  const spinner = ora(`Subiendo ${aSubir.length} archivo(s)...`).start();
+
+  try {
+    const form = new FormData();
+    for (const { filePath, ruta } of aSubir) {
+      form.append(ruta, fs.createReadStream(filePath), { filename: ruta });
+    }
+    const result = publish
+      ? await deployWithPublish(uuid, form)
+      : await deployFiles(uuid, form, false);
+
+    spinner.stop();
+    (result.archivos || []).forEach(r => console.log('  ' + chalk.green('') + ' ' + chalk.white(r)));
+    console.log(
+      chalk.bold.green(`\n   Deploy  ${result.total || aSubir.length} subido(s)`)
+      + (omitidos.length ? chalk.gray(`, ${omitidos.length} sin cambios`) : '') + '\n'
+    );
+    if (result.publicado?.url) console.log('  ' + chalk.bold.cyan(' ' + result.publicado.url) + '\n');
+    return true;
+  } catch (err) {
+    const msg = err.response?.data?.error || err.message;
+    spinner.fail(chalk.red('Error en deploy: ' + msg));
+    return false;
+  }
+}
+
+module.exports = async function (options) {
+  if (!getToken()) { console.log(chalk.red('\n  No has iniciado sesión. Ejecuta: entexto login\n')); process.exit(1); }
+
+  const full = !!options.full;
+  if (full) console.log(chalk.gray('\n  Modo completo (--full): subiendo todos los archivos...\n'));
+
+  let uuid = options.id;
+  if (!uuid) {
+    const spinner = ora('Cargando proyectos...').start();
+    let projects;
+    try { projects = await getProjects(); spinner.stop(); }
+    catch (err) { spinner.fail(chalk.red('Error: ' + (err.response?.data?.error || err.message))); process.exit(1); }
+
+    if (!projects.length) { console.log(chalk.yellow('\n  No tienes proyectos.\n')); process.exit(0); }
+
+    const { selectedUuid } = await inquirer.prompt([{
+      type: 'list', name: 'selectedUuid', message: '¿A qué proyecto deseas subir los archivos?', pageSize: 10,
+      choices: projects.map(p => ({
+        name: [(p.project_uuid || String(p.id)).padEnd(20), (p.name || 'Sin nombre').slice(0,28).padEnd(30), p.is_published ? chalk.green('') : chalk.yellow('')].join(' '),
+        value: p.project_uuid || String(p.id),
+      })),
+    }]);
+    uuid = selectedUuid;
+  }
+
+  const dir = options.dir || '.';
+  if (!fs.existsSync(path.resolve(dir))) { console.log(chalk.red(`  La carpeta "${dir}" no existe.\n`)); process.exit(1); }
+
+  let publish = !!options.publish;
+  if (!publish && !options.watch) {
+    const { shouldPublish } = await inquirer.prompt([{ type: 'confirm', name: 'shouldPublish', message: '¿Publicar el proyecto después del deploy?', default: true }]);
+    publish = shouldPublish;
+  }
+
+  if (!options.watch) { await ejecutarDeploy(uuid, dir, publish, full); return; }
+
+  console.log(chalk.bold.cyan('\n   Modo watch activo. Ctrl+C para detener.\n'));
+  await ejecutarDeploy(uuid, dir, publish, full);
+
+  let debounce = null;
+  const changed = new Set();
+  const absDir  = path.resolve(dir);
+
+  const watcher = chokidar.watch(absDir, {
+    ignored: (fp) => debeIgnorar(path.basename(fp)),
+    ignoreInitial: true, usePolling: false,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+  });
+
+  function disparar() {
+    clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      const files = [...changed]; changed.clear();
+      for (const fp of files) await subirArchivoSolo(uuid, absDir, fp, false);
+    }, 300);
+  }
+
+  watcher.on('add', fp => { changed.add(fp); disparar(); });
+  watcher.on('change', fp => { changed.add(fp); disparar(); });
+  watcher.on('error', err => console.error(chalk.red('  [watch] Error: ' + err.message)));
+};
+
+module.exports.subirArchivoSolo = subirArchivoSolo;

package/lib/commands/sync.js

@@ -0,0 +1,314 @@
+'use strict';
+
+const fs       = require('fs');
+const path     = require('path');
+const inquirer = require('inquirer');
+const chalk    = require('chalk');
+const ora      = require('ora');
+const FormData = require('form-data');
+const chokidar = require('chokidar');
+const { getToken }    = require('../utils/config');
+const { getProjects, deployFiles, getManifest, pullProject, streamEvents } = require('../utils/api');
+const { hashFile, hashContent } = require('../utils/delta');
+
+const IGNORE_NAMES = new Set([
+  'node_modules', '.git', '.env', '.env.local', '.DS_Store',
+  'dist', '.next', 'build', 'coverage', '.cache', '.turbo',
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+  '.entexto', 'Thumbs.db',
+]);
+const IGNORE_EXT = new Set([
+  '.key', '.pem', '.cert', '.p12', '.pfx', '.sqlite', '.sqlite3',
+  '.db', '.log', '.bak', '.backup',
+]);
+function debeIgnorar(nombre) {
+  if (IGNORE_NAMES.has(nombre)) return true;
+  const ext = path.extname(nombre).toLowerCase();
+  if (IGNORE_EXT.has(ext)) return true;
+  if (nombre.startsWith('.') && nombre !== '.htaccess') return true;
+  return false;
+}
+function recolectarArchivos(dir) {
+  const resultado = [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return resultado; }
+  for (const entry of entries) {
+    if (debeIgnorar(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) resultado.push(...recolectarArchivos(full));
+    else if (entry.isFile()) resultado.push(full);
+  }
+  return resultado;
+}
+
+// Rastrea cuándo subimos cada archivo (para evitar eco del SSE)
+const localUploadedAt = new Map();
+
+async function subirArchivoSolo(uuid, absDir, filePath) {
+  if (!fs.existsSync(filePath)) return;
+  const ruta = path.relative(absDir, filePath).replace(/\\/g, '/');
+  if (debeIgnorar(path.basename(filePath))) return;
+  try {
+    const form = new FormData();
+    form.append(ruta, fs.createReadStream(filePath), { filename: ruta });
+    await deployFiles(uuid, form, false);
+    localUploadedAt.set(ruta, Date.now());
+    console.log('  ' + chalk.green('↑') + ' ' + chalk.white(ruta) + chalk.gray(' → remoto'));
+  } catch (err) {
+    const msg = err.response?.data?.error || err.message;
+    console.log('  ' + chalk.red('✖') + ' ' + chalk.white(ruta) + chalk.red(' ' + msg));
+  }
+}
+
+module.exports = async function sync(options) {
+  if (!getToken()) {
+    console.error(chalk.red('✖ No has iniciado sesión. Ejecuta: entexto login'));
+    process.exit(1);
+  }
+
+  let uuid = options.id || null;
+
+  if (!uuid) {
+    const spinner = ora('Cargando proyectos...').start();
+    let proyectos;
+    try {
+      proyectos = await getProjects();
+      spinner.stop();
+    } catch (err) {
+      spinner.stop();
+      console.error(chalk.red('✖ Error: ' + err.message));
+      process.exit(1);
+    }
+    if (!proyectos || !proyectos.length) {
+      console.log(chalk.yellow('No tienes proyectos.'));
+      return;
+    }
+    const choices = proyectos.map((p, i) => ({
+      name: `${String(i + 1).padStart(2, ' ')}. ${p.name}${p.is_published ? chalk.green(' [publicado]') : ''}  ${chalk.gray(p.project_uuid)}`,
+      value: p.project_uuid,
+      short: p.name,
+    }));
+    const { selectedUuid } = await inquirer.prompt([{
+      type: 'list', name: 'selectedUuid',
+      message: 'Elige el proyecto a sincronizar:',
+      choices, pageSize: 15,
+    }]);
+    uuid = selectedUuid;
+  }
+
+  const dir = options.dir || '.';
+  const absDir = path.resolve(dir);
+  if (!fs.existsSync(absDir)) {
+    console.error(chalk.red(`✖ La carpeta "${dir}" no existe.`));
+    process.exit(1);
+  }
+
+  // ── 1. Delta inicial bidireccional ──────────────────────────────────────
+  console.log(chalk.bold('\n🔄 Sincronización inicial...\n'));
+
+  // 1a. Manifest remoto { ruta: hash }
+  let manifest = {};
+  try {
+    manifest = await getManifest(uuid);
+  } catch {
+    console.log(chalk.gray('  (manifest no disponible, comparando todos)'));
+  }
+
+  // 1b. Hashes de los archivos locales
+  const todosArchivos = recolectarArchivos(absDir);
+  const localHashes = new Map();
+  for (const fp of todosArchivos) {
+    const ruta = path.relative(absDir, fp).replace(/\\/g, '/');
+    localHashes.set(ruta, hashFile(fp));
+  }
+
+  // 1c. Clasificar qué hacer con cada archivo
+  const aDescargar = [];  // ruta[]             — remoto → local
+  const aSubir     = [];  // { filePath, ruta }[] — local → remoto
+
+  // Recorrer archivos remotos
+  for (const [ruta, remHash] of Object.entries(manifest)) {
+    const localHash = localHashes.get(ruta);
+    if (!localHash) {
+      // No existe localmente → descargar
+      aDescargar.push(ruta);
+    } else if (localHash === remHash) {
+      // Mismo contenido → sin cambios
+      console.log('  ' + chalk.gray('──') + ' ' + chalk.gray(ruta));
+    } else {
+      // Hash diferente → si el archivo local fue modificado hace < 10s, local gana
+      // de lo contrario remoto gana (remoto es fuente de verdad en sync inicial)
+      try {
+        const stat = fs.statSync(path.join(absDir, ruta));
+        if (Date.now() - stat.mtimeMs < 10000) {
+          aSubir.push({ filePath: path.join(absDir, ruta), ruta });
+        } else {
+          aDescargar.push(ruta);
+        }
+      } catch {
+        aDescargar.push(ruta);
+      }
+    }
+  }
+
+  // Archivos solo en local (no están en remoto) → subir
+  for (const [ruta] of localHashes) {
+    if (!(ruta in manifest)) {
+      aSubir.push({ filePath: path.join(absDir, ruta), ruta });
+    }
+  }
+
+  // 1d. Descargar archivos remotos faltantes o actualizados
+  if (aDescargar.length > 0) {
+    const sp = ora(`Descargando ${aDescargar.length} archivo(s) del servidor...`).start();
+    try {
+      const pullData = await pullProject(uuid);
+      const archivos = pullData.archivos || [];
+      const contentMap = new Map(archivos.map(a => [a.ruta, a.content]));
+      sp.stop();
+      let downloaded = 0;
+      for (const ruta of aDescargar) {
+        const contenido = contentMap.get(ruta);
+        if (contenido === undefined) {
+          console.log('  ' + chalk.yellow('⚠') + ' No encontrado en pull: ' + chalk.gray(ruta));
+          continue;
+        }
+        const destFile = path.join(absDir, ruta);
+        const destDir  = path.dirname(destFile);
+        if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+        fs.writeFileSync(destFile, contenido, 'utf8');
+        localUploadedAt.set(ruta, Date.now()); // evitar re-subida por chokidar
+        console.log('  ' + chalk.cyan('↓') + ' ' + chalk.white(ruta) + chalk.gray(' ← remoto'));
+        downloaded++;
+      }
+      console.log(chalk.green(`  ✔ ${downloaded} archivo(s) descargados\n`));
+    } catch (err) {
+      sp.fail('Error descargando: ' + (err.response?.data?.error || err.message));
+    }
+  }
+
+  // 1e. Subir archivos locales nuevos o modificados recientemente
+  if (aSubir.length > 0) {
+    const sp = ora(`Subiendo ${aSubir.length} archivo(s) al servidor...`).start();
+    try {
+      const form = new FormData();
+      for (const { filePath, ruta } of aSubir) {
+        form.append(ruta, fs.createReadStream(filePath), { filename: ruta });
+        localUploadedAt.set(ruta, Date.now());
+      }
+      await deployFiles(uuid, form, false);
+      sp.stop();
+      aSubir.forEach(({ ruta }) =>
+        console.log('  ' + chalk.green('↑') + ' ' + chalk.white(ruta) + chalk.gray(' → remoto'))
+      );
+      console.log(chalk.green(`  ✔ ${aSubir.length} archivo(s) subidos\n`));
+    } catch (err) {
+      sp.fail('Error subiendo: ' + (err.response?.data?.error || err.message));
+    }
+  }
+
+  if (aDescargar.length === 0 && aSubir.length === 0) {
+    console.log(chalk.green('  ✔ Todo sincronizado, sin cambios.\n'));
+  }
+
+  // ── 2. Canal SSE (remoto → local) ───────────────────────────────────────
+  console.log(chalk.bold.cyan('\n🔗 Abriendo canal bidireccional...\n'));
+
+  let sseStream = null;
+  let sseReconnectTimer = null;
+
+  function manejarEventoRemoto(eventType, data) {
+    if (eventType !== 'file-update') return;
+    const { ruta, contenido } = data || {};
+    if (!ruta || contenido === undefined) return;
+
+    // Evitar eco: si acabamos de subir este archivo (< 3s), ignorar
+    const uploadedAt = localUploadedAt.get(ruta);
+    if (uploadedAt && Date.now() - uploadedAt < 3000) return;
+
+    const destFile = path.join(absDir, ruta);
+    const destDir  = path.dirname(destFile);
+
+    // Detección de conflicto: archivo local modificado hace < 5s Y diferente al remoto
+    try {
+      if (fs.existsSync(destFile)) {
+        const stat      = fs.statSync(destFile);
+        const localHash = hashFile(destFile);
+        const remHash   = hashContent(contenido);
+        if (localHash !== remHash && Date.now() - stat.mtimeMs < 5000) {
+          const conflictPath = destFile + '.conflict.' + Date.now();
+          fs.writeFileSync(conflictPath, contenido, 'utf8');
+          console.log('  ' + chalk.yellow('⚠') + '  CONFLICTO ' + chalk.white(ruta));
+          console.log('     Versión remota guardada → ' + chalk.gray(path.basename(conflictPath)));
+          return;
+        }
+      }
+    } catch {}
+
+    try {
+      if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+      fs.writeFileSync(destFile, contenido, 'utf8');
+      localUploadedAt.set(ruta, Date.now()); // evitar re-subida por chokidar
+      console.log('  ' + chalk.cyan('↓') + ' ' + chalk.white(ruta) + chalk.gray(' ← remoto'));
+    } catch {
+      console.log('  ' + chalk.red('✖') + ' No se pudo escribir: ' + ruta);
+    }
+  }
+
+  function conectarSSE() {
+    streamEvents(uuid, manejarEventoRemoto)
+      .then(stream => {
+        sseStream = stream;
+        console.log(chalk.green('  ✔ SSE conectado — escuchando cambios remotos\n'));
+        stream.on('error', () => {
+          console.log(chalk.yellow('\n  ⚠ SSE desconectado, reconectando en 5s...'));
+          sseReconnectTimer = setTimeout(conectarSSE, 5000);
+        });
+        stream.on('close', () => {
+          console.log(chalk.yellow('\n  ⚠ SSE cerrado, reconectando en 5s...'));
+          sseReconnectTimer = setTimeout(conectarSSE, 5000);
+        });
+      })
+      .catch(err => {
+        console.log(chalk.yellow('  ⚠ SSE no disponible: ' + err.message));
+        sseReconnectTimer = setTimeout(conectarSSE, 5000);
+      });
+  }
+
+  conectarSSE();
+
+  // ── 3. Watch local → remoto ─────────────────────────────────────────────
+  console.log(chalk.bold('👀 Watching: ' + absDir));
+  console.log(chalk.gray('  Ctrl+C para detener\n'));
+
+  let debounce = null;
+  const changed = new Set();
+
+  const watcher = chokidar.watch(absDir, {
+    ignored: (fp) => debeIgnorar(path.basename(fp)),
+    ignoreInitial: true,
+    usePolling: false,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+  });
+
+  function disparar() {
+    clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      const files = [...changed];
+      changed.clear();
+      for (const fp of files) await subirArchivoSolo(uuid, absDir, fp);
+    }, 300);
+  }
+
+  watcher.on('add',    fp => { changed.add(fp); disparar(); });
+  watcher.on('change', fp => { changed.add(fp); disparar(); });
+  watcher.on('error',  err => console.error(chalk.red('  [watch] Error: ' + err.message)));
+
+  process.on('SIGINT', () => {
+    clearTimeout(sseReconnectTimer);
+    if (sseStream) try { sseStream.destroy(); } catch {}
+    watcher.close();
+    console.log(chalk.gray('\n  Sync detenido.\n'));
+    process.exit(0);
+  });
+};

package/lib/utils/api.js

@@ -64,4 +64,36 @@ async function pullProject(uuid) {
   return res.data;
 }
 
-module.exports = { login, getProjects, deployFiles, deployWithPublish, publishProject, pullProject };
+async function getManifest(uuid) {
+  const res = await client().get(`/api/cli/manifest/${uuid}`);
+  return res.data.manifest || {};
+}
+
+async function streamEvents(uuid, onEvent) {
+  const token   = getToken();
+  const baseURL = getBaseUrl();
+  const response = await axios.get(`${baseURL}/api/cli/stream/${uuid}`, {
+    headers: token ? { Authorization: `Bearer ${token}` } : {},
+    responseType: 'stream',
+    timeout: 0,
+  });
+  const stream = response.data;
+  let buffer = '';
+  stream.on('data', (chunk) => {
+    buffer += chunk.toString();
+    const parts = buffer.split('\n');
+    buffer = parts.pop();
+    let eventType = 'message', dataStr = '';
+    for (const line of parts) {
+      if (line.startsWith('event: '))      eventType = line.slice(7).trim();
+      else if (line.startsWith('data: '))  dataStr   = line.slice(6).trim();
+      else if (line === '' && dataStr) {
+        try { onEvent(eventType, JSON.parse(dataStr)); } catch {}
+        eventType = 'message'; dataStr = '';
+      }
+    }
+  });
+  return stream;
+}
+
+module.exports = { login, getProjects, deployFiles, deployWithPublish, publishProject, pullProject, getManifest, streamEvents };

package/lib/utils/delta.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs     = require('fs');
+
+/**
+ * SHA256 (16 chars) del contenido de un Buffer o string.
+ */
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/**
+ * SHA256 (16 chars) del contenido de un archivo en disco.
+ * Devuelve null si no se puede leer.
+ */
+function hashFile(filePath) {
+  try {
+    const buf = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(buf).digest('hex').slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { hashContent, hashFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entexto-cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "CLI oficial de Entexto — Deploy y gestión de proyectos desde tu terminal",
   "main": "lib/index.js",
   "bin": {