bedrock-portal 1.1.6 → 2.0.0

package/README.md

@@ -12,6 +12,10 @@ npm install bedrock-portal
 ### Warning
 This package is not meant to be used with your main account. It is meant to be used with alt accounts. If you use this package with your main account, you may be banned from the XSAPI. This package is not affiliated with Mojang or Microsoft.
 
+## Migration
+
+Upgrading from v1.x to v2.x introduces breaking API changes. See [docs/migration-v2.md](docs/migration-v2.md).
+
 ## Usage
 
 ### BedrockPortal(options)
@@ -20,11 +24,12 @@ This package is not meant to be used with your main account. It is meant to be u
   - **ip** - The IP address of the server to redirect players to (required)
   - **port** - The port of the server to redirect players to | default: 19132
   - **joinability** - The joinability of the session  | default: Joinability.FriendsOfFriends
-  - **authflow** - Either an Authflow instance from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth#authflow) or an object with the following properties:
+  - **host** - Either an Authflow instance from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth#authflow) or an object with the following properties:
     - **username** - The username of the account to use for the session | default: 'BedrockPortal'
     - **cache** - The cache directory to use for the session | default: './'
     - **options** - Options for the Authflow instance from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth#authflow)
-  - **updatePresence** - Whether to update the presence of the authenticated account making it appear as if they are playing Minecraft | default: true
+  - **peers** - Additional accounts that should be connected to the session. Each entry can be either an Authflow instance or an object with the same shape as **host**. | default: []
+  - **updatePresence** - Whether to update the presence of the authenticated account making it appear as if they are playing Minecraft. Will also update the presence of any connected peers. | default: true
   - **world** - The world config to use for the session. Changes the session card which is displayed in the Minecraft client. (optional)
 	  - **hostName** - string
 	  - **name** - string
@@ -57,10 +62,37 @@ const main = async () => {
 main();
 ```
 
+### Use multiple joinable accounts
+```js
+const { BedrockPortal, Modules } = require('bedrock-portal')
+const { Titles } = require('prismarine-auth')
+
+const main = async () => {
+  const portal = new BedrockPortal({
+    ip: 'your.server.ip',
+    port: 19132,
+    peers: [
+      { username: 'account1' },
+      { username: 'account2' },
+    ],
+  })
+
+  portal.use(Modules.AutoFriendAdd, {
+    inviteOnAdd: true,
+  })
+
+  await portal.start()
+}
+
+main()
+```
+
 ## Modules
 
 Modules are used to extend the functionality of the BedrockPortal class. **Modules should be initialised before calling the `start` method.**
 
+Modules that operate on Xbox accounts use the primary **host** account and any configured **peers** automatically.
+
 ### ServerFormList
 
 Instead of redirecting players to a server, the portal will display a list of servers to join from a form. `#.use(Modules.serverFormList, options);`
@@ -99,41 +131,6 @@ const main = async () => {
 main()
 ```
 
-### MultipleAccounts
-
-Allows the portal to use multiple accounts to redirect players to the server. `#.use(Modules.MultipleAccounts, options);`
-
-Options:
-- **accounts**: Authflow[] - An array of authflows from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth), these accounts are automatically added to the host session and allows players to add them as a friend to join the game. (required)
-
-```js
-const { Authflow, Titles } = require('prismarine-auth')
-const { BedrockPortal, Modules } = require('bedrock-portal')
-
-const main = async () => {
-  const portal = new BedrockPortal( {
-    ip: 'your.server.ip',
-    port: 19132,
-  })
-
-  portal.use(Modules.AutoFriendAdd, {
-    inviteOnAdd: true,
-  })
-
-  portal.use(Modules.MultipleAccounts, {
-    accounts: [
-      new Authflow('account1', './', { authTitle: Titles.MinecraftIOS, deviceType: 'iOS', flow: 'sisu' }),
-      new Authflow('account2', './', { authTitle: Titles.MinecraftIOS, deviceType: 'iOS', flow: 'sisu' }),
-    ],
-  })
-
-  await portal.start()
-}
-
-main()
-```
-
-
 ### RedirectFromRealm
 
 > Requires [bedrock-protocol](https://github.com/PrismarineJS/bedrock-protocol) to be installed. `npm install bedrock-protocol`

package/dist/classes/Host.js

@@ -23,33 +23,67 @@ class Host {
         this.rest = new rest_1.default(this.authflow);
     }
     async connect() {
-        const auth = await this.authflow.getXboxToken();
-        this.profile = await this.rest.getProfile(auth.userXUID);
-        this.rta = new xbox_rta_1.XboxRTA(this.authflow);
-        await this.rta.connect();
-        const subResponse = await this.rta.subscribe('https://sessiondirectory.xboxlive.com/connections/');
-        this.connectionId = subResponse.data.ConnectionId;
-        this.rta.on('subscribe', (event) => this.onSubscribe(event));
-        if (this.portal.options.updatePresence) {
-            const updatePresence = () => {
-                if (this.profile) {
-                    this.rest.setPresence(this.profile.xuid)
-                        .catch(e => { debug('Failed to set presence', e); });
-                }
-            };
-            this.presenceInterval = setInterval(updatePresence, 300000);
-            updatePresence();
+        let rta = null;
+        let presenceInterval = null;
+        try {
+            const auth = await this.authflow.getXboxToken();
+            const profile = await this.rest.getProfile(auth.userXUID);
+            rta = new xbox_rta_1.XboxRTA(this.authflow);
+            await rta.connect();
+            const subResponse = await rta.subscribe('https://sessiondirectory.xboxlive.com/connections/');
+            const subData = subResponse.data;
+            this.profile = profile;
+            this.rta = rta;
+            this.connectionId = subData.ConnectionId ?? null;
+            this.subscriptionId = (0, uuid_1.v4)();
+            this.rta.on('subscribe', (event) => this.onSubscribe(event));
+            if (this.portal.options.updatePresence) {
+                const updatePresence = () => {
+                    if (this.profile) {
+                        this.rest.setPresence(this.profile.xuid)
+                            .catch(e => { debug('Failed to set presence', e); });
+                    }
+                };
+                presenceInterval = setInterval(updatePresence, 300000);
+                this.presenceInterval = presenceInterval;
+                updatePresence();
+            }
+        }
+        catch (e) {
+            if (presenceInterval) {
+                clearInterval(presenceInterval);
+            }
+            if (rta) {
+                await rta.destroy()
+                    .catch(error => { debug('Failed to destroy host RTA during connect cleanup', error); });
+            }
+            this.rta = null;
+            this.profile = null;
+            this.connectionId = null;
+            this.presenceInterval = null;
+            this.subscriptionId = (0, uuid_1.v4)();
+            throw e;
         }
     }
     async disconnect() {
-        if (this.rta) {
-            await this.rta.destroy();
+        const rta = this.rta;
+        const presenceInterval = this.presenceInterval;
+        const sessionName = this.portal.session.name;
+        this.rta = null;
+        this.profile = null;
+        this.connectionId = null;
+        this.presenceInterval = null;
+        this.subscriptionId = (0, uuid_1.v4)();
+        if (presenceInterval) {
+            clearInterval(presenceInterval);
+        }
+        if (rta) {
+            await rta.destroy();
         }
-        if (this.presenceInterval) {
-            clearInterval(this.presenceInterval);
+        if (sessionName) {
+            await this.rest.leaveSession(sessionName);
         }
-        await this.rest.leaveSession(this.portal.session.name)
-            .catch(() => { debug('Failed to leave session as host'); });
+        debug('Successfully disconnected host', this.authflow.username);
     }
     async onSubscribe(event) {
         const connectionId = event.data?.ConnectionId;
@@ -57,6 +91,9 @@ class Host {
             debug('Received RTA subscribe event', event);
             try {
                 this.connectionId = connectionId;
+                if (!this.portal.session.name) {
+                    return;
+                }
                 await this.rest.updateConnection(this.portal.session.name, connectionId);
                 await this.rest.setActivity(this.portal.session.name);
             }

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import type { Message } from 'xbox-message';
 import { EventResponse } from 'xbox-rta';
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { Server } from 'bedrock-portal-nethernet';
-import { Authflow, CacheFactory, MicrosoftAuthFlowOptions } from 'prismarine-auth';
+import { Authflow, CacheFactory, MicrosoftAuthFlowOptions, ServerDeviceCodeResponse } from 'prismarine-auth';
 import Host from './classes/Host';
 import Player from './classes/Player';
 import Module from './classes/Module';
@@ -11,14 +11,14 @@ import { Joinability } from './common/constants';
 import AutoFriendAdd from './modules/autoFriendAdd';
 import InviteOnMessage from './modules/inviteOnMessage';
 import RedirectFromRealm from './modules/redirectFromRealm';
-import MultipleAccounts from './modules/multipleAccounts';
 import AutoFriendAccept from './modules/autoFriendAccept';
 import UpdateMemberCount from './modules/updateMemberCount';
 import ServerFromList from './modules/serverFormList';
 type AuthflowOptions = {
-    username: string;
-    cache: string | CacheFactory;
-    options: MicrosoftAuthFlowOptions;
+    username?: string;
+    cache?: string | CacheFactory;
+    options?: MicrosoftAuthFlowOptions;
+    onMsaCode?: (res: ServerDeviceCodeResponse) => void;
 };
 type BedrockPortalOptions = {
     /**
@@ -60,12 +60,17 @@ type BedrockPortalOptions = {
      */
     updatePresence: boolean;
     /**
-     * The authentication flow to use for the session.
+     * The authflow options or authflow instance to use for the host account.
      */
-    authflow: AuthflowOptions | Authflow;
+    host: AuthflowOptions | Authflow;
     /**
-     * The world config to use for the session. Changes the session card which is displayed in the Minecraft client
-     */
+      * Additional accounts which are connected to the session and can be used to join the portal..
+      * @default []
+      */
+    peers: (AuthflowOptions | Authflow)[];
+    /**
+   * The world config to use for the session. Changes the session card which is displayed in the Minecraft client
+   */
     world: {
         /**
          * The host name of the world.
@@ -122,13 +127,13 @@ interface PortalEvents {
     }) => void;
 }
 export declare class BedrockPortal extends TypedEmitter<PortalEvents> {
-    authflow: Authflow;
     host: Host;
     options: BedrockPortalOptions;
     session: {
         name: string;
     };
     players: Map<string, Player>;
+    peers: Map<string, Host>;
     modules: Map<string, Module>;
     server: Server;
     constructor(options?: Partial<BedrockPortalOptions>);
@@ -145,6 +150,7 @@ export declare class BedrockPortal extends TypedEmitter<PortalEvents> {
      * Returns the current members in the session.
      */
     getSessionMembers(): Map<string, Player>;
+    getHostAndPeers(): Host[];
     /**
      * Invites a player to the BedrockPortal instance.
      * @param identifyer The player's gamertag or XUID.
@@ -178,6 +184,8 @@ export declare class BedrockPortal extends TypedEmitter<PortalEvents> {
     use<T extends ExtendedModule>(mod: ExtendedModuleConstructor<T>, options?: Partial<T['options']>): void;
     onServerConnection: (client: any) => void;
     private createAndPublishSession;
+    private connectPeers;
+    private disconnectPeers;
     private createSessionBody;
 }
 export { Joinability } from './common/constants';
@@ -186,7 +194,6 @@ declare const Modules: {
     AutoFriendAdd: typeof AutoFriendAdd;
     InviteOnMessage: typeof InviteOnMessage;
     RedirectFromRealm: typeof RedirectFromRealm;
-    MultipleAccounts: typeof MultipleAccounts;
     AutoFriendAccept: typeof AutoFriendAccept;
     UpdateMemberCount: typeof UpdateMemberCount;
     ServerFromList: typeof ServerFromList;

package/dist/index.js

@@ -17,19 +17,31 @@ const Event_1 = __importDefault(require("./handlers/Event"));
 const autoFriendAdd_1 = __importDefault(require("./modules/autoFriendAdd"));
 const inviteOnMessage_1 = __importDefault(require("./modules/inviteOnMessage"));
 const redirectFromRealm_1 = __importDefault(require("./modules/redirectFromRealm"));
-const multipleAccounts_1 = __importDefault(require("./modules/multipleAccounts"));
 const autoFriendAccept_1 = __importDefault(require("./modules/autoFriendAccept"));
 const updateMemberCount_1 = __importDefault(require("./modules/updateMemberCount"));
 const serverFormList_1 = __importDefault(require("./modules/serverFormList"));
 const start_game_1 = require("./common/start_game");
 const util_1 = require("./common/util");
 const debug = (0, debug_1.default)('bedrock-portal');
+const getDefaultAuthflowOptions = (options = {}) => ({
+    username: 'BedrockPortal',
+    cache: './',
+    options: {
+        authTitle: prismarine_auth_1.Titles.MinecraftIOS,
+        flow: 'sisu',
+        deviceType: 'iOS',
+    },
+    onMsaCode: (res) => {
+        console.log(`${options.username} - ${res.message}`);
+    },
+    ...options,
+});
 class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
-    authflow;
     host;
     options;
     session;
     players;
+    peers;
     modules = new Map();
     server = new bedrock_portal_nethernet_1.Server();
     constructor(options = {}) {
@@ -41,16 +53,8 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
             webRTCNetworkId: (0, util_1.getRandomUint64)(),
             updatePresence: true,
             ...options,
-            authflow: options.authflow instanceof prismarine_auth_1.Authflow ? options.authflow : {
-                username: 'BedrockPortal',
-                cache: './',
-                options: {
-                    authTitle: prismarine_auth_1.Titles.MinecraftIOS,
-                    flow: 'sisu',
-                    deviceType: 'iOS',
-                },
-                ...options.authflow,
-            },
+            host: options.host instanceof prismarine_auth_1.Authflow ? options.host : getDefaultAuthflowOptions(options.host),
+            peers: options.peers ? options.peers.map(peer => peer instanceof prismarine_auth_1.Authflow ? peer : getDefaultAuthflowOptions(peer)) : [],
             world: {
                 hostName: 'Bedrock Portal v1.0.0',
                 name: 'By LucienHH',
@@ -63,10 +67,10 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
             },
         };
         this.validateOptions(this.options);
-        this.authflow = this.options.authflow instanceof prismarine_auth_1.Authflow ? this.options.authflow : new prismarine_auth_1.Authflow(this.options.authflow.username, this.options.authflow.cache, this.options.authflow.options);
-        this.host = new Host_1.default(this, this.authflow);
+        this.host = new Host_1.default(this, this.options.host instanceof prismarine_auth_1.Authflow ? this.options.host : new prismarine_auth_1.Authflow(this.options.host.username, this.options.host.cache, this.options.host.options, this.options.host.onMsaCode));
         this.session = { name: '' };
         this.players = new Map();
+        this.peers = new Map();
         this.modules = new Map();
     }
     validateOptions(options) {
@@ -82,9 +86,10 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
         this.players = new Map();
         await this.host.connect();
         this.session.name = (0, uuid_1.v4)();
-        await this.server.listen(this.authflow, this.options.webRTCNetworkId);
+        await this.server.listen(this.host.authflow, this.options.webRTCNetworkId);
         this.server.on('connect', (client) => this.onServerConnection(client));
         const session = await this.createAndPublishSession();
+        await this.connectPeers();
         this.host.rta.on('event', (event) => {
             (0, Event_1.default)(this, event)
                 .catch(e => debug('Failed to handle event', e));
@@ -102,13 +107,14 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
      * Ends the BedrockPortal instance.
      */
     async end(resume = false) {
-        await this.host.disconnect();
         if (this.modules) {
             for (const mod of this.modules.values()) {
                 debug(`Stopping module: ${mod.name}`);
                 await mod.stop();
             }
         }
+        await this.disconnectPeers();
+        await this.host.disconnect();
         debug(`Abandoned session, name: ${this.session.name} - Resume: ${resume}`);
         if (resume) {
             return this.start();
@@ -120,6 +126,9 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
     getSessionMembers() {
         return this.players;
     }
+    getHostAndPeers() {
+        return [this.host, ...this.peers.values()];
+    }
     /**
      * Invites a player to the BedrockPortal instance.
      * @param identifyer The player's gamertag or XUID.
@@ -217,6 +226,49 @@ class BedrockPortal extends tiny_typed_emitter_1.TypedEmitter {
         debug(`Published session, name: ${this.session.name}, ID: ${this.options.webRTCNetworkId}`);
         return session;
     }
+    async connectPeers() {
+        for (const account of this.options.peers) {
+            let peer = null;
+            try {
+                peer = new Host_1.default(this, account instanceof prismarine_auth_1.Authflow ? account : new prismarine_auth_1.Authflow(account.username, account.cache, account.options, account.onMsaCode));
+                await peer.connect();
+                if (!peer.profile || !peer.connectionId) {
+                    throw Error(`Failed to connect to ${account.username}`);
+                }
+                debug(`Connected ${peer.profile.gamertag}`);
+                const hostAddPeer = await this.host.rest.addXboxFriend(peer.profile.xuid)
+                    .then(() => null)
+                    .catch(error => error);
+                const peerAddHost = await peer.rest.addXboxFriend(this.host.profile.xuid)
+                    .then(() => null)
+                    .catch(error => error);
+                if (hostAddPeer || peerAddHost) {
+                    if (hostAddPeer)
+                        debug(`Failed to add ${peer.profile.gamertag} as a friend - ${hostAddPeer.message}`);
+                    if (peerAddHost)
+                        debug(`Failed to add ${this.host.profile.gamertag} as a friend - ${peerAddHost.message}`);
+                    throw Error(`Failed to create friendship between ${this.host.profile.gamertag} and ${peer.profile.gamertag}`);
+                }
+                await peer.rest.addConnection(this.session.name, peer.profile.xuid, peer.connectionId, peer.subscriptionId);
+                await peer.rest.setActivity(this.session.name);
+                this.peers.set(peer.profile.xuid, peer);
+            }
+            catch (error) {
+                debug(`Failed to initialise ${account.username} - ${error.message}`);
+                if (peer) {
+                    await peer.disconnect()
+                        .catch((err) => debug(`Failed to disconnect ${peer?.authflow.username ?? account.username}`, err));
+                }
+            }
+        }
+    }
+    async disconnectPeers() {
+        for (const peer of this.peers.values()) {
+            await peer.disconnect()
+                .catch((err) => debug(`Failed to disconnect ${peer.authflow.username}`, err));
+        }
+        this.peers.clear();
+    }
     createSessionBody() {
         if (!this.host.profile || !this.host.connectionId)
             throw new Error('No session owner');
@@ -290,7 +342,6 @@ const Modules = {
     AutoFriendAdd: autoFriendAdd_1.default,
     InviteOnMessage: inviteOnMessage_1.default,
     RedirectFromRealm: redirectFromRealm_1.default,
-    MultipleAccounts: multipleAccounts_1.default,
     AutoFriendAccept: autoFriendAccept_1.default,
     UpdateMemberCount: updateMemberCount_1.default,
     ServerFromList: serverFormList_1.default,

package/dist/modules/autoFriendAccept.d.ts

@@ -1,6 +1,8 @@
 import type { BedrockPortal } from '../index';
 import type { FriendRequestPerson } from '../types/peoplehub';
+import type { EventResponse } from 'xbox-rta';
 import Module from '../classes/Module';
+import Host from '../classes/Host';
 export default class AutoFriendAccept extends Module {
     options: {
         /**
@@ -16,6 +18,10 @@ export default class AutoFriendAccept extends Module {
         */
         conditionToMeet: (request: FriendRequestPerson) => boolean;
     };
+    listeners: Map<string, {
+        host: Host;
+        listener: (event: EventResponse) => Promise<void>;
+    }>;
     constructor(portal: BedrockPortal);
     run(): Promise<void>;
     stop(): Promise<void>;

package/dist/modules/autoFriendAccept.js

@@ -5,19 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (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 {
     options;
+    listeners;
     constructor(portal) {
         super(portal, 'autoFriendAccept', 'Automatically accept friend requests');
         this.options = {
             inviteOnAdd: false,
             conditionToMeet: () => true,
         };
+        this.listeners = new Map();
     }
     async run() {
         const addXboxFriend = async (host) => {
-            host.rta?.on('event', async (event) => {
+            if (!host.rta || !host.profile || this.listeners.has(host.authflow.username)) {
+                return;
+            }
+            const listener = async (event) => {
                 if (event.data.NotificationType !== 'IncomingFriendRequestCountChanged')
                     return;
                 this.debug('Received Friend RTA event', event);
@@ -35,21 +39,22 @@ class AutoFriendAccept extends Module_1.default {
                         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`);
+            };
+            this.listeners.set(host.authflow.username, { host, listener });
+            host.rta.on('event', listener);
+            await host.rta.subscribe(`https://social.xboxlive.com/users/xuid(${host.profile.xuid})/friends`);
         };
-        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));
-            }
+        for (const account of this.portal.getHostAndPeers()) {
+            addXboxFriend(account)
+                .catch(error => this.debug(`Error: ${error.message}`, error));
         }
-        addXboxFriend(this.portal.host)
-            .catch(error => this.debug(`Error: ${error.message}`, error));
     }
     async stop() {
         super.stop();
+        for (const { host, listener } of this.listeners.values()) {
+            host.rta?.removeListener('event', listener);
+        }
+        this.listeners.clear();
     }
 }
 exports.default = AutoFriendAccept;

package/dist/modules/autoFriendAdd.js

@@ -6,7 +6,6 @@ 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;
     options;
@@ -57,15 +56,10 @@ class AutoFriendAdd extends Module_1.default {
             }
         };
         this.interval = setInterval(() => {
-            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));
-                }
+            for (const account of this.portal.getHostAndPeers()) {
+                addXboxFriend(account)
+                    .catch(error => this.debug(`Error: ${error.message}`, error));
             }
-            addXboxFriend(this.portal.host)
-                .catch(error => this.debug(`Error: ${error.message}`, error));
         }, this.options.checkInterval);
     }
     async stop() {

package/dist/modules/inviteOnMessage.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const xbox_message_1 = require("xbox-message");
 const Module_1 = __importDefault(require("../classes/Module"));
-const multipleAccounts_1 = __importDefault(require("./multipleAccounts"));
 class IniteOnMessage extends Module_1.default {
     options;
     clients;
@@ -32,20 +31,17 @@ class IniteOnMessage extends Module_1.default {
             });
             await client.connect();
         };
-        const multipleAccounts = this.portal.modules.get('multipleAccounts');
-        if (multipleAccounts && multipleAccounts instanceof multipleAccounts_1.default) {
-            for (const account of multipleAccounts.peers.values()) {
-                xboxMessageHandler(account)
-                    .catch(error => this.debug(`Error: ${error.message}`, error));
-            }
+        for (const account of this.portal.getHostAndPeers()) {
+            xboxMessageHandler(account)
+                .catch(error => this.debug(`Error: ${error.message}`, error));
         }
-        xboxMessageHandler(this.portal.host);
     }
     async stop() {
         super.stop();
         for (const client of this.clients.values()) {
             await client.destroy();
         }
+        this.clients.clear();
     }
 }
 exports.default = IniteOnMessage;

package/docs/migration-v2.md

@@ -0,0 +1,126 @@
+# V2 Migration Guide
+
+This guide covers the breaking changes required to move from v1.x to v2.x.
+
+## Summary
+
+The main API changes in v2 are:
+
+- `authflow` has been renamed to `host` if you previously set a custom authflow in the constructor
+- additional accounts are now configured with `peers` on `BedrockPortal`
+- `Modules.MultipleAccounts` has been removed
+- account-oriented modules automatically operate on the primary host and any configured peers
+
+## Constructor Changes
+
+If you did not pass `authflow` in v1, you do not need to add `host` in v2 unless you want to override the default account configuration.
+
+### v1
+
+```js
+const portal = new BedrockPortal({
+  ip: 'your.server.ip',
+  port: 19132,
+  authflow: new Authflow('main-account', './', {
+    authTitle: Titles.MinecraftIOS,
+    deviceType: 'iOS',
+    flow: 'sisu',
+  }),
+})
+```
+
+### v2
+
+```js
+const portal = new BedrockPortal({
+  ip: 'your.server.ip',
+  port: 19132,
+  host: new Authflow('main-account', './', {
+    authTitle: Titles.MinecraftIOS,
+    deviceType: 'iOS',
+    flow: 'sisu',
+  }),
+})
+```
+
+You can also pass a plain config object instead of an `Authflow` instance:
+
+```js
+const portal = new BedrockPortal({
+  ip: 'your.server.ip',
+  port: 19132,
+  host: {
+    username: 'main-account',
+    cache: './',
+    options: {
+      authTitle: Titles.MinecraftIOS,
+      deviceType: 'iOS',
+      flow: 'sisu',
+    },
+  },
+})
+```
+
+## Multiple Account Changes
+
+### v1
+
+```js
+const portal = new BedrockPortal({
+  ip: 'your.server.ip',
+  port: 19132,
+})
+
+portal.use(Modules.MultipleAccounts, {
+  accounts: [
+    new Authflow('account1', './', {
+      authTitle: Titles.MinecraftIOS,
+      deviceType: 'iOS',
+      flow: 'sisu',
+    }),
+    new Authflow('account2', './', {
+      authTitle: Titles.MinecraftIOS,
+      deviceType: 'iOS',
+      flow: 'sisu',
+    }),
+  ],
+})
+```
+
+### v2
+
+```js
+const portal = new BedrockPortal({
+  ip: 'your.server.ip',
+  port: 19132,
+  peers: [
+    new Authflow('account1', './', {
+      authTitle: Titles.MinecraftIOS,
+      deviceType: 'iOS',
+      flow: 'sisu',
+    }),
+    // or with a config object instead of an Authflow instance:
+    {
+      username: 'account2',
+    },
+  ],
+})
+```
+
+## Module Behavior Changes
+
+Modules that interact with Xbox accounts now automatically use all connected accounts.
+
+This affects modules such as:
+
+- `AutoFriendAdd`
+- `AutoFriendAccept`
+- `InviteOnMessage`
+
+You do not need to add a separate module to make those features work across peer accounts.
+
+## Migration Checklist
+
+- Rename `authflow` to `host` if your v1 code explicitly set `authflow`
+- Move any `Modules.MultipleAccounts` configuration into `peers`
+- Remove `portal.use(Modules.MultipleAccounts, ...)`

package/package.json

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

package/dist/modules/multipleAccounts.d.ts

@@ -1,23 +0,0 @@
-import type { Authflow } from 'prismarine-auth';
-import type { BedrockPortal } from '../index';
-import Module from '../classes/Module';
-import Host from '../classes/Host';
-export default class MultipleAccounts extends Module {
-    options: {
-        /**
-         * An array of authflows from prismarine-auth, these accounts are automatically added to the host session and allows players to add them as a friend to join the game
-         * @example
-         * portal.use(Modules.MultipleAccounts, {
-              accounts: [
-                new Authflow('account1', './'),
-                new Authflow('account2', './')
-              ],
-            })
-        */
-        accounts: Authflow[];
-    };
-    peers: Map<string, Host>;
-    constructor(portal: BedrockPortal);
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}

package/dist/modules/multipleAccounts.js

@@ -1,58 +0,0 @@
-"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 Host_1 = __importDefault(require("../classes/Host"));
-class MultipleAccounts extends Module_1.default {
-    options;
-    peers;
-    constructor(portal) {
-        super(portal, 'multipleAccounts', 'Make the portal session joinable from multiple accounts');
-        this.options = {
-            accounts: [],
-        };
-        this.peers = new Map();
-    }
-    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(this.portal, account);
-            await peer.connect();
-            if (!peer.profile || !peer.connectionId) {
-                this.debug(`Failed to connect to ${account.username}`);
-                continue;
-            }
-            this.peers.set(peer.profile.xuid, peer);
-            this.debug(`Connected ${peer.profile.gamertag}`);
-            const hostAddPeer = await this.portal.host.rest.addXboxFriend(peer.profile.xuid)
-                .catch(error => ({ error }));
-            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 ${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(this.portal.session.name, peer.profile.xuid, peer.connectionId, peer.subscriptionId);
-            await peer.rest.setActivity(this.portal.session.name);
-        }
-    }
-    async stop() {
-        super.stop();
-        for (const peer of this.peers.values()) {
-            await peer.disconnect()
-                .then(() => this.debug(`Disconnected ${peer.profile?.gamertag}`))
-                .catch(() => this.debug(`Failed to disconnect ${peer.profile?.gamertag}`));
-        }
-    }
-}
-exports.default = MultipleAccounts;