bedrock-portal 0.5.1 → 0.6.1

package/README.md

@@ -19,15 +19,14 @@ This package is not meant to be used with your main account. It is meant to be u
 - authflow - Takes an **Authflow** instance from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth), you can see the documentation for this [here.](https://github.com/PrismarineJS/prismarine-auth#authflow)
 - options
   - **ip** - The IP address of the server to redirect players to (required)
-  - **port** - The port of the server to redirect players to (default: 19132)
-  - **disableAltCheck** - Disables the alt check (default: false)
-  - **joinability** - The joinability of the session (default: Joinability.FriendsOfFriends)
-  - **world** - The world config to use for the session. Changes the session card which is displayed in the Minecraft client.
-	  - **hostName** - string (default: '{gamertag}'s Portal')
-	  - **name** - string (default: 'BedrockPortal')
-	  - **version** - string (default: '{BedrockPortal version}')
-	  - **memberCount** - number (default: 0)
-	  - **maxMemberCount** - number (default: 10)
+  - **port** - The port of the server to redirect players to | default: 19132
+  - **joinability** - The joinability of the session  | default: FriendsOfFriends
+  - **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
+	  - **version** - string
+	  - **memberCount** - number
+	  - **maxMemberCount** - number
 
 ### Create a session redirect to a server
 ```js
@@ -38,9 +37,12 @@ const main = async () => {
   const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' });
   
   const portal = new BedrockPortal(auth, {
-    ip: 'geyserconnect.net', // The server IP & port to redirect players to
+    // The server IP & port to redirect players to
+    ip: 'geyserconnect.net',
     port: 19132,
-    joinability: Joinability.InviteOnly, // The joinability of the session. Joinability.FriendsOfFriends, Joinability.FriendsOnly, Joinability.InviteOnly
+
+     // The joinability of the session. Joinability.FriendsOfFriends, Joinability.FriendsOnly, Joinability.InviteOnly
+    joinability: Joinability.FriendsOfFriends
   });
 
   await portal.start();
@@ -57,7 +59,44 @@ main();
 
 Modules are used to extend the functionality of the BedrockPortal class.
 
-### redirectFromRealm
+### 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 auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' })
+
+  const portal = new BedrockPortal(auth, {
+    ip: 'geyserconnect.net',
+    port: 19132,
+  })
+
+  portal.use(Modules.AutoFriendAdd, {
+    inviteOnAdd: true,
+  })
+
+  portal.use(Modules.MultipleAccounts, {
+    accounts: [
+      new Authflow('account1', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' }),
+      new Authflow('account2', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' }),
+    ],
+  })
+
+  await portal.start()
+}
+
+main()
+```
+
+
+### RedirectFromRealm
 
 > Requires [bedrock-protocol](https://github.com/PrismarineJS/bedrock-protocol) to be installed. `npm install bedrock-protocol`
 
@@ -75,7 +114,7 @@ const { BedrockPortal, Modules } = require('bedrock-portal');
 
 const portal = new BedrockPortal(auth, { ... })
 
-portal.use(Modules.redirectFromRealm, {
+portal.use(Modules.RedirectFromRealm, {
   // The client options to use when connecting to the Realm.
   clientOptions: {
     realms: {
@@ -94,7 +133,7 @@ portal.use(Modules.redirectFromRealm, {
 }
 ```
 
-### autoFriendAdd
+### AutoFriendAdd
 
 Automatically adds the account's followers as friends and invites them to the game. `#.use(Modules.autoFriendAdd);`
 
@@ -110,11 +149,11 @@ const { BedrockPortal, Modules } = require('bedrock-portal');
 
 const portal = new BedrockPortal(auth, { ... })
 
-portal.use(Modules.autoFriendAdd);
+portal.use(Modules.AutoFriendAdd);
 
 // or
 
-portal.use(Modules.autoFriendAdd, {
+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
@@ -128,7 +167,7 @@ portal.use(Modules.autoFriendAdd, {
 });
 ```
 
-### inviteOnMessage
+### InviteOnMessage
 
 Automatically invites players to the game when they send a message in the chat. `#.use(Modules.inviteOnMessage);`
 
@@ -141,11 +180,11 @@ const { BedrockPortal, Modules } = require('bedrock-portal');
 
 const portal = new BedrockPortal(auth, { ... })
 
-portal.use(Modules.inviteOnMessage);
+portal.use(Modules.InviteOnMessage);
 
 // or
 
-portal.use(Modules.inviteOnMessage, {
+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)
@@ -170,256 +209,48 @@ const myModule = class MyModule extends Module {
     }
   }
 
-  async run(portal, { rest, rta }) {
+  async run(portal) {
     // portal - The BedrockPortal instance
-    // rest - The REST API instance
-    // rta - The RTA API instance
 
     // Do stuff here
   }
+
+  async stop() {
+    super.stop();
+    // Do stuff when the module is stopped
+  }
 }
 
-portal.use(myModule);
+portal.use(myModule, {
+  option1: false,
+});
+
 ```
 
 ## Events
 
-### portal.on('sessionCreated', (session) => {})
+### portal.on('sessionCreated', (session) => void)
 Emitted when a session is created.
 
-**Parameters**
-- session - [Session](#session) object
-
-
-### portal.on('sessionUpdated', (session) => {})
+### portal.on('sessionUpdated', (session) => void)
 Emitted when a session is updated.
 
-**Parameters**
-- session - [Session](#session) object
-
-
-### portal.on('playerJoin', (player) => {})
+### portal.on('playerJoin', (player) => void)
 Emitted when a player joins the session.
 
-**Parameters**
-- player - [Player](#player) object
-
-
-### portal.on('playerLeave', (player) => {})
+### portal.on('playerLeave', (player) => void)
 Emitted when a player leaves the session.
 
-**Parameters**
-- player - [Player](#player) object
-
 
-### portal.on('friendAdded', (player) => {})
+### 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.
 
-**Parameters**
-- player - [Player](#player) object
-
-### portal.on('friendRemoved', (player) => {})
+### 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.
 
-**Parameters**
-- player - [Player](#player) object
-
-### portal.on('messageRecieved', (message) => {})
+### 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.
 
-## Objects
-
-### Player
-
-```ts
-{
-  profile?: {
-    xuid: string,
-    avatar: string,
-    gamerscore: string,
-    gamertag: string,
-    tier: string,
-    reputation: string,
-    colour: {
-      primaryColour: string,
-      secondaryColour: string,
-      tertiaryColour: string
-    },
-    realname: string,
-    bio: string,
-    location: string,
-    modernGamertag: string,
-    modernGamertagSuffix: string,
-    uniqueModernGamertag: string,
-    realnameOverride: string,
-    tenureLevel: string,
-    watermarks: string,
-    isQuarantined: boolean,
-    linkedAccounts: []
-  }
-  session?: {
-    titleId: string
-    joinTime: string
-    index: number
-    connectionId: string
-    subscriptionId: string
-  }
-}
-```
-
-### Session
-
-```ts
-{
-  membersInfo: {
-    first: number,
-    next: number,
-    count: number,
-    accepted: number,
-    active: number
-  },
-  constants: {
-    system: {
-      readyRemovalTimeout: number,
-      reservedRemovalTimeout: number,
-      sessionEmptyTimeout: number,
-      inactiveRemovalTimeout: number,
-      version: number,
-      maxMembersCount: number,
-      visibility: string,
-      capabilities: {
-        connectivity: boolean,
-        connectionRequiredForActiveMembers: boolean,
-        gameplay: boolean,
-        crossPlay: boolean,
-        userAuthorizationStyle: boolean
-      },
-      inviteProtocol: string,
-      memberInitialization: {
-        membersNeededToStart: number,
-      }
-    },
-    custom: {}
-  },
-  properties: {
-    system: {
-      joinRestriction: 'followed' | 'local',
-      readRestriction: string,
-      turn: []
-    },
-    custom: {
-      Joinability: string,
-      hostName: string,
-      ownerId: string,
-      rakNetGUID: string,
-      version: string,
-      worldName: string,
-      worldType: string,
-      protocol: number,
-      MemberCount: number,
-      MaxMemberCount: number,
-      BroadcastSetting: number,
-      UsesWebSocketsWebRTCSignaling: boolean,
-      UsesMPSDWebRTCSignaling: boolean,
-      netherNetEnabled: boolean,
-      OnlineCrossPlatformGame: boolean,
-      CrossPlayDisabled: boolean,
-      TitleId: number,
-      SupportedConnections: SessionConnection[],
-      levelId: string,
-      LanGame: boolean
-    }
-  },
-  servers: {},
-  members: {
-    [index: number]: SessionMember
-  }
-  correlationId: string,
-  contractVersion: number,
-  branch: string,
-  changeNumber: number,
-  startTime: string
-}
-```
-
-### RawPlayer
-
-```ts
-{
-    xuid: string;
-    isFavorite: boolean;
-    isFollowingCaller: boolean;
-    isFollowedByCaller: boolean;
-    isIdentityShared: boolean;
-    addedDateTimeUtc: string;
-    displayName: string;
-    realName: string;
-    displayPicRaw: string;
-    showUserAsAvatar: string;
-    gamertag: string;
-    gamerScore: string;
-    modernGamertag: string;
-    modernGamertagSuffix: string;
-    uniqueModernGamertag: string;
-    xboxOneRep: string;
-    presenceState: string;
-    presenceText: string;
-    presenceDevices: null | any[];
-    isBroadcasting: boolean;
-    isCloaked: null | boolean;
-    isQuarantined: boolean;
-    isXbox360Gamerpic: boolean;
-    lastSeenDateTimeUtc: string;
-    suggestion: null;
-    recommendation: null;
-    search: null;
-    titleHistory: null;
-    multiplayerSummary: null;
-    recentPlayer: null;
-    follower: {
-        text: string;
-        followedDateTime: string;
-    };
-    preferredColor: {
-        primaryColor: string;
-        secondaryColor: string;
-        tertiaryColor: string;
-    };
-    presenceDetails: null;
-    titlePresence: null;
-    titleSummaries: null;
-    presenceTitleIds: null;
-    detail: {
-        accountTier: string;
-        bio: string;
-        isVerified: boolean;
-        location: string;
-        tenure: string;
-        watermarks: any[];
-        blocked: boolean;
-        mute: boolean;
-        followerCount: number;
-        followingCount: number;
-        hasGamePass: boolean;
-    };
-    communityManagerTitles: null;
-    socialManager: null;
-    broadcast: null;
-    avatar: null;
-    linkedAccounts: {
-      networkName: string;
-      displayName: string;
-      showOnProfile: boolean;
-      isFamilyFriendly: boolean;
-      deeplink: null;
-    }[];
-    colorTheme: string;
-    preferredFlag: string;
-    preferredPlatforms: string[];
-}
-```
-
-
 ## Debugging
 
 You can enable some debugging output using the `DEBUG` enviroment variable. Through node.js, you can add `process.env.DEBUG = 'bedrock-portal*'` at the top of your code.

package/dist/classes/Host.d.ts

@@ -0,0 +1,17 @@
+import { Authflow } from 'prismarine-auth';
+import { XboxRTA } from 'xbox-rta';
+import { BedrockPortal } from '..';
+import { Person } from '../types/peoplehub';
+import Rest from '../rest';
+export default class Host {
+    portal: BedrockPortal;
+    authflow: Authflow;
+    rest: Rest;
+    rta: XboxRTA | null;
+    profile: Person | null;
+    connectionId: string | null;
+    subscriptionId: string;
+    constructor(portal: BedrockPortal, authflow: Authflow);
+    connect(): Promise<void>;
+    private onSubscribe;
+}

package/dist/classes/Host.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const uuid_1 = require("uuid");
+const xbox_rta_1 = require("xbox-rta");
+const rest_1 = __importDefault(require("../rest"));
+const debug = (0, debug_1.default)('bedrock-portal');
+class Host {
+    constructor(portal, authflow) {
+        this.rta = null;
+        this.profile = null;
+        this.connectionId = null;
+        this.subscriptionId = (0, uuid_1.v4)();
+        this.portal = portal;
+        this.authflow = authflow;
+        this.rest = new rest_1.default(this.authflow);
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const auth = yield this.authflow.getXboxToken();
+            this.profile = yield this.rest.getProfile(auth.userXUID);
+            this.rta = new xbox_rta_1.XboxRTA(this.authflow);
+            yield this.rta.connect();
+            const subResponse = yield this.rta.subscribe('https://sessiondirectory.xboxlive.com/connections/');
+            this.connectionId = subResponse.data.ConnectionId;
+            this.rta.on('subscribe', (event) => this.onSubscribe(event));
+        });
+    }
+    onSubscribe(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('Received RTA subscribe event', event);
+            const connectionId = event.data.ConnectionId;
+            if (connectionId && typeof connectionId === 'string') {
+                try {
+                    this.connectionId = connectionId;
+                    yield this.rest.updateConnection(this.portal.session.name, connectionId);
+                    yield this.rest.setActivity(this.portal.session.name);
+                }
+                catch (e) {
+                    debug('Failed to update connection, session may have been abandoned', e);
+                    yield this.portal.end(true);
+                }
+            }
+        });
+    }
+}
+exports.default = Host;

package/dist/classes/Module.d.ts

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

package/dist/classes/Module.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+class Module {
+    constructor(name, description) {
+        this.name = name;
+        this.description = description;
+        this.stopped = false;
+        this.options = {};
+        this.debug = (0, debug_1.default)(`bedrock-portal:${this.name}`);
+    }
+    applyOptions(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopped = true;
+        });
+    }
+    run(_portal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error('Module.run() must be implemented');
+        });
+    }
+}
+exports.default = Module;

package/dist/classes/Player.d.ts

@@ -0,0 +1,15 @@
+import type { Person } from '../types/peoplehub';
+import type { SessionMember } from '../types/sessiondirectory';
+type PlayerSession = {
+    titleId: string;
+    joinTime: string;
+    index: number;
+    connectionId: string;
+    subscriptionId: string;
+};
+export default class Player {
+    profile: Partial<Person>;
+    session: Partial<PlayerSession>;
+    constructor(profileData: Person | null, sessionData: SessionMember | null);
+}
+export {};

package/dist/classes/Player.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Player {
+    constructor(profileData, sessionData) {
+        var _a;
+        this.profile = {};
+        this.session = {};
+        if (profileData) {
+            this.profile = profileData;
+        }
+        if (sessionData) {
+            this.session = {
+                titleId: sessionData.activeTitleId,
+                joinTime: sessionData.joinTime,
+                index: sessionData.constants.system.index,
+                connectionId: sessionData.properties.system.connection,
+                subscriptionId: (_a = sessionData.properties.system.subscription) === null || _a === void 0 ? void 0 : _a.id,
+            };
+        }
+    }
+}
+exports.default = Player;

package/dist/common/constants.d.ts

@@ -0,0 +1,38 @@
+export declare const SessionConfig: {
+    MinecraftTitleID: string;
+    MinecraftSCID: string;
+    MinecraftTemplateName: string;
+    MiencraftProtocolVersion: number;
+};
+export declare enum Joinability {
+    /**
+     * Only players who have been invited can join the session.
+     * */
+    InviteOnly = "invite_only",
+    /**
+     * Friends of the authenticating account can join/view the session without an invite.
+     * */
+    FriendsOnly = "friends_only",
+    /**
+     * Anyone that's a friend or friend of a friend can join/view the session without an invite.
+     * @default
+     * */
+    FriendsOfFriends = "friends_of_friends"
+}
+export declare const JoinabilityConfig: {
+    invite_only: {
+        joinability: string;
+        joinRestriction: string;
+        broadcastSetting: number;
+    };
+    friends_only: {
+        joinability: string;
+        joinRestriction: string;
+        broadcastSetting: number;
+    };
+    friends_of_friends: {
+        joinability: string;
+        joinRestriction: string;
+        broadcastSetting: number;
+    };
+};

package/dist/common/constants.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinabilityConfig = exports.Joinability = exports.SessionConfig = void 0;
+exports.SessionConfig = {
+    MinecraftTitleID: '896928775',
+    MinecraftSCID: '4fc10100-5f7a-4470-899b-280835760c07',
+    MinecraftTemplateName: 'MinecraftLobby',
+    MiencraftProtocolVersion: 649,
+};
+var Joinability;
+(function (Joinability) {
+    /**
+     * Only players who have been invited can join the session.
+     * */
+    Joinability["InviteOnly"] = "invite_only";
+    /**
+     * Friends of the authenticating account can join/view the session without an invite.
+     * */
+    Joinability["FriendsOnly"] = "friends_only";
+    /**
+     * Anyone that's a friend or friend of a friend can join/view the session without an invite.
+     * @default
+     * */
+    Joinability["FriendsOfFriends"] = "friends_of_friends";
+})(Joinability || (exports.Joinability = Joinability = {}));
+exports.JoinabilityConfig = {
+    [Joinability.InviteOnly]: {
+        joinability: 'invite_only',
+        joinRestriction: 'local',
+        broadcastSetting: 1,
+    },
+    [Joinability.FriendsOnly]: {
+        joinability: 'joinable_by_friends',
+        joinRestriction: 'followed',
+        broadcastSetting: 2,
+    },
+    [Joinability.FriendsOfFriends]: {
+        joinability: 'joinable_by_friends',
+        joinRestriction: 'followed',
+        broadcastSetting: 3,
+    },
+};

package/dist/handlers/Event.d.ts

@@ -0,0 +1,4 @@
+import { EventResponse } from 'xbox-rta';
+import { BedrockPortal } from '..';
+declare const _default: (portal: BedrockPortal, event: EventResponse) => Promise<void>;
+export default _default;