@jubbio/core 1.3.1 → 1.3.3

package/dist/esm/Client.js

@@ -0,0 +1,634 @@
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import { GatewayOpcodes, GatewayIntentBits } from './enums';
+import { Collection } from './structures/Collection';
+import { User } from './structures/User';
+import { Guild } from './structures/Guild';
+import { Message } from './structures/Message';
+import { createInteraction } from './structures/Interaction';
+import { REST } from './rest/REST';
+/**
+ * Main client class
+ */
+export class Client extends EventEmitter {
+    /** Client options */
+    options;
+    /** REST API client */
+    rest;
+    /** The bot user */
+    user = null;
+    /** Application ID */
+    applicationId = null;
+    /** Cached guilds */
+    guilds = new Collection();
+    /** Cached channels */
+    channels = new Collection();
+    /** Cached users */
+    users = new Collection();
+    /** Voice adapter management */
+    voice;
+    /** WebSocket connection */
+    ws = null;
+    /** Bot token */
+    token = '';
+    /** Session ID */
+    sessionId = null;
+    /** Sequence number */
+    sequence = null;
+    /** Heartbeat interval */
+    heartbeatInterval = null;
+    /** Gateway URL */
+    gatewayUrl;
+    /** Voice state update handlers (for voice adapters) */
+    voiceStateHandlers = new Map();
+    voiceServerHandlers = new Map();
+    /** Whether the client is currently in the login flow */
+    _loginState = 'idle';
+    /** Reconnect attempt counter */
+    _reconnectAttempts = 0;
+    /** Maximum reconnect attempts before giving up */
+    _maxReconnectAttempts = 5;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.gatewayUrl = options.gatewayUrl || 'wss://realtime.jubbio.com/ws/bot';
+        this.rest = new REST(options.apiUrl);
+        // Initialize voice adapter system
+        this.voice = {
+            adapters: new Map()
+        };
+    }
+    /**
+     * Calculate intents value
+     */
+    getIntentsValue() {
+        if (typeof this.options.intents === 'number') {
+            return this.options.intents;
+        }
+        return this.options.intents.reduce((acc, intent) => acc | intent, 0);
+    }
+    /**
+     * Gateway close code descriptions
+     */
+    static CLOSE_CODES = {
+        4000: { message: 'Bilinmeyen hata (Unknown error)', reconnectable: true },
+        4001: { message: 'Bilinmeyen opcode gönderildi (Unknown opcode)', reconnectable: true },
+        4002: { message: 'Geçersiz payload gönderildi (Decode error)', reconnectable: true },
+        4003: { message: 'Henüz kimlik doğrulaması yapılmadı (Not authenticated)', reconnectable: true },
+        4004: { message: 'Geçersiz bot token\'ı (Authentication failed)', reconnectable: false },
+        4005: { message: 'Zaten kimlik doğrulaması yapılmış (Already authenticated)', reconnectable: true },
+        4007: { message: 'Geçersiz sequence numarası (Invalid seq)', reconnectable: true },
+        4008: { message: 'Rate limit aşıldı (Rate limited)', reconnectable: true },
+        4009: { message: 'Oturum zaman aşımına uğradı (Session timed out)', reconnectable: true },
+        4010: { message: 'Geçersiz shard yapılandırması (Invalid shard)', reconnectable: false },
+        4011: { message: 'Sharding gerekli (Sharding required)', reconnectable: false },
+        4014: { message: 'İzin verilmeyen intent\'ler istendi (Disallowed intents)', reconnectable: false },
+    };
+    /**
+     * Login to the gateway
+     */
+    async login(token) {
+        if (!token || typeof token !== 'string') {
+            throw new Error('Geçerli bir bot token\'ı sağlanmalıdır. Örnek: client.login(process.env.BOT_TOKEN)');
+        }
+        this.token = token.replace(/^Bot\s+/i, '');
+        this.rest.setToken(this.token);
+        this._loginState = 'connecting';
+        this._reconnectAttempts = 0;
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timeout);
+                this.removeListener('ready', onReady);
+                this.removeListener('error', onError);
+                this.removeListener('gatewayClose', onGatewayClose);
+            };
+            const timeout = setTimeout(() => {
+                cleanup();
+                this._loginState = 'idle';
+                reject(new Error('Gateway\'e bağlanılamadı: 30 saniye içinde READY event\'i alınamadı. ' +
+                    'Olası sebepler: gateway sunucusu erişilemez, token geçersiz veya ağ sorunu.'));
+            }, 30000);
+            const onReady = () => {
+                cleanup();
+                this._loginState = 'ready';
+                this._reconnectAttempts = 0;
+                resolve(this.token);
+            };
+            const onError = (error) => {
+                cleanup();
+                this._loginState = 'idle';
+                reject(error);
+            };
+            const onGatewayClose = (code, reason) => {
+                const info = Client.CLOSE_CODES[code];
+                if (info && !info.reconnectable) {
+                    cleanup();
+                    this._loginState = 'idle';
+                    reject(new Error(`Gateway bağlantısı reddedildi [${code}]: ${info.message}${reason ? ' - ' + reason : ''}`));
+                }
+                // Reconnectable codes: login promise stays alive, connect() will retry
+            };
+            this.once('ready', onReady);
+            this.once('error', onError);
+            this.on('gatewayClose', onGatewayClose);
+            this.connect();
+        });
+    }
+    /**
+     * Connect to the gateway
+     */
+    connect() {
+        this.ws = new WebSocket(this.gatewayUrl);
+        this.ws.on('open', () => {
+            this.emit('debug', 'WebSocket bağlantısı açıldı');
+            this._reconnectAttempts = 0;
+        });
+        this.ws.on('message', (data) => {
+            this.handleMessage(data.toString());
+        });
+        this.ws.on('close', (code, reason) => {
+            const reasonStr = reason?.toString() || '';
+            const info = Client.CLOSE_CODES[code];
+            if (info) {
+                this.emit('debug', `Gateway bağlantısı kapandı [${code}]: ${info.message}${reasonStr ? ' - ' + reasonStr : ''}`);
+            }
+            else {
+                this.emit('debug', `WebSocket kapandı: ${code} - ${reasonStr}`);
+            }
+            this.cleanup();
+            // Emit gatewayClose so login() can handle non-reconnectable codes
+            this.emit('gatewayClose', code, reasonStr);
+            // Non-reconnectable codes: don't retry
+            if (info && !info.reconnectable) {
+                this.emit('debug', `Kod ${code} yeniden bağlanılamaz, bağlantı sonlandırılıyor.`);
+                return;
+            }
+            // Normal close: don't retry
+            if (code === 1000) {
+                return;
+            }
+            // Reconnectable: retry with backoff
+            this._reconnectAttempts++;
+            if (this._reconnectAttempts > this._maxReconnectAttempts) {
+                this.emit('debug', `Maksimum yeniden bağlanma denemesi aşıldı (${this._maxReconnectAttempts})`);
+                this.emit('error', new Error(`Gateway bağlantısı ${this._maxReconnectAttempts} denemeden sonra kurulamadı. Son kapanma kodu: ${code}`));
+                return;
+            }
+            const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts - 1), 30000);
+            this.emit('debug', `Yeniden bağlanılıyor (deneme ${this._reconnectAttempts}/${this._maxReconnectAttempts}), ${delay}ms sonra...`);
+            setTimeout(() => this.connect(), delay);
+        });
+        this.ws.on('error', (error) => {
+            this.emit('debug', `WebSocket hatası: ${error.message}`);
+            this.emit('error', error);
+        });
+    }
+    /**
+     * Handle incoming gateway message
+     */
+    handleMessage(data) {
+        // Handle multiple messages in one frame
+        const messages = data.split('\n').filter(m => m.trim());
+        for (const msg of messages) {
+            try {
+                const payload = JSON.parse(msg);
+                this.handlePayload(payload);
+            }
+            catch (e) {
+                this.emit('debug', `Failed to parse message: ${msg}`);
+            }
+        }
+    }
+    /**
+     * Handle gateway payload
+     */
+    handlePayload(payload) {
+        if (payload.s) {
+            this.sequence = payload.s;
+        }
+        switch (payload.op) {
+            case GatewayOpcodes.Hello:
+                this.handleHello(payload.d);
+                break;
+            case GatewayOpcodes.Dispatch:
+                this.handleDispatch(payload.t, payload.d);
+                break;
+            case GatewayOpcodes.HeartbeatAck:
+                this.emit('debug', 'Heartbeat acknowledged');
+                break;
+            case GatewayOpcodes.InvalidSession:
+                this.emit('debug', 'Geçersiz oturum, yeniden kimlik doğrulanıyor...');
+                // InvalidSession may carry error data from sendError()
+                if (payload.d && typeof payload.d === 'object' && payload.d.code && payload.d.message) {
+                    this.emit('debug', `Sunucu hatası [${payload.d.code}]: ${payload.d.message}`);
+                    const info = Client.CLOSE_CODES[payload.d.code];
+                    if (info && !info.reconnectable) {
+                        this.emit('error', new Error(`Gateway hatası [${payload.d.code}]: ${info.message}`));
+                        return;
+                    }
+                }
+                setTimeout(() => this.identify(), 5000);
+                break;
+            case GatewayOpcodes.Reconnect:
+                this.emit('debug', 'Reconnect requested');
+                this.ws?.close();
+                setTimeout(() => this.connect(), 1000);
+                break;
+        }
+    }
+    /**
+     * Handle Hello payload
+     */
+    handleHello(data) {
+        this.emit('debug', `Received Hello, heartbeat interval: ${data.heartbeat_interval}ms`);
+        this.startHeartbeat(data.heartbeat_interval);
+        this.identify();
+    }
+    /**
+     * Handle Dispatch events
+     */
+    handleDispatch(eventType, data) {
+        this.emit('debug', `Dispatch: ${eventType}`);
+        switch (eventType) {
+            case 'READY':
+                this.handleReady(data);
+                break;
+            case 'GUILD_CREATE':
+                this.handleGuildCreate(data);
+                break;
+            case 'GUILD_UPDATE':
+                this.handleGuildUpdate(data);
+                break;
+            case 'GUILD_DELETE':
+                this.handleGuildDelete(data);
+                break;
+            case 'MESSAGE_CREATE':
+                this.handleMessageCreate(data);
+                break;
+            case 'MESSAGE_UPDATE':
+                this.emit('messageUpdate', data);
+                break;
+            case 'MESSAGE_DELETE':
+                this.emit('messageDelete', data);
+                break;
+            case 'MESSAGE_DELETE_BULK':
+                this.emit('messageDeleteBulk', data);
+                break;
+            case 'CHANNEL_CREATE': {
+                // Update guild channel cache
+                const guildId = data.guild_id;
+                const channelId = data.id || data.channel_id;
+                if (guildId && channelId) {
+                    const guild = this.guilds.get(guildId);
+                    if (guild) {
+                        guild.channels.set(channelId, data);
+                    }
+                }
+                this.emit('channelCreate', data);
+                break;
+            }
+            case 'CHANNEL_UPDATE': {
+                const guildId = data.guild_id;
+                const channelId = data.id || data.channel_id;
+                if (guildId && channelId) {
+                    const guild = this.guilds.get(guildId);
+                    if (guild) {
+                        guild.channels.set(channelId, data);
+                    }
+                }
+                this.emit('channelUpdate', data);
+                break;
+            }
+            case 'CHANNEL_DELETE': {
+                const guildId = data.guild_id;
+                const channelId = data.id || data.channel_id;
+                if (guildId && channelId) {
+                    const guild = this.guilds.get(guildId);
+                    if (guild) {
+                        guild.channels.delete(channelId);
+                    }
+                }
+                this.emit('channelDelete', data);
+                break;
+            }
+            case 'GUILD_MEMBER_ADD': {
+                const guild = this.guilds.get(String(data.guild_id));
+                if (guild && data.user) {
+                    const member = guild._addMember(data);
+                    this.emit('guildMemberAdd', member);
+                }
+                else {
+                    this.emit('guildMemberAdd', data);
+                }
+                break;
+            }
+            case 'GUILD_MEMBER_UPDATE': {
+                const guild = this.guilds.get(String(data.guild_id));
+                const rawUserId = data.user?.id || data.user_id;
+                if (guild && rawUserId) {
+                    const existing = guild.members.get(String(rawUserId));
+                    if (existing) {
+                        existing._patch(data);
+                        this.emit('guildMemberUpdate', existing);
+                    }
+                    else {
+                        this.emit('guildMemberUpdate', data);
+                    }
+                }
+                else {
+                    this.emit('guildMemberUpdate', data);
+                }
+                break;
+            }
+            case 'GUILD_MEMBER_REMOVE': {
+                const guild = this.guilds.get(String(data.guild_id));
+                const rawUserId = data.user?.id || data.user_id;
+                if (guild && rawUserId) {
+                    const userId = String(rawUserId);
+                    const member = guild.members.get(userId);
+                    guild.members.delete(userId);
+                    this.emit('guildMemberRemove', member || data);
+                }
+                else {
+                    this.emit('guildMemberRemove', data);
+                }
+                break;
+            }
+            case 'GUILD_ROLE_CREATE':
+                this.emit('roleCreate', data);
+                break;
+            case 'GUILD_ROLE_UPDATE':
+                this.emit('roleUpdate', data);
+                break;
+            case 'GUILD_ROLE_DELETE':
+                this.emit('roleDelete', data);
+                break;
+            case 'GUILD_BAN_ADD':
+                this.emit('guildBanAdd', data);
+                break;
+            case 'GUILD_BAN_REMOVE':
+                this.emit('guildBanRemove', data);
+                break;
+            case 'INVITE_CREATE':
+                this.emit('inviteCreate', data);
+                break;
+            case 'INVITE_DELETE':
+                this.emit('inviteDelete', data);
+                break;
+            case 'TYPING_START':
+                this.emit('typingStart', data);
+                break;
+            case 'PRESENCE_UPDATE':
+                this.emit('presenceUpdate', data);
+                break;
+            case 'INTERACTION_CREATE':
+                this.handleInteractionCreate(data);
+                break;
+            case 'VOICE_STATE_UPDATE':
+                this.handleVoiceStateUpdate(data);
+                break;
+            case 'VOICE_SERVER_UPDATE':
+                this.handleVoiceServerUpdate(data);
+                break;
+            default:
+                // Emit raw event for unhandled types
+                this.emit('raw', { t: eventType, d: data });
+        }
+    }
+    /**
+     * Handle Ready event
+     */
+    handleReady(data) {
+        this.sessionId = data.session_id;
+        this.user = new User(data.user);
+        // Handle both string and number application IDs
+        this.applicationId = data.application?.id ? String(data.application.id) : null;
+        if (this.applicationId) {
+            this.rest.setApplicationId(this.applicationId);
+        }
+        // Cache guilds (as unavailable initially)
+        if (data.guilds) {
+            for (const guild of data.guilds) {
+                this.guilds.set(String(guild.id), new Guild(this, guild));
+            }
+        }
+        // Setup voice adapters for each guild
+        this.setupVoiceAdapters();
+        console.log(`✅ Bot hazır! User: ${this.user.username} (${this.user.id}), App: ${this.applicationId}`);
+        this.emit('ready', this);
+    }
+    /**
+     * Setup voice adapters for all guilds
+     */
+    setupVoiceAdapters() {
+        for (const [guildId] of this.guilds) {
+            this.createVoiceAdapter(guildId);
+        }
+    }
+    /**
+     * Create a voice adapter for a guild
+     */
+    createVoiceAdapter(guildId) {
+        const adapter = (methods) => {
+            // Store handlers for this guild
+            this.voiceStateHandlers.set(guildId, methods.onVoiceStateUpdate);
+            this.voiceServerHandlers.set(guildId, methods.onVoiceServerUpdate);
+            return {
+                sendPayload: (payload) => {
+                    if (this.ws?.readyState === WebSocket.OPEN) {
+                        this.ws.send(JSON.stringify(payload));
+                        return true;
+                    }
+                    return false;
+                },
+                destroy: () => {
+                    this.voiceStateHandlers.delete(guildId);
+                    this.voiceServerHandlers.delete(guildId);
+                }
+            };
+        };
+        this.voice.adapters.set(guildId, adapter);
+    }
+    /**
+     * Handle Guild Create event
+     */
+    handleGuildCreate(data) {
+        let guild = this.guilds.get(data.id);
+        if (guild) {
+            guild._patch(data);
+        }
+        else {
+            guild = new Guild(this, data);
+            this.guilds.set(data.id, guild);
+            this.createVoiceAdapter(data.id);
+        }
+        this.emit('guildCreate', guild);
+    }
+    /**
+     * Handle Guild Update event
+     */
+    handleGuildUpdate(data) {
+        const guild = this.guilds.get(data.id);
+        if (guild) {
+            guild._patch(data);
+            this.emit('guildUpdate', guild);
+        }
+    }
+    /**
+     * Handle Guild Delete event
+     */
+    handleGuildDelete(data) {
+        const guild = this.guilds.get(data.id);
+        if (guild) {
+            this.guilds.delete(data.id);
+            this.voice.adapters.delete(data.id);
+            this.emit('guildDelete', guild);
+        }
+    }
+    /**
+     * Handle Message Create event
+     */
+    handleMessageCreate(data) {
+        // Backend sends user_id separately, map it to author.id for compatibility
+        if (data.user_id && data.author && !data.author.id) {
+            data.author.id = data.user_id;
+        }
+        // Cache the author
+        if (data.author) {
+            const user = new User(data.author);
+            this.users.set(user.id, user);
+            // Also cache in REST for mention resolution
+            this.rest.cacheUser(data.author);
+        }
+        const message = new Message(this, data);
+        // Mark message as from bot if author ID matches the bot's own user ID
+        if (this.user && String(message.author.id) === String(this.user.id)) {
+            message.author.bot = true;
+        }
+        // Resolve guild member if in a guild
+        if (message.guildId) {
+            const guild = this.guilds.get(message.guildId);
+            const memberData = data.member;
+            if (memberData && guild) {
+                // Gateway sent member data with the message — cache it
+                memberData.user = data.author;
+                const member = guild._addMember(memberData);
+                message.member = member;
+            }
+            else if (memberData) {
+                // No guild in cache but member data exists
+                memberData.user = data.author;
+                const resolvedGuild = { id: message.guildId, ownerId: null };
+                message.member = new (require('./structures/GuildMember').GuildMember)(this, resolvedGuild, memberData);
+            }
+            else if (guild) {
+                // Try cache
+                const cached = guild.members?.get(String(message.author.id));
+                if (cached?.permissions?.has) {
+                    message.member = cached;
+                }
+            }
+        }
+        this.emit('messageCreate', message);
+    }
+    /**
+     * Handle Interaction Create event
+     */
+    handleInteractionCreate(data) {
+        console.log('[DEBUG] handleInteractionCreate called with:', JSON.stringify(data, null, 2));
+        // Cache the user
+        const userData = data.member?.user || data.user;
+        if (userData) {
+            const user = new User(userData);
+            this.users.set(user.id, user);
+            this.rest.cacheUser(userData);
+        }
+        const interaction = createInteraction(this, data);
+        console.log('[DEBUG] Created interaction type:', interaction.constructor.name, 'customId:', interaction.customId);
+        this.emit('interactionCreate', interaction);
+    }
+    /**
+     * Handle Voice State Update event
+     */
+    handleVoiceStateUpdate(data) {
+        const guildId = data.guild_id;
+        // Forward to voice adapter if exists
+        const handler = this.voiceStateHandlers.get(guildId);
+        if (handler) {
+            handler(data);
+        }
+        this.emit('voiceStateUpdate', data);
+    }
+    /**
+     * Handle Voice Server Update event
+     */
+    handleVoiceServerUpdate(data) {
+        const guildId = data.guild_id;
+        // Forward to voice adapter if exists
+        const handler = this.voiceServerHandlers.get(guildId);
+        if (handler) {
+            handler({
+                token: data.token,
+                endpoint: data.endpoint,
+                room: data.room
+            });
+        }
+        this.emit('voiceServerUpdate', data);
+    }
+    /**
+     * Send Identify payload
+     */
+    identify() {
+        const payload = {
+            op: GatewayOpcodes.Identify,
+            d: {
+                token: `Bot ${this.token}`,
+                intents: this.getIntentsValue(),
+                shard: this.options.shards || [0, 1]
+            }
+        };
+        this.send(payload);
+    }
+    /**
+     * Start heartbeat
+     */
+    startHeartbeat(interval) {
+        this.heartbeatInterval = setInterval(() => {
+            this.send({
+                op: GatewayOpcodes.Heartbeat,
+                d: this.sequence
+            });
+        }, interval);
+    }
+    /**
+     * Send payload to gateway
+     */
+    send(payload) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(payload));
+        }
+    }
+    /**
+     * Cleanup on disconnect
+     */
+    cleanup() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    /**
+     * Destroy the client
+     */
+    destroy() {
+        this._loginState = 'idle';
+        this._reconnectAttempts = this._maxReconnectAttempts + 1; // Prevent reconnect
+        this.cleanup();
+        this.ws?.close(1000);
+        this.ws = null;
+        this.removeAllListeners();
+    }
+}
+// Re-export for convenience
+export { GatewayIntentBits };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Client.js","sourceRoot":"","sources":["../../src/Client.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from 'events';\r\nimport WebSocket from 'ws';\r\nimport { \r\n  ClientOptions, \r\n  GatewayPayload, \r\n  ReadyEventData,\r\n  APIGuild,\r\n  APIInteraction,\r\n  APIMessage,\r\n  APIVoiceServerUpdate,\r\n  APIChannel,\r\n  APIUser\r\n} from './types';\r\nimport { GatewayOpcodes, GatewayIntentBits } from './enums';\r\nimport { Collection } from './structures/Collection';\r\nimport { User } from './structures/User';\r\nimport { Guild } from './structures/Guild';\r\nimport { Message } from './structures/Message';\r\nimport { createInteraction, Interaction } from './structures/Interaction';\r\nimport { BaseChannel, createChannel } from './structures/Channel';\r\nimport { REST } from './rest/REST';\r\n\r\n/**\r\n * Voice adapter creator type for @jubbio/voice compatibility\r\n */\r\ntype VoiceAdapterCreator = (methods: {\r\n  onVoiceServerUpdate(data: any): void;\r\n  onVoiceStateUpdate(data: any): void;\r\n  destroy(): void;\r\n}) => {\r\n  sendPayload(payload: any): boolean;\r\n  destroy(): void;\r\n};\r\n\r\n/**\r\n * Main client class\r\n */\r\nexport class Client extends EventEmitter {\r\n  /** Client options */\r\n  public readonly options: ClientOptions;\r\n  \r\n  /** REST API client */\r\n  public readonly rest: REST;\r\n  \r\n  /** The bot user */\r\n  public user: User | null = null;\r\n  \r\n  /** Application ID */\r\n  public applicationId: string | null = null;\r\n  \r\n  /** Cached guilds */\r\n  public guilds: Collection<string, Guild> = new Collection();\r\n  \r\n  /** Cached channels */\r\n  public channels: Collection<string, BaseChannel> = new Collection();\r\n  \r\n  /** Cached users */\r\n  public users: Collection<string, User> = new Collection();\r\n  \r\n  /** Voice adapter management */\r\n  public voice: {\r\n    adapters: Map<string, VoiceAdapterCreator>;\r\n  };\r\n  \r\n  /** WebSocket connection */\r\n  private ws: WebSocket | null = null;\r\n  \r\n  /** Bot token */\r\n  private token: string = '';\r\n  \r\n  /** Session ID */\r\n  private sessionId: string | null = null;\r\n  \r\n  /** Sequence number */\r\n  private sequence: number | null = null;\r\n  \r\n  /** Heartbeat interval */\r\n  private heartbeatInterval: NodeJS.Timeout | null = null;\r\n  \r\n  /** Gateway URL */\r\n  private gatewayUrl: string;\r\n  \r\n  /** Voice state update handlers (for voice adapters) */\r\n  private voiceStateHandlers: Map<string, (data: any) => void> = new Map();\r\n  private voiceServerHandlers: Map<string, (data: any) => void> = new Map();\r\n\r\n  /** Whether the client is currently in the login flow */\r\n  private _loginState: 'idle' | 'connecting' | 'ready' = 'idle';\r\n\r\n  /** Reconnect attempt counter */\r\n  private _reconnectAttempts: number = 0;\r\n\r\n  /** Maximum reconnect attempts before giving up */\r\n  private readonly _maxReconnectAttempts: number = 5;\r\n\r\n  constructor(options: ClientOptions) {\r\n    super();\r\n    this.options = options;\r\n    this.gatewayUrl = options.gatewayUrl || 'wss://realtime.jubbio.com/ws/bot';\r\n    this.rest = new REST(options.apiUrl);\r\n    \r\n    // Initialize voice adapter system\r\n    this.voice = {\r\n      adapters: new Map()\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Calculate intents value\r\n   */\r\n  private getIntentsValue(): number {\r\n    if (typeof this.options.intents === 'number') {\r\n      return this.options.intents;\r\n    }\r\n    return this.options.intents.reduce((acc, intent) => acc | intent, 0);\r\n  }\r\n\r\n  /**\r\n   * Gateway close code descriptions\r\n   */\r\n  private static readonly CLOSE_CODES: Record<number, { message: string; reconnectable: boolean }> = {\r\n    4000: { message: 'Bilinmeyen hata (Unknown error)', reconnectable: true },\r\n    4001: { message: 'Bilinmeyen opcode gönderildi (Unknown opcode)', reconnectable: true },\r\n    4002: { message: 'Geçersiz payload gönderildi (Decode error)', reconnectable: true },\r\n    4003: { message: 'Henüz kimlik doğrulaması yapılmadı (Not authenticated)', reconnectable: true },\r\n    4004: { message: 'Geçersiz bot token\\'ı (Authentication failed)', reconnectable: false },\r\n    4005: { message: 'Zaten kimlik doğrulaması yapılmış (Already authenticated)', reconnectable: true },\r\n    4007: { message: 'Geçersiz sequence numarası (Invalid seq)', reconnectable: true },\r\n    4008: { message: 'Rate limit aşıldı (Rate limited)', reconnectable: true },\r\n    4009: { message: 'Oturum zaman aşımına uğradı (Session timed out)', reconnectable: true },\r\n    4010: { message: 'Geçersiz shard yapılandırması (Invalid shard)', reconnectable: false },\r\n    4011: { message: 'Sharding gerekli (Sharding required)', reconnectable: false },\r\n    4014: { message: 'İzin verilmeyen intent\\'ler istendi (Disallowed intents)', reconnectable: false },\r\n  };\r\n\r\n  /**\r\n   * Login to the gateway\r\n   */\r\n  async login(token: string): Promise<string> {\r\n    if (!token || typeof token !== 'string') {\r\n      throw new Error(\r\n        'Geçerli bir bot token\\'ı sağlanmalıdır. Örnek: client.login(process.env.BOT_TOKEN)'\r\n      );\r\n    }\r\n\r\n    this.token = token.replace(/^Bot\\s+/i, '');\r\n    this.rest.setToken(this.token);\r\n    this._loginState = 'connecting';\r\n    this._reconnectAttempts = 0;\r\n\r\n    return new Promise((resolve, reject) => {\r\n      const cleanup = () => {\r\n        clearTimeout(timeout);\r\n        this.removeListener('ready', onReady);\r\n        this.removeListener('error', onError);\r\n        this.removeListener('gatewayClose', onGatewayClose);\r\n      };\r\n\r\n      const timeout = setTimeout(() => {\r\n        cleanup();\r\n        this._loginState = 'idle';\r\n        reject(new Error(\r\n          'Gateway\\'e bağlanılamadı: 30 saniye içinde READY event\\'i alınamadı. ' +\r\n          'Olası sebepler: gateway sunucusu erişilemez, token geçersiz veya ağ sorunu.'\r\n        ));\r\n      }, 30000);\r\n\r\n      const onReady = () => {\r\n        cleanup();\r\n        this._loginState = 'ready';\r\n        this._reconnectAttempts = 0;\r\n        resolve(this.token);\r\n      };\r\n\r\n      const onError = (error: Error) => {\r\n        cleanup();\r\n        this._loginState = 'idle';\r\n        reject(error);\r\n      };\r\n\r\n      const onGatewayClose = (code: number, reason: string) => {\r\n        const info = Client.CLOSE_CODES[code];\r\n        if (info && !info.reconnectable) {\r\n          cleanup();\r\n          this._loginState = 'idle';\r\n          reject(new Error(`Gateway bağlantısı reddedildi [${code}]: ${info.message}${reason ? ' - ' + reason : ''}`));\r\n        }\r\n        // Reconnectable codes: login promise stays alive, connect() will retry\r\n      };\r\n\r\n      this.once('ready', onReady);\r\n      this.once('error', onError);\r\n      this.on('gatewayClose', onGatewayClose);\r\n\r\n      this.connect();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Connect to the gateway\r\n   */\r\n  private connect(): void {\r\n    this.ws = new WebSocket(this.gatewayUrl);\r\n    \r\n    this.ws.on('open', () => {\r\n      this.emit('debug', 'WebSocket bağlantısı açıldı');\r\n      this._reconnectAttempts = 0;\r\n    });\r\n    \r\n    this.ws.on('message', (data) => {\r\n      this.handleMessage(data.toString());\r\n    });\r\n    \r\n    this.ws.on('close', (code, reason) => {\r\n      const reasonStr = reason?.toString() || '';\r\n      const info = Client.CLOSE_CODES[code];\r\n      \r\n      if (info) {\r\n        this.emit('debug', `Gateway bağlantısı kapandı [${code}]: ${info.message}${reasonStr ? ' - ' + reasonStr : ''}`);\r\n      } else {\r\n        this.emit('debug', `WebSocket kapandı: ${code} - ${reasonStr}`);\r\n      }\r\n      \r\n      this.cleanup();\r\n\r\n      // Emit gatewayClose so login() can handle non-reconnectable codes\r\n      this.emit('gatewayClose', code, reasonStr);\r\n\r\n      // Non-reconnectable codes: don't retry\r\n      if (info && !info.reconnectable) {\r\n        this.emit('debug', `Kod ${code} yeniden bağlanılamaz, bağlantı sonlandırılıyor.`);\r\n        return;\r\n      }\r\n\r\n      // Normal close: don't retry\r\n      if (code === 1000) {\r\n        return;\r\n      }\r\n\r\n      // Reconnectable: retry with backoff\r\n      this._reconnectAttempts++;\r\n      if (this._reconnectAttempts > this._maxReconnectAttempts) {\r\n        this.emit('debug', `Maksimum yeniden bağlanma denemesi aşıldı (${this._maxReconnectAttempts})`);\r\n        this.emit('error', new Error(\r\n          `Gateway bağlantısı ${this._maxReconnectAttempts} denemeden sonra kurulamadı. Son kapanma kodu: ${code}`\r\n        ));\r\n        return;\r\n      }\r\n\r\n      const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts - 1), 30000);\r\n      this.emit('debug', `Yeniden bağlanılıyor (deneme ${this._reconnectAttempts}/${this._maxReconnectAttempts}), ${delay}ms sonra...`);\r\n      setTimeout(() => this.connect(), delay);\r\n    });\r\n    \r\n    this.ws.on('error', (error) => {\r\n      this.emit('debug', `WebSocket hatası: ${error.message}`);\r\n      this.emit('error', error);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Handle incoming gateway message\r\n   */\r\n  private handleMessage(data: string): void {\r\n    // Handle multiple messages in one frame\r\n    const messages = data.split('\\n').filter(m => m.trim());\r\n    \r\n    for (const msg of messages) {\r\n      try {\r\n        const payload: GatewayPayload = JSON.parse(msg);\r\n        this.handlePayload(payload);\r\n      } catch (e) {\r\n        this.emit('debug', `Failed to parse message: ${msg}`);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle gateway payload\r\n   */\r\n  private handlePayload(payload: GatewayPayload): void {\r\n    if (payload.s) {\r\n      this.sequence = payload.s;\r\n    }\r\n\r\n    switch (payload.op) {\r\n      case GatewayOpcodes.Hello:\r\n        this.handleHello(payload.d);\r\n        break;\r\n        \r\n      case GatewayOpcodes.Dispatch:\r\n        this.handleDispatch(payload.t!, payload.d);\r\n        break;\r\n        \r\n      case GatewayOpcodes.HeartbeatAck:\r\n        this.emit('debug', 'Heartbeat acknowledged');\r\n        break;\r\n        \r\n      case GatewayOpcodes.InvalidSession:\r\n        this.emit('debug', 'Geçersiz oturum, yeniden kimlik doğrulanıyor...');\r\n        // InvalidSession may carry error data from sendError()\r\n        if (payload.d && typeof payload.d === 'object' && payload.d.code && payload.d.message) {\r\n          this.emit('debug', `Sunucu hatası [${payload.d.code}]: ${payload.d.message}`);\r\n          const info = Client.CLOSE_CODES[payload.d.code];\r\n          if (info && !info.reconnectable) {\r\n            this.emit('error', new Error(`Gateway hatası [${payload.d.code}]: ${info.message}`));\r\n            return;\r\n          }\r\n        }\r\n        setTimeout(() => this.identify(), 5000);\r\n        break;\r\n        \r\n      case GatewayOpcodes.Reconnect:\r\n        this.emit('debug', 'Reconnect requested');\r\n        this.ws?.close();\r\n        setTimeout(() => this.connect(), 1000);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Hello payload\r\n   */\r\n  private handleHello(data: { heartbeat_interval: number }): void {\r\n    this.emit('debug', `Received Hello, heartbeat interval: ${data.heartbeat_interval}ms`);\r\n    this.startHeartbeat(data.heartbeat_interval);\r\n    this.identify();\r\n  }\r\n\r\n  /**\r\n   * Handle Dispatch events\r\n   */\r\n  private handleDispatch(eventType: string, data: any): void {\r\n    this.emit('debug', `Dispatch: ${eventType}`);\r\n    \r\n    switch (eventType) {\r\n      case 'READY':\r\n        this.handleReady(data);\r\n        break;\r\n        \r\n      case 'GUILD_CREATE':\r\n        this.handleGuildCreate(data);\r\n        break;\r\n        \r\n      case 'GUILD_UPDATE':\r\n        this.handleGuildUpdate(data);\r\n        break;\r\n        \r\n      case 'GUILD_DELETE':\r\n        this.handleGuildDelete(data);\r\n        break;\r\n        \r\n      case 'MESSAGE_CREATE':\r\n        this.handleMessageCreate(data);\r\n        break;\r\n        \r\n      case 'MESSAGE_UPDATE':\r\n        this.emit('messageUpdate', data);\r\n        break;\r\n        \r\n      case 'MESSAGE_DELETE':\r\n        this.emit('messageDelete', data);\r\n        break;\r\n        \r\n      case 'MESSAGE_DELETE_BULK':\r\n        this.emit('messageDeleteBulk', data);\r\n        break;\r\n        \r\n      case 'CHANNEL_CREATE': {\r\n        // Update guild channel cache\r\n        const guildId = data.guild_id;\r\n        const channelId = data.id || data.channel_id;\r\n        if (guildId && channelId) {\r\n          const guild = this.guilds.get(guildId);\r\n          if (guild) {\r\n            guild.channels.set(channelId, data);\r\n          }\r\n        }\r\n        this.emit('channelCreate', data);\r\n        break;\r\n      }\r\n        \r\n      case 'CHANNEL_UPDATE': {\r\n        const guildId = data.guild_id;\r\n        const channelId = data.id || data.channel_id;\r\n        if (guildId && channelId) {\r\n          const guild = this.guilds.get(guildId);\r\n          if (guild) {\r\n            guild.channels.set(channelId, data);\r\n          }\r\n        }\r\n        this.emit('channelUpdate', data);\r\n        break;\r\n      }\r\n        \r\n      case 'CHANNEL_DELETE': {\r\n        const guildId = data.guild_id;\r\n        const channelId = data.id || data.channel_id;\r\n        if (guildId && channelId) {\r\n          const guild = this.guilds.get(guildId);\r\n          if (guild) {\r\n            guild.channels.delete(channelId);\r\n          }\r\n        }\r\n        this.emit('channelDelete', data);\r\n        break;\r\n      }\r\n        \r\n      case 'GUILD_MEMBER_ADD': {\r\n        const guild = this.guilds.get(String(data.guild_id));\r\n        if (guild && data.user) {\r\n          const member = guild._addMember(data);\r\n          this.emit('guildMemberAdd', member);\r\n        } else {\r\n          this.emit('guildMemberAdd', data);\r\n        }\r\n        break;\r\n      }\r\n        \r\n      case 'GUILD_MEMBER_UPDATE': {\r\n        const guild = this.guilds.get(String(data.guild_id));\r\n        const rawUserId = data.user?.id || data.user_id;\r\n        if (guild && rawUserId) {\r\n          const existing = guild.members.get(String(rawUserId));\r\n          if (existing) {\r\n            existing._patch(data);\r\n            this.emit('guildMemberUpdate', existing);\r\n          } else {\r\n            this.emit('guildMemberUpdate', data);\r\n          }\r\n        } else {\r\n          this.emit('guildMemberUpdate', data);\r\n        }\r\n        break;\r\n      }\r\n        \r\n      case 'GUILD_MEMBER_REMOVE': {\r\n        const guild = this.guilds.get(String(data.guild_id));\r\n        const rawUserId = data.user?.id || data.user_id;\r\n        if (guild && rawUserId) {\r\n          const userId = String(rawUserId);\r\n          const member = guild.members.get(userId);\r\n          guild.members.delete(userId);\r\n          this.emit('guildMemberRemove', member || data);\r\n        } else {\r\n          this.emit('guildMemberRemove', data);\r\n        }\r\n        break;\r\n      }\r\n        \r\n      case 'GUILD_ROLE_CREATE':\r\n        this.emit('roleCreate', data);\r\n        break;\r\n        \r\n      case 'GUILD_ROLE_UPDATE':\r\n        this.emit('roleUpdate', data);\r\n        break;\r\n        \r\n      case 'GUILD_ROLE_DELETE':\r\n        this.emit('roleDelete', data);\r\n        break;\r\n        \r\n      case 'GUILD_BAN_ADD':\r\n        this.emit('guildBanAdd', data);\r\n        break;\r\n        \r\n      case 'GUILD_BAN_REMOVE':\r\n        this.emit('guildBanRemove', data);\r\n        break;\r\n        \r\n      case 'INVITE_CREATE':\r\n        this.emit('inviteCreate', data);\r\n        break;\r\n        \r\n      case 'INVITE_DELETE':\r\n        this.emit('inviteDelete', data);\r\n        break;\r\n        \r\n      case 'TYPING_START':\r\n        this.emit('typingStart', data);\r\n        break;\r\n        \r\n      case 'PRESENCE_UPDATE':\r\n        this.emit('presenceUpdate', data);\r\n        break;\r\n        \r\n      case 'INTERACTION_CREATE':\r\n        this.handleInteractionCreate(data);\r\n        break;\r\n        \r\n      case 'VOICE_STATE_UPDATE':\r\n        this.handleVoiceStateUpdate(data);\r\n        break;\r\n        \r\n      case 'VOICE_SERVER_UPDATE':\r\n        this.handleVoiceServerUpdate(data);\r\n        break;\r\n        \r\n      default:\r\n        // Emit raw event for unhandled types\r\n        this.emit('raw', { t: eventType, d: data });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Ready event\r\n   */\r\n  private handleReady(data: ReadyEventData): void {\r\n    this.sessionId = data.session_id;\r\n    this.user = new User(data.user);\r\n    // Handle both string and number application IDs\r\n    this.applicationId = data.application?.id ? String(data.application.id) : null;\r\n    if (this.applicationId) {\r\n      this.rest.setApplicationId(this.applicationId);\r\n    }\r\n    \r\n    // Cache guilds (as unavailable initially)\r\n    if (data.guilds) {\r\n      for (const guild of data.guilds) {\r\n        this.guilds.set(String(guild.id), new Guild(this, guild));\r\n      }\r\n    }\r\n    \r\n    // Setup voice adapters for each guild\r\n    this.setupVoiceAdapters();\r\n    \r\n    console.log(`✅ Bot hazır! User: ${this.user.username} (${this.user.id}), App: ${this.applicationId}`);\r\n    this.emit('ready', this);\r\n  }\r\n\r\n  /**\r\n   * Setup voice adapters for all guilds\r\n   */\r\n  private setupVoiceAdapters(): void {\r\n    for (const [guildId] of this.guilds) {\r\n      this.createVoiceAdapter(guildId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a voice adapter for a guild\r\n   */\r\n  private createVoiceAdapter(guildId: string): void {\r\n    const adapter: VoiceAdapterCreator = (methods) => {\r\n      // Store handlers for this guild\r\n      this.voiceStateHandlers.set(guildId, methods.onVoiceStateUpdate);\r\n      this.voiceServerHandlers.set(guildId, methods.onVoiceServerUpdate);\r\n      \r\n      return {\r\n        sendPayload: (payload) => {\r\n          if (this.ws?.readyState === WebSocket.OPEN) {\r\n            this.ws.send(JSON.stringify(payload));\r\n            return true;\r\n          }\r\n          return false;\r\n        },\r\n        destroy: () => {\r\n          this.voiceStateHandlers.delete(guildId);\r\n          this.voiceServerHandlers.delete(guildId);\r\n        }\r\n      };\r\n    };\r\n    \r\n    this.voice.adapters.set(guildId, adapter);\r\n  }\r\n\r\n  /**\r\n   * Handle Guild Create event\r\n   */\r\n  private handleGuildCreate(data: APIGuild): void {\r\n    let guild = this.guilds.get(data.id);\r\n    \r\n    if (guild) {\r\n      guild._patch(data);\r\n    } else {\r\n      guild = new Guild(this, data);\r\n      this.guilds.set(data.id, guild);\r\n      this.createVoiceAdapter(data.id);\r\n    }\r\n    \r\n    this.emit('guildCreate', guild);\r\n  }\r\n\r\n  /**\r\n   * Handle Guild Update event\r\n   */\r\n  private handleGuildUpdate(data: APIGuild): void {\r\n    const guild = this.guilds.get(data.id);\r\n    if (guild) {\r\n      guild._patch(data);\r\n      this.emit('guildUpdate', guild);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Guild Delete event\r\n   */\r\n  private handleGuildDelete(data: { id: string }): void {\r\n    const guild = this.guilds.get(data.id);\r\n    if (guild) {\r\n      this.guilds.delete(data.id);\r\n      this.voice.adapters.delete(data.id);\r\n      this.emit('guildDelete', guild);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle Message Create event\r\n   */\r\n  private handleMessageCreate(data: APIMessage): void {\r\n    // Backend sends user_id separately, map it to author.id for compatibility\r\n    if (data.user_id && data.author && !data.author.id) {\r\n      (data.author as any).id = data.user_id;\r\n    }\r\n    \r\n    // Cache the author\r\n    if (data.author) {\r\n      const user = new User(data.author);\r\n      this.users.set(user.id, user);\r\n      // Also cache in REST for mention resolution\r\n      this.rest.cacheUser(data.author);\r\n    }\r\n    \r\n    const message = new Message(this, data);\r\n\r\n    // Mark message as from bot if author ID matches the bot's own user ID\r\n    if (this.user && String(message.author.id) === String(this.user.id)) {\r\n      (message.author as any).bot = true;\r\n    }\r\n\r\n    // Resolve guild member if in a guild\r\n    if (message.guildId) {\r\n      const guild = this.guilds.get(message.guildId);\r\n      const memberData = (data as any).member;\r\n      if (memberData && guild) {\r\n        // Gateway sent member data with the message — cache it\r\n        memberData.user = data.author;\r\n        const member = guild._addMember(memberData);\r\n        message.member = member;\r\n      } else if (memberData) {\r\n        // No guild in cache but member data exists\r\n        memberData.user = data.author;\r\n        const resolvedGuild = { id: message.guildId, ownerId: null } as any;\r\n        message.member = new (require('./structures/GuildMember').GuildMember)(this, resolvedGuild, memberData);\r\n      } else if (guild) {\r\n        // Try cache\r\n        const cached = guild.members?.get(String(message.author.id));\r\n        if (cached?.permissions?.has) {\r\n          message.member = cached;\r\n        }\r\n      }\r\n    }\r\n\r\n    this.emit('messageCreate', message);\r\n  }\r\n\r\n  /**\r\n   * Handle Interaction Create event\r\n   */\r\n  private handleInteractionCreate(data: APIInteraction): void {\r\n    console.log('[DEBUG] handleInteractionCreate called with:', JSON.stringify(data, null, 2));\r\n    \r\n    // Cache the user\r\n    const userData = data.member?.user || data.user;\r\n    if (userData) {\r\n      const user = new User(userData);\r\n      this.users.set(user.id, user);\r\n      this.rest.cacheUser(userData);\r\n    }\r\n    \r\n    const interaction = createInteraction(this, data);\r\n    console.log('[DEBUG] Created interaction type:', interaction.constructor.name, 'customId:', (interaction as any).customId);\r\n    this.emit('interactionCreate', interaction);\r\n  }\r\n\r\n  /**\r\n   * Handle Voice State Update event\r\n   */\r\n  private handleVoiceStateUpdate(data: any): void {\r\n    const guildId = data.guild_id;\r\n    \r\n    // Forward to voice adapter if exists\r\n    const handler = this.voiceStateHandlers.get(guildId);\r\n    if (handler) {\r\n      handler(data);\r\n    }\r\n    \r\n    this.emit('voiceStateUpdate', data);\r\n  }\r\n\r\n  /**\r\n   * Handle Voice Server Update event\r\n   */\r\n  private handleVoiceServerUpdate(data: APIVoiceServerUpdate): void {\r\n    const guildId = data.guild_id;\r\n    \r\n    // Forward to voice adapter if exists\r\n    const handler = this.voiceServerHandlers.get(guildId);\r\n    if (handler) {\r\n      handler({\r\n        token: data.token,\r\n        endpoint: data.endpoint,\r\n        room: data.room\r\n      });\r\n    }\r\n    \r\n    this.emit('voiceServerUpdate', data);\r\n  }\r\n\r\n  /**\r\n   * Send Identify payload\r\n   */\r\n  private identify(): void {\r\n    const payload: GatewayPayload = {\r\n      op: GatewayOpcodes.Identify,\r\n      d: {\r\n        token: `Bot ${this.token}`,\r\n        intents: this.getIntentsValue(),\r\n        shard: this.options.shards || [0, 1]\r\n      }\r\n    };\r\n    \r\n    this.send(payload);\r\n  }\r\n\r\n  /**\r\n   * Start heartbeat\r\n   */\r\n  private startHeartbeat(interval: number): void {\r\n    this.heartbeatInterval = setInterval(() => {\r\n      this.send({\r\n        op: GatewayOpcodes.Heartbeat,\r\n        d: this.sequence\r\n      });\r\n    }, interval);\r\n  }\r\n\r\n  /**\r\n   * Send payload to gateway\r\n   */\r\n  private send(payload: GatewayPayload): void {\r\n    if (this.ws?.readyState === WebSocket.OPEN) {\r\n      this.ws.send(JSON.stringify(payload));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Cleanup on disconnect\r\n   */\r\n  private cleanup(): void {\r\n    if (this.heartbeatInterval) {\r\n      clearInterval(this.heartbeatInterval);\r\n      this.heartbeatInterval = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Destroy the client\r\n   */\r\n  destroy(): void {\r\n    this._loginState = 'idle';\r\n    this._reconnectAttempts = this._maxReconnectAttempts + 1; // Prevent reconnect\r\n    this.cleanup();\r\n    this.ws?.close(1000);\r\n    this.ws = null;\r\n    this.removeAllListeners();\r\n  }\r\n}\r\n\r\n// Re-export for convenience\r\nexport { GatewayIntentBits };\r\n"]}