entexto-cli 2.0.1 → 2.1.1

package/lib/commands/tunnel.js

@@ -102,7 +102,7 @@ module.exports = async function tunnel(opts) {
 
   // Procesar requests del server
   socket.on('tunnel-request', (payload, cb) => {
-    const { method, path: reqPath, headers, body, id } = payload;
+    const { method, path: reqPath, headers, body, id, streamId } = payload;
 
     // Construir URL completa al target local
     const localUrl = new URL(reqPath, targetUrl);
@@ -126,55 +126,118 @@ module.exports = async function tunnel(opts) {
     const timestamp = new Date().toLocaleTimeString();
     process.stdout.write(chalk.gray(`  [${timestamp}] `) + chalk.yellow(method.padEnd(6)) + chalk.white(reqPath) + ' ');
 
+    // Detectar si el server soporta streaming (envía streamId)
+    const useStreaming = !!streamId;
+
     const localReq = proto.request(reqOpts, (localRes) => {
-      const chunks = [];
-      localRes.on('data', (chunk) => chunks.push(chunk));
-      localRes.on('end', () => {
-        let bodyBuf = Buffer.concat(chunks);
-
-        // Reescribir el host local → URL pública del túnel en respuestas de texto.
-        // Esto cubre el caso de Elementor/webpack cuyo __webpack_public_path__
-        // queda hardcodeado como cmy-rent-car.local (o el dominio local) en el JS.
-        const ct = (localRes.headers['content-type'] || '').toLowerCase();
-        const isText = /\b(javascript|css|html|json|xml|svg|text\/)/i.test(ct);
-        if (isText && publicUrl && bodyBuf.length > 0) {
-          const localOrigins = [
-            parsedTarget.origin,                          // http://cmy-rent-car.local
-            parsedTarget.origin.replace(/^http:/, 'https:'), // https://cmy-rent-car.local
-            parsedTarget.host,                            // cmy-rent-car.local
-          ];
-          let text = bodyBuf.toString('utf8');
-          for (const origin of localOrigins) {
-            // Reemplazar como origen completo primero, luego como host suelto
-            text = text.split(origin).join(publicUrl);
-          }
-          bodyBuf = Buffer.from(text, 'utf8');
-          // Corregir Content-Length si venía fijo
-          localRes.headers['content-length'] = String(bodyBuf.length);
-        }
+      const ct = (localRes.headers['content-type'] || '').toLowerCase();
+      const isText = /\b(javascript|css|html|json|xml|svg|text\/)/i.test(ct);
+      const status = localRes.statusCode;
 
-        // Color del status
-        const status = localRes.statusCode;
+      if (useStreaming) {
+        // ── Modo streaming: enviar head + chunks + end ──
         const statusColor = status < 300 ? chalk.green(status) : status < 400 ? chalk.cyan(status) : chalk.red(status);
-        console.log(statusColor + chalk.gray(` (${bodyBuf.length}B)`));
+        process.stdout.write(statusColor + ' ');
+
+        // SSE / event-stream y chunked (transfer-encoding) siempre van streaming real
+        const isSSE = /event-stream/i.test(ct);
+        const isChunked = /chunked/i.test(localRes.headers['transfer-encoding'] || '');
+        // Para responses de texto pequeños, acumular para poder reescribir URLs
+        // Para binarios, SSE, chunked o responses grandes, hacer streaming directo
+        const isSmallText = isText && !isSSE && !isChunked &&
+          localRes.headers['content-length'] && parseInt(localRes.headers['content-length']) < 5 * 1024 * 1024;
+
+        if (isSmallText) {
+          // Acumular texto para URL rewriting, luego enviar en un solo stream
+          const chunks = [];
+          localRes.on('data', (chunk) => chunks.push(chunk));
+          localRes.on('end', () => {
+            let bodyBuf = Buffer.concat(chunks);
+            if (publicUrl && bodyBuf.length > 0) {
+              const localOrigins = [
+                parsedTarget.origin,
+                parsedTarget.origin.replace(/^http:/, 'https:'),
+                parsedTarget.host,
+              ];
+              let text = bodyBuf.toString('utf8');
+              for (const origin of localOrigins) {
+                text = text.split(origin).join(publicUrl);
+              }
+              bodyBuf = Buffer.from(text, 'utf8');
+            }
+            const h = { ...localRes.headers };
+            h['content-length'] = String(bodyBuf.length);
+            socket.emit('tunnel-stream-head', { streamId, status, headers: h });
+            socket.emit('tunnel-stream-chunk', { streamId, data: bodyBuf.toString('base64') });
+            socket.emit('tunnel-stream-end', { streamId });
+            console.log(chalk.gray(`(${bodyBuf.length}B)`));
+          });
+        } else {
+          // Streaming real: enviar chunks conforme llegan
+          const h = { ...localRes.headers };
+          delete h['content-length']; // no sabemos el tamaño final
+          socket.emit('tunnel-stream-head', { streamId, status, headers: h });
+
+          let totalBytes = 0;
+          localRes.on('data', (chunk) => {
+            totalBytes += chunk.length;
+            socket.emit('tunnel-stream-chunk', { streamId, data: chunk.toString('base64') });
+          });
+          localRes.on('end', () => {
+            socket.emit('tunnel-stream-end', { streamId });
+            console.log(chalk.gray(`(${totalBytes}B streamed)`));
+          });
+        }
+      } else {
+        // ── Modo clásico: acumular todo y callback ──
+        const chunks = [];
+        localRes.on('data', (chunk) => chunks.push(chunk));
+        localRes.on('end', () => {
+          let bodyBuf = Buffer.concat(chunks);
+
+          if (isText && publicUrl && bodyBuf.length > 0) {
+            const localOrigins = [
+              parsedTarget.origin,
+              parsedTarget.origin.replace(/^http:/, 'https:'),
+              parsedTarget.host,
+            ];
+            let text = bodyBuf.toString('utf8');
+            for (const origin of localOrigins) {
+              text = text.split(origin).join(publicUrl);
+            }
+            bodyBuf = Buffer.from(text, 'utf8');
+            localRes.headers['content-length'] = String(bodyBuf.length);
+          }
 
-        cb({
-          status: status,
-          headers: localRes.headers,
-          body: bodyBuf.toString('base64'),
+          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 });
+      if (useStreaming) {
+        socket.emit('tunnel-stream-error', { streamId, error: err.message, status: 502 });
+      } else {
+        cb({ error: err.message, status: 502 });
+      }
     });
 
-    localReq.setTimeout(25000, () => {
+    localReq.setTimeout(useStreaming ? 120000 : 25000, () => {
       localReq.destroy();
       console.log(chalk.red('TIMEOUT'));
-      cb({ error: 'Local server timeout', status: 504 });
+      if (useStreaming) {
+        socket.emit('tunnel-stream-error', { streamId, error: 'Local server timeout', status: 504 });
+      } else {
+        cb({ error: 'Local server timeout', status: 504 });
+      }
     });
 
     if (body) {

package/package.json

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