bedrock-portal 0.0.1

package/.eslintrc.json

@@ -0,0 +1,45 @@
+{
+	"extends": "eslint:recommended",
+	"env": {
+		"node": true,
+		"es2022": true
+	},
+	"rules": {
+        "brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+		"comma-dangle": ["error", "always-multiline"],
+		"comma-spacing": "error",
+		"comma-style": "error",
+		"curly": ["error", "multi-line", "consistent"],
+		"dot-location": ["error", "property"],
+		"handle-callback-err": "off",
+		"indent": ["error", "tab", { "SwitchCase": 1 }],
+		"max-nested-callbacks": ["error", { "max": 4 }],
+		"max-statements-per-line": ["error", { "max": 2 }],
+		"no-console": "off",
+		"quote-props": ["error", "consistent-as-needed"],
+		"no-empty-function": "off",
+		"no-floating-decimal": "error",
+		"no-inline-comments": "off",
+		"no-lonely-if": "error",
+		"no-multi-spaces": "error",
+		"no-multiple-empty-lines": ["error", { "max": 2, "maxEOF": 1, "maxBOF": 0 }],
+		"no-shadow": ["error", { "allow": ["err", "resolve", "reject"] }],
+		"no-trailing-spaces": ["error"],
+		"no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }],
+		"no-var": "error",
+		"object-curly-spacing": ["error", "always"],
+		"prefer-const": "error",
+		"quotes": ["error", "single"],
+		"semi": ["error", "always"],
+		"space-before-blocks": "error",
+		"space-before-function-paren": ["error", {
+			"anonymous": "never",
+			"named": "never",
+			"asyncArrow": "always"
+		}],
+		"space-in-parens": "error",
+		"space-infix-ops": "error",
+		"space-unary-ops": "error",
+		"spaced-comment": "error"
+	}
+}

package/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: npm-publish
+on:
+  push:
+    branches:
+      - main
+jobs:
+  npm-publish:
+    name: npm-publish
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@master
+    - name: Set up Node.js
+      uses: actions/setup-node@master
+      with:
+        node-version: 14.0.0
+    - id: publish
+      uses: JS-DevTools/npm-publish@v1
+      with:
+        token: ${{ secrets.NPM_AUTH_TOKEN }}
+    - name: Create Release
+      if: steps.publish.outputs.type != 'none'
+      id: create_release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ steps.publish.outputs.version }}
+        release_name: Release ${{ steps.publish.outputs.version }}
+        body: ${{ steps.publish.outputs.version }}
+        draft: false
+        prerelease: false

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# BedrockPortal
+[![NPM version](https://img.shields.io/npm/v/bedrock-portal.svg)](http://npmjs.com/package/bedrock-portal)
+[![Discord](https://img.shields.io/badge/chat-on%20discord-brightgreen.svg)](https://discord.gg/KTyd9HWuBD)
+
+Handles and creates a Minecraft Bedrock game session which will redirect players to the specified server
+
+## Installation
+```shell
+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.
+
+## Usage
+
+### BedrockPortal(authflow)
+**Parameters**
+- 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
+  - **port** - The port of the server to redirect players to
+  - **disableAltCheck** - Disables the alt check.
+  - **joinability** - The joinability of the session, Can be 'friends_of_friends', 'friends_only', 'invite_only'
+  - **world** - The world config to use for the session. Changes the session card which is displayed in the Minecraft client.
+	  - **hostName** - string
+	  - **name** - string
+	  - **version** - string
+	  - **memberCount** - number
+	  - **maxMemberCount** - number
+  - **modules** - An object containing modules to enable. See [Modules](#modules) for more information.
+
+### Create a session redirect to a server
+```js
+const { BedrockPortal } = require('bedrock-portal');
+const { Authflow, Titles } = require('prismarine-auth');
+
+const main = async () => {
+	const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo' });
+
+	const session = new BedrockPortal(auth, {
+		ip: 'geyserconnect.net', // The server IP & port to redirect players to
+		port: 19132,
+		joinability: 'friends_of_friends', // The joinability of the session. Can be 'friends_of_friends', 'friends_only', 'invite_only'
+	});
+
+	await session.start();
+};
+
+main();
+```
+
+## Modules
+
+Modules are used to extend the functionality of the BedrockPortal class. You can find a list of modules below.
+
+```js
+new BedrockPortal(auth, {
+	...,
+	modules: {
+		autoFriendAdd: true, // Automatically add friends to the session
+	},
+})
+```
+
+### autoFriendAdd
+
+Automatically adds the account's followers as friends so the session can be joined by them.
+* Add `autoFriendAdd: true` to the modules object in the BedrockPortal constructor.
+
+
+## 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.
+
+## License
+
+[MIT](LICENSE)

package/examples/events.js

@@ -0,0 +1,31 @@
+const { BedrockPortal } = require('bedrock-portal');
+const { Authflow, Titles } = require('prismarine-auth');
+
+const main = async () => {
+	const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo' });
+
+	const session = new BedrockPortal(auth, {
+		ip: 'geyserconnect.net',
+		port: 19132,
+		joinability: 'friends_of_friends',
+	});
+
+	await session.start();
+
+	await session.invitePlayer('p3');
+
+	session.on('rtaEvent', (event) => {
+		console.log(event);
+	});
+
+	session.on('playersAdded', (players) => {
+		console.log(players);
+	});
+
+	session.on('playersRemoved', (players) => {
+		console.log(players);
+	});
+
+};
+
+main();

package/index.d.ts

@@ -0,0 +1,296 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+declare module 'bedrock-portal' {
+  export class BedrockPortal extends EventEmitter {
+    /**
+     * Handles and creates a Minecraft Bedrock game session which will redirect players to the specified server.
+     * @param authflow An Authflow instance from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth).
+     * @param options Options for the BedrockPortal instance
+     */
+    constructor(authflow: Authflow, options: BedrockPortalOptions = {})
+
+    /**
+     * Starts the BedrockPortal instance.
+     */
+    start(): Promise<SessionResponse>
+
+    /**
+     * Ends the BedrockPortal instance.
+     */
+    end(): Promise<void>
+
+    /**
+     * Returns the current members in the session.
+     */
+    getSessionMembers(): Promise<SessionMember[]>
+
+    /**
+     * Invites a player to the BedrockPortal instance.
+     * @param identifyer The player's gamertag or XUID.
+     */
+    invitePlayer(identifyer: string): Promise<void>
+
+    /**
+     * Updates the current member count which is displayed in the Minecraft client.
+     * @param count The new member count.
+     */
+    updateMemberCount(count: number): Promise<void>
+
+    /**
+     * Updates the connectionId of the BedrockPortal instance. Used internally on reconnect.
+     * @param connectionId The new connectionId.
+     */
+    updateConnection(connectionId: string): Promise<void>
+
+    /**
+     * Gets the current session of the BedrockPortal instance.
+     */
+    getSession(): Promise<SessionResponse>
+
+    /**
+     * Updates the current session of the BedrockPortal instance with the specified payload.
+     * @param payload The payload to update the session with.
+     */
+    updateSession(payload: SessionRequest): Promise<void>
+
+    /**
+     * Used to set the session for the user's current activity and to invite session members if required
+     * @param payload The payload 
+     */
+    updateHandle(payload: HandlePayload): Promise<void>
+
+    on(event: 'playersAdded', listener: (data: SessionMember[]) => void): this;
+    on(event: 'playersRemoved', listener: (data: SessionMember[]) => void): this;
+    on(event: 'rtaEvent', listener: (data: RTAEvent) => void): this;
+  }
+
+  export interface RTAEvent {
+    type: number;
+    subId: number;
+    data: {
+      ncid: string,
+      shoulderTaps: {
+        timestamp: string,
+        subscription: string,
+        resourceType: string,
+        resource: string,
+        branch: string,
+        changeNumber: number
+      }[]
+    }
+  }
+
+  export interface SessionMember {
+    profile: { 
+      xuid: string
+      gamertag: string
+      avatar: string
+      gamerscore: string
+      colour: {
+        primaryColor: string
+        secondaryColor: string
+        tertiaryColor: string
+      }
+    },
+    session: {
+      titleId: string
+      joinTime: string
+      index: string
+      connectionId: string
+      subscriptionId: string
+    }
+  }
+
+  export interface BedrockPortalOptions {
+    ip: string
+    port: number
+    disableAltCheck?: boolean
+    joinability?: 'invite_only' | 'friends_only' | 'friends_of_friends'
+    world?: {
+      hostName?: string
+			name?: string
+			version?: string
+			memberCount?: number
+			maxMemberCount?: number
+    }
+    modules?: {
+      autoFriendAdd?: boolean
+    }
+  }
+
+  export interface HandlePayload {
+    version: number,
+    type: 'activity' | 'invite',
+    sessionRef: {
+      scid: string,
+      templateName: string,
+      name: string,
+    },
+    inviteAttributes?: {
+      titleId: string 
+      context: string
+      contextString: string
+      senderString: string
+    },
+    invitedXuid?: string,
+  }
+
+  export interface SessionResponse {
+      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: {},
+
+      // all objects withing this object have the same structure
+      members: {
+          [index: number]: SessionMember
+      }
+      correlationId: string,
+      contractVersion: number,
+      branch: string,
+      changeNumber: number,
+      startTime: string
+  }
+
+  export interface SessionRequest {
+    properties: {
+      system: {
+        joinRestriction: 'followed' | 'local',
+        readRestriction: string,
+        closed: boolean,
+      },
+      custom: {
+        Joinability: string,
+        hostName: string,
+        ownerId: string,
+        rakNetGUID: string,
+        version: string,
+        levelId: string,
+        worldName: string,
+        worldType: string,
+        protocol: number,
+        MemberCount: number,
+        MaxMemberCount: number,
+        BroadcastSetting: number,
+        LanGame: boolean,
+        TransportLayer: number,
+        WebRTCNetworkId: number,
+        OnlineCrossPlatformGame: boolean,
+        CrossPlayDisabled: boolean,
+        TitleId: number,
+        SupportedConnections: SessionConnection[],
+      }
+    },
+    members: {
+      me: {
+        constants: {
+          system: {
+            xuid: string,
+            initialize: boolean
+          }
+        },
+        properties: {
+          system: {
+            active: boolean,
+            connection: string,
+            subscription: {
+              id: string,
+              changeTypes: string[]
+            }
+          }
+        }
+      }
+    }
+  }
+
+  export interface SessionMember {
+    next: number,
+    joinTime: string,
+    constants: {
+      system: {
+        initialize: boolean,
+        xuid: string,
+        index: number
+
+      },
+      custom: {}
+    },
+    properties: {
+      system: {
+        subscription: {
+          id: string,
+          changeTypes: string[]
+        },
+        active: boolean,
+        connection: string
+      },
+      custom: {}
+    },
+    gamertag: string,
+    activeTitleId: string
+  }
+
+  export interface SessionConnection {
+    ConnectionType: number,
+    HostIpAddress: string,
+    HostPort: number,
+    RakNetGUID: string,
+  }
+
+}

package/index.js

@@ -0,0 +1,5 @@
+process.env.DEBUG = '*';
+
+module.exports = {
+	BedrockPortal: require('./src/index'),
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "bedrock-portal",
+  "version": "0.0.1",
+  "description": "Creates a joinable session in Minecraft Bedrock Edition that can route players to their a specified host",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LucienHH/bedrock-portal.git"
+  },
+  "author": "Lucienn",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/LucienHH/bedrock-portal/issues"
+  },
+  "homepage": "https://github.com/LucienHH/bedrock-portal#readme",
+  "dependencies": {
+    "axios": "^1.0.0",
+    "uuid": "^9.0.0",
+    "xbox-rta": "^0.0.4"
+  },
+  "devDependencies": {
+    "bedrock-portal": "file:.",
+    "debug": "^4.3.4",
+    "prismarine-auth": "^1.7.0"
+  }
+}

package/src/common/constants.js

@@ -0,0 +1,29 @@
+module.exports = {
+	Endpoints: {
+		Handle: 'https://sessiondirectory.xboxlive.com/handles',
+		ServiceConfigs: 'https://sessiondirectory.xboxlive.com/serviceconfigs',
+	},
+	SessionConfig: {
+		MinecraftTitleID: '896928775',
+		MinecraftSCID: '4fc10100-5f7a-4470-899b-280835760c07',
+		MinecraftTemplateName: 'MinecraftLobby',
+		MiencraftProtocolVersion: 554,
+	},
+	Joinability: {
+		invite_only: {
+			joinability: 'invite_only',
+			joinRestriction: 'local',
+			broadcastSetting: 1,
+		},
+		friends_only: {
+			joinability: 'joinable_by_friends',
+			joinRestriction: 'followed',
+			broadcastSetting: 2,
+		},
+		friends_of_friends: {
+			joinability: 'joinable_by_friends',
+			joinRestriction: 'followed',
+			broadcastSetting: 3,
+		},
+	},
+};

package/src/index.js

@@ -0,0 +1,246 @@
+const debug = require('debug')('bedrock-portal');
+const { v4: uuidV4 } = require('uuid');
+const { XboxRTA } = require('xbox-rta');
+const { EventEmitter } = require('events');
+
+const { autoFriendAdd, altCheck } = require('./modules');
+const { SessionConfig, Endpoints, Joinability } = require('./common/constants');
+
+const Rest = require('./rest');
+
+const genRaknetGUID = () => {
+	const chars = '0123456789';
+	let result = '';
+	for (let i = 20; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];
+	return result;
+};
+
+module.exports = class BedrockPortal extends EventEmitter {
+	#rest;#rta;
+	constructor(authflow, options = {}) {
+		super();
+		const name = options.sessionName || uuidV4();
+		this.validateOptions(options);
+		this.#rest = new Rest(authflow);
+		this.#rta = new XboxRTA(authflow);
+		this.options = options;
+		this.session = {
+			url: `https://sessiondirectory.xboxlive.com/serviceconfigs/${SessionConfig.MinecraftSCID}/sessionTemplates/${SessionConfig.MinecraftTemplateName}/sessions/${name}`,
+			name,
+			subscriptionId: uuidV4(),
+		};
+		this.players = [];
+	}
+
+	validateOptions(options) {
+		if (!options.ip) throw new Error('No IP provided');
+		if (!options.port) throw new Error('No port provided');
+		if (options.joinability && !Object.keys(Joinability).includes(options.joinability)) throw new Error('Invalid joinability - Expected one of ' + Object.keys(Joinability).join(', '));
+	}
+
+	async start() {
+
+		this.sessionOwner = await this.#rest.getXboxProfile('me');
+
+		if (!this.options.disableAltCheck) {
+			const { isAlt, reason } = await altCheck(this.#rest, this.sessionOwner);
+			if (!isAlt) throw new Error('Genuine account detected - ' + reason);
+		}
+
+		await this.#rta.connect();
+
+		const connectionId = await this.#rta.subscribe('https://sessiondirectory.xboxlive.com/connections/').then(e => e.data.ConnectionId);
+
+		await this.updateSession(this.#createSessionBody(connectionId));
+
+		debug(`Created session, name: ${this.session.name}`);
+
+		await this.updateHandle(this.#createHandleBody('activity'));
+
+		const session = await this.getSession();
+
+		await this.updateSession({ properties: session.properties });
+
+		await this.#handleSessionEvents();
+
+		debug(`Published session, name: ${this.session.name}`);
+
+		return session;
+	}
+
+	async end() {
+		await this.#rta.disconnect();
+
+		await this.updateSession({ members: { me: null } });
+
+		debug(`Abandoned session, name: ${this.session.name}`);
+	}
+
+	getSessionMembers() {
+		return this.players;
+	}
+
+	async invitePlayer(identifier) {
+		const profile = await this.#rest.getXboxProfile(identifier);
+		const invitePayload = {
+			invitedXuid: String(profile.xuid),
+			inviteAttributes: { titleId: SessionConfig.MinecraftTitleID },
+		};
+
+		await this.updateHandle(this.#createHandleBody('invite', invitePayload));
+
+		debug(`Invited player, xuid: ${profile.xuid}`);
+
+	}
+
+	async updateMemberCount(count) {
+		await this.updateSession({ properties: { custom: { MemberCount: Number(count) } } });
+	}
+
+	async updateConnection(connectionId) {
+		await this.updateSession({
+			members: {
+				me: {
+					properties: {
+						system: {
+							active: true,
+							connectionId,
+						},
+					},
+				},
+			},
+		});
+	}
+
+	async getSession() {
+		return await this.#rest.get(this.session.url, {
+			contractVersion: 107,
+		});
+	}
+
+	async updateSession(payload) {
+		await this.#rest.put(this.session.url, {
+			data: { ...payload },
+			contractVersion: 107,
+		});
+	}
+
+	async updateHandle(payload) {
+		await this.#rest.post(Endpoints.Handle, {
+			data: { ...payload },
+			contractVersion: 107,
+		});
+	}
+
+	async #handleSessionEvents() {
+		this.#rta.on('reconnect', async () => {
+			const connectionId = await this.#rta.subscribe('https://sessiondirectory.xboxlive.com/connections/').then(e => e.data.ConnectionId);
+			await this.updateConnection(connectionId);
+		});
+
+		this.#rta.on('event', async ({ type, subId, data }) => {
+			this.emit('rtaEvent', { type, subId, data });
+			const session = await this.getSession();
+
+			const sessionMembers = Object.keys(session.members).map(key => session.members[key]).filter(member => member.constants.system.xuid !== this.sessionOwner.xuid);
+			const xuids = sessionMembers.map(e => e.constants.system.xuid);
+
+			const profiles = await this.#rest.getxboxProfileBatch(xuids);
+
+			const players = sessionMembers.map(e => {
+				const { xuid, gamertag, displayPicRaw: avatar, gamerScore: gamerscore, preferredColor: colour } = profiles.find(p => p.xuid === e.constants.system.xuid);
+				return {
+					profile: { xuid, gamertag, avatar, gamerscore, colour },
+					session: {
+						titleId: e.activeTitleId,
+						joinTime: e.joinTime,
+						index: e.constants.system.index,
+						connectionId: e.properties.system.connection,
+						subscriptionId: e.properties.system.subscription.id,
+					},
+				};
+			});
+
+			const newPlayers = players.filter(player => !this.players.find(p => p.profile.xuid === player.profile.xuid));
+			if (newPlayers.length) this.emit('playersAdded', newPlayers);
+
+			const removedPlayers = this.players.filter(player => !players.find(p => p.profile.xuid === player.profile.xuid));
+			if (removedPlayers.length) this.emit('playersRemoved', removedPlayers);
+
+			this.players = players;
+		});
+
+		if (this.options.modules?.autoFriendAdd) autoFriendAdd(this.#rest);
+
+	}
+
+	#createHandleBody(type, additional = {}) {
+		return {
+			version: 1,
+			type,
+			sessionRef: {
+				scid: SessionConfig.MinecraftSCID,
+				templateName: SessionConfig.MinecraftTemplateName,
+				name: this.session.name,
+			},
+			...additional,
+		};
+	}
+
+	#createSessionBody(connectionId) {
+		const joinability = Joinability[this.options.joinability ?? 'friends_of_friends'];
+		return {
+			properties: {
+				system: {
+					joinRestriction: joinability.joinRestriction,
+					readRestriction: 'followed',
+					closed: false,
+				},
+				custom: {
+					hostName: String(this.options.world?.hostName) ?? `${this.sessionOwner.gamertag}'s Portal`,
+					worldName: String(this.options.world?.name) ?? 'BedrockPortal',
+					version: String(this.options.world?.version) ?? require('../package.json').version,
+					MemberCount: Number(this.options.world?.memberCount) ?? 0,
+					MaxMemberCount: Number(this.options.world?.maxMemberCount) ?? 10,
+					Joinability: joinability.joinability,
+					ownerId: this.sessionOwner.xuid,
+					rakNetGUID: genRaknetGUID(),
+					worldType: 'Survival',
+					protocol: SessionConfig.MiencraftProtocolVersion,
+					BroadcastSetting: joinability.broadcastSetting,
+					OnlineCrossPlatformGame: true,
+					CrossPlayDisabled: false,
+					TitleId: 0,
+					SupportedConnections: [
+						{
+							ConnectionType: 6,
+							HostIpAddress: this.options.ip,
+							HostPort: Number(this.options.port),
+							RakNetGUID: '',
+						},
+					],
+				},
+			},
+			members: {
+				me: {
+					constants: {
+						system: {
+							xuid: this.sessionOwner.xuid,
+							initialize: true,
+						},
+					},
+					properties: {
+						system: {
+							active: true,
+							connection: connectionId,
+							subscription: {
+								id: this.session.subscriptionId,
+								changeTypes: ['everything'],
+							},
+						},
+					},
+				},
+			},
+		};
+	}
+};

package/src/modules.js

@@ -0,0 +1,37 @@
+const debug = require('debug')('bedrock-portal');
+
+// Rough alt check, can be improved
+const altCheck = async (api, owner) => {
+	if (owner.tier === 'Gold') return { isAlt: false, reason: 'Account is subscribed to Xbox Gold' };
+	if (owner.gamescore > 1000) return { isAlt: false, reason: `High Gamerscore. Account has ${owner.gamescore}, expected less than 1000` };
+
+	const lastplayed = await api.get(`https://titlehub.xboxlive.com/users/xuid(${owner.xuid})/titles/titlehistory/decoration/detail?maxItems=5000`, { contractVersion: 2 }).then(res => res.titles);
+
+	if (lastplayed.length > 10) return { isAlt: false, reason: `High number of games played. Account has ${lastplayed.length}, expected less than 10` };
+
+	return { isAlt: true, reason: 'Account is likely an alt' };
+};
+
+const autoFriendAdd = async (api) => {
+	setInterval(async () => {
+
+		const friends = await api.get('https://peoplehub.xboxlive.com/users/me/people/social/decoration/details').then(res => res.people.map(e => e.xuid));
+		const followers = await api.get('https://peoplehub.xboxlive.com/users/me/people/followers/decoration/details').then(res => res.people);
+
+		const needsAdding = followers.filter(res => !friends.includes(res.xuid));
+
+		if (!needsAdding.length) return;
+
+		debug(`Adding ${needsAdding.length} account(s) [${needsAdding.map(res => res.gamertag).join(', ')}]`);
+
+		for (const account of needsAdding) {
+			await api.put(`https://social.xboxlive.com/users/me/people/xuid(${account.xuid})`, { contractVersion: 2 }).catch(_ => debug(`Couldn't add ${account.xuid}`));
+		}
+
+	}, 30000);
+};
+
+module.exports = {
+	autoFriendAdd,
+	altCheck,
+};

package/src/rest.js

@@ -0,0 +1,93 @@
+const axios = require('axios');
+
+module.exports = class Rest {
+	constructor(authflow, options = {}) {
+		this.auth = authflow;
+		this.options = options;
+	}
+
+	async get(url, config = {}) {
+		return await this._request('GET', { url, ...config });
+	}
+
+	async post(url, config = {}) {
+		return await this._request('POST', { url, ...config });
+	}
+
+	async put(url, config = {}) {
+		return await this._request('PUT', { url, ...config });
+	}
+
+	async delete(url, config = {}) {
+		return await this._request('DELETE', { url, ...config });
+	}
+
+	async _request(method, config) {
+		const auth = await this.auth.getXboxToken('http://xboxlive.com');
+
+		const payload = {
+			method,
+			url: config.url,
+			headers: {
+				'Authorization': `XBL3.0 x=${auth.userHash};${auth.XSTSToken}`,
+				'accept-language': 'en-US',
+				...(this.options.headers || {}),
+				...(config.headers || {}),
+			},
+		};
+
+		if (config.contractVersion) payload.headers['x-xbl-contract-version'] = config.contractVersion;
+		if (config.params) payload.params = config.params;
+		if (config.data) payload.data = config.data;
+
+		return await axios(payload).then(e => e.data);
+	}
+
+	async getxboxProfileBatch(xuids) {
+		const response = await this.post('https://peoplehub.xboxlive.com/users/me/people/batch/decoration/detail,preferredcolor', { data: { xuids }, contractVersion: 5 }).then(e => e.people).catch(e => []);
+		return response;
+	}
+
+	async getXboxProfile(input) {
+		const settings = 'GameDisplayPicRaw,Gamerscore,Gamertag,AccountTier,XboxOneRep,PreferredColor,RealName,Bio,Location,ModernGamertag,ModernGamertagSuffix,UniqueModernGamertag,RealNameOverride,TenureLevel,Watermarks,IsQuarantined,DisplayedLinkedAccounts';
+
+		let target = '';
+		if (input === 'me') {
+			target = 'me';
+		}
+		else if (input.length === 16 && !isNaN(input)) {
+			target = `xuid(${input})`;
+		}
+		else {
+			target = `gt(${encodeURIComponent(input)})`;
+		}
+
+		const response = await this.get(`https://profile.xboxlive.com/users/${target}/profile/settings`, { params: { settings }, contractVersion: 2 });
+
+		const [avatar, gamerscore, gamertag, tier, reputation, colour, realname, bio, location, modernGamertag, modernGamertagSuffix, uniqueModernGamertag, realnameOverride, tenureLevel, watermarks, isQuarantined, linkedAccounts] = response.profileUsers[0].settings.map(e=> e.value);
+		const colourData = await axios.get(colour).then(e => e.data);
+
+		const result = {
+			xuid: response.profileUsers[0].id,
+			avatar: avatar.replace(/&background=0xababab&mode=Padding&format=png/g, ''),
+			gamerscore,
+			gamertag,
+			tier,
+			reputation,
+			colour: colourData,
+			realname,
+			bio,
+			location,
+			modernGamertag,
+			modernGamertagSuffix,
+			uniqueModernGamertag,
+			realnameOverride,
+			tenureLevel,
+			watermarks,
+			isQuarantined,
+			linkedAccounts,
+		};
+
+		return result;
+	}
+};