@pdc-test/chat-io 1.0.0 → 1.0.2

package/bin/cli.js

@@ -25,8 +25,10 @@ const rl = readline.createInterface({
 let isTyping = false;
 let typingTimeout = null;
 let typingUsers = new Set();
+let userTypingTimers = {};
 let typingFrames = ['.', '..', '...'];
 let tIdx = 0;
+let isMultilinePrompt = false;
 
 // Escuchador de teclado constante (Raw Mode Mágico)
 process.stdin.on('keypress', (str, key) => {
@@ -42,26 +44,31 @@ process.stdin.on('keypress', (str, key) => {
        clearTimeout(typingTimeout);
        typingTimeout = setTimeout(() => {
            isTyping = false;
-       }, 2000);
+           if (ws.readyState === WebSocket.OPEN) ws.send("/typ_stop");
+       }, 1500);
     }
 });
 
-// Renderizado de "Escribiendo..." Dinámico en la Barra Inferior
+// Renderizado de "Escribiendo..." en la parte SUPERIOR (En el Prompt)
 setInterval(() => {
     if (typingUsers.size > 0) {
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        
         const users = Array.from(typingUsers).join(", ");
         const suffix = users.includes(",") ? "están escribiendo" : "está escribiendo";
         
-        // Escribe el texto Gris y luego vuelve al inicio en 0 milisegundos para no interrumpir
-        process.stdout.write(`\x1b[90m${users} ${suffix} ${typingFrames[tIdx]}\x1b[0m`);
+        rl.setPrompt(`\x1b[90m[${users} ${suffix} ${typingFrames[tIdx]}]\x1b[0m\n> `);
         tIdx = (tIdx + 1) % typingFrames.length;
-        
-        // Restaurar silenciosamente lo que el usuario estaba redactando
-        readline.cursorTo(process.stdout, 0);
-        process.stdout.write(`> ${rl.line}`);
+        rl.prompt(true);
+        isMultilinePrompt = true;
+    } else {
+        if (isMultilinePrompt) {
+            rl.setPrompt('> ');
+            // Borrar el fantasma superior que dejó el prompt multilinea
+            readline.moveCursor(process.stdout, 0, -1);
+            readline.clearLine(process.stdout, 0);
+            readline.moveCursor(process.stdout, 0, 1);
+            rl.prompt(true);
+            isMultilinePrompt = false;
+        }
     }
 }, 400);
 
@@ -79,27 +86,48 @@ ws.on('message', (data) => {
    if (msg.startsWith("/typ_event ")) {
        const u = msg.replace("/typ_event ", "").trim();
        typingUsers.add(u);
-       setTimeout(() => typingUsers.delete(u), 3000); // 3seg de cooldown maximo
+       clearTimeout(userTypingTimers[u]);
+       userTypingTimers[u] = setTimeout(() => typingUsers.delete(u), 3500); 
        return; 
    }
    
-   // Si recibimos texto normal, limpiamos indicadores para que no estorben
+   if (msg.startsWith("/typ_stop_event ")) {
+       const u = msg.replace("/typ_stop_event ", "").trim();
+       typingUsers.delete(u);
+       clearTimeout(userTypingTimers[u]);
+       return;
+   }
+   
+   // Si recibimos texto normal, limpiamos todas las señales tácticas
    typingUsers.clear();
 
-   // Purgamos la línea completa en la consola antes de dibujar la obra de Arte/Chat
+   // Purgamos toda visualización flotante o entrada corrupta antes de dibujar texto nuevo
+   if (isMultilinePrompt) {
+       readline.moveCursor(process.stdout, 0, -1);
+       readline.clearLine(process.stdout, 0);
+       readline.moveCursor(process.stdout, 0, 1);
+       isMultilinePrompt = false;
+   }
    readline.clearLine(process.stdout, 0);
    readline.cursorTo(process.stdout, 0);
    
-   console.log(msg); // Imprimimos la maravilla de Colores que envió Railway
-   rl.prompt(true);  // Forzamos al cursor a volver al lugar de escritura limpio
+   console.log(msg);
+   rl.setPrompt('> ');
+   rl.prompt(true);  
 });
 
 // Cuando le damos ENTER
 rl.on('line', (input) => {
+   // Borramos la línea que acabas de teclear para que no se duplique 
+   // con el mensaje que el servidor nos devolverá en azul
+   readline.moveCursor(process.stdout, 0, -1);
+   readline.clearLine(process.stdout, 0);
+   
    const line = input.trim();
    if (line) {
        ws.send(line);
-       isTyping = false; // Matamos flag al presionar intro
+       isTyping = false;
+       ws.send("/typ_stop");
    }
    rl.prompt(true);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdc-test/chat-io",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "./src/index.js",
   "bin": {
     "chat-io": "bin/cli.js"
@@ -9,6 +9,7 @@
     "start": "node src/server/index.js"
   },
   "dependencies": {
+    "@pdc-test/chat-io": "^1.0.2",
     "crypto-js": "^4.2.0",
     "ws": "^8.0.0"
   }

package/src/server/index.js

@@ -62,7 +62,7 @@ wss.on("connection", (server) => {
 
       // REGISTRO ÚNICO
       if (!socketData.name) {
-         if (!text) return;
+         if (!text || text === "/typ") return;
          const desiredName = text.replace("/name ", "").trim();
          if (targetExists(desiredName)) {
             server.send("❌ Nombre en uso. Escribe otro distinto:");
@@ -88,14 +88,14 @@ wss.on("connection", (server) => {
       const myEmoji = socketData.emoji;
 
       if (text === "/help") {
-         server.send(`\n──────────── 💡 COMANDOS MÁGICOS ────────────
+         server.send(`\n──────────── 💡 COMANDOS ────────────
  👥 /users           → Ver conectados
- 🪙 /flip            → Lanzar moneda (Animado)
+ 🪙 /flip            → Lanzar moneda
  🎮 /rps <usr> <j>   → Piedra-Papel-Tijera
  🌟 /blink <msj>     → Mensaje parpadeante
  🔒 /w <usr> <msj>   → Mensaje privado
- 🏪 /tiendita        → Animación ASCII Sorpresa
- ℹ️  /help           → Esta ayuda
+ 🏪 /tiendita        → Invitación a la Tiendita
+ ℹ️ /help            → Esta ayuda
 ─────────────────────────────────────────────\n`);
          return;
       }
@@ -107,51 +107,73 @@ wss.on("connection", (server) => {
          return;
       }
 
-      // Indicador de "Escribiendo" Exclusivo para Smart Clients
-      if (text === "/typ") {
+      // Indicadores de "Escribiendo" Exclusivos para Smart Clients
+      if (text === "/typ" || text === "/typ_stop") {
          for (const [s, data] of sessions.entries()) {
             if (s !== server && s.readyState === WebSocket.OPEN && data.smart) {
-               try { s.send(`/typ_event ${myEmoji} ${myName}`); } catch(e) {}
+               try { s.send(`${text}_event ${myEmoji} ${myName}`); } catch (e) { }
             }
          }
-         return; // No lo procesamos más, es invisible
+         return; // Invisible, solo de control
       }
 
-      // Mensajes Privados
+      // Restablecer chat a global
+      if (text === "/all") {
+         socketData.privateTarget = null;
+         server.send(`\n[Sistema] 🟢 \x1b[32mModo Chat Público Restaurado.\x1b[0m Ahora todos leerán tus mensajes.\n`);
+         return;
+      }
+
+      // Mensajes Privados Estáticos y Dinámicos
       if (text.startsWith("/w ")) {
          const parts = text.split(" ");
-         if (parts.length < 3) { server.send("❌ Error. Uso: /w <usuario> <mensaje secreto>"); return; }
          const targetUser = parts[1];
-         const secretMsg = parts.slice(2).join(" ");
 
          if (!targetExists(targetUser)) { server.send("❌ Usuario no encontrado."); return; }
          if (targetUser === myName) { server.send("❌ ¿Hablando contigo mismo?"); return; }
 
-         server.send(`\n[${getTime()}] 🔒 [Secret → ${targetUser}]: \x1b[35m${secretMsg}\x1b[0m`);
-         sendToTarget(targetUser, `\n[${getTime()}] 🔒 [${myEmoji} Secreto de ${myName}]: \x1b[35m${secretMsg}\x1b[0m\n`);
+         // Si solo envían /w Mario (Se quedan en modo privado)
+         if (parts.length === 2) {
+            socketData.privateTarget = targetUser;
+            server.send(`\n[Sistema] 🔒 \x1b[35mModo Susurro activado con ${targetUser}.\x1b[0m Todo lo que escribas solo lo leerá él. Escribe /all para salir.\n`);
+            return;
+         }
+
+         // Si lo envían todo de golpe /w Mario hola
+         const secretMsg = parts.slice(2).join(" ");
+         server.send(`\n[${getTime()}] 🔒 [Private → ${targetUser}]: \x1b[35m${secretMsg}\x1b[0m`);
+         sendToTarget(targetUser, `\n[${getTime()}] 🔒 [${myEmoji} Secreto de ${myName}]: \x1b[35m${secretMsg}\x1b[0m`);
          return;
       }
 
-      // Moneda Animada de 3 Segundos
+      // Moneda Animada ASCII Rotativa in-place
       if (text === "/flip") {
-         server.send(`\n[${getTime()}] 🪙  Alistando la moneda...`);
-         broadcast(`\n[${getTime()}] 🪙  [${myEmoji} ${myName}] prepara un lanzamiento de moneda...\n`, server);
+         const prep = `\n[${getTime()}] 🪙  [${myEmoji} ${myName}] lanza una moneda al aire...\n`;
+         server.send(prep);
+         broadcast(prep, server);
+
+         const asciiCoins = [
+            "\x1b[33m ( o ) \x1b[0m",
+            "\x1b[33m ( | ) \x1b[0m",
+            "\x1b[38;5;220m ( 0 ) \x1b[0m",
+            "\x1b[33m ( | ) \x1b[0m"
+         ];
 
-         let count = 3;
+         let i = 0;
          const timer = setInterval(() => {
-            if (count > 0) {
-               const countMsg = `   ⏳ Girando en el aire... ${count}s`;
-               server.send(countMsg);
-               broadcast(countMsg, server);
-               count--;
+            if (i < 15) { // 3 segundos a 200ms
+               const frame = `\r\x1b[A\x1b[K       ${asciiCoins[i % asciiCoins.length]} zumbando...`;
+               server.send(frame);
+               broadcast(frame, server);
+               i++;
             } else {
                clearInterval(timer);
                const result = Math.random() < 0.5 ? "CARA" : "ESCUDO";
-               const renderMsg = `\n[${getTime()}] 🎯 ¡CAYÓ LA MONEDA de ${myName}! Es -> \x1b[1m\x1b[33m${result}\x1b[0m\n`;
+               const renderMsg = `\r\x1b[A\x1b[K[${getTime()}] 🎯 ¡CAYÓ LA MONEDA de ${myName}! Es -> \x1b[1m\x1b[33m${result}\x1b[0m\n`;
                server.send(renderMsg);
                broadcast(renderMsg, server);
             }
-         }, 1000);
+         }, 200);
          return;
       }
 
@@ -161,12 +183,12 @@ wss.on("connection", (server) => {
          server.send(introMsg);
          broadcast(introMsg, server);
 
-         const asciiArt = ` _____ _                _ _ _           _____ _               _ _ _  
-|_   _(_)              | (_) |         |_   _(_)             | | | | 
-  | |  _  ___ _ __   __| |_| |_ __ _     | |  _ _ __ ___   ___| | | | 
-  | | | |/ _ \\ '_ \\ / _\` | | __/ _\` |    | | | | '_ \` _ \\ / _ \\ | | | 
-  | | | |  __/ | | | (_| | | || (_| |    | | | | | | | | |  __/_|_|_| 
-  \\_/ |_|\\___|_| |_|\\__,_|_|\\__\\__,_|    \\_/ |_|_| |_| |_|\\___(_|_|_)`;
+         const asciiArt = `_____ _                _ _ _        _ _ _ 
+ |_   _(_) ___ _ __   __| (_) |_ __ _| | | |
+   | | | |/ _ \ '_ \ / _  | | __/ _  | | | |
+   | | | |  __/ | | | (_  | | || (_  |_|_|_|
+   |_| |_|\___|_| |_|\__,_|_|\__\__,_(_|_|_)
+  `;
 
          const baseColors = [
             "\x1b[31m", // Rojo
@@ -238,10 +260,31 @@ wss.on("connection", (server) => {
          return;
       }
 
-      // Chat
-      const msg = `\n[${getTime()}] 🌍 [${myEmoji} ${myName}]: ${text}`;
-      server.send(msg);
-      broadcast(msg, server);
+      // Analizar Menciones con @
+      const formattedText = text.replace(/@([a-zA-Z0-9_]+)/g, "\x1b[1m\x1b[33m@$1\x1b[0m");
+
+      // Notificar con Ring! a los mencionados (si existen)
+      const mentions = [...text.matchAll(/@([a-zA-Z0-9_]+)/g)].map(m => m[1]);
+      for (const m of mentions) {
+         if (targetExists(m) && m !== myName && m !== socketData.privateTarget) {
+            sendToTarget(m, "\x07"); // ASCII Bell character
+         }
+      }
+
+      // Chat Normal o Modo Susurro Fijo
+      if (socketData.privateTarget) {
+         const target = socketData.privateTarget;
+         if (!targetExists(target)) {
+            server.send(`❌ ${target} ya no está conectado. Escribe /all para salir del modo privado.`);
+            return;
+         }
+         server.send(`\n[${getTime()}] 🔒 [Private → ${target}]: \x1b[35m${formattedText}\x1b[0m`);
+         sendToTarget(target, `\n[${getTime()}] 🔒 [${myEmoji} Secreto de ${myName}]: \x1b[35m${formattedText}\x1b[0m`);
+      } else {
+         const msg = `\n[${getTime()}] 🌍 [${myEmoji} ${myName}]: ${formattedText}`;
+         server.send(msg);
+         broadcast(msg, server);
+      }
    });
 
    server.on("close", () => {