@helyx/bot 0.4.1 → 0.4.4

package/dist/developer-operations-module.js

@@ -44,6 +44,13 @@ export function createDeveloperOperationsModule(input) {
                                         : `${Math.round(shard.gatewayPingMs)}ms`;
                                     return `\`${shard.shardId}\` ${shard.status} · ${shard.guildCount} guilds · ${ping} · restarts ${shard.restartCount}`;
                                 });
+                                const schedulerLines = health.scheduler?.status === "available"
+                                    ? [
+                                        "Scheduler: available",
+                                        `One-shot: ${health.scheduler.oneShot.ready} ready / ${health.scheduler.oneShot.expiredLeases} expired leases / ${health.scheduler.oneShot.requiresReview} review`,
+                                        `Coalesced: ${health.scheduler.coalesced.ready} ready / ${health.scheduler.coalesced.expiredLeases} expired leases / ${health.scheduler.coalesced.requiresReview} review`,
+                                    ]
+                                    : ["Scheduler: unavailable"];
                                 await context.reply({
                                     ephemeral: true,
                                     componentsV2: {
@@ -56,6 +63,7 @@ export function createDeveloperOperationsModule(input) {
                                                     `Mode: ${health.mode}/${health.scope}`,
                                                     `Generation: \`${health.generation}\``,
                                                     `Observed: ${health.observedAt}`,
+                                                    ...schedulerLines,
                                                     "",
                                                     ...shardLines,
                                                     ...(health.shards.length < health.configuredShardCount

package/dist/discord-owned-message-service.d.ts

@@ -0,0 +1,39 @@
+import type { DiscordOwnedMessageService, MessageResponse } from "@helyx/sdk";
+import { type Client } from "discord.js";
+export declare class DiscordOwnedMessageDeletionService implements DiscordOwnedMessageService {
+    #private;
+    private readonly client;
+    constructor(client: Client);
+    addOwnedMessageReaction(input: {
+        guildId: string;
+        channelId: string;
+        messageId: string;
+        emojiIdentifier: string;
+    }): Promise<{
+        added: boolean;
+    }>;
+    clearOwnedMessageReaction(input: {
+        guildId: string;
+        channelId: string;
+        messageId: string;
+        emojiIdentifier: string;
+    }): Promise<{
+        cleared: boolean;
+    }>;
+    deleteOwnedMessage(input: {
+        guildId: string;
+        channelId: string;
+        messageId: string;
+    }): Promise<{
+        deleted: boolean;
+    }>;
+    editOwnedMessage(input: {
+        guildId: string;
+        channelId: string;
+        messageId: string;
+        response: MessageResponse;
+    }): Promise<{
+        edited: boolean;
+    }>;
+}
+//# sourceMappingURL=discord-owned-message-service.d.ts.map

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

@@ -0,0 +1,138 @@
+import { RESTJSONErrorCodes } from "discord.js";
+import { deleteChannelMessage, toUpdateOptions } from "./interactions.js";
+const discordSnowflake = /^\d{17,20}$/u;
+export class DiscordOwnedMessageDeletionService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async addOwnedMessageReaction(input) {
+        const emoji = prepareEmojiIdentifier(input.emojiIdentifier);
+        const message = await this.#fetchOwnedMessage(input);
+        if (!message)
+            return { added: false };
+        await message.react(emoji.identifier);
+        return { added: true };
+    }
+    async clearOwnedMessageReaction(input) {
+        const emoji = prepareEmojiIdentifier(input.emojiIdentifier);
+        const message = await this.#fetchOwnedMessage(input);
+        if (!message)
+            return { cleared: false };
+        const reaction = message.reactions.resolve(emoji.cacheKey);
+        if (!reaction)
+            return { cleared: false };
+        await reaction.remove();
+        return { cleared: true };
+    }
+    async deleteOwnedMessage(input) {
+        validateSnowflake(input.guildId, "guild");
+        validateSnowflake(input.channelId, "channel");
+        validateSnowflake(input.messageId, "message");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const channel = await guild.channels.fetch(input.channelId);
+        if (!channel ||
+            channel.id !== input.channelId ||
+            channel.guild.id !== guild.id)
+            throw new Error("Discord channel validation failed");
+        if (!channel.isTextBased() || !channel.viewable)
+            throw new Error("Discord channel is not a bot-accessible text channel");
+        const botUserId = this.client.user?.id;
+        if (!botUserId)
+            throw new Error("Discord bot user is unavailable");
+        try {
+            const message = await channel.messages.fetch(input.messageId);
+            if (message.id !== input.messageId ||
+                message.channelId !== channel.id ||
+                message.guildId !== guild.id)
+                throw new Error("Discord message validation failed");
+            if (message.author.id !== botUserId)
+                throw new Error("Discord message is not owned by Helyx");
+            await deleteChannelMessage(this.client, input.channelId, input.messageId);
+            return { deleted: true };
+        }
+        catch (error) {
+            if (isUnknownMessage(error))
+                return { deleted: false };
+            throw error;
+        }
+    }
+    async editOwnedMessage(input) {
+        const message = await this.#fetchOwnedMessage(input);
+        if (!message)
+            return { edited: false };
+        await message.edit(toUpdateOptions(input.response));
+        return { edited: true };
+    }
+    async #fetchOwnedMessage(input) {
+        validateSnowflake(input.guildId, "guild");
+        validateSnowflake(input.channelId, "channel");
+        validateSnowflake(input.messageId, "message");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const channel = await guild.channels.fetch(input.channelId);
+        if (!channel ||
+            channel.id !== input.channelId ||
+            channel.guild.id !== guild.id)
+            throw new Error("Discord channel validation failed");
+        if (!channel.isTextBased() || !channel.viewable)
+            throw new Error("Discord channel is not a bot-accessible text channel");
+        const botUserId = this.client.user?.id;
+        if (!botUserId)
+            throw new Error("Discord bot user is unavailable");
+        try {
+            const message = await channel.messages.fetch(input.messageId);
+            if (message.id !== input.messageId ||
+                message.channelId !== channel.id ||
+                message.guildId !== guild.id)
+                throw new Error("Discord message validation failed");
+            if (message.author.id !== botUserId)
+                throw new Error("Discord message is not owned by Helyx");
+            return message;
+        }
+        catch (error) {
+            if (isUnknownMessage(error))
+                return null;
+            throw error;
+        }
+    }
+}
+function validateSnowflake(value, label) {
+    if (!discordSnowflake.test(value))
+        throw new Error(`Invalid Discord ${label} ID`);
+}
+function prepareEmojiIdentifier(value) {
+    if (value.length < 1 || value.length > 128 || /[\r\n]/u.test(value)) {
+        throw new Error("Invalid bounded Discord emoji identifier");
+    }
+    const custom = /^(?:<a?:([A-Za-z0-9_]{2,32}):(\d{17,20})>|([A-Za-z0-9_]{2,32}):(\d{17,20}))$/u.exec(value);
+    if (custom) {
+        const name = custom[1] ?? custom[3];
+        const id = custom[2] ?? custom[4];
+        return {
+            identifier: `${name}:${id}`,
+            cacheKey: id,
+        };
+    }
+    const normalized = value.normalize("NFKC").trim();
+    const graphemes = [
+        ...new Intl.Segmenter("en", { granularity: "grapheme" }).segment(normalized),
+    ];
+    if (!/\p{Emoji}/u.test(normalized) || graphemes.length !== 1) {
+        throw new Error("Invalid Discord emoji identifier");
+    }
+    return {
+        identifier: normalized,
+        cacheKey: normalized,
+    };
+}
+function isUnknownMessage(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === RESTJSONErrorCodes.UnknownMessage);
+}
+//# sourceMappingURL=discord-owned-message-service.js.map

package/dist/events.d.ts

@@ -1,4 +1,4 @@
-import type { ModuleDefinition, ServiceAccess } from "@helyx/sdk";
+import type { DiscordChannelInspection, DiscordEmojiInspection, DiscordResourceInspectionService, DiscordRoleInspection, MemberRoleService, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
 import { type Client, type MessageReaction, type PartialMessageReaction } from "discord.js";
 import { type InteractionLogger } from "./interactions.js";
 export declare function installModuleEvents(client: Client, modules: readonly ModuleDefinition[], logger: InteractionLogger, services: ServiceAccess): ModuleEventHandle;
@@ -8,4 +8,73 @@ export interface ModuleEventHandle {
 }
 export declare function reactionEmojiKey(reaction: MessageReaction | PartialMessageReaction): string;
 export declare function reactionCacheKey(emojiIdentifier: string): string;
+interface ApprovedRoleMutation {
+    guildId: string;
+    memberUserId: string;
+    roleId: string;
+    moduleId: string;
+    reason: string;
+}
+export declare class DiscordMemberRoleService implements MemberRoleService {
+    private readonly client;
+    constructor(client: Client);
+    getCurrentRoleIds(input: {
+        guildId: string;
+        memberUserId: string;
+    }): Promise<readonly string[]>;
+    addApprovedRole(input: ApprovedRoleMutation): Promise<{
+        changed: boolean;
+    }>;
+    removeApprovedRole(input: ApprovedRoleMutation): Promise<{
+        changed: boolean;
+    }>;
+    reconcileApprovedRoles(input: {
+        guildId: string;
+        memberUserId: string;
+        allowedRoleIds: readonly string[];
+        desiredRoleIds: readonly string[];
+        moduleId: string;
+        reason: string;
+    }): Promise<{
+        added: readonly string[];
+        removed: readonly string[];
+    }>;
+    private fetchGuildAndMember;
+}
+export declare class DiscordResourceInspection implements DiscordResourceInspectionService {
+    #private;
+    private readonly client;
+    constructor(client: Client);
+    resolveMemberSnapshots(input: {
+        guildId: string;
+        userIds: readonly string[];
+    }): Promise<readonly {
+        userId: string;
+        exists: boolean;
+        isBot: boolean;
+        roleIds: readonly string[];
+        joinedAt: Date | null;
+    }[]>;
+    resolveMembers(input: {
+        guildId: string;
+        userIds: readonly string[];
+    }): Promise<readonly {
+        userId: string;
+        displayName: string | null;
+    }[]>;
+    inspectRole(input: {
+        guildId: string;
+        roleId: string;
+        actorUserId?: string;
+    }): Promise<DiscordRoleInspection>;
+    inspectEmoji(input: {
+        guildId: string;
+        emojiIdentifier: string;
+    }): Promise<DiscordEmojiInspection>;
+    inspectChannel(input: {
+        guildId: string;
+        channelId: string;
+    }): Promise<DiscordChannelInspection>;
+}
+export {};
 //# sourceMappingURL=events.d.ts.map