Update serveur.js

serveur.js

@@ -1,280 +1,67 @@
-// Name: WebSocket avec Authentification
-// ID: gsaWebsocket
-// Description: Connect to WebSocket servers and handle user file verification with boolean status.
-// By: RedMan13 & Custom Auth
-// License: MIT
-
-(function (Scratch) {
-  "use strict";
-
-  if (!Scratch.extensions.unsandboxed) {
-    throw new Error("can not load outside unsandboxed mode");
-  }
-
-  const blobToDataURL = (blob) =>
-    new Promise((resolve, reject) => {
-      const fr = new FileReader();
-      fr.onload = () => resolve(fr.result);
-      fr.onerror = () =>
-        reject(new Error(`Failed to read as data URL: ${fr.error}`));
-      fr.readAsDataURL(blob);
-    });
-
-  /* ------- BLOCKS -------- */
-  const { BlockType, Cast, ArgumentType } = Scratch;
-  const vm = Scratch.vm;
-  const runtime = vm.runtime;
-
-  class WebSocketExtension {
-    constructor() {
-      /** @type {Record<string, WebSocketInfo>} */
-      this.instances = {};
-
-      runtime.on("targetWasRemoved", (target) => {
-        const instance = this.instances[target.id];
-        if (instance) {
-          instance.destroyed = true;
-          if (instance.websocket) {
-            instance.websocket.close();
-          }
-          delete this.instances[target.id];
-        }
-      });
-    }
-
-    getInfo() {
-      return {
-        id: "gsaWebsocket",
-        name: "WebSocket Auth",
-        color1: "#307eff",
-        color2: "#2c5eb0",
-        blocks: [
-          {
-            opcode: "newInstance",
-            blockType: BlockType.COMMAND,
-            arguments: {
-              URL: {
-                type: ArgumentType.STRING,
-                defaultValue: "wss://ymc3013-user-save.hf.space",
-              },
-            },
-            text: "connect to [URL]",
-          },
-          "---",
-          {
-            opcode: "enregistrerUtilisateur",
-            blockType: BlockType.COMMAND,
-            arguments: {
-              PSEUDO: { type: ArgumentType.STRING, defaultValue: "Scratcher" },
-              EMAIL: { type: ArgumentType.STRING, defaultValue: "exemple@gmail.com" },
-            },
-            text: "enregistrer l'utilisateur avec le pseudo [PSEUDO] et l'email [EMAIL]",
-          },
-          {
-            opcode: "verifierUtilisateur",
-            blockType: BlockType.COMMAND,
-            arguments: {
-              PSEUDO: { type: ArgumentType.STRING, defaultValue: "Scratcher" },
-              EMAIL: { type: ArgumentType.STRING, defaultValue: "exemple@gmail.com" },
-            },
-            text: "vérifier l'utilisateur avec le pseudo [PSEUDO] et l'email [EMAIL]",
-          },
-          "---",
-          // --- LES DEUX NOUVEAUX BLOCS DE STATUT ---
-          {
-            opcode: "estVerificationValide",
-            blockType: BlockType.BOOLEAN,
-            text: "dernière vérification valide ?",
-            disableMonitor: false,
-          },
-          {
-            opcode: "messageVerification",
-            blockType: BlockType.REPORTER,
-            text: "statut de la dernière vérification",
-            disableMonitor: false,
-          },
-          "---",
-          {
-            opcode: "onOpen",
-            blockType: BlockType.EVENT,
-            isEdgeActivated: false,
-            shouldRestartExistingThreads: true,
-            text: "when connected",
-          },
-          {
-            opcode: "isConnected",
-            blockType: BlockType.BOOLEAN,
-            text: "is connected?",
-            disableMonitor: true,
-          },
-          "---",
-          {
-            opcode: "onMessage",
-            blockType: BlockType.EVENT,
-            isEdgeActivated: false,
-            shouldRestartExistingThreads: true,
-            text: "when message received",
-          },
-          {
-            opcode: "messageData",
-            blockType: BlockType.REPORTER,
-            text: "received message data",
-            disableMonitor: true,
-          },
-          "---",
-          {
-            opcode: "closeWithoutReason",
-            blockType: BlockType.COMMAND,
-            text: "close connection",
-          }
-        ],
-      };
-    }
-
-    // --- ENREGISTREMENT ET VÉRIFICATION ---
-
-    enregistrerUtilisateur(args, utils) {
-      const payload = JSON.stringify({
-        type: "enregistrement",
-        pseudo: Cast.toString(args.PSEUDO),
-        email: Cast.toString(args.EMAIL)
-      });
-      this.sendMessage({ PAYLOAD: payload }, utils);
-    }
-
-    verifierUtilisateur(args, utils) {
-      const payload = JSON.stringify({
-        type: "comparer",
-        pseudo: Cast.toString(args.PSEUDO),
-        email: Cast.toString(args.EMAIL)
-      });
-      this.sendMessage({ PAYLOAD: payload }, utils);
-    }
-
-    // --- FONCTIONS DES NOUVEAUX BLOCS BOULÉENS ---
-
-    estVerificationValide(_, utils) {
-      const instance = this.instances[utils.target.id];
-      if (!instance || instance.verificationValide === undefined) return false;
-      return instance.verificationValide; // Renvoie true ou false
-    }
-
-    messageVerification(_, utils) {
-      const instance = this.instances[utils.target.id];
-      if (!instance || !instance.verificationMessage) return "";
-      return instance.verificationMessage; // Renvoie le texte ("Infos correctes", etc.)
-    }
-
-    // --- MOTEUR DE L'EXTENSION ---
-
-    newInstance(args, util) {
-      const target = util.target;
-      let url = Cast.toString(args.URL);
-
-      const oldInstance = this.instances[util.target.id];
-      if (oldInstance) {
-        oldInstance.destroyed = true;
-        if (oldInstance.websocket) oldInstance.websocket.close();
-      }
-
-      const instance = {
-        destroyed: false,
-        errored: false,
-        data: "",
-        websocket: null,
-        messageThreadsRunning: false,
-        connectThreads: [],
-        messageThreads: [],
-        messageQueue: [],
-        sendOnceConnected: [],
-        // Variables pour mémoriser l'état de la connexion utilisateur
-        verificationValide: false,
-        verificationMessage: "Aucune vérification effectuée"
-      };
-      this.instances[util.target.id] = instance;
-
-      return Scratch.canFetch(url)
-        .then((allowed) => new Promise((resolve) => {
-          if (!allowed) throw new Error("Not allowed");
-          const websocket = new WebSocket(url);
-          instance.websocket = websocket;
-
-          const beforeExecute = () => {
-            if (instance.messageThreadsRunning) {
-              const stillRunning = instance.messageThreads.some((i) => runtime.isActiveThread(i));
-              if (!stillRunning) {
-                if (instance.messageQueue.length === 0) {
-                  instance.messageThreadsRunning = false;
-                  instance.messageThreads = [];
-                } else {
-                  instance.data = instance.messageQueue.shift();
-                  instance.messageThreads = runtime.startHats("gsaWebsocket_onMessage", null, target);
-                }
-              }
+const { WebSocketServer } = require('ws');
+const fs = require('fs');
+const path = require('path');
+
+// Utilise le port fourni par Hugging Face (7860) ou 3000 par défaut
+const PORT = process.env.PORT || 7860; 
+const wss = new WebSocketServer({ port: PORT, host: '0.0.0.0' });
+
+// Dossier où stocker les utilisateurs
+const DOSSIER_USER = path.join(__dirname, 'user');
+
+// Crée le dossier 'user' s'il n'existe pas encore
+if (!fs.existsSync(DOSSIER_USER)) {
+    fs.mkdirSync(DOSSIER_USER);
+}
+
+console.log("=== SERVEUR DE CHAT PRIVÉ EN COURS D'EXÉCUTION ===");
+console.log(`En attente de connexions sur le port ${PORT} ...\n`);
+
+wss.on('connection', (ws) => {
+    console.log("[CONNEXION] Un utilisateur a rejoint le serveur.");
+
+    ws.on('message', (message) => {
+        const texteRecu = message.toString();
+
+        // 1. Tenter de lire le message comme une action d'inscription/connexion (JSON)
+        try {
+            const donnees = JSON.parse(texteRecu);
+
+            // Si le message contient un type "enregistrement", un email et un pseudo
+            if (donnees.type === "enregistrement" && donnees.email && donnees.pseudo) {
+                
+                // Préparation du contenu du fichier demandé : pseudo et email
+                const contenuFichier = `pseudo: ${donnees.pseudo}\nemail: ${donnees.email}`;
+                
+                // Sécurisation du nom de fichier pour éviter les caractères interdits
+                const nomFichier = `${donnees.email.replace(/[^a-zA-Z0-9@.]/g, "_")}.txt`;
+                const cheminFichier = path.join(DOSSIER_USER, nomFichier);
+
+                // Écriture (ou écrasement) du fichier utilisateur
+                fs.writeFileSync(cheminFichier, contenuFichier, 'utf8');
+                console.log(`[USER] Utilisateur enregistré dans : ${nomFichier}`);
+                
+                // Envoi d'une confirmation à TurboWarp
+                ws.send(JSON.stringify({ statut: "succes", message: "Utilisateur enregistré !" }));
+                return; // On s'arrête ici pour ce message, pas besoin de l'envoyer sur le chat
             }
-          };
-
-          vm.runtime.on("BEFORE_EXECUTE", beforeExecute);
-          websocket.onopen = () => {
-            for (const item of instance.sendOnceConnected) websocket.send(item);
-            instance.sendOnceConnected.length = 0;
-            instance.connectThreads = runtime.startHats("gsaWebsocket_onOpen", null, target);
-            resolve();
-          };
-
-          websocket.onmessage = async (e) => {
-            if (instance.destroyed) return;
-            let data = e.data;
-            if (data instanceof Blob) data = await blobToDataURL(data);
+        } catch (e) {
+            // Si ce n'est pas du JSON (ou qu'il manque des données), le serveur ignore l'erreur
+            // et passe directement à la suite (le code du chat normal)
+        }
 
-            // --- INTERCEPTION DE LA RÉPONSE DE VÉRIFICATION ---
-            try {
-              const json = JSON.parse(data);
-              if (json.type === "reponse_comparer") {
-                instance.verificationValide = json.valide; // true ou false
-                instance.verificationMessage = json.message; // Le message texte
-              }
-            } catch (err) {}
+        // --- TON CODE DE CHAT CLASSIQUE ---
+        console.log(`[MESSAGE CHAT] : ${texteRecu}`);
 
-            if (instance.messageThreadsRunning) {
-              instance.messageQueue.push(data);
-            } else {
-              instance.data = data;
-              instance.messageThreads = runtime.startHats("gsaWebsocket_onMessage", null, target);
-              instance.messageThreadsRunning = true;
+        // Renvoie le message reçu à tout le monde
+        wss.clients.forEach((client) => {
+            if (client.readyState === 1) {
+                client.send(texteRecu);
             }
-          };
-        }));
-    }
-
-    isConnected(_, utils) {
-      const instance = this.instances[utils.target.id];
-      return !!instance && !!instance.websocket && instance.websocket.readyState === WebSocket.OPEN;
-    }
-
-    messageData(_, utils) {
-      const instance = this.instances[utils.target.id];
-      return instance ? instance.data : "";
-    }
-
-    sendMessage(args, utils) {
-      const PAYLOAD = Cast.toString(args.PAYLOAD);
-      const instance = this.instances[utils.target.id];
-      if (!instance) return;
-      if (!instance.websocket || instance.websocket.readyState === WebSocket.CONNECTING) {
-        instance.sendOnceConnected.push(PAYLOAD);
-      } else {
-        instance.websocket.send(PAYLOAD);
-      }
-    }
-
-    closeWithoutReason(_, utils) {
-      const instance = this.instances[utils.target.id];
-      if (!instance) return;
-      instance.destroyed = true;
-      if (instance.websocket) instance.websocket.close();
-    }
-  }
+        });
+    });
 
-  Scratch.extensions.register(new WebSocketExtension());
-})(Scratch);
+    ws.on('close', () => {
+        console.log("[DÉCONNEXION] Un utilisateur a quitté le chat.");
+    });
+});