@spatulox/simplediscordbot 1.0.1

package/dist/manager/hadlers_old/builder/delete.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rest_1 = require("@discordjs/rest");
+const v10_1 = require("discord-api-types/v10");
+const Log_1 = require("../../../utils/Log");
+const BotEnv_1 = require("../../../bot/BotEnv");
+const Bot_1 = require("../../../bot/Bot");
+async function deleteAllCommandsAndMenus() {
+    const rest = new rest_1.REST({ version: '10' }).setToken(BotEnv_1.BotEnv.token);
+    const guildIDs = ["1111160769132896377", "1214320754578165901"]; // Liste des guildes à vérifier
+    try {
+        // 1. Suppression des commandes/menus globaux
+        Log_1.Log.info('INFO : Suppression des commandes et menus contextuels globaux...');
+        const globalCommands = await rest.get(v10_1.Routes.applicationCommands(Bot_1.Bot.config.clientId));
+        for (const command of globalCommands) {
+            try {
+                await rest.delete(v10_1.Routes.applicationCommand(Bot_1.Bot.config.clientId, command.id));
+                Log_1.Log.info(`Commande/menu contextuel global "${command.name}" supprimé.`);
+            }
+            catch (err) {
+                Log_1.Log.error(`Impossible de supprimer la commande/menu contextuel global "${command.name}" : ${err.message}`);
+            }
+        }
+        // 2. Suppression des commandes/menus spécifiques aux guildes
+        Log_1.Log.info('Suppression des commandes et menus contextuels spécifiques aux guildes...');
+        for (const guildId of guildIDs) {
+            try {
+                const guildCommands = await rest.get(v10_1.Routes.applicationGuildCommands(Bot_1.Bot.config.clientId, guildId));
+                for (const command of guildCommands) {
+                    try {
+                        await rest.delete(v10_1.Routes.applicationGuildCommand(Bot_1.Bot.config.clientId, guildId, command.id));
+                        Log_1.Log.info(`Commande/menu contextuel "${command.name}" supprimé sur la guilde ${guildId}.`);
+                    }
+                    catch (err) {
+                        Log_1.Log.error(`Impossible de supprimer la commande/menu contextuel "${command.name}" sur la guilde ${guildId} : ${err.message}`);
+                    }
+                }
+            }
+            catch (err) {
+                Log_1.Log.error(`Impossible de récupérer ou supprimer les commandes/menus contextuels pour le serveur ${guildId} : ${err.message}`);
+            }
+        }
+        Log_1.Log.info('Toutes les commandes et menus contextuels ont été supprimés.');
+    }
+    catch (err) {
+        Log_1.Log.error(`Impossible de récupérer ou supprimer les commandes/menus contextuels : ${err.message}`);
+    }
+}
+deleteAllCommandsAndMenus();

package/dist/manager/hadlers_old/builder/deploy.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*import { PermissionFlagsBits } from 'discord-api-types/v10';
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v10';
+import { setTimeout } from "timers/promises";
+import { client } from '../utils/client.js';
+import { Time } from '../utils/times/UnitTime.js';
+import { log } from '../utils/log.js';
+import { listJsonFile, readJsonFile, writeJsonFileRework } from '../utils/server/files.js';
+import { loginBot } from '../utils/login.js';
+import config from '../config.js';
+import {Events} from "discord.js";
+
+
+export interface Command {
+    name: string;
+    description: string;
+    options?: any[];
+    default_member_permissions?: string | bigint | number;
+    guildID?: string[];
+    type: 1 | 2 | 3; // 1 = slash, 2 = user context, 3 = message context
+    id?: string; // Discord API Command ID
+}
+
+// Initialisation du REST
+client.rest = new REST({ version: '10' }).setToken(config.token);
+
+export async function deployCommand(commandPath: string[]): Promise<void> {
+    if (!(await loginBot(client))) {
+        log("Erreur : Impossible de connecter le bot");
+        process.exit()
+    }
+
+    client.once(Events.ClientReady, async () => {
+        log('INFO : Déploiement des commandes slash');
+
+        for (const path of commandPath){
+            const slashFiles = await listJsonFile(`./handlers/${path}/`);
+            if (!slashFiles) {
+                log('ERREUR : Impossible de lire les fichiers de commandes');
+                return;
+            }
+            console.log(`${slashFiles.length} ${path}`)
+        }
+        
+        // Récupère toutes les commandes actuelles sur Discord
+        const globalDiscordCmds: any[] = await client.rest.get(
+            Routes.applicationCommands(client.user!.id)
+        ) as any[];
+        
+        const allLocalCommands: Command[] = [];
+        const guildDiscordCmds = {} as Record<string, any[]>;
+        
+        for(const path of commandPath){
+            const slashFiles = await listJsonFile(`./${path}/`);
+            if (!slashFiles) {
+                log('ERREUR : Impossible de lire les fichiers de commandes');
+                return;
+            }
+            
+
+            // Pour chaque guilde utilisée dans tes JSONs
+            const allGuildIds = new Set<string>();
+            for (const filename of slashFiles) {
+                const cmdData = await readJsonFile(`./${path}/${filename}`);
+                if (cmdData?.guildID) {
+                    for (const gid of cmdData.guildID) allGuildIds.add(gid);
+                }
+            }
+
+            for (const guildId of allGuildIds) {
+                try {
+                    guildDiscordCmds[guildId] = await client.rest.get(
+                        Routes.applicationGuildCommands(config.clientId, guildId)
+                    ) as any[];
+                } catch (error) {
+                    console.error()
+                }
+            }
+
+            // ---------------------- Déploiement attendue ---------------------------
+
+            for (const file of slashFiles.filter((n: string | string[])=>!n.includes('example'))) {
+                let updated = false;
+                const cmd: Command | false = await readJsonFile(`./${path}/${file}`);
+                if(!cmd) continue;
+
+                // Traitement permissions
+                if (cmd.default_member_permissions && Array.isArray(cmd.default_member_permissions)) {
+                    const bitfield = cmd.default_member_permissions
+                        .map(perm => {
+                            const flag = PermissionFlagsBits[perm as keyof typeof PermissionFlagsBits];
+                            if (flag === undefined) throw new Error(`Permission inconnue : "${perm}"`);
+                            return flag;
+                        })
+                        .reduce((acc, val) => acc | val, BigInt(0));
+                    cmd.default_member_permissions = Number(bitfield)
+                }
+
+                // Déploiement Guild vs Global
+                const deployToGuilds = (cmd.guildID && cmd.guildID.length > 0) ? cmd.guildID : [];
+                if (deployToGuilds.length > 0) {
+                    for (const guildId of deployToGuilds) {
+                        // Cherche la commande existante sur Discord
+                        const found = guildDiscordCmds[guildId]?.find(e => e.id === cmd.id || e.name === cmd.name);
+                        const dataToSend = { ...cmd };
+                        delete dataToSend.guildID;
+
+                        if (cmd.type === 2 || cmd.type === 3) {
+                            // Les context menus ne doivent **pas** utiliser `options`
+                            console.log("on delete options")
+                            delete dataToSend.options;
+                        }
+
+                        try {
+                            if (!cmd.id || !found) {
+                                // Pas d'ID ou pas trouvée, on crée la commande
+                                console.log("Pas d'ID ou pas trouvée, on crée la commande : " + dataToSend.name)
+                                const resp = await client.rest.post(
+                                    Routes.applicationGuildCommands(config.clientId, guildId),
+                                    { body: dataToSend }
+                                ) as any;
+                                cmd.id = resp.id;
+                                updated = true;
+                                log(`SUCCÈS : Commande "${cmd.name}" déployée/guild ${guildId}, id = ${cmd.id}`);
+                            } else {
+                                // Si déjà existante, on la met à jour
+                                console.log("Si déjà existante, on la met à jour : " + dataToSend.name)
+                                await client.rest.patch(
+                                    Routes.applicationGuildCommand(config.clientId, guildId, found.id),
+                                    { body: dataToSend }
+                                );
+                                cmd.id = found.id;
+                                log(`MAJ : Commande "${cmd.name}" mise à jour/guild ${guildId}, id = ${cmd.id}`);
+                            }
+                            await setTimeout(Time.second.SEC_01.toMilliseconds());
+                        } catch (error) {
+                            console.log(error)
+                        }
+                    }
+                } else {
+                    // Commande globale
+                    const found = globalDiscordCmds.find(e => e.id === cmd.id || e.name === cmd.name);
+                    const dataToSend = { ...cmd };
+                    delete dataToSend.guildID;
+                    if (cmd.type === 2 || cmd.type === 3) {
+                        // Les context menus ne doivent **pas** utiliser `options`
+                        delete dataToSend.options;
+                    }
+
+                    try {
+                        if (!cmd.id || !found) {
+                            const resp = await client.rest.post(
+                                Routes.applicationCommands(client.user!.id),
+                                { body: dataToSend }
+                            ) as any;
+                            cmd.id = resp.id;
+                            updated = true;
+                            log(`SUCCÈS : Commande globale "${cmd.name}" déployée, id = ${cmd.id}`);
+                        } else {
+                            await client.rest.patch(
+                                Routes.applicationCommand(client.user!.id, found.id),
+                                { body: dataToSend }
+                            );
+                            cmd.id = found.id;
+                            log(`MAJ : Commande globale "${cmd.name}" mise à jour, id = ${cmd.id}`);
+                        }
+                    } catch (error) {
+                        console.log(error)
+                    }
+                }
+                //if (updated) await writeJsonFileRework(`./${path}/`, `${file}`, cmd); // Sauvegarde l'id Discord
+                if (updated) {
+                    allLocalCommands.push(cmd); // Ajoute ici la version à jour de la commande
+                    await writeJsonFileRework(`./${path}/`, `${file}`, cmd);
+                } else {
+                    allLocalCommands.push(cmd); // Même si elle n’a pas été modifiée, on veut la conserver
+                }
+
+            }
+
+        }
+
+        // ---------------------- SUPPRESSION COMMANDES ---------------------------
+
+        const localNames = allLocalCommands.map(c => c.name); // Regroupe toutes les commandes locales
+
+        // Supprime les commandes globales non déclarées
+        for (const apiCmd of globalDiscordCmds) {
+            try {
+                if (!localNames.includes(apiCmd.name)) {
+                    await client.rest.delete(
+                        Routes.applicationCommand(client.user!.id, apiCmd.id)
+                    );
+                    log(`SUPPR : Commande globale "${apiCmd.name}" supprimée, id = ${apiCmd.id}`);
+                }
+            } catch (error) {
+                console.log(error);
+            }
+        }
+
+        // Supprime les commandes guild non déclarées
+        for (const gid of Object.keys(guildDiscordCmds)) {
+            const current = guildDiscordCmds[gid];
+            if (!current) continue;
+            for (const apiCmd of current) {
+                try {
+                    if (!localNames.includes(apiCmd.name)) {
+                        await client.rest.delete(
+                            Routes.applicationGuildCommand(config.clientId, gid, apiCmd.id)
+                        );
+                        log(`SUPPR : Commande "${apiCmd.name}" supprimée de guild ${gid}`);
+                    }
+                } catch (error) {
+                    console.log(error);
+                }
+            }
+        }
+
+        process.exit();
+    });
+}
+
+deployCommand(["context_menu", "commands"]);*/ 

package/dist/manager/hadlers_old/builder/interactions/CommandManager.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandManager = void 0;
+// src/discord/CommandManager.ts
+const InteractionBase_1 = require("./InteractionBase");
+class CommandManager extends InteractionBase_1.InteractionBase {
+    get name() {
+        return "📋 SLASH COMMAND MANAGER";
+    }
+    get interactionHandlerFolder() {
+        return "commands";
+    }
+}
+exports.CommandManager = CommandManager;

package/dist/manager/hadlers_old/builder/interactions/ContextMenuManager.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMenuManager = void 0;
+// src/discord/ContextMenuManager.ts
+const InteractionBase_1 = require("./InteractionBase");
+class ContextMenuManager extends InteractionBase_1.InteractionBase {
+    get name() {
+        return `📋 CONTEXT MENU MANAGER`;
+    }
+    get interactionHandlerFolder() {
+        return "context_menu";
+    }
+}
+exports.ContextMenuManager = ContextMenuManager;

package/dist/manager/hadlers_old/builder/interactions/InteractionBase.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionBase = void 0;
+const discord_js_1 = require("discord.js");
+const readline_1 = __importDefault(require("readline"));
+const FileManager_1 = require("../../../FileManager");
+const Bot_1 = require("../../../../bot/Bot");
+const BotEnv_1 = require("../../../../bot/BotEnv");
+const Log_1 = require("../../../../utils/Log");
+class InteractionBase {
+    constructor() {
+        this.currentState = 'menu';
+        this.deployFiles = [];
+        this.rest = new discord_js_1.REST({ version: '10' }).setToken(BotEnv_1.BotEnv.token);
+        this.rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+    /** 🚀 START INTERACTIF (100% automatique) */
+    async startInteractive() {
+        Log_1.Log.info('================================');
+        console.clear();
+        Log_1.Log.info(`${this.name}`);
+        await this.showMenu();
+        this.rl.prompt();
+        this.rl.on('line', async (input) => {
+            await this.handleInput(input.trim().toLowerCase());
+        });
+        this.rl.on('close', () => {
+            Log_1.Log.info('👋 Au revoir !');
+            process.exit(0);
+        });
+    }
+    /** 🎛️ SINGLE INPUT HANDLER */
+    async handleInput(input) {
+        switch (this.currentState) {
+            case 'menu':
+                await this.handleMenuInput(input);
+                break;
+            case 'deploy_select':
+                await this.handleDeploySelect(input);
+                break;
+            case 'delete_name':
+                await this.handleDeleteName(input);
+                break;
+            case 'delete_all_confirm':
+                await this.handleDeleteAllConfirm(input);
+                break;
+        }
+        this.rl?.prompt();
+    }
+    /** 🎛️ MENU PRINCIPAL */
+    async handleMenuInput(input) {
+        const [action, arg] = input.split(' ');
+        switch (action) {
+            case 'deploy':
+                await this.startDeployInteractive();
+                break;
+            case 'deploy-all':
+                await this.deployAll();
+                break;
+            case 'list':
+                await this.listAll();
+                break;
+            case 'list-guild':
+                await this.listGuild(arg || '');
+                break;
+            case 'delete':
+                this.startDeleteInteractive();
+                break;
+            case 'delete-all':
+                this.startDeleteAllConfirm();
+                break;
+            case 'help':
+                await this.showMenu();
+                break;
+            case 'exit':
+                this.rl?.close();
+                break;
+            default:
+                Log_1.Log.error('❌ Commande inconnue. Tapez "help"');
+        }
+    }
+    /** 📁 START DEPLOY INTERACTIF */
+    async startDeployInteractive() {
+        const files = await FileManager_1.FileManager.listJsonFiles(`./handlers/${this.interactionHandlerFolder}`);
+        if (!files) {
+            Log_1.Log.error("Files not found!");
+            return;
+        }
+        this.deployFiles = files;
+        if (!this.deployFiles || this.deployFiles.length <= 0) {
+            Log_1.Log.error("Files not found");
+            return;
+        }
+        console.log(`\n📁 ${this.name} (${this.deployFiles.length} fichiers):`);
+        console.log('  0. ALL → Tout déployer');
+        this.deployFiles.forEach((file, index) => {
+            console.log(`  ${index + 1}. ${file.replace('.json', '')}`);
+        });
+        console.log('');
+        this.currentState = 'deploy_select';
+        console.log('Choisir (numéro ou 0 pour tout): ');
+    }
+    /** 🔢 HANDLE DEPLOY CHOICE */
+    async handleDeploySelect(input) {
+        const num = parseInt(input);
+        if (isNaN(num)) {
+            Log_1.Log.error("❌ Numéro invalide");
+            this.currentState = 'menu';
+            await this.showMenu();
+            return;
+        }
+        if (num === 0) {
+            await this.deployAll();
+        }
+        else if (num > 0 && num <= this.deployFiles.length) {
+            const selectedFile = this.deployFiles[num - 1];
+            Log_1.Log.info(`🚀 Déploiement ${selectedFile}...`);
+            const cmd = await FileManager_1.FileManager.readJsonFile(`./handlers/${this.interactionHandlerFolder}/${selectedFile}`);
+            if (cmd) {
+                const processed = await this.processPermissions(cmd);
+                const globalCmds = await this.getGlobalCommands();
+                await this.deploySingle(processed);
+                await this.cleanup(globalCmds, [processed]);
+            }
+        }
+        else {
+            Log_1.Log.error(`❌ Choix ${num} invalide (1-${this.deployFiles.length} ou 0)`);
+            this.currentState = 'menu';
+            await this.showMenu();
+            return;
+        }
+        this.currentState = 'menu';
+        await this.showMenu();
+    }
+    /** 🗑️ START DELETE INTERACTIF */
+    startDeleteInteractive() {
+        console.log('\nNom de la commande: ');
+        this.currentState = 'delete_name';
+    }
+    /** 🗑️ HANDLE DELETE NAME */
+    async handleDeleteName(input) {
+        await this.deleteCommand(input);
+        this.currentState = 'menu';
+        await this.showMenu();
+    }
+    /** 💥 START DELETE ALL CONFIRM */
+    startDeleteAllConfirm() {
+        console.log('\n⚠️ SUPPRIMER TOUT ? (yes/no): ');
+        this.currentState = 'delete_all_confirm';
+    }
+    /** 💥 HANDLE DELETE ALL CONFIRM */
+    async handleDeleteAllConfirm(input) {
+        if (input.toLowerCase() === 'yes') {
+            await this.deleteAllCommands();
+        }
+        this.currentState = 'menu';
+        await this.showMenu();
+    }
+    /** 🚀 DÉPLOIER TOUT */
+    async deployAll() {
+        Log_1.Log.info(`🚀 Déploiement ${this.name}...`);
+        await this.deployCommands([this.interactionHandlerFolder]);
+        this.currentState = 'menu';
+        await this.showMenu();
+    }
+    /** 📦 DÉPLOIEMENT BATCH */
+    async deployCommands(paths) {
+        const globalCmds = await this.getGlobalCommands();
+        const localCommands = [];
+        for (const path of paths) {
+            const files = await FileManager_1.FileManager.listJsonFiles(`./handlers/${path}`);
+            if (files == false || files.length <= 0) {
+                Log_1.Log.error(`Aucun fichier dans ${path}`);
+                return;
+            }
+            for (const file of files.filter(f => !f.includes('example'))) {
+                const cmd = await FileManager_1.FileManager.readJsonFile(`./handlers/${path}/${file}`);
+                if (!cmd)
+                    continue;
+                const processed = await this.processPermissions(cmd);
+                localCommands.push(processed);
+                await this.deploySingle(processed);
+                await this.delay(100);
+            }
+        }
+        await this.cleanup(globalCmds, localCommands);
+    }
+    /** ⚡ DÉPLOYER UNE SEULE */
+    async deploySingle(cmd) {
+        const data = { ...cmd, guildID: undefined };
+        if (cmd.type === 2 || cmd.type === 3)
+            delete data.options;
+        try {
+            if (cmd.guildID?.length) {
+                for (const guildId of cmd.guildID) {
+                    const guildCmds = await this.getGuildCommands(guildId);
+                    const existing = guildCmds.find(c => c.name === cmd.name && c.type === cmd.type);
+                    if (existing) {
+                        await this.rest.patch(discord_js_1.Routes.applicationGuildCommand(Bot_1.Bot.config.clientId, guildId, existing.id), { body: data });
+                        Log_1.Log.info(`🔄 MAJ ${cmd.name} → ${guildId.slice(-4)}`);
+                    }
+                    else {
+                        await this.rest.post(discord_js_1.Routes.applicationGuildCommands(Bot_1.Bot.config.clientId, guildId), { body: data });
+                        Log_1.Log.info(`✅ NEW ${cmd.name} → ${guildId.slice(-4)}`);
+                    }
+                }
+            }
+            else {
+                const globalCmds = await this.getGlobalCommands();
+                const existing = globalCmds.find(c => c.name === cmd.name && c.type === cmd.type);
+                if (existing) {
+                    await this.rest.patch(discord_js_1.Routes.applicationCommand(Bot_1.Bot.config.clientId, existing.id), { body: data });
+                    Log_1.Log.info(`🔄 MAJ ${cmd.name} → GLOBAL`);
+                }
+                else {
+                    await this.rest.post(discord_js_1.Routes.applicationCommands(Bot_1.Bot.config.clientId), { body: data });
+                    Log_1.Log.info(`✅ NEW ${cmd.name} → GLOBAL`);
+                }
+            }
+        }
+        catch (error) {
+            Log_1.Log.error(`❌ ${cmd.name}: ${error}`);
+        }
+    }
+    /** 📊 LISTE TOUT */
+    async listAll() {
+        const globalCmds = await this.getGlobalCommands();
+        Log_1.Log.table([{ Type: `${this.name} GLOBAL`, Nombre: globalCmds.length }]);
+        this.currentState = 'menu';
+        await this.showMenu();
+    }
+    /** 📊 LISTE GUILDE */
+    async listGuild(guildId) {
+        if (!guildId) {
+            Log_1.Log.error('ID guilde requis');
+            this.currentState = 'menu';
+            await this.showMenu();
+            return;
+        }
+        const guildCmds = await this.getGuildCommands(guildId);
+        Log_1.Log.table([{ Guilde: guildId.slice(-8), [`${this.name}`]: guildCmds.length }]);
+        this.currentState = 'menu';
+        await this.showMenu();
+    }
+    /** 📋 MENU PRINCIPAL */
+    async showMenu() {
+        console.log(`\n${this.name}:`);
+        console.log('  deploy         → Déployer spécifique');
+        console.log('  deploy-all     → Tout déployer/MAJ');
+        console.log('  list           → Lister toutes');
+        console.log('  list-guild <id> → Lister guilde');
+        console.log('  delete         → Supprimer une');
+        console.log('  delete-all     → Tout supprimer');
+        console.log('  help           → Cette aide');
+        console.log('  exit           → Quitter\n');
+    }
+    // ... [Toutes les autres méthodes restent EXACTEMENT identiques] ...
+    /** ⏱️ DELAY */
+    async delay(ms) {
+        return new Promise(r => setTimeout(r, ms));
+    }
+    /** 🌍 GLOBAL CMDS */
+    async getGlobalCommands() {
+        return this.rest.get(discord_js_1.Routes.applicationCommands(Bot_1.Bot.config.clientId));
+    }
+    /** 🏛️ GUILD CMDS */
+    async getGuildCommands(guildId) {
+        return this.rest.get(discord_js_1.Routes.applicationGuildCommands(Bot_1.Bot.config.clientId, guildId));
+    }
+    /** 🔐 PERMISSIONS */
+    async processPermissions(cmd) {
+        const processed = { ...cmd };
+        if (cmd.default_member_permissions && Array.isArray(cmd.default_member_permissions)) {
+            const bitfield = cmd.default_member_permissions
+                .map(perm => BigInt(discord_js_1.PermissionFlagsBits[perm] || 0))
+                .reduce((acc, val) => acc | val, BigInt(0));
+            processed.default_member_permissions = Number(bitfield);
+        }
+        return processed;
+    }
+    /** 🗑️ DELETE UNE COMMANDE */
+    async deleteCommand(name) {
+        const globalCmds = await this.getGlobalCommands();
+        const globalMatch = globalCmds.find(c => c.name === name);
+        if (globalMatch) {
+            await this.rest.delete(discord_js_1.Routes.applicationCommand(Bot_1.Bot.config.clientId, globalMatch.id));
+            Log_1.Log.info(`✅ SUPPR GLOBAL ${name}`);
+        }
+        const botGuilds = Bot_1.Bot.client.guilds.cache.map(g => g.id);
+        for (const guildId of botGuilds) {
+            try {
+                const guildCmds = await this.getGuildCommands(guildId);
+                const guildMatch = guildCmds.find(c => c.name === name);
+                if (guildMatch) {
+                    await this.rest.delete(discord_js_1.Routes.applicationGuildCommand(Bot_1.Bot.config.clientId, guildId, guildMatch.id));
+                    Log_1.Log.info(`✅ SUPPR ${name} → ${guildId.slice(-4)}`);
+                }
+            }
+            catch {
+            }
+        }
+    }
+    /** 💥 DELETE TOUS */
+    async deleteAllCommands() {
+        const globalCmds = await this.getGlobalCommands();
+        for (const cmd of globalCmds) {
+            await this.rest.delete(discord_js_1.Routes.applicationCommand(Bot_1.Bot.config.clientId, cmd.id));
+            Log_1.Log.info(`🗑️ SUPPR GLOBAL ${cmd.name}`);
+            await this.delay(100);
+        }
+        const botGuilds = Bot_1.Bot.client.guilds.cache.map(g => g.id);
+        for (const guildId of botGuilds) {
+            try {
+                const guildCmds = await this.getGuildCommands(guildId);
+                for (const cmd of guildCmds) {
+                    await this.rest.delete(discord_js_1.Routes.applicationGuildCommand(Bot_1.Bot.config.clientId, guildId, cmd.id));
+                    Log_1.Log.info(`🗑️ SUPPR ${cmd.name} → ${guildId.slice(-4)}`);
+                    await this.delay(100);
+                }
+            }
+            catch {
+            }
+        }
+        Log_1.Log.info('✅ TOUT SUPPRIMÉ !');
+    }
+    /** 🧹 NETTOYAGE */
+    async cleanup(globalCmds, localCmds) {
+        const localNames = localCmds.map(c => `${c.name}_${c.type}`);
+        for (const cmd of globalCmds.filter(c => !localNames.includes(`${c.name}_${c.type}`))) {
+            await this.rest.delete(discord_js_1.Routes.applicationCommand(Bot_1.Bot.config.clientId, cmd.id));
+            Log_1.Log.info(`🗑️ SUPPR ${cmd.name}`);
+        }
+    }
+}
+exports.InteractionBase = InteractionBase;