From ff851ed35f51d6c19d4e21cc6729df36338ce596 Mon Sep 17 00:00:00 2001
From: Louis Mazin <mazinlouis79@gmail.com>
Date: Tue, 9 Dec 2025 13:27:43 +0100
Subject: [PATCH] test

---
 consoleMonitor.js | 63 +++++++++++++++++++++++++----------------------
 index.js          |  9 ++++---
 2 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/consoleMonitor.js b/consoleMonitor.js
index 5326def..3c24c57 100644
--- a/consoleMonitor.js
+++ b/consoleMonitor.js
@@ -8,6 +8,7 @@ let client = null;
 let heartbeatInterval = null;
 let checkInterval = null;
 let isMonitoring = false;
+let isConnecting = false;
 
 const parseLogMessage = (log) => {
     // Format réel de log Palworld:
@@ -118,21 +119,18 @@ const checkAndManageWebSocket = async () => {
     const { hasActiveLinkCodes, cleanExpiredCodes } = require('./database.js');
     
     try {
-        // Nettoyer les codes expirés
         await cleanExpiredCodes();
         
         const hasActiveCodes = await hasActiveLinkCodes();
         
-        if (hasActiveCodes && !ws) {
-            // Il y a des codes actifs mais pas de connexion WebSocket
+        if (hasActiveCodes && !ws && !isConnecting) {
             console.log('🔌 Codes de liaison actifs détectés, connexion au WebSocket...');
             const serverId = process.env.PTERODACTYL_SERVER_ID;
             const pterodactylToken = process.env.PTERODACTYL_API_TOKEN;
             await connectWebSocket(pterodactylToken, serverId);
         } else if (!hasActiveCodes && ws) {
-            // Pas de codes actifs mais WebSocket connecté
             console.log('🔌 Aucun code actif, fermeture du WebSocket...');
-            stopConsoleMonitoring();
+            stopWebSocketOnly();
         }
     } catch (error) {
         console.error('Erreur lors de la vérification des codes actifs:', error);
@@ -140,12 +138,18 @@ const checkAndManageWebSocket = async () => {
 };
 
 const connectWebSocket = async (pterodactylToken, serverId) => {
-    // Éviter les connexions multiples
-    if (ws && ws.readyState === WebSocket.OPEN) {
-        console.log('⚠️ WebSocket déjà connecté');
+    if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+        console.log('⚠️ WebSocket déjà connecté ou en cours de connexion');
         return;
     }
     
+    if (isConnecting) {
+        console.log('⚠️ Connexion WebSocket déjà en cours');
+        return;
+    }
+    
+    isConnecting = true;
+    
     try {
         const credentials = await getWebSocketCredentials(pterodactylToken, serverId);
         
@@ -155,8 +159,8 @@ const connectWebSocket = async (pterodactylToken, serverId) => {
         
         ws.on('open', () => {
             console.log('✅ WebSocket Pterodactyl connecté');
+            isConnecting = false;
             
-            // Authentification selon la documentation
             ws.send(JSON.stringify({
                 event: 'auth',
                 args: [credentials.token]
@@ -167,17 +171,14 @@ const connectWebSocket = async (pterodactylToken, serverId) => {
             try {
                 const message = JSON.parse(data.toString());
                 
-                // Gérer l'événement d'authentification réussie
                 if (message.event === 'auth success') {
                     console.log('✅ Authentification WebSocket réussie');
                     
-                    // S'abonner aux logs de la console
                     ws.send(JSON.stringify({
                         event: 'send logs',
                         args: [null]
                     }));
                     
-                    // Démarrer le heartbeat (toutes les 30 secondes)
                     if (heartbeatInterval) clearInterval(heartbeatInterval);
                     heartbeatInterval = setInterval(() => {
                         if (ws && ws.readyState === WebSocket.OPEN) {
@@ -189,7 +190,6 @@ const connectWebSocket = async (pterodactylToken, serverId) => {
                     }, 30000);
                 }
                 
-                // Gérer les logs de la console
                 if (message.event === 'console output') {
                     const log = message.args[0];
                     
@@ -199,46 +199,59 @@ const connectWebSocket = async (pterodactylToken, serverId) => {
                         
                         if (playerData) {
                             await handleLinkCommand(linkData.playerName, playerData, linkData.code);
-                            await checkAndManageWebSocket();
+                            // Vérifier immédiatement après la liaison
+                            setTimeout(() => checkAndManageWebSocket(), 2000);
                         } else {
                             console.log(`❌ Impossible de trouver le Steam ID pour ${linkData.playerName}`);
                         }
                     }
                 }
                 
-                // Gérer les événements de statut
                 if (message.event === 'status') {
                     console.log('📊 Statut du serveur:', message.args[0]);
                 }
                 
             } catch (error) {
-                // Message non-JSON ou erreur de parsing, on ignore
                 console.error('Erreur parsing message WebSocket:', error);
             }
         });
         
         ws.on('error', (error) => {
             console.error('❌ Erreur WebSocket:', error.message);
+            isConnecting = false;
         });
         
         ws.on('close', (code, reason) => {
             console.log(`⚠️ WebSocket Pterodactyl déconnecté (Code: ${code})`);
             ws = null;
+            isConnecting = false;
             
-            // Arrêter le heartbeat
             if (heartbeatInterval) {
                 clearInterval(heartbeatInterval);
                 heartbeatInterval = null;
             }
-            
-            // Ne pas reconnecter automatiquement, laisser le checkInterval gérer ça
         });
         
     } catch (error) {
         console.error('Erreur lors de la connexion WebSocket:', error);
+        isConnecting = false;
     }
 };
 
+const stopWebSocketOnly = () => {
+    if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+    }
+    
+    if (ws) {
+        ws.close();
+        ws = null;
+    }
+    
+    isConnecting = false;
+};
+
 const startConsoleMonitoring = (discordClient, pterodactylToken) => {
     if (isMonitoring) {
         console.log('⚠️ Surveillance déjà active');
@@ -259,15 +272,12 @@ const startConsoleMonitoring = (discordClient, pterodactylToken) => {
     // Vérifier immédiatement
     checkAndManageWebSocket();
     
-    // Vérifier toutes les 30 secondes s'il faut connecter/déconnecter
+    // Vérifier toutes les 30 secondes
     checkInterval = setInterval(checkAndManageWebSocket, 30000);
 };
 
 const stopConsoleMonitoring = () => {
-    if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-    }
+    stopWebSocketOnly();
     
     if (checkInterval) {
         clearInterval(checkInterval);
@@ -279,11 +289,6 @@ const stopConsoleMonitoring = () => {
         reconnectTimeout = null;
     }
     
-    if (ws) {
-        ws.close();
-        ws = null;
-    }
-    
     isMonitoring = false;
     console.log('🔌 Surveillance de la console arrêtée');
 };
diff --git a/index.js b/index.js
index 80f02a3..9396df9 100644
--- a/index.js
+++ b/index.js
@@ -6,7 +6,7 @@ const deploy = require('./deploy_command.js')
 const update  = require('./displayer.js');
 const clean = require('./cleaner.js');
 const { Client, GatewayIntentBits, Collection, Events, Partials } = require('discord.js');
-const { initDatabase, createTables } = require('./database.js');
+const { initDatabase, createTables, cleanExpiredCodes } = require('./database.js');
 const { startConsoleMonitoring } = require('./consoleMonitor.js');
 
 const client = new Client({ intents:
@@ -52,13 +52,16 @@ client.once('ready', async () => {
   client.user.setPresence({ activities: [{ name: 'Rygain', type: 'WATCHING' }], status: 'online' });
   console.log('Bot started !');
   
-  // Initialiser la base de données (non bloquant)
   try {
     await initDatabase();
     await createTables();
+    
+    // Nettoyer les codes expirés au démarrage
+    await cleanExpiredCodes();
+    console.log('🧹 Codes expirés nettoyés');
+    
     console.log('📦 Système de liaison activé');
     
-    // Démarrer la surveillance de la console seulement si la DB est OK
     startConsoleMonitoring(client, process.env.PTERODACTYL_API_TOKEN);
   } catch (error) {
     console.error('⚠️ Erreur lors de l\'initialisation de la base de données');