feat: discord message

app/lib/minecraft-whitelist.ts

@@ -0,0 +1,258 @@
+import crypto from "node:crypto";
+import { sendRconCommand } from "./rcon";
+
+export type WhitelistDecision = "accept" | "reject";
+
+export type WhitelistRequest = {
+  username: string;
+  discord: string;
+  reason: string;
+};
+
+type ReviewTokenPayload = WhitelistRequest & {
+  decision: WhitelistDecision;
+  exp: number;
+};
+
+const usernamePattern = /^[A-Za-z0-9_]{3,16}$/;
+const maxDiscordLength = 64;
+const maxReasonLength = 800;
+const reviewTokenTtlMs = 7 * 24 * 60 * 60 * 1000;
+
+export function parseWhitelistRequest(payload: unknown): WhitelistRequest {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Demande invalide.");
+  }
+
+  const input = payload as Partial<Record<keyof WhitelistRequest, unknown>>;
+  const username = String(input.username ?? "").trim();
+  const discord = String(input.discord ?? "").trim();
+  const reason = String(input.reason ?? "").trim();
+
+  if (!usernamePattern.test(username)) {
+    throw new Error("Pseudo Minecraft invalide.");
+  }
+
+  if (discord.length < 2 || discord.length > maxDiscordLength) {
+    throw new Error("Identifiant Discord invalide.");
+  }
+
+  if (reason.length < 10 || reason.length > maxReasonLength) {
+    throw new Error("Message trop court ou trop long.");
+  }
+
+  return { username, discord, reason };
+}
+
+export function parseWhitelistDecision(payload: unknown): {
+  username: string;
+  decision: WhitelistDecision;
+} {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Décision invalide.");
+  }
+
+  const input = payload as Partial<Record<"username" | "decision", unknown>>;
+  const username = String(input.username ?? "").trim();
+  const decision = String(input.decision ?? "").trim();
+
+  if (!usernamePattern.test(username)) {
+    throw new Error("Pseudo Minecraft invalide.");
+  }
+
+  if (decision !== "accept" && decision !== "reject") {
+    throw new Error("Décision invalide.");
+  }
+
+  return { username, decision };
+}
+
+function getReviewSecret() {
+  const secret = process.env.MINECRAFT_WHITELIST_REVIEW_SECRET;
+
+  if (!secret || secret.length < 32) {
+    throw new Error("Secret de revue whitelist manquant ou trop court.");
+  }
+
+  return secret;
+}
+
+function getBaseUrl() {
+  const baseUrl = process.env.APP_BASE_URL ?? process.env.NEXT_PUBLIC_SITE_URL;
+
+  if (!baseUrl) {
+    throw new Error("APP_BASE_URL est requis pour générer les boutons Discord.");
+  }
+
+  return baseUrl.replace(/\/$/, "");
+}
+
+function signTokenPayload(encodedPayload: string) {
+  return crypto
+    .createHmac("sha256", getReviewSecret())
+    .update(encodedPayload)
+    .digest("base64url");
+}
+
+function createReviewToken(request: WhitelistRequest, decision: WhitelistDecision) {
+  const payload: ReviewTokenPayload = {
+    ...request,
+    decision,
+    exp: Date.now() + reviewTokenTtlMs,
+  };
+  const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  const signature = signTokenPayload(encodedPayload);
+
+  return `${encodedPayload}.${signature}`;
+}
+
+export function verifyReviewToken(token: string | null) {
+  if (!token) {
+    throw new Error("Token manquant.");
+  }
+
+  const [encodedPayload, signature] = token.split(".");
+
+  if (!encodedPayload || !signature) {
+    throw new Error("Token invalide.");
+  }
+
+  const expectedSignature = signTokenPayload(encodedPayload);
+  const signatureBuffer = Buffer.from(signature);
+  const expectedBuffer = Buffer.from(expectedSignature);
+
+  if (
+    signatureBuffer.length !== expectedBuffer.length ||
+    !crypto.timingSafeEqual(signatureBuffer, expectedBuffer)
+  ) {
+    throw new Error("Signature invalide.");
+  }
+
+  const payload = JSON.parse(
+    Buffer.from(encodedPayload, "base64url").toString("utf8"),
+  ) as ReviewTokenPayload;
+
+  if (!usernamePattern.test(payload.username)) {
+    throw new Error("Pseudo Minecraft invalide.");
+  }
+
+  if (payload.decision !== "accept" && payload.decision !== "reject") {
+    throw new Error("Décision invalide.");
+  }
+
+  if (payload.exp < Date.now()) {
+    throw new Error("Token expiré.");
+  }
+
+  return payload;
+}
+
+function createReviewUrl(request: WhitelistRequest, decision: WhitelistDecision) {
+  const url = new URL("/api/minecraft/whitelist/review", getBaseUrl());
+  url.searchParams.set("token", createReviewToken(request, decision));
+
+  return url.toString();
+}
+
+export async function sendWhitelistRequestToDiscord(request: WhitelistRequest) {
+  const webhookUrl = process.env.DISCORD_WHITELIST_WEBHOOK_URL;
+
+  if (!webhookUrl) {
+    throw new Error("Webhook Discord non configuré.");
+  }
+
+  const acceptUrl = createReviewUrl(request, "accept");
+  const rejectUrl = createReviewUrl(request, "reject");
+
+  const response = await fetch(webhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      content: "Nouvelle demande whitelist Minecraft",
+      embeds: [
+        {
+          title: "Candidature Minecraft",
+          color: 0x33e879,
+          fields: [
+            { name: "Pseudo", value: request.username, inline: true },
+            { name: "Discord", value: request.discord, inline: true },
+            { name: "Motivation", value: request.reason.slice(0, maxReasonLength) },
+          ],
+          timestamp: new Date().toISOString(),
+        },
+      ],
+      components: [
+        {
+          type: 1,
+          components: [
+            {
+              type: 2,
+              style: 5,
+              label: "Accepter",
+              url: acceptUrl,
+              emoji: { name: "✅" },
+            },
+            {
+              type: 2,
+              style: 5,
+              label: "Refuser",
+              url: rejectUrl,
+              emoji: { name: "❌" },
+            },
+          ],
+        },
+      ],
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Discord a refusé la demande (${response.status}).`);
+  }
+}
+
+export async function sendWhitelistDecisionToDiscord(
+  username: string,
+  decision: WhitelistDecision,
+  result?: string,
+) {
+  const webhookUrl = process.env.DISCORD_WHITELIST_WEBHOOK_URL;
+
+  if (!webhookUrl) {
+    return;
+  }
+
+  await fetch(webhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      content:
+        decision === "accept"
+          ? `✅ ${username} a été ajouté à la whitelist Minecraft.`
+          : `❌ La demande de ${username} a été refusée.`,
+      embeds: result
+        ? [
+            {
+              title: "Réponse RCON",
+              description: result || "Commande exécutée.",
+              color: decision === "accept" ? 0x33e879 : 0xff5c5c,
+            },
+          ]
+        : undefined,
+    }),
+  });
+}
+
+export async function applyWhitelistDecision(
+  username: string,
+  decision: WhitelistDecision,
+) {
+  if (decision === "reject") {
+    await sendWhitelistDecisionToDiscord(username, decision);
+    return "Demande refusée.";
+  }
+
+  const result = await sendRconCommand(`whitelist add ${username}`);
+  await sendWhitelistDecisionToDiscord(username, decision, result);
+
+  return result || `${username} ajouté à la whitelist.`;
+}