bedrock-portal 0.8.0 → 0.8.2

package/README.md

@@ -135,6 +135,40 @@ portal.use(Modules.RedirectFromRealm, {
 
 ### AutoFriendAdd
 
+Automatically adds the account's followers as friends and invites them to the game. `#.use(Modules.autoFriendAdd);`
+
+Options:
+- **inviteOnAdd**: boolean - Automatically invites recently added friends to the game (default: false)
+- **conditionToMeet**: (player: RawPlayer) => boolean - A function that returns a boolean. If the function returns true, followers will be added as a friend and the friends that don't will be removed (default: () => true)
+- **checkInterval**: number - How often to check for friends to add/remove (default: 30000ms)
+- **addInterval**: number - How long to wait between adding friends (default: 2000ms)
+- **removeInterval**: number - How long to wait between removing friends (default: 2000ms)
+
+```js
+const { BedrockPortal, Modules } = require('bedrock-portal');
+
+const portal = new BedrockPortal(auth, { ... })
+
+portal.use(Modules.AutoFriendAdd);
+
+// or
+
+portal.use(Modules.AutoFriendAdd, {
+  // When a friend is added, automatically invite them to the game
+  inviteOnAdd: true,
+  // 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,
+});
+```
+
+### AutoFriendAccept
+
 Automatically accepts friend requests sent to the account. `#.use(Modules.autoFriendAdd);`
 
 Options:
@@ -146,11 +180,11 @@ const { BedrockPortal, Modules } = require('bedrock-portal');
 
 const portal = new BedrockPortal(auth, { ... })
 
-portal.use(Modules.AutoFriendAdd);
+portal.use(Modules.AutoFriendAccept);
 
 // or
 
-portal.use(Modules.AutoFriendAdd, {
+portal.use(Modules.AutoFriendAccept, {
   // When a friend is added invite them to the game
   inviteOnAdd: true,
   // Only accept friends that have 'elite' in their gamertag
@@ -236,6 +270,9 @@ Emitted when a player leaves the session.
 ### portal.on('friendAdded', (player) => void)
 Emitted when a player is added as a friend. This event is only emitted when the `autoFriendAdd` module is enabled.
 
+### portal.on('friendRemoved', (player) => void)
+Emitted when a player is removed as a friend. This event is only emitted when the `autoFriendAdd` module is enabled.
+
 ### portal.on('messageRecieved', (message) => void)
 Emitted when a message is recieved from a player. This event is only emitted when the `inviteOnMessage` module is enabled.
 

package/dist/index.d.ts

@@ -7,7 +7,7 @@ import Host from './classes/Host';
 import Player from './classes/Player';
 import Module from './classes/Module';
 import { Joinability } from './common/constants';
-import AutoFriendAdd from './modules/autoFriendAdd';
+import AutoFriendAdd from './modules/autoFriendAccept';
 import InviteOnMessage from './modules/inviteOnMessage';
 import RedirectFromRealm from './modules/redirectFromRealm';
 import MultipleAccounts from './modules/multipleAccounts';
@@ -149,5 +149,6 @@ declare const Modules: {
     InviteOnMessage: typeof InviteOnMessage;
     RedirectFromRealm: typeof RedirectFromRealm;
     MultipleAccounts: typeof MultipleAccounts;
+    AutoFriendAccept: typeof AutoFriendAdd;
 };
 export { Modules };

package/dist/index.js

@@ -13,10 +13,11 @@ const Module_1 = __importDefault(require("./classes/Module"));
 exports.Module = Module_1.default;
 const constants_1 = require("./common/constants");
 const Event_1 = __importDefault(require("./handlers/Event"));
-const autoFriendAdd_1 = __importDefault(require("./modules/autoFriendAdd"));
+const autoFriendAccept_1 = __importDefault(require("./modules/autoFriendAccept"));
 const inviteOnMessage_1 = __importDefault(require("./modules/inviteOnMessage"));
 const redirectFromRealm_1 = __importDefault(require("./modules/redirectFromRealm"));
 const multipleAccounts_1 = __importDefault(require("./modules/multipleAccounts"));
+const autoFriendAccept_2 = __importDefault(require("./modules/autoFriendAccept"));
 const start_game_1 = require("./common/start_game");
 const util_1 = require("./common/util");
 const debug = (0, debug_1.default)('bedrock-portal');
@@ -248,9 +249,10 @@ exports.BedrockPortal = BedrockPortal;
 var constants_2 = require("./common/constants");
 Object.defineProperty(exports, "Joinability", { enumerable: true, get: function () { return constants_2.Joinability; } });
 const Modules = {
-    AutoFriendAdd: autoFriendAdd_1.default,
+    AutoFriendAdd: autoFriendAccept_1.default,
     InviteOnMessage: inviteOnMessage_1.default,
     RedirectFromRealm: redirectFromRealm_1.default,
     MultipleAccounts: multipleAccounts_1.default,
+    AutoFriendAccept: autoFriendAccept_2.default,
 };
 exports.Modules = Modules;

package/dist/modules/autoFriendAccept.d.ts

@@ -0,0 +1,7 @@
+import type { BedrockPortal } from '../index';
+import Module from '../classes/Module';
+export default class AutoFriendAccept extends Module {
+    constructor();
+    run(portal: BedrockPortal): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/modules/autoFriendAccept.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Module_1 = __importDefault(require("../classes/Module"));
+const Player_1 = __importDefault(require("../classes/Player"));
+const multipleAccounts_1 = __importDefault(require("./multipleAccounts"));
+class AutoFriendAccept extends Module_1.default {
+    constructor() {
+        super('autoFriendAccept', 'Automatically accept friend requests');
+        this.options = {
+            inviteOnAdd: false,
+            conditionToMeet: () => true,
+        };
+    }
+    async run(portal) {
+        const addXboxFriend = async (host) => {
+            host.rta?.on('event', async (event) => {
+                if (event.data.NotificationType !== 'IncomingFriendRequestCountChanged')
+                    return;
+                this.debug('Received Friend RTA event', event);
+                const requests = await host.rest.getFriendRequestsReceived()
+                    .then(res => res.filter(this.options.conditionToMeet));
+                this.debug(`Received ${requests.length} friend request(s)`);
+                if (!requests.length)
+                    return;
+                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.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 host.rta?.subscribe(`https://social.xboxlive.com/users/xuid(${host.profile?.xuid})/friends`);
+        };
+        const multipleAccounts = 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)
+            .catch(error => this.debug(`Error: ${error.message}`, error));
+    }
+    async stop() {
+        super.stop();
+    }
+}
+exports.default = AutoFriendAccept;

package/dist/modules/autoFriendAdd.d.ts

@@ -1,6 +1,7 @@
 import type { BedrockPortal } from '../index';
 import Module from '../classes/Module';
 export default class AutoFriendAdd extends Module {
+    interval: NodeJS.Timeout | null;
     constructor();
     run(portal: BedrockPortal): Promise<void>;
     stop(): Promise<void>;

package/dist/modules/autoFriendAdd.js

@@ -3,52 +3,75 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("timers/promises");
 const Module_1 = __importDefault(require("../classes/Module"));
 const Player_1 = __importDefault(require("../classes/Player"));
 const multipleAccounts_1 = __importDefault(require("./multipleAccounts"));
 class AutoFriendAdd extends Module_1.default {
+    interval = null;
     constructor() {
-        super('autoFriendAdd', 'Automatically accept friend requests');
+        super('autoFriendAdd', 'Automatically adds followers as friends');
         this.options = {
             inviteOnAdd: false,
             conditionToMeet: () => true,
+            checkInterval: 30000,
+            addInterval: 2000,
+            removeInterval: 2000,
         };
     }
     async run(portal) {
         const addXboxFriend = async (host) => {
-            host.rta?.on('event', async (event) => {
-                if (event.data.NotificationType !== 'IncomingFriendRequestCountChanged')
-                    return;
-                this.debug('Received Friend RTA event', event);
-                const requests = await host.rest.getFriendRequestsReceived()
-                    .then(res => res.filter(this.options.conditionToMeet));
-                this.debug(`Received ${requests.length} friend request(s)`);
-                if (!requests.length)
-                    return;
-                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.debug(`Accepted ${person.gamertag}`);
-                    if (this.options.inviteOnAdd) {
-                        await portal.invitePlayer(person.xuid).catch(error => this.debug(`Error: Failed to invite ${person.gamertag}`, error));
-                    }
+            this.debug('Checking for followers to add');
+            const followers = await host.rest.getXboxFollowers()
+                .catch(() => []);
+            this.debug(`Found ${followers.length} follower(s)`);
+            const needsAdding = followers.filter(res => !res.isFollowedByCaller && this.options.conditionToMeet(res));
+            this.debug(`Adding ${needsAdding.length} account(s) [${needsAdding.map(res => res.gamertag).join(', ')}]`);
+            for (const account of needsAdding) {
+                await host.rest.addXboxFriend(account.xuid).catch(() => {
+                    throw Error(`Failed to add ${account.gamertag}`);
+                });
+                if (this.options.inviteOnAdd) {
+                    await portal.invitePlayer(account.xuid).catch(() => {
+                        throw Error(`Failed to invite ${account.gamertag}`);
+                    });
                 }
-            });
-            await host.rta?.subscribe(`https://social.xboxlive.com/users/xuid(${host.profile?.xuid})/friends`);
+                portal.emit('friendAdded', new Player_1.default(account, null));
+                this.debug(`Added & invited ${account.gamertag}`);
+                await (0, promises_1.setTimeout)(this.options.addInterval);
+            }
+            this.debug('Checking for friends to remove');
+            const friends = await host.rest.getXboxFriends()
+                .catch(() => []);
+            this.debug(`Found ${friends.length} friend(s)`);
+            const needsRemoving = friends.filter(res => !res.isFollowingCaller || !this.options.conditionToMeet(res));
+            this.debug(`Removing ${needsRemoving.length} account(s) [${needsRemoving.map(res => res.gamertag).join(', ')}]`);
+            for (const account of needsRemoving) {
+                await host.rest.removeXboxFriend(account.xuid).catch(() => {
+                    throw Error(`Failed to remove ${account.gamertag}`);
+                });
+                portal.emit('friendRemoved', new Player_1.default(account, null));
+                this.debug(`Removed ${account.gamertag}`);
+                await (0, promises_1.setTimeout)(this.options.removeInterval);
+            }
         };
-        const multipleAccounts = 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));
+        this.interval = setInterval(() => {
+            const multipleAccounts = 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)
-            .catch(error => this.debug(`Error: ${error.message}`, error));
+            addXboxFriend(portal.host)
+                .catch(error => this.debug(`Error: ${error.message}`, error));
+        }, this.options.checkInterval);
     }
     async stop() {
         super.stop();
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
     }
 }
 exports.default = AutoFriendAdd;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bedrock-portal",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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",