Discord scheduled messages bot: announcements and reminders on time (Python and JavaScript)

discord.py
python-dotenv
tzdata

DISCORD_TOKEN=paste-your-token-here

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()  # reads the token from the .env file

# Messages are saved next to the bot: a restart doesn't lose them.
DATA = Path("scheduled.json")
ZONE = ZoneInfo("Europe/London")  # times are in this zone, not the computer's
MAX_DELAY = 120  # if it was off at that time, it sends it when back, but at most 2 hours late
MAX_PER_SERVER = 15  # scheduled messages per server
DAYS = {"every": "every day", "weekdays": "Monday to Friday", "weekend": "Saturdays and Sundays"}
DUE = {"every": range(7), "weekdays": range(5), "weekend": (5, 6)}  # 0 is Monday
VALID_TIME = re.compile(r"^([01]?\d|2[0-3]):([0-5]\d)$")
MENTIONS = discord.AllowedMentions(everyone=False, users=True, roles=True)  # never @everyone


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


def save(data: dict) -> None:
    DATA.write_text(json.dumps(data, indent=2, ensure_ascii=False), "utf-8")


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


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

    async def setup_hook(self):
        await self.tree.sync()  # publishes the commands
        send_due.start()


bot = Bot()


@tasks.loop(minutes=1)  # checks every minute whether a message is due
async def send_due():
    now = datetime.now(ZONE)
    today = now.date().isoformat()
    current = now.hour * 60 + now.minute
    for guild_id, messages in load().items():
        for m in messages:
            late = current - minutes(m["time"])
            if m["last"] == today or not 0 <= late <= MAX_DELAY or now.weekday() not in DUE[m["days"]]:
                continue
            channel = bot.get_channel(m["channel"])
            if channel is None:
                continue  # channel deleted, or the bot is no longer on that server
            try:
                await channel.send(m["text"], allowed_mentions=MENTIONS)
            except discord.HTTPException as error:
                print(f"Couldn't send #{m['id']} on {guild_id}: {error!r}")
                continue  # it tries again on the next round
            fresh = load()  # read again in case someone used a command meanwhile
            for f in fresh.get(guild_id, []):
                if f["id"] == m["id"]:
                    f["last"] = today
            save(fresh)


@send_due.before_loop
async def before_send_due():
    await bot.wait_until_ready()


@bot.tree.command(name="schedule", description="Schedule a message the bot posts at a set time")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)  # by default, only people who manage the server
@app_commands.describe(channel="Where it's posted", time="Time like 09:00 or 21:30, in the bot's zone",
                       text="The message; type \\n for a new line", days="Which days (every day by default)")
@app_commands.choices(days=[app_commands.Choice(name=label, value=key) for key, label in DAYS.items()])
async def schedule(interaction: discord.Interaction, channel: discord.TextChannel, time: str,
                   text: app_commands.Range[str, 1, 1800], days: Optional[app_commands.Choice[str]] = None):
    valid = VALID_TIME.match(time.strip())
    if not valid:
        await interaction.response.send_message("Write the time like this: 09:00 or 21:30.", ephemeral=True)
        return
    time = f"{int(valid[1]):02d}:{valid[2]}"
    if not channel.permissions_for(interaction.guild.me).send_messages:
        await interaction.response.send_message(f"I can't write in {channel.mention}: give me “View Channel” and “Send Messages” there.", ephemeral=True)
        return
    data = load()
    messages = data.setdefault(str(interaction.guild_id), [])
    if len(messages) >= MAX_PER_SERVER:
        await interaction.response.send_message(f"There are {MAX_PER_SERVER} scheduled messages already: remove one with /unschedule.", ephemeral=True)
        return
    now = datetime.now(ZONE)
    # If that time has already passed today, it starts tomorrow (otherwise it would go out right now).
    passed = now.hour * 60 + now.minute >= minutes(time)
    new = {"id": max((m["id"] for m in messages), default=0) + 1, "channel": channel.id, "time": time,
           "days": days.value if days else "every", "text": text.replace("\\n", "\n"),
           "last": now.date().isoformat() if passed else None}
    messages.append(new)
    save(data)
    await interaction.response.send_message(
        f"Scheduled (#{new['id']}): {DAYS[new['days']]} at {time} in {channel.mention}.", ephemeral=True)


@bot.tree.command(name="scheduled", description="This server's scheduled messages")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
async def scheduled(interaction: discord.Interaction):
    messages = sorted(load().get(str(interaction.guild_id), []), key=lambda m: m["time"])
    if not messages:
        await interaction.response.send_message("There aren't any. Create one with /schedule.", ephemeral=True)
        return
    lines = []
    for m in messages:
        summary = m["text"].replace("\n", " ")
        if len(summary) > 60:
            summary = summary[:60] + "…"
        lines.append(f"**{m['id']}** · {m['time']}, {DAYS[m['days']]}, in <#{m['channel']}>: {summary}")
    await interaction.response.send_message("\n".join(lines), ephemeral=True,
                                            allowed_mentions=discord.AllowedMentions.none())


@bot.tree.command(name="unschedule", description="Remove a scheduled message")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
@app_commands.describe(number="The number shown in /scheduled")
async def unschedule(interaction: discord.Interaction, number: int):
    data = load()
    messages = data.get(str(interaction.guild_id), [])
    left = [m for m in messages if m["id"] != number]
    if len(left) == len(messages):
        await interaction.response.send_message(f"There's no message number {number}. See them with /scheduled.", ephemeral=True)
        return
    data[str(interaction.guild_id)] = left
    save(data)
    await interaction.response.send_message(f"Removed #{number}: it won't be posted any more.", ephemeral=True)


@bot.event
async def on_ready():
    print(f"Logged in as {bot.user}")


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

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

DISCORD_TOKEN=paste-your-token-here

require("dotenv").config(); // reads the token from the .env file
const fs = require("node:fs");
const path = require("node:path");
const { ChannelType, Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } = require("discord.js");

// Messages are saved next to the bot: a restart doesn't lose them.
const DATA = path.join(__dirname, "scheduled.json");
const ZONE = "Europe/London"; // times are in this zone, not the computer's
const MAX_DELAY = 120; // if it was off at that time, it sends it when back, but at most 2 hours late
const MAX_PER_SERVER = 15; // scheduled messages per server
const DAYS = { every: "every day", weekdays: "Monday to Friday", weekend: "Saturdays and Sundays" };
const DUE = { every: [0, 1, 2, 3, 4, 5, 6], weekdays: [1, 2, 3, 4, 5], weekend: [0, 6] }; // 0 is Sunday
const VALID_TIME = /^([01]?\d|2[0-3]):([0-5]\d)$/;
const MENTIONS = { parse: ["users", "roles"] }; // never @everyone

const load = () => (fs.existsSync(DATA) ? JSON.parse(fs.readFileSync(DATA, "utf8")) : {});
const save = (data) => fs.writeFileSync(DATA, JSON.stringify(data, null, 2));
const minutes = (hhmm) => Number(hhmm.slice(0, 2)) * 60 + Number(hhmm.slice(3));

// The date (“YYYY-MM-DD”), minutes since midnight and day of the week, in the chosen zone.
function now() {
  const parts = new Intl.DateTimeFormat("en-US", { timeZone: ZONE, 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(parts.map((x) => [x.type, x.value]));
  const weekday = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(p.weekday);
  return { today: `${p.year}-${p.month}-${p.day}`, current: Number(p.hour) * 60 + Number(p.minute), weekday };
}

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

async function sendDue() {
  const { today, current, weekday } = now();
  for (const [guildId, messages] of Object.entries(load())) {
    for (const m of messages) {
      const late = current - minutes(m.time);
      if (m.last === today || late < 0 || late > MAX_DELAY || !DUE[m.days].includes(weekday)) continue;
      const channel = client.channels.cache.get(m.channel);
      if (!channel) continue; // channel deleted, or the bot is no longer on that server
      try {
        await channel.send({ content: m.text, allowedMentions: MENTIONS });
      } catch (error) {
        console.error(`Couldn't send #${m.id} on ${guildId}:`, error);
        continue; // it tries again on the next round
      }
      const fresh = load(); // read again in case someone used a command meanwhile
      for (const f of fresh[guildId] ?? []) if (f.id === m.id) f.last = today;
      save(fresh);
    }
  }
}

const commands = [
  new SlashCommandBuilder().setName("schedule").setDescription("Schedule a message the bot posts at a set time")
    .setContexts(InteractionContextType.Guild)
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild) // by default, only people who manage the server
    .addChannelOption((o) => o.setName("channel").setDescription("Where it's posted").setRequired(true).addChannelTypes(ChannelType.GuildText))
    .addStringOption((o) => o.setName("time").setDescription("Time like 09:00 or 21:30, in the bot's zone").setRequired(true))
    .addStringOption((o) => o.setName("text").setDescription("The message; type \\n for a new line").setRequired(true).setMaxLength(1800))
    .addStringOption((o) => o.setName("days").setDescription("Which days (every day by default)").addChoices(...Object.entries(DAYS).map(([value, name]) => ({ name, value })))),
  new SlashCommandBuilder().setName("scheduled").setDescription("This server's scheduled messages")
    .setContexts(InteractionContextType.Guild).setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild),
  new SlashCommandBuilder().setName("unschedule").setDescription("Remove a scheduled message")
    .setContexts(InteractionContextType.Guild).setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild)
    .addIntegerOption((o) => o.setName("number").setDescription("The number shown in /scheduled").setRequired(true)),
];

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand()) return;
  const ephemeral = { flags: MessageFlags.Ephemeral };
  const data = load();
  const messages = (data[i.guildId] ??= []);

  if (i.commandName === "schedule") {
    const channel = i.options.getChannel("channel");
    const valid = VALID_TIME.exec(i.options.getString("time").trim());
    if (!valid) {
      await i.reply({ content: "Write the time like this: 09:00 or 21:30.", ...ephemeral });
      return;
    }
    const time = `${valid[1].padStart(2, "0")}:${valid[2]}`;
    if (!channel.permissionsFor(i.guild.members.me).has(PermissionFlagsBits.SendMessages)) {
      await i.reply({ content: `I can't write in ${channel}: give me “View Channel” and “Send Messages” there.`, ...ephemeral });
      return;
    }
    if (messages.length >= MAX_PER_SERVER) {
      await i.reply({ content: `There are ${MAX_PER_SERVER} scheduled messages already: remove one with /unschedule.`, ...ephemeral });
      return;
    }
    const { today, current } = now();
    const days = i.options.getString("days") ?? "every";
    const created = {
      id: Math.max(0, ...messages.map((m) => m.id)) + 1, channel: channel.id, time, days,
      text: i.options.getString("text").replaceAll("\\n", "\n"),
      last: current >= minutes(time) ? today : null, // if that time has already passed today, it starts tomorrow
    };
    messages.push(created);
    save(data);
    await i.reply({ content: `Scheduled (#${created.id}): ${DAYS[days]} at ${time} in ${channel}.`, ...ephemeral });
  } else if (i.commandName === "scheduled") {
    if (!messages.length) {
      await i.reply({ content: "There aren't any. Create one with /schedule.", ...ephemeral });
      return;
    }
    const lines = [...messages].sort((a, b) => a.time.localeCompare(b.time)).map((m) => {
      const summary = m.text.replaceAll("\n", " ");
      return `**${m.id}** · ${m.time}, ${DAYS[m.days]}, in <#${m.channel}>: ${summary.length > 60 ? summary.slice(0, 60) + "…" : summary}`;
    });
    await i.reply({ content: lines.join("\n"), allowedMentions: { parse: [] }, ...ephemeral });
  } else if (i.commandName === "unschedule") {
    const number = i.options.getInteger("number");
    const left = messages.filter((m) => m.id !== number);
    if (left.length === messages.length) {
      await i.reply({ content: `There's no message number ${number}. See them with /scheduled.`, ...ephemeral });
      return;
    }
    data[i.guildId] = left;
    save(data);
    await i.reply({ content: `Removed #${number}: it won't be posted any more.`, ...ephemeral });
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(commands.map((x) => x.toJSON())); // publishes the commands
  console.log(`Logged in as ${c.user.tag}`);
  setInterval(() => sendDue().catch(console.error), 60 * 1000); // checks every minute whether a message is due
  sendDue().catch(console.error);
});

client.login(process.env.DISCORD_TOKEN);