@pdc-test/chat-io 1.0.0

package/bin/cli.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+const WebSocket = require('ws');
+const readline = require('readline');
+
+// URL del Servidor Oficial de Railway
+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)
+function completer(line) {
+  const hits = commands.filter((c) => c.startsWith(line));
+  return [hits.length ? hits : [], line];
+}
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  completer,
+  prompt: '\r> ' // Prefix visual del input
+});
+
+let isTyping = false;
+let typingTimeout = null;
+let typingUsers = new Set();
+let typingFrames = ['.', '..', '...'];
+let tIdx = 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
+           }
+       }
+       // Reiniciar el timeout si el usuario sigue tecleando
+       clearTimeout(typingTimeout);
+       typingTimeout = setTimeout(() => {
+           isTyping = false;
+       }, 2000);
+    }
+});
+
+// Renderizado de "Escribiendo..." Dinámico en la Barra Inferior
+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`);
+        tIdx = (tIdx + 1) % typingFrames.length;
+        
+        // Restaurar silenciosamente lo que el usuario estaba redactando
+        readline.cursorTo(process.stdout, 0);
+        process.stdout.write(`> ${rl.line}`);
+    }
+}, 400);
+
+// Flujo WebSocket
+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.
+});
+
+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);
+       setTimeout(() => typingUsers.delete(u), 3000); // 3seg de cooldown maximo
+       return; 
+   }
+   
+   // Si recibimos texto normal, limpiamos indicadores para que no estorben
+   typingUsers.clear();
+
+   // Purgamos la línea completa en la consola antes de dibujar la obra de Arte/Chat
+   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
+});
+
+// Cuando le damos ENTER
+rl.on('line', (input) => {
+   const line = input.trim();
+   if (line) {
+       ws.send(line);
+       isTyping = false; // Matamos flag al presionar intro
+   }
+   rl.prompt(true);
+});
+
+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");
+    process.exit(0);
+});

package/package.json

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

package/src/chat/index.js

@@ -0,0 +1,378 @@
+const dgram = require("dgram");
+const WebSocket = require("ws");
+const readline = require("readline");
+const { encrypt, decrypt } = require("../utils/crypto");
+const { getLocalIps } = require("../utils/network");
+const { getUserEmoji } = require("../utils/emojis");
+
+function startChat(onExit, mode = 'udp') {
+  console.clear();
+  const PORT = 41234;
+  const BROADCAST_IP = "172.16.41.255"; 
+  const CLOUD_URL = "wss://chat-backend.marioarita502.workers.dev";
+  let socket;
+
+  let username = "";
+  let currentChat = "";
+  let knownUsers = new Set();
+  let typingUsers = new Map();
+  let lastSeen = new Map();
+
+  let pendingRPS = new Map(); 
+  let incomingRPS = new Set();
+  let dotCount = 0;
+  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));
+    return [hits.length ? hits : completions, line];
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    completer: completer
+  });
+
+  animationInterval = setInterval(() => {
+    if (typingUsers.size > 0 && username) {
+      dotCount = (dotCount + 1) % 4; 
+      updatePrompt();
+    }
+  }, 500);
+
+  function updatePrompt() {
+    const typers = Array.from(typingUsers.keys());
+    let typingMsg = "";
+    if (typers.length > 0) {
+      const verb = typers.length > 1 ? "están escribiendo" : "escribiendo";
+      const typersWithEmoji = typers.map(t => `${getUserEmoji(t)} ${t}`);
+      const dots = ".".repeat(dotCount);
+      typingMsg = ` (✏️  ${typersWithEmoji.join(", ")} ${verb}${dots})`;
+    }
+    rl.setPrompt(currentChat ? `[priv:${currentChat}]${typingMsg} > ` : `[all]${typingMsg} > `);
+    rl.prompt(true);
+  }
+
+  function initChatUI() {
+    rl.question("Nombre: ", (name) => {
+      username = name.trim() || "Anon";
+      console.log(`👋 Bienvenido ${username}`);
+      console.log("💡 Escribe /help para ver los comandos.");
+      
+      const joinPayload = { type: "join", from: username };
+      broadcastData(encrypt(JSON.stringify(joinPayload)));
+
+      updatePrompt();
+    });
+  }
+
+  function processMessage(cipherText) {
+    const decrypted = decrypt(cipherText);
+    if (!decrypted) return;
+
+    let data;
+    try { data = JSON.parse(decrypted); } catch { return; }
+
+    if (data.from && data.from !== username) {
+      const isNew = !knownUsers.has(data.from);
+      knownUsers.add(data.from);
+      lastSeen.set(data.from, Date.now());
+
+      if (isNew && data.type !== "leave") {
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        console.log(`🟢 [${getUserEmoji(data.from)} ${data.from}] conectado.`);
+        updatePrompt();
+      }
+    }
+
+    if (data.type === "heartbeat" || data.type === "present" || data.type === "join") return;
+
+    if (data.type === "leave") {
+      if (knownUsers.has(data.from)) {
+        knownUsers.delete(data.from);
+        lastSeen.delete(data.from);
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        console.log(`🔴 [${getUserEmoji(data.from)} ${data.from}] salió del chat.`);
+        updatePrompt();
+      }
+      return;
+    }
+
+    if (data.type === "flip") {
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+      console.log(`🪙  [${getUserEmoji(data.from)} ${data.from}] lanzó moneda: \x1b[1m\x1b[33m${data.result}\x1b[0m!`);
+      updatePrompt();
+      return;
+    }
+
+    if (data.type === "rps_challenge" && data.to === username) {
+      incomingRPS.add(data.from);
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+      console.log(`\n\x1b[5m\x1b[35m🎮 ¡${data.from} te ha retado a Piedra, Papel o Tijera!\x1b[0m`);
+      console.log(`👉 Acepta con: /rps ${data.from} <piedra|papel|tijera>\n`);
+      updatePrompt();
+      return;
+    }
+
+    if (data.type === "rps_response" && data.to === username) {
+      if (pendingRPS.has(data.from)) {
+        const miJugada = pendingRPS.get(data.from).miJugada;
+        const suJugada = data.choice;
+        pendingRPS.delete(data.from);
+
+        let resultStr = "😐 Es un empate.";
+        let win = false;
+        if (miJugada === suJugada) { resultStr = "😐 Es un empate."; } 
+        else if (
+          (miJugada === "piedra" && suJugada === "tijera") ||
+          (miJugada === "papel" && suJugada === "piedra") ||
+          (miJugada === "tijera" && suJugada === "papel")
+        ) { resultStr = "🎉 ¡Tú ganas!"; win = true; } 
+        else { resultStr = `💀 ¡Gana ${data.from}!`; }
+
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        console.log(`\n🎮 RESULTADO RPS CONTRA ${data.from}:`);
+        console.log(`Tu jugada: ${miJugada} | Su jugada: ${suJugada}`);
+        console.log(`${resultStr}\n`);
+        
+        const theWinner = win ? username : (resultStr === "😐 Es un empate." ? "Nadie" : data.from);
+        const broadPld = { type: "message", from: "Sistema", text: `🕹️ RPS Resultado: \x1b[36m${username}\x1b[0m (${miJugada}) vs \x1b[36m${data.from}\x1b[0m (${suJugada}) -> Ganó: \x1b[33m${theWinner}!\x1b[0m` };
+        broadcastData(encrypt(JSON.stringify(broadPld)));
+        updatePrompt();
+      }
+      return;
+    }
+
+    if (data.type === "typing") {
+      if (data.to && data.to !== username) return;
+      if (typingUsers.has(data.from)) clearTimeout(typingUsers.get(data.from));
+
+      typingUsers.set(data.from, setTimeout(() => {
+        typingUsers.delete(data.from);
+        updatePrompt();
+      }, 3000));
+      updatePrompt();
+      return;
+    }
+
+    if (typingUsers.has(data.from)) {
+      clearTimeout(typingUsers.get(data.from));
+      typingUsers.delete(data.from);
+    }
+
+    if (!data.text) return; 
+    if (data.type === "message" && data.to && data.to !== username) return;
+
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    const senderEmoji = data.from === "Sistema" ? "🖥️" : getUserEmoji(data.from);
+
+    let dTxt = data.blink ? `\x1b[5m${data.text}\x1b[0m` : data.text;
+    if (data.to) { console.log(`🔒 [${senderEmoji} ${data.from} → tú]: ${dTxt}`); } 
+    else { console.log(`🌍 [${senderEmoji} ${data.from}]: ${dTxt}`); }
+    updatePrompt();
+  }
+
+  function broadcastData(textPayload) {
+    const buffer = Buffer.from(textPayload);
+    if (mode === 'cloud') {
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(buffer);
+      }
+    } else {
+      socket.send(buffer, 0, buffer.length, PORT, BROADCAST_IP);
+    }
+  }
+
+  // == ESTABLECER CONEXION ==
+  if (mode === 'cloud') {
+    console.log("☁️  Intentando conectar a Cloudflare...");
+    socket = new WebSocket(CLOUD_URL);
+    socket.on("open", () => {
+      console.log("✅ Conectado a Servidor Global Cloudflare!");
+      initChatUI();
+    });
+    socket.on("message", (msg) => {
+      processMessage(msg.toString());
+    });
+    socket.on("error", (e) => console.log("⚠️ Error WS:", e.message));
+  } else {
+    socket = dgram.createSocket("udp4");
+    socket.on("listening", () => {
+      socket.setBroadcast(true);
+      console.log("📡 Red P2P Local Activa.");
+      initChatUI();
+    });
+    socket.on("message", (msg, rinfo) => {
+      if (getLocalIps().includes(rinfo.address)) return;
+      processMessage(msg.toString());
+    });
+    socket.on("error", (e) => console.log("⚠️ Error UDP:", e.message));
+    socket.bind(PORT);
+  }
+
+  let typingInterval;
+  let heartbeatInterval;
+  let pruneInterval;
+  let isClosing = false;
+
+  function cleanupAndExit() {
+    if (isClosing) return;
+    isClosing = true;
+    
+    clearInterval(typingInterval);
+    clearInterval(heartbeatInterval);
+    clearInterval(pruneInterval);
+    clearInterval(animationInterval);
+
+    if (!username) {
+      if (mode === 'cloud') {
+          if (socket.readyState === WebSocket.OPEN) socket.close();
+      } else socket.close();
+      rl.close();
+      if (onExit) onExit();
+      return;
+    }
+
+    const lvPayload = encrypt(JSON.stringify({ type: "leave", from: username }));
+    broadcastData(lvPayload);
+    
+    setTimeout(() => {
+      if (mode === 'cloud') {
+          if (socket.readyState === WebSocket.OPEN) socket.close();
+      } else socket.close();
+      rl.close();
+      if (onExit) onExit();
+    }, 200);
+  }
+
+  rl.on("line", (line) => {
+    if (!username) return;
+    const input = line.trim();
+
+    if (input === "/exit") { cleanupAndExit(); return; }
+    if (input === "/users") {
+      console.log("──────────── 👥 USUARIOS CONECTADOS ────────────");
+      const usersArr = Array.from(knownUsers);
+      if (usersArr.length === 0) console.log(" 👻 No hay otros usuarios todavía.");
+      else usersArr.forEach(u => console.log(`  ${getUserEmoji(u)} ${u}`));
+      console.log(`  (Tú) ${getUserEmoji(username)} ${username}`);
+      updatePrompt();
+      return;
+    }
+    if (input === "/clear") { console.clear(); updatePrompt(); return; }
+    if (input === "/help") {
+      console.log("──────────── 💡 COMANDOS DISPONIBLES ────────────");
+      console.log(" 💬 /chat <usuario>  → Iniciar 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(" ❌ /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 (input === "/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`);
+      broadcastData(encrypt(JSON.stringify({ type: "flip", from: username, result })));
+      updatePrompt();
+      return;
+    }
+
+    if (input.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 (incomingRPS.has(targetUser)) {
+        incomingRPS.delete(targetUser);
+        console.log(`🎮 Respuesta enviada (${jugada})...`);
+        broadcastData(encrypt(JSON.stringify({ type: "rps_response", from: username, to: targetUser, choice: jugada })));
+      } else {
+        pendingRPS.set(targetUser, { miJugada: jugada, time: Date.now() });
+        console.log(`🎮 Retaste a ${targetUser} con ${jugada}...`);
+        broadcastData(encrypt(JSON.stringify({ type: "rps_challenge", from: username, to: targetUser })));
+      }
+      updatePrompt();
+      return;
+    }
+
+    if (input.startsWith("/") && !input.startsWith("/blink ")) {
+      console.log("❌ Comando no reconocido.");
+      updatePrompt();
+      return;
+    }
+
+    let textToSend = input;
+    let isBlink = false;
+    if (input.startsWith("/blink ")) {
+      isBlink = true;
+      textToSend = input.replace("/blink ", "").trim();
+      if (!textToSend) { updatePrompt(); return; }
+    } else if (!input) { updatePrompt(); return; }
+
+    broadcastData(encrypt(JSON.stringify({ type: "message", from: username, to: currentChat || null, text: textToSend, blink: isBlink })));
+
+    readline.moveCursor(process.stdout, 0, -1);
+    readline.clearLine(process.stdout, 0);
+
+    const myEmoji = getUserEmoji(username);
+    let txtView = isBlink ? `\x1b[5m${textToSend}\x1b[0m` : textToSend;
+
+    if (currentChat) { console.log(`🔒 [Tú ${myEmoji} → ${getUserEmoji(currentChat)} ${currentChat}]: ${txtView}`); } 
+    else { console.log(`🌍 [Tú ${myEmoji}]: ${txtView}`); }
+    updatePrompt();
+  });
+
+  let lastTypedLine = "";
+  typingInterval = setInterval(() => {
+    if (username && rl.line && rl.line !== lastTypedLine && !rl.line.startsWith("/")) {
+      broadcastData(encrypt(JSON.stringify({ type: "typing", from: username, to: currentChat || null })));
+    }
+    lastTypedLine = rl.line || "";
+  }, 1500);
+
+  heartbeatInterval = setInterval(() => {
+    if (username) {
+      broadcastData(encrypt(JSON.stringify({ type: "heartbeat", from: username })));
+    }
+  }, 3000); // 3 seconds heartbeat for WebSocket liveness
+
+  pruneInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [user, time] of lastSeen.entries()) {
+      if (now - time > 15000) {
+        knownUsers.delete(user);
+        lastSeen.delete(user);
+        incomingRPS.delete(user);
+        pendingRPS.delete(user);
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        console.log(`🔴 [${getUserEmoji(user)} ${user}] se ha desconectado.`);
+        updatePrompt();
+      }
+    }
+  }, 5000);
+}
+
+module.exports = { startChat };

package/src/games/rps.js

@@ -0,0 +1,56 @@
+const readline = require("readline");
+
+function startRPS(onExit) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.clear();
+  console.log("=====================================");
+  console.log("   🎮 PIEDRA, PAPEL O TIJERA 🎮");
+  console.log("=====================================");
+  console.log("Escribe 'piedra', 'papel' o 'tijera' para jugar.");
+  console.log("Escribe 'salir' para volver al menú principal.");
+  console.log("=====================================");
+
+  const options = ["piedra", "papel", "tijera"];
+
+  function play() {
+    rl.question("\nTu jugada: ", (answer) => {
+      const userChoice = answer.trim().toLowerCase();
+      
+      if (userChoice === "salir" || userChoice === "/exit") {
+        rl.close();
+        if (onExit) onExit();
+        return;
+      }
+
+      if (!options.includes(userChoice)) {
+        console.log("❌ Opción inválida. Usa: piedra, papel, tijera o salir.");
+        return play();
+      }
+
+      const botChoice = options[Math.floor(Math.random() * options.length)];
+      console.log(`🤖 La IA eligió: ${botChoice}`);
+
+      if (userChoice === botChoice) {
+        console.log("😐 ¡Es un empate!");
+      } else if (
+        (userChoice === "piedra" && botChoice === "tijera") ||
+        (userChoice === "papel" && botChoice === "piedra") ||
+        (userChoice === "tijera" && botChoice === "papel")
+      ) {
+        console.log("🎉 ¡Ganaste!");
+      } else {
+        console.log("💀 ¡Perdiste!");
+      }
+
+      play();
+    });
+  }
+
+  play();
+}
+
+module.exports = { startRPS };

package/src/index.js

@@ -0,0 +1,48 @@
+const readline = require("readline");
+const { startChat } = require("./chat/index.js");
+const { startRPS } = require("./games/rps.js");
+
+function showMenu() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.clear();
+  console.log("=====================================");
+  console.log("   🚀 MULTI-HERRAMIENTA CLI 🚀");
+  console.log("=====================================");
+  console.log("1. Entrar al Chat P2P (Red Local/UDP)");
+  console.log("2. Entrar al Chat Global (Cloudflare/WS)");
+  console.log("3. Jugar Piedra, Papel o Tijera (Local)");
+  console.log("4. Salir");
+  console.log("=====================================");
+  
+  rl.question("Elige una opción: ", (opcion) => {
+    const choice = opcion.trim();
+    rl.close(); // Cerramos esta instancia para que las apps usen las suyas
+    
+    switch(choice) {
+      case "1":
+        startChat(showMenu, "udp");
+        break;
+      case "2":
+        startChat(showMenu, "cloud");
+        break;
+      case "3":
+        startRPS(showMenu);
+        break;
+      case "4":
+        console.log("👋 ¡Hasta luego!");
+        process.exit(0);
+        break;
+      default:
+        console.log("❌ Opción inválida.");
+        setTimeout(showMenu, 1000);
+        break;
+    }
+  });
+}
+
+// Iniciar aplicación
+showMenu();

package/src/server/index.js

@@ -0,0 +1,262 @@
+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" }
+
+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`;
+}
+
+function broadcast(msg, ignoreWs = null) {
+   for (const [s, data] of sessions.entries()) {
+      if (s !== ignoreWs && s.readyState === WebSocket.OPEN && data.name) {
+         try { s.send(msg); } catch (e) { }
+      }
+   }
+}
+
+function sendToTarget(name, msg) {
+   for (const [s, data] of sessions.entries()) {
+      if (data.name === name && s.readyState === WebSocket.OPEN) {
+         try { s.send(msg); } catch (e) { }
+      }
+   }
+}
+
+function targetExists(name) {
+   for (const data of sessions.values()) if (data.name === name) 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) 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;
+
+      if (text === "/help") {
+         server.send(`\n──────────── 💡 COMANDOS MÁGICOS ────────────
+ 👥 /users           → Ver conectados
+ 🪙 /flip            → Lanzar moneda (Animado)
+ 🎮 /rps <usr> <j>   → Piedra-Papel-Tijera
+ 🌟 /blink <msj>     → Mensaje parpadeante
+ 🔒 /w <usr> <msj>   → Mensaje privado
+ 🏪 /tiendita        → Animación ASCII Sorpresa
+ ℹ️  /help           → Esta ayuda
+─────────────────────────────────────────────\n`);
+         return;
+      }
+
+      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;
+      }
+
+      // Indicador de "Escribiendo" Exclusivo para Smart Clients
+      if (text === "/typ") {
+         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) {}
+            }
+         }
+         return; // No lo procesamos más, es invisible
+      }
+
+      // Mensajes Privados
+      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`);
+         return;
+      }
+
+      // Moneda Animada de 3 Segundos
+      if (text === "/flip") {
+         server.send(`\n[${getTime()}] 🪙  Alistando la moneda...`);
+         broadcast(`\n[${getTime()}] 🪙  [${myEmoji} ${myName}] prepara un lanzamiento de moneda...\n`, server);
+
+         let count = 3;
+         const timer = setInterval(() => {
+            if (count > 0) {
+               const countMsg = `   ⏳ Girando en el aire... ${count}s`;
+               server.send(countMsg);
+               broadcast(countMsg, server);
+               count--;
+            } 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`;
+               server.send(renderMsg);
+               broadcast(renderMsg, server);
+            }
+         }, 1000);
+         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;
+      }
+
+      if (text.startsWith("/")) {
+         server.send("❌ Desconocido. Usa /help");
+         return;
+      }
+
+      // Chat
+      const msg = `\n[${getTime()}] 🌍 [${myEmoji} ${myName}]: ${text}`;
+      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);
+      }
+   });
+
+   server.on("error", () => {
+      sessions.delete(server);
+   });
+});
+
+console.log(`📡 Servidor WebSocket de Node corriendo en puerto ${PORT}`);

package/src/server/worker.js

@@ -0,0 +1,164 @@
+const sessions = new Map(); // socket -> { name: string }
+const pendingRPS = new Map(); // targetName -> { from: name, miJugada: "piedra" }
+
+const userEmojis = ["🐶", "🐱", "🐭", "🐹", "🐰", "🦊", "🐻", "🐼", "🐨", "🐯", "🦁", "🐮", "🐷", "🐸", "🐵", "🦄", "🐙", "🦋", "🦖", "🐧", "🦉", "👽", "🤖", "👻", "🥑", "🍕"];
+
+function getUserEmoji(name) {
+  if (!name) return "👤";
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) hash = name.charCodeAt(i) + ((hash << 5) - hash);
+  const index = Math.abs(hash) % userEmojis.length;
+  return userEmojis[index];
+}
+
+function broadcast(msg, ignoreWs = null) {
+  for (const [s, data] of sessions.entries()) {
+    if (s !== ignoreWs && data.name) { 
+       try { s.send(msg); } catch(e) {}
+    }
+  }
+}
+
+function sendToTarget(name, msg) {
+  for (const [s, data] of sessions.entries()) {
+    if (data.name === name) {
+       try { s.send(msg); } catch(e) {}
+    }
+  }
+}
+
+export default {
+  async fetch(request, env) {
+    const upgradeHeader = request.headers.get('Upgrade');
+    if (!upgradeHeader || upgradeHeader !== 'websocket') {
+      return new Response('Expected Upgrade: websocket.', { status: 426 });
+    }
+
+    const webSocketPair = new WebSocketPair();
+    const [client, server] = Object.values(webSocketPair);
+    
+    server.accept();
+    sessions.set(server, { name: null });
+
+    server.send("\x1b[36m====================================\x1b[0m\n   🚀 BIENVENIDO A LA NUBE CLOUDFLARE 🚀\n\x1b[36m====================================\x1b[0m");
+    server.send("🤖 Sistema: Por favor, danos tu nombre. (escribe \x1b[33m/name TuNombre\x1b[0m para entrar):");
+
+    server.addEventListener('message', event => {
+      const socketData = sessions.get(server);
+      let text = event.data;
+      if (typeof text !== 'string') text = text.toString();
+      text = text.trim();
+
+      if (!socketData.name) {
+        if (text.startsWith("/name ")) {
+          const desiredName = text.replace("/name ", "").trim();
+          let alreadyExists = false;
+          for (const d of sessions.values()) if (d.name === desiredName) alreadyExists = true;
+          
+          if (alreadyExists) {
+             server.send("❌ Ese nombre ya está en uso. Usa /name con otro.");
+          } else {
+             socketData.name = desiredName;
+             server.send(`✅ ¡Hola ${desiredName}! Acabas de entrar. Usa /help para ver tus comandos.`);
+             broadcast(`\n🟢 [\x1b[32m${getUserEmoji(desiredName)} ${desiredName}\x1b[0m] ha entrado a la sala.\n`, server);
+          }
+        } else {
+          server.send("⚠️ Aún no tienes nombre registrado. Escribe: /name Usuario");
+        }
+        return;
+      }
+
+      const myName = socketData.name;
+      const myEmoji = getUserEmoji(myName);
+
+      if (text === "/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") {
+         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") {
+         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
+         broadcast(msg, server); 
+         return;
+      }
+
+      if (text.startsWith("/blink ")) {
+         const blnkText = text.replace("/blink ", "").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 ")) {
+         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 (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🕹️ RESULTADO RPS 🕹️\n⚔️ \x1b[36m${target}\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`);
+         }
+         return;
+      }
+
+      if (text.startsWith("/")) {
+         server.send("❌ Comando no reconocido. Usa /help");
+         return;
+      }
+
+      // Comunicación general
+      const msg = `\n🌍 [${myEmoji} ${myName}]: ${text}`;
+      server.send(msg); // <----- ECHO LOCAL AGREGADO PARA QUE LEAS TUS PROPIOS MSJS EN WSCAT
+      broadcast(msg, server);
+    });
+
+    server.addEventListener('close', () => {
+       const u = sessions.get(server);
+       if (u && u.name) broadcast(`\n🔴 [\x1b[31m${getUserEmoji(u.name)} ${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);
+       }
+    });
+
+    server.addEventListener('error', () => {
+       sessions.delete(server);
+    });
+
+    return new Response(null, {
+      status: 101,
+      webSocket: client,
+    });
+  }
+};

package/src/utils/crypto.js

@@ -0,0 +1,17 @@
+const CryptoJS = require("crypto-js");
+const SECRET_KEY = new Date().toISOString().slice(0, 10);
+
+function encrypt(text) {
+  return CryptoJS.AES.encrypt(text, SECRET_KEY).toString();
+}
+
+function decrypt(cipher) {
+  try {
+    const bytes = CryptoJS.AES.decrypt(cipher, SECRET_KEY);
+    return bytes.toString(CryptoJS.enc.Utf8);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { encrypt, decrypt };

package/src/utils/emojis.js

@@ -0,0 +1,13 @@
+const userEmojis = ["🐶", "🐱", "🐭", "🐹", "🐰", "🦊", "🐻", "🐼", "🐨", "🐯", "🦁", "🐮", "🐷", "🐸", "🐵", "🦄", "🐙", "🦋", "🦖", "🐧", "🦉", "👽", "🤖", "👻", "🥑", "🍕"];
+
+function getUserEmoji(name) {
+  if (!name) return "👤";
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = name.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const index = Math.abs(hash) % userEmojis.length;
+  return userEmojis[index];
+}
+
+module.exports = { getUserEmoji };

package/src/utils/network.js

@@ -0,0 +1,10 @@
+const os = require("os");
+
+function getLocalIps() {
+  return Object.values(os.networkInterfaces())
+    .flat()
+    .filter((iface) => iface.family === "IPv4")
+    .map((iface) => iface.address);
+}
+
+module.exports = { getLocalIps };

package/wrangler.toml

@@ -0,0 +1,3 @@
+name = "chat-io"
+main = "src/server/worker.js"
+compatibility_date = "2024-04-07"