entexto-cli 1.4.4 → 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/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.4",
+  "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"
   }
 }