bedrock-portal 0.3.1 → 0.5.0

package/README.md

@@ -2,7 +2,7 @@
 [![NPM version](https://img.shields.io/npm/v/bedrock-portal.svg)](http://npmjs.com/package/bedrock-portal)
 [![Discord](https://img.shields.io/badge/chat-on%20discord-brightgreen.svg)](https://discord.gg/KTyd9HWuBD)
 
-Handles and creates a Minecraft Bedrock game session which will redirect players to the specified server
+Handles and creates a Minecraft Bedrock game session which will redirect players to the specified server. Join our [Discord](https://discord.com/invite/KTyd9HWuBD) for support.
 
 ## Installation
 ```shell
@@ -57,6 +57,43 @@ main();
 
 Modules are used to extend the functionality of the BedrockPortal class.
 
+### redirectFromRealm
+
+> Requires [bedrock-protocol](https://github.com/PrismarineJS/bedrock-protocol) to be installed. `npm install bedrock-protocol`
+
+Invites players when they join a Realm to the specified server or if they use the chat command. `#.use(Modules.redirectFromRealm, options);`
+
+Options:
+- **clientOptions**: ClientOptions - The client options to use when connecting to the Realm. These are passed directly to a [bedrock-protocol createClient](https://github.com/PrismarineJS/bedrock-protocol/blob/master/docs/API.md#becreateclientoptions--client) function. See the documentation for more information. 
+- **chatCommand**: object - Options for the chat command
+  - **enabled**: boolean - Whether sending the command in chat should trigger an invite (default: true)
+  - **message**: string - The message to send in chat to run the command (default: 'invite')
+  - **cooldown**: number - The cooldown between being able to send the command in chat (default: 60000ms)
+
+```js
+const { BedrockPortal, Modules } = require('bedrock-portal');
+
+const portal = new BedrockPortal(auth, { ... })
+
+portal.use(Modules.redirectFromRealm, {
+  // The client options to use when connecting to the Realm.
+  clientOptions: {
+    realms: {
+      realmInvite: ''
+    }
+  }
+  // Options for the chat command
+  chatCommand: {
+    // Whether sending the command in chat should trigger an invite (optional - defaults to true)
+    enabled: true,
+    // The message to send in chat to run the command (optional - defaults to 'invite')
+    message: 'invite',
+    // The cooldown between being able to send the command in chat (optional - defaults to 60000ms)
+    cooldown: 60000,
+  }
+}
+```
+
 ### autoFriendAdd
 
 Automatically adds the account's followers as friends and invites them to the game. `#.use(Modules.autoFriendAdd);`
@@ -78,11 +115,41 @@ portal.use(Modules.autoFriendAdd);
 // or
 
 portal.use(Modules.autoFriendAdd, {
+  // When a friend is added, automatically invite them to the game
   inviteOnAdd: true,
-  conditionToMeet: (player) => player.presenceState === 'Online', // Only add friends that are online and remove friends that are offline
-  // checkInterval: 30000,                      // How often to check for friends to add/remove (optional - defaults to 30000ms)
-  // addInterval: 2000,                         // How long to wait between adding friends (optional - defaults to 2000ms)
-  // removeInterval: 2000,                      // How long to wait between removing friends (optional - defaults to 2000ms)
+  // Only add friends that are online and remove friends that are offline
+  conditionToMeet: (player) => player.presenceState === 'Online',
+  // How often to check for friends to add/remove (optional - defaults to 30000ms)
+  checkInterval: 30000,
+  // How long to wait between adding friends (optional - defaults to 2000ms)
+  addInterval: 2000,
+  // How long to wait between removing friends (optional - defaults to 2000ms)
+  removeInterval: 2000,
+});
+```
+
+### inviteOnMessage
+
+Automatically invites players to the game when they send a message in the chat. `#.use(Modules.inviteOnMessage);`
+
+Options:
+- **command**: string - The command to use to invite players (default: 'invite')
+- **checkInterval**: number - How often to check for messages (default: 30000ms)
+
+```js
+const { BedrockPortal, Modules } = require('bedrock-portal');
+
+const portal = new BedrockPortal(auth, { ... })
+
+portal.use(Modules.inviteOnMessage);
+
+// or
+
+portal.use(Modules.inviteOnMessage, {
+  // The command to use to invite players (optional - defaults to 'invite')
+  command: 'invite',
+  // How often to check for messages (optional - defaults to 30000ms)
+  checkInterval: 30000,
 });
 ```
 
@@ -157,6 +224,9 @@ Emitted when a player is removed as a friend. This event is only emitted when th
 **Parameters**
 - player - [Player](#player) object
 
+### portal.on('messageRecieved', (message) => {})
+Emitted when a message is recieved from a player. This event is only emitted when the `inviteOnMessage` module is enabled.
+
 ## Objects
 
 ### Player

package/examples/portal.js

@@ -23,10 +23,15 @@ const main = async () => {
 
   portal.use(Modules.autoFriendAdd, {          // Automatically adds friends to the session
     inviteOnAdd: true,
-    conditionToMeet: (player) => player.presenceState === 'Online', // Only add friends that are online and remove friends that are offline
-    // checkInterval: 30000,                   // How often to check for friends to add/remove (optional - defaults to 30000ms)
-    addInterval: 2000,                         // How long to wait between adding friends (optional - defaults to 2000ms)
-    removeInterval: 2000,                      // How long to wait between removing friends (optional - defaults to 2000ms)
+    // conditionToMeet: (player) => player.presenceState === 'Online', // Only add friends that are online and remove friends that are offline
+    // checkInterval: 30000,                                           // How often to check for friends to add/remove (optional - defaults to 30000ms)
+    // addInterval: 2000,                                              // How long to wait between adding friends (optional - defaults to 2000ms)
+    // removeInterval: 2000,                                           // How long to wait between removing friends (optional - defaults to 2000ms)
+  });
+
+  portal.use(Modules.inviteOnMessage, {        // Automatically invites players when they send a message with the specified command
+    command: 'invite',                         // The command to use to invite players (optional - defaults to 'invite')
+    checkInterval: 30000,                      // How often to check for messages (optional - defaults to 30000ms)
   });
 
   // Put your event listeners before portal.start() to ensure you don't miss any events
@@ -59,6 +64,10 @@ const main = async () => {
     console.log('Friend Removed: ', player);
   });
 
+  portal.on('messageRecieved', (message) => {  // Emits when a message is received. Only emitted if inviteOnMessage module is used
+    console.log('Message Received: ', message);
+  });
+
   await portal.start();                        // Starts the session
 
   await portal.invitePlayer('p3');             // gamertag or xuid to invite

package/examples/realm.js

@@ -0,0 +1,58 @@
+/* eslint-disable no-multi-spaces */
+
+const { BedrockPortal, Modules, Joinability } = require('bedrock-portal');
+const { Authflow, Titles } = require('prismarine-auth');
+
+const main = async () => {
+  const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' });
+
+  const portal = new BedrockPortal(auth, {
+    ip: 'geyserconnect.net',
+    port: 19132,                               // The port of the server (optional - defaults to 19132)
+    joinability: Joinability.FriendsOfFriends, // The joinability of the session (optional - defaults to Joinability.FriendsOfFriends)
+    disableAltCheck: false,                    // Disables the alt check (optional - defaults to false)
+  });
+
+  portal.use(Modules.redirectFromRealm, {      // Automatically invite players to the server when they join a Realm
+    clientOptions: {                           // Options for the bedrock-protocol client, see https://github.com/PrismarineJS/bedrock-protocol for options
+      realms: {
+        realmId: '',                           // The realm ID of the realm to invite players from
+        realmInvite: '',                       // The invite code of the realm to invite players from
+        pickRealm: (realms) => realms[0],      // A function to pick a realm from the list of realms
+      },
+      onMsaCode: console.log,                  // A function to handle the MSA code
+    },
+    chatCommand: {                             // Options for the chat command
+      enabled: true,                           // Whether sending the command in chat should trigger an invite (optional - defaults to true)
+      cooldown: 60000,                         // The cooldown of the command in milliseconds (optional - defaults to 60000)
+      message: 'invite',                       // The message to send in chat to run the command (optional - defaults to 'invite')
+    },
+  });
+
+  // Put your event listeners before portal.start() to ensure you don't miss any events
+
+  portal.on('rtaEvent', (event) => {           // Emits when an RTA event is received
+    console.log('RTA Event: ', event);
+  });
+
+  portal.on('sessionCreated', (session) => {   // Emits when the session is created'
+    console.log('Session Created: ', session);
+  });
+
+  portal.on('sessionUpdated', (session) => {   // Emits when the session is updated
+    console.log('Session Updated: ', session);
+  });
+
+  portal.on('playerJoin', (player) => {        // Emits when a player joins the session
+    console.log('Player Join: ', player);
+  });
+
+  portal.on('playerLeave', (player) => {       // Emits when a player leaves the session
+    console.log('Player Leave: ', player);
+  });
+
+  await portal.start();                        // Starts the session
+
+};
+
+main();

package/index.d.ts

@@ -173,6 +173,8 @@ declare module 'bedrock-portal' {
      * })
      */
     autoFriendAdd: InstanceType<typeof ExtendedModule>
+    inviteOnMessage: InstanceType<typeof ExtendedModule>
+    redirectFromRealm: InstanceType<typeof ExtendedModule>
   }
 
   export interface RTAEvent {

package/index.js

@@ -3,6 +3,8 @@ module.exports = {
   Module : require('./src/classes/Module'),
   Modules: {
     autoFriendAdd: require('./src/modules/autoFriendAdd'),
+    inviteOnMessage: require('./src/modules/inviteOnMessage'),
+    redirectFromRealm: require('./src/modules/redirectFromRealm'),
   },
   Joinability: {
     InviteOnly: 'invite_only',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bedrock-portal",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Creates a joinable session in Minecraft Bedrock Edition that can route players to their a specified host",
   "main": "index.js",
   "scripts": {

package/src/modules/inviteOnMessage.js

@@ -0,0 +1,68 @@
+/* eslint-disable no-constant-condition */
+const Module = require('../classes/Module.js');
+
+class IniteOnMessage extends Module {
+  constructor() {
+    super('initeOnMessage', 'Automatically invite players to the server when they message you');
+    this.options = {
+      command: 'invite',
+      checkInterval: 30000,
+    };
+    this.cache = [];
+  }
+
+  async run(portal, { rest, rta }) {
+
+    const initeOnMessage = async () => {
+      const primaryMessages = await rest.get('https://xblmessaging.xboxlive.com/network/xbox/users/me/inbox/primary', { contractVersion: 1 });
+      const secondaryMessages = await rest.get('https://xblmessaging.xboxlive.com/network/xbox/users/me/inbox/secondary', { contractVersion: 1 });
+
+      const messages = [...primaryMessages.conversations, ...secondaryMessages.conversations];
+
+      const contentMessages = messages.filter(message => message.lastMessage.type === 'ContentMessage');
+
+      this.debug(`Found ${contentMessages.length} content message(s)`);
+
+      if (this.cache.length === 0) return this.cache = contentMessages;
+
+      // use #.lastMessage.messageId
+      const newMessages = contentMessages.filter(message => this.cache.some(cacheMessage => cacheMessage.lastMessage.messageId !== message.lastMessage.messageId && cacheMessage.conversationId === message.conversationId));
+
+      this.debug(`Found ${newMessages.length} new message(s)`);
+
+      if (newMessages.length === 0) return;
+
+      for (const message of newMessages) {
+        portal.emit('messageRecieved', message.lastMessage);
+
+        const senderXuid = message.lastMessage.sender;
+
+        if (senderXuid === '0') continue;
+
+        this.debug(`Received message from ${senderXuid}`);
+
+        const content = message.lastMessage.contentPayload.content.parts.find(part => part.contentType === 'text')?.text;
+
+        if (!content) continue;
+
+        if (content.toLowerCase() === this.options.command.toLowerCase()) {
+          await portal.invitePlayer(senderXuid);
+        }
+      }
+
+      this.cache = contentMessages;
+    };
+
+    while (!this.stopped) {
+      try {
+        await initeOnMessage();
+        await new Promise(resolve => setTimeout(resolve, this.options.checkInterval));
+      }
+      catch (error) {
+        this.debug(`Error: ${error.message}`, error);
+      }
+    }
+  }
+}
+
+module.exports = IniteOnMessage;

package/src/modules/redirectFromRealm.js

@@ -0,0 +1,81 @@
+const Module = require('../classes/Module.js');
+
+const cd = new Set();
+
+class RedirectFromRealm extends Module {
+  constructor() {
+    super('redirectFromRealm', 'Automatically invite players to the server when they join a Realm');
+    this.options = {
+      clientOptions: { }, // Options for the bedrock-protocol client
+      chatCommand: {
+        enabled: true,
+        cooldown: 60000,
+        message: 'invite',
+      },
+    };
+    try {
+      this.bedrock = require('bedrock-protocol');
+    }
+    catch (e) {
+      console.trace('bedrock-protocol is not installed, please run "npm i bedrock-protocol" to use this module');
+      process.exit(1);
+    }
+  }
+
+  async run(portal, { rest, rta }) {
+
+    const { clientOptions } = this.options;
+
+    const client = await this.initClient(clientOptions, portal).catch(error => ({ error }));
+
+    if (client.error) return console.error(`Error connecting to Realm - ${client.error.message}. BedrockPortal will continue to run, but will not be able to redirect players from this realm.`);
+
+  }
+
+  async initClient(options, portal) {
+    return new Promise((resolve, reject) => {
+
+      this.client = this.bedrock.createClient(options);
+
+      this.client.once('error', (e) => (this.client = null, reject(e)));
+      this.client.once('disconnect', (e) => (this.client = null, reject(e)));
+
+      this.client.once('spawn', () => {
+        this.heartbeat = setInterval(async () => {
+          this.debug(`Sending heartbeat to Realm - Status: ${this.client?.status}`);
+          if (this.client === null || this.client.status === 0) {
+            this.client = null;
+            clearInterval(this.heartbeat);
+            this.debug('Attempting to reconnect to Realm');
+            return await this.initClient(options, portal).catch(err => {
+              this.debug(`Error reconnecting to Realm - ${err.message}`);
+            });
+          }
+        }, 30000);
+        resolve(this.client);
+      });
+
+      this.client.on('player_list', async packet => {
+        if (packet.records.type === 'add') {
+          for (const record of packet.records.records) {
+            try { await await portal.invitePlayer(record.xbox_user_id); }
+            catch (e) { this.debug(`Failed to invite ${record.xbox_user_id} - ${e.message}`); }
+          }
+        }
+      });
+
+      this.client.on('text', async (packet) => {
+        if (!this.options.chatCommand.enabled || packet.type !== 'chat' || cd.has(packet.xuid)) return;
+        if (packet.message.toLowerCase() === this.options.chatCommand.message.toLowerCase()) {
+          cd.add(packet.xuid);
+          setTimeout(() => cd.delete(packet.xuid), this.options.chatCommand.cooldown);
+          try { await await portal.invitePlayer(packet.xuid); }
+          catch (e) { this.debug(`Failed to invite ${packet.xuid} - ${e.message}`); }
+        }
+      });
+
+    });
+  }
+}
+
+module.exports = RedirectFromRealm;

package/src/rest.js

@@ -81,7 +81,9 @@ module.exports = class Rest {
     const response = await this.get(`https://profile.xboxlive.com/users/${target}/profile/settings`, { params: { settings }, contractVersion: 2 });
 
     const [avatar, gamerscore, gamertag, tier, reputation, colour, realname, bio, location, modernGamertag, modernGamertagSuffix, uniqueModernGamertag, realnameOverride, tenureLevel, watermarks, isQuarantined, linkedAccounts] = response.profileUsers[0].settings.map(e=> e.value);
-    const colourData = await axios.get(colour).then(e => e.data);
+    const colourData = await axios.get(colour, { timeout: 5000 })
+      .then(e => e.data)
+      .catch(() => ({ primaryColor: '000000', secondaryColor: '000000', tertiaryColor: '000000' }));
 
     return {
       xuid: response.profileUsers[0].id,