@hieuxyz/rpc 1.0.7 → 1.0.8

package/README.md

@@ -43,7 +43,7 @@ DISCORD_USER_TOKEN="YOUR_DISCORD_USER_TOKEN_HERE"
 
 ```typescript
 import * as path from 'path';
-import { Client, RawImage, LocalImage, logger } from '@hieuxyz/rpc';
+import { Client, LocalImage, logger } from '@hieuxyz/rpc';
 
 async function start() {
     const token = process.env.DISCORD_USER_TOKEN;
@@ -54,7 +54,10 @@ async function start() {
     }
 
     // Initialize client with token
-    const client = new Client({ token });
+    const client = new Client({
+        token,
+        alwaysReconnect: true,
+    });
 
     await client.run();
 
@@ -66,11 +69,8 @@ async function start() {
         .setType(0) // 0: Playing
         .setTimestamps(Date.now())
         .setParty(1, 5)
-        .setLargeImage(new RawImage("mp:external/b7uybXM7LoJRB6_ig-65aX6dCHm2qGCEe8CiS5j7c2M/https/cdn.worldvectorlogo.com/logos/typescript.svg"), "TypeScript")
-        .setSmallImage(new LocalImage(path.join(__dirname, 'vscode.png')), "VS Code")
-        .setButtons([
-            { label: "View on GitHub", url: "https://github.com/hieuxyz00/hieuxyz_rpc" }
-        ]);
+        .setLargeImage("https://i.ibb.co/MDP0hfTM/typescript.png", "TypeScript")
+        .setSmallImage(new LocalImage(path.join(__dirname, 'vscode.png')), "VS Code");
 
     await client.rpc.build();
 
@@ -139,8 +139,11 @@ This is the main starting point.
 -   `new Client(options)`: Create a new instance.
     -   `options.token` (required): Your Discord user token.
     -   `options.apiBaseUrl` (optional): Override the default image proxy service URL.
+    -   `options.alwaysReconnect` (optional): If `true`, the client will attempt to reconnect even after a normal close (e.g., from `client.close()` or a Discord-initiated close). Defaults to `false`.
 -   `client.run()`: Start connecting to Discord Gateway.
 -   `client.rpc`: Access the instance of `HieuxyzRPC` to build the state.
+-   `client.close(force?: boolean)`: Closes the connection to the Discord Gateway.
+    -   `force` (optional, boolean): If set to `true`, the client will close permanently and will not attempt to reconnect, overriding the `alwaysReconnect` option. Defaults to `false`.
 
 ### Class `HieuxyzRPC`
 

package/dist/hieuxyz/Client.d.ts

@@ -48,8 +48,8 @@ export declare class Client {
     run(): Promise<void>;
     /**
      * Close the connection to Discord Gateway.
-     * Terminate RPC and clean up resources.
-     * If `alwaysReconnect` is true, the client will attempt to reconnect after this.
+     * @param {boolean} [force=false] - If true, the client will close permanently and will not attempt to reconnect,
+     * even if `alwaysReconnect` is enabled. Defaults to false.
      */
-    close(): void;
+    close(force?: boolean): void;
 }

package/dist/hieuxyz/Client.js

@@ -55,12 +55,12 @@ class Client {
     }
     /**
      * Close the connection to Discord Gateway.
-     * Terminate RPC and clean up resources.
-     * If `alwaysReconnect` is true, the client will attempt to reconnect after this.
+     * @param {boolean} [force=false] - If true, the client will close permanently and will not attempt to reconnect,
+     * even if `alwaysReconnect` is enabled. Defaults to false.
      */
-    close() {
+    close(force = false) {
         this.rpc.stopBackgroundRenewal();
-        this.websocket.close();
+        this.websocket.close(force);
     }
 }
 exports.Client = Client;

package/dist/hieuxyz/gateway/DiscordWebSocket.d.ts

@@ -11,9 +11,12 @@ export declare class DiscordWebSocket {
     private ws;
     private sequence;
     private heartbeatInterval;
+    private heartbeatIntervalValue;
     private sessionId;
     private resumeGatewayUrl;
     private options;
+    private isReconnecting;
+    private permanentClose;
     private resolveReady;
     /**
      * A promise will be resolved when the Gateway connection is ready.
@@ -34,9 +37,9 @@ export declare class DiscordWebSocket {
      * If there was a previous session, it will try to resume.
      */
     connect(): void;
-    private reconnect;
     private onMessage;
     private startHeartbeating;
+    private sendHeartbeat;
     private identify;
     private resume;
     /**
@@ -46,9 +49,10 @@ export declare class DiscordWebSocket {
     sendActivity(presence: PresenceUpdatePayload): void;
     private sendJson;
     /**
-     * Close the WebSocket connection and clean up the resources.
+     * Closes the WebSocket connection.
+     * @param force If true, prevents any automatic reconnection attempts.
      */
-    close(): void;
+    close(force?: boolean): void;
     private cleanupHeartbeat;
     private shouldReconnect;
 }

package/dist/hieuxyz/gateway/DiscordWebSocket.js

@@ -17,9 +17,12 @@ class DiscordWebSocket {
     ws = null;
     sequence = null;
     heartbeatInterval = null;
+    heartbeatIntervalValue = 0;
     sessionId = null;
     resumeGatewayUrl = null;
     options;
+    isReconnecting = false;
+    permanentClose = false;
     resolveReady = () => { };
     /**
      * A promise will be resolved when the Gateway connection is ready.
@@ -51,18 +54,40 @@ class DiscordWebSocket {
      * If there was a previous session, it will try to resume.
      */
     connect() {
+        if (this.isReconnecting) {
+            logger_1.logger.info("Connection attempt aborted: reconnection already in progress.");
+            return;
+        }
+        this.permanentClose = false;
+        this.isReconnecting = true;
         this.resetReadyPromise();
         const url = this.resumeGatewayUrl || "wss://gateway.discord.gg/?v=10&encoding=json";
         logger_1.logger.info(`Attempting to connect to ${url}...`);
         this.ws = new ws_1.default(url);
-        this.ws.on('open', () => logger_1.logger.info(`Connected to Discord Gateway at ${url}.`));
+        this.ws.on('open', () => {
+            logger_1.logger.info(`Successfully connected to Discord Gateway at ${url}.`);
+            this.isReconnecting = false;
+        });
         this.ws.on('message', this.onMessage.bind(this));
         this.ws.on('close', (code, reason) => {
-            logger_1.logger.warn(`Connection closed: ${code} - ${reason.toString()}`);
+            logger_1.logger.warn(`Connection closed: ${code} - ${reason.toString('utf-8')}`);
             this.cleanupHeartbeat();
+            if (this.permanentClose) {
+                logger_1.logger.info("Connection permanently closed by client. Not reconnecting.");
+                return;
+            }
+            if (this.isReconnecting)
+                return;
             if (this.shouldReconnect(code)) {
-                logger_1.logger.info("Attempting to reconnect...");
-                this.reconnect(code === 4004);
+                setTimeout(() => {
+                    const canResume = code !== 4004 && !!this.sessionId;
+                    if (!canResume) {
+                        this.sessionId = null;
+                        this.sequence = null;
+                        this.resumeGatewayUrl = null;
+                    }
+                    this.connect();
+                }, 500);
             }
             else {
                 logger_1.logger.info("Not attempting to reconnect based on close code and client options.");
@@ -72,15 +97,6 @@ class DiscordWebSocket {
             logger_1.logger.error(`WebSocket Error: ${err.message}`);
         });
     }
-    reconnect(forceNewSession = false) {
-        this.ws?.terminate();
-        if (forceNewSession) {
-            logger_1.logger.warn("Forcing a new session. Clearing previous session data.");
-            this.sessionId = null;
-            this.resumeGatewayUrl = null;
-        }
-        setTimeout(() => this.connect(), 3000);
-    }
     onMessage(data) {
         const payload = JSON.parse(data.toString());
         if (payload.s) {
@@ -88,8 +104,10 @@ class DiscordWebSocket {
         }
         switch (payload.op) {
             case OpCode_1.OpCode.HELLO:
-                this.startHeartbeating(payload.d.heartbeat_interval);
-                if (this.sessionId) {
+                this.heartbeatIntervalValue = payload.d.heartbeat_interval;
+                logger_1.logger.info(`Received HELLO. Setting heartbeat interval to ${this.heartbeatIntervalValue}ms.`);
+                this.startHeartbeating();
+                if (this.sessionId && this.sequence) {
                     this.resume();
                 }
                 else {
@@ -99,8 +117,8 @@ class DiscordWebSocket {
             case OpCode_1.OpCode.DISPATCH:
                 if (payload.t === 'READY') {
                     this.sessionId = payload.d.session_id;
-                    this.resumeGatewayUrl = payload.d.resume_gateway_url;
-                    logger_1.logger.info(`Session is READY. Session ID: ${this.sessionId}`);
+                    this.resumeGatewayUrl = payload.d.resume_gateway_url + "/?v=10&encoding=json";
+                    logger_1.logger.info(`Session READY. Session ID: ${this.sessionId}. Resume URL set.`);
                     this.resolveReady();
                 }
                 else if (payload.t === 'RESUMED') {
@@ -112,28 +130,27 @@ class DiscordWebSocket {
                 logger_1.logger.info("Heartbeat acknowledged.");
                 break;
             case OpCode_1.OpCode.INVALID_SESSION:
-                logger_1.logger.warn(`Invalid session received. Resumable: ${payload.d}`);
-                if (payload.d === false) {
-                    this.ws?.close(4004, "Session not resumable");
+                logger_1.logger.warn(`Received INVALID_SESSION. Resumable: ${payload.d}`);
+                if (payload.d) {
+                    this.ws?.close(4000, "Invalid session, attempting to resume.");
                 }
                 else {
-                    this.ws?.close(4000, "Session is resumable, retrying");
+                    this.ws?.close(4004, "Invalid session, starting a new session.");
                 }
                 break;
             case OpCode_1.OpCode.RECONNECT:
-                logger_1.logger.info("Gateway requested reconnect. Closing and reconnecting.");
-                this.ws?.close(4000, "Reconnect request");
+                logger_1.logger.info("Gateway requested RECONNECT. Closing to reconnect and resume.");
+                this.ws?.close(4000, "Gateway requested reconnect.");
                 break;
             default:
                 break;
         }
     }
-    startHeartbeating(interval) {
+    startHeartbeating() {
         this.cleanupHeartbeat();
         setTimeout(() => {
             if (this.ws?.readyState === ws_1.default.OPEN) {
-                this.sendJson({ op: OpCode_1.OpCode.HEARTBEAT, d: this.sequence });
-                logger_1.logger.info(`Initial heartbeat sent with sequence ${this.sequence}.`);
+                this.sendHeartbeat();
             }
             this.heartbeatInterval = setInterval(() => {
                 if (this.ws?.readyState !== ws_1.default.OPEN) {
@@ -141,10 +158,15 @@ class DiscordWebSocket {
                     this.cleanupHeartbeat();
                     return;
                 }
-                this.sendJson({ op: OpCode_1.OpCode.HEARTBEAT, d: this.sequence });
-                logger_1.logger.info(`Heartbeat sent with sequence ${this.sequence}.`);
-            }, interval);
-        }, interval * Math.random());
+                this.sendHeartbeat();
+            }, this.heartbeatIntervalValue);
+        }, this.heartbeatIntervalValue * Math.random());
+    }
+    sendHeartbeat() {
+        if (this.ws?.readyState !== ws_1.default.OPEN)
+            return;
+        this.sendJson({ op: OpCode_1.OpCode.HEARTBEAT, d: this.sequence });
+        logger_1.logger.info(`Heartbeat sent with sequence ${this.sequence}.`);
     }
     identify() {
         const identifyPayload = (0, identify_1.getIdentifyPayload)(this.token);
@@ -182,10 +204,21 @@ class DiscordWebSocket {
         }
     }
     /**
-     * Close the WebSocket connection and clean up the resources.
+     * Closes the WebSocket connection.
+     * @param force If true, prevents any automatic reconnection attempts.
      */
-    close() {
-        this.ws?.close(1000, "Client closed connection");
+    close(force = false) {
+        if (force) {
+            logger_1.logger.info("Forcing permanent closure. Reconnects will be disabled.");
+            this.permanentClose = true;
+        }
+        else {
+            logger_1.logger.info("Closing connection manually...");
+        }
+        this.isReconnecting = false;
+        if (this.ws) {
+            this.ws.close(1000, "Client initiated closure");
+        }
     }
     cleanupHeartbeat() {
         if (this.heartbeatInterval) {

package/dist/hieuxyz/rpc/HieuxyzRPC.js

@@ -288,7 +288,7 @@ class HieuxyzRPC {
             since: 0,
             activities: [activity],
             status: this.status,
-            afk: false,
+            afk: true,
         };
         this.websocket.sendActivity(presencePayload);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hieuxyz/rpc",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "A Discord Rich Presence library for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",