@stonyx/discord 0.1.1-beta.9 → 0.1.1-beta.90

package/README.md

@@ -68,20 +68,13 @@ export default class MessageCreateHandler extends EventHandler {
 
 ### 4. Start the bot
 
-With Stonyx auto-initialization (recommended):
+Stonyx auto-initializes the bot when your app boots — no manual wiring needed:
 
 ```bash
 stonyx serve
 ```
 
-Or manually:
-
-```javascript
-import { DiscordBot } from '@stonyx/discord';
-
-const bot = new DiscordBot();
-await bot.init();
-```
+`Discord.init()` (called by the Stonyx module loader) awaits `new DiscordBot().init()`, which discovers commands/events, derives intents, and connects to the gateway. The lazy-init guards still apply: if `DISCORD_TOKEN` is unset or no commands/events exist, the bot skips login.
 
 ## Command Architecture
 
@@ -185,7 +178,16 @@ All methods are on the `DiscordBot` instance (accessible via `this._bot` in comm
 
 ### sendMessage(content, channelId, imagePath?)
 
-Send a text message to a channel. Optionally attach an image file.
+Send a text message to a channel with auto-chunking. Messages over 2000 characters are split at newline/space boundaries and sent sequentially. Optionally attach an image file (attached to the first chunk only).
+
+Messages are delivered reliably across connection state transitions:
+- If the bot is **ready**, the message is sent immediately.
+- If the bot is **connecting or disconnected**, the message is queued and auto-delivered when the connection resumes.
+- **Transient failures** (5xx, network errors) are retried up to 3 times with exponential backoff.
+- Queued messages expire after **5 minutes** (TTL) — stale messages are rejected rather than sent late.
+- The queue holds up to **1000** messages; excess messages are rejected with a "queue full" error.
+
+The returned promise resolves when the message is actually delivered or rejects on permanent failure.
 
 ```javascript
 await bot.sendMessage('Hello world', '123456789');
@@ -248,10 +250,10 @@ const guild = await bot.getGuild();
 
 ### clearChannelMessages(channelId)
 
-Delete all fetched messages in a channel (up to `maxMessagesPerRequest`).
+Delete all fetched messages in a channel (up to `maxMessagesPerRequest`). Awaits every delete via `Promise.allSettled` and resolves with a structured `{ deleted, failed, errors }` so callers can act on partial failure. Never throws on individual delete failures; emits a single `log.warn` summary when any deletes fail.
 
 ```javascript
-await bot.clearChannelMessages('123456789');
+const { deleted, failed, errors } = await bot.clearChannelMessages('123456789');
 ```
 
 ### giveRole(memberId, roleId)
@@ -296,18 +298,18 @@ Configuration is read from `stonyx/config` under `discord`:
 | `commands` | `Object` — registered command instances keyed by name |
 | `eventHandlers` | `Array` — registered event handler instances |
 | `client` | Discord.js `Client` instance (after init) |
-| `ready` | `Promise` — resolves when the bot is connected and ready |
-| `sendMessage(content, channelId, imagePath?)` | Send a message to a channel |
+| `ready` | `Promise` — resolves when the bot is connected and ready; re-pends on gateway disconnects |
+| `sendMessage(content, channelId, imagePath?)` | Send a message to a channel with auto-chunking (queues during disconnections, retries transient failures) |
 | `sendFile(file, messageObject)` | Replace a message with a file attachment |
 | `reply(interaction, content)` | Reply with auto-chunking |
 | `updateStatus(name, type?)` | Set bot presence |
 | `getChannelMessages(channelId, options?)` | Fetch channel messages |
 | `getChannelMessage(channelId, messageId)` | Fetch a single message |
 | `getGuild(guildId?)` | Fetch a guild |
-| `clearChannelMessages(channelId)` | Delete messages in a channel |
+| `clearChannelMessages(channelId)` | Delete messages in a channel; returns `{ deleted, failed, errors }` and never throws on partial failure |
 | `giveRole(memberId, roleId)` | Add a role to a member |
-| `close()` | Destroy the Discord client and clear singleton |
-| `reset()` | Close + clear all commands and handlers |
+| `close()` | Destroy the Discord client, reject pending queue, clear singleton |
+| `reset()` | Close + clear all commands, handlers, and connection state |
 
 ### Command
 

package/dist/base.d.ts

@@ -0,0 +1 @@
+export { SlashCommandBuilder, MessageFlags, PermissionFlagsBits, GatewayIntentBits, AttachmentBuilder, Client, Partials, REST, Routes } from 'discord.js';

package/dist/base.js

@@ -0,0 +1 @@
+export { SlashCommandBuilder, MessageFlags, PermissionFlagsBits, GatewayIntentBits, AttachmentBuilder, Client, Partials, REST, Routes } from 'discord.js';

package/dist/bot.d.ts

@@ -0,0 +1,60 @@
+import { Client } from 'discord.js';
+import type { ChatInputCommandInteraction, Message } from 'discord.js';
+export interface ClearChannelMessagesResult {
+    deleted: number;
+    failed: number;
+    errors: Error[];
+}
+interface CommandInstance {
+    data?: {
+        name: string;
+    };
+    execute?: (interaction: ChatInputCommandInteraction) => Promise<void>;
+    _bot?: DiscordBot;
+    [key: string]: unknown;
+}
+interface EventHandlerInstance {
+    handle?: (...args: unknown[]) => void | Promise<void>;
+    _bot?: DiscordBot;
+    constructor: {
+        event: string | null;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export default class DiscordBot {
+    static instance: DiscordBot | null;
+    commands: Record<string, CommandInstance>;
+    eventHandlers: EventHandlerInstance[];
+    resolveReady: () => void;
+    ready: Promise<void>;
+    client: Client | null;
+    private _connectionState;
+    private _queue;
+    constructor();
+    init(): Promise<void>;
+    private _resetReady;
+    registerClientEvents(): void;
+    discoverCommands(): Promise<void>;
+    discoverEvents(): Promise<void>;
+    private _doSend;
+    sendMessage(content: string, channelId: string, imagePath?: string | null): Promise<Message>;
+    private _enqueue;
+    private _enqueueForRetry;
+    private _scheduleRetry;
+    private _processEntry;
+    private _flushQueue;
+    private _isRetryable;
+    private _ensureReady;
+    sendFile(file: string, messageObject: Message): Promise<Message>;
+    reply(interaction: ChatInputCommandInteraction, content: string): Promise<void>;
+    updateStatus(name: string, type?: number): Promise<void>;
+    getChannelMessages(channelId: string, options?: Record<string, unknown>): Promise<unknown>;
+    getChannelMessage(channelId: string, messageId: string): Promise<unknown>;
+    getGuild(guildId?: string): Promise<unknown>;
+    clearChannelMessages(channelId: string): Promise<ClearChannelMessagesResult>;
+    giveRole(memberId: string, roleId: string): Promise<void>;
+    close(): void;
+    reset(): void;
+}
+export {};

package/dist/bot.js

@@ -0,0 +1,423 @@
+import config from 'stonyx/config';
+import log from 'stonyx/log';
+import { Client, GatewayIntentBits, AttachmentBuilder, MessageFlags } from 'discord.js';
+import { forEachFileImport } from '@stonyx/utils/file';
+import { deriveIntents, derivePartials } from './intents.js';
+import { chunkMessage } from './message.js';
+const MAX_RETRIES = 3;
+const MAX_QUEUE_SIZE = 1000;
+const QUEUE_TTL = 300_000; // 5 minutes
+const READY_TIMEOUT = 30_000; // 30 seconds
+const RETRYABLE_NETWORK_CODES = new Set(['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED']);
+export default class DiscordBot {
+    static instance;
+    commands = {};
+    eventHandlers = [];
+    resolveReady;
+    ready = new Promise(resolve => { this.resolveReady = resolve; });
+    client = null;
+    _connectionState = 'connecting';
+    _queue = [];
+    constructor() {
+        if (DiscordBot.instance)
+            return DiscordBot.instance;
+        DiscordBot.instance = this;
+    }
+    async init() {
+        // Self-register so log.discord works even when @stonyx/discord is in the
+        // consumer's `dependencies` (stonyx loader only merges devDependencies).
+        const { logColor = '#7289da', logMethod = 'discord' } = config.discord;
+        log.defineType(logMethod, logColor);
+        if (this.client) {
+            // Already initialized — singleton reuse via Discord.init() or a direct
+            // new DiscordBot().init() call. Wait for the existing ready promise
+            // rather than re-running discovery + login.
+            await this.ready;
+            return;
+        }
+        const { token } = config.discord;
+        if (!token) {
+            log.discord?.('No DISCORD_TOKEN configured — bot will not start');
+            this.resolveReady();
+            return;
+        }
+        await this.discoverCommands();
+        await this.discoverEvents();
+        const intents = deriveIntents(this.eventHandlers, config.discord.additionalIntents);
+        const partials = derivePartials(intents, config.discord.additionalPartials);
+        if (Object.keys(this.commands).length > 0) {
+            intents.push(GatewayIntentBits.Guilds);
+        }
+        this.client = new Client({ intents: [...new Set(intents)], partials });
+        this.registerClientEvents();
+        this.client.login(token);
+        await this.ready;
+    }
+    _resetReady() {
+        this.ready = new Promise(resolve => { this.resolveReady = resolve; });
+    }
+    registerClientEvents() {
+        const { client } = this;
+        if (!client)
+            return;
+        client.on('ready', () => {
+            this._connectionState = 'ready';
+            this.resolveReady();
+            this._flushQueue();
+            log.discord?.('Discord Bot is Ready!');
+        });
+        client.on('shardDisconnect', () => {
+            this._resetReady();
+            this._connectionState = 'disconnected';
+            log.discord?.('Shard disconnected');
+        });
+        client.on('shardReconnecting', () => {
+            this._resetReady();
+            this._connectionState = 'connecting';
+            log.discord?.('Shard reconnecting');
+        });
+        client.on('shardResume', () => {
+            this._connectionState = 'ready';
+            this.resolveReady();
+            this._flushQueue();
+            log.discord?.('Shard resumed');
+        });
+        client.on('invalidated', () => {
+            log.error('Discord session invalidated — rejecting all queued messages');
+            const entries = this._queue.splice(0);
+            for (const entry of entries) {
+                if (entry.timerId !== null)
+                    clearTimeout(entry.timerId);
+                entry.reject(new Error('Discord session invalidated'));
+            }
+        });
+        client.on('interactionCreate', async (interaction) => {
+            if (!interaction.isChatInputCommand())
+                return;
+            const { commandName } = interaction;
+            const command = this.commands[commandName];
+            if (!command) {
+                await interaction.reply({ content: `\`/${commandName}\` is not available`, flags: MessageFlags.Ephemeral });
+                return;
+            }
+            try {
+                await command.execute(interaction);
+            }
+            catch (error) {
+                log.error(String(error));
+                const reply = { content: 'There was an error executing this command!', flags: MessageFlags.Ephemeral };
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp(reply);
+                }
+                else {
+                    await interaction.reply(reply);
+                }
+            }
+        });
+        for (const handler of this.eventHandlers) {
+            const event = handler.constructor.event;
+            if (event) {
+                client.on(event, (...args) => handler.handle(...args));
+            }
+        }
+    }
+    async discoverCommands() {
+        const { commandDir } = config.discord;
+        if (!commandDir)
+            return;
+        await forEachFileImport(commandDir, (CommandClassUntyped, { name }) => {
+            const CommandClass = CommandClassUntyped;
+            const instance = new CommandClass();
+            if (!instance.data || typeof instance.execute !== 'function') {
+                log.discord?.(`Command "${name}" is missing data or execute — skipping`);
+                return;
+            }
+            instance._bot = this;
+            this.commands[instance.data.name] = instance;
+            log.discord?.(`Loaded command: /${instance.data.name}`);
+        }, { ignoreAccessFailure: true });
+    }
+    async discoverEvents() {
+        const { eventDir } = config.discord;
+        if (!eventDir)
+            return;
+        await forEachFileImport(eventDir, (EventHandlerClassUntyped, { name }) => {
+            const EventHandlerClass = EventHandlerClassUntyped;
+            if (!EventHandlerClass.event) {
+                log.discord?.(`Event handler "${name}" is missing static event property — skipping`);
+                return;
+            }
+            const instance = new EventHandlerClass();
+            instance._bot = this;
+            this.eventHandlers.push(instance);
+            log.discord?.(`Loaded event handler: ${EventHandlerClass.event} (${name})`);
+        }, { ignoreAccessFailure: true });
+    }
+    async _doSend(content, channelId, imagePath) {
+        if (!this.client)
+            throw new Error('Discord bot is not initialized');
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel)
+            throw new Error('Invalid Channel ID');
+        const sendable = channel;
+        if (content.length > 2000) {
+            const chunks = chunkMessage('', content);
+            let firstMessage;
+            for (let i = 0; i < chunks.length; i++) {
+                const options = { content: chunks[i] };
+                if (i === 0 && imagePath) {
+                    options.files = [new AttachmentBuilder(imagePath)];
+                }
+                const msg = await sendable.send(options);
+                if (i === 0)
+                    firstMessage = msg;
+            }
+            return firstMessage;
+        }
+        const options = { content };
+        if (imagePath) {
+            options.files = [new AttachmentBuilder(imagePath)];
+        }
+        return await sendable.send(options);
+    }
+    async sendMessage(content, channelId, imagePath = null) {
+        if (this._connectionState === 'ready') {
+            try {
+                return await this._doSend(content, channelId, imagePath);
+            }
+            catch (error) {
+                if (this._isRetryable(error)) {
+                    return this._enqueueForRetry(content, channelId, imagePath, 1);
+                }
+                throw error;
+            }
+        }
+        return this._enqueue(content, channelId, imagePath);
+    }
+    _enqueue(content, channelId, imagePath) {
+        if (this._queue.length >= MAX_QUEUE_SIZE) {
+            return Promise.reject(new Error('Message queue full'));
+        }
+        return new Promise((resolve, reject) => {
+            this._queue.push({
+                content,
+                channelId,
+                imagePath,
+                resolve,
+                reject,
+                retries: 0,
+                enqueuedAt: Date.now(),
+                timerId: null,
+            });
+        });
+    }
+    _enqueueForRetry(content, channelId, imagePath, retries) {
+        if (this._queue.length >= MAX_QUEUE_SIZE) {
+            return Promise.reject(new Error('Message queue full'));
+        }
+        return new Promise((resolve, reject) => {
+            const entry = {
+                content,
+                channelId,
+                imagePath,
+                resolve,
+                reject,
+                retries,
+                enqueuedAt: Date.now(),
+                timerId: null,
+            };
+            this._queue.push(entry);
+            this._scheduleRetry(entry);
+        });
+    }
+    _scheduleRetry(entry) {
+        const backoff = Math.min(1000 * Math.pow(2, entry.retries) + Math.floor(Math.random() * 500), 30000);
+        entry.timerId = setTimeout(() => {
+            entry.timerId = null;
+            // Only process if the entry is still in the queue (wasn't rejected by close/invalidated)
+            const idx = this._queue.indexOf(entry);
+            if (idx === -1)
+                return;
+            if (this._connectionState === 'ready') {
+                this._processEntry(entry, idx);
+            }
+            // If not ready, entry stays in queue for _flushQueue on reconnect
+        }, backoff);
+    }
+    async _processEntry(entry, idx) {
+        // Remove from queue before attempting
+        const currentIdx = this._queue.indexOf(entry);
+        if (currentIdx === -1)
+            return;
+        this._queue.splice(currentIdx, 1);
+        // TTL check
+        if (Date.now() - entry.enqueuedAt > QUEUE_TTL) {
+            entry.reject(new Error('Message expired: stale TTL exceeded'));
+            return;
+        }
+        try {
+            const msg = await this._doSend(entry.content, entry.channelId, entry.imagePath);
+            entry.resolve(msg);
+        }
+        catch (error) {
+            if (this._isRetryable(error) && entry.retries < MAX_RETRIES) {
+                entry.retries++;
+                this._queue.push(entry);
+                this._scheduleRetry(entry);
+            }
+            else {
+                const message = entry.retries >= MAX_RETRIES
+                    ? `Message send failed: retries exhausted (${entry.retries}/${MAX_RETRIES})`
+                    : (error instanceof Error ? error.message : String(error));
+                entry.reject(new Error(message));
+            }
+        }
+    }
+    async _flushQueue() {
+        // Take a snapshot of entries to process
+        const entries = this._queue.splice(0);
+        for (const entry of entries) {
+            // TTL check
+            if (Date.now() - entry.enqueuedAt > QUEUE_TTL) {
+                entry.reject(new Error('Message expired: stale TTL exceeded'));
+                continue;
+            }
+            try {
+                const msg = await this._doSend(entry.content, entry.channelId, entry.imagePath);
+                entry.resolve(msg);
+            }
+            catch (error) {
+                if (this._isRetryable(error) && entry.retries < MAX_RETRIES) {
+                    entry.retries++;
+                    this._queue.push(entry);
+                    this._scheduleRetry(entry);
+                }
+                else {
+                    entry.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        }
+    }
+    _isRetryable(error) {
+        if (error == null || typeof error !== 'object')
+            return false;
+        const err = error;
+        // HTTP 5xx errors
+        if (typeof err.status === 'number' && err.status >= 500 && err.status <= 599) {
+            return true;
+        }
+        // Network error codes
+        if (typeof err.code === 'string' && RETRYABLE_NETWORK_CODES.has(err.code)) {
+            return true;
+        }
+        return false;
+    }
+    async _ensureReady() {
+        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Timed out waiting for Discord bot to be ready')), READY_TIMEOUT));
+        await Promise.race([this.ready, timeout]);
+    }
+    async sendFile(file, messageObject) {
+        return await messageObject.edit({
+            content: '',
+            files: [{
+                    attachment: file,
+                    name: file.split('/').pop() ?? file
+                }]
+        });
+    }
+    async reply(interaction, content) {
+        if (content.length <= 2000) {
+            if (interaction.deferred || interaction.replied) {
+                await interaction.editReply({ content });
+                return;
+            }
+            await interaction.reply({ content });
+            return;
+        }
+        const [first, ...rest] = chunkMessage('', content);
+        if (interaction.deferred || interaction.replied) {
+            await interaction.editReply({ content: first });
+        }
+        else {
+            await interaction.reply({ content: first });
+        }
+        for (const chunk of rest) {
+            await interaction.followUp({ content: chunk });
+        }
+    }
+    async updateStatus(name, type = 0) {
+        await this._ensureReady();
+        if (!this.client?.user)
+            throw new Error('Discord bot is not initialized');
+        await this.client.user.setPresence({
+            activities: [{ name, type }],
+            status: 'online'
+        });
+    }
+    async getChannelMessages(channelId, options = {}) {
+        await this._ensureReady();
+        if (!this.client)
+            throw new Error('Discord bot is not initialized');
+        const channel = await this.client.channels.fetch(channelId);
+        return await channel.messages.fetch({
+            limit: config.discord.maxMessagesPerRequest,
+            ...options
+        });
+    }
+    async getChannelMessage(channelId, messageId) {
+        await this._ensureReady();
+        if (!this.client)
+            throw new Error('Discord bot is not initialized');
+        const channel = await this.client.channels.fetch(channelId);
+        return await channel.messages.fetch(messageId);
+    }
+    async getGuild(guildId) {
+        await this._ensureReady();
+        if (!this.client)
+            throw new Error('Discord bot is not initialized');
+        return await this.client.guilds.fetch(guildId || config.discord.serverId || '');
+    }
+    async clearChannelMessages(channelId) {
+        const messages = await this.getChannelMessages(channelId);
+        const settled = await Promise.allSettled([...messages.values()].map(m => m.delete()));
+        const errors = settled
+            .filter((s) => s.status === 'rejected')
+            .map(s => s.reason instanceof Error ? s.reason : new Error(String(s.reason)));
+        const result = {
+            deleted: settled.length - errors.length,
+            failed: errors.length,
+            errors,
+        };
+        if (result.failed > 0) {
+            log.warn(`clearChannelMessages partial failure on channel ${channelId}: deleted=${result.deleted} failed=${result.failed} errors=${errors.map(String).join('; ')}`);
+        }
+        return result;
+    }
+    async giveRole(memberId, roleId) {
+        const guild = await this.getGuild();
+        const role = await guild.roles.fetch(roleId);
+        const member = await guild.members.fetch(memberId);
+        await member.roles.add(role);
+    }
+    close() {
+        // Cancel all pending retry timers and reject all queue entries
+        const entries = this._queue.splice(0);
+        for (const entry of entries) {
+            if (entry.timerId !== null)
+                clearTimeout(entry.timerId);
+            entry.reject(new Error('Discord bot closed'));
+        }
+        if (this.client) {
+            this.client.destroy();
+            this.client = null;
+        }
+        DiscordBot.instance = null;
+    }
+    reset() {
+        this.close();
+        this.commands = {};
+        this.eventHandlers = [];
+        this._connectionState = 'connecting';
+        this._resetReady();
+    }
+}

package/dist/command.d.ts

@@ -0,0 +1,6 @@
+import type { ChatInputCommandInteraction, SlashCommandBuilder } from 'discord.js';
+export default class Command {
+    static skipAuth: boolean;
+    data?: SlashCommandBuilder;
+    execute?: (interaction: ChatInputCommandInteraction) => Promise<void>;
+}

package/{src → dist}/command.js

@@ -1,3 +1,3 @@
 export default class Command {
-  static skipAuth = false;
+    static skipAuth = false;
 }

package/dist/event-handler.d.ts

@@ -0,0 +1,4 @@
+export default class EventHandler {
+    static event: string | null;
+    handle?: (...args: unknown[]) => void | Promise<void>;
+}

package/{src → dist}/event-handler.js

@@ -1,3 +1,3 @@
 export default class EventHandler {
-  static event = null;
+    static event = null;
 }

package/dist/intents.d.ts

@@ -0,0 +1,11 @@
+import { GatewayIntentBits, Partials } from 'discord.js';
+interface EventHandlerLike {
+    constructor: {
+        event: string | null;
+    };
+}
+declare const EVENT_INTENT_MAP: Record<string, GatewayIntentBits[]>;
+declare const INTENT_PARTIAL_MAP: Partial<Record<GatewayIntentBits, Partials[]>>;
+export declare function deriveIntents(eventHandlers: EventHandlerLike[], additionalIntents?: string[]): GatewayIntentBits[];
+export declare function derivePartials(intents: GatewayIntentBits[], additionalPartials?: string[]): Partials[];
+export { EVENT_INTENT_MAP, INTENT_PARTIAL_MAP };

package/dist/intents.js

@@ -0,0 +1,51 @@
+import { GatewayIntentBits, Partials } from 'discord.js';
+const EVENT_INTENT_MAP = {
+    messageCreate: [GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+    messageDelete: [GatewayIntentBits.GuildMessages],
+    messageUpdate: [GatewayIntentBits.GuildMessages],
+    guildMemberAdd: [GatewayIntentBits.GuildMembers],
+    guildMemberRemove: [GatewayIntentBits.GuildMembers],
+    inviteCreate: [GatewayIntentBits.GuildInvites],
+    inviteDelete: [GatewayIntentBits.GuildInvites],
+    voiceStateUpdate: [GatewayIntentBits.GuildVoiceStates],
+    interactionCreate: [],
+};
+const INTENT_PARTIAL_MAP = {
+    [GatewayIntentBits.DirectMessages]: [Partials.Channel],
+};
+export function deriveIntents(eventHandlers, additionalIntents = []) {
+    const intents = new Set([GatewayIntentBits.Guilds]);
+    for (const handler of eventHandlers) {
+        const event = handler.constructor.event;
+        if (!event)
+            continue;
+        const required = EVENT_INTENT_MAP[event];
+        if (required) {
+            for (const intent of required)
+                intents.add(intent);
+        }
+    }
+    for (const name of additionalIntents) {
+        const intent = GatewayIntentBits[name];
+        if (intent !== undefined)
+            intents.add(intent);
+    }
+    return [...intents];
+}
+export function derivePartials(intents, additionalPartials = []) {
+    const partials = new Set();
+    for (const intent of intents) {
+        const required = INTENT_PARTIAL_MAP[intent];
+        if (required) {
+            for (const partial of required)
+                partials.add(partial);
+        }
+    }
+    for (const name of additionalPartials) {
+        const partial = Partials[name];
+        if (partial !== undefined)
+            partials.add(partial);
+    }
+    return [...partials];
+}
+export { EVENT_INTENT_MAP, INTENT_PARTIAL_MAP };

package/dist/main.d.ts

@@ -0,0 +1,6 @@
+export default class Discord {
+    static instance: Discord | null;
+    constructor();
+    init(): Promise<void>;
+    reset(): void;
+}

package/dist/main.js

@@ -0,0 +1,15 @@
+import DiscordBot from './bot.js';
+export default class Discord {
+    static instance;
+    constructor() {
+        if (Discord.instance)
+            return Discord.instance;
+        Discord.instance = this;
+    }
+    async init() {
+        await new DiscordBot().init();
+    }
+    reset() {
+        Discord.instance = null;
+    }
+}

package/dist/message.d.ts

@@ -0,0 +1 @@
+export declare function chunkMessage(header: string, body: string): string[];

package/dist/message.js

@@ -0,0 +1,25 @@
+const MAX_LENGTH = 2000;
+function splitAtBoundary(text, max) {
+    if (text.length <= max)
+        return [text, ''];
+    const region = text.slice(0, max);
+    const newlineIdx = region.lastIndexOf('\n');
+    if (newlineIdx > 0)
+        return [text.slice(0, newlineIdx + 1), text.slice(newlineIdx + 1)];
+    const spaceIdx = region.lastIndexOf(' ');
+    if (spaceIdx > 0)
+        return [text.slice(0, spaceIdx + 1), text.slice(spaceIdx + 1)];
+    return [text.slice(0, max), text.slice(max)];
+}
+export function chunkMessage(header, body) {
+    const chunks = [];
+    const firstChunkMax = MAX_LENGTH - header.length;
+    let [first, remaining] = splitAtBoundary(body, firstChunkMax);
+    chunks.push(header + first);
+    while (remaining.length > 0) {
+        let chunk;
+        [chunk, remaining] = splitAtBoundary(remaining, MAX_LENGTH);
+        chunks.push(chunk);
+    }
+    return chunks;
+}

package/package.json

@@ -4,22 +4,42 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.1.1-beta.9",
+  "version": "0.1.1-beta.90",
   "description": "Discord bot module for the Stonyx framework",
-  "main": "src/main.js",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
   "type": "module",
   "files": [
-    "src",
+    "dist",
     "config",
     "LICENSE.md",
     "README.md"
   ],
   "exports": {
-    ".": "./src/main.js",
-    "./bot": "./src/bot.js",
-    "./command": "./src/command.js",
-    "./event-handler": "./src/event-handler.js",
-    "./message": "./src/message.js"
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    },
+    "./bot": {
+      "types": "./dist/bot.d.ts",
+      "default": "./dist/bot.js"
+    },
+    "./command": {
+      "types": "./dist/command.d.ts",
+      "default": "./dist/command.js"
+    },
+    "./event-handler": {
+      "types": "./dist/event-handler.d.ts",
+      "default": "./dist/event-handler.js"
+    },
+    "./message": {
+      "types": "./dist/message.d.ts",
+      "default": "./dist/message.js"
+    },
+    "./base": {
+      "types": "./dist/base.d.ts",
+      "default": "./dist/base.js"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -44,12 +64,19 @@
     "stonyx": ">=0.2.3-beta.4"
   },
   "devDependencies": {
-    "@stonyx/utils": "0.2.3-beta.7",
+    "@stonyx/utils": "0.2.3-beta.26",
+    "@types/node": "^25.5.2",
+    "@types/qunit": "^2.19.13",
+    "@types/sinon": "^21.0.1",
     "qunit": "^2.24.1",
     "sinon": "^21.0.0",
-    "stonyx": "0.2.3-beta.12"
+    "stonyx": "0.2.3-beta.83",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.3"
   },
   "scripts": {
-    "test": "stonyx test"
+    "build": "tsc",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
+    "test": "pnpm build && NODE_ENV=test node --import tsx/esm --import ./test/setup.ts node_modules/qunit/bin/qunit.js 'test/**/*-test.ts'"
   }
 }

package/src/bot.js

@@ -1,214 +0,0 @@
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-import { Client, GatewayIntentBits, AttachmentBuilder, MessageFlags } from 'discord.js';
-import { forEachFileImport } from '@stonyx/utils/file';
-import { deriveIntents, derivePartials } from './intents.js';
-import { chunkMessage } from './message.js';
-
-export default class DiscordBot {
-  commands = {};
-  eventHandlers = [];
-  ready = new Promise(resolve => { this.resolveReady = resolve; });
-
-  constructor() {
-    if (DiscordBot.instance) return DiscordBot.instance;
-    DiscordBot.instance = this;
-  }
-
-  async init() {
-    const { token } = config.discord;
-
-    if (!token) {
-      log.discord('No DISCORD_TOKEN configured — bot will not start');
-      this.resolveReady();
-      return;
-    }
-
-    await this.discoverCommands();
-    await this.discoverEvents();
-
-    const hasWork = Object.keys(this.commands).length > 0 || this.eventHandlers.length > 0;
-
-    if (!hasWork) {
-      log.discord('No discord commands or event handlers found — skipping bot initialization');
-      this.resolveReady();
-      return;
-    }
-
-    const intents = deriveIntents(this.eventHandlers, config.discord.additionalIntents);
-    const partials = derivePartials(intents, config.discord.additionalPartials);
-
-    if (Object.keys(this.commands).length > 0) {
-      intents.push(GatewayIntentBits.Guilds);
-    }
-
-    this.client = new Client({ intents: [...new Set(intents)], partials });
-    this.registerClientEvents();
-    this.client.login(token);
-
-    await this.ready;
-  }
-
-  registerClientEvents() {
-    const { client } = this;
-
-    client.on('clientReady', () => {
-      this.resolveReady();
-      log.discord('Discord Bot is Ready!');
-    });
-
-    client.on('interactionCreate', async interaction => {
-      if (!interaction.isChatInputCommand()) return;
-
-      const { commandName } = interaction;
-      const command = this.commands[commandName];
-
-      if (!command) {
-        return await interaction.reply({ content: `\`/${commandName}\` is not available`, flags: MessageFlags.Ephemeral });
-      }
-
-      try {
-        await command.execute(interaction);
-      } catch (error) {
-        log.error(error);
-        const reply = { content: 'There was an error executing this command!', flags: MessageFlags.Ephemeral };
-        if (interaction.replied || interaction.deferred) {
-          await interaction.followUp(reply);
-        } else {
-          await interaction.reply(reply);
-        }
-      }
-    });
-
-    for (const handler of this.eventHandlers) {
-      client.on(handler.constructor.event, (...args) => handler.handle(...args));
-    }
-  }
-
-  async discoverCommands() {
-    const { commandDir } = config.discord;
-
-    await forEachFileImport(commandDir, (CommandClass, { name }) => {
-      const instance = new CommandClass();
-
-      if (!instance.data || typeof instance.execute !== 'function') {
-        log.discord(`Command "${name}" is missing data or execute — skipping`);
-        return;
-      }
-
-      instance._bot = this;
-      this.commands[instance.data.name] = instance;
-      log.discord(`Loaded command: /${instance.data.name}`);
-    }, { ignoreAccessFailure: true });
-  }
-
-  async discoverEvents() {
-    const { eventDir } = config.discord;
-
-    await forEachFileImport(eventDir, (EventHandlerClass, { name }) => {
-      if (!EventHandlerClass.event) {
-        log.discord(`Event handler "${name}" is missing static event property — skipping`);
-        return;
-      }
-
-      const instance = new EventHandlerClass();
-      instance._bot = this;
-      this.eventHandlers.push(instance);
-      log.discord(`Loaded event handler: ${EventHandlerClass.event} (${name})`);
-    }, { ignoreAccessFailure: true });
-  }
-
-  async sendMessage(content, channelId, imagePath = null) {
-    const channel = await this.client.channels.fetch(channelId);
-    if (!channel) throw new Error('Invalid Channel ID');
-
-    const options = { content };
-    if (imagePath) {
-      options.files = [new AttachmentBuilder(imagePath)];
-    }
-    return await channel.send(options);
-  }
-
-  async sendFile(file, messageObject) {
-    return await messageObject.edit({
-      content: '',
-      files: [{
-        attachment: file,
-        name: file.split('/').pop()
-      }]
-    });
-  }
-
-  async reply(interaction, content) {
-    if (content.length <= 2000) {
-      if (interaction.deferred || interaction.replied) {
-        return await interaction.editReply({ content });
-      }
-      return await interaction.reply({ content });
-    }
-
-    const [first, ...rest] = chunkMessage('', content);
-
-    if (interaction.deferred || interaction.replied) {
-      await interaction.editReply({ content: first });
-    } else {
-      await interaction.reply({ content: first });
-    }
-
-    for (const chunk of rest) {
-      await interaction.followUp({ content: chunk });
-    }
-  }
-
-  async updateStatus(name, type = 0) {
-    await this.client.user.setPresence({
-      activities: [{ name, type }],
-      status: 'online'
-    });
-  }
-
-  async getChannelMessages(channelId, options = {}) {
-    const channel = await this.client.channels.fetch(channelId);
-    return await channel.messages.fetch({
-      limit: config.discord.maxMessagesPerRequest,
-      ...options
-    });
-  }
-
-  async getChannelMessage(channelId, messageId) {
-    const channel = await this.client.channels.fetch(channelId);
-    return await channel.messages.fetch(messageId);
-  }
-
-  async getGuild(guildId = config.discord.serverId) {
-    return await this.client.guilds.fetch(guildId);
-  }
-
-  async clearChannelMessages(channelId) {
-    const promises = [];
-    const messages = await this.getChannelMessages(channelId);
-    messages.forEach(message => promises.push(message.delete()));
-    return Promise.all(promises);
-  }
-
-  async giveRole(memberId, roleId) {
-    const guild = await this.getGuild();
-    const role = await guild.roles.fetch(roleId);
-    const member = await guild.members.fetch(memberId);
-    await member.roles.add(role);
-  }
-
-  close() {
-    if (this.client) {
-      this.client.destroy();
-      this.client = null;
-    }
-    DiscordBot.instance = null;
-  }
-
-  reset() {
-    this.close();
-    this.commands = {};
-    this.eventHandlers = [];
-  }
-}

package/src/intents.js

@@ -1,56 +0,0 @@
-import { GatewayIntentBits, Partials } from 'discord.js';
-
-const EVENT_INTENT_MAP = {
-  messageCreate:      [GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
-  messageDelete:      [GatewayIntentBits.GuildMessages],
-  messageUpdate:      [GatewayIntentBits.GuildMessages],
-  guildMemberAdd:     [GatewayIntentBits.GuildMembers],
-  guildMemberRemove:  [GatewayIntentBits.GuildMembers],
-  inviteCreate:       [GatewayIntentBits.GuildInvites],
-  inviteDelete:       [GatewayIntentBits.GuildInvites],
-  voiceStateUpdate:   [GatewayIntentBits.GuildVoiceStates],
-  interactionCreate:  [],
-};
-
-const INTENT_PARTIAL_MAP = {
-  [GatewayIntentBits.DirectMessages]: [Partials.Channel],
-};
-
-export function deriveIntents(eventHandlers, additionalIntents = []) {
-  const intents = new Set([GatewayIntentBits.Guilds]);
-
-  for (const handler of eventHandlers) {
-    const event = handler.constructor.event;
-    const required = EVENT_INTENT_MAP[event];
-    if (required) {
-      for (const intent of required) intents.add(intent);
-    }
-  }
-
-  for (const name of additionalIntents) {
-    const intent = GatewayIntentBits[name];
-    if (intent !== undefined) intents.add(intent);
-  }
-
-  return [...intents];
-}
-
-export function derivePartials(intents, additionalPartials = []) {
-  const partials = new Set();
-
-  for (const intent of intents) {
-    const required = INTENT_PARTIAL_MAP[intent];
-    if (required) {
-      for (const partial of required) partials.add(partial);
-    }
-  }
-
-  for (const name of additionalPartials) {
-    const partial = Partials[name];
-    if (partial !== undefined) partials.add(partial);
-  }
-
-  return [...partials];
-}
-
-export { EVENT_INTENT_MAP, INTENT_PARTIAL_MAP };

package/src/main.js

@@ -1,15 +0,0 @@
-export default class Discord {
-  constructor() {
-    if (Discord.instance) return Discord.instance;
-    Discord.instance = this;
-  }
-
-  async init() {
-    // Bot initialization is deferred to DiscordBot.init()
-    // This entry point satisfies Stonyx module auto-initialization
-  }
-
-  reset() {
-    Discord.instance = null;
-  }
-}

package/src/message.js

@@ -1,30 +0,0 @@
-const MAX_LENGTH = 2000;
-
-function splitAtBoundary(text, max) {
-  if (text.length <= max) return [text, ''];
-
-  const region = text.slice(0, max);
-  const newlineIdx = region.lastIndexOf('\n');
-  if (newlineIdx > 0) return [text.slice(0, newlineIdx + 1), text.slice(newlineIdx + 1)];
-
-  const spaceIdx = region.lastIndexOf(' ');
-  if (spaceIdx > 0) return [text.slice(0, spaceIdx + 1), text.slice(spaceIdx + 1)];
-
-  return [text.slice(0, max), text.slice(max)];
-}
-
-export function chunkMessage(header, body) {
-  const chunks = [];
-  const firstChunkMax = MAX_LENGTH - header.length;
-
-  let [first, remaining] = splitAtBoundary(body, firstChunkMax);
-  chunks.push(header + first);
-
-  while (remaining.length > 0) {
-    let chunk;
-    [chunk, remaining] = splitAtBoundary(remaining, MAX_LENGTH);
-    chunks.push(chunk);
-  }
-
-  return chunks;
-}