setup

configManager.js

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+
+const filePath = path.resolve("./guildConfigs.json");
+
+export const DEFAULT_CONFIG = {
+	logChannelId: null,
+	textModel: "yaya36095/xlm-roberta-text-detector",
+	imageModel: "capcheck/ai-image-detection"
+};
+
+export function loadConfig(guildId) {
+	if (!fs.existsSync(filePath)) {
+		fs.writeFileSync(filePath, JSON.stringify({}));
+	}
+	try {
+		const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		return data[guildId] || { ...DEFAULT_CONFIG };
+	} catch (err) {
+		console.error("Błąd podczas odczytu konfiguracji:", err);
+		return { ...DEFAULT_CONFIG };
+	}
+}
+
+export function saveConfig(guildId, newConfig) {
+	if (!fs.existsSync(filePath)) {
+		fs.writeFileSync(filePath, JSON.stringify({}));
+	}
+	try {
+		const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		data[guildId] = { ...DEFAULT_CONFIG, ...data[guildId], ...newConfig };
+		fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+		return true;
+	} catch (err) {
+		console.error("Błąd podczas zapisu konfiguracji:", err);
+		return false;
+	}
+}

guildConfigs.json

@@ -0,0 +1,7 @@
+{
+  "1515307986963267595": {
+    "logChannelId": "1515373138937123007",
+    "textModel": "yaya36095/xlm-roberta-text-detector",
+    "imageModel": "capcheck/ai-image-detection"
+  }
+}

index.js

@@ -13,9 +13,15 @@ import {
   ApplicationCommandType,
   EmbedBuilder,
   ButtonBuilder,
-  ButtonStyle
+  ButtonStyle,
+  PermissionFlagsBits,
+  ChannelSelectMenuBuilder,
+  StringSelectMenuBuilder,
+  ChannelType
 } from "discord.js";
 
+import { loadConfig, saveConfig } from "./configManager.js";
+
 const client = new Client({
 	intents: [
 		GatewayIntentBits.Guilds,
@@ -26,6 +32,15 @@ const client = new Client({
 
 const API_URL = process.env.API_URL || "http://127.0.0.1:8000";
 
+// Domyślne modele zapasowe (używane gdyby backend był wyłączony podczas konfiguracji)
+const FALLBACK_MODELS = {
+	text: ["yaya36095/xlm-roberta-text-detector", "mock"],
+	image: ["capcheck/ai-image-detection", "mock"]
+};
+
+// Pamięć podręczna przechowuje konfigurację oraz pobrane dynamicznie modele
+const activeSetupSessions = new Map();
+
 client.once(Events.ClientReady, async () => {
 	console.log(`Bot ready: ${client.user.tag}`);
 
@@ -36,17 +51,46 @@ client.once(Events.ClientReady, async () => {
 				description: "Otwiera okienko do wklejenia linku lub tekstu do analizy",
 				type: ApplicationCommandType.ChatInput
 			},
+			{
+				name: "setup",
+				description: "Ustawienia kanału logów i modeli analizy (Wymaga Administratora)",
+				default_member_permissions: PermissionFlagsBits.Administrator.toString(),
+				type: ApplicationCommandType.ChatInput
+			},
 			{
 				name: "Przeanalizuj tekst",
 				type: ApplicationCommandType.Message
 			}
 		]);
-		console.log("Pomyślnie zarejestrowano komendy (/detect oraz menu kontekstowe)");
+		console.log("Pomyślnie zarejestrowano komendy (/detect, /setup oraz menu kontekstowe)");
 	} catch (error) {
 		console.error("Błąd podczas rejestracji komend:", error);
 	}
 });
 
+// Funkcja pobierająca aktualne modele bezpośrednio z FastAPI w czasie rzeczywistym
+async function fetchAvailableModels() {
+	try {
+		const response = await fetch(API_URL);
+		if (response.ok) {
+			const data = await response.json();
+			if (data.available_models) {
+				const textModels = data.available_models.text || [];
+				const imageModels = data.available_models.image || [];
+
+				// Upewniamy się, że zawsze mamy opcję testową "mock"
+				if (!textModels.includes("mock")) textModels.push("mock");
+				if (!imageModels.includes("mock")) imageModels.push("mock");
+
+				return { text: textModels, image: imageModels };
+			}
+		}
+	} catch (err) {
+		console.warn("Nie udało się pobrać modeli z API (użyto modeli zapasowych):", err.message);
+	}
+	return FALLBACK_MODELS;
+}
+
 function preparePayload(input) {
 	const trimmed = input.trim();
 	const isUrl = trimmed.startsWith("http://") || trimmed.startsWith("https://");
@@ -98,13 +142,114 @@ function getProgressBar(confidence, isDeepfake) {
 	return blockEmoji.repeat(filledBlocks) + "⬛".repeat(emptyBlocks);
 }
 
+// ZMIANA: Funkcja przyjmuje teraz pobrane dynamicznie modele jako drugi parametr
+function generateSetupView(tempConfig, availableModels) {
+	const embed = new EmbedBuilder()
+		.setColor(0x5865F2)
+		.setTitle("⚙️ Konfiguracja Systemu Detekcji")
+		.setDescription("Wybierz kanał do wysyłania logów oraz aktywne modele analizy z menu poniżej.")
+		.addFields(
+			{ 
+				name: "📂 Kanał logów (Raporty)", 
+				value: tempConfig.logChannelId ? `<#${tempConfig.logChannelId}>` : "*Wysyłanie tylko do konsoli*", 
+				inline: false 
+			},
+			{ 
+				name: "📝 Model tekstowy", 
+				value: `\`${tempConfig.textModel}\``, 
+				inline: true 
+			},
+			{ 
+				name: "🖼️ Model obrazów", 
+				value: `\`${tempConfig.imageModel}\``, 
+				inline: true 
+			}
+		)
+		.setFooter({ text: "Wybierz opcje i kliknij Zapisz ustawienia" })
+		.setTimestamp();
+
+	const channelSelect = new ChannelSelectMenuBuilder()
+		.setCustomId("setup_log_channel")
+		.setPlaceholder("Wybierz kanał dla raportów")
+		.addChannelTypes(ChannelType.GuildText);
+
+	// DYNAMICZNE mapowanie modeli tekstowych z API
+	const textOptions = availableModels.text.map(model => ({
+		label: model === "mock" ? "Mock (Model testowy)" : model,
+		value: model,
+		default: tempConfig.textModel === model
+	}));
+
+	const textModelSelect = new StringSelectMenuBuilder()
+		.setCustomId("setup_text_model")
+		.setPlaceholder("Wybierz model tekstu")
+		.addOptions(textOptions);
+
+	// DYNAMICZNE mapowanie modeli graficznych z API
+	const imageOptions = availableModels.image.map(model => ({
+		label: model === "mock" ? "Mock (Model testowy)" : model,
+		value: model,
+		default: tempConfig.imageModel === model
+	}));
+
+	const imageModelSelect = new StringSelectMenuBuilder()
+		.setCustomId("setup_image_model")
+		.setPlaceholder("Wybierz model obrazów")
+		.addOptions(imageOptions);
+
+	const buttonsRow = new ActionRowBuilder().addComponents(
+		new ButtonBuilder()
+			.setCustomId("setup_save")
+			.setLabel("Zapisz ustawienia")
+			.setStyle(ButtonStyle.Success)
+			.setEmoji("💾"),
+		new ButtonBuilder()
+			.setCustomId("setup_cancel")
+			.setLabel("Anuluj")
+			.setStyle(ButtonStyle.Danger)
+			.setEmoji("❌")
+	);
+
+	return {
+		embeds: [embed],
+		components: [
+			new ActionRowBuilder().addComponents(channelSelect),
+			new ActionRowBuilder().addComponents(textModelSelect),
+			new ActionRowBuilder().addComponents(imageModelSelect),
+			buttonsRow
+		]
+	};
+}
+
+async function sendLogToDiscord(guild, embedToSend) {
+	const config = loadConfig(guild.id);
+	if (!config.logChannelId) return;
+
+	try {
+		const channel = await guild.channels.fetch(config.logChannelId);
+		if (channel) {
+			await channel.send({ embeds: [embedToSend] });
+		}
+	} catch (err) {
+		console.warn(`Nie można wysłać logu na kanał ${config.logChannelId}:`, err.message);
+	}
+}
+
 async function handleAnalysis(interaction, userContent, targetMessage = null) {
 	await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
+	const serverConfig = loadConfig(interaction.guildId);
+
 	try {
 		const { type, payload } = preparePayload(userContent);
 		
-		console.log(`Wysyłanie zapytania typu: ${type} do API...`);
+		if (type === "text") {
+			payload.model = serverConfig.textModel;
+		} else if (type === "image") {
+			payload.model = serverConfig.imageModel;
+		}
+
+		console.log(`Wysyłanie zapytania typu: ${type} do API z modelem: ${payload.model}...`);
 
 		const response = await fetch(`${API_URL}/analyze`, {
 			method: "POST",
@@ -163,7 +308,6 @@ async function handleAnalysis(interaction, userContent, targetMessage = null) {
 			.setTimestamp()
 			.setFooter({ text: "Deepfake Detection Service", iconURL: client.user.displayAvatarURL() });
 
-		// TWORZENIE PRZYCISKÓW
 		const buttonRow = new ActionRowBuilder().addComponents(
 			new ButtonBuilder()
 				.setCustomId("modelCorrect")
@@ -210,6 +354,54 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 			await interaction.showModal(modal);
 		}
+
+		// ZMIANA: Pobieranie modeli z API na żywo przed pokazaniem setupu
+		if (interaction.commandName === "setup") {
+			const guildId = interaction.guildId;
+			const currentConfig = loadConfig(guildId);
+
+			// Informujemy Discord, że pobieramy konfigurację z API
+			await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+
+			// Pobieramy aktywne modele bezpośrednio z FastAPI
+			const availableModels = await fetchAvailableModels();
+
+			// Zapisujemy w sesji zarówno konfigurację, jak i pobrane modele
+			activeSetupSessions.set(guildId, { 
+				config: { ...currentConfig }, 
+				availableModels 
+			});
+
+			const setupView = generateSetupView(currentConfig, availableModels);
+			await interaction.editReply(setupView);
+		}
+	}
+
+	// OBSŁUGA ZMIANY KANAŁU LOGÓW
+	if (interaction.isChannelSelectMenu()) {
+		if (interaction.customId === "setup_log_channel") {
+			const guildId = interaction.guildId;
+			const tempSession = activeSetupSessions.get(guildId);
+			if (tempSession) {
+				tempSession.config.logChannelId = interaction.values[0];
+				await interaction.update(generateSetupView(tempSession.config, tempSession.availableModels));
+			}
+		}
+	}
+
+	// OBSŁUGA ZMIANY MODELI
+	if (interaction.isStringSelectMenu()) {
+		const guildId = interaction.guildId;
+		const tempSession = activeSetupSessions.get(guildId);
+		
+		if (tempSession) {
+			if (interaction.customId === "setup_text_model") {
+				tempSession.config.textModel = interaction.values[0];
+			} else if (interaction.customId === "setup_image_model") {
+				tempSession.config.imageModel = interaction.values[0];
+			}
+			await interaction.update(generateSetupView(tempSession.config, tempSession.availableModels));
+		}
 	}
 
 	if (interaction.isMessageContextMenuCommand()) {
@@ -241,26 +433,67 @@ client.on(Events.InteractionCreate, async (interaction) => {
 		}
 	}
 
-	// GUZIKI
 	if (interaction.isButton()) {
-		// ZGŁOSZENIE BŁĘDU
+		const guildId = interaction.guildId;
+
+		if (interaction.customId === "setup_save") {
+			const tempSession = activeSetupSessions.get(guildId);
+			if (tempSession) {
+				saveConfig(guildId, tempSession.config);
+				activeSetupSessions.delete(guildId);
+				await interaction.update({
+					content: "✅ **Ustawienia zostały pomyślnie zapisane!**",
+					embeds: [],
+					components: []
+				});
+			}
+		}
+
+		if (interaction.customId === "setup_cancel") {
+			activeSetupSessions.delete(guildId);
+			await interaction.update({
+				content: "❌ **Konfiguracja została anulowana.**",
+				embeds: [],
+				components: []
+			});
+		}
+
 		if (interaction.customId === "reportError") {
 			await interaction.reply({
-				content: "✅ **Dziękujemy!** Twoje zgłoszenie błędu zostało zarejestrowane. Pomoże nam ono udoskonalić algorytmy detekcji.",
+				content: "✅ **Dziękujemy!** Twoje zgłoszenie błędu zostało zarejestrowane.",
 				flags: [MessageFlags.Ephemeral]
 			});
 
-			console.log(`[RAPORT BŁĘDU] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) zgłosił błędną klasyfikację bota.`);
+			console.log(`[RAPORT BŁĘDU] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) zgłosił błędną klasyfikację.`);
+
+			const originalEmbed = interaction.message.embeds[0];
+			if (originalEmbed) {
+				const logEmbed = EmbedBuilder.from(originalEmbed)
+					.setColor(0xFFAA00)
+					.setTitle("⚠️ Zgłoszenie błędu analizy")
+					.setDescription(`Użytkownik **${interaction.user.tag}** (ID: \`${interaction.user.id}\`) zgłosił błąd analizy w poniższym raporcie.`);
+				
+				await sendLogToDiscord(interaction.guild, logEmbed);
+			}
 		}
 
-		// POTWIERDZENIE POPRAWNOŚCI
 		if (interaction.customId === "modelCorrect") {
 			await interaction.reply({
-				content: "✅ **Dziękujemy!** Twoje potwierdzenie zostało pomyślnie zapisane. Cieszymy się, że model zadziałał prawidłowo.",
+				content: "✅ **Dziękujemy!** Twoje potwierdzenie zostało pomyślnie zapisane.",
 				flags: [MessageFlags.Ephemeral]
 			});
 
-			console.log(`[POTWIERDZENIE] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) potwierdził poprawną klasyfikację bota.`);
+			console.log(`[POTWIERDZENIE] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) potwierdził poprawną klasyfikację.`);
+
+			const originalEmbed = interaction.message.embeds[0];
+			if (originalEmbed) {
+				const logEmbed = EmbedBuilder.from(originalEmbed)
+					.setColor(0x00AAFF)
+					.setTitle("✅ Potwierdzona poprawność analizy")
+					.setDescription(`Użytkownik **${interaction.user.tag}** (ID: \`${interaction.user.id}\`) potwierdził poprawność raportu.`);
+				
+				await sendLogToDiscord(interaction.guild, logEmbed);
+			}
 		}
 	}
 });