@helyx/bot 1.1.0 → 1.2.0

package/dist/discord-message-enforcement-service.js

@@ -0,0 +1,102 @@
+import { DiscordAPIError, PermissionFlagsBits, } from "discord.js";
+const MODERATION_MODULE_ID = "helyx.moderation";
+const SNOWFLAKE_PATTERN = /^\d{17,20}$/u;
+const OPERATION_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u;
+/** Deletes only a positively identified member-authored guild message. */
+export class DiscordMessageEnforcementAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteMemberMessage(input) {
+        validateInput(input);
+        if (input.callerModuleId !== MODERATION_MODULE_ID)
+            return result("failed", "caller_not_allowed");
+        const guild = this.client.guilds.cache.get(input.guildId);
+        if (!guild)
+            return result("failed", "guild_not_owned");
+        const channel = await guild.channels
+            .fetch(input.channelId)
+            .catch(() => null);
+        if (!channel ||
+            channel.guild.id !== input.guildId ||
+            !channel.isTextBased() ||
+            channel.isDMBased())
+            return result("already_absent");
+        const me = guild.members.me;
+        if (!me ||
+            !channel.permissionsFor(me).has(PermissionFlagsBits.ManageMessages))
+            return result("missing_permission", "manage_messages");
+        let message;
+        try {
+            message = await fetchMessage(channel, input.messageId);
+        }
+        catch (error) {
+            if (isDiscordStatus(error, 403))
+                return result("missing_permission", "discord_forbidden");
+            if (error instanceof DiscordAPIError)
+                return result("failed", `discord_${error.code}`.slice(0, 80));
+            return result("ambiguous", "discord_transport_unknown");
+        }
+        if (!message)
+            return result("already_absent");
+        if (message.guildId !== input.guildId ||
+            message.channelId !== input.channelId ||
+            message.author.id !== input.expectedAuthorUserId)
+            return result("author_mismatch");
+        if (!(await safelyRevalidate(() => input.revalidate())))
+            return result("failed", "revalidation_rejected");
+        try {
+            await message.delete();
+            return result("deleted");
+        }
+        catch (error) {
+            if (isDiscordStatus(error, 404))
+                return result("already_absent");
+            if (isDiscordStatus(error, 403))
+                return result("missing_permission", "discord_forbidden");
+            if (error instanceof DiscordAPIError)
+                return result("failed", `discord_${error.code}`.slice(0, 80));
+            return result("ambiguous", "discord_transport_unknown");
+        }
+    }
+}
+async function fetchMessage(channel, messageId) {
+    try {
+        return await channel.messages.fetch(messageId);
+    }
+    catch (error) {
+        if (isDiscordStatus(error, 404))
+            return null;
+        throw error;
+    }
+}
+function validateInput(input) {
+    for (const value of [
+        input.guildId,
+        input.channelId,
+        input.messageId,
+        input.expectedAuthorUserId,
+    ])
+        if (!SNOWFLAKE_PATTERN.test(value))
+            throw new Error("Message enforcement Discord identity is invalid");
+    if (!OPERATION_KEY_PATTERN.test(input.operationKey) ||
+        input.reason.trim().length < 1 ||
+        input.reason.length > 512)
+        throw new Error("Message enforcement metadata is invalid");
+}
+async function safelyRevalidate(revalidate) {
+    try {
+        return await revalidate();
+    }
+    catch {
+        return false;
+    }
+}
+function result(outcome, safeCode) {
+    return { outcome, ...(safeCode ? { safeCode } : {}) };
+}
+function isDiscordStatus(error, status) {
+    return error instanceof DiscordAPIError && error.status === status;
+}
+//# sourceMappingURL=discord-message-enforcement-service.js.map

package/dist/discord-violation-thread-service.d.ts

@@ -0,0 +1,33 @@
+import type { ViolationEvidenceReference, ViolationThreadConfigurationInspection, ViolationThreadDeliveryResult, ViolationThreadService } from "@helyx/sdk";
+import { type Client } from "discord.js";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+/** Guild-owner-routed adapter for role-gated private violation threads. */
+export declare class DiscordViolationThreadAdapter implements ViolationThreadService {
+    #private;
+    private readonly client;
+    constructor(client: Client);
+    inspectConfiguration(input: Parameters<ViolationThreadService["inspectConfiguration"]>[0]): Promise<ViolationThreadConfigurationInspection>;
+    createAccessRole(input: Parameters<ViolationThreadService["createAccessRole"]>[0]): ReturnType<ViolationThreadService["createAccessRole"]>;
+    configureParent(input: Parameters<ViolationThreadService["configureParent"]>[0]): ReturnType<ViolationThreadService["configureParent"]>;
+    create(input: Parameters<ViolationThreadService["create"]>[0]): ReturnType<ViolationThreadService["create"]>;
+    addMember(input: Parameters<ViolationThreadService["addMember"]>[0]): ReturnType<ViolationThreadService["addMember"]>;
+    removeMember(input: Parameters<ViolationThreadService["removeMember"]>[0]): ReturnType<ViolationThreadService["removeMember"]>;
+    send(input: Parameters<ViolationThreadService["send"]>[0]): ReturnType<ViolationThreadService["send"]>;
+    close(input: Parameters<ViolationThreadService["close"]>[0]): ReturnType<ViolationThreadService["close"]>;
+    reconcile(input: Parameters<ViolationThreadService["reconcile"]>[0]): ReturnType<ViolationThreadService["reconcile"]>;
+}
+export interface DiscordViolationEvidenceDeliveryInput {
+    guildId: string;
+    threadId: string;
+    evidenceReference: ViolationEvidenceReference;
+    operationKey: string;
+}
+/** Bot-private capability; never installed in the module service map. */
+export declare class DiscordViolationEvidenceDeliveryAdapter {
+    #private;
+    private readonly client;
+    private readonly evidence;
+    constructor(client: Client, evidence: TransientViolationEvidenceStore);
+    deliverEvidence(input: DiscordViolationEvidenceDeliveryInput): Promise<ViolationThreadDeliveryResult>;
+}
+//# sourceMappingURL=discord-violation-thread-service.d.ts.map