@helyx/bot 1.0.1 → 1.2.0

package/dist/developer-operations-module.js

@@ -4,7 +4,7 @@ import { SHARD_CONTROL_TIMEOUT_MS, assertShardMessageSize, shardOperationsHealth
 import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const DEVELOPER_MODULE_ID = "helyx.developer-operations";
 const DEVELOPER_MODULE_NAME = "Helyx Developer Operations";
-const DEVELOPER_MODULE_VERSION = "0.2.0";
+const DEVELOPER_MODULE_VERSION = "0.3.0";
 const MAX_MODULE_LINES = 8;
 export function createDeveloperOperationsModule(input) {
     const approvedRoles = new Set(input.approvedRoleIds);
@@ -15,13 +15,24 @@ export function createDeveloperOperationsModule(input) {
             id: DEVELOPER_MODULE_ID,
             name: DEVELOPER_MODULE_NAME,
             version: DEVELOPER_MODULE_VERSION,
-            description: "Private read-only development operations for Helyx support.",
+            description: "Private development and hosted-server operations for Helyx staff.",
             entry: "./dist/developer-operations-module.js",
             framework: "^0.1.0",
             dependencies: [],
             permissions: [],
             contributions: { commands: ["dev"], events: [] },
         },
+        defaultPermissions: {
+            module: restrictedPolicy(),
+            commands: Object.fromEntries([
+                "dev.shards",
+                "dev.bot",
+                "dev.proc",
+                "dev.trivia-data",
+                "dev.leave",
+                "dev.blacklist",
+            ].map((id) => [id, restrictedPolicy()])),
+        },
         interactions: {
             commands: [
                 {
@@ -33,6 +44,7 @@ export function createDeveloperOperationsModule(input) {
                     subcommands: [
                         {
                             name: "shards",
+                            permissionId: "dev.shards",
                             description: "Show bounded read-only shard health",
                             acknowledgement: "deferred-ephemeral",
                             authorization: "self-authorized",
@@ -83,6 +95,7 @@ export function createDeveloperOperationsModule(input) {
                         },
                         {
                             name: "bot",
+                            permissionId: "dev.bot",
                             description: "Show the bot build and installed module versions",
                             acknowledgement: "immediate-response",
                             authorization: "self-authorized",
@@ -137,6 +150,7 @@ export function createDeveloperOperationsModule(input) {
                         },
                         {
                             name: "proc",
+                            permissionId: "dev.proc",
                             description: "Show safe process resource and uptime information",
                             acknowledgement: "immediate-response",
                             authorization: "self-authorized",
@@ -171,6 +185,7 @@ export function createDeveloperOperationsModule(input) {
                         },
                         {
                             name: "trivia-data",
+                            permissionId: "dev.trivia-data",
                             description: "Show question counts from the Trivia database",
                             acknowledgement: "deferred-ephemeral",
                             authorization: "self-authorized",
@@ -220,6 +235,100 @@ export function createDeveloperOperationsModule(input) {
                                 });
                             },
                         },
+                        ...(input.moderation
+                            ? ["leave", "blacklist"].map((action) => ({
+                                name: action,
+                                permissionId: `dev.${action}`,
+                                description: action === "leave"
+                                    ? "Make hosted Helyx leave a server"
+                                    : "Blacklist a server and make hosted Helyx leave",
+                                acknowledgement: "deferred-ephemeral",
+                                authorization: "self-authorized",
+                                rateLimit: {
+                                    scope: "user",
+                                    limit: 3,
+                                    windowSeconds: 60,
+                                },
+                                options: [
+                                    {
+                                        type: "string",
+                                        name: "server_id",
+                                        description: "Discord server ID",
+                                        required: true,
+                                        minLength: 17,
+                                        maxLength: 20,
+                                    },
+                                    {
+                                        type: "string",
+                                        name: "reason",
+                                        description: "Private reason for this action",
+                                        required: true,
+                                        minLength: 3,
+                                        maxLength: 500,
+                                    },
+                                ],
+                                async execute(context) {
+                                    if (!(await authorizeDeveloperCommand(context)))
+                                        return;
+                                    const guildId = context
+                                        .getStringOption("server_id")
+                                        ?.trim();
+                                    const reason = context.getStringOption("reason")?.trim();
+                                    if (!guildId ||
+                                        !/^\d{17,20}$/u.test(guildId) ||
+                                        !reason ||
+                                        reason.length < 3 ||
+                                        reason.length > 500 ||
+                                        /[\r\n\0]/u.test(reason)) {
+                                        await context.reply({
+                                            ephemeral: true,
+                                            componentsV2: {
+                                                accentColor: 0xdc2626,
+                                                text: [
+                                                    {
+                                                        content: "The server ID or private reason is invalid.",
+                                                    },
+                                                ],
+                                            },
+                                        });
+                                        return;
+                                    }
+                                    try {
+                                        const result = await input.moderation.moderate({
+                                            action,
+                                            guildId,
+                                            actorUserId: context.userId,
+                                            reason,
+                                            idempotencyKey: `discord:${context.interactionId}`,
+                                        });
+                                        await context.reply({
+                                            ephemeral: true,
+                                            componentsV2: {
+                                                accentColor: 0x2563eb,
+                                                text: [
+                                                    {
+                                                        content: `## Hosted server ${action}\n${moderationOutcome(result.outcome)}\nOperation: \`${result.operationId}\`${result.paidSlotsReleased ? `\nPremium slots released: ${result.paidSlotsReleased}` : ""}`,
+                                                    },
+                                                ],
+                                            },
+                                        });
+                                    }
+                                    catch {
+                                        await context.reply({
+                                            ephemeral: true,
+                                            componentsV2: {
+                                                accentColor: 0xdc2626,
+                                                text: [
+                                                    {
+                                                        content: "The hosted moderation service is unavailable. The request was not reported as complete; retry with the same command when service is restored.",
+                                                    },
+                                                ],
+                                            },
+                                        });
+                                    }
+                                },
+                            }))
+                            : []),
                     ],
                 },
             ],
@@ -247,6 +356,31 @@ export function createDeveloperOperationsModule(input) {
         return false;
     }
 }
+function restrictedPolicy() {
+    return {
+        everyone: false,
+        requiredPermissions: ["ADMINISTRATOR"],
+        allowedRoleIds: [],
+        deniedRoleIds: [],
+        allowedUserIds: [],
+        deniedUserIds: [],
+    };
+}
+function moderationOutcome(outcome) {
+    if (outcome === "queued")
+        return "Accepted. Helyx will leave through the durable delivery queue.";
+    if (outcome === "already_blacklisted")
+        return "No new blacklist was created; this server is already blacklisted.";
+    if (outcome === "not_currently_installed")
+        return "Recorded. Helyx is not currently installed in that server.";
+    if (outcome === "accepted_for_retry")
+        return "Accepted for a safe retry.";
+    if (outcome === "requires_review")
+        return "Recorded and flagged for staff review.";
+    if (outcome === "completed")
+        return "Completed.";
+    return "The request was recorded but did not complete.";
+}
 function safeInlineCode(value) {
     return `\`${value.replaceAll("`", "'").slice(0, 120)}\``;
 }

package/dist/discord-analytics.d.ts

@@ -1,6 +1,7 @@
 import type { DiscordAnalyticsInspectionService } from "@helyx/sdk";
 import { type Client } from "discord.js";
 export declare class DiscordAnalyticsInspection implements DiscordAnalyticsInspectionService {
+    #private;
     private readonly client;
     constructor(client: Client);
     listChannels(input: {
@@ -25,6 +26,8 @@ export declare class DiscordAnalyticsInspection implements DiscordAnalyticsInspe
         limit: number;
         includeArchived: boolean;
         includePrivate: boolean;
+        signal?: AbortSignal;
     }): ReturnType<DiscordAnalyticsInspectionService["listThreads"]>;
+    private activeThreads;
 }
 //# sourceMappingURL=discord-analytics.d.ts.map

package/dist/discord-analytics.js

@@ -2,8 +2,10 @@ import { ChannelType, GatewayIntentBits, PermissionFlagsBits, } from "discord.js
 const MAX_MESSAGE_PAGE = 100;
 const MAX_MEMBER_PAGE = 1_000;
 const MAX_THREAD_PAGE = 100;
+const ACTIVE_THREAD_CACHE_MS = 15_000;
 export class DiscordAnalyticsInspection {
     client;
+    #activeThreads = new WeakMap();
     constructor(client) {
         this.client = client;
     }
@@ -147,12 +149,12 @@ export class DiscordAnalyticsInspection {
         if (input.cursor && !cursor)
             return unavailable("not_supported");
         try {
-            const parents = await threadParents(guild, input.parentChannelId);
+            const parents = await abortable(threadParents(guild, input.parentChannelId), input.signal);
             const privateCoverage = privateThreadCoverage(guild);
             const current = cursor ?? { phase: "active", offset: 0 };
             if (current.phase === "active") {
-                const active = await guild.channels.fetchActiveThreads(false);
-                const facts = [...active.threads.values()]
+                const active = await abortable(this.activeThreads(guild), input.signal);
+                const facts = active
                     .filter((thread) => !input.parentChannelId ||
                     thread.parentId === input.parentChannelId)
                     .sort((left, right) => left.id.localeCompare(right.id))
@@ -183,12 +185,12 @@ export class DiscordAnalyticsInspection {
                 const phase = phases[phaseIndex];
                 while (parentIndex < parents.length) {
                     const parent = parents[parentIndex];
-                    const page = await parent.threads.fetchArchived({
+                    const page = await abortable(parent.threads.fetchArchived({
                         type: phase,
                         fetchAll: phase === "private" && privateCoverage === "all",
                         limit,
                         ...(before ? { before } : {}),
-                    }, false);
+                    }, false), input.signal);
                     const threads = [...page.threads.values()].sort((left, right) => left.id.localeCompare(right.id));
                     const items = threads.map((thread) => threadFact(guild, thread));
                     if (page.hasMore && threads.length > 0) {
@@ -228,6 +230,23 @@ export class DiscordAnalyticsInspection {
             return unavailable("discord_unavailable");
         }
     }
+    activeThreads(guild) {
+        const cached = this.#activeThreads.get(guild);
+        if (cached && cached.expiresAt > Date.now())
+            return cached.promise;
+        const promise = guild.channels
+            .fetchActiveThreads(false)
+            .then((response) => [...response.threads.values()]);
+        this.#activeThreads.set(guild, {
+            expiresAt: Date.now() + ACTIVE_THREAD_CACHE_MS,
+            promise,
+        });
+        void promise.catch(() => {
+            if (this.#activeThreads.get(guild)?.promise === promise)
+                this.#activeThreads.delete(guild);
+        });
+        return promise;
+    }
 }
 function analyticsChannelType(channel) {
     switch (channel.type) {
@@ -246,6 +265,10 @@ function analyticsChannelType(channel) {
     }
 }
 async function threadParents(guild, parentChannelId) {
+    if (parentChannelId) {
+        const channel = await guild.channels.fetch(parentChannelId);
+        return channel && "threads" in channel ? [channel] : [];
+    }
     const channels = await guild.channels.fetch();
     return [...channels.values()]
         .filter((channel) => channel !== null &&
@@ -334,4 +357,25 @@ function snowflakeTimestamp(id) {
 function unavailable(code) {
     return { available: false, code };
 }
+function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason instanceof Error
+            ? signal.reason
+            : new Error("Discord Analytics inspection was aborted"));
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        signal.addEventListener("abort", abort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error instanceof Error ? error : new Error("Discord read failed"));
+        });
+    });
+}
 //# sourceMappingURL=discord-analytics.js.map

package/dist/discord-auto-moderation-service.d.ts

@@ -0,0 +1,21 @@
+import type { DiscordAutoModerationAction, DiscordAutoModerationMutationResult, DiscordAutoModerationRuleSnapshot, DiscordAutoModerationService } from "@helyx/sdk";
+import { type AutoModerationAction, type AutoModerationRule, type Client } from "discord.js";
+/** Discord REST adapter scoped to guilds owned by this client/shard. */
+export declare class DiscordAutoModerationAdapter implements DiscordAutoModerationService {
+    #private;
+    private readonly client;
+    constructor(client: Client);
+    list(input: {
+        guildId: string;
+    }): Promise<readonly DiscordAutoModerationRuleSnapshot[]>;
+    read(input: {
+        guildId: string;
+        ruleId: string;
+    }): Promise<DiscordAutoModerationRuleSnapshot | null>;
+    create(input: Parameters<DiscordAutoModerationService["create"]>[0]): Promise<DiscordAutoModerationMutationResult>;
+    update(input: Parameters<DiscordAutoModerationService["update"]>[0]): Promise<DiscordAutoModerationMutationResult>;
+    delete(input: Parameters<DiscordAutoModerationService["delete"]>[0]): Promise<DiscordAutoModerationMutationResult>;
+}
+export declare function toRuleSnapshot(rule: AutoModerationRule): DiscordAutoModerationRuleSnapshot;
+export declare function fromDiscordAction(action: AutoModerationAction): DiscordAutoModerationAction;
+//# sourceMappingURL=discord-auto-moderation-service.d.ts.map