entexto-cli 1.4.3 → 1.4.5

package/bin/entexto.js

@@ -77,6 +77,14 @@ program
   .option('-f, --full',        'Subir todos los archivos en el delta inicial (sin comparación)')
   .action(require('../lib/commands/sync'));
 
+// ─── entexto tunnel ──────────────────────────────────────────
+program
+  .command('tunnel [target]')
+  .description('Exponer un servidor local en una URL pública de entexto.com')
+  .action((target) => {
+    require('../lib/commands/tunnel')({ target: target || '3000' });
+  });
+
 program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {

package/lib/commands/pull.js

@@ -85,13 +85,17 @@ module.exports = async function pull(options) {
 
   // Escribir archivos localmente
   let escritos = 0;
-  for (const { ruta, content } of data.archivos) {
+  for (const { ruta, content, isBinary } of data.archivos) {
     const destFile = path.join(absDir, ruta);
     const dir = path.dirname(destFile);
 
     try {
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(destFile, content, 'utf8');
+      if (isBinary) {
+        fs.writeFileSync(destFile, Buffer.from(content, 'base64'));
+      } else {
+        fs.writeFileSync(destFile, content, 'utf8');
+      }
       escritos++;
     } catch (err) {
       console.warn(chalk.yellow(`  ⚠ No se pudo escribir: ${ruta} — ${err.message}`));

package/lib/commands/sync.js

@@ -178,19 +178,24 @@ module.exports = async function sync(options) {
     try {
       const pullData = await pullProject(uuid);
       const archivos = pullData.archivos || [];
-      const contentMap = new Map(archivos.map(a => [a.ruta, a.content]));
+      const contentMap = new Map(archivos.map(a => [a.ruta, a]));
       sp.stop();
       let downloaded = 0;
       for (const ruta of aDescargar) {
-        const contenido = contentMap.get(ruta);
-        if (contenido === undefined) {
+        const entrada = contentMap.get(ruta);
+        if (!entrada) {
           console.log('  ' + chalk.yellow('⚠') + ' No encontrado en pull: ' + chalk.gray(ruta));
           continue;
         }
+        const contenido = entrada.content;
         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');
+        if (entrada.isBinary) {
+          fs.writeFileSync(destFile, Buffer.from(contenido, 'base64'));
+        } else {
+          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++;
@@ -233,11 +238,16 @@ module.exports = async function sync(options) {
 
   // Reintenta una operación FS hasta maxRetries veces con delay ms entre intentos.
   // Necesario en Windows donde los archivos abiertos en VS Code quedan bloqueados (EPERM/EBUSY).
-  function retryFsOp(opName, ruta, fn, maxRetries, delay) {
+  // retryFsOp: reintenta una operación FS hasta maxRetries veces si el archivo
+  // está bloqueado (EBUSY/EPERM/EACCES). Si se agotan los intentos, llama a
+  // onFail() para que el caller pueda limpiar cualquier guard de estado
+  // (ej. localDeletedAt) y no quede desincronizado.
+  function retryFsOp(opName, ruta, fn, maxRetries, delay, onFail) {
     let attempt = 0;
     function tryOnce() {
       try {
         fn();
+        // Éxito: no se llama onFail
       } catch (err) {
         const locked = err.code === 'EBUSY' || err.code === 'EPERM' || err.code === 'EACCES';
         if (locked && attempt < maxRetries) {
@@ -247,9 +257,11 @@ module.exports = async function sync(options) {
           }
           setTimeout(tryOnce, delay);
         } else if (locked) {
-          console.log('  ' + chalk.red('✖') + ' ' + chalk.white(ruta) + chalk.red(' bloqueado — cierra el archivo en VS Code e intenta de nuevo'));
+          console.log('  ' + chalk.red('✖') + ' ' + chalk.white(ruta) + chalk.red(' bloqueado — cierra el archivo e intenta de nuevo'));
+          if (typeof onFail === 'function') onFail();
         } else {
           console.log('  ' + chalk.red('✖') + ' ' + opName + ' fallido (' + (err.code || err.message) + '): ' + ruta);
+          if (typeof onFail === 'function') onFail();
         }
       }
     }
@@ -269,7 +281,7 @@ module.exports = async function sync(options) {
       retryFsOp('borrar', ruta, () => {
         fs.unlinkSync(destFile);
         console.log('  ' + chalk.red('✖') + ' ' + chalk.white(ruta) + chalk.gray(' ← borrado remoto'));
-      }, 5, 500);
+      }, 5, 500, () => localDeletedAt.delete(ruta));
       return;
     }
     if (eventType === 'file-rename') {
@@ -286,13 +298,23 @@ module.exports = async function sync(options) {
         if (!fs.existsSync(newDir)) fs.mkdirSync(newDir, { recursive: true });
         fs.renameSync(oldFile, newFile);
         console.log('  ' + chalk.yellow('↔') + ' ' + chalk.white(ruta_antigua) + chalk.gray(' → ') + chalk.white(ruta_nueva));
-      }, 5, 500);
+      }, 5, 500, () => {
+        localDeletedAt.delete(ruta_antigua);
+        localUploadedAt.delete(ruta_nueva);
+      });
       return;
     }
     if (eventType !== 'file-update') return;
-    const { ruta, contenido } = data || {};
+    const { ruta, contenido, isBinary, isText } = data || {};
     if (!ruta || contenido === undefined) return;
 
+    // Binary files via SSE: skip (handled by full pull on reconnect)
+    const binary = isBinary === true || isText === false;
+    if (binary) {
+      console.log('  ' + chalk.gray('⊘') + ' ' + chalk.gray(ruta) + chalk.gray(' (binario, ignorado por SSE)'));
+      return;
+    }
+
     // Evitar eco: si acabamos de subir este archivo (< 3s), ignorar
     const uploadedAt = localUploadedAt.get(ruta);
     if (uploadedAt && Date.now() - uploadedAt < 3000) return;

package/lib/commands/tunnel.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const http  = require('http');
+const https = require('https');
+const chalk = require('chalk');
+const ora   = require('ora');
+
+module.exports = async function tunnel(opts) {
+  // Parsear target: puede ser un puerto, una URL, o un hostname
+  const target = opts.target || 'localhost:3000';
+  let targetUrl;
+
+  if (/^\d+$/.test(target)) {
+    targetUrl = `http://localhost:${target}`;
+  } else if (/^https?:\/\//.test(target)) {
+    targetUrl = target;
+  } else {
+    targetUrl = `http://${target}`;
+  }
+
+  // Validar que la URL es parseable
+  let parsedTarget;
+  try {
+    parsedTarget = new URL(targetUrl);
+  } catch {
+    console.error(chalk.red(`URL inválida: ${target}`));
+    process.exit(1);
+  }
+
+  const { getConfig } = require('../utils/config');
+  const cfg = getConfig();
+  const baseUrl = (cfg.baseUrl || 'https://entexto.com').replace(/\/$/, '');
+
+  // Calcular URL del WebSocket
+  const wsUrl = baseUrl.replace(/^http/, 'ws') + '/tunnel';
+
+  const spinner = ora('Conectando al servidor de túneles...').start();
+
+  // Cargar socket.io-client
+  let ioClient;
+  try {
+    ioClient = require('socket.io-client');
+  } catch {
+    spinner.fail('Falta socket.io-client. Ejecuta: npm install socket.io-client');
+    process.exit(1);
+  }
+
+  const socket = ioClient(wsUrl, {
+    transports: ['websocket'],
+    reconnection: true,
+    reconnectionDelay: 2000,
+    reconnectionAttempts: 20,
+  });
+
+  socket.on('connect', () => {
+    socket.emit('open-tunnel', { target: targetUrl }, (res) => {
+      if (!res || !res.ok) {
+        spinner.fail('No se pudo abrir el túnel: ' + JSON.stringify(res));
+        process.exit(1);
+      }
+
+      const publicUrl = `${baseUrl}/t/${res.tunnelId}`;
+      spinner.succeed('Túnel activo');
+      console.log('');
+      console.log(chalk.bold('  🚇 URL pública:'), chalk.cyan.underline(publicUrl));
+      console.log(chalk.gray(`     → ${targetUrl}`));
+      console.log('');
+      console.log(chalk.gray('  Presiona Ctrl+C para cerrar'));
+      console.log('');
+    });
+  });
+
+  // Procesar requests del server
+  socket.on('tunnel-request', (payload, cb) => {
+    const { method, path: reqPath, headers, body, id } = payload;
+
+    // Construir URL completa al target local
+    const localUrl = new URL(reqPath, targetUrl);
+
+    // Preparar headers — reescribir host al target local
+    const fwdHeaders = { ...headers };
+    fwdHeaders.host = parsedTarget.host;
+    delete fwdHeaders['accept-encoding']; // Evitar compresión para simplificar relay
+
+    const proto = parsedTarget.protocol === 'https:' ? https : http;
+
+    const reqOpts = {
+      method: method,
+      hostname: parsedTarget.hostname,
+      port: parsedTarget.port || (parsedTarget.protocol === 'https:' ? 443 : 80),
+      path: localUrl.pathname + localUrl.search,
+      headers: fwdHeaders,
+      rejectUnauthorized: false, // Permitir self-signed certs en localhost
+    };
+
+    const timestamp = new Date().toLocaleTimeString();
+    process.stdout.write(chalk.gray(`  [${timestamp}] `) + chalk.yellow(method.padEnd(6)) + chalk.white(reqPath) + ' ');
+
+    const localReq = proto.request(reqOpts, (localRes) => {
+      const chunks = [];
+      localRes.on('data', (chunk) => chunks.push(chunk));
+      localRes.on('end', () => {
+        const bodyBuf = Buffer.concat(chunks);
+
+        // Color del status
+        const status = localRes.statusCode;
+        const statusColor = status < 300 ? chalk.green(status) : status < 400 ? chalk.cyan(status) : chalk.red(status);
+        console.log(statusColor + chalk.gray(` (${bodyBuf.length}B)`));
+
+        cb({
+          status: status,
+          headers: localRes.headers,
+          body: bodyBuf.toString('base64'),
+        });
+      });
+    });
+
+    localReq.on('error', (err) => {
+      console.log(chalk.red('ERR ') + chalk.gray(err.message));
+      cb({ error: err.message, status: 502 });
+    });
+
+    localReq.setTimeout(25000, () => {
+      localReq.destroy();
+      console.log(chalk.red('TIMEOUT'));
+      cb({ error: 'Local server timeout', status: 504 });
+    });
+
+    if (body) {
+      localReq.write(Buffer.from(body, 'base64'));
+    }
+    localReq.end();
+  });
+
+  socket.on('connect_error', (err) => {
+    if (spinner.isSpinning) {
+      spinner.fail('No se pudo conectar al servidor: ' + err.message);
+    } else {
+      console.error(chalk.red('  Conexión perdida: ' + err.message));
+    }
+  });
+
+  socket.on('disconnect', (reason) => {
+    console.log(chalk.yellow('\n  Desconectado: ' + reason));
+    if (reason === 'io server disconnect') {
+      console.log(chalk.gray('  El servidor cerró la conexión.'));
+      process.exit(0);
+    }
+    console.log(chalk.gray('  Reintentando...'));
+  });
+
+  // Ctrl+C
+  process.on('SIGINT', () => {
+    console.log(chalk.gray('\n  Cerrando túnel...'));
+    socket.disconnect();
+    process.exit(0);
+  });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entexto-cli",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "CLI oficial de Entexto — Deploy y gestión de proyectos desde tu terminal",
   "main": "lib/index.js",
   "bin": {
@@ -29,6 +29,7 @@
     "commander": "^11.0.0",
     "form-data": "^4.0.0",
     "inquirer": "^8.2.6",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "socket.io-client": "^4.8.3"
   }
 }