c95cc7d91f
Removed backup files and unused legacy scanner function. All code verified as unreferenced.
1046 lines
45 KiB
Python
Executable File
1046 lines
45 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
"""
|
||
RedFlag Discord Management Bot
|
||
Interactive Discord server management with secure configuration
|
||
"""
|
||
|
||
import discord
|
||
import asyncio
|
||
import logging
|
||
import sys
|
||
from typing import Optional, Dict, List
|
||
from discord.ext import commands
|
||
from discord import app_commands
|
||
from env_manager import discord_env
|
||
|
||
# Configure logging
|
||
logging.basicConfig(
|
||
level=logging.INFO,
|
||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||
)
|
||
logger = logging.getLogger(__name__)
|
||
|
||
class DiscordManager:
|
||
"""Interactive Discord server manager"""
|
||
|
||
def __init__(self):
|
||
self.bot_token = discord_env.get_required('DISCORD_BOT_TOKEN')
|
||
self.server_id = int(discord_env.get_required('DISCORD_SERVER_ID'))
|
||
self.application_id = discord_env.get_required('DISCORD_APPLICATION_ID')
|
||
self.public_key = discord_env.get_required('DISCORD_PUBLIC_KEY')
|
||
|
||
# Bot setup with required intents
|
||
intents = discord.Intents.default()
|
||
intents.guilds = True
|
||
intents.message_content = True
|
||
|
||
# Initialize bot
|
||
self.bot = commands.Bot(
|
||
command_prefix='!',
|
||
intents=intents,
|
||
help_command=None # We'll create custom help
|
||
)
|
||
|
||
self.setup_events()
|
||
self.setup_commands()
|
||
|
||
def setup_events(self):
|
||
"""Setup bot event handlers"""
|
||
|
||
@self.bot.event
|
||
async def on_ready():
|
||
logger.info(f'✅ Bot logged in as {self.bot.user}')
|
||
logger.info(f'Serving server: {self.bot.user.name} (ID: {self.bot.user.id})')
|
||
|
||
# Sync commands to guild specifically (more reliable)
|
||
guild = self.bot.get_guild(self.server_id)
|
||
# Sync commands globally
|
||
await self.bot.tree.sync()
|
||
logger.info('✅ Commands synced globally')
|
||
|
||
# Get server info
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if guild:
|
||
logger.info(f'✅ Connected to server: {guild.name}')
|
||
await self.print_server_status(guild)
|
||
else:
|
||
logger.error('❌ Could not find server!')
|
||
|
||
@self.bot.event
|
||
async def on_command_error(ctx, error):
|
||
"""Handle command errors"""
|
||
logger.error(f'Command error in {ctx.command}: {error}')
|
||
if isinstance(error, commands.MissingRequiredArgument):
|
||
await ctx.send(f'❌ Missing required argument: `{error.param}`')
|
||
elif isinstance(error, commands.BadArgument):
|
||
await ctx.send(f'❌ Invalid argument: {error}')
|
||
else:
|
||
await ctx.send(f'❌ An error occurred: {error}')
|
||
|
||
@self.bot.event
|
||
async def on_interaction_error(interaction, error):
|
||
"""Handle interaction errors"""
|
||
logger.error(f'Interaction error: {error}')
|
||
if interaction.response.is_done():
|
||
await interaction.followup.send(f'❌ An error occurred: {error}', ephemeral=True)
|
||
else:
|
||
await interaction.response.send_message(f'❌ An error occurred: {error}', ephemeral=True)
|
||
|
||
def setup_commands(self):
|
||
"""Setup slash commands"""
|
||
|
||
# Server management commands
|
||
@self.bot.tree.command(name="status", description="Show current Discord server status")
|
||
async def cmd_status(interaction: discord.Interaction):
|
||
await self.cmd_status(interaction)
|
||
|
||
@self.bot.tree.command(name="create-channels", description="Create standard RedFlag channels")
|
||
async def cmd_create_channels(interaction: discord.Interaction):
|
||
await self.cmd_create_channels(interaction)
|
||
|
||
@self.bot.tree.command(name="send-message", description="Send a message to a channel")
|
||
@app_commands.describe(channel="Channel to send message to", message="Message to send")
|
||
async def cmd_send_message(interaction: discord.Interaction, channel: str, message: str):
|
||
await self.cmd_send_message(interaction, channel, message)
|
||
|
||
@self.bot.tree.command(name="list-channels", description="List all channels and categories")
|
||
async def cmd_list_channels(interaction: discord.Interaction):
|
||
await self.cmd_list_channels(interaction)
|
||
|
||
@self.bot.tree.command(name="create-category", description="Create a channel category")
|
||
@app_commands.describe(name="Category name")
|
||
async def cmd_create_category(interaction: discord.Interaction, name: str):
|
||
await self.cmd_create_category(interaction, name)
|
||
|
||
@self.bot.tree.command(name="create-test-channel", description="Create one simple test channel")
|
||
async def cmd_create_test_channel(interaction: discord.Interaction):
|
||
await self.cmd_create_test_channel(interaction)
|
||
|
||
@self.bot.tree.command(name="create-roles", description="Create RedFlag community roles")
|
||
async def cmd_create_roles(interaction: discord.Interaction):
|
||
await self.cmd_create_roles(interaction)
|
||
|
||
@self.bot.tree.command(name="role-menu", description="Show interactive role assignment menu")
|
||
async def cmd_role_menu(interaction: discord.Interaction):
|
||
await self.cmd_role_menu(interaction)
|
||
|
||
@self.bot.tree.command(name="assign-lead-dev", description="Assign RedFlag Lead Dev role *(Admin only)*")
|
||
async def cmd_assign_lead_dev(interaction: discord.Interaction, user: discord.Member):
|
||
await self.cmd_assign_lead_dev(interaction, user)
|
||
|
||
@self.bot.tree.command(name="setup-welcome", description="Setup welcome channel with message and role selector *(Admin only)*")
|
||
async def cmd_setup_welcome(interaction: discord.Interaction):
|
||
await self.cmd_setup_welcome(interaction)
|
||
|
||
@self.bot.tree.command(name="create-version-channels", description="Create version-related channels *(Admin only)*")
|
||
async def cmd_create_version_channels(interaction: discord.Interaction):
|
||
await self.cmd_create_version_channels(interaction)
|
||
|
||
@self.bot.tree.command(name="sync-commands", description="Force sync commands *(Admin only)*")
|
||
async def cmd_sync_commands(interaction: discord.Interaction):
|
||
await self.cmd_sync_commands(interaction)
|
||
|
||
@self.bot.tree.command(name="create-redflag-channels", description="Create RedFlag homelab management channels")
|
||
async def cmd_create_redflag_channels(interaction: discord.Interaction):
|
||
await self.cmd_create_redflag_channels(interaction)
|
||
|
||
@self.bot.tree.command(name="test", description="Test command")
|
||
async def cmd_test(interaction: discord.Interaction):
|
||
await interaction.response.send_message("✅ Test command works!", ephemeral=True)
|
||
|
||
@self.bot.tree.command(name="create-welcome-banner", description="Create a welcome banner in a channel")
|
||
@app_commands.describe(channel="Channel to create banner in")
|
||
async def cmd_create_welcome_banner(interaction: discord.Interaction, channel: discord.TextChannel):
|
||
await self.cmd_create_welcome_banner(interaction, channel)
|
||
|
||
@self.bot.tree.command(name="list-commands", description="List all available bot commands")
|
||
async def cmd_list_commands_debug(interaction: discord.Interaction):
|
||
await self.cmd_list_commands_debug(interaction)
|
||
|
||
@self.bot.tree.command(name="help", description="Show available commands")
|
||
async def cmd_help(interaction: discord.Interaction):
|
||
await self.cmd_help(interaction)
|
||
|
||
async def cmd_status(self, interaction: discord.Interaction):
|
||
"""Show server status"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
embed = discord.Embed(
|
||
title="📊 RedFlag Discord Server Status",
|
||
color=discord.Color.blue(),
|
||
description=f"Server: **{guild.name}**"
|
||
)
|
||
|
||
embed.add_field(name="👥 Members", value=str(guild.member_count), inline=True)
|
||
embed.add_field(name="💬 Channels", value=str(len(guild.channels)), inline=True)
|
||
embed.add_field(name="🎭 Roles", value=str(len(guild.roles)), inline=True)
|
||
embed.add_field(name="📅 Created", value=guild.created_at.strftime("%Y-%m-%d"), inline=True)
|
||
embed.add_field(name="👑 Owner", value=f"<@{guild.owner_id}>", inline=True)
|
||
embed.add_field(name="🚀 Boost Level", value=str(guild.premium_tier), inline=True)
|
||
|
||
await interaction.response.send_message(embed=embed)
|
||
|
||
async def cmd_create_channels(self, interaction: discord.Interaction):
|
||
"""Create standard RedFlag channels"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
|
||
results = []
|
||
|
||
# Create categories first
|
||
try:
|
||
# Community category
|
||
community_cat = await guild.create_category_channel("🌍 Community")
|
||
discord_env.update_category_ids("community", str(community_cat.id))
|
||
results.append("✅ Community category")
|
||
|
||
# Development category
|
||
dev_cat = await guild.create_category_channel("💻 Development")
|
||
discord_env.update_category_ids("development", str(dev_cat.id))
|
||
results.append("✅ Development category")
|
||
|
||
# Security category
|
||
security_cat = await guild.create_category_channel("🔒 Security")
|
||
discord_env.update_category_ids("security", str(security_cat.id))
|
||
results.append("✅ Security category")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating categories: {e}")
|
||
results.append(f"❌ Categories: {e}")
|
||
|
||
# Create channels (with small delays to avoid rate limits)
|
||
await asyncio.sleep(1)
|
||
|
||
# Community channels
|
||
try:
|
||
general = await guild.create_text_channel(
|
||
"general",
|
||
category=discord.Object(id=int(discord_env.get('COMMUNITY_CATEGORY_ID', 0))),
|
||
reason="Community general discussion"
|
||
)
|
||
discord_env.update_channel_ids("general", str(general.id))
|
||
results.append("✅ #general")
|
||
|
||
announcements = await guild.create_text_channel(
|
||
"announcements",
|
||
category=discord.Object(id=int(discord_env.get('COMMUNITY_CATEGORY_ID', 0))),
|
||
reason="Project announcements"
|
||
)
|
||
discord_env.update_channel_ids("announcements", str(announcements.id))
|
||
results.append("✅ #announcements")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating community channels: {e}")
|
||
results.append(f"❌ Community channels: {e}")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Security channels
|
||
try:
|
||
security_alerts = await guild.create_text_channel(
|
||
"security-alerts",
|
||
category=discord.Object(id=int(discord_env.get('SECURITY_CATEGORY_ID', 0))),
|
||
reason="Security alerts and notifications"
|
||
)
|
||
discord_env.update_channel_ids("security-alerts", str(security_alerts.id))
|
||
results.append("✅ #security-alerts")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating security channels: {e}")
|
||
results.append(f"❌ Security channels: {e}")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Development channels
|
||
try:
|
||
dev_chat = await guild.create_text_channel(
|
||
"dev-chat",
|
||
category=discord.Object(id=int(discord_env.get('DEVELOPMENT_CATEGORY_ID', 0))),
|
||
reason="Development discussions"
|
||
)
|
||
discord_env.update_channel_ids("dev-chat", str(dev_chat.id))
|
||
results.append("✅ #dev-chat")
|
||
|
||
bug_reports = await guild.create_text_channel(
|
||
"bug-reports",
|
||
category=discord.Object(id=int(discord_env.get('DEVELOPMENT_CATEGORY_ID', 0))),
|
||
reason="Bug reports and issues"
|
||
)
|
||
discord_env.update_channel_ids("bug-reports", str(bug_reports.id))
|
||
results.append("✅ #bug-reports")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating development channels: {e}")
|
||
results.append(f"❌ Development channels: {e}")
|
||
|
||
# Send results
|
||
embed = discord.Embed(
|
||
title="🔧 Channel Creation Results",
|
||
color=discord.Color.green() if "❌" not in str(results) else discord.Color.red(),
|
||
description="\n".join(results)
|
||
)
|
||
|
||
await interaction.followup.send(embed=embed, ephemeral=True)
|
||
|
||
async def cmd_send_message(self, interaction: discord.Interaction, channel: str, message: str):
|
||
"""Send a message to a specific channel"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Find channel by name
|
||
target_channel = discord.utils.get(guild.text_channels, name=channel.lower())
|
||
if not target_channel:
|
||
await interaction.response.send_message(f"❌ Channel '{channel}' not found!", ephemeral=True)
|
||
return
|
||
|
||
try:
|
||
await target_channel.send(message)
|
||
await interaction.response.send_message(
|
||
f"✅ Message sent to #{channel}!", ephemeral=True
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"Error sending message: {e}")
|
||
await interaction.response.send_message(
|
||
f"❌ Failed to send message: {e}", ephemeral=True
|
||
)
|
||
|
||
async def cmd_list_channels(self, interaction: discord.Interaction):
|
||
"""List all channels and categories"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
embed = discord.Embed(
|
||
title="📋 Server Channels",
|
||
color=discord.Color.blue()
|
||
)
|
||
|
||
# List categories
|
||
categories = [c for c in guild.categories if c.name]
|
||
if categories:
|
||
category_text = "\n".join([f"**{c.name}** (ID: {c.id})" for c in categories])
|
||
embed.add_field(name="📂 Categories", value=category_text or "None", inline=False)
|
||
|
||
# List text channels
|
||
text_channels = [c for c in guild.text_channels if c.category]
|
||
if text_channels:
|
||
channel_text = "\n".join([f"#{c.name} (ID: {c.id})" for c in text_channels])
|
||
embed.add_field(name="💬 Text Channels", value=channel_text or "None", inline=False)
|
||
|
||
# List voice channels
|
||
voice_channels = [c for c in guild.voice_channels if c.category]
|
||
if voice_channels:
|
||
voice_text = "\n".join([f"🎤 {c.name} (ID: {c.id})" for c in voice_channels])
|
||
embed.add_field(name="🎤 Voice Channels", value=voice_text or "None", inline=False)
|
||
|
||
await interaction.response.send_message(embed=embed, ephemeral=True)
|
||
|
||
async def cmd_create_category(self, interaction: discord.Interaction, name: str):
|
||
"""Create a new category"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
try:
|
||
category = await guild.create_category_channel(name)
|
||
await interaction.response.send_message(
|
||
f"✅ Created category: **{name}** (ID: {category.id})",
|
||
ephemeral=True
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"Error creating category: {e}")
|
||
await interaction.response.send_message(
|
||
f"❌ Failed to create category: {e}",
|
||
ephemeral=True
|
||
)
|
||
|
||
async def cmd_create_test_channel(self, interaction: discord.Interaction):
|
||
"""Create one simple test channel"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
try:
|
||
# Create a simple text channel
|
||
test_channel = await guild.create_text_channel(
|
||
"test-channel",
|
||
reason="Testing bot channel creation"
|
||
)
|
||
|
||
await interaction.response.send_message(
|
||
f"✅ Created test channel: **#{test_channel.name}**",
|
||
ephemeral=True
|
||
)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating test channel: {e}")
|
||
await interaction.response.send_message(
|
||
f"❌ Failed to create test channel: {e}",
|
||
ephemeral=True
|
||
)
|
||
|
||
async def cmd_create_redflag_channels(self, interaction: discord.Interaction):
|
||
"""Create RedFlag development/support Discord channels"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
results = []
|
||
|
||
try:
|
||
# Create categories for community Discord
|
||
welcome_cat = await guild.create_category_channel("👋 Welcome & Info")
|
||
results.append("✅ Welcome & Info category")
|
||
|
||
support_cat = await guild.create_category_channel("💬 Support & Help")
|
||
results.append("✅ Support & Help category")
|
||
|
||
dev_cat = await guild.create_category_channel("🔧 Development")
|
||
results.append("✅ Development category")
|
||
|
||
community_cat = await guild.create_category_channel("🌍 Community")
|
||
results.append("✅ Community category")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Welcome & Info channels
|
||
rules = await guild.create_text_channel(
|
||
"rules-and-info",
|
||
category=welcome_cat,
|
||
reason="Community rules and project information"
|
||
)
|
||
results.append("✅ #rules-and-info")
|
||
|
||
announcements = await guild.create_text_channel(
|
||
"announcements",
|
||
category=welcome_cat,
|
||
reason="Project announcements and releases"
|
||
)
|
||
results.append("✅ #announcements")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Support & Help channels
|
||
general_support = await guild.create_text_channel(
|
||
"general-support",
|
||
category=support_cat,
|
||
reason="General RedFlag support and questions"
|
||
)
|
||
results.append("✅ #general-support")
|
||
|
||
installation = await guild.create_text_channel(
|
||
"installation-help",
|
||
category=support_cat,
|
||
reason="Help with RedFlag installation and setup"
|
||
)
|
||
results.append("✅ #installation-help")
|
||
|
||
bug_reports = await guild.create_text_channel(
|
||
"bug-reports",
|
||
category=support_cat,
|
||
reason="Bug reports and troubleshooting"
|
||
)
|
||
results.append("✅ #bug-reports")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Development channels
|
||
general_dev = await guild.create_text_channel(
|
||
"general-development",
|
||
category=dev_cat,
|
||
reason="General development discussions"
|
||
)
|
||
results.append("✅ #general-development")
|
||
|
||
feature_requests = await guild.create_text_channel(
|
||
"feature-requests",
|
||
category=dev_cat,
|
||
reason="Feature requests and ideas"
|
||
)
|
||
results.append("✅ #feature-requests")
|
||
|
||
code_review = await guild.create_text_channel(
|
||
"code-review",
|
||
category=dev_cat,
|
||
reason="Code review and development collaboration"
|
||
)
|
||
results.append("✅ #code-review")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Community channels
|
||
general_chat = await guild.create_text_channel(
|
||
"general-chat",
|
||
category=community_cat,
|
||
reason="Off-topic community chat"
|
||
)
|
||
results.append("✅ #general-chat")
|
||
|
||
homelab = await guild.create_text_channel(
|
||
"homelab-showcase",
|
||
category=community_cat,
|
||
reason="Share your homelab setups and RedFlag deployments"
|
||
)
|
||
results.append("✅ #homelab-showcase")
|
||
|
||
# Update .env with important channel IDs
|
||
discord_env.update_channel_ids("announcements", str(announcements.id))
|
||
discord_env.update_channel_ids("general-support", str(general_support.id))
|
||
discord_env.update_channel_ids("bug-reports", str(bug_reports.id))
|
||
discord_env.update_channel_ids("general-development", str(general_dev.id))
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating RedFlag community channels: {e}")
|
||
results.append(f"❌ Error: {e}")
|
||
|
||
embed = discord.Embed(
|
||
title="🏠 RedFlag Community Discord Setup",
|
||
color=discord.Color.green() if "❌" not in str(results) else discord.Color.red(),
|
||
description="Created RedFlag development/support community channels:\n\n" + "\n".join(results)
|
||
)
|
||
|
||
await interaction.followup.send(embed=embed, ephemeral=True)
|
||
|
||
async def cmd_create_roles(self, interaction: discord.Interaction):
|
||
"""Create RedFlag community roles"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Only allow administrators to create roles
|
||
if not interaction.user.guild_permissions.administrator:
|
||
await interaction.response.send_message("❌ Only administrators can create roles!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
results = []
|
||
|
||
# Define RedFlag roles
|
||
redflag_roles = {
|
||
"🚩 RedFlag Lead Dev": discord.Color.red(),
|
||
"🛠 Backend Dev": discord.Color.blue(),
|
||
"🎨 Frontend Dev": discord.Color.green(),
|
||
"🔍 QA Tester": discord.Color.orange(),
|
||
"💬 Community Helper": discord.Color.purple(),
|
||
"👤 User": discord.Color.greyple(),
|
||
"👀 Lurker": discord.Color.dark_grey(),
|
||
}
|
||
|
||
for role_name, role_color in redflag_roles.items():
|
||
try:
|
||
# Check if role already exists
|
||
existing_role = discord.utils.get(guild.roles, name=role_name)
|
||
if existing_role:
|
||
results.append(f"⚠️ {role_name} already exists")
|
||
continue
|
||
|
||
# Create the role
|
||
role = await guild.create_role(
|
||
name=role_name,
|
||
color=role_color,
|
||
reason="RedFlag community role creation",
|
||
mentionable=True
|
||
)
|
||
results.append(f"✅ Created {role_name}")
|
||
|
||
# Store role ID in .env for future reference
|
||
safe_name = role_name.replace("🚩 ", "").replace("🛠 ", "").replace("🎨 ", "").replace("🔍 ", "").replace("💬 ", "").replace("👤 ", "").replace("👀 ", "").lower().replace(" ", "_")
|
||
discord_env._config[f"ROLE_{safe_name.upper()}_ID"] = str(role.id)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating role {role_name}: {e}")
|
||
results.append(f"❌ Failed to create {role_name}: {e}")
|
||
|
||
embed = discord.Embed(
|
||
title="🎭 Role Creation Results",
|
||
color=discord.Color.green() if "❌" not in str(results) else discord.Color.red(),
|
||
description="\n".join(results)
|
||
)
|
||
|
||
await interaction.followup.send(embed=embed, ephemeral=True)
|
||
|
||
async def cmd_role_menu(self, interaction: discord.Interaction):
|
||
"""Show interactive role assignment menu"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Create the view with role buttons
|
||
view = discord.ui.View(timeout=180) # 3 minutes timeout
|
||
|
||
# Available roles for self-assignment (excluding Lead Dev)
|
||
available_roles = [
|
||
("🛠 Backend Dev", discord.Color.blue()),
|
||
("🎨 Frontend Dev", discord.Color.green()),
|
||
("🔍 QA Tester", discord.Color.orange()),
|
||
("💬 Community Helper", discord.Color.purple()),
|
||
("👤 User", discord.Color.greyple()),
|
||
("👀 Lurker", discord.Color.dark_grey()),
|
||
]
|
||
|
||
# Create buttons for each role
|
||
for role_name, role_color in available_roles:
|
||
button = discord.ui.Button(
|
||
label=role_name.replace("🛠 ", "").replace("🎨 ", "").replace("🔍 ", "").replace("💬 ", "").replace("👤 ", "").replace("👀 ", ""),
|
||
emoji=role_name.split()[0], # Get the emoji
|
||
style=discord.ButtonStyle.secondary
|
||
)
|
||
|
||
async def button_callback(interaction: discord.Interaction, current_role_name=role_name):
|
||
await self.handle_role_assignment(interaction, current_role_name)
|
||
|
||
button.callback = button_callback
|
||
view.add_item(button)
|
||
|
||
embed = discord.Embed(
|
||
title="🎭 Choose Your RedFlag Role",
|
||
description="Click a button below to assign yourself a role. You can change your role anytime!",
|
||
color=discord.Color.blue()
|
||
)
|
||
embed.add_field(
|
||
name="🚩 RedFlag Lead Dev",
|
||
value="This role is assigned by administrators only",
|
||
inline=False
|
||
)
|
||
embed.set_footer(text="You can only have one role at a time. Click again to change roles.")
|
||
|
||
await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
|
||
|
||
async def cmd_assign_lead_dev(self, interaction: discord.Interaction, user: discord.Member):
|
||
"""Assign RedFlag Lead Dev role (admin only)"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Only allow administrators to assign Lead Dev role
|
||
if not interaction.user.guild_permissions.administrator:
|
||
await interaction.response.send_message("❌ Only administrators can assign the Lead Dev role!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
|
||
# Find the Lead Dev role
|
||
lead_role = discord.utils.get(guild.roles, name="🚩 RedFlag Lead Dev")
|
||
if not lead_role:
|
||
await interaction.followup.send("❌ Lead Dev role not found! Please create roles first.", ephemeral=True)
|
||
return
|
||
|
||
try:
|
||
# Remove existing RedFlag roles from the user
|
||
redflag_role_prefixes = ["🚩 ", "🛠 ", "🎨 ", "🔍 ", "💬 ", "👤 ", "👀 "]
|
||
current_roles = [role for role in user.roles if any(role.name.startswith(prefix) for prefix in redflag_role_prefixes)]
|
||
|
||
if current_roles:
|
||
await user.remove_roles(*current_roles, reason="Assigned Lead Dev role")
|
||
|
||
# Assign Lead Dev role
|
||
await user.add_roles(lead_role, reason="Assigned by admin")
|
||
await interaction.followup.send(f"✅ Assigned **🚩 RedFlag Lead Dev** to {user.mention}", ephemeral=True)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error assigning Lead Dev role: {e}")
|
||
await interaction.followup.send(f"❌ Failed to assign role: {e}", ephemeral=True)
|
||
|
||
async def cmd_setup_welcome(self, interaction: discord.Interaction):
|
||
"""Setup welcome channel with message and role selector"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Only allow administrators
|
||
if not interaction.user.guild_permissions.administrator:
|
||
await interaction.response.send_message("❌ Only administrators can setup the welcome channel!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
results = []
|
||
|
||
try:
|
||
# Find the general channel (try multiple names)
|
||
general_channel = None
|
||
possible_names = ["general", "🏠127.0.0.1", "🏠localhost", "welcome", "welcome-and-info"]
|
||
|
||
for name in possible_names:
|
||
general_channel = discord.utils.get(guild.text_channels, name=name)
|
||
if general_channel:
|
||
break
|
||
|
||
if not general_channel:
|
||
# If no specific channel found, just use the first text channel (any category)
|
||
logger.info(f"Using first available text channel: {guild.text_channels[0].name}")
|
||
general_channel = guild.text_channels[0]
|
||
logger.info(f"Selected channel: {general_channel.name} (Category: {general_channel.category.name if general_channel.category else 'No category'})")
|
||
|
||
if not general_channel:
|
||
await interaction.followup.send("❌ Could not find any text channel to use!", ephemeral=True)
|
||
return
|
||
|
||
# Rename the channel to localhost with house emoji
|
||
await general_channel.edit(name="🏠localhost", reason="Setup welcome channel")
|
||
results.append("✅ Renamed general to 🏠localhost")
|
||
|
||
# Create welcome message with role selector
|
||
welcome_embed = discord.Embed(
|
||
title="🏠 Welcome to RedFlag",
|
||
description="**Self-hosted update management for homelabs**",
|
||
color=discord.Color.blue()
|
||
)
|
||
|
||
welcome_embed.add_field(
|
||
name="⚠️ ALPHA SOFTWARE",
|
||
value="This is experimental software in active development. Features may be broken, bugs are expected, and breaking changes happen frequently. Use at your own risk, preferably on test systems only.",
|
||
inline=False
|
||
)
|
||
|
||
welcome_embed.add_field(
|
||
name="🤝 Community & Support",
|
||
value="""**Discord Maintenance:** Full disclosure - Discord community management isn't my strongest area. If we grow over 100 users, I'll be looking to vet a moderator to help keep things organized.
|
||
|
||
**Response Times:** I *should* get alerts and will try to respond timely, but this place is a community for us all to grow and share in.
|
||
|
||
**Community Guidelines:** Small requests that are slightly off-topic are totally fine. We're building a community around homelabs, update management, and practical solutions - not a corporate support channel.""",
|
||
inline=False
|
||
)
|
||
|
||
welcome_embed.add_field(
|
||
name="🚀 Get Started",
|
||
value="1. **Choose Your Role** below - This helps us know how you're using RedFlag\n2. **Introduce Yourself** in #general-chat\n3. **Share Your Setup** in #homelab-showcase\n4. **Ask Questions** in #general-support",
|
||
inline=False
|
||
)
|
||
|
||
welcome_embed.set_footer(text="RedFlag - Simple, Honest, Homelab-first")
|
||
welcome_embed.set_thumbnail(url=guild.icon.url if guild.icon else None)
|
||
|
||
# Create role selector view
|
||
view = discord.ui.View(timeout=None) # Persistent view
|
||
|
||
# Available roles for self-assignment
|
||
available_roles = [
|
||
("🛠 Backend Dev", discord.Color.blue()),
|
||
("🎨 Frontend Dev", discord.Color.green()),
|
||
("🔍 QA Tester", discord.Color.orange()),
|
||
("💬 Community Helper", discord.Color.purple()),
|
||
("👤 User", discord.Color.greyple()),
|
||
("👀 Lurker", discord.Color.dark_grey()),
|
||
]
|
||
|
||
# Create buttons for each role
|
||
for role_name, role_color in available_roles:
|
||
button = discord.ui.Button(
|
||
label=role_name.replace("🛠 ", "").replace("🎨 ", "").replace("🔍 ", "").replace("💬 ", "").replace("👤 ", "").replace("👀 ", ""),
|
||
emoji=role_name.split()[0],
|
||
style=discord.ButtonStyle.secondary,
|
||
custom_id=f"role_select_{role_name.replace(' ', '_').replace('🛠', '').replace('🎨', '').replace('🔍', '').replace('💬', '').replace('👤', '').replace('👀', '')}"
|
||
)
|
||
|
||
async def button_callback(interaction: discord.Interaction, current_role_name=role_name):
|
||
await self.handle_role_assignment(interaction, current_role_name)
|
||
|
||
button.callback = button_callback
|
||
view.add_item(button)
|
||
|
||
# Set channel topic with important info
|
||
topic = "🏠 Welcome! Use /role-menu to choose your role. RedFlag: Self-hosted update management for homelabs. ALPHA SOFTWARE - expect bugs!"
|
||
await general_channel.edit(topic=topic, reason="Set welcome channel topic")
|
||
|
||
# Send the welcome message
|
||
await general_channel.send(embed=welcome_embed, view=view)
|
||
results.append("✅ Posted welcome message with role selector and channel topic")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error setting up welcome channel: {e}")
|
||
results.append(f"❌ Error: {e}")
|
||
|
||
embed = discord.Embed(
|
||
title="🏠 Welcome Channel Setup Complete",
|
||
color=discord.Color.green() if "❌" not in str(results) else discord.Color.red(),
|
||
description="\n".join(results)
|
||
)
|
||
|
||
await interaction.followup.send(embed=embed, ephemeral=True)
|
||
|
||
async def cmd_create_version_channels(self, interaction: discord.Interaction):
|
||
"""Create version-related channels"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Only allow administrators
|
||
if not interaction.user.guild_permissions.administrator:
|
||
await interaction.response.send_message("❌ Only administrators can create version channels!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
results = []
|
||
|
||
try:
|
||
# Create version category
|
||
version_cat = await guild.create_category_channel("📦 Version Management")
|
||
results.append("✅ Version Management category")
|
||
|
||
await asyncio.sleep(1)
|
||
|
||
# Main version channel
|
||
main_version = await guild.create_text_channel(
|
||
"🎯main",
|
||
category=version_cat,
|
||
reason="Main stable version discussion"
|
||
)
|
||
results.append("✅ #main (stable version)")
|
||
|
||
# Tagged versions channel
|
||
tagged_versions = await guild.create_text_channel(
|
||
"🏷️tagged",
|
||
category=version_cat,
|
||
reason="Tagged release versions discussion"
|
||
)
|
||
results.append("✅ #tagged (release versions)")
|
||
|
||
# Unstable dev channel
|
||
unstable_dev = await guild.create_text_channel(
|
||
"🔮unstable-developer",
|
||
category=version_cat,
|
||
reason="Unstable developer branch discussion"
|
||
)
|
||
results.append("✅ #unstable-developer (dev branch)")
|
||
|
||
# Update .env with channel IDs
|
||
discord_env.update_channel_ids("main_version", str(main_version.id))
|
||
discord_env.update_channel_ids("tagged_versions", str(tagged_versions.id))
|
||
discord_env.update_channel_ids("unstable_dev", str(unstable_dev.id))
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error creating version channels: {e}")
|
||
results.append(f"❌ Error: {e}")
|
||
|
||
embed = discord.Embed(
|
||
title="📦 Version Channels Created",
|
||
color=discord.Color.green() if "❌" not in str(results) else discord.Color.red(),
|
||
description="Created version management channels:\n\n" + "\n".join(results)
|
||
)
|
||
|
||
await interaction.followup.send(embed=embed, ephemeral=True)
|
||
|
||
async def cmd_sync_commands(self, interaction: discord.Interaction):
|
||
"""Force sync commands"""
|
||
# Only allow administrators
|
||
if not interaction.user.guild_permissions.administrator:
|
||
await interaction.response.send_message("❌ Only administrators can sync commands!", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
|
||
try:
|
||
# Sync commands globally
|
||
synced = await self.bot.tree.sync()
|
||
await interaction.followup.send(f"✅ Synced {len(synced)} commands globally!", ephemeral=True)
|
||
logger.info(f"Manually synced {len(synced)} commands")
|
||
except Exception as e:
|
||
logger.error(f"Error syncing commands: {e}")
|
||
await interaction.followup.send(f"❌ Failed to sync commands: {e}", ephemeral=True)
|
||
|
||
async def handle_role_assignment(self, interaction: discord.Interaction, role_name: str):
|
||
"""Handle role assignment from button click"""
|
||
guild = self.bot.get_guild(self.server_id)
|
||
if not guild:
|
||
await interaction.response.send_message("❌ Could not find server!", ephemeral=True)
|
||
return
|
||
|
||
# Find the role
|
||
target_role = discord.utils.get(guild.roles, name=role_name)
|
||
if not target_role:
|
||
await interaction.response.send_message("❌ Role not found! Please ask an admin to create roles first.", ephemeral=True)
|
||
return
|
||
|
||
# Get all RedFlag roles (for removal)
|
||
redflag_role_prefixes = ["🚩 ", "🛠 ", "🎨 ", "🔍 ", "💬 ", "👤 ", "👀 "]
|
||
current_roles = [role for role in interaction.user.roles if any(role.name.startswith(prefix) for prefix in redflag_role_prefixes)]
|
||
|
||
try:
|
||
# Remove existing RedFlag roles
|
||
if current_roles:
|
||
await interaction.user.remove_roles(*current_roles, reason="Role change via bot")
|
||
|
||
# Add new role
|
||
await interaction.user.add_roles(target_role, reason="Self-assigned via bot")
|
||
|
||
# Update the original message to show success
|
||
await interaction.response.edit_message(
|
||
content=f"✅ Successfully assigned role: **{role_name}**",
|
||
view=None # Remove buttons after selection
|
||
)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error assigning role {role_name}: {e}")
|
||
await interaction.response.send_message(f"❌ Failed to assign role: {e}", ephemeral=True)
|
||
|
||
async def cmd_create_welcome_banner(self, interaction: discord.Interaction, channel: discord.TextChannel):
|
||
"""Create a welcome banner in a channel"""
|
||
try:
|
||
# Check if user has admin permissions
|
||
if not interaction.user.guild_permissions.administrator:
|
||
await interaction.response.send_message("❌ This command requires Administrator permissions.", ephemeral=True)
|
||
return
|
||
|
||
await interaction.response.defer()
|
||
|
||
# Create simple welcome embed
|
||
embed = discord.Embed(
|
||
title="🏠 RedFlag",
|
||
description="Self-hosted update management for homelabs",
|
||
color=discord.Color.red()
|
||
)
|
||
embed.add_field(
|
||
name="Links",
|
||
value="[GitHub](https://github.com/Fimeg/RedFlag) • [Issues](https://github.com/Fimeg/RedFlag/issues)",
|
||
inline=False
|
||
)
|
||
embed.set_thumbnail(url="https://raw.githubusercontent.com/Fimeg/RedFlag/main/website/public/favicon.svg")
|
||
|
||
# Send and pin the welcome message
|
||
message = await channel.send(embed=embed)
|
||
await message.pin()
|
||
|
||
await interaction.followup.send(f"✅ Created welcome banner in #{channel.name}!", ephemeral=True)
|
||
logger.info(f"Created welcome banner in #{channel.name}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error converting announcement channel: {e}")
|
||
await interaction.followup.send(f"❌ Error converting channel: {e}", ephemeral=True)
|
||
|
||
async def cmd_list_commands_debug(self, interaction: discord.Interaction):
|
||
"""List all registered commands for debugging"""
|
||
try:
|
||
commands = self.bot.tree.get_commands(guild=discord.Object(id=self.server_id))
|
||
command_list = []
|
||
|
||
for cmd in commands:
|
||
if hasattr(cmd, 'name') and hasattr(cmd, 'description'):
|
||
command_list.append(f"**/{cmd.name}** - {cmd.description}")
|
||
|
||
embed = discord.Embed(
|
||
title="🔍 Registered Commands Debug",
|
||
description=f"Found {len(command_list)} commands:",
|
||
color=discord.Color.gold()
|
||
)
|
||
|
||
if command_list:
|
||
embed.add_field(name="Available Commands", value="\n".join(command_list), inline=False)
|
||
else:
|
||
embed.description = "No commands found!"
|
||
|
||
await interaction.response.send_message(embed=embed, ephemeral=True)
|
||
|
||
except Exception as e:
|
||
await interaction.response.send_message(f"❌ Error listing commands: {e}", ephemeral=True)
|
||
|
||
async def cmd_help(self, interaction: discord.Interaction):
|
||
"""Show help information"""
|
||
embed = discord.Embed(
|
||
title="🤖 RedFlag Discord Bot Help",
|
||
description="Interactive Discord server management commands",
|
||
color=discord.Color.blue()
|
||
)
|
||
|
||
commands_info = [
|
||
("`/status`", "📊 Show server status"),
|
||
("`/create-channels`", "🔧 Create standard channels"),
|
||
("`/create-redflag-channels`", "🏠 Create RedFlag community channels"),
|
||
("`/create-roles`", "🎭 Create RedFlag community roles *(Admin only)*"),
|
||
("`/setup-welcome`", "🏠 Setup welcome channel with role selector *(Admin only)*"),
|
||
("`/create-version-channels`", "📦 Create version management channels *(Admin only)*"),
|
||
("`/role-menu`", "🎮 Show interactive role assignment menu"),
|
||
("`/assign-lead-dev`", "🚩 Assign Lead Dev role *(Admin only)*"),
|
||
("`/list-channels`", "📋 List all channels"),
|
||
("`/send-message`", "💬 Send message to channel"),
|
||
("`/create-category`", "📂 Create new category"),
|
||
("`/create-test-channel`", "🧪 Create one test channel"),
|
||
("`/help`", "❓ Show this help"),
|
||
]
|
||
|
||
for cmd, desc in commands_info:
|
||
embed.add_field(name=cmd, value=desc, inline=False)
|
||
|
||
embed.add_field(
|
||
name="🛡️ Security Features",
|
||
value="✅ Secure configuration management\n✅ Token protection\n✅ Rate limiting",
|
||
inline=False
|
||
)
|
||
|
||
embed.add_field(
|
||
name="🔄 Live Updates",
|
||
value="Configuration changes are saved instantly to .env file",
|
||
inline=False
|
||
)
|
||
|
||
embed.set_footer(text="RedFlag Security Discord Management v1.0")
|
||
|
||
await interaction.response.send_message(embed=embed, ephemeral=True)
|
||
|
||
async def print_server_status(self, guild):
|
||
"""Print detailed server status to console"""
|
||
print(f"\n{'='*60}")
|
||
print(f"🚀 REDFLAG DISCORD SERVER STATUS")
|
||
print(f"{'='*60}")
|
||
print(f"Server Name: {guild.name}")
|
||
print(f"Server ID: {guild.id}")
|
||
print(f"Members: {guild.member_count}")
|
||
print(f"Channels: {len(guild.channels)}")
|
||
print(f"Roles: {len(guild.roles)}")
|
||
print(f"Owner: <@{guild.owner_id}>")
|
||
print(f"Created: {guild.created_at}")
|
||
print(f"Boost Level: {guild.premium_tier}")
|
||
print(f"{'='*60}\n")
|
||
|
||
async def run(self):
|
||
"""Start the bot"""
|
||
try:
|
||
# Connect to Discord
|
||
await self.bot.start(self.bot_token)
|
||
|
||
except discord.errors.LoginFailure:
|
||
logger.error("❌ Invalid Discord bot token!")
|
||
logger.error("Please check your DISCORD_BOT_TOKEN in .env file")
|
||
sys.exit(1)
|
||
except Exception as e:
|
||
logger.error(f"❌ Failed to start bot: {e}")
|
||
sys.exit(1)
|
||
|
||
def main():
|
||
"""Main entry point"""
|
||
print("🚀 Starting RedFlag Discord Management Bot...")
|
||
|
||
# Check configuration
|
||
if not discord_env.is_configured():
|
||
print("❌ Discord not configured!")
|
||
print("Please:")
|
||
print("1. Copy .env.example to .env")
|
||
print("2. Fill in your Discord bot token and server ID")
|
||
print("3. Run this script again")
|
||
sys.exit(1)
|
||
|
||
# Create and run bot
|
||
bot = DiscordManager()
|
||
asyncio.run(bot.run())
|
||
|
||
if __name__ == "__main__":
|
||
main() |