@hieuxyz/rpc 1.0.6 → 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

@@ -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();
@@ -40,7 +48,8 @@ export declare class Client {
     run(): Promise<void>;
     /**
      * Close the connection to Discord Gateway.
-     * Terminate RPC and clean up resources.
+     * @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

@@ -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);
     }
     /**
@@ -50,10 +55,12 @@ class Client {
     }
     /**
      * Close the connection to Discord Gateway.
-     * Terminate RPC and clean up resources.
+     * @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() {
-        this.websocket.close();
+    close(force = false) {
+        this.rpc.stopBackgroundRenewal();
+        this.websocket.close(force);
     }
 }
 exports.Client = Client;

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.
@@ -8,8 +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.
@@ -19,9 +26,11 @@ 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.
@@ -30,6 +39,7 @@ export declare class DiscordWebSocket {
     connect(): void;
     private onMessage;
     private startHeartbeating;
+    private sendHeartbeat;
     private identify;
     private resume;
     /**
@@ -39,9 +49,11 @@ 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;
 }
+export {};

package/dist/hieuxyz/gateway/DiscordWebSocket.js

@@ -17,24 +17,34 @@ 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.
      * 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,20 +54,43 @@ 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("Trying to reconnect...");
-                setTimeout(() => this.connect(), 350);
+                setTimeout(() => {
+                    const canResume = code !== 4004 && !!this.sessionId;
+                    if (!canResume) {
+                        this.sessionId = null;
+                        this.sequence = null;
+                        this.resumeGatewayUrl = null;
+                    }
+                    this.connect();
+                }, 500);
             }
             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) => {
@@ -71,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 {
@@ -82,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') {
@@ -95,25 +130,43 @@ 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(`Received INVALID_SESSION. Resumable: ${payload.d}`);
+                if (payload.d) {
+                    this.ws?.close(4000, "Invalid session, attempting to resume.");
+                }
+                else {
+                    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();
-        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.sendHeartbeat();
+            }
+            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.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);
@@ -121,6 +174,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,
@@ -146,15 +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() {
+    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 closed connection");
+            this.ws.close(1000, "Client initiated closure");
         }
-        this.cleanupHeartbeat();
-        this.sessionId = null;
-        this.resumeGatewayUrl = null;
     }
     cleanupHeartbeat() {
         if (this.heartbeatInterval) {
@@ -163,7 +227,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;
@@ -223,7 +288,7 @@ class HieuxyzRPC {
             since: 0,
             activities: [activity],
             status: this.status,
-            afk: false,
+            afk: true,
         };
         this.websocket.sendActivity(presencePayload);
     }

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.8",
   "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": {