@pdc-test/chat-io 1.0.2 → 1.1.1

package/bin/cli.js

@@ -1,140 +1,302 @@
 #!/usr/bin/env node
-
 const WebSocket = require('ws');
 const readline = require('readline');
 
-// URL del Servidor Oficial de Railway
+// ============================================
+// CLIENTE MODULAR RÁPIDO (Carga NATIVA JSON)
+// ============================================
 const SERVER_URL = 'wss://chat-io-production.up.railway.app/';
-
 const ws = new WebSocket(SERVER_URL);
-const commands = ['/users', '/flip', '/rps', '/tiendita', '/help', '/w', '/blink'];
 
-// Autocompletado del Teclado (TAB)
+let myName = null;
+let currentIsTyping = false;
+let typingTimeout = null;
+
+// Control de UI Local
+let activeTypers = [];
+let tIdx = 0;
+const typingFrames = ['.', '..', '...'];
+let isMultilinePrompt = false;
+
+// Helpers VISUALES
+function getTime() {
+   const d = new Date();
+   const hs = String(d.getHours()).padStart(2, '0');
+   const ms = String(d.getMinutes()).padStart(2, '0');
+   return `\x1b[90m${hs}:${ms}\x1b[0m`;
+}
+
+function clearTopLine() {
+   readline.moveCursor(process.stdout, 0, -1);
+   readline.clearLine(process.stdout, 0);
+   readline.moveCursor(process.stdout, 0, 1);
+}
+
+// Interfaz del Teclado Local
+const commands = ['/users', '/flip', '/rps', '/tiendita', '/help', '/w', '/all', '/blink', '/exit', '/clear'];
+let knownUsersList = [];
+
 function completer(line) {
-  const hits = commands.filter((c) => c.startsWith(line));
+  const tokens = line.split(" ");
+  let completions = [];
+
+  if (line.startsWith("@")) {
+      completions = knownUsersList.map(u => "@" + u);
+  } else if (line.toLowerCase().startsWith("/w ") || line.toLowerCase().startsWith("/chat ")) {
+      completions = knownUsersList.map(u => tokens[0] + " " + u + " ");
+  } else if (line.toLowerCase().startsWith("/rps ")) {
+      if (tokens.length === 2) {
+          completions = knownUsersList.map(u => "/rps " + u + " ");
+      } else if (tokens.length === 3) {
+          const rpsOpts = ["piedra", "papel", "tijera"];
+          completions = rpsOpts.map(o => `/rps ${tokens[1]} ${o}`);
+      }
+  } else if (line.includes("@")) {
+      const lastAt = line.lastIndexOf("@");
+      const prefix = line.substring(0, lastAt);
+      completions = knownUsersList.map(u => prefix + "@" + u + " ");
+  } else {
+      completions = [...commands, ...knownUsersList.map(u => "/w " + u)];
+  }
+
+  const hits = completions.filter((c) => c.toLowerCase().startsWith(line.toLowerCase()));
   return [hits.length ? hits : [], line];
 }
 
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  completer,
-  prompt: '\r> ' // Prefix visual del input
-});
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout, completer, prompt: '> ', removeHistoryDuplicates: true });
 
-let isTyping = false;
-let typingTimeout = null;
-let typingUsers = new Set();
-let userTypingTimers = {};
-let typingFrames = ['.', '..', '...'];
-let tIdx = 0;
-let isMultilinePrompt = false;
+rl.on('SIGINT', () => {
+    printMessage("\x1b[33mSaliendo...\x1b[0m");
+    ws.close();
+    process.exit(0);
+});
 
-// Escuchador de teclado constante (Raw Mode Mágico)
 process.stdin.on('keypress', (str, key) => {
-    // Detectamos cualquier tecla que no presione Enter
-    if (key && key.name !== 'return' && key.name !== 'enter') {
-       if (!isTyping) {
-           isTyping = true;
-           if (ws.readyState === WebSocket.OPEN) {
-               ws.send("/typ"); // Ping silencioso
-           }
+    if (key && key.name !== 'return' && key.name !== 'enter' && key.name !== 'c' && myName) {
+       if (!currentIsTyping && ws.readyState === WebSocket.OPEN) {
+           currentIsTyping = true;
+           ws.send(JSON.stringify({ type: "typing" }));
        }
-       // Reiniciar el timeout si el usuario sigue tecleando
        clearTimeout(typingTimeout);
        typingTimeout = setTimeout(() => {
-           isTyping = false;
-           if (ws.readyState === WebSocket.OPEN) ws.send("/typ_stop");
+           currentIsTyping = false;
+           if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: "typing_stop" }));
        }, 1500);
     }
 });
 
-// Renderizado de "Escribiendo..." en la parte SUPERIOR (En el Prompt)
+// Actualizador de UI Typing Background -> Puesto a 300ms, Cero Network Latency porque es local
 setInterval(() => {
-    if (typingUsers.size > 0) {
-        const users = Array.from(typingUsers).join(", ");
-        const suffix = users.includes(",") ? "están escribiendo" : "está escribiendo";
-        
-        rl.setPrompt(`\x1b[90m[${users} ${suffix} ${typingFrames[tIdx]}]\x1b[0m\n> `);
+    if (activeTypers.length > 0) {
+        const usersInfo = activeTypers.join(", ") + (activeTypers.length > 1 ? " están" : " está") + " escribiendo";
+        rl.setPrompt(`\x1b[90m[${usersInfo} ${typingFrames[tIdx]}]\x1b[0m\n> `);
         tIdx = (tIdx + 1) % typingFrames.length;
         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);
+            clearTopLine();
             rl.prompt(true);
             isMultilinePrompt = false;
         }
     }
-}, 400);
+}, 300);
 
-// Flujo WebSocket
+// Flujo Principal Socket
 ws.on('open', () => {
-   // Nos identificamos en secreto como un Cliente VIP Inteligente
-   ws.send("/iam_smart");
-   // No necesitamos imprimir conexión local, el servidor de Railway enviará el cohete.
+   console.log("\x1b[36m====================================\x1b[0m");
+   console.log("   🚀 BIENVENIDO AL JSON-CHAT-CLI 🚀");
+   console.log("\x1b[36m====================================\x1b[0m");
+   console.log("🤖 Sistema: Escribe tu nombre y presiona Enter para comenzar:");
+   rl.prompt();
 });
 
-ws.on('message', (data) => {
-   const msg = data.toString();
-   
-   // Si el servidor nos avisa secretamente que alguien tipeó:
-   if (msg.startsWith("/typ_event ")) {
-       const u = msg.replace("/typ_event ", "").trim();
-       typingUsers.add(u);
-       clearTimeout(userTypingTimers[u]);
-       userTypingTimers[u] = setTimeout(() => typingUsers.delete(u), 3500); 
-       return; 
-   }
-   
-   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 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;
-   }
+// Encargado de Pintar Todo en la Terminal limpiamente
+function printMessage(msgStr) {
+   if (isMultilinePrompt) { clearTopLine(); isMultilinePrompt = false; }
    readline.clearLine(process.stdout, 0);
    readline.cursorTo(process.stdout, 0);
-   
-   console.log(msg);
+   console.log(msgStr);
    rl.setPrompt('> ');
-   rl.prompt(true);  
+   rl.prompt(true);
+}
+
+// Receptor de la Nube (Solo procesa comandos JSON Puros, nada de basura String)
+ws.on('message', (data) => {
+   let res;
+   try { res = JSON.parse(data.toString()); } catch(e) { return; }
+
+   switch (res.type) {
+      case "error": printMessage(`❌ \x1b[31m${res.msg}\x1b[0m`); break;
+      
+      case "system": printMessage(`\n[${getTime()}] ${res.msg}`); break;
+      
+      case "registered": 
+          myName = res.name;
+          printMessage(`\n✅ ¡Listo ${res.name}! Estás con el avatar ${res.emoji}. Escribe /help para los comandos nativos.`);
+          break;
+          
+      case "typing_event":
+          // El servidor nos entrega el arreglo COMPLETO y VIVO de quién tipea
+          // Tu computadora solo limpia e ignora inteligentemente si está tu mismo nombre de pila
+          activeTypers = res.users.filter(u => u !== myName); 
+          break;
+          
+      case "users_update":
+          if (res.plain) knownUsersList = res.plain.filter(u => u !== myName);
+          break;
+          
+      case "ding":
+          process.stdout.write("\x07"); // ASCII Bell físico disparado remotamente
+          break;
+          
+      case "users_list":
+          printMessage(`\n👥 \x1b[36mCONECTADOS AHORA (${res.users.length}):\x1b[0m ` + res.users.join(", ") + "\n");
+          break;
+          
+      case "chat":
+          // Todo el poder de Parsear Regex se procesa en TU PC, ahorrándole billones de cálculos al Server
+          let safeMsg = res.msg.replace(/@([a-zA-Z0-9_]+)/g, "\x1b[1m\x1b[33m@$1\x1b[0m");
+          if (res.isWhisper) {
+             const dir = res.from === myName ? `Private → ${res.to}` : `${res.emoji} Secreto de ${res.from}`;
+             printMessage(`\n[${getTime()}] 🔒 [${dir}]: \x1b[35m${safeMsg}\x1b[0m`);
+          } else {
+             printMessage(`\n[${getTime()}] 🌍 [${res.emoji} ${res.from}]: ${safeMsg}`);
+          }
+          break;
+
+      case "animation":
+          if (res.name === "tiendita") renderTiendita(res.user);
+          else if (res.name === "flip") renderFlip(res.user, res.emoji, res.result);
+          break;
+   }
 });
 
-// Cuando le damos ENTER
+// ANIMACIONES RENDERIZADAS LOCALMENTE CON CPU CLIENT (LATENCIA CERO, NO SUCIA LA RED)
+function renderTiendita(user) {
+    if (isMultilinePrompt) { clearTopLine(); isMultilinePrompt = false; }
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    
+    console.log(`\n[${getTime()}] 🏪 \x1b[1m${user}\x1b[0m convoca a la tiendita...\n`);
+    
+    const asciiArt = `_____ _                _ _ _        _ _ _ \n |_   _(_) ___ _ __   __| (_) |_ __ _| | | |\n   | | | |/ _ \\ '_ \\ / _  | | __/ _  | | | |\n   | | | |  __/ | | | (_  | | || (_  |_|_|_|\n   |_| |_|\\___|_| |_|\\__,_|_|\\__\\__,_(_|_|_)\n  `;
+    const colors = ["\x1b[31m", "\x1b[33m", "\x1b[32m", "\x1b[36m", "\x1b[1m\x1b[35m"];
+    
+    // Dejar huella Base
+    process.stdout.write(`${colors[0]}${asciiArt}\x1b[0m\n`);
+    
+    let frames = 0;
+    const anim = setInterval(() => {
+        frames++;
+        const c = colors[frames % colors.length];
+        // Bucle mágico hiper-veloz usando RAM Local
+        process.stdout.write(`\r\x1b[6A\x1b[0J${c}${asciiArt}\x1b[0m\n`);
+        if (frames > 15) {
+            clearInterval(anim);
+            rl.prompt(true);
+        }
+    }, 150); // Mismo efecto, pero procesado x100 más eficiente
+}
+
+function renderFlip(user, emoji, result) {
+    if (isMultilinePrompt) { clearTopLine(); isMultilinePrompt = false; }
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    console.log(`\n[${getTime()}] 🪙  [${emoji} ${user}] lanza una moneda al aire...`);
+    
+    const asciiCoins = ["\x1b[33m ( o ) \x1b[0m", "\x1b[33m ( | ) \x1b[0m", "\x1b[38;5;220m ( 0 ) \x1b[0m", "\x1b[33m ( | ) \x1b[0m"];
+    let i = 0;
+    
+    process.stdout.write(" \n");
+    const anim = setInterval(() => {
+        process.stdout.write(`\r\x1b[1A\x1b[K     ${asciiCoins[i % 4]} zumbando...\n`);
+        i++;
+        if (i > 15) {
+            clearInterval(anim);
+            process.stdout.write(`\r\x1b[1A\x1b[K[${getTime()}] 🎯 ¡CAYÓ LA MONEDA de ${user}! Es -> \x1b[1m\x1b[33m${result}\x1b[0m\n\n`);
+            rl.prompt(true);
+        }
+    }, 100); 
+}
+
+// Control General del Botón Enter (Distribuidor Estructurado)
 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
+   // Destruimos el "echo" por defecto para no dejar basura arriba del prompt
    readline.moveCursor(process.stdout, 0, -1);
    readline.clearLine(process.stdout, 0);
    
    const line = input.trim();
-   if (line) {
-       ws.send(line);
-       isTyping = false;
-       ws.send("/typ_stop");
+   if (!line) { rl.prompt(true); return; }
+
+   // Flujo Inicial Obligatorio
+   if (!myName) {
+       ws.send(JSON.stringify({ type: "register", name: line }));
+       return;
    }
-   rl.prompt(true);
+
+   // Local Helper Menú
+   if (line.toLowerCase() === "/clear") { console.clear(); rl.setPrompt('> '); rl.prompt(true); return; }
+   if (line.toLowerCase() === "/exit") {
+       printMessage("\x1b[33mSaliendo...\x1b[0m");
+       ws.close();
+       process.exit(0);
+   }
+   if (line.toLowerCase() === "/help") {
+       printMessage(`\n──────────── 💡 COMANDOS NATIVOS ────────────
+ 👥 /users           → Ver conectados remotamente
+ 🪙 /flip            → Lanzar moneda 60FPS
+ 🎮 /rps <usr> <j>   → Piedra-Papel-Tijera
+ 🌟 /blink <msj>     → Envía un texto parpadeante ANSI
+ 🔒 /w <usr> [msj]   → Modo Susurro directo a una persona
+ 🌍 /all             → Volver a la Sala Global Abierta
+ 🏪 /tiendita        → Letrero de Neón de colores acelerado
+ 🧹 /clear           → Limpia historial de consola
+ ❌ /exit            → Salir del chat
+ ℹ️ /help            → Te ayuda desde la memoria Caché
+─────────────────────────────────────────────\n`);
+       return;
+   }
+
+   // Constructor Arquitectónico y Limpio de Comandos a Servidor
+   if (line.startsWith("/")) {
+       const lowerLine = line.toLowerCase();
+       if (lowerLine === "/users" || lowerLine === "/flip" || lowerLine === "/tiendita") {
+           ws.send(JSON.stringify({ type: "command", cmd: lowerLine.substring(1) }));
+       } else if (lowerLine === "/all") {
+           ws.send(JSON.stringify({ type: "command", cmd: "mode_all" }));
+       } else if (lowerLine.startsWith("/w ")) {
+           const p = line.split(" ");
+           if (p.length === 2) {
+               ws.send(JSON.stringify({ type: "command", cmd: "mode_whisper", target: p[1] }));
+           } else if (p.length > 2) {
+               const inlineMsg = p.slice(2).join(" ").trim();
+               if (inlineMsg) {
+                   ws.send(JSON.stringify({ type: "chat", target: p[1], msg: inlineMsg }));
+               } else {
+                   ws.send(JSON.stringify({ type: "command", cmd: "mode_whisper", target: p[1] }));
+               }
+           }
+       } else if (lowerLine.startsWith("/rps ")) {
+           const p = line.split(" ");
+           if (p.length >= 3) ws.send(JSON.stringify({ type: "command", cmd: "rps", target: p[1], choice: p[2].toLowerCase() }));
+       } else if (lowerLine.startsWith("/blink ")) {
+           ws.send(JSON.stringify({ type: "command", cmd: "blink", msg: line.substring(7) }));
+       } else {
+           printMessage(`❌ Comando desconocido. Intenta /help`);
+       }
+   } else {
+       // Mensaje Casual
+       ws.send(JSON.stringify({ type: "chat", msg: line }));
+   }
+   
+   isTyping = false;
+   ws.send(JSON.stringify({ type: "typing_stop" }));
 });
 
+// Salvavidas de Desconexión Rápida
 ws.on('close', () => {
-    readline.clearLine(process.stdout, 0);
-    readline.cursorTo(process.stdout, 0);
-    console.log("\n\x1b[31m[!] Se ha perdido la conexión con la Nube.\x1b[0m");
+    printMessage("\x1b[31m[!] Oh no... Acabas de perder la conexión con la Matriz (Nube principal caída).\x1b[0m");
     process.exit(0);
 });

package/package.json

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

package/src/chat/index.js

@@ -24,19 +24,39 @@ function startChat(onExit, mode = 'udp') {
   let animationInterval;
 
   function completer(line) {
-    const completions = [
-      ...Array.from(knownUsers).map(u => `/chat ${u}`),
-      ...Array.from(knownUsers).map(u => `/rps ${u} `),
-      "/all", "/clear", "/help", "/users", "/exit", "/flip", "/blink ", "/chat ", "/rps "
-    ];
-    const hits = completions.filter((c) => c.startsWith(line));
+    const tokens = line.split(" ");
+    let completions = [];
+    const cmds = ["/all", "/clear", "/help", "/users", "/exit", "/flip", "/blink", "/chat", "/rps", "/w"];
+    const users = Array.from(knownUsers);
+
+    if (line.startsWith("@")) {
+        completions = users.map(u => "@" + u);
+    } else if (line.toLowerCase().startsWith("/w ") || line.toLowerCase().startsWith("/chat ")) {
+        completions = users.map(u => tokens[0] + " " + u + " ");
+    } else if (line.toLowerCase().startsWith("/rps ")) {
+        if (tokens.length === 2) {
+            completions = users.map(u => "/rps " + u + " ");
+        } else if (tokens.length === 3) {
+            const rpsOpts = ["piedra", "papel", "tijera"];
+            completions = rpsOpts.map(o => `/rps ${tokens[1]} ${o}`);
+        }
+    } else if (line.includes("@")) {
+        const lastAt = line.lastIndexOf("@");
+        const prefix = line.substring(0, lastAt);
+        completions = users.map(u => prefix + "@" + u + " ");
+    } else {
+        completions = [...cmds, ...users.map(u => "/w " + u)];
+    }
+
+    const hits = completions.filter((c) => c.toLowerCase().startsWith(line.toLowerCase()));
     return [hits.length ? hits : completions, line];
   }
 
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    completer: completer
+    completer: completer,
+    removeHistoryDuplicates: true
   });
 
   animationInterval = setInterval(() => {
@@ -114,7 +134,10 @@ function startChat(onExit, mode = 'udp') {
       return;
     }
 
-    if (data.type === "rps_challenge" && data.to === username) {
+    // Resolving case insensitivity for target
+    const isTargetMe = data.to && data.to.toLowerCase() === username.toLowerCase();
+
+    if (data.type === "rps_challenge" && isTargetMe) {
       incomingRPS.add(data.from);
       readline.clearLine(process.stdout, 0);
       readline.cursorTo(process.stdout, 0);
@@ -124,11 +147,13 @@ function startChat(onExit, mode = 'udp') {
       return;
     }
 
-    if (data.type === "rps_response" && data.to === username) {
-      if (pendingRPS.has(data.from)) {
-        const miJugada = pendingRPS.get(data.from).miJugada;
+    if (data.type === "rps_response" && isTargetMe) {
+      // Allow case insensitive checking for pendingRPS
+      const pendingKey = Array.from(pendingRPS.keys()).find(k => k.toLowerCase() === data.from.toLowerCase());
+      if (pendingKey) {
+        const miJugada = pendingRPS.get(pendingKey).miJugada;
         const suJugada = data.choice;
-        pendingRPS.delete(data.from);
+        pendingRPS.delete(pendingKey);
 
         let resultStr = "😐 Es un empate.";
         let win = false;
@@ -172,7 +197,7 @@ function startChat(onExit, mode = 'udp') {
     }
 
     if (!data.text) return; 
-    if (data.type === "message" && data.to && data.to !== username) return;
+    if (data.type === "message" && data.to && data.to.toLowerCase() !== username.toLowerCase() && data.from.toLowerCase() !== username.toLowerCase()) return;
 
     readline.clearLine(process.stdout, 0);
     readline.cursorTo(process.stdout, 0);
@@ -257,12 +282,19 @@ function startChat(onExit, mode = 'udp') {
     }, 200);
   }
 
+  rl.on('SIGINT', () => {
+    cleanupAndExit();
+  });
+
   rl.on("line", (line) => {
     if (!username) return;
     const input = line.trim();
+    if (!input) { updatePrompt(); return; }
+
+    const inputLower = input.toLowerCase();
 
-    if (input === "/exit") { cleanupAndExit(); return; }
-    if (input === "/users") {
+    if (inputLower === "/exit") { cleanupAndExit(); return; }
+    if (inputLower === "/users") {
       console.log("──────────── 👥 USUARIOS CONECTADOS ────────────");
       const usersArr = Array.from(knownUsers);
       if (usersArr.length === 0) console.log(" 👻 No hay otros usuarios todavía.");
@@ -271,22 +303,39 @@ function startChat(onExit, mode = 'udp') {
       updatePrompt();
       return;
     }
-    if (input === "/clear") { console.clear(); updatePrompt(); return; }
-    if (input === "/help") {
+    if (inputLower === "/clear") { console.clear(); updatePrompt(); return; }
+    if (inputLower === "/help") {
       console.log("──────────── 💡 COMANDOS DISPONIBLES ────────────");
       console.log(" 💬 /chat <usuario>  → Iniciar chat privado");
+      console.log(" 💬 /w <usuario>     → Susurro / chat privado");
       console.log(" 🌍 /all             → Volver al chat público");
       console.log(" 🪙 /flip            → Lanzar una moneda");
       console.log(" 🎮 /rps <usr> <j>   → Retar a Piedra/Papel/Tijera");
       console.log(" 🌟 /blink <msj>     → Enviar msj parpadeante");
+      console.log(" 🧹 /clear           → Limpiar historial de consola");
       console.log(" ❌ /exit            → Salir al menú");
       updatePrompt();
       return;
     }
-    if (input === "/all") { currentChat = ""; console.log("🌍 Chat público"); updatePrompt(); return; }
-    if (input.startsWith("/chat ")) { currentChat = input.replace("/chat ", "").trim(); console.log(`🔒 Chat privado con ${currentChat}`); updatePrompt(); return; }
+    if (inputLower === "/all") { currentChat = ""; console.log("🌍 Chat público"); updatePrompt(); return; }
+    if (inputLower.startsWith("/chat ") || inputLower.startsWith("/w ")) { 
+      const parts = input.split(" ");
+      currentChat = parts[1] || "";
+      if (parts.length > 2) {
+          const inlineMsg = parts.slice(2).join(" ").trim();
+          if (inlineMsg) {
+              broadcastData(encrypt(JSON.stringify({ type: "message", from: username, to: currentChat, text: inlineMsg, blink: false })));
+              readline.moveCursor(process.stdout, 0, -1);
+              readline.clearLine(process.stdout, 0);
+              console.log(`🔒 [Tú ${getUserEmoji(username)} → ${getUserEmoji(currentChat)} ${currentChat}]: ${inlineMsg}`);
+              updatePrompt();
+              return;
+          }
+      }
+      console.log(`🔒 Chat privado con ${currentChat}`); updatePrompt(); return; 
+    }
     
-    if (input === "/flip") {
+    if (inputLower === "/flip") {
       const choices = ["CARA", "ESCUDO"];
       const result = choices[Math.floor(Math.random() * choices.length)];
       console.log(`🪙  Lanzaste la moneda y salió: \x1b[1m\x1b[33m${result}\x1b[0m`);
@@ -295,19 +344,20 @@ function startChat(onExit, mode = 'udp') {
       return;
     }
 
-    if (input.startsWith("/rps ")) {
+    if (inputLower.startsWith("/rps ")) {
       const parts = input.split(" ");
       if (parts.length < 3) { console.log("❌ Usa: /rps <usuario> <piedra|papel|tijera>"); updatePrompt(); return; }
       
       const targetUser = parts[1];
       const jugada = parts[2].toLowerCase();
       if (!["piedra", "papel", "tijera"].includes(jugada)) { console.log("❌ piedra, papel o tijera."); updatePrompt(); return; }
-      if (targetUser === username) { console.log("❌ No puedes jugar contigo mismo."); updatePrompt(); return; }
+      if (targetUser.toLowerCase() === username.toLowerCase()) { console.log("❌ No puedes jugar contigo mismo."); updatePrompt(); return; }
 
-      if (incomingRPS.has(targetUser)) {
-        incomingRPS.delete(targetUser);
+      const incomingKey = Array.from(incomingRPS).find(k => k.toLowerCase() === targetUser.toLowerCase());
+      if (incomingKey) {
+        incomingRPS.delete(incomingKey);
         console.log(`🎮 Respuesta enviada (${jugada})...`);
-        broadcastData(encrypt(JSON.stringify({ type: "rps_response", from: username, to: targetUser, choice: jugada })));
+        broadcastData(encrypt(JSON.stringify({ type: "rps_response", from: username, to: incomingKey, choice: jugada })));
       } else {
         pendingRPS.set(targetUser, { miJugada: jugada, time: Date.now() });
         console.log(`🎮 Retaste a ${targetUser} con ${jugada}...`);
@@ -317,7 +367,7 @@ function startChat(onExit, mode = 'udp') {
       return;
     }
 
-    if (input.startsWith("/") && !input.startsWith("/blink ")) {
+    if (inputLower.startsWith("/") && !inputLower.startsWith("/blink ")) {
       console.log("❌ Comando no reconocido.");
       updatePrompt();
       return;
@@ -325,9 +375,9 @@ function startChat(onExit, mode = 'udp') {
 
     let textToSend = input;
     let isBlink = false;
-    if (input.startsWith("/blink ")) {
+    if (inputLower.startsWith("/blink ")) {
       isBlink = true;
-      textToSend = input.replace("/blink ", "").trim();
+      textToSend = input.substring(7).trim();
       if (!textToSend) { updatePrompt(); return; }
     } else if (!input) { updatePrompt(); return; }
 

package/src/server/index.js

@@ -1,305 +1,237 @@
-const WebSocket = require("ws");
-
+const WebSocket = require('ws');
 const PORT = process.env.PORT || 3000;
 const wss = new WebSocket.Server({ port: PORT });
 
-let globalTienditaTimer = null;
-
-const sessions = new Map(); // socket -> { name: string, emoji: string }
-const pendingRPS = new Map(); // targetName -> { from: name, miJugada: "piedra" }
-
+// --- ESTADO GLOBAL ---
+const sessions = new Map(); // ws -> { name, emoji, privateTarget }
 const userEmojis = ["🐶", "🐱", "🐭", "🐹", "🐰", "🦊", "🐻", "🐼", "🐨", "🐯", "🦁", "🐮", "🐷", "🐸", "🐵", "🦄", "🐙", "🦋", "🦖", "🐧", "🦉", "👽", "🤖", "👻", "🥑", "🍕"];
 
-function getTime() {
-   const d = new Date();
-   const hs = String(d.getHours()).padStart(2, '0');
-   const ms = String(d.getMinutes()).padStart(2, '0');
-   return `\x1b[90m${hs}:${ms}\x1b[0m`;
-}
+let pendingRPS = new Map(); // target -> { from, miJugada }
 
-function broadcast(msg, ignoreWs = null) {
+// Helpers
+function broadcast(jsonObj, ignoreWs = null) {
+   const payload = JSON.stringify(jsonObj);
    for (const [s, data] of sessions.entries()) {
       if (s !== ignoreWs && s.readyState === WebSocket.OPEN && data.name) {
-         try { s.send(msg); } catch (e) { }
+         try { s.send(payload); } catch(e) {}
       }
    }
 }
 
-function sendToTarget(name, msg) {
+function sendToTarget(targetName, jsonObj) {
+   if (!targetName) return;
+   const payload = JSON.stringify(jsonObj);
    for (const [s, data] of sessions.entries()) {
-      if (data.name === name && s.readyState === WebSocket.OPEN) {
-         try { s.send(msg); } catch (e) { }
+      if (data.name && data.name.toLowerCase() === targetName.toLowerCase() && s.readyState === WebSocket.OPEN) {
+         try { s.send(payload); } catch(e) {}
       }
    }
 }
 
 function targetExists(name) {
-   for (const data of sessions.values()) if (data.name === name) return true;
+   if (!name) return false;
+   for (const d of sessions.values()) if (d.name && d.name.toLowerCase() === name.toLowerCase()) return true;
    return false;
 }
 
-wss.on("connection", (server) => {
-   sessions.set(server, { name: null, emoji: null });
-
-   server.send("\x1b[36m====================================\x1b[0m\n   🚀 BIENVENIDO A LA SALA GLOBAL 🚀\n\x1b[36m====================================\x1b[0m");
-   // 1. Al entrar por primera vez no es necesario /name
-   server.send("🤖 Sistema: Escribe tu nombre y presiona Enter para comenzar:");
-
-   server.on("message", (message) => {
-      if (globalTienditaTimer) {
-         clearInterval(globalTienditaTimer);
-         globalTienditaTimer = null;
-      }
-
-      const socketData = sessions.get(server);
-      let text = message.toString().trim();
-
-      // Registro de Smart Client Silencioso
-      if (text === "/iam_smart") {
-         socketData.smart = true;
-         return;
-      }
-
-      // REGISTRO ÚNICO
-      if (!socketData.name) {
-         if (!text || text === "/typ") return;
-         const desiredName = text.replace("/name ", "").trim();
-         if (targetExists(desiredName)) {
-            server.send("❌ Nombre en uso. Escribe otro distinto:");
-         } else {
-            // Lógica de Emojis Únicos sin repetir (Evitamos colisiones)
-            const takenEmojis = new Set(Array.from(sessions.values()).map(d => d.emoji).filter(Boolean));
-            const available = userEmojis.filter(e => !takenEmojis.has(e));
-
-            // Si por algun motivo la sala es masiva (> 26 usuarios), reciclamos de todos
-            const pool = available.length > 0 ? available : userEmojis;
-            const assignedEmoji = pool[Math.floor(Math.random() * pool.length)];
-
-            socketData.name = desiredName;
-            socketData.emoji = assignedEmoji;
-
-            server.send(`✅ ¡Listo ${desiredName}! Estás conectado con el avatar ${assignedEmoji}. Escribe /help para comandos.`);
-            broadcast(`\n[${getTime()}] 🟢 [\x1b[32m${assignedEmoji} ${desiredName}\x1b[0m] se ha unido al servidor.\n`, server);
-         }
-         return;
-      }
-
-      const myName = socketData.name;
-      const myEmoji = socketData.emoji;
+function getExactName(name) {
+   if (!name) return null;
+   for (const d of sessions.values()) if (d.name && d.name.toLowerCase() === name.toLowerCase()) return d.name;
+   return name;
+}
 
-      if (text === "/help") {
-         server.send(`\n──────────── 💡 COMANDOS ────────────
- 👥 /users           → Ver conectados
- 🪙 /flip            → Lanzar moneda
- 🎮 /rps <usr> <j>   → Piedra-Papel-Tijera
- 🌟 /blink <msj>     → Mensaje parpadeante
- 🔒 /w <usr> <msj>   → Mensaje privado
- 🏪 /tiendita        → Invitación a la Tiendita
- ℹ️ /help            → Esta ayuda
-─────────────────────────────────────────────\n`);
-         return;
-      }
+// State para Tiping
+let typingMap = new Map(); 
+
+function broadcastUsers() {
+    const list = [];
+    const plainList = [];
+    for(const d of sessions.values()) {
+        if(d.name) {
+            list.push(`${d.emoji} ${d.name}`);
+            plainList.push(d.name);
+        }
+    }
+    broadcast({ type: "users_update", users: list, plain: plainList });
+}
 
-      if (text === "/users") {
-         let userList = [];
-         for (const d of sessions.values()) if (d.name) userList.push(`${d.emoji} ${d.name}`);
-         server.send(`\n👥 \x1b[36mCONECTADOS AHORA (${userList.length}):\x1b[0m ` + userList.join(", ") + "\n");
-         return;
-      }
+function broadcastTyping() {
+    const list = Array.from(typingMap.keys());
+    broadcast({ type: "typing_event", users: list });
+}
 
-      // 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(`${text}_event ${myEmoji} ${myName}`); } catch (e) { }
+wss.on("connection", (ws) => {
+   sessions.set(ws, { name: null, emoji: null, privateTarget: null });
+
+   ws.on("message", (raw) => {
+      let req;
+      try { req = JSON.parse(raw); } catch(e) { return; } // Ignorar todo lo que no sea JSON moderno
+
+      const user = sessions.get(ws);
+
+      // 1. REGISTRO
+      if (req.type === "register") {
+          const desiredName = req.name.trim();
+          if (targetExists(desiredName)) {
+             ws.send(JSON.stringify({ type: "error", msg: "Nombre en uso. Elige otro." }));
+             return;
+          }
+          const taken = new Set(Array.from(sessions.values()).map(d => d.emoji).filter(Boolean));
+          const available = userEmojis.filter(e => !taken.has(e));
+          const emoji = available.length > 0 ? available[Math.floor(Math.random() * available.length)] : "⭐";
+          
+          user.name = desiredName;
+          user.emoji = emoji;
+          
+          ws.send(JSON.stringify({ type: "registered", name: user.name, emoji: user.emoji }));
+          broadcast({ type: "system", msg: `🟢 [\x1b[32m${emoji} ${user.name}\x1b[0m] se ha unido al servidor.` }, ws);
+          broadcastUsers();
+          return;
+      }
+
+      // Seguridad: Debe estar registrado para ejecutar comandos
+      if (!user.name) return;
+
+      const myName = user.name;
+
+      // Limpiar typing automático si envía un mensaje real
+      if (req.type === "chat" || req.type === "command") {
+          if (typingMap.has(myName)) {
+             clearTimeout(typingMap.get(myName));
+             typingMap.delete(myName);
+             broadcastTyping();
+          }
+      }
+
+      switch (req.type) {
+         case "typing":
+            if (typingMap.has(myName)) clearTimeout(typingMap.get(myName));
+            typingMap.set(myName, setTimeout(() => {
+                typingMap.delete(myName);
+                broadcastTyping();
+            }, 5000));
+            broadcastTyping();
+            break;
+
+         case "typing_stop":
+            if (typingMap.has(myName)) {
+                clearTimeout(typingMap.get(myName));
+                typingMap.delete(myName);
+                broadcastTyping();
             }
-         }
-         return; // Invisible, solo de control
-      }
-
-      // 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(" ");
-         const targetUser = parts[1];
-
-         if (!targetExists(targetUser)) { server.send("❌ Usuario no encontrado."); return; }
-         if (targetUser === myName) { server.send("❌ ¿Hablando contigo mismo?"); return; }
-
-         // 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 ASCII Rotativa in-place
-      if (text === "/flip") {
-         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 i = 0;
-         const timer = setInterval(() => {
-            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++;
+            break;
+
+         case "chat":
+            const isPrivate = req.target || user.privateTarget;
+            const target = req.target || user.privateTarget;
+
+            if (isPrivate) {
+                if (!targetExists(target)) {
+                    ws.send(JSON.stringify({ type: "error", msg: `${target} no está conectado.` }));
+                    return;
+                }
+                const exactTarget = getExactName(target);
+                const pMsg = { type: "chat", from: myName, emoji: user.emoji, msg: req.msg, isWhisper: true, to: exactTarget };
+                ws.send(JSON.stringify(pMsg));
+                sendToTarget(exactTarget, pMsg);
             } else {
-               clearInterval(timer);
-               const result = Math.random() < 0.5 ? "CARA" : "ESCUDO";
-               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);
+                const globalMsg = { type: "chat", from: myName, emoji: user.emoji, msg: req.msg, isWhisper: false };
+                ws.send(JSON.stringify(globalMsg));
+                broadcast(globalMsg, ws);
+
+                // Menciones (ding!) enviamos comando JSON puro de ping a clientes
+                const mentions = [...req.msg.matchAll(/@([a-zA-Z0-9_]+)/g)].map(m => m[1]);
+                for (const m of mentions) {
+                   if (targetExists(m) && m !== myName) {
+                       sendToTarget(m, { type: "ding" });
+                   }
+                }
             }
-         }, 200);
-         return;
-      }
-
-      // Comando Animado ASCII de Cambios de Colores
-      if (text === "/tiendita") {
-         const introMsg = `\n[${getTime()}] 🏪 \x1b[1m${myName}\x1b[0m convoca a todos a la tiendita...\n`;
-         server.send(introMsg);
-         broadcast(introMsg, server);
-
-         const asciiArt = `_____ _                _ _ _        _ _ _ 
- |_   _(_) ___ _ __   __| (_) |_ __ _| | | |
-   | | | |/ _ \ '_ \ / _  | | __/ _  | | | |
-   | | | |  __/ | | | (_  | | || (_  |_|_|_|
-   |_| |_|\___|_| |_|\__,_|_|\__\__,_(_|_|_)
-  `;
-
-         const baseColors = [
-            "\x1b[31m", // Rojo
-            "\x1b[33m", // Amarillo
-            "\x1b[32m", // Verde
-            "\x1b[36m", // Cyan
-            "\x1b[1m\x1b[35m" // Magenta Brillante
-         ];
-
-         // Primer frame puro sin código de arrastre hacia arriba
-         const f0 = `${baseColors[0]}${asciiArt}\x1b[0m`;
-         server.send(f0);
-         broadcast(f0, server);
-
-         let i = 1;
-         globalTienditaTimer = setInterval(() => {
-            const color = baseColors[i % baseColors.length];
-            const frame = `\r\x1b[6A\x1b[0J< ${color}${asciiArt}\x1b[0m`;
-            server.send(frame);
-            broadcast(frame, server);
-            i++;
-         }, 600); // Bucle Infinito a 600ms
-         return;
-      }
-
-      if (text.startsWith("/blink ")) {
-         const blnkText = text.replace("/blink ", "").trim();
-         const msg = `\n[${getTime()}] 🌟 [${myEmoji} ${myName}]: \x1b[5m${blnkText}\x1b[0m\n`;
-         server.send(msg);
-         broadcast(msg, server);
-         return;
-      }
-
-      if (text.startsWith("/rps ")) {
-         const parts = text.split(" ");
-         if (parts.length < 3) { server.send("❌ Error: /rps <usuario> <piedra|papel|tijera>"); return; }
-         const target = parts[1];
-         const choice = parts[2].toLowerCase();
-
-         if (!["piedra", "papel", "tijera"].includes(choice)) { server.send("❌ Elige piedra, papel o tijera."); return; }
-         if (target === myName) { server.send("❌ No contra ti mismo."); return; }
-         if (!targetExists(target)) { server.send(`❌ El usuario ${target} no existe.`); return; }
-
-         if (pendingRPS.has(myName) && pendingRPS.get(myName).from === target) {
-            const retoAnterior = pendingRPS.get(myName);
-            pendingRPS.delete(myName);
-
-            const miJugada = choice;
-            const suJugada = retoAnterior.miJugada;
-
-            let winStr;
-            if (miJugada === suJugada) { winStr = "😐 Empate"; }
-            else if ((miJugada === "piedra" && suJugada === "tijera") || (miJugada === "papel" && suJugada === "piedra") || (miJugada === "tijera" && suJugada === "papel")) { winStr = `🎉 \x1b[32m${myName}!\x1b[0m`; }
-            else { winStr = `🎉 \x1b[32m${target}!\x1b[0m`; }
-
-            const outMsg = `\n[${getTime()}] 🕹️ RESULTADO RPS 🕹️\n⚔️ \x1b[36m${target}\x1b[0m (${suJugada}) VS \x1b[36m${myName}\x1b[0m (${miJugada})\n🏆 Ganador: ${winStr}\n`;
-            server.send(outMsg);
-            broadcast(outMsg, server);
-         } else {
-            pendingRPS.set(target, { from: myName, miJugada: choice });
-            server.send(`\n[${getTime()}] 🎮 \x1b[33mTu elección escondida (${choice}) ha sido fijada. Esperando a ${target}.\x1b[0m`);
-            sendToTarget(target, `\n[${getTime()}] \x1b[5m\x1b[35m🚨 ¡${myName} te reta a muerte en RPS!\x1b[0m\n👉 Responde tu golpe con: /rps ${myName} <piedra|papel|tijera>\n`);
-         }
-         return;
-      }
+            break;
 
-      if (text.startsWith("/")) {
-         server.send("❌ Desconocido. Usa /help");
-         return;
-      }
-
-      // 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", () => {
-      const u = sessions.get(server);
-      if (u && u.name) broadcast(`\n[${getTime()}] 🔴 [\x1b[31m${u.emoji} ${u.name}\x1b[0m] abandonó la sala.\n`, server);
-      sessions.delete(server);
-      pendingRPS.delete(u ? u.name : "");
-      for (const [t, data] of pendingRPS.entries()) {
-         if (data.from === u?.name) pendingRPS.delete(t);
+         case "command":
+            if (req.cmd === "users") {
+                const list = [];
+                for(const d of sessions.values()) if(d.name) list.push(`${d.emoji} ${d.name}`);
+                ws.send(JSON.stringify({ type: "users_list", users: list }));
+            }
+            else if (req.cmd === "flip") {
+                const result = Math.random() < 0.5 ? "CARA" : "ESCUDO";
+                // Delega el procesado nativo intensivo al cliente! Envía la órden e historial en 1 Ms.
+                const animData = { type: "animation", name: "flip", result: result, user: myName, emoji: user.emoji };
+                ws.send(JSON.stringify(animData));
+                broadcast(animData, ws);
+            }
+            else if (req.cmd === "tiendita") {
+                const animData = { type: "animation", name: "tiendita", user: myName, emoji: user.emoji };
+                ws.send(JSON.stringify(animData));
+                broadcast(animData, ws);
+            }
+            else if (req.cmd === "rps") {
+                const target = req.target;
+                const choice = req.choice;
+                if (!targetExists(target)) { ws.send(JSON.stringify({ type: "error", msg: "Usuario no existe" })); return; }
+                if (target === myName) { ws.send(JSON.stringify({ type: "error", msg: "No contigo mismo" })); return; }
+
+                if (pendingRPS.has(myName) && pendingRPS.get(myName).from === target) {
+                    const reto = pendingRPS.get(myName);
+                    pendingRPS.delete(myName);
+                    let win = "😐 Empate";
+                    if (choice !== reto.miJugada) {
+                       if ((choice === "piedra" && reto.miJugada === "tijera") || (choice === "papel" && reto.miJugada === "piedra") || (choice === "tijera" && reto.miJugada === "papel")) win = `🎉 Ganador: \x1b[32m${myName}\x1b[0m`;
+                       else win = `🎉 Ganador: \x1b[32m${target}\x1b[0m`;
+                    }
+                    const resMsg = `\n🕹️ RESULTADO RPS 🕹️\n⚔️ \x1b[36m${target}\x1b[0m (${reto.miJugada}) VS \x1b[36m${myName}\x1b[0m (${choice})\n🏆 ${win}\n`;
+                    const resPayload = { type: "system", msg: resMsg };
+                    ws.send(JSON.stringify(resPayload));
+                    broadcast(resPayload, ws);
+                } else {
+                    pendingRPS.set(target, { from: myName, miJugada: choice });
+                    ws.send(JSON.stringify({ type: "system", msg: `🎮 \x1b[33mTu elección escondida (${choice}) ha sido fijada. Esperando a ${target}.\x1b[0m` }));
+                    sendToTarget(target, { type: "system", msg: `\x1b[5m\x1b[35m🚨 ¡${myName} te reta a muerte en RPS!\x1b[0m\n👉 Responde tu golpe con: /rps ${myName} <piedra|papel|tijera>` });
+                }
+            }
+            else if (req.cmd === "mode_whisper") {
+                const exactTarget = getExactName(req.target);
+                if (!targetExists(exactTarget)) {
+                    ws.send(JSON.stringify({ type: "error", msg: `${req.target} no está conectado.` }));
+                    return;
+                }
+                user.privateTarget = exactTarget;
+                ws.send(JSON.stringify({ type: "system", msg: `🔒 \x1b[35mModo Privado Fijo con ${exactTarget}.\x1b[0m Usa /all para salir.` }));
+            }
+            else if (req.cmd === "mode_all") {
+                user.privateTarget = null;
+                ws.send(JSON.stringify({ type: "system", msg: `🟢 \x1b[32mModo Chat Público Restaurado.\x1b[0m` }));
+            }
+            else if (req.cmd === "blink") {
+                const bMsg = { type: "system", msg: `🌟 [${user.emoji} ${myName}]: \x1b[5m${req.msg}\x1b[0m` };
+                ws.send(JSON.stringify(bMsg));
+                broadcast(bMsg, ws);
+            }
+            break;
       }
    });
 
-   server.on("error", () => {
-      sessions.delete(server);
+   ws.on("close", () => {
+       const u = sessions.get(ws);
+       if (u && u.name) {
+           broadcast({ type: "system", msg: `🔴 [\x1b[31m${u.emoji} ${u.name}\x1b[0m] abandonó la sala.` }, ws);
+           if (typingMap.has(u.name)) {
+               clearTimeout(typingMap.get(u.name));
+               typingMap.delete(u.name);
+               broadcastTyping(); // Notificamos de inmediato al mundo para que eliminen su typing UI
+           }
+       }
+       sessions.delete(ws);
+       if (u && u.name) {
+           broadcastUsers();
+           pendingRPS.delete(u.name);
+           for(const [t, data] of pendingRPS.entries()) {
+               if(data.from === u.name) pendingRPS.delete(t);
+           }
+       }
    });
 });
 
-console.log(`📡 Servidor WebSocket de Node corriendo en puerto ${PORT}`);
+console.log(`📡 Servidor JSON-Core Central corriendo en puerto ${PORT}`);

package/src/server/worker.js

@@ -50,10 +50,10 @@ export default {
       text = text.trim();
 
       if (!socketData.name) {
-        if (text.startsWith("/name ")) {
-          const desiredName = text.replace("/name ", "").trim();
+        if (text.toLowerCase().startsWith("/name ")) {
+          const desiredName = text.substring(6).trim();
           let alreadyExists = false;
-          for (const d of sessions.values()) if (d.name === desiredName) alreadyExists = true;
+          for (const d of sessions.values()) if (d.name && d.name.toLowerCase() === desiredName.toLowerCase()) alreadyExists = true;
           
           if (alreadyExists) {
              server.send("❌ Ese nombre ya está en uso. Usa /name con otro.");
@@ -70,20 +70,21 @@ export default {
 
       const myName = socketData.name;
       const myEmoji = getUserEmoji(myName);
+      const textLower = text.toLowerCase();
 
-      if (text === "/help") {
+      if (textLower === "/help") {
          server.send(`\n──────────── 💡 COMANDOS CENTRALIZADOS ────────────\n 👥 /users           → Ver conectados\n 🪙 /flip            → Lanzar moneda al aire\n 🎮 /rps <usr> <j>   → Piedra-Papel-Tijera\n 🌟 /blink <msj>     → Mensaje parpadeante\n ℹ️  /help           → Esta ayuda\n───────────────────────────────────────────────────\n`);
          return;
       }
 
-      if (text === "/users") {
+      if (textLower === "/users") {
          let userList = [];
          for (const d of sessions.values()) if (d.name) userList.push(`${getUserEmoji(d.name)} ${d.name}`);
          server.send("\n👥 \x1b[36mCONECTADOS AHORA:\x1b[0m " + userList.join(", ") + "\n");
          return;
       }
 
-      if (text === "/flip") {
+      if (textLower === "/flip") {
          const result = Math.random() < 0.5 ? "CARA" : "ESCUDO";
          const msg = `\n🪙  [${myEmoji} ${myName}] ha lanzado la moneda y cayó en: \x1b[1m\x1b[33m${result}\x1b[0m!\n`;
          server.send(msg); // <--- ECHO LOCAL agregado
@@ -91,24 +92,32 @@ export default {
          return;
       }
 
-      if (text.startsWith("/blink ")) {
-         const blnkText = text.replace("/blink ", "").trim();
+      if (textLower.startsWith("/blink ")) {
+         const blnkText = text.substring(7).trim();
          const msg = `\n🌟 [${myEmoji} ${myName}]: \x1b[5m${blnkText}\x1b[0m\n`;
          server.send(msg); // <--- ECHO LOCAL agregado
          broadcast(msg, server);
          return;
       }
 
-      if (text.startsWith("/rps ")) {
+      if (textLower.startsWith("/rps ")) {
          const parts = text.split(" ");
          if (parts.length < 3) { server.send("❌ Error: /rps <usuario> <piedra|papel|tijera>"); return; }
          const target = parts[1];
          const choice = parts[2].toLowerCase();
 
+         let exactTargetName = target;
+         for (const d of sessions.values()) {
+             if (d.name && d.name.toLowerCase() === target.toLowerCase()) {
+                 exactTargetName = d.name;
+                 break;
+             }
+         }
+
          if (!["piedra", "papel", "tijera"].includes(choice)) { server.send("❌ Elige piedra, papel o tijera."); return; }
-         if (target === myName) { server.send("❌ No contra ti mismo."); return; }
+         if (exactTargetName.toLowerCase() === myName.toLowerCase()) { server.send("❌ No contra ti mismo."); return; }
 
-         if (pendingRPS.has(myName) && pendingRPS.get(myName).from === target) {
+         if (pendingRPS.has(myName) && pendingRPS.get(myName).from.toLowerCase() === exactTargetName.toLowerCase()) {
              const retoAnterior = pendingRPS.get(myName);
              pendingRPS.delete(myName); 
 
@@ -118,20 +127,20 @@ export default {
              let winStr;
              if (miJugada === suJugada) { winStr = "😐 Empate"; }
              else if ( (miJugada === "piedra" && suJugada === "tijera") || (miJugada === "papel" && suJugada === "piedra") || (miJugada === "tijera" && suJugada === "papel") ) { winStr = `🎉 \x1b[32m${myName}!\x1b[0m`; }
-             else { winStr = `🎉 \x1b[32m${target}!\x1b[0m`; }
+             else { winStr = `🎉 \x1b[32m${exactTargetName}!\x1b[0m`; }
 
-             const outMsg = `\n🕹️ RESULTADO RPS 🕹️\n⚔️ \x1b[36m${target}\x1b[0m (${suJugada}) VS \x1b[36m${myName}\x1b[0m (${miJugada})\n🏆 Ganador: ${winStr}\n`;
+             const outMsg = `\n🕹️ RESULTADO RPS 🕹️\n⚔️ \x1b[36m${exactTargetName}\x1b[0m (${suJugada}) VS \x1b[36m${myName}\x1b[0m (${miJugada})\n🏆 Ganador: ${winStr}\n`;
              server.send(outMsg); // ECHO LOCAL
              broadcast(outMsg, server);
          } else {
-             pendingRPS.set(target, { from: myName, miJugada: choice });
-             server.send(`\n🎮 \x1b[33mTu reto (${choice}) ha sido enviado a ${target}.\x1b[0m`);
-             sendToTarget(target, `\n\x1b[5m\x1b[35m🚨 ¡${myName} te reta a RPS!\x1b[0m\n👉 Responde: /rps ${myName} <piedra|papel|tijera>\n`);
+             pendingRPS.set(exactTargetName, { from: myName, miJugada: choice });
+             server.send(`\n🎮 \x1b[33mTu reto (${choice}) ha sido enviado a ${exactTargetName}.\x1b[0m`);
+             sendToTarget(exactTargetName, `\n\x1b[5m\x1b[35m🚨 ¡${myName} te reta a RPS!\x1b[0m\n👉 Responde: /rps ${myName} <piedra|papel|tijera>\n`);
          }
          return;
       }
 
-      if (text.startsWith("/")) {
+      if (textLower.startsWith("/")) {
          server.send("❌ Comando no reconocido. Usa /help");
          return;
       }