entexto-cli 2.1.2 → 2.2.1

package/bin/entexto.js

@@ -81,10 +81,17 @@ program
 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' });
+  .option('-l, --link <name>', 'Link personalizado: /t/<name> (requiere login)')
+  .action((target, opts) => {
+    require('../lib/commands/tunnel')({ target: target || '3000', link: opts.link });
   });
 
+// ─── entexto tunnels ─────────────────────────────────────────
+program
+  .command('tunnels')
+  .description('Ver y gestionar tus túneles abiertos')
+  .action(require('../lib/commands/tunnels'));
+
 // ─── entexto create ──────────────────────────────────────────
 program
   .command('create')

package/lib/commands/tunnel.js

@@ -30,6 +30,14 @@ module.exports = async function tunnel(opts) {
   const { getConfig } = require('../utils/config');
   const cfg = getConfig();
   const baseUrl = (cfg.baseUrl || 'https://entexto.com').replace(/\/$/, '');
+  const token = cfg.token || null;
+
+  // Validar link personalizado
+  const customLink = opts.link || null;
+  if (customLink && !token) {
+    console.error(chalk.red('Los links personalizados requieren iniciar sesión. Ejecuta: entexto login'));
+    process.exit(1);
+  }
 
   // Calcular URL del WebSocket
   const wsUrl = baseUrl.replace(/^http/, 'ws') + '/tunnel';
@@ -52,15 +60,18 @@ module.exports = async function tunnel(opts) {
     upgrade: false,
     reconnection: true,
     reconnectionDelay: 1000,
-    reconnectionDelayMax: 3000,
+    reconnectionDelayMax: 5000,
     reconnectionAttempts: Infinity,
     timeout: 20000,
+    // Forzar reconexión incluso cuando el server cierra la conexión
+    forceNew: false,
   });
 
   // Mantener el mismo tunnelId entre reconexiones
   let currentTunnelId = null;
   let publicUrl = null;
   let heartbeatTimer = null;
+  let reconnectWatchdog = null;
 
   function startHeartbeat() {
     clearInterval(heartbeatTimer);
@@ -70,9 +81,24 @@ module.exports = async function tunnel(opts) {
     }, 25000);
   }
 
+  // Watchdog: si tras 15s no estamos conectados ni reconectando, forzar reconexión
+  function startWatchdog() {
+    clearInterval(reconnectWatchdog);
+    reconnectWatchdog = setInterval(() => {
+      if (!socket.connected && !socket.io._reconnecting) {
+        console.log(chalk.yellow('  ⟳ Watchdog: forzando reconexión...'));
+        try { socket.connect(); } catch (_) {}
+      }
+    }, 15000);
+  }
+
   socket.on('connect', () => {
     const meta = { target: targetUrl };
     if (currentTunnelId) meta.reclaimId = currentTunnelId; // intentar recuperar el mismo ID
+    if (customLink) meta.link = customLink;
+    if (token) meta.token = token;
+
+    startWatchdog();
 
     socket.emit('open-tunnel', meta, (res) => {
       if (!res || !res.ok) {
@@ -247,31 +273,55 @@ module.exports = async function tunnel(opts) {
     localReq.end();
   });
 
+  let connectErrorCount = 0;
+
   socket.on('connect_error', (err) => {
+    connectErrorCount++;
     if (spinner.isSpinning) {
       spinner.fail('No se pudo conectar al servidor: ' + err.message);
-    } else {
-      console.error(chalk.red('  Conexión perdida: ' + err.message));
+    }
+    // Solo mostrar cada 10 errores para no llenar la terminal
+    if (connectErrorCount <= 3 || connectErrorCount % 10 === 0) {
+      console.error(chalk.yellow(`  ⟳ Reintentando conexión... (intento ${connectErrorCount})`));
+    }
+    // Si socket.io dejó de intentar, forzar reconexión
+    if (!socket.io._reconnecting) {
+      setTimeout(() => {
+        try { socket.connect(); } catch (_) {}
+      }, 3000);
     }
   });
 
   socket.on('disconnect', (reason) => {
     clearInterval(heartbeatTimer);
-    console.log(chalk.yellow('\n  Desconectado: ' + reason));
+    connectErrorCount = 0;
     if (reason === 'io client disconnect') {
       // Cierre manual (Ctrl+C)
+      clearInterval(reconnectWatchdog);
       process.exit(0);
     }
+    console.log(chalk.yellow('\n  Desconectado: ' + reason));
     if (publicUrl) {
       console.log(chalk.gray('  Reintentando... (la URL se mantendrá: ') + chalk.cyan(publicUrl) + chalk.gray(')'));
     } else {
       console.log(chalk.gray('  Reintentando...'));
     }
+    // Forzar reconexión si socket.io no lo hace automáticamente
+    if (reason === 'transport close' || reason === 'transport error' || reason === 'ping timeout') {
+      setTimeout(() => {
+        if (!socket.connected && !socket.io._reconnecting) {
+          console.log(chalk.yellow('  ⟳ Forzando reconexión...'));
+          try { socket.connect(); } catch (_) {}
+        }
+      }, 2000);
+    }
   });
 
   // Ctrl+C
   process.on('SIGINT', () => {
     console.log(chalk.gray('\n  Cerrando túnel...'));
+    clearInterval(heartbeatTimer);
+    clearInterval(reconnectWatchdog);
     socket.disconnect();
     process.exit(0);
   });

package/lib/commands/tunnels.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const chalk = require('chalk');
+const ora   = require('ora');
+
+module.exports = async function tunnels() {
+  const { getConfig } = require('../utils/config');
+  const cfg = getConfig();
+  const token = cfg.token;
+
+  if (!token) {
+    console.error(chalk.red('Debes iniciar sesión para ver tus túneles. Ejecuta: entexto login'));
+    process.exit(1);
+  }
+
+  const baseUrl = (cfg.baseUrl || 'https://entexto.com').replace(/\/$/, '');
+  const wsUrl = baseUrl.replace(/^http/, 'ws') + '/tunnel';
+
+  const spinner = ora('Consultando túneles abiertos...').start();
+
+  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'],
+    upgrade: false,
+    reconnection: false,
+    timeout: 10000,
+  });
+
+  socket.on('connect', () => {
+    socket.emit('list-tunnels', { token }, (res) => {
+      if (!res || !res.ok) {
+        spinner.fail('Error: ' + (res?.error || 'sin respuesta'));
+        socket.disconnect();
+        process.exit(1);
+      }
+
+      const list = res.tunnels || [];
+      spinner.stop();
+
+      if (list.length === 0) {
+        console.log(chalk.yellow('\n  No tienes túneles abiertos.\n'));
+        socket.disconnect();
+        process.exit(0);
+      }
+
+      console.log(chalk.bold(`\n  🚇 Tus túneles abiertos (${list.length}):\n`));
+      list.forEach((t, i) => {
+        const status = t.connected
+          ? chalk.green('● conectado')
+          : chalk.yellow('○ reconectando');
+        const url = chalk.cyan.underline(`${baseUrl}/t/${t.id}`);
+        console.log(`  ${i + 1}. ${url}`);
+        console.log(`     → ${t.target}  ${status}${t.queued ? chalk.gray(` (${t.queued} en cola)`) : ''}`);
+      });
+      console.log('');
+
+      // Preguntar si quiere cerrar alguno
+      askClose(socket, token, list, baseUrl);
+    });
+  });
+
+  socket.on('connect_error', (err) => {
+    spinner.fail('No se pudo conectar: ' + err.message);
+    process.exit(1);
+  });
+};
+
+async function askClose(socket, token, list, baseUrl) {
+  let inquirer;
+  try {
+    inquirer = require('inquirer');
+  } catch {
+    socket.disconnect();
+    process.exit(0);
+  }
+
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: '¿Qué deseas hacer?',
+    choices: [
+      ...list.map((t, i) => ({
+        name: `Cerrar /t/${t.id} (→ ${t.target})`,
+        value: t.id,
+      })),
+      { name: 'Salir', value: null },
+    ],
+  }]);
+
+  if (!action) {
+    socket.disconnect();
+    process.exit(0);
+  }
+
+  const chalk = require('chalk');
+  const spinner = require('ora')('Cerrando túnel...').start();
+
+  socket.emit('close-tunnel', { token, tunnelId: action }, (res) => {
+    if (res?.ok) {
+      spinner.succeed(`Túnel /t/${action} cerrado`);
+    } else {
+      spinner.fail('Error: ' + (res?.error || 'sin respuesta'));
+    }
+    socket.disconnect();
+    process.exit(0);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entexto-cli",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "description": "CLI oficial de Entexto — Crea, deploya y gestiona proyectos, dominios, APIs y Live SDK desde tu terminal",
   "main": "lib/index.js",
   "bin": {