Bot de mensajes programados para Discord: avisos y recordatorios a su hora (Python y JavaScript)

discord.py
python-dotenv
tzdata

DISCORD_TOKEN=pega-aquí-tu-token

import json
import os
import re
from datetime import datetime
from pathlib import Path
from typing import Optional
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 mensajes se guardan junto al bot: un reinicio no los pierde.
DATOS = Path("programados.json")
ZONA = ZoneInfo("Europe/Madrid")  # las horas son de esta zona, no la del ordenador
RETRASO_MAX = 120  # si estaba apagado a la hora, lo manda al volver, pero como mucho 2 horas tarde
MAXIMO = 15  # mensajes programados por servidor
DIAS = {"todos": "todos los días", "laborables": "de lunes a viernes", "finde": "sábados y domingos"}
TOCA = {"todos": range(7), "laborables": range(5), "finde": (5, 6)}  # 0 es lunes
HORA_VALIDA = re.compile(r"^([01]?\d|2[0-3]):([0-5]\d)$")
AVISOS = discord.AllowedMentions(everyone=False, users=True, roles=True)  # nunca @everyone


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, ensure_ascii=False), "utf-8")


def minutos(hora: str) -> int:
    h, m = hora.split(":")
    return int(h) * 60 + int(m)


class Bot(discord.Client):
    def __init__(self):
        super().__init__(intents=discord.Intents.default())  # sin intents privilegiados
        self.tree = app_commands.CommandTree(self)

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


bot = Bot()


@tasks.loop(minutes=1)  # mira cada minuto si a algún mensaje le toca
async def enviar():
    ahora = datetime.now(ZONA)
    hoy = ahora.date().isoformat()
    ya = ahora.hour * 60 + ahora.minute
    for guild_id, mensajes in leer().items():
        for m in mensajes:
            tarde = ya - minutos(m["hora"])
            if m["ultimo"] == hoy or not 0 <= tarde <= RETRASO_MAX or ahora.weekday() not in TOCA[m["dias"]]:
                continue
            canal = bot.get_channel(m["canal"])
            if canal is None:
                continue  # canal borrado, o el bot ya no está en ese servidor
            try:
                await canal.send(m["texto"], allowed_mentions=AVISOS)
            except discord.HTTPException as error:
                print(f"No he podido mandar el {m['id']} 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
            for f in fresco.get(guild_id, []):
                if f["id"] == m["id"]:
                    f["ultimo"] = hoy
            guardar(fresco)


@enviar.before_loop
async def antes_de_enviar():
    await bot.wait_until_ready()


@bot.tree.command(name="programar", description="Programa un mensaje que el bot publica a una hora")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)  # de serie, solo quien gestiona el servidor
@app_commands.describe(canal="Dónde se publica", hora="Hora de España, como 09:00 o 21:30",
                       texto="El mensaje; escribe \\n para saltar de línea", dias="Qué días (de serie, todos)")
@app_commands.choices(dias=[app_commands.Choice(name=nombre, value=clave) for clave, nombre in DIAS.items()])
async def programar(interaction: discord.Interaction, canal: discord.TextChannel, hora: str,
                    texto: app_commands.Range[str, 1, 1800], dias: Optional[app_commands.Choice[str]] = None):
    valida = HORA_VALIDA.match(hora.strip())
    if not valida:
        await interaction.response.send_message("Escribe la hora así: 09:00 o 21:30.", ephemeral=True)
        return
    hora = f"{int(valida[1]):02d}:{valida[2]}"
    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()
    mensajes = datos.setdefault(str(interaction.guild_id), [])
    if len(mensajes) >= MAXIMO:
        await interaction.response.send_message(f"Ya hay {MAXIMO} mensajes programados: quita alguno con /quitar-programado.", ephemeral=True)
        return
    ahora = datetime.now(ZONA)
    # Si hoy ya ha pasado esa hora, empieza mañana (si no, saldría ahora mismo).
    pasada = ahora.hour * 60 + ahora.minute >= minutos(hora)
    nuevo = {"id": max((m["id"] for m in mensajes), default=0) + 1, "canal": canal.id, "hora": hora,
             "dias": dias.value if dias else "todos", "texto": texto.replace("\\n", "\n"),
             "ultimo": ahora.date().isoformat() if pasada else None}
    mensajes.append(nuevo)
    guardar(datos)
    await interaction.response.send_message(
        f"Programado (n.º {nuevo['id']}): {DIAS[nuevo['dias']]} a las {hora} en {canal.mention}.", ephemeral=True)


@bot.tree.command(name="programados", description="Los mensajes programados de este servidor")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
async def programados(interaction: discord.Interaction):
    mensajes = sorted(leer().get(str(interaction.guild_id), []), key=lambda m: m["hora"])
    if not mensajes:
        await interaction.response.send_message("No hay ninguno. Crea uno con /programar.", ephemeral=True)
        return
    lineas = []
    for m in mensajes:
        resumen = m["texto"].replace("\n", " ")
        if len(resumen) > 60:
            resumen = resumen[:60] + "…"
        lineas.append(f"**{m['id']}** · {m['hora']}, {DIAS[m['dias']]}, en <#{m['canal']}>: {resumen}")
    await interaction.response.send_message("\n".join(lineas), ephemeral=True,
                                            allowed_mentions=discord.AllowedMentions.none())


@bot.tree.command(name="quitar-programado", description="Quita un mensaje programado")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
@app_commands.describe(numero="El número que sale en /programados")
async def quitar_programado(interaction: discord.Interaction, numero: int):
    datos = leer()
    mensajes = datos.get(str(interaction.guild_id), [])
    quedan = [m for m in mensajes if m["id"] != numero]
    if len(quedan) == len(mensajes):
        await interaction.response.send_message(f"No hay ningún mensaje con el número {numero}. Míralos con /programados.", ephemeral=True)
        return
    datos[str(interaction.guild_id)] = quedan
    guardar(datos)
    await interaction.response.send_message(f"Quitado el {numero}: ya no se publicará.", ephemeral=True)


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


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

{
  "name": "bot-mensajes-programados",
  "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 mensajes se guardan junto al bot: un reinicio no los pierde.
const DATOS = path.join(__dirname, "programados.json");
const ZONA = "Europe/Madrid"; // las horas son de esta zona, no la del ordenador
const RETRASO_MAX = 120; // si estaba apagado a la hora, lo manda al volver, pero como mucho 2 horas tarde
const MAXIMO = 15; // mensajes programados por servidor
const DIAS = { todos: "todos los días", laborables: "de lunes a viernes", finde: "sábados y domingos" };
const TOCA = { todos: [0, 1, 2, 3, 4, 5, 6], laborables: [1, 2, 3, 4, 5], finde: [0, 6] }; // 0 es domingo
const HORA_VALIDA = /^([01]?\d|2[0-3]):([0-5]\d)$/;
const AVISOS = { parse: ["users", "roles"] }; // nunca @everyone

const leer = () => (fs.existsSync(DATOS) ? JSON.parse(fs.readFileSync(DATOS, "utf8")) : {});
const guardar = (datos) => fs.writeFileSync(DATOS, JSON.stringify(datos, null, 2));
const minutos = (hora) => Number(hora.slice(0, 2)) * 60 + Number(hora.slice(3));

// La fecha («AAAA-MM-DD»), los minutos desde medianoche y el día de la semana, en la zona elegida.
function ahora() {
  const partes = new Intl.DateTimeFormat("en-US", { timeZone: ZONA, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", weekday: "short", hourCycle: "h23" }).formatToParts(new Date());
  const p = Object.fromEntries(partes.map((x) => [x.type, x.value]));
  const semana = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(p.weekday);
  return { hoy: `${p.year}-${p.month}-${p.day}`, ya: Number(p.hour) * 60 + Number(p.minute), semana };
}

const client = new Client({ intents: [GatewayIntentBits.Guilds] }); // sin intents privilegiados

async function enviar() {
  const { hoy, ya, semana } = ahora();
  for (const [guildId, mensajes] of Object.entries(leer())) {
    for (const m of mensajes) {
      const tarde = ya - minutos(m.hora);
      if (m.ultimo === hoy || tarde < 0 || tarde > RETRASO_MAX || !TOCA[m.dias].includes(semana)) continue;
      const canal = client.channels.cache.get(m.canal);
      if (!canal) continue; // canal borrado, o el bot ya no está en ese servidor
      try {
        await canal.send({ content: m.texto, allowedMentions: AVISOS });
      } catch (error) {
        console.error(`No he podido mandar el ${m.id} 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
      for (const f of fresco[guildId] ?? []) if (f.id === m.id) f.ultimo = hoy;
      guardar(fresco);
    }
  }
}

const comandos = [
  new SlashCommandBuilder().setName("programar").setDescription("Programa un mensaje que el bot publica a una hora")
    .setContexts(InteractionContextType.Guild)
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild) // de serie, solo quien gestiona el servidor
    .addChannelOption((o) => o.setName("canal").setDescription("Dónde se publica").setRequired(true).addChannelTypes(ChannelType.GuildText))
    .addStringOption((o) => o.setName("hora").setDescription("Hora de España, como 09:00 o 21:30").setRequired(true))
    .addStringOption((o) => o.setName("texto").setDescription("El mensaje; escribe \\n para saltar de línea").setRequired(true).setMaxLength(1800))
    .addStringOption((o) => o.setName("dias").setDescription("Qué días (de serie, todos)").addChoices(...Object.entries(DIAS).map(([value, name]) => ({ name, value })))),
  new SlashCommandBuilder().setName("programados").setDescription("Los mensajes programados de este servidor")
    .setContexts(InteractionContextType.Guild).setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild),
  new SlashCommandBuilder().setName("quitar-programado").setDescription("Quita un mensaje programado")
    .setContexts(InteractionContextType.Guild).setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild)
    .addIntegerOption((o) => o.setName("numero").setDescription("El número que sale en /programados").setRequired(true)),
];

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

  if (i.commandName === "programar") {
    const canal = i.options.getChannel("canal");
    const valida = HORA_VALIDA.exec(i.options.getString("hora").trim());
    if (!valida) {
      await i.reply({ content: "Escribe la hora así: 09:00 o 21:30.", ...privado });
      return;
    }
    const hora = `${valida[1].padStart(2, "0")}:${valida[2]}`;
    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;
    }
    if (mensajes.length >= MAXIMO) {
      await i.reply({ content: `Ya hay ${MAXIMO} mensajes programados: quita alguno con /quitar-programado.`, ...privado });
      return;
    }
    const { hoy, ya } = ahora();
    const dias = i.options.getString("dias") ?? "todos";
    const nuevo = {
      id: Math.max(0, ...mensajes.map((m) => m.id)) + 1, canal: canal.id, hora, dias,
      texto: i.options.getString("texto").replaceAll("\\n", "\n"),
      ultimo: ya >= minutos(hora) ? hoy : null, // si hoy ya ha pasado esa hora, empieza mañana
    };
    mensajes.push(nuevo);
    guardar(datos);
    await i.reply({ content: `Programado (n.º ${nuevo.id}): ${DIAS[dias]} a las ${hora} en ${canal}.`, ...privado });
  } else if (i.commandName === "programados") {
    if (!mensajes.length) {
      await i.reply({ content: "No hay ninguno. Crea uno con /programar.", ...privado });
      return;
    }
    const lineas = [...mensajes].sort((a, b) => a.hora.localeCompare(b.hora)).map((m) => {
      const resumen = m.texto.replaceAll("\n", " ");
      return `**${m.id}** · ${m.hora}, ${DIAS[m.dias]}, en <#${m.canal}>: ${resumen.length > 60 ? resumen.slice(0, 60) + "…" : resumen}`;
    });
    await i.reply({ content: lineas.join("\n"), allowedMentions: { parse: [] }, ...privado });
  } else if (i.commandName === "quitar-programado") {
    const numero = i.options.getInteger("numero");
    const quedan = mensajes.filter((m) => m.id !== numero);
    if (quedan.length === mensajes.length) {
      await i.reply({ content: `No hay ningún mensaje con el número ${numero}. Míralos con /programados.`, ...privado });
      return;
    }
    datos[i.guildId] = quedan;
    guardar(datos);
    await i.reply({ content: `Quitado el ${numero}: ya no se publicará.`, ...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(() => enviar().catch(console.error), 60 * 1000); // mira cada minuto si a algún mensaje le toca
  enviar().catch(console.error);
});

client.login(process.env.DISCORD_TOKEN);