@hieuxyz/rpc 1.0.6

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025, hieuxyz
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+# @hieuxyz/rpc
+
+[![NPM Version](https://img.shields.io/npm/v/@hieuxyz/rpc.svg)](https://www.npmjs.com/package/@hieuxyz/rpc)
+[![License](https://img.shields.io/npm/l/@hieuxyz/rpc.svg)](https://github.com/hieuxyz/rpc/blob/main/LICENSE)
+[![Downloads](https://img.shields.io/npm/dt/@hieuxyz/rpc.svg)](https://www.npmjs.com/package/@hieuxyz/rpc)
+
+An easy-to-use Discord Rich Presence (RPC) library built for the Node.js environment using TypeScript. This library is designed to simplify the creation and management of custom RPC states for Discord user accounts.
+
+> [!WARNING]
+> **I don't take any responsibility for blocked Discord accounts that used this module.**
+
+> [!CAUTION]
+> **Using this on a user account is prohibited by the [Discord TOS](https://discord.com/terms) and can lead to the account block.**
+> **When using these libraries, you accept the risk of exposing your Discord Token.**
+
+## Outstanding features
+
+-   **Flexible Builder Pattern:** Easily build your RPC state with intuitive chainable methods.
+-   **Easy to use:** The `Client` class abstracts away all the complex connection and setup logic, letting you get started with just a few lines of code.
+-   **Auto Resume:** Built-in auto reconnect and session recovery mechanism in case of network failure, ensuring your RPC is always stable.
+
+## Install
+
+Use `npm` or `yarn` to install libraries:
+
+```bash
+npm i @hieuxyz/rpc
+```
+
+## How to use
+
+Here is a complete example to get you started.
+
+**1. Create a `.env` file**
+
+In the root directory of your project, create a file called `.env` and paste your Discord token into it.
+
+```
+DISCORD_USER_TOKEN="YOUR_DISCORD_USER_TOKEN_HERE"
+```
+
+**2. Write your source code (e.g. `index.ts`)**
+
+```typescript
+import * as path from 'path';
+import { Client, RawImage, LocalImage, logger } from '@hieuxyz/rpc';
+
+async function start() {
+    const token = process.env.DISCORD_USER_TOKEN;
+
+    if (!token) {
+        logger.error("Token not found in .env file. Please set DISCORD_USER_TOKEN.");
+        return;
+    }
+
+    // Initialize client with token
+    const client = new Client({ token });
+
+    await client.run();
+
+    client.rpc
+        .setName("Visual Studio Code")
+        .setDetails("Developing a new library")
+        .setState("Workspace: @hieuxyz/rpc")
+        .setPlatform('desktop') // 'desktop', 'xbox', 'ps5', etc.
+        .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" }
+        ]);
+
+    await client.rpc.build();
+
+    setTimeout(async () => {
+        logger.info("Updating RPC details dynamically...");
+
+        // Change the necessary information
+        client.rpc
+            .setDetails("Reviewing pull requests")
+            .setState("PR #01: Feature enhancement")
+            .setParty(2, 5);
+
+        await client.rpc.updateRPC();
+        
+        logger.info("RPC has been dynamically updated!");
+
+    }, 15000);
+
+    process.on('SIGINT', () => {
+        logger.info("SIGINT received. Closing connection...");
+        client.close();
+        process.exit(0);
+    });
+}
+
+start().catch(err => {
+    logger.error(`An unexpected error occurred: ${err}`);
+});
+```
+
+## Get Token ?
+
+- Based: [findByProps](https://discord.com/channels/603970300668805120/1085682686607249478/1085682686607249478)
+
+<strong>Run code (Discord Console - [Ctrl + Shift + I])</strong>
+
+```js
+window.webpackChunkdiscord_app.push([
+	[Symbol()],
+	{},
+	req => {
+		if (!req.c) return;
+		for (let m of Object.values(req.c)) {
+			try {
+				if (!m.exports || m.exports === window) continue;
+				if (m.exports?.getToken) return copy(m.exports.getToken());
+				for (let ex in m.exports) {
+					if (m.exports?.[ex]?.getToken && m.exports[ex][Symbol.toStringTag] !== 'IntlMessagesProxy') return copy(m.exports[ex].getToken());
+				}
+			} catch {}
+		}
+	},
+]);
+
+window.webpackChunkdiscord_app.pop();
+console.log('%cWorked!', 'font-size: 50px');
+console.log(`%cYou now have your token in the clipboard!`, 'font-size: 16px');
+```
+
+## API Reference
+
+### The `Client` Class
+
+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.
+-   `client.run()`: Start connecting to Discord Gateway.
+-   `client.rpc`: Access the instance of `HieuxyzRPC` to build the state.
+
+### Class `HieuxyzRPC`
+
+Main builder class for RPC.
+
+-   `.setName(string)`: Activity name (first line).
+-   `.setDetails(string)`: Activity details (second line).
+-   `.setState(string)`: Activity status (third line).
+-   `.setTimestamps(start?, end?)`: Set start/end time.
+-   `.setParty(current, max)`: Set group information.
+-   `.setLargeImage(RpcImage, text?)`: Set large image and caption.
+-   `.setSmallImage(RpcImage, text?)`: Set thumbnail and caption.
+-   `.setButtons(buttons[])`: Set buttons (up to 2).
+-   `.setPlatform(platform)`: Lay the platform (`'desktop'`, `'xbox'`, `'ps5'`).
+-   `.build()`: First RPC send.
+-   `.updateRPC()`: Send updates to an existing RPC.(it just call build() lol)
+
+### Types of images
+
+-   `new ExternalImage(url)`: Use image from an external URL (will be proxy).
+-   `new LocalImage(filePath, fileName?)`: Upload a photo from your device.
+-   `new RawImage(assetKey)`: Use an existing asset key directly.
+-   `new DiscordImage(key)`: Use assets already on Discord.
+
+## Author
+
+Developed by **hieuxyz**.
+
+-   GitHub: [@hieuxyz00](https://github.com/hieuxyz00)
+
+## Copyright
+
+This project is licensed under the ISC License. See the `LICENSE` file for more details.

package/dist/hieuxyz/Client.d.ts

@@ -0,0 +1,46 @@
+import { HieuxyzRPC } from './rpc/HieuxyzRPC';
+/**
+ * Option to initialize Client.
+ */
+export interface ClientOptions {
+    /** Your Discord user token. */
+    token: string;
+    /** (Optional) Base URL of the image proxy service. */
+    apiBaseUrl?: string;
+}
+/**
+ * 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" });
+ * await client.run();
+ * client.rpc.setName("Visual Studio Code");
+ * await client.rpc.build();
+ */
+export declare class Client {
+    /**
+     * Provides access to RPC constructor methods.
+     * Use this property to set your Rich Presence state details.
+     */
+    readonly rpc: HieuxyzRPC;
+    private readonly websocket;
+    private readonly imageService;
+    private readonly token;
+    /**
+     * Create a new Client instance.
+     * @param options - Options to configure the client.
+     * @throws {Error} If no token is provided in the options.
+     */
+    constructor(options: ClientOptions);
+    /**
+     * Connect to Discord Gateway and prepare the client for RPC updates.
+     * This method must be called before sending any Rich Presence updates.
+     * @returns {Promise<void>} A promise will be resolved when the client is ready.
+     */
+    run(): Promise<void>;
+    /**
+     * Close the connection to Discord Gateway.
+     * Terminate RPC and clean up resources.
+     */
+    close(): void;
+}

package/dist/hieuxyz/Client.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const DiscordWebSocket_1 = require("./gateway/DiscordWebSocket");
+const HieuxyzRPC_1 = require("./rpc/HieuxyzRPC");
+const ImageService_1 = require("./rpc/ImageService");
+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" });
+ * await client.run();
+ * client.rpc.setName("Visual Studio Code");
+ * await client.rpc.build();
+ */
+class Client {
+    /**
+     * Provides access to RPC constructor methods.
+     * Use this property to set your Rich Presence state details.
+     */
+    rpc;
+    websocket;
+    imageService;
+    token;
+    /**
+     * Create a new Client instance.
+     * @param options - Options to configure the client.
+     * @throws {Error} If no token is provided in the options.
+     */
+    constructor(options) {
+        if (!options.token) {
+            throw new Error("Tokens are required to connect to Discord.");
+        }
+        this.token = options.token;
+        this.imageService = new ImageService_1.ImageService(options.apiBaseUrl);
+        this.websocket = new DiscordWebSocket_1.DiscordWebSocket(this.token);
+        this.rpc = new HieuxyzRPC_1.HieuxyzRPC(this.websocket, this.imageService);
+    }
+    /**
+     * Connect to Discord Gateway and prepare the client for RPC updates.
+     * This method must be called before sending any Rich Presence updates.
+     * @returns {Promise<void>} A promise will be resolved when the client is ready.
+     */
+    async run() {
+        this.websocket.connect();
+        logger_1.logger.info("Waiting for Discord session to be ready...");
+        await this.websocket.readyPromise;
+        logger_1.logger.info("Client is ready to send Rich Presence updates.");
+    }
+    /**
+     * Close the connection to Discord Gateway.
+     * Terminate RPC and clean up resources.
+     */
+    close() {
+        this.websocket.close();
+    }
+}
+exports.Client = Client;

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

@@ -0,0 +1,47 @@
+import { PresenceUpdatePayload } from './entities/types';
+/**
+ * Manage WebSocket connections to Discord Gateway.
+ * Handles low-level operations like heartbeating, identifying, and resuming.
+ */
+export declare class DiscordWebSocket {
+    private token;
+    private ws;
+    private sequence;
+    private heartbeatInterval;
+    private sessionId;
+    private resumeGatewayUrl;
+    private resolveReady;
+    /**
+     * A promise will be resolved when the Gateway connection is ready.
+     * and received the READY event.
+     */
+    readyPromise: Promise<void>;
+    /**
+     * Create a DiscordWebSocket instance.
+     * @param token - Discord user token for authentication.
+     * @throws {Error} If the token is invalid.
+     */
+    constructor(token: string);
+    private isTokenValid;
+    /**
+     * Initiate connection to Discord Gateway.
+     * If there was a previous session, it will try to resume.
+     */
+    connect(): void;
+    private onMessage;
+    private startHeartbeating;
+    private identify;
+    private resume;
+    /**
+     * Send presence update payload to Gateway.
+     * @param presence - Payload update status to send.
+     */
+    sendActivity(presence: PresenceUpdatePayload): void;
+    private sendJson;
+    /**
+     * Close the WebSocket connection and clean up the resources.
+     */
+    close(): void;
+    private cleanupHeartbeat;
+    private shouldReconnect;
+}

package/dist/hieuxyz/gateway/DiscordWebSocket.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordWebSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+const logger_1 = require("../utils/logger");
+const identify_1 = require("./entities/identify");
+const OpCode_1 = require("./entities/OpCode");
+/**
+ * Manage WebSocket connections to Discord Gateway.
+ * Handles low-level operations like heartbeating, identifying, and resuming.
+ */
+class DiscordWebSocket {
+    token;
+    ws = null;
+    sequence = null;
+    heartbeatInterval = null;
+    sessionId = null;
+    resumeGatewayUrl = null;
+    resolveReady = () => { };
+    /**
+     * A promise will be resolved when the Gateway connection is ready.
+     * and received the READY event.
+     */
+    readyPromise = new Promise(resolve => (this.resolveReady = resolve));
+    /**
+     * Create a DiscordWebSocket instance.
+     * @param token - Discord user token for authentication.
+     * @throws {Error} If the token is invalid.
+     */
+    constructor(token) {
+        if (!this.isTokenValid(token)) {
+            throw new Error("Invalid token provided.");
+        }
+        this.token = token;
+    }
+    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);
+    }
+    /**
+     * Initiate connection to Discord Gateway.
+     * If there was a previous session, it will try to resume.
+     */
+    connect() {
+        const url = this.resumeGatewayUrl || "wss://gateway.discord.gg/?v=10&encoding=json";
+        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));
+        this.ws.on('close', (code, reason) => {
+            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);
+            }
+            else {
+                this.sessionId = null;
+                this.resumeGatewayUrl = null;
+            }
+        });
+        this.ws.on('error', (err) => {
+            logger_1.logger.error(`WebSocket Error: ${err.message}`);
+        });
+    }
+    onMessage(data) {
+        const payload = JSON.parse(data.toString());
+        if (payload.s) {
+            this.sequence = payload.s;
+        }
+        switch (payload.op) {
+            case OpCode_1.OpCode.HELLO:
+                this.startHeartbeating(payload.d.heartbeat_interval);
+                if (this.sessionId) {
+                    this.resume();
+                }
+                else {
+                    this.identify();
+                }
+                break;
+            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.resolveReady();
+                }
+                else if (payload.t === 'RESUMED') {
+                    logger_1.logger.info("The session has been successfully resumed.");
+                    this.resolveReady();
+                }
+                break;
+            case OpCode_1.OpCode.HEARTBEAT_ACK:
+                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);
+                break;
+            case OpCode_1.OpCode.RECONNECT:
+                logger_1.logger.info("Gateway requested reconnect. Closing and reconnecting.");
+                this.ws?.close(4000, "Reconnect request");
+                break;
+            default:
+                break;
+        }
+    }
+    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);
+    }
+    identify() {
+        const identifyPayload = (0, identify_1.getIdentifyPayload)(this.token);
+        this.sendJson({ op: OpCode_1.OpCode.IDENTIFY, d: identifyPayload });
+        logger_1.logger.info("Identify payload sent.");
+    }
+    resume() {
+        const resumePayload = {
+            token: this.token,
+            session_id: this.sessionId,
+            seq: this.sequence
+        };
+        this.sendJson({ op: OpCode_1.OpCode.RESUME, d: resumePayload });
+        logger_1.logger.info("Resume payload sent.");
+    }
+    /**
+     * Send presence update payload to Gateway.
+     * @param presence - Payload update status to send.
+     */
+    sendActivity(presence) {
+        this.sendJson({ op: OpCode_1.OpCode.PRESENCE_UPDATE, d: presence });
+        logger_1.logger.info("Presence update sent.");
+    }
+    sendJson(data) {
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+        else {
+            logger_1.logger.warn("Attempted to send data while WebSocket was not open.");
+        }
+    }
+    /**
+     * 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;
+    }
+    cleanupHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    shouldReconnect(code) {
+        return code !== 1000 && code !== 4004;
+    }
+}
+exports.DiscordWebSocket = DiscordWebSocket;

package/dist/hieuxyz/gateway/entities/OpCode.d.ts

@@ -0,0 +1,13 @@
+export declare enum OpCode {
+    DISPATCH = 0,
+    HEARTBEAT = 1,
+    IDENTIFY = 2,
+    PRESENCE_UPDATE = 3,
+    VOICE_STATE_UPDATE = 4,
+    RESUME = 6,
+    RECONNECT = 7,
+    REQUEST_GUILD_MEMBERS = 8,
+    INVALID_SESSION = 9,
+    HELLO = 10,
+    HEARTBEAT_ACK = 11
+}

package/dist/hieuxyz/gateway/entities/OpCode.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpCode = void 0;
+var OpCode;
+(function (OpCode) {
+    OpCode[OpCode["DISPATCH"] = 0] = "DISPATCH";
+    OpCode[OpCode["HEARTBEAT"] = 1] = "HEARTBEAT";
+    OpCode[OpCode["IDENTIFY"] = 2] = "IDENTIFY";
+    OpCode[OpCode["PRESENCE_UPDATE"] = 3] = "PRESENCE_UPDATE";
+    OpCode[OpCode["VOICE_STATE_UPDATE"] = 4] = "VOICE_STATE_UPDATE";
+    OpCode[OpCode["RESUME"] = 6] = "RESUME";
+    OpCode[OpCode["RECONNECT"] = 7] = "RECONNECT";
+    OpCode[OpCode["REQUEST_GUILD_MEMBERS"] = 8] = "REQUEST_GUILD_MEMBERS";
+    OpCode[OpCode["INVALID_SESSION"] = 9] = "INVALID_SESSION";
+    OpCode[OpCode["HELLO"] = 10] = "HELLO";
+    OpCode[OpCode["HEARTBEAT_ACK"] = 11] = "HEARTBEAT_ACK";
+})(OpCode || (exports.OpCode = OpCode = {}));

package/dist/hieuxyz/gateway/entities/identify.d.ts

@@ -0,0 +1,2 @@
+import { IdentifyPayload } from "./types";
+export declare function getIdentifyPayload(token: string): IdentifyPayload;

package/dist/hieuxyz/gateway/entities/identify.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdentifyPayload = getIdentifyPayload;
+function getIdentifyPayload(token) {
+    return {
+        token: token,
+        capabilities: 65,
+        properties: {
+            os: "Windows",
+            browser: "Discord Client",
+            device: "hieuxyz©rpc",
+        },
+        compress: false,
+    };
+}

package/dist/hieuxyz/gateway/entities/types.d.ts

@@ -0,0 +1,59 @@
+import { OpCode } from "./OpCode";
+export declare enum ActivityType {
+    Playing = 0,
+    Streaming = 1,
+    Listening = 2,
+    Watching = 3,
+    Custom = 4,
+    Competing = 5
+}
+export type ActivityTypeName = 'playing' | 'streaming' | 'listening' | 'watching' | 'custom' | 'competing';
+export type SettableActivityType = ActivityType | ActivityTypeName | number;
+export interface GatewayPayload {
+    op: OpCode;
+    d: any;
+    s?: number | null;
+    t?: string | null;
+}
+export interface IdentifyPayload {
+    token: string;
+    capabilities: number;
+    properties: {
+        os: string;
+        browser: string;
+        device: string;
+    };
+    compress: boolean;
+}
+export interface Activity {
+    name: string;
+    type: number;
+    application_id?: string;
+    details?: string;
+    state?: string;
+    platform?: string;
+    party?: {
+        id?: string;
+        size?: [number, number];
+    };
+    timestamps?: {
+        start?: number;
+        end?: number;
+    };
+    assets?: {
+        large_image?: string;
+        large_text?: string;
+        small_image?: string;
+        small_text?: string;
+    };
+    buttons?: string[];
+    metadata?: {
+        button_urls?: string[];
+    };
+}
+export interface PresenceUpdatePayload {
+    since: number;
+    activities: Activity[];
+    status: 'online' | 'dnd' | 'idle' | 'invisible' | 'offline';
+    afk: boolean;
+}

package/dist/hieuxyz/gateway/entities/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityType = void 0;
+var ActivityType;
+(function (ActivityType) {
+    ActivityType[ActivityType["Playing"] = 0] = "Playing";
+    ActivityType[ActivityType["Streaming"] = 1] = "Streaming";
+    ActivityType[ActivityType["Listening"] = 2] = "Listening";
+    ActivityType[ActivityType["Watching"] = 3] = "Watching";
+    ActivityType[ActivityType["Custom"] = 4] = "Custom";
+    ActivityType[ActivityType["Competing"] = 5] = "Competing";
+})(ActivityType || (exports.ActivityType = ActivityType = {}));