@hieuxyz/rpc 1.0.6 → 1.0.7

package/dist/hieuxyz/Client.d.ts

@@ -7,12 +7,20 @@ export interface ClientOptions {
     token: string;
     /** (Optional) Base URL of the image proxy service. */
     apiBaseUrl?: string;
+    /**
+     * (Optional) If true, the client will attempt to reconnect even after a normal close (code 1000).
+     * Defaults to false.
+     */
+    alwaysReconnect?: boolean;
 }
 /**
  * The main Client class for interacting with Discord Rich Presence.
  * This is the starting point for creating and managing your RPC state.
  * @example
- * const client = new Client({ token: "YOUR_DISCORD_TOKEN" });
+ * const client = new Client({
+ *   token: "YOUR_DISCORD_TOKEN",
+ *   alwaysReconnect: true // Keep the RPC alive no matter what
+ * });
  * await client.run();
  * client.rpc.setName("Visual Studio Code");
  * await client.rpc.build();
@@ -41,6 +49,7 @@ export declare 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.
      */
     close(): void;
 }

package/dist/hieuxyz/Client.js

@@ -9,7 +9,10 @@ const logger_1 = require("./utils/logger");
  * The main Client class for interacting with Discord Rich Presence.
  * This is the starting point for creating and managing your RPC state.
  * @example
- * const client = new Client({ token: "YOUR_DISCORD_TOKEN" });
+ * const client = new Client({
+ *   token: "YOUR_DISCORD_TOKEN",
+ *   alwaysReconnect: true // Keep the RPC alive no matter what
+ * });
  * await client.run();
  * client.rpc.setName("Visual Studio Code");
  * await client.rpc.build();
@@ -34,7 +37,9 @@ class Client {
         }
         this.token = options.token;
         this.imageService = new ImageService_1.ImageService(options.apiBaseUrl);
-        this.websocket = new DiscordWebSocket_1.DiscordWebSocket(this.token);
+        this.websocket = new DiscordWebSocket_1.DiscordWebSocket(this.token, {
+            alwaysReconnect: options.alwaysReconnect ?? false,
+        });
         this.rpc = new HieuxyzRPC_1.HieuxyzRPC(this.websocket, this.imageService);
     }
     /**
@@ -51,8 +56,10 @@ 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.
      */
     close() {
+        this.rpc.stopBackgroundRenewal();
         this.websocket.close();
     }
 }

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

@@ -1,4 +1,7 @@
 import { PresenceUpdatePayload } from './entities/types';
+interface DiscordWebSocketOptions {
+    alwaysReconnect: boolean;
+}
 /**
  * Manage WebSocket connections to Discord Gateway.
  * Handles low-level operations like heartbeating, identifying, and resuming.
@@ -10,6 +13,7 @@ export declare class DiscordWebSocket {
     private heartbeatInterval;
     private sessionId;
     private resumeGatewayUrl;
+    private options;
     private resolveReady;
     /**
      * A promise will be resolved when the Gateway connection is ready.
@@ -19,15 +23,18 @@ export declare class DiscordWebSocket {
     /**
      * Create a DiscordWebSocket instance.
      * @param token - Discord user token for authentication.
+     * @param options - Configuration options for the WebSocket client.
      * @throws {Error} If the token is invalid.
      */
-    constructor(token: string);
+    constructor(token: string, options: DiscordWebSocketOptions);
+    private resetReadyPromise;
     private isTokenValid;
     /**
      * Initiate connection to Discord Gateway.
      * If there was a previous session, it will try to resume.
      */
     connect(): void;
+    private reconnect;
     private onMessage;
     private startHeartbeating;
     private identify;
@@ -45,3 +52,4 @@ export declare class DiscordWebSocket {
     private cleanupHeartbeat;
     private shouldReconnect;
 }
+export {};

package/dist/hieuxyz/gateway/DiscordWebSocket.js

@@ -19,22 +19,29 @@ class DiscordWebSocket {
     heartbeatInterval = null;
     sessionId = null;
     resumeGatewayUrl = null;
+    options;
     resolveReady = () => { };
     /**
      * A promise will be resolved when the Gateway connection is ready.
      * and received the READY event.
      */
-    readyPromise = new Promise(resolve => (this.resolveReady = resolve));
+    readyPromise;
     /**
      * Create a DiscordWebSocket instance.
      * @param token - Discord user token for authentication.
+     * @param options - Configuration options for the WebSocket client.
      * @throws {Error} If the token is invalid.
      */
-    constructor(token) {
+    constructor(token, options) {
         if (!this.isTokenValid(token)) {
             throw new Error("Invalid token provided.");
         }
         this.token = token;
+        this.options = options;
+        this.readyPromise = new Promise(resolve => (this.resolveReady = resolve));
+    }
+    resetReadyPromise() {
+        this.readyPromise = new Promise(resolve => (this.resolveReady = resolve));
     }
     isTokenValid(token) {
         return /^[a-zA-Z0-9_-]{24}\.[a-zA-Z0-9_-]{6}\.[a-zA-Z0-9_-]{38}$/.test(token) || /^mfa\.[a-zA-Z0-9_-]{84}$/.test(token);
@@ -44,7 +51,9 @@ class DiscordWebSocket {
      * If there was a previous session, it will try to resume.
      */
     connect() {
+        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('message', this.onMessage.bind(this));
@@ -52,18 +61,26 @@ class DiscordWebSocket {
             logger_1.logger.warn(`Connection closed: ${code} - ${reason.toString()}`);
             this.cleanupHeartbeat();
             if (this.shouldReconnect(code)) {
-                logger_1.logger.info("Trying to reconnect...");
-                setTimeout(() => this.connect(), 350);
+                logger_1.logger.info("Attempting to reconnect...");
+                this.reconnect(code === 4004);
             }
             else {
-                this.sessionId = null;
-                this.resumeGatewayUrl = null;
+                logger_1.logger.info("Not attempting to reconnect based on close code and client options.");
             }
         });
         this.ws.on('error', (err) => {
             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) {
@@ -95,10 +112,13 @@ class DiscordWebSocket {
                 logger_1.logger.info("Heartbeat acknowledged.");
                 break;
             case OpCode_1.OpCode.INVALID_SESSION:
-                logger_1.logger.warn("Invalid session. Re-identifying after 3 seconds.");
-                this.sessionId = null;
-                this.resumeGatewayUrl = null;
-                setTimeout(() => this.connect(), 3000);
+                logger_1.logger.warn(`Invalid session received. Resumable: ${payload.d}`);
+                if (payload.d === false) {
+                    this.ws?.close(4004, "Session not resumable");
+                }
+                else {
+                    this.ws?.close(4000, "Session is resumable, retrying");
+                }
                 break;
             case OpCode_1.OpCode.RECONNECT:
                 logger_1.logger.info("Gateway requested reconnect. Closing and reconnecting.");
@@ -110,10 +130,21 @@ class DiscordWebSocket {
     }
     startHeartbeating(interval) {
         this.cleanupHeartbeat();
-        this.heartbeatInterval = setInterval(() => {
-            this.sendJson({ op: OpCode_1.OpCode.HEARTBEAT, d: this.sequence });
-            logger_1.logger.info(`Heartbeat sent with sequence ${this.sequence}.`);
-        }, interval);
+        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.heartbeatInterval = setInterval(() => {
+                if (this.ws?.readyState !== ws_1.default.OPEN) {
+                    logger_1.logger.warn("Heartbeat skipped: WebSocket is not open.");
+                    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());
     }
     identify() {
         const identifyPayload = (0, identify_1.getIdentifyPayload)(this.token);
@@ -121,6 +152,11 @@ class DiscordWebSocket {
         logger_1.logger.info("Identify payload sent.");
     }
     resume() {
+        if (!this.sessionId || this.sequence === null) {
+            logger_1.logger.error("Attempted to resume without session ID or sequence. Falling back to identify.");
+            this.identify();
+            return;
+        }
         const resumePayload = {
             token: this.token,
             session_id: this.sessionId,
@@ -149,12 +185,7 @@ class DiscordWebSocket {
      * Close the WebSocket connection and clean up the resources.
      */
     close() {
-        if (this.ws) {
-            this.ws.close(1000, "Client closed connection");
-        }
-        this.cleanupHeartbeat();
-        this.sessionId = null;
-        this.resumeGatewayUrl = null;
+        this.ws?.close(1000, "Client closed connection");
     }
     cleanupHeartbeat() {
         if (this.heartbeatInterval) {
@@ -163,7 +194,15 @@ class DiscordWebSocket {
         }
     }
     shouldReconnect(code) {
-        return code !== 1000 && code !== 4004;
+        const fatalErrorCodes = [4010, 4011, 4013, 4014];
+        if (fatalErrorCodes.includes(code)) {
+            logger_1.logger.error(`Fatal WebSocket error received (code: ${code}). Will not reconnect.`);
+            return false;
+        }
+        if (this.options.alwaysReconnect) {
+            return true;
+        }
+        return code !== 1000;
     }
 }
 exports.DiscordWebSocket = DiscordWebSocket;

package/dist/hieuxyz/rpc/HieuxyzRPC.d.ts

@@ -18,7 +18,13 @@ export declare class HieuxyzRPC {
     private status;
     private applicationId;
     private platform;
+    /**
+     * Cache for resolved image assets to avoid re-uploading or re-fetching.
+     * Key: A unique string from RpcImage.getCacheKey().
+     * Value: The resolved asset key (e.g., "mp:attachments/...").
+     */
     private resolvedAssetsCache;
+    private renewalInterval;
     constructor(websocket: DiscordWebSocket, imageService: ImageService);
     private _toRpcImage;
     private sanitize;
@@ -99,6 +105,14 @@ export declare class HieuxyzRPC {
      * @returns {this}
      */
     setPlatform(platform: DiscordPlatform): this;
+    private getExpiryTime;
+    private renewAssetIfNeeded;
+    private startBackgroundRenewal;
+    /**
+     * Stops the background process that checks for asset renewal.
+     */
+    stopBackgroundRenewal(): void;
+    private resolveImage;
     private buildActivity;
     /**
      * Build the final Rich Presence payload and send it to Discord.

package/dist/hieuxyz/rpc/HieuxyzRPC.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HieuxyzRPC = void 0;
 const types_1 = require("../gateway/entities/types");
 const RpcImage_1 = require("./RpcImage");
+const logger_1 = require("../utils/logger");
 /**
  * Class built for creating and managing Discord Rich Presence states.
  */
@@ -14,10 +15,17 @@ class HieuxyzRPC {
     status = 'online';
     applicationId = '1416676323459469363'; // Default ID, can be changed
     platform = 'desktop';
-    resolvedAssetsCache = {};
+    /**
+     * Cache for resolved image assets to avoid re-uploading or re-fetching.
+     * Key: A unique string from RpcImage.getCacheKey().
+     * Value: The resolved asset key (e.g., "mp:attachments/...").
+     */
+    resolvedAssetsCache = new Map();
+    renewalInterval = null;
     constructor(websocket, imageService) {
         this.websocket = websocket;
         this.imageService = imageService;
+        this.startBackgroundRenewal();
     }
     _toRpcImage(source) {
         if (typeof source !== 'string') {
@@ -35,7 +43,7 @@ class HieuxyzRPC {
                 }
             }
             catch (e) {
-                console.warn(`Could not parse "${source}" into a valid URL. Treating as RawImage.`);
+                logger_1.logger.warn(`Could not parse "${source}" into a valid URL. Treating as RawImage.`);
                 return new RpcImage_1.RawImage(source);
             }
         }
@@ -126,7 +134,6 @@ class HieuxyzRPC {
         this.assets.large_image = this._toRpcImage(source);
         if (text)
             this.assets.large_text = this.sanitize(text);
-        delete this.resolvedAssetsCache.large_image;
         return this;
     }
     /**
@@ -139,7 +146,6 @@ class HieuxyzRPC {
         this.assets.small_image = this._toRpcImage(source);
         if (text)
             this.assets.small_text = this.sanitize(text);
-        delete this.resolvedAssetsCache.small_image;
         return this;
     }
     /**
@@ -184,29 +190,88 @@ class HieuxyzRPC {
         this.platform = platform;
         return this;
     }
-    async buildActivity() {
-        if (this.assets.large_image && !this.resolvedAssetsCache.large_image) {
-            this.resolvedAssetsCache.large_image = await this.assets.large_image.resolve(this.imageService);
+    getExpiryTime(assetKey) {
+        if (!assetKey.startsWith('mp:attachments'))
+            return null;
+        const urlPart = assetKey.substring(3);
+        try {
+            const parsedUrl = new URL(`https://cdn.discordapp.com/${urlPart}`);
+            const expiresTimestamp = parsedUrl.searchParams.get('ex');
+            if (expiresTimestamp) {
+                return parseInt(expiresTimestamp, 16) * 1000;
+            }
         }
-        if (this.assets.small_image && !this.resolvedAssetsCache.small_image) {
-            this.resolvedAssetsCache.small_image = await this.assets.small_image.resolve(this.imageService);
+        catch (e) {
+            logger_1.logger.error(`Could not parse asset URL for expiry check: ${assetKey}`);
         }
+        return null;
+    }
+    async renewAssetIfNeeded(cacheKey, assetKey) {
+        const expiryTimeMs = this.getExpiryTime(assetKey);
+        if (expiryTimeMs && expiryTimeMs < (Date.now() + 3600000)) {
+            logger_1.logger.info(`Asset ${cacheKey} is expiring soon. Renewing...`);
+            const assetId = assetKey.split('mp:attachments/')[1];
+            const newAsset = await this.imageService.renewImage(assetId);
+            if (newAsset) {
+                this.resolvedAssetsCache.set(cacheKey, newAsset);
+                return newAsset;
+            }
+            logger_1.logger.warn(`Failed to renew asset, will use the old one.`);
+        }
+        return assetKey;
+    }
+    startBackgroundRenewal() {
+        if (this.renewalInterval) {
+            clearInterval(this.renewalInterval);
+        }
+        this.renewalInterval = setInterval(async () => {
+            logger_1.logger.info("Running background asset renewal check...");
+            for (const [cacheKey, assetKey] of this.resolvedAssetsCache.entries()) {
+                await this.renewAssetIfNeeded(cacheKey, assetKey);
+            }
+        }, 600000);
+    }
+    /**
+     * Stops the background process that checks for asset renewal.
+     */
+    stopBackgroundRenewal() {
+        if (this.renewalInterval) {
+            clearInterval(this.renewalInterval);
+            this.renewalInterval = null;
+            logger_1.logger.info("Stopped background asset renewal process.");
+        }
+    }
+    async resolveImage(image) {
+        if (!image)
+            return undefined;
+        const cacheKey = image.getCacheKey();
+        let cachedAsset = this.resolvedAssetsCache.get(cacheKey);
+        if (cachedAsset) {
+            return await this.renewAssetIfNeeded(cacheKey, cachedAsset);
+        }
+        const resolvedAsset = await image.resolve(this.imageService);
+        if (resolvedAsset) {
+            this.resolvedAssetsCache.set(cacheKey, resolvedAsset);
+        }
+        return resolvedAsset;
+    }
+    async buildActivity() {
+        const large_image = await this.resolveImage(this.assets.large_image);
+        const small_image = await this.resolveImage(this.assets.small_image);
         const finalAssets = {
             large_text: this.assets.large_text,
             small_text: this.assets.small_text,
         };
-        if (this.resolvedAssetsCache.large_image) {
-            finalAssets.large_image = this.resolvedAssetsCache.large_image;
-        }
-        if (this.resolvedAssetsCache.small_image) {
-            finalAssets.small_image = this.resolvedAssetsCache.small_image;
-        }
+        if (large_image)
+            finalAssets.large_image = large_image;
+        if (small_image)
+            finalAssets.small_image = small_image;
         const finalActivity = { ...this.activity };
-        finalActivity.assets = finalAssets;
+        finalActivity.assets = (large_image || small_image) ? finalAssets : undefined;
         finalActivity.application_id = this.applicationId;
         finalActivity.platform = this.platform;
         if (!finalActivity.name) {
-            finalActivity.name = "Custom Status";
+            finalActivity.name = "hieuxyzRPC";
         }
         if (typeof finalActivity.type === 'undefined') {
             finalActivity.type = types_1.ActivityType.Playing;

package/dist/hieuxyz/rpc/ImageService.d.ts

@@ -22,4 +22,10 @@ export declare class ImageService {
      * @returns {Promise<string | undefined>} Asset key resolved or undefined if failed.
      */
     uploadImage(filePath: string, fileName: string): Promise<string | undefined>;
+    /**
+     * Requests a new signed URL for an expired or expiring attachment asset.
+     * @param assetId The asset ID part of the URL (e.g., "channel_id/message_id/filename.ext...")
+     * @returns {Promise<string | undefined>} The new asset key or undefined if it failed.
+     */
+    renewImage(assetId: string): Promise<string | undefined>;
 }

package/dist/hieuxyz/rpc/ImageService.js

@@ -102,5 +102,24 @@ class ImageService {
         }
         return undefined;
     }
+    /**
+     * Requests a new signed URL for an expired or expiring attachment asset.
+     * @param assetId The asset ID part of the URL (e.g., "channel_id/message_id/filename.ext...")
+     * @returns {Promise<string | undefined>} The new asset key or undefined if it failed.
+     */
+    async renewImage(assetId) {
+        try {
+            const response = await this.apiClient.post('/renew', { asset_id: assetId });
+            if (response.data && response.data.id) {
+                logger_1.logger.info(`Successfully renewed asset: ${assetId}`);
+                return response.data.id;
+            }
+        }
+        catch (error) {
+            const err = error;
+            logger_1.logger.error(`Failed to renew asset ${assetId}: ${err.response?.data || err.message}`);
+        }
+        return undefined;
+    }
 }
 exports.ImageService = ImageService;

package/dist/hieuxyz/rpc/RpcImage.d.ts

@@ -9,6 +9,11 @@ export declare abstract class RpcImage {
      * @returns {Promise<string | undefined>} Asset key has been resolved.
      */
     abstract resolve(imageService: ImageService): Promise<string | undefined>;
+    /**
+     * Gets a unique key for this image instance, used for caching.
+     * @returns {string} A unique identifier for the image source.
+     */
+    abstract getCacheKey(): string;
 }
 /**
  * Represents an image that already exists on Discord's servers (e.g., via proxy or previous upload).
@@ -17,6 +22,7 @@ export declare class DiscordImage extends RpcImage {
     private imageKey;
     constructor(imageKey: string);
     resolve(): Promise<string | undefined>;
+    getCacheKey(): string;
 }
 /**
  * Represents an image from an external URL.
@@ -25,6 +31,7 @@ export declare class ExternalImage extends RpcImage {
     private url;
     constructor(url: string);
     resolve(imageService: ImageService): Promise<string | undefined>;
+    getCacheKey(): string;
 }
 /**
  * Represents an image from the local file system.
@@ -35,6 +42,7 @@ export declare class LocalImage extends RpcImage {
     private fileName;
     constructor(filePath: string, fileName?: string);
     resolve(imageService: ImageService): Promise<string | undefined>;
+    getCacheKey(): string;
 }
 /**
  * Represents a resolved raw asset key.
@@ -44,4 +52,5 @@ export declare class RawImage extends RpcImage {
     private assetKey;
     constructor(assetKey: string);
     resolve(imageService: ImageService): Promise<string | undefined>;
+    getCacheKey(): string;
 }

package/dist/hieuxyz/rpc/RpcImage.js

@@ -53,6 +53,9 @@ class DiscordImage extends RpcImage {
     async resolve() {
         return this.imageKey.startsWith('mp:') ? this.imageKey : `mp:${this.imageKey}`;
     }
+    getCacheKey() {
+        return `discord:${this.imageKey}`;
+    }
 }
 exports.DiscordImage = DiscordImage;
 /**
@@ -67,6 +70,9 @@ class ExternalImage extends RpcImage {
     async resolve(imageService) {
         return imageService.getExternalUrl(this.url);
     }
+    getCacheKey() {
+        return `external:${this.url}`;
+    }
 }
 exports.ExternalImage = ExternalImage;
 /**
@@ -84,6 +90,9 @@ class LocalImage extends RpcImage {
     async resolve(imageService) {
         return imageService.uploadImage(this.filePath, this.fileName);
     }
+    getCacheKey() {
+        return `local:${this.filePath}`;
+    }
 }
 exports.LocalImage = LocalImage;
 /**
@@ -99,5 +108,8 @@ class RawImage extends RpcImage {
     async resolve(imageService) {
         return this.assetKey;
     }
+    getCacheKey() {
+        return `raw:${this.assetKey}`;
+    }
 }
 exports.RawImage = RawImage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hieuxyz/rpc",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "A Discord Rich Presence library for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,7 +21,7 @@
   "author": "hieuxyz",
   "license": "ISC",
   "dependencies": {
-    "axios": "^1.7.2",
+    "axios": "^1.12.2",
     "ws": "^8.18.3"
   },
   "devDependencies": {