@discordjs/rpc 0.2.0-dev.1786968995-99af6d8be → 0.2.0-dev.1788538586-ecea9ed57

package/dist/index.js

@@ -0,0 +1,688 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { AsyncEventEmitter as AsyncEventEmitter2 } from "@vladfrangu/async_event_emitter";
+import { RPCEvents, RPCCommands, Routes, RouteBases } from "discord-api-types/v10";
+
+// src/RPCEventError.ts
+var RPCEventError = class extends Error {
+  static {
+    __name(this, "RPCEventError");
+  }
+  code;
+  data;
+  constructor(data) {
+    if (typeof data === "string") {
+      super(data);
+    } else {
+      super(data.message);
+      this.code = data.code;
+      this.data = data;
+    }
+    this.name = "RPCEventError";
+  }
+};
+
+// src/constants.ts
+var Events = /* @__PURE__ */ ((Events2) => {
+  Events2["ApplicationReady"] = "APPLICATION_READY";
+  Events2["Disconnected"] = "DISCONNECTED";
+  return Events2;
+})(Events || {});
+
+// src/ipc.ts
+import { Buffer as Buffer2 } from "buffer";
+import { randomUUID } from "crypto";
+import fs from "fs/promises";
+import { createConnection, Socket } from "net";
+import path from "path";
+import process2 from "process";
+import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
+async function canOpenFile(path2) {
+  try {
+    await fs.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(canOpenFile, "canOpenFile");
+async function getIPCPath(id) {
+  if (process2.platform === "win32") {
+    return String.raw`\\?\pipe\discord-ipc-${id}`;
+  }
+  const prefix = process2.env.XDG_RUNTIME_DIR ?? process2.env.TMPDIR ?? "/tmp";
+  const bases = [prefix, path.join(prefix, "app", "com.discordapp.Discord"), path.join(prefix, "snap.discord")];
+  for (const base of bases) {
+    const candidate = path.join(base, `discord-ipc-${id}`);
+    if (await canOpenFile(candidate)) return candidate;
+  }
+  return path.join(prefix, `discord-ipc-${id}`);
+}
+__name(getIPCPath, "getIPCPath");
+async function getIPC(id) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const path2 = await getIPCPath(id);
+  const onError = /* @__PURE__ */ __name(async () => reject(new Error("Could not connect")), "onError");
+  const socket = createConnection(path2, () => {
+    socket.removeListener("error", onError);
+    resolve(socket);
+  });
+  socket.once("error", onError);
+  return promise;
+}
+__name(getIPC, "getIPC");
+function encode(op, data) {
+  const stringifiedData = JSON.stringify(data);
+  const length = Buffer2.byteLength(stringifiedData);
+  const packet = Buffer2.allocUnsafe(8 + length);
+  packet.writeInt32LE(op, 0);
+  packet.writeInt32LE(length, 4);
+  packet.write(stringifiedData, 8, length);
+  return packet;
+}
+__name(encode, "encode");
+var IPCTransport = class extends AsyncEventEmitter {
+  constructor(client) {
+    super();
+    this.client = client;
+    this.socket = new Socket();
+    this.working = {
+      op: 0,
+      len: 0,
+      buffer: Buffer2.from([])
+    };
+  }
+  client;
+  static {
+    __name(this, "IPCTransport");
+  }
+  socket;
+  working;
+  async connect() {
+    for (let id = 0; id < 10; id++) {
+      try {
+        this.socket = await getIPC(id);
+        break;
+      } catch (error) {
+        if (id === 9) throw error;
+      }
+    }
+    this.socket.on("close", this.onClose.bind(this));
+    this.socket.on("error", this.onError.bind(this));
+    this.emit("open");
+    this.socket.write(
+      encode(0 /* Handshake */, {
+        v: 1,
+        client_id: this.client.clientId
+      })
+    );
+    this.socket.pause();
+    this.socket.on("readable", this.decode.bind(this));
+  }
+  async decode() {
+    let packet;
+    const chunks = [];
+    while ((packet = this.socket.read()) !== null) {
+      chunks.push(packet);
+    }
+    if (chunks.length === 0) return;
+    const packets = Buffer2.concat([this.working.buffer, ...chunks]);
+    if (this.working.buffer.byteLength === 0) {
+      this.working.op = packets.readInt32LE(0);
+      this.working.len = packets.readInt32LE(4);
+    }
+    this.working.buffer = packets;
+    const { op, len } = this.working;
+    let data;
+    try {
+      data = JSON.parse(packets.subarray(8, len + 8).toString());
+    } catch {
+      return;
+    }
+    this.working.buffer = Buffer2.from([]);
+    switch (op) {
+      case 3 /* Ping */:
+        this.send(data, 4 /* Pong */);
+        break;
+      case 1 /* Frame */:
+        if (!data) {
+          return;
+        }
+        this.emit("message", data);
+        break;
+      case 2 /* Close */:
+        this.emit("close", data);
+        break;
+      default:
+        break;
+    }
+  }
+  onClose(data) {
+    this.socket.removeAllListeners();
+    this.socket = new Socket();
+    this.working.buffer = Buffer2.from([]);
+    const error = typeof data === "boolean" ? new Error("socket closed") : data;
+    this.emit("close", error);
+  }
+  onError(error) {
+    this.emit("error", error);
+  }
+  send(data, op = 1 /* Frame */) {
+    this.socket.write(encode(op, data));
+  }
+  async close(options) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const signal = options?.signal ?? AbortSignal.timeout(1e4);
+    const onAbort = /* @__PURE__ */ __name((_) => reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason))), "onAbort");
+    this.once("close", (error) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(error);
+    });
+    signal.addEventListener("abort", onAbort);
+    this.send({}, 2 /* Close */);
+    this.socket.end();
+    return promise;
+  }
+  /**
+   * Manual ping method
+   */
+  ping() {
+    this.send(randomUUID(), 3 /* Ping */);
+  }
+};
+
+// src/util.ts
+import { createRequire } from "module";
+var register = /* @__PURE__ */ __name(async () => {
+  const require2 = createRequire(import.meta.url);
+  try {
+    const { app } = require2("electron");
+    return app.setAsDefaultProtocolClient.bind(app);
+  } catch {
+    try {
+      return require2("register-scheme");
+    } catch {
+      return false;
+    }
+  }
+}, "register");
+function getPid() {
+  if (typeof globalThis.process !== "undefined") {
+    return process.pid;
+  }
+  return null;
+}
+__name(getPid, "getPid");
+function isValidTimestamp(timestamp) {
+  return Number.isInteger(timestamp) && timestamp >= 0 && timestamp <= 2147483647e3;
+}
+__name(isValidTimestamp, "isValidTimestamp");
+
+// src/client.ts
+var RPCClient = class extends AsyncEventEmitter2 {
+  static {
+    __name(this, "RPCClient");
+  }
+  options;
+  accessToken;
+  clientId;
+  clientSecret;
+  readyTimestamp;
+  application;
+  user;
+  /**
+   * The transport for the IPC
+   */
+  transport;
+  /**
+   * Map of nonces being expected from the transport
+   */
+  #expectedNonces;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.accessToken = "";
+    this.clientId = "";
+    this.clientSecret = "";
+    this.readyTimestamp = null;
+    this.application = null;
+    this.user = null;
+    this.transport = new IPCTransport(this);
+    this.transport.on("message", this.#onRpcMessage.bind(this));
+    this.#expectedNonces = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Returns the Date for when the client became ready
+   */
+  get readyAt() {
+    if (this.readyTimestamp === null) return null;
+    return new Date(this.readyTimestamp);
+  }
+  /**
+   * Returns true if the client is currently ready
+   */
+  get ready() {
+    return this.readyTimestamp !== null;
+  }
+  /**
+   * Search and connect to RPC
+   */
+  async connect(options) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    if (this.ready) {
+      resolve(this);
+      return promise;
+    }
+    const signal = options?.signal ?? AbortSignal.timeout(1e4);
+    const onAbort = /* @__PURE__ */ __name((_) => {
+      this.removeListener(RPCEvents.Ready, onReady);
+      this.transport.removeListener("close", onClose);
+      const reason = signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
+      reject(reason);
+    }, "onAbort");
+    const onReady = /* @__PURE__ */ __name(() => {
+      signal.removeEventListener("abort", onAbort);
+      this.readyTimestamp = Date.now();
+      resolve(this);
+    }, "onReady");
+    const onClose = /* @__PURE__ */ __name((data) => {
+      signal.removeEventListener("abort", onAbort);
+      this.removeListener(RPCEvents.Ready, onReady);
+      for (const expNonce of this.#expectedNonces.values()) {
+        expNonce.reject(new RPCEventError("connection closed"));
+      }
+      this.#expectedNonces.clear();
+      this.readyTimestamp = null;
+      this.emit("DISCONNECTED" /* Disconnected */);
+      reject(new RPCEventError(JSON.stringify(data)));
+    }, "onClose");
+    signal.addEventListener("abort", onAbort);
+    this.once(RPCEvents.Ready, onReady);
+    this.transport.once("close", onClose);
+    try {
+      await this.transport.connect();
+    } catch (error) {
+      this.readyTimestamp = null;
+      signal.removeEventListener("abort", onAbort);
+      this.removeListener(RPCEvents.Ready, onReady);
+      this.transport.removeListener("close", onClose);
+      reject(error);
+    }
+    return promise;
+  }
+  /**
+   * Performs authentication flow. Automatically calls Client#connect if needed.
+   *
+   * @example
+   * logging in with a client id and secret
+   * ```ts
+   * client.login({ clientId: '1234567', clientSecret: 'abcdef123' });
+   * ```
+   */
+  async login({ clientId, clientSecret, accessToken }, options) {
+    if (!clientId) {
+      throw new Error("A client id must be provided to login");
+    }
+    this.clientId = clientId;
+    await this.connect(options);
+    if (!this.options.scopes) {
+      this.emit("APPLICATION_READY" /* ApplicationReady */);
+      return this;
+    }
+    if (accessToken) {
+      return this.authenticate(accessToken, options);
+    }
+    if (!clientSecret) {
+      throw new Error("A client secret must be provided for authorization if scopes are included");
+    }
+    this.clientSecret = clientSecret;
+    const authorizeArgs = { client_id: this.clientId, scopes: this.options.scopes };
+    if (this.options.username) authorizeArgs.username = this.options.username;
+    return this.authenticate(await this.authorize(authorizeArgs, options), options);
+  }
+  async request(cmd, args = {}, options) {
+    const signal = options?.signal ?? AbortSignal.timeout(1e4);
+    signal.throwIfAborted();
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const nonce = randomUUID2();
+    const payload = {
+      cmd,
+      args,
+      nonce
+    };
+    if (cmd === RPCCommands.Subscribe || cmd === RPCCommands.Unsubscribe) {
+      payload.evt = options?.evt;
+    }
+    this.transport.send(payload);
+    this.#expectedNonces.set(nonce, { resolve, reject });
+    const onAbort = /* @__PURE__ */ __name((_) => {
+      this.#expectedNonces.delete(nonce);
+      const reason = signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
+      reject(reason);
+    }, "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await promise;
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+  /**
+   * Message handler
+   *
+   * @param message - message
+   */
+  #onRpcMessage(message) {
+    if (message.cmd === RPCCommands.Dispatch && message.evt === RPCEvents.Ready) {
+      if (message.data.user) {
+        this.user = message.data.user;
+      }
+      this.emit(RPCEvents.Ready, message.data);
+    } else if (message.cmd === RPCCommands.Dispatch) {
+      this.emit(message.evt, message.data);
+    } else {
+      if (!this.#expectedNonces.has(message.nonce)) {
+        return;
+      }
+      const { resolve, reject } = this.#expectedNonces.get(message.nonce);
+      if ("evt" in message && message.evt === RPCEvents.Error) {
+        reject(new RPCEventError(message.data));
+      } else {
+        resolve(message.data);
+      }
+      this.#expectedNonces.delete(message.nonce);
+    }
+  }
+  /**
+   * Authorize
+   *
+   * @param args - authorize args
+   */
+  async authorize(args, options) {
+    const { code } = await this.request(RPCCommands.Authorize, args, options);
+    const jsonBody = {
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      code,
+      grant_type: "authorization_code"
+    };
+    if (this.options.redirectUri) {
+      jsonBody.redirect_uri = this.options.redirectUri;
+    }
+    const response = await fetch(`${RouteBases.api}${Routes.oauth2TokenExchange()}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams(jsonBody),
+      ...options
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const data = await response.json();
+    if (!("access_token" in data)) {
+      throw new Error(JSON.stringify(response));
+    }
+    return data.access_token;
+  }
+  /**
+   * Authenticate
+   *
+   * @param accessToken - access token
+   */
+  async authenticate(accessToken, options) {
+    const { application, user } = await this.request(RPCCommands.Authenticate, { access_token: accessToken }, options);
+    this.accessToken = accessToken;
+    this.application = application;
+    this.user = user;
+    this.emit("APPLICATION_READY" /* ApplicationReady */);
+    return this;
+  }
+  /**
+   * Fetch a guild
+   *
+   * @param id - Guild id
+   * @param timeout - Timeout request
+   */
+  async getGuild(id, timeout, options) {
+    return this.request(RPCCommands.GetGuild, { guild_id: id, timeout }, options);
+  }
+  /**
+   * Fetch all guilds
+   *
+   * @param timeout - Timeout request
+   */
+  async getGuilds(timeout, options) {
+    return this.request(RPCCommands.GetGuilds, { timeout }, options);
+  }
+  /**
+   * Get a channel
+   *
+   * @param id - Channel id
+   */
+  async getChannel(id, options) {
+    return this.request(RPCCommands.GetChannel, { channel_id: id }, options);
+  }
+  /**
+   * Get all channels
+   *
+   * @param id - Guild id
+   */
+  async getChannels(id, options) {
+    const { channels } = await this.request(RPCCommands.GetChannels, { guild_id: id }, options);
+    return channels;
+  }
+  /**
+   * Create channel invite
+   *
+   * @param id - Channel id
+   */
+  async createChannelInvite(id, options) {
+    return this.request(RPCCommands.CreateChannelInvite, { channel_id: id }, options);
+  }
+  /**
+   * Tell discord which devices are certified
+   *
+   * @param devices - Certified devices to send to discord
+   */
+  async setCertifiedDevices(devices, options) {
+    return this.request(
+      RPCCommands.SetCertifiedDevices,
+      {
+        devices
+      },
+      options
+    );
+  }
+  /**
+   * Set the voice settings for a user, by id
+   *
+   * @param id - Id of the user to set
+   * @param settings - Settings to set
+   */
+  async setUserVoiceSettings(id, settings, options) {
+    return this.request(
+      RPCCommands.SetUserVoiceSettings,
+      {
+        user_id: id,
+        ...settings
+      },
+      options
+    );
+  }
+  /**
+   * Move the user to a voice channel
+   *
+   * @param id - Id of the voice channel
+   * @param args - select voice channel args
+   * @param options - request options
+   */
+  async selectVoiceChannel(id, args = {}, options) {
+    const svcArgs = { ...args, channel_id: id };
+    return this.request(RPCCommands.SelectVoiceChannel, svcArgs, options);
+  }
+  /**
+   * Move the user to a text channel
+   *
+   * @param id - Id of the text channel
+   * @param args - select text channel args
+   * @param options - request options
+   */
+  async selectTextChannel(id, args = {}, options) {
+    const stcArgs = { ...args, channel_id: id };
+    return this.request(RPCCommands.SelectTextChannel, stcArgs, options);
+  }
+  /**
+   * Get current voice settings
+   *
+   */
+  async getVoiceSettings(options) {
+    return this.request(RPCCommands.GetVoiceSettings, {}, options);
+  }
+  /**
+   * Set current voice settings, overriding the current settings until this session disconnects.
+   * This also locks the settings for any other rpc sessions which may be connected.
+   *
+   * @param args - Settings
+   */
+  async setVoiceSettings(args, options) {
+    return this.request(RPCCommands.SetVoiceSettings, args, options);
+  }
+  /**
+   * Sets the presence for the logged in user.
+   *
+   * @param activity - The rich presence to pass.
+   * @param pid - The application's process ID. Defaults to the executing process' PID.
+   * @remarks
+   * Clients may only update their activity 5 times per 20 seconds.
+   */
+  async setActivity(activity = {}, pid = getPid(), options) {
+    activity.instance = Boolean(activity.instance);
+    if (activity.timestamps) {
+      if ("start" in activity.timestamps && !isValidTimestamp(activity.timestamps.start)) {
+        throw new RangeError("timestamps.start must fit into a unix timestamp");
+      }
+      if ("end" in activity.timestamps && !isValidTimestamp(activity.timestamps.end)) {
+        throw new RangeError("timestamps.end must fit into a unix timestamp");
+      }
+    }
+    return this.request(
+      RPCCommands.SetActivity,
+      {
+        pid: pid ?? 0,
+        activity
+      },
+      options
+    );
+  }
+  /**
+   * Clears the currently set presence, if any. This will hide the "Playing X" message
+   * displayed below the user's name.
+   *
+   * @param pid - The application's process ID. Defaults to the executing process' PID.
+   */
+  async clearActivity(pid = getPid(), options) {
+    return this.request(
+      RPCCommands.SetActivity,
+      {
+        pid: pid ?? 0
+      },
+      options
+    );
+  }
+  /**
+   * Invite a user to join the game the RPC user is currently playing
+   *
+   * @param userId - The id of the user to invite
+   */
+  async sendJoinInvite(userId, options) {
+    return this.request(
+      RPCCommands.SendActivityJoinInvite,
+      {
+        user_id: userId
+      },
+      options
+    );
+  }
+  /**
+   * Reject a join request from a user
+   *
+   * @param userId - The id of the user whose request you wish to reject
+   */
+  async closeJoinRequest(userId, options) {
+    return this.request(
+      RPCCommands.CloseActivityJoinRequest,
+      {
+        user_id: userId
+      },
+      options
+    );
+  }
+  /**
+   * requires `relationships.read` scope
+   */
+  async getRelationships(options) {
+    return this.request(RPCCommands.GetRelationships, {}, options);
+  }
+  /**
+   * Fetches a user
+   */
+  async getUser(id, options) {
+    return this.request(RPCCommands.GetUser, { id }, options);
+  }
+  /**
+   * Fetches a user's profile picture
+   */
+  async getImage({ id, format, size }, options) {
+    return (await this.request(RPCCommands.GetImage, { type: "user", id, format, size }, options)).data_url;
+  }
+  /**
+   * Subscribe to an event
+   *
+   * @param event - Name of event e.g. `MESSAGE_CREATE`
+   * @param args - Args for event e.g. `{ channel_id: '1234' }`
+   */
+  async subscribe(...[event, args, options]) {
+    await this.request(RPCCommands.Subscribe, args, { evt: event, ...options });
+    return {
+      unsubscribe: /* @__PURE__ */ __name(async () => this.request(RPCCommands.Unsubscribe, args, { evt: event, ...options }), "unsubscribe")
+    };
+  }
+  /**
+   * Unsubscribe from an event
+   *
+   * @param event - Name of event e.g. `MESSAGE_CREATE`
+   * @param args - Args for event e.g. `{ channel_id: '1234' }`
+   */
+  async unsubscribe(...[event, args, options]) {
+    await this.request(RPCCommands.Unsubscribe, args, { evt: event, ...options });
+    return {
+      subscribe: /* @__PURE__ */ __name(async () => this.request(RPCCommands.Subscribe, args, { evt: event, ...options }), "subscribe")
+    };
+  }
+  /**
+   * Destroy the client
+   */
+  async destroy() {
+    await this.transport.close();
+  }
+};
+
+// src/index.ts
+var version = "0.2.0-dev.1788538586-ecea9ed57";
+export {
+  Events,
+  IPCTransport,
+  RPCClient,
+  RPCEventError,
+  encode,
+  getPid,
+  isValidTimestamp,
+  register,
+  version
+};
+//# sourceMappingURL=index.js.map