bedrock-portal 0.8.14 → 0.9.0

package/dist/classes/Module.d.ts

@@ -1,12 +1,13 @@
 import debugFn from 'debug';
 import { BedrockPortal } from '..';
 export default class Module {
+    portal: BedrockPortal;
     name: string;
     description: string;
     stopped: boolean;
     options: any;
     debug: debugFn.Debugger;
-    constructor(name: string, description: string);
+    constructor(portal: BedrockPortal, name: string, description: string);
     applyOptions(options: any): void;
     stop(): Promise<void>;
     run(_portal: BedrockPortal): Promise<void>;

package/dist/classes/Module.js

@@ -5,12 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const debug_1 = __importDefault(require("debug"));
 class Module {
+    portal;
     name;
     description;
     stopped;
     options;
     debug;
-    constructor(name, description) {
+    constructor(portal, name, description) {
+        this.portal = portal;
         this.name = name;
         this.description = description;
         this.stopped = false;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { RESTSessionResponse, SessionRequest } from './types/sessiondirectory';
-import type { Message } from './types/xblmessaging';
+import type { Message } from 'xbox-message';
 import { EventResponse } from 'xbox-rta';
 import { Authflow } from 'prismarine-auth';
 import { TypedEmitter } from 'tiny-typed-emitter';

package/dist/index.js

@@ -154,7 +154,7 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
      * })
      */
     use(mod, options) {
-        const constructed = new mod();
+        const constructed = new mod(this);
         debug(`Enabled module: ${constructed.name}`);
         if (!(constructed instanceof Module_1.default))
             throw new Error('Module must extend the base module');

package/dist/modules/autoFriendAccept.d.ts

@@ -16,7 +16,7 @@ export default class AutoFriendAccept extends Module {
         */
         conditionToMeet: (request: FriendRequestPerson) => boolean;
     };
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/modules/autoFriendAccept.js

@@ -8,14 +8,14 @@ const Player_1 = __importDefault(require("../classes/Player"));
 const multipleAccounts_1 = __importDefault(require("./multipleAccounts"));
 class AutoFriendAccept extends Module_1.default {
     options;
-    constructor() {
-        super('autoFriendAccept', 'Automatically accept friend requests');
+    constructor(portal) {
+        super(portal, 'autoFriendAccept', 'Automatically accept friend requests');
         this.options = {
             inviteOnAdd: false,
             conditionToMeet: () => true,
         };
     }
-    async run(portal) {
+    async run() {
         const addXboxFriend = async (host) => {
             host.rta?.on('event', async (event) => {
                 if (event.data.NotificationType !== 'IncomingFriendRequestCountChanged')
@@ -29,23 +29,23 @@ class AutoFriendAccept extends Module_1.default {
                 const accept = await host.rest.acceptFriendRequests(requests.map(req => req.xuid));
                 this.debug(`Accepted ${accept.updatedPeople.length} friend request(s)`);
                 for (const person of requests.filter(req => accept.updatedPeople.includes(req.xuid))) {
-                    portal.emit('friendAdded', new Player_1.default(person, null));
+                    this.portal.emit('friendAdded', new Player_1.default(person, null));
                     this.debug(`Accepted ${person.gamertag}`);
                     if (this.options.inviteOnAdd) {
-                        await portal.invitePlayer(person.xuid).catch(error => this.debug(`Error: Failed to invite ${person.gamertag}`, error));
+                        await this.portal.invitePlayer(person.xuid).catch(error => this.debug(`Error: Failed to invite ${person.gamertag}`, error));
                     }
                 }
             });
             await host.rta?.subscribe(`https://social.xboxlive.com/users/xuid(${host.profile?.xuid})/friends`);
         };
-        const multipleAccounts = portal.modules.get('multipleAccounts');
+        const multipleAccounts = this.portal.modules.get('multipleAccounts');
         if (multipleAccounts && multipleAccounts instanceof multipleAccounts_1.default) {
             for (const account of multipleAccounts.peers.values()) {
                 addXboxFriend(account)
                     .catch(error => this.debug(`Error: ${error.message}`, error));
             }
         }
-        addXboxFriend(portal.host)
+        addXboxFriend(this.portal.host)
             .catch(error => this.debug(`Error: ${error.message}`, error));
     }
     async stop() {

package/dist/modules/autoFriendAdd.d.ts

@@ -32,7 +32,7 @@ export default class AutoFriendAdd extends Module {
         */
         removeInterval: number;
     };
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/modules/autoFriendAdd.js

@@ -10,8 +10,8 @@ const multipleAccounts_1 = __importDefault(require("./multipleAccounts"));
 class AutoFriendAdd extends Module_1.default {
     interval = null;
     options;
-    constructor() {
-        super('autoFriendAdd', 'Automatically adds followers as friends');
+    constructor(portal) {
+        super(portal, 'autoFriendAdd', 'Automatically adds followers as friends');
         this.options = {
             inviteOnAdd: false,
             conditionToMeet: () => true,
@@ -20,7 +20,7 @@ class AutoFriendAdd extends Module_1.default {
             removeInterval: 2000,
         };
     }
-    async run(portal) {
+    async run() {
         const addXboxFriend = async (host) => {
             this.debug('Checking for followers to add');
             const followers = await host.rest.getXboxFollowers()
@@ -33,11 +33,11 @@ class AutoFriendAdd extends Module_1.default {
                     throw Error(`Failed to add ${account.gamertag}`);
                 });
                 if (this.options.inviteOnAdd) {
-                    await portal.invitePlayer(account.xuid).catch(() => {
+                    await this.portal.invitePlayer(account.xuid).catch(() => {
                         throw Error(`Failed to invite ${account.gamertag}`);
                     });
                 }
-                portal.emit('friendAdded', new Player_1.default(account, null));
+                this.portal.emit('friendAdded', new Player_1.default(account, null));
                 this.debug(`Added & invited ${account.gamertag}`);
                 await (0, promises_1.setTimeout)(this.options.addInterval);
             }
@@ -51,20 +51,20 @@ class AutoFriendAdd extends Module_1.default {
                 await host.rest.removeXboxFriend(account.xuid).catch(() => {
                     throw Error(`Failed to remove ${account.gamertag}`);
                 });
-                portal.emit('friendRemoved', new Player_1.default(account, null));
+                this.portal.emit('friendRemoved', new Player_1.default(account, null));
                 this.debug(`Removed ${account.gamertag}`);
                 await (0, promises_1.setTimeout)(this.options.removeInterval);
             }
         };
         this.interval = setInterval(() => {
-            const multipleAccounts = portal.modules.get('multipleAccounts');
+            const multipleAccounts = this.portal.modules.get('multipleAccounts');
             if (multipleAccounts && multipleAccounts instanceof multipleAccounts_1.default) {
                 for (const account of multipleAccounts.peers.values()) {
                     addXboxFriend(account)
                         .catch(error => this.debug(`Error: ${error.message}`, error));
                 }
             }
-            addXboxFriend(portal.host)
+            addXboxFriend(this.portal.host)
                 .catch(error => this.debug(`Error: ${error.message}`, error));
         }, this.options.checkInterval);
     }

package/dist/modules/inviteOnMessage.d.ts

@@ -1,22 +1,16 @@
 import type { BedrockPortal } from '../index';
-import type { Conversation } from '../types/xblmessaging';
 import Module from '../classes/Module';
+import { XboxMessage } from 'xbox-message';
 export default class IniteOnMessage extends Module {
-    interval: NodeJS.Timeout | null;
-    cache: Conversation[];
     options: {
         /**
          * The message to look for in chat to trigger inviting the player
          * @default 'invite'
         */
         command: string;
-        /**
-         * How often to check for new messages in milliseconds
-         * @default 30000
-        */
-        checkInterval: number;
     };
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
+    client: XboxMessage;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/modules/inviteOnMessage.js

@@ -4,63 +4,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Module_1 = __importDefault(require("../classes/Module"));
+const xbox_message_1 = require("xbox-message");
 class IniteOnMessage extends Module_1.default {
-    interval = null;
-    cache;
     options;
-    constructor() {
-        super('initeOnMessage', 'Automatically invite players to the server when they message you');
+    client;
+    constructor(portal) {
+        super(portal, 'initeOnMessage', 'Automatically invite players to the server when they message you');
         this.options = {
             command: 'invite',
-            checkInterval: 30000,
         };
-        this.cache = [];
+        this.client = new xbox_message_1.XboxMessage({ authflow: portal.authflow });
     }
-    async run(portal) {
-        const initeOnMessage = async () => {
-            const primaryMessages = await portal.host.rest.getInboxMessages('primary');
-            const secondaryMessages = await portal.host.rest.getInboxMessages('secondary');
-            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) {
-                this.cache = contentMessages;
+    async run() {
+        this.client.on('message', async (message) => {
+            this.debug(`Received message from ${message.userId}`);
+            const content = message.content;
+            if (!content)
                 return;
+            this.portal.emit('messageReceived', message);
+            if (content.toLowerCase() === this.options.command.toLowerCase()) {
+                await this.portal.invitePlayer(message.userId);
             }
-            // 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) {
-                if (portal.listenerCount('messageRecieved') > 0) {
-                    console.warn('[Deprecation Warning]: The event \'messageRecieved\' is deprecated and will be removed in a future release. Please use \'messageReceived\' instead.');
-                    portal.emit('messageRecieved', message.lastMessage);
-                }
-                portal.emit('messageReceived', 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;
-        };
-        this.interval = setInterval(() => {
-            initeOnMessage()
-                .catch(error => this.debug(`Error: ${error.message}`, error));
-        }, this.options.checkInterval);
+        });
+        await this.client.connect();
     }
     async stop() {
         super.stop();
-        if (this.interval) {
-            clearInterval(this.interval);
-        }
+        this.client.destroy();
     }
 }
 exports.default = IniteOnMessage;

package/dist/modules/multipleAccounts.d.ts

@@ -17,7 +17,7 @@ export default class MultipleAccounts extends Module {
         accounts: Authflow[];
     };
     peers: Map<string, Host>;
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
     stop(): Promise<void>;
 }

package/dist/modules/multipleAccounts.js

@@ -8,21 +8,21 @@ const Host_1 = __importDefault(require("../classes/Host"));
 class MultipleAccounts extends Module_1.default {
     options;
     peers;
-    constructor() {
-        super('multipleAccounts', 'Make the portal session joinable from multiple accounts');
+    constructor(portal) {
+        super(portal, 'multipleAccounts', 'Make the portal session joinable from multiple accounts');
         this.options = {
             accounts: [],
         };
         this.peers = new Map();
     }
-    async run(portal) {
-        if (!portal.host || !portal.host.profile) {
+    async run() {
+        if (!this.portal.host || !this.portal.host.profile) {
             this.debug('No host to connect to');
             return;
         }
         await Promise.all(this.options.accounts.map(account => account.getXboxToken()));
         for (const account of this.options.accounts) {
-            const peer = new Host_1.default(portal, account);
+            const peer = new Host_1.default(this.portal, account);
             await peer.connect();
             if (!peer.profile || !peer.connectionId) {
                 this.debug(`Failed to connect to ${account.username}`);
@@ -30,20 +30,20 @@ class MultipleAccounts extends Module_1.default {
             }
             this.peers.set(peer.profile.xuid, peer);
             this.debug(`Connected ${peer.profile.gamertag}`);
-            const hostAddPeer = await portal.host.rest.addXboxFriend(peer.profile.xuid)
+            const hostAddPeer = await this.portal.host.rest.addXboxFriend(peer.profile.xuid)
                 .catch(error => ({ error }));
-            const peerAddHost = await peer.rest.addXboxFriend(portal.host.profile.xuid)
+            const peerAddHost = await peer.rest.addXboxFriend(this.portal.host.profile.xuid)
                 .catch(error => ({ error }));
             if ((hostAddPeer && 'error' in hostAddPeer) || (peerAddHost && 'error' in peerAddHost)) {
                 if (hostAddPeer)
                     this.debug(`Failed to add ${peer.profile.gamertag} as a friend - ${hostAddPeer.error.message}`);
                 if (peerAddHost)
-                    this.debug(`Failed to add ${portal.host.profile.gamertag} as a friend - ${peerAddHost.error.message}`);
-                console.error(`Error creating a friendship between ${portal.host.profile.gamertag} and ${peer.profile.gamertag} - BedrockPortal will continue to run, but will not be joinable from ${peer.profile.gamertag}`);
+                    this.debug(`Failed to add ${this.portal.host.profile.gamertag} as a friend - ${peerAddHost.error.message}`);
+                console.error(`Error creating a friendship between ${this.portal.host.profile.gamertag} and ${peer.profile.gamertag} - BedrockPortal will continue to run, but will not be joinable from ${peer.profile.gamertag}`);
                 continue;
             }
-            await peer.rest.addConnection(portal.session.name, peer.profile.xuid, peer.connectionId, peer.subscriptionId);
-            await peer.rest.setActivity(portal.session.name);
+            await peer.rest.addConnection(this.portal.session.name, peer.profile.xuid, peer.connectionId, peer.subscriptionId);
+            await peer.rest.setActivity(this.portal.session.name);
         }
     }
     async stop() {

package/dist/modules/redirectFromRealm.d.ts

@@ -38,8 +38,8 @@ export default class RedirectFromRealm extends Module {
             message: string;
         };
     };
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
-    initClient(options: any, portal: BedrockPortal): Promise<any>;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
+    initClient(options: any): Promise<any>;
     stop(): Promise<void>;
 }

package/dist/modules/redirectFromRealm.js

@@ -10,8 +10,8 @@ class RedirectFromRealm extends Module_1.default {
     client;
     heartbeat = null;
     options;
-    constructor() {
-        super('redirectFromRealm', 'Automatically invite players to the server when they join a Realm');
+    constructor(portal) {
+        super(portal, 'redirectFromRealm', 'Automatically invite players to the server when they join a Realm');
         this.options = {
             clientOptions: {}, // Options for the bedrock-protocol client
             overideDeviceOS: 7,
@@ -29,14 +29,14 @@ class RedirectFromRealm extends Module_1.default {
             process.exit(1);
         }
     }
-    async run(portal) {
+    async run() {
         const { clientOptions } = this.options;
-        const client = await this.initClient(clientOptions, portal)
+        const client = await this.initClient(clientOptions)
             .catch(error => ({ error }));
         if ('error' in client)
             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) {
+    async initClient(options) {
         return new Promise((resolve, reject) => {
             this.client = this.bedrock.createClient(options);
             if (this.options.overideDeviceOS)
@@ -52,7 +52,7 @@ class RedirectFromRealm extends Module_1.default {
                     if (this.heartbeat)
                         clearInterval(this.heartbeat);
                     this.debug('Attempting to reconnect to Realm');
-                    return this.initClient(options, portal).catch(err => {
+                    return this.initClient(options).catch(err => {
                         this.debug(`Error reconnecting to Realm - ${err.message}`);
                     });
                 }, 30000);
@@ -62,7 +62,7 @@ class RedirectFromRealm extends Module_1.default {
                 if (packet.records.type !== 'add')
                     return;
                 for (const record of packet.records.records) {
-                    portal.invitePlayer(record.xbox_user_id)
+                    this.portal.invitePlayer(record.xbox_user_id)
                         .catch(e => this.debug(`Failed to invite ${record.xbox_user_id} - ${e.message}`));
                 }
             });
@@ -73,7 +73,7 @@ class RedirectFromRealm extends Module_1.default {
                     return;
                 cd.add(packet.xuid);
                 setTimeout(() => cd.delete(packet.xuid), this.options.chatCommand.cooldown);
-                portal.invitePlayer(packet.xuid)
+                this.portal.invitePlayer(packet.xuid)
                     .catch(e => this.debug(`Failed to invite ${packet.xuid} - ${e.message}`));
             });
         });

package/dist/modules/serverFormList.d.ts

@@ -37,8 +37,8 @@ export default class ServerFromList extends Module {
         */
         timeoutMessage: string;
     };
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
     private sendForm;
     private handleJoin;
     private handleFormResponse;

package/dist/modules/serverFormList.js

@@ -8,8 +8,8 @@ const start_game_1 = require("../common/start_game");
 class ServerFromList extends Module_1.default {
     n;
     options;
-    constructor() {
-        super('serverFromList', 'Allows players to join the server from a list of servers');
+    constructor(portal) {
+        super(portal, 'serverFromList', 'Allows players to join the server from a list of servers');
         this.options = {
             form: {
                 title: '§l§aServer Form List',
@@ -25,8 +25,8 @@ class ServerFromList extends Module_1.default {
         };
         this.n = 0;
     }
-    async run(portal) {
-        portal.onServerConnection = (client) => {
+    async run() {
+        this.portal.onServerConnection = (client) => {
             client.once('join', () => this.handleJoin(client));
             client.on('spawn', () => {
                 this.sendForm(client);

package/dist/modules/updateMemberCount.d.ts

@@ -14,6 +14,6 @@ export default class UpdateMemberCount extends Module {
         */
         updateMaxMemberCount: boolean;
     };
-    constructor();
-    run(portal: BedrockPortal): Promise<void>;
+    constructor(portal: BedrockPortal);
+    run(): Promise<void>;
 }

package/dist/modules/updateMemberCount.js

@@ -7,8 +7,8 @@ const Module_1 = __importDefault(require("../classes/Module"));
 class UpdateMemberCount extends Module_1.default {
     ping;
     options;
-    constructor() {
-        super('updateMemberCount', 'Periodically updates the member count of the session to the amount of players online');
+    constructor(portal) {
+        super(portal, 'updateMemberCount', 'Periodically updates the member count of the session to the amount of players online');
         this.options = {
             updateInterval: 60000,
             updateMaxMemberCount: true,
@@ -21,14 +21,14 @@ class UpdateMemberCount extends Module_1.default {
             process.exit(1);
         }
     }
-    async run(portal) {
+    async run() {
         let cycle = 0;
         setInterval(async () => {
             try {
-                const data = await this.ping({ host: portal.options.ip, port: portal.options.port });
+                const data = await this.ping({ host: this.portal.options.ip, port: this.portal.options.port });
                 this.debug(`Updating member count to ${data.playersOnline} / ${data.playersMax}`);
-                await portal.updateMemberCount(data.playersOnline, this.options.updateMaxMemberCount ? data.playersMax : undefined);
-                portal.emit('memberCountUpdate', { online: Number(data.playersOnline), max: Number(data.playersMax), cycle });
+                await this.portal.updateMemberCount(data.playersOnline, this.options.updateMaxMemberCount ? data.playersMax : undefined);
+                this.portal.emit('memberCountUpdate', { online: Number(data.playersOnline), max: Number(data.playersMax), cycle });
             }
             catch (error) {
                 this.debug(`Error updating member count - ${error.message}`, error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bedrock-portal",
-  "version": "0.8.14",
+  "version": "0.9.0",
   "description": "Creates a joinable session in Minecraft Bedrock Edition that can route players to their a specified host",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,6 +28,7 @@
     "prismarine-auth": "github:LucienHH/prismarine-auth#playfab",
     "tiny-typed-emitter": "^2.1.0",
     "uuid": "^9.0.0",
+    "xbox-message": "^0.2.0",
     "xbox-rta": "^2.1.0"
   },
   "devDependencies": {