@helyx/bot 0.4.43 → 0.4.46

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.4.46
+
+### Patch Changes
+
+- Add explicit role-mention allowlists and member-leave identity metadata to the
+  module runtime contract. Upgrade Welcome with multiline user, role and channel
+  placeholders, an inline dashboard test send, and independent member-left
+  logging.
+
+## 0.4.45
+
+### Patch Changes
+
+- Expose bounded structural user mentions to guild message event contributions without exposing message content, and include AFK in the reviewed self-host catalogue.
+
+## 0.4.44
+
+### Patch Changes
+
+- c369ae4: Publish the complete loaded feature catalogue to the Status synchroniser while keeping global availability controls limited to customer-selectable modules.
+
 ## 0.4.43
 
 ### Patch Changes

package/dist/control-errors.d.ts

@@ -0,0 +1,11 @@
+import { type PermissionMutationDenialReason } from "@helyx/core";
+export declare class BotControlForbiddenError extends Error {
+    constructor(message?: string);
+}
+export declare function assertPermissionMutationAllowed(decision: {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: PermissionMutationDenialReason;
+}): void;
+//# sourceMappingURL=control-errors.d.ts.map

package/dist/control-errors.js

@@ -0,0 +1,13 @@
+import { permissionMutationDenialMessage, } from "@helyx/core";
+export class BotControlForbiddenError extends Error {
+    constructor(message = "You no longer have permission to perform this action") {
+        super(message);
+        this.name = "BotControlForbiddenError";
+    }
+}
+export function assertPermissionMutationAllowed(decision) {
+    if (decision.allowed)
+        return;
+    throw new BotControlForbiddenError(permissionMutationDenialMessage(decision.reason));
+}
+//# sourceMappingURL=control-errors.js.map

package/dist/control-server.d.ts

@@ -350,7 +350,7 @@ export declare class BotControlService implements BotControlHandler {
     constructor(database: DatabasePool, modules: readonly ModuleDefinition[], resources: BotControlGuildResourceDirectory, services: ServiceAccess, privacyExecutor?: PrivacyProviderExecutor, supportNotifications?: {
         guildId: string;
         channelId: string;
-    } | undefined, presenceOwnership?: GuildShardOwnership | undefined, presenceShardCount?: number | undefined);
+    } | undefined, presenceOwnership?: GuildShardOwnership | undefined, presenceShardCount?: number | undefined, statusModules?: readonly ModuleDefinition[]);
     cleanupOAuthConsumer(input: {
         consumerBindingId: string;
         moduleId: string;

package/dist/control-server.js

@@ -1,7 +1,7 @@
 import { AuditRepository, GuildAccessPolicyRepository, GuildCommandActiveLeaseError, GuildCommandRevisionConflictError, GuildCommandSetupConflictError, InstallationRepository, ModuleLoggingPolicyRepository, OptimisticConcurrencyError, PermissionPolicyRepository, withTransaction, } from "@helyx/database";
 import { DashboardActionValidationError, DEFAULT_GUILD_ACCESS_POLICY, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
 import { actionReceiptSchema, signedAssessmentEnvelopeSchema, } from "@helyx/verification-contracts";
-import { canAccessGuildDashboard, canMutatePermissionPolicy, canUseCommand, permissionMutationDenialMessage, resolveHelyxAuthority, } from "@helyx/core";
+import { canAccessGuildDashboard, canMutatePermissionPolicy, canUseCommand, resolveHelyxAuthority, } from "@helyx/core";
 import { ChannelType, PermissionFlagsBits } from "discord.js";
 import Fastify, {} from "fastify";
 import { createHash, timingSafeEqual } from "node:crypto";
@@ -12,8 +12,9 @@ import { completeFirstTimeCommandSetup, } from "./first-time-command-setup.js";
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.js";
 import { dashboardCategoryLabel } from "./dashboard-category.js";
 import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
+import { assertPermissionMutationAllowed, BotControlForbiddenError, } from "./control-errors.js";
 import { dashboardCommands, } from "./dashboard-commands.js";
-import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, } from "./module-availability-control.js";
+import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, statusCatalogueDefinitions, } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
 import { createPrivacyProviderRegistry, describePrivacyProviders, } from "./privacy-provider-registry.js";
 const snowflake = z.string().regex(/^\d{17,20}$/u);
@@ -265,12 +266,13 @@ export class BotControlService {
     #modules;
     #dashboardModules;
     #availabilityModules;
+    #statusModules;
     #configurations;
     #installations;
     #permissions;
     #services;
     #privacyProviders;
-    constructor(database, modules, resources, services, privacyExecutor, supportNotifications, presenceOwnership, presenceShardCount) {
+    constructor(database, modules, resources, services, privacyExecutor, supportNotifications, presenceOwnership, presenceShardCount, statusModules) {
         this.database = database;
         this.resources = resources;
         this.supportNotifications = supportNotifications;
@@ -281,6 +283,7 @@ export class BotControlService {
             .filter((module) => module.manifest.dashboard !== undefined)
             .map(mapDashboardModule);
         this.#availabilityModules = availabilityCatalogueDefinitions(modules);
+        this.#statusModules = statusCatalogueDefinitions(statusModules ?? modules);
         this.#configurations = services.get(HELYX_SERVICE_NAMES.configuration);
         this.#installations = services.get(HELYX_SERVICE_NAMES.installations);
         this.#permissions = services.get(HELYX_SERVICE_NAMES.permissions);
@@ -1037,7 +1040,7 @@ export class BotControlService {
         return module;
     }
     listAvailabilityModules() {
-        return availabilityCatalogue(this.#availabilityModules);
+        return availabilityCatalogue(this.#availabilityModules, this.#statusModules);
     }
     async #requireModuleAvailable(moduleIdValue) {
         const availability = moduleAvailabilityService(this.#services);
@@ -1743,12 +1746,6 @@ class BotControlNotFoundError extends Error {
         this.name = "BotControlNotFoundError";
     }
 }
-class BotControlForbiddenError extends Error {
-    constructor(message = "You no longer have permission to perform this action") {
-        super(message);
-        this.name = "BotControlForbiddenError";
-    }
-}
 function digest(value) {
     return createHash("sha256").update(value).digest();
 }
@@ -1905,9 +1902,4 @@ function mapDashboardModule(module) {
             : undefined,
     };
 }
-function assertPermissionMutationAllowed(decision) {
-    if (decision.allowed)
-        return;
-    throw new BotControlForbiddenError(permissionMutationDenialMessage(decision.reason));
-}
 //# sourceMappingURL=control-server.js.map

package/dist/events.js

@@ -343,6 +343,7 @@ export function installModuleEvents(client, modules, logger, services) {
         const authorDisplayName = message.member?.displayName ??
             message.author.globalName ??
             message.author.username;
+        const mentionedUserIds = [...message.mentions.users.keys()].slice(0, 25);
         let classifiedMessage;
         for (const { moduleId, classificationRequested, contribution, } of guildMessageContributions) {
             try {
@@ -362,6 +363,7 @@ export function installModuleEvents(client, modules, logger, services) {
                     authorIsBot: false,
                     authorIsWebhook: false,
                     authorIsSystem: false,
+                    mentionedUserIds,
                     get classification() {
                         if (!classificationRequested || !messageClassificationAvailable)
                             return unavailableGuildMessageClassification;
@@ -523,7 +525,9 @@ export function installModuleEvents(client, modules, logger, services) {
                 }
                 await contribution.execute({
                     serverId: member.guild.id,
+                    serverName: member.guild.name,
                     memberId: member.id,
+                    memberDisplayName: member.displayName,
                     memberIsBot: member.user.bot,
                     accountCreatedAt: member.user.createdAt,
                     joinedAt: member.joinedAt,

package/dist/index.js

@@ -403,7 +403,7 @@ async function startUnshardedBot(processEnvironment) {
                 guildId: environment.DISCORD_INTERNAL_GUILD_ID,
                 channelId: environment.HELYX_SUPPORT_STAFF_CHANNEL_ID,
             }
-            : undefined);
+            : undefined, undefined, undefined, featureModules);
         cloudConnector.setControlHandler(controlService);
         let controlServer;
         let shuttingDown = false;

package/dist/interactions.js

@@ -1003,7 +1003,7 @@ export function normalizeDiscordPermission(permission) {
     return permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
 }
 export function toReplyOptions(response) {
-    const allowedMentions = toAllowedUserMentions(response.allowedUserMentionIds);
+    const allowedMentions = toAllowedMentions(response.allowedUserMentionIds, response.allowedRoleMentionIds);
     const selectRows = toSelectRows(response);
     if (response.componentsV2) {
         if (response.content !== undefined) {
@@ -1154,15 +1154,25 @@ export function toUpdateOptions(response) {
         ephemeral: false,
     });
 }
-function toAllowedUserMentions(userIds) {
-    if (userIds === undefined)
+function toAllowedMentions(userIds, roleIds) {
+    if (userIds === undefined && roleIds === undefined)
         return undefined;
-    if (userIds.length > 100 ||
-        new Set(userIds).size !== userIds.length ||
-        userIds.some((userId) => !/^\d{17,20}$/u.test(userId))) {
-        throw new Error("Allowed user mentions must be unique Discord snowflakes");
+    validateAllowedMentionIds(userIds, "user");
+    validateAllowedMentionIds(roleIds, "role");
+    return {
+        parse: [],
+        ...(userIds === undefined ? {} : { users: [...userIds] }),
+        ...(roleIds === undefined ? {} : { roles: [...roleIds] }),
+    };
+}
+function validateAllowedMentionIds(ids, label) {
+    if (ids === undefined)
+        return;
+    if (ids.length > 100 ||
+        new Set(ids).size !== ids.length ||
+        ids.some((id) => !/^\d{17,20}$/u.test(id))) {
+        throw new Error(`Allowed ${label} mentions must be unique Discord snowflakes`);
     }
-    return { parse: [], users: [...userIds] };
 }
 function toButtonEmoji(emojiIdentifier) {
     const custom = /^([A-Za-z0-9_]{2,32}):(\d{17,20})$/u.exec(emojiIdentifier);

package/dist/module-availability-control.d.ts

@@ -8,10 +8,13 @@ export interface AvailabilityModuleDefinition {
 export interface AvailabilityModuleCatalogue {
     catalogueDigest: string;
     modules: AvailabilityModuleDefinition[];
+    statusCatalogueDigest?: string;
+    statusModules?: AvailabilityModuleDefinition[];
 }
 export declare function availabilityCatalogueDefinitions(modules: readonly ModuleDefinition[]): AvailabilityModuleDefinition[];
-export declare function availabilityCatalogueSnapshot(definitions: readonly AvailabilityModuleDefinition[]): AvailabilityModuleCatalogue;
-export declare function availabilityCatalogue(definitions: readonly AvailabilityModuleDefinition[]): Promise<AvailabilityModuleCatalogue>;
+export declare function statusCatalogueDefinitions(modules: readonly ModuleDefinition[]): AvailabilityModuleDefinition[];
+export declare function availabilityCatalogueSnapshot(definitions: readonly AvailabilityModuleDefinition[], statusDefinitions?: readonly AvailabilityModuleDefinition[]): AvailabilityModuleCatalogue;
+export declare function availabilityCatalogue(definitions: readonly AvailabilityModuleDefinition[], statusDefinitions?: readonly AvailabilityModuleDefinition[]): Promise<AvailabilityModuleCatalogue>;
 export declare function moduleAvailabilityService(services: ServiceAccess): ModuleAvailabilityService | undefined;
 export declare function moduleAvailabilityStates(services: ServiceAccess, moduleIds: readonly string[]): Promise<ModuleAvailabilityState[]>;
 export declare function dashboardModuleStatus(globallyDisabled: ReadonlySet<string>, moduleId: string, installation: {

package/dist/module-availability-control.js

@@ -12,17 +12,31 @@ export function availabilityCatalogueDefinitions(modules) {
     }))
         .sort((left, right) => left.name.localeCompare(right.name, "en-GB"));
 }
-export function availabilityCatalogueSnapshot(definitions) {
+export function statusCatalogueDefinitions(modules) {
+    return modules
+        .map(({ manifest }) => ({
+        id: manifest.id,
+        name: manifest.name,
+        version: manifest.version,
+        releaseStatus: manifest.releaseStatus,
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name, "en-GB"));
+}
+function catalogueDigest(definitions) {
+    return createHash("sha256").update(JSON.stringify(definitions)).digest("hex");
+}
+export function availabilityCatalogueSnapshot(definitions, statusDefinitions = definitions) {
     const modules = definitions.map((module) => ({ ...module }));
+    const statusModules = statusDefinitions.map((module) => ({ ...module }));
     return {
-        catalogueDigest: createHash("sha256")
-            .update(JSON.stringify(modules))
-            .digest("hex"),
+        catalogueDigest: catalogueDigest(modules),
         modules,
+        statusCatalogueDigest: catalogueDigest(statusModules),
+        statusModules,
     };
 }
-export function availabilityCatalogue(definitions) {
-    return Promise.resolve(availabilityCatalogueSnapshot(definitions));
+export function availabilityCatalogue(definitions, statusDefinitions = definitions) {
+    return Promise.resolve(availabilityCatalogueSnapshot(definitions, statusDefinitions));
 }
 export function moduleAvailabilityService(services) {
     if (!services.has(HELYX_SERVICE_NAMES.moduleAvailability))

package/dist/shard-supervisor.js

@@ -25,7 +25,7 @@ import { createSupportModule } from "./support-module.js";
 import { createOAuthModule } from "./oauth-module.js";
 import { createPrivacyModule } from "./privacy-module.js";
 import { discordRestOptions } from "./discord-rest.js";
-import { availabilityCatalogue, availabilityCatalogueDefinitions, } from "./module-availability-control.js";
+import { availabilityCatalogue, availabilityCatalogueDefinitions, statusCatalogueDefinitions, } from "./module-availability-control.js";
 import { createScheduledTaskRunner, schedulerOperationalHealth, } from "./scheduled-task-runner.js";
 import { numericWriteBehindRegistrations } from "./numeric-write-behind.js";
 import { PostgresTriviaDataProvider } from "./trivia-data-provider.js";
@@ -257,8 +257,9 @@ export async function startShardSupervisor(environment, processEnvironment, work
         ];
         commandModules = modules;
         const availabilityModules = availabilityCatalogueDefinitions(modules);
+        const statusModules = statusCatalogueDefinitions(featureModules);
         const availabilityService = {
-            listAvailabilityModules: () => availabilityCatalogue(availabilityModules),
+            listAvailabilityModules: () => availabilityCatalogue(availabilityModules, statusModules),
         };
         const initialiseLeader = async () => {
             await runLeaderStartup(database, environment, modulePackages, modules, logger);

package/dist/shard-worker.js

@@ -259,7 +259,7 @@ export async function startShardWorker(processEnvironment = process.env, identit
                 guildId: environment.DISCORD_INTERNAL_GUILD_ID,
                 channelId: environment.HELYX_SUPPORT_STAFF_CHANNEL_ID,
             }
-            : undefined, shardOwnership, identity.shardCount);
+            : undefined, shardOwnership, identity.shardCount, featureModules);
         process.on("message", (raw) => {
             const parsed = supervisorMessageSchema.safeParse(raw);
             if (!parsed.success)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/bot",
-  "version": "0.4.43",
+  "version": "0.4.46",
   "description": "Production Discord runtime for the modular Helyx platform.",
   "keywords": [
     "helyx",