Bot de cumpleaños para Discord: felicita solo a cada miembro en su día (Python y JavaScript)

discord.py
python-dotenv
tzdata

DISCORD_TOKEN=pega-aquí-tu-token

import json
import os
from datetime import date, datetime
from pathlib import Path
from zoneinfo import ZoneInfo

import discord
from discord import app_commands
from discord.ext import tasks
from dotenv import load_dotenv

load_dotenv()  # lee el token del fichero .env

# Los cumpleaños se guardan junto al bot: un reinicio no los pierde.
DATOS = Path("cumples.json")
ZONA = ZoneInfo("Europe/Madrid")  # cámbiala si tu grupo vive en otra zona horaria
HORA = 9  # a partir de esta hora se felicita
MESES = ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio",
         "agosto", "septiembre", "octubre", "noviembre", "diciembre"]
SIN_AVISOS = discord.AllowedMentions.none()


def leer() -> dict:
    return json.loads(DATOS.read_text("utf-8")) if DATOS.exists() else {}


def guardar(datos: dict) -> None:
    DATOS.write_text(json.dumps(datos, indent=2), "utf-8")


def servidor(datos: dict, guild_id: int) -> dict:
    return datos.setdefault(str(guild_id), {"canal": None, "ultimo": None, "cumples": {}})


def proximo(dia: int, mes: int, hoy: date) -> date:
    """El próximo cumpleaños a partir de hoy (hoy incluido)."""
    for anio in (hoy.year, hoy.year + 1):
        try:
            fecha = date(anio, mes, dia)
        except ValueError:
            fecha = date(anio, 2, 28)  # nació un 29 de febrero y este año no es bisiesto
        if fecha >= hoy:
            return fecha


def juntar(nombres: list[str]) -> str:
    return nombres[0] if len(nombres) == 1 else ", ".join(nombres[:-1]) + " y " + nombres[-1]


class Bot(discord.Client):
    def __init__(self):
        # Sin intents privilegiados: a cada persona se la busca por su ID cuando le toca.
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        await self.tree.sync()  # publica los comandos
        felicitar.start()


bot = Bot()


@tasks.loop(minutes=30)  # mira cada media hora: si el bot estaba apagado a las 9, felicita al volver
async def felicitar():
    ahora = datetime.now(ZONA)
    if ahora.hour < HORA:
        return
    hoy = ahora.date()
    for guild_id, datos in leer().items():
        if datos["ultimo"] == hoy.isoformat() or datos["canal"] is None:
            continue  # ya felicitado hoy, o sin canal
        guild = bot.get_guild(int(guild_id))
        canal = bot.get_channel(datos["canal"])
        if guild is None or canal is None:
            continue
        quienes = []
        for user_id, (dia, mes) in datos["cumples"].items():
            if proximo(dia, mes, hoy) != hoy:
                continue
            try:
                await guild.fetch_member(int(user_id))  # ¿sigue en el servidor?
            except discord.HTTPException:
                continue  # se ha ido (o Discord no contesta): a esa persona no se la nombra
            quienes.append(f"<@{user_id}>")
        if quienes:
            try:
                await canal.send(f"🎂 ¡Feliz cumpleaños, {juntar(quienes)}! 🎉",
                                 allowed_mentions=discord.AllowedMentions(users=True, roles=False, everyone=False))
            except discord.HTTPException as error:
                print(f"No he podido felicitar en {guild_id}: {error!r}")
                continue  # se vuelve a intentar en la siguiente vuelta
        fresco = leer()  # se relee por si alguien ha usado un comando mientras tanto
        servidor(fresco, int(guild_id))["ultimo"] = hoy.isoformat()
        guardar(fresco)


@felicitar.before_loop
async def antes_de_felicitar():
    await bot.wait_until_ready()


@bot.tree.command(name="cumple", description="Guarda tu cumpleaños (sin el año)")
@app_commands.guild_only()
@app_commands.describe(dia="Día del mes", mes="Mes, del 1 al 12")
async def cumple(interaction: discord.Interaction, dia: app_commands.Range[int, 1, 31], mes: app_commands.Range[int, 1, 12]):
    try:
        date(2000, mes, dia)  # 2000 fue bisiesto: el 29 de febrero vale
    except ValueError:
        await interaction.response.send_message("Esa fecha no existe.", ephemeral=True)
        return
    datos = leer()
    s = servidor(datos, interaction.guild_id)
    s["cumples"][str(interaction.user.id)] = [dia, mes]
    guardar(datos)
    falta = "" if s["canal"] else " Aún no hay canal para felicitar: alguien que gestione el servidor tiene que usar /canal-cumples."
    await interaction.response.send_message(f"Apuntado: el {dia} de {MESES[mes - 1]}.{falta}", ephemeral=True)


@bot.tree.command(name="borrar-cumple", description="Borra tu cumpleaños de este servidor")
@app_commands.guild_only()
async def borrar_cumple(interaction: discord.Interaction):
    datos = leer()
    borrado = servidor(datos, interaction.guild_id)["cumples"].pop(str(interaction.user.id), None)
    guardar(datos)
    texto = "Borrado: ya no te felicitaré." if borrado else "No tenías ningún cumpleaños apuntado."
    await interaction.response.send_message(texto, ephemeral=True)


@bot.tree.command(name="cumples", description="Los próximos cumpleaños del servidor")
@app_commands.guild_only()
async def cumples(interaction: discord.Interaction):
    hoy = datetime.now(ZONA).date()
    apuntados = servidor(leer(), interaction.guild_id)["cumples"]
    if not apuntados:
        await interaction.response.send_message("Nadie ha apuntado su cumpleaños todavía. Usa /cumple.", ephemeral=True)
        return
    orden = sorted(apuntados.items(), key=lambda p: proximo(p[1][0], p[1][1], hoy))[:10]
    lineas = [f"{dia} de {MESES[mes - 1]}: <@{user_id}>" for user_id, (dia, mes) in orden]
    # Se ve el nombre, pero no se avisa a nadie.
    await interaction.response.send_message("🎂 Próximos cumpleaños:\n" + "\n".join(lineas), allowed_mentions=SIN_AVISOS)


@bot.tree.command(name="canal-cumples", description="Elige el canal donde se felicita")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)  # de serie, solo quien gestiona el servidor
async def canal_cumples(interaction: discord.Interaction, canal: discord.TextChannel):
    if not canal.permissions_for(interaction.guild.me).send_messages:
        await interaction.response.send_message(f"No puedo escribir en {canal.mention}: dame «Ver canal» y «Enviar mensajes» allí.", ephemeral=True)
        return
    datos = leer()
    servidor(datos, interaction.guild_id)["canal"] = canal.id
    guardar(datos)
    await interaction.response.send_message(f"Hecho: felicitaré en {canal.mention} a partir de las {HORA}:00.", ephemeral=True)


@bot.event
async def on_ready():
    print(f"Conectado como {bot.user}")


bot.run(os.environ["DISCORD_TOKEN"])

{
  "name": "bot-cumpleanos",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "discord.js": "^14.16.0",
    "dotenv": "^16.4.0"
  }
}

DISCORD_TOKEN=pega-aquí-tu-token

require("dotenv").config(); // lee el token del fichero .env
const fs = require("node:fs");
const path = require("node:path");
const { ChannelType, Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } = require("discord.js");

// Los cumpleaños se guardan junto al bot: un reinicio no los pierde.
const DATOS = path.join(__dirname, "cumples.json");
const ZONA = "Europe/Madrid"; // cámbiala si tu grupo vive en otra zona horaria
const HORA = 9; // a partir de esta hora se felicita
const MEDIA_HORA = 30 * 60 * 1000; // mira cada media hora: si el bot estaba apagado a las 9, felicita al volver
const MESES = ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"];

const leer = () => (fs.existsSync(DATOS) ? JSON.parse(fs.readFileSync(DATOS, "utf8")) : {});
const guardar = (datos) => fs.writeFileSync(DATOS, JSON.stringify(datos, null, 2));
const servidor = (datos, guildId) => (datos[guildId] ??= { canal: null, ultimo: null, cumples: {} });
const dos = (n) => String(n).padStart(2, "0");
const juntar = (nombres) => (nombres.length === 1 ? nombres[0] : `${nombres.slice(0, -1).join(", ")} y ${nombres.at(-1)}`);

// La fecha («AAAA-MM-DD») y la hora de ahora en la zona elegida.
function ahora() {
  const partes = new Intl.DateTimeFormat("en-CA", { timeZone: ZONA, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", hourCycle: "h23" }).formatToParts(new Date());
  const p = Object.fromEntries(partes.map((x) => [x.type, x.value]));
  return { hoy: `${p.year}-${p.month}-${p.day}`, hora: Number(p.hour) };
}

// El próximo cumpleaños a partir de hoy (hoy incluido), como «AAAA-MM-DD».
function proximo(dia, mes, hoy) {
  const anio = Number(hoy.slice(0, 4));
  for (const a of [anio, anio + 1]) {
    const bisiesto = new Date(Date.UTC(a, 1, 29)).getUTCDate() === 29;
    const d = dia === 29 && mes === 2 && !bisiesto ? 28 : dia; // nació un 29 de febrero y este año no es bisiesto
    const fecha = `${a}-${dos(mes)}-${dos(d)}`;
    if (fecha >= hoy) return fecha;
  }
}

// Sin intents privilegiados: a cada persona se la busca por su ID cuando le toca.
const client = new Client({ intents: [GatewayIntentBits.Guilds] });

async function felicitar() {
  const { hoy, hora } = ahora();
  if (hora < HORA) return;
  for (const [guildId, datos] of Object.entries(leer())) {
    if (datos.ultimo === hoy || !datos.canal) continue; // ya felicitado hoy, o sin canal
    const guild = client.guilds.cache.get(guildId);
    const canal = client.channels.cache.get(datos.canal);
    if (!guild || !canal) continue;
    const quienes = [];
    for (const [userId, [dia, mes]] of Object.entries(datos.cumples)) {
      if (proximo(dia, mes, hoy) !== hoy) continue;
      const miembro = await guild.members.fetch(userId).catch(() => null); // ¿sigue en el servidor?
      if (miembro) quienes.push(`<@${userId}>`);
    }
    if (quienes.length) {
      try {
        await canal.send({ content: `🎂 ¡Feliz cumpleaños, ${juntar(quienes)}! 🎉`, allowedMentions: { parse: ["users"] } });
      } catch (error) {
        console.error(`No he podido felicitar en ${guildId}:`, error);
        continue; // se vuelve a intentar en la siguiente vuelta
      }
    }
    const fresco = leer(); // se relee por si alguien ha usado un comando mientras tanto
    servidor(fresco, guildId).ultimo = hoy;
    guardar(fresco);
  }
}

const comandos = [
  new SlashCommandBuilder().setName("cumple").setDescription("Guarda tu cumpleaños (sin el año)").setContexts(InteractionContextType.Guild)
    .addIntegerOption((o) => o.setName("dia").setDescription("Día del mes").setRequired(true).setMinValue(1).setMaxValue(31))
    .addIntegerOption((o) => o.setName("mes").setDescription("Mes, del 1 al 12").setRequired(true).setMinValue(1).setMaxValue(12)),
  new SlashCommandBuilder().setName("borrar-cumple").setDescription("Borra tu cumpleaños de este servidor").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("cumples").setDescription("Los próximos cumpleaños del servidor").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("canal-cumples").setDescription("Elige el canal donde se felicita").setContexts(InteractionContextType.Guild)
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild) // de serie, solo quien gestiona el servidor
    .addChannelOption((o) => o.setName("canal").setDescription("Canal de texto").setRequired(true).addChannelTypes(ChannelType.GuildText)),
];

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand()) return;
  const privado = { flags: MessageFlags.Ephemeral };
  const datos = leer();
  const s = servidor(datos, i.guildId);

  if (i.commandName === "cumple") {
    const dia = i.options.getInteger("dia");
    const mes = i.options.getInteger("mes");
    if (new Date(Date.UTC(2000, mes - 1, dia)).getUTCDate() !== dia) { // 2000 fue bisiesto: el 29 de febrero vale
      await i.reply({ content: "Esa fecha no existe.", ...privado });
      return;
    }
    s.cumples[i.user.id] = [dia, mes];
    guardar(datos);
    const falta = s.canal ? "" : " Aún no hay canal para felicitar: alguien que gestione el servidor tiene que usar /canal-cumples.";
    await i.reply({ content: `Apuntado: el ${dia} de ${MESES[mes - 1]}.${falta}`, ...privado });
  } else if (i.commandName === "borrar-cumple") {
    const habia = i.user.id in s.cumples;
    delete s.cumples[i.user.id];
    guardar(datos);
    await i.reply({ content: habia ? "Borrado: ya no te felicitaré." : "No tenías ningún cumpleaños apuntado.", ...privado });
  } else if (i.commandName === "cumples") {
    const { hoy } = ahora();
    const orden = Object.entries(s.cumples).sort((a, b) => proximo(...a[1], hoy).localeCompare(proximo(...b[1], hoy))).slice(0, 10);
    if (!orden.length) {
      await i.reply({ content: "Nadie ha apuntado su cumpleaños todavía. Usa /cumple.", ...privado });
      return;
    }
    const lineas = orden.map(([userId, [dia, mes]]) => `${dia} de ${MESES[mes - 1]}: <@${userId}>`);
    // Se ve el nombre, pero no se avisa a nadie.
    await i.reply({ content: `🎂 Próximos cumpleaños:\n${lineas.join("\n")}`, allowedMentions: { parse: [] } });
  } else if (i.commandName === "canal-cumples") {
    const canal = i.options.getChannel("canal");
    if (!canal.permissionsFor(i.guild.members.me).has(PermissionFlagsBits.SendMessages)) {
      await i.reply({ content: `No puedo escribir en ${canal}: dame «Ver canal» y «Enviar mensajes» allí.`, ...privado });
      return;
    }
    s.canal = canal.id;
    guardar(datos);
    await i.reply({ content: `Hecho: felicitaré en ${canal} a partir de las ${HORA}:00.`, ...privado });
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(comandos.map((x) => x.toJSON())); // publica los comandos
  console.log(`Conectado como ${c.user.tag}`);
  setInterval(() => felicitar().catch(console.error), MEDIA_HORA);
  felicitar().catch(console.error);
});

client.login(process.env.DISCORD_TOKEN);