@nyabsi/minimal-discord-rpc 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { Client, ActivityType } from "./structures/client";

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityType = exports.Client = void 0;
+var client_1 = require("./structures/client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+Object.defineProperty(exports, "ActivityType", { enumerable: true, get: function () { return client_1.ActivityType; } });

package/dist/structures/client.d.ts

@@ -0,0 +1,103 @@
+import { EventEmitter } from "./eventEmitter";
+interface ClientOptions {
+    clientId: string;
+}
+export declare enum ActivityType {
+    /**
+     * Playing {game}
+     */
+    Playing = 0,
+    /**
+     * Listening to {name}
+     */
+    Listening = 2,
+    /**
+     * Watching {details}
+     */
+    Watching = 3,
+    /**
+     * Competing in {name}
+     */
+    Competing = 5
+}
+interface ActivityTimestamps {
+    /**
+     * Unix time (in milliseconds) of when the activity started
+     * Must be between 0 and 2147483647000
+     */
+    start?: number | Date;
+    /**
+     * Unix time (in milliseconds) of when the activity ends
+     * Must be between 0 and 2147483647000
+     */
+    end?: number | Date;
+}
+interface ActivityAssets {
+    /**
+     * Main icon, can be an asset name or a URL (1-128 characters)
+     * If not specified, the client icon will be used
+     */
+    large_image?: string;
+    /**
+     * Hover text for the main icon (2-128 characters)
+     */
+    large_text?: string;
+    /**
+     * Small icon, can be an asset name or a URL (1-128 characters)
+     */
+    small_image?: string;
+    /**
+     * Hover text for the small icon (2-128 characters)
+     */
+    small_text?: string;
+}
+interface ActivityButton {
+    /**
+     * The text shown on the button (1-32 characters)
+     */
+    label: string;
+    /**
+     * The url opened when clicking the button (1-512 characters)
+     */
+    url: string;
+}
+interface Activity {
+    /**
+     * The player's current party status (2-128 characters)
+     */
+    state?: string;
+    /**
+     * What the player is currently doing (2-128 characters)
+     */
+    details?: string;
+    /**
+     * Create elapsed/remaining timestamps on a player's profile
+     */
+    timestamps?: ActivityTimestamps;
+    /**
+     * Internal - Undocumented
+     */
+    flags?: number;
+    /**
+     * Assets to display on the player's profile
+     */
+    assets?: ActivityAssets;
+    /**
+     * List of interactive buttons
+     */
+    buttons?: ActivityButton[];
+    /**
+     * Default: ActivityType.Playing
+     */
+    type?: ActivityType.Playing | ActivityType.Listening | ActivityType.Watching | ActivityType.Competing;
+}
+export declare class Client extends EventEmitter {
+    #private;
+    clientId: string;
+    constructor(options: ClientOptions);
+    login(): Promise<void>;
+    setActivity(activity: Activity, pid?: number): Promise<void>;
+    clearActivity(pid?: number): Promise<void>;
+    destroy(): Promise<void>;
+}
+export {};

package/dist/structures/client.js

@@ -0,0 +1,135 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Client_instances, _Client_transport, _Client_request;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.ActivityType = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const eventEmitter_1 = require("./eventEmitter");
+const ipcTransport_1 = require("./ipcTransport");
+var ActivityType;
+(function (ActivityType) {
+    /**
+     * Playing {game}
+     */
+    ActivityType[ActivityType["Playing"] = 0] = "Playing";
+    /**
+     * Listening to {name}
+     */
+    ActivityType[ActivityType["Listening"] = 2] = "Listening";
+    /**
+     * Watching {details}
+     */
+    ActivityType[ActivityType["Watching"] = 3] = "Watching";
+    /**
+     * Competing in {name}
+     */
+    ActivityType[ActivityType["Competing"] = 5] = "Competing";
+})(ActivityType || (exports.ActivityType = ActivityType = {}));
+class Client extends eventEmitter_1.EventEmitter {
+    constructor(options) {
+        super();
+        _Client_instances.add(this);
+        Object.defineProperty(this, "clientId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _Client_transport.set(this, void 0);
+        this.clientId = options.clientId;
+        __classPrivateFieldSet(this, _Client_transport, new ipcTransport_1.IpcTransport(this), "f");
+        __classPrivateFieldGet(this, _Client_transport, "f").on("message", (message) => {
+            if (message.cmd === "DISPATCH" && message.evt === "READY") {
+                this.emit("ready");
+            }
+            else {
+                this.emit(message.evt, message.data);
+            }
+        });
+    }
+    // LOGIN
+    async login() {
+        await __classPrivateFieldGet(this, _Client_transport, "f").connect();
+    }
+    async setActivity(activity, pid) {
+        const cleaned = {};
+        if (activity.state)
+            cleaned.state = activity.state;
+        if (activity.details)
+            cleaned.details = activity.details;
+        if (activity.timestamps && Object.entries(activity.timestamps).length > 0) {
+            cleaned.timestamps = {};
+            if (activity.timestamps?.start)
+                cleaned.timestamps.start = activity.timestamps.start;
+            if (activity.timestamps?.end)
+                cleaned.timestamps.end = activity.timestamps.end;
+        }
+        if (activity.flags)
+            cleaned.flags = activity.flags;
+        if (activity.assets && Object.entries(activity.assets).length > 0) {
+            cleaned.assets = {};
+            if (activity.assets?.large_image)
+                cleaned.assets.large_image = activity.assets.large_image;
+            if (activity.assets?.large_text)
+                cleaned.assets.large_text = activity.assets.large_text;
+            if (activity.assets?.small_image)
+                cleaned.assets.small_image = activity.assets.small_image;
+            if (activity.assets?.small_text)
+                cleaned.assets.small_text = activity.assets.small_text;
+        }
+        if (activity.buttons && activity.buttons.length > 0) {
+            cleaned.buttons = [];
+            for (const button of activity.buttons) {
+                cleaned.buttons.push({
+                    label: button.label,
+                    url: button.url,
+                });
+            }
+        }
+        if (activity.type) {
+            cleaned.type = activity.type;
+            if ([
+                ActivityType.Playing,
+                ActivityType.Listening,
+                ActivityType.Watching,
+                ActivityType.Competing,
+            ].includes(cleaned.type))
+                cleaned.type = ActivityType.Playing;
+        }
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_request).call(this, "SET_ACTIVITY", {
+            pid: (pid ?? process) ? (process.pid ?? 0) : 0,
+            activity,
+        });
+    }
+    async clearActivity(pid) {
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_request).call(this, "CLEAR_ACTIVITY", {
+            pid: (pid ?? process) ? (process.pid ?? 0) : 0,
+        });
+    }
+    async destroy() {
+        await __classPrivateFieldGet(this, _Client_transport, "f").close();
+    }
+}
+exports.Client = Client;
+_Client_transport = new WeakMap(), _Client_instances = new WeakSet(), _Client_request = 
+// RICH PRESENCE
+async function _Client_request(cmd, args) {
+    __classPrivateFieldGet(this, _Client_transport, "f").send(ipcTransport_1.IPC_OPERATION.FRAME, {
+        cmd,
+        args,
+        nonce: node_crypto_1.default.randomUUID(),
+    });
+};

package/dist/structures/eventEmitter.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class EventEmitter {
+    #private;
+    on(event: string, callback: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}

package/dist/structures/eventEmitter.js

@@ -0,0 +1,28 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EventEmitter_listeners;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+class EventEmitter {
+    constructor() {
+        _EventEmitter_listeners.set(this, new Map());
+    }
+    on(event, callback) {
+        const eventListeners = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(event);
+        if (!eventListeners)
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(event, [callback]);
+        else
+            eventListeners?.push(callback);
+    }
+    emit(event, ...args) {
+        for (const listener of __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(event) ?? []) {
+            listener(...args);
+        }
+    }
+}
+exports.EventEmitter = EventEmitter;
+_EventEmitter_listeners = new WeakMap();

package/dist/structures/ipcTransport.d.ts

@@ -0,0 +1,21 @@
+import type { Client } from "./client";
+import net from "node:net";
+import { EventEmitter } from "./eventEmitter";
+export declare enum IPC_OPERATION {
+    HANDSHAKE = 0,
+    FRAME = 1,
+    CLOSE = 2,
+    PING = 3,
+    PONG = 4
+}
+export declare class IpcTransport extends EventEmitter {
+    client: Client;
+    socket?: net.Socket;
+    constructor(client: Client);
+    get isConnected(): boolean;
+    getSocket(): Promise<net.Socket>;
+    connect(): Promise<void>;
+    send(operation?: IPC_OPERATION, payload?: any): void;
+    ping(): void;
+    close(): Promise<void>;
+}

package/dist/structures/ipcTransport.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpcTransport = exports.IPC_OPERATION = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_net_1 = __importDefault(require("node:net"));
+const eventEmitter_1 = require("./eventEmitter");
+var IPC_OPERATION;
+(function (IPC_OPERATION) {
+    IPC_OPERATION[IPC_OPERATION["HANDSHAKE"] = 0] = "HANDSHAKE";
+    IPC_OPERATION[IPC_OPERATION["FRAME"] = 1] = "FRAME";
+    IPC_OPERATION[IPC_OPERATION["CLOSE"] = 2] = "CLOSE";
+    IPC_OPERATION[IPC_OPERATION["PING"] = 3] = "PING";
+    IPC_OPERATION[IPC_OPERATION["PONG"] = 4] = "PONG";
+})(IPC_OPERATION || (exports.IPC_OPERATION = IPC_OPERATION = {}));
+const pathList = [
+    {
+        platform: ["win32"],
+        format: (id) => `\\\\?\\pipe\\discord-ipc-${id}`,
+    },
+    // MacOS and Linux
+    {
+        platform: ["darwin", "linux"],
+        format: (id) => {
+            const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP }, } = process;
+            const prefix = node_fs_1.default.realpathSync(XDG_RUNTIME_DIR ?? TMPDIR ?? TMP ?? TEMP ?? `${node_path_1.default.sep}tmp`);
+            return node_path_1.default.join(prefix, `discord-ipc-${id}`);
+        },
+    },
+    // Linux (Snap)
+    {
+        platform: ["linux"],
+        format: (id) => {
+            const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP }, } = process;
+            const prefix = node_fs_1.default.realpathSync(XDG_RUNTIME_DIR ?? TMPDIR ?? TMP ?? TEMP ?? `${node_path_1.default.sep}tmp`);
+            return node_path_1.default.join(prefix, "snap.discord", `discord-ipc-${id}`);
+        },
+    },
+    // Linux (Flatpak)
+    {
+        platform: ["linux"],
+        format: (id) => {
+            const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP }, } = process;
+            const prefix = node_fs_1.default.realpathSync(XDG_RUNTIME_DIR ?? TMPDIR ?? TMP ?? TEMP ?? `${node_path_1.default.sep}tmp`);
+            return node_path_1.default.join(prefix, "app", "com.discordapp.Discord", `discord-ipc-${id}`);
+        },
+    },
+];
+const createSocket = async (path) => {
+    return new Promise((resolve, reject) => {
+        const onError = () => {
+            socket.removeListener("conect", onConnect);
+            reject();
+        };
+        const onConnect = () => {
+            socket.removeListener("error", onError);
+            resolve(socket);
+        };
+        const socket = node_net_1.default.createConnection(path);
+        socket.once("connect", onConnect);
+        socket.once("error", onError);
+    });
+};
+class IpcTransport extends eventEmitter_1.EventEmitter {
+    constructor(client) {
+        super();
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "socket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = client;
+    }
+    get isConnected() {
+        return this.socket !== undefined && this.socket.readyState === "open";
+    }
+    async getSocket() {
+        if (this.socket)
+            return this.socket;
+        for (const pat of pathList) {
+            const handleSocketId = async (id) => {
+                if (!pat.platform.includes(process.platform))
+                    return;
+                const socketPath = pat.format(id);
+                if (process.platform !== "win32" &&
+                    !node_fs_1.default.existsSync(node_path_1.default.dirname(socketPath)))
+                    return;
+                const socket = await createSocket(socketPath).catch(() => undefined);
+                return socket;
+            };
+            for (let i = 0; i < 10; i++) {
+                const socket = await handleSocketId(i);
+                if (socket)
+                    return socket;
+            }
+        }
+        throw new Error("Could not connect");
+    }
+    async connect() {
+        if (!this.socket)
+            this.socket = await this.getSocket();
+        this.emit("open");
+        this.send(IPC_OPERATION.HANDSHAKE, {
+            v: 1,
+            client_id: this.client.clientId,
+        });
+        this.socket.on("readable", () => {
+            let data = Buffer.alloc(0);
+            while (true) {
+                if (!this.isConnected)
+                    break;
+                const chunk = this.socket?.read();
+                if (!chunk)
+                    break;
+                this.client.emit("debug", `SERVER => CLIENT | ${chunk
+                    .toString("hex")
+                    .match(/.{1,2}/g)
+                    ?.join(" ")
+                    .toUpperCase()}`);
+                data = Buffer.concat([data, chunk]);
+            }
+            if (data.length < 8) {
+                if (data.length === 0)
+                    return;
+                this.client.emit("debug", "SERVER => CLIENT | Malformed packet, invalid payload");
+                return;
+            }
+            const op = data.readUInt32LE(0);
+            const length = data.readUInt32LE(4);
+            if (data.length !== length + 8) {
+                this.client.emit("debug", "SERVER => CLIENT | Malformed packet, invalid payload");
+                return;
+            }
+            let parsedData;
+            try {
+                parsedData = JSON.parse(data.subarray(8, length + 8).toString());
+            }
+            catch {
+                this.client.emit("debug", "SERVER => CLIENT | Malformed packet, invalid payload");
+                return;
+            }
+            this.client.emit("debug", `SERVER => CLIENT | OPCODE.${IPC_OPERATION[op]} |`, parsedData);
+            switch (op) {
+                case IPC_OPERATION.FRAME: {
+                    if (!data)
+                        break;
+                    this.emit("message", parsedData);
+                    break;
+                }
+                case IPC_OPERATION.CLOSE: {
+                    this.emit("close", parsedData);
+                    break;
+                }
+                case IPC_OPERATION.PING: {
+                    this.send(IPC_OPERATION.PONG, parsedData);
+                    this.emit("ping");
+                    break;
+                }
+            }
+        });
+        this.on("close", (reason) => {
+            this.socket = undefined;
+            this.client.emit("close", reason);
+        });
+    }
+    send(operation = IPC_OPERATION.FRAME, payload) {
+        this.client.emit("debug", `CLIENT => SERVER | OPCODE.${IPC_OPERATION[operation]} |`, payload);
+        const dataBuffer = payload
+            ? Buffer.from(JSON.stringify(payload))
+            : Buffer.alloc(0);
+        const packet = Buffer.alloc(8);
+        packet.writeUInt32LE(operation, 0);
+        packet.writeUInt32LE(dataBuffer.length, 4);
+        this.socket?.write(Buffer.concat([packet, dataBuffer]));
+    }
+    ping() {
+        this.send(IPC_OPERATION.PING, crypto.randomUUID());
+    }
+    close() {
+        if (!this.socket)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            if (!this.socket)
+                return resolve();
+            this.socket.once("close", () => {
+                this.emit("close", { code: -1, message: "Closed by client" });
+                this.socket = undefined;
+                resolve();
+            });
+            this.socket.end();
+        });
+    }
+}
+exports.IpcTransport = IpcTransport;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nyabsi/minimal-discord-rpc",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "A minimal Discord RPC client",
 	"author": "ItsPi3141 (Original Author) & Nyabsi",
 	"license": "GPL-3.0",