@rustwirebot/rustplus.js 2.5.0

package/cli/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+const axios = require('axios');
+const express = require('express');
+const { v4: uuidv4 } = require('uuid');
+const commandLineArgs = require('command-line-args');
+const commandLineUsage = require('command-line-usage');
+const ChromeLauncher = require('chrome-launcher');
+const path = require('path');
+const fs = require('fs');
+// Vendored locally (see /vendor/push-receiver) so this package keeps working
+// even if @liamcottle/push-receiver is ever removed from npm.
+const AndroidFCM = require('../vendor/push-receiver/android/fcm');
+const PushReceiverClient = require('../vendor/push-receiver/client');
+
+let server;
+let fcmClient;
+
+/**
+ * Get the path to the config file defined in command line options,
+ * or fallback to default config file in current directory.
+ */
+function getConfigFile(options) {
+    return options['config-file'] || path.join(process.cwd(), 'rustplus.config.json');
+}
+
+/**
+ * Reads config file, or returns empty config on error
+ */
+function readConfig(configFile) {
+    try {
+        return JSON.parse(fs.readFileSync(configFile));
+    } catch (err) {
+        return {};
+    }
+}
+
+/**
+ * Merges new config into existing config and saves to config file
+ * @param configFile
+ * @param config
+ */
+function updateConfig(configFile, config) {
+    // get current config
+    const currentConfig = readConfig(configFile);
+
+    // merge config into current config
+    const updatedConfig = {...currentConfig, ...config};
+
+    // convert to pretty json
+    const json = JSON.stringify(updatedConfig, null, 2);
+
+    // save updated config to config file
+    fs.writeFileSync(configFile, json, "utf8");
+}
+
+async function getExpoPushToken(fcmToken) {
+    const response = await axios.post('https://exp.host/--/api/v2/push/getExpoPushToken', {
+        type: 'fcm',
+        deviceId: uuidv4(),
+        development: false,
+        appId: 'com.facepunch.rust.companion',
+        deviceToken: fcmToken,
+        projectId: "49451aca-a822-41e6-ad59-955718d0ff9c",
+    });
+    return response.data.data.expoPushToken;
+}
+
+async function registerWithRustPlus(authToken, expoPushToken) {
+    return axios.post('https://companion-rust.facepunch.com:443/api/push/register', {
+        AuthToken: authToken,
+        DeviceId: 'rustplus.js',
+        PushKind: 3,
+        PushToken: expoPushToken,
+    })
+}
+
+async function linkSteamWithRustPlus() {
+    return new Promise((resolve, reject) => {
+        const app = express();
+
+        // register pair web page
+        app.get('/', (req, res) => {
+            res.sendFile(path.join(__dirname + '/pair.html'));
+        });
+
+        // register callback
+        app.get('/callback', async (req, res) => {
+            // we no longer need the Google Chrome instance
+            await ChromeLauncher.killAll();
+
+            // get token from callback
+            const authToken = req.query.token;
+            if (authToken) {
+                res.send('Steam Account successfully linked with rustplus.js, you can now close this window and go back to the console.');
+                resolve(authToken)
+            } else {
+                res.status(400).send('Token missing from request!');
+                reject(new Error('Token missing from request!'))
+            }
+
+            // we no longer need the express web server
+            server.close()
+        });
+
+        /**
+         * Start the express server before Google Chrome is launched.
+         * If the port is updated, make sure to also update it in pair.html
+         */
+        const port = 3000;
+        server = app.listen(port, async () => {
+            /**
+             * FIXME: Google Chrome is launched with Web Security disabled.
+             * This is bad, but it allows us to modify the window object of other domains, such as Rust+
+             * By doing so, we can inject a custom ReactNativeWebView.postMessage handler to capture Rust+ auth data.
+             *
+             * Rust+ recently changed the login flow, which no longer sends auth data in the URL callback.
+             * Auth data is now sent to a ReactNativeWebView.postMessage handler, which is available to the Rust+ app since
+             * it is a ReactNative app.
+             *
+             * We don't have access to ReactNative, but we can emulate the behaviour by registering our own window objects.
+             * However, to do so we need to disable Web Security to be able to manipulate the window of other origins.
+             */
+            await ChromeLauncher.launch({
+                startingUrl: `http://localhost:${port}`,
+                chromeFlags: [
+                    '--disable-web-security', // allows us to manipulate rust+ window
+                    '--disable-popup-blocking', // allows us to open rust+ login from our main window
+                    '--disable-site-isolation-trials', // required for --disable-web-security to work
+                    '--user-data-dir=/tmp/temporary-chrome-profile-dir-rustplus', // create a new chrome profile for pair.js
+                ],
+                handleSIGINT: false, // handled manually in shutdown
+            }).catch((error) => {
+                console.log(error);
+                console.log("pair.js failed to launch Google Chrome. Do you have it installed?");
+                process.exit(1);
+            });
+        });
+    });
+}
+
+var expoPushToken = null;
+var rustplusAuthToken = null;
+
+async function fcmRegister(options) {
+    console.log("Registering with FCM");
+    const apiKey = "AIzaSyB5y2y-Tzqb4-I4Qnlsh_9naYv_TD8pCvY";
+    const projectId = "rust-companion-app";
+    const gcmSenderId = "976529667804";
+    const gmsAppId = "1:976529667804:android:d6f1ddeb4403b338fea619";
+    const androidPackageName = "com.facepunch.rust.companion";
+    const androidPackageCert = "E28D05345FB78A7A1A63D70F4A302DBF426CA5AD";
+    const fcmCredentials = await AndroidFCM.register(apiKey, projectId, gcmSenderId, gmsAppId, androidPackageName, androidPackageCert);
+
+    console.log("Fetching Expo Push Token");
+    expoPushToken = await getExpoPushToken(fcmCredentials.fcm.token).catch((error) => {
+        console.log("Failed to fetch Expo Push Token");
+        console.log(error);
+        process.exit(1);
+    });
+
+    // show expo push token to user
+    console.log("Successfully fetched Expo Push Token");
+    console.log("Expo Push Token: " + expoPushToken);
+
+    // tell user to link steam with rust+ through Google Chrome
+    console.log("Google Chrome is launching so you can link your Steam account with Rust+");
+    rustplusAuthToken = await linkSteamWithRustPlus();
+
+    // show rust+ auth token to user
+    console.log("Successfully linked Steam account with Rust+");
+    console.log("Rust+ AuthToken: " + rustplusAuthToken);
+
+    console.log("Registering with Rust Companion API");
+    await registerWithRustPlus(rustplusAuthToken, expoPushToken).catch((error) => {
+        console.log("Failed to register with Rust Companion API");
+        console.log(error);
+        process.exit(1);
+    });
+    console.log("Successfully registered with Rust Companion API.");
+
+    // save to config
+    const configFile = getConfigFile(options);
+    updateConfig(configFile, {
+        fcm_credentials: fcmCredentials,
+        expo_push_token: expoPushToken,
+        rustplus_auth_token: rustplusAuthToken,
+    });
+    console.log("FCM, Expo and Rust+ auth tokens have been saved to " + configFile);
+}
+
+async function fcmListen(options) {
+    // read config file
+    const configFile = getConfigFile(options);
+    const config = readConfig(configFile);
+
+    // make sure fcm credentials are in config
+    if(!config.fcm_credentials){
+        console.error("FCM Credentials missing. Please run `fcm-register` first.");
+        process.exit(1);
+        return;
+    }
+
+    console.log("Listening for FCM Notifications");
+    const androidId = config.fcm_credentials.gcm.androidId;
+    const securityToken = config.fcm_credentials.gcm.securityToken;
+    const client = new PushReceiverClient(androidId, securityToken, []);
+    client.on('ON_DATA_RECEIVED', (data) => {
+
+        // generate timestamp
+        const timestamp = new Date().toLocaleString();
+
+        // log timestamp the notification was received (in green colour)
+        console.log('\x1b[32m%s\x1b[0m', `[${timestamp}] Notification Received`)
+
+        // log notification body
+        console.log(data);
+
+    });
+
+    // force exit on ctrl + c
+    process.on('SIGINT', async () => {
+        process.exit(0);
+    });
+
+    await client.connect();
+
+}
+
+function showUsage() {
+    const usage = commandLineUsage([
+        {
+            header: 'RustPlus',
+            content: 'A command line tool for things related to Rust+',
+        },
+        {
+            header: 'Usage',
+            content: '$ rustplus <options> <command>'
+        },
+        {
+            header: 'Command List',
+            content: [
+                { name: 'help', summary: 'Print this usage guide.' },
+                { name: 'fcm-register', summary: 'Registers with FCM, Expo and links your Steam account with Rust+ so you can listen for Pairing Notifications.' },
+                { name: 'fcm-listen', summary: 'Listens to notifications received from FCM, such as Rust+ Pairing Notifications.' },
+            ]
+        },
+        {
+            header: 'Options',
+            optionList: [
+                {
+                    name: 'config-file',
+                    typeLabel: '{underline file}',
+                    description: 'Path to config file. (default: rustplus.config.json)',
+                },
+            ],
+        },
+    ]);
+    console.log(usage);
+}
+
+async function run() {
+    // parse command line args
+    const options = commandLineArgs([
+        { name: 'command', type: String, defaultOption: true },
+        { name: 'config-file', type: String },
+    ]);
+
+    // run command
+    switch(options.command){
+        case 'fcm-register': {
+            await fcmRegister(options);
+            break;
+        }
+        case 'fcm-listen': {
+            await fcmListen(options);
+            break;
+        }
+        case 'help': {
+            showUsage();
+            break;
+        }
+        default: {
+            showUsage();
+            break;
+        }
+    }
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+async function shutdown() {
+    // close chrome instances launched by pair.js
+    await ChromeLauncher.killAll();
+
+    // close express server
+    if(server){
+        server.close()
+    }
+
+    // destroy fcm client
+    if(fcmClient){
+        fcmClient.destroy();
+    }
+}
+
+run();

package/cli/pair.html

@@ -0,0 +1,49 @@
+<html lang="en">
+<head>
+    <title>RustPlus Pairing</title>
+</head>
+<body>
+<div>To pair rustplus.js with Rust+, you must allow popup windows. You may need to refresh this page after enabling popups.</div>
+<script type="text/javascript">
+
+    /**
+     * Launch Rust+ login website in a popup window.
+     */
+    var popupWindow = window.open("https://companion-rust.facepunch.com/login", "", "");
+
+    /**
+     * Each time the popup window changes origins (rust+ -> steam -> rust+), our changes to the window object are reset.
+     * So, every 250ms check if our handler is not registered, and register it if needed.
+     */
+    var handlerInterval = setInterval(function() {
+        if(popupWindow.ReactNativeWebView === undefined){
+            console.log("registering ReactNativeWebView.postMessage handler");
+            popupWindow.ReactNativeWebView = {
+
+                /**
+                 * Rust+ login website calls ReactNativeWebView.postMessage after successfully logging in with Steam.
+                 * @param message json string with SteamId and Token
+                 */
+                postMessage: function(message) {
+
+                    // we no longer need the handler
+                    clearInterval(handlerInterval);
+
+                    // parse json message
+                    var auth = JSON.parse(message);
+
+                    // send the Token back to pair.js in the main window
+                    window.location.href = "http://localhost:3000/callback?token=" + encodeURIComponent(auth.Token);
+
+                    // close the popup window
+                    popupWindow.close();
+
+                },
+
+            };
+        }
+    }, 250);
+
+</script>
+</body>
+</html>

package/docs/API.md

@@ -0,0 +1,101 @@
+# Rust Companion API
+
+Base URL
+
+- https://companion-rust.facepunch.com
+
+## App Endpoints
+
+These endpoints are used by the Rust+ Companion App.
+
+### `/api/avatar/{steamId}`
+
+- Method: `GET`
+
+Redirects to the Profile Image for the SteamId.
+
+### `/api/history/read`
+
+- Method: `POST`
+- Headers:
+    - `Content-Type`: `application/json`
+- Body: `AuthToken`
+
+Response contains event history, such as Player Deaths and Server Pair Requests.
+
+- Notification ID
+- Notification Date
+- Player SteamId
+- Server ID
+- Title (eg `{name} is online`)
+- Body (server name)
+- Data (event data)
+
+### TODO
+
+Endpoints that haven't been documented yet.
+
+- POST /api/push/register
+- DELETE /api/push/unregister
+- POST /api/subscriptions/app/add
+- POST /api/subscriptions/app/remove
+- POST /api/subscriptions/app/check
+- POST /api/channel/enable
+- POST /api/channel/disable
+- POST /api/channel/check
+
+## Server Endpoints
+
+These endpoints are used by the Rust Server.
+
+### `/api/server/register`
+
+- Method: `GET`
+
+Registers a new Rust server with the Rust+ Companion API. This is called when the Rust server is initialized and has not registered, or refreshing the existing server token fails.
+
+### `/api/server/refresh`
+
+- Method: `POST`
+- Headers:
+    - `Content-Type`: `text/plain`
+- Body: `Existing Server Token`
+
+Refreshes an existing server token.
+
+### `/api/push/send`
+
+- Method: `POST`
+- Headers:
+    - `Content-Type`: `application/json`
+- JSON Body:
+    - `ServerToken` (string)
+    - `SteamIds` (list of unsigned longs)
+    - `Channel` (int)
+      - `Pairing=1001`
+      - `PlayerLoggedIn=1002`
+      - `PlayerDied=1003`
+      - `SmartAlarm=1004`
+    - `Title` (string)
+    - `Body` (string)
+    - `Data` (dictionary<string, string>)
+        - `id` (string)
+        - `name` (string)
+        - `desc` (string)
+        - `img` (string)
+        - `logo` (string)
+        - `url` (string)
+        - `ip` (string)
+        - `port` (string)
+        - `playerId` (string)
+        - `playerToken` (string)
+        - `entityId` (string)
+        - `entityType` (string)
+        - `entityName` (string)
+        - `type` (string)
+            - `death`
+            - `login`
+            - `server`
+            - `entity`
+
+Sends a push notification to the Rust+ Companion App.

package/docs/DownloadBundle.md

@@ -0,0 +1,7 @@
+# Download Rust+ Bundle
+
+You can use the following bash snippet to fetch the latest Rust+ bundle URL.
+
+```bash
+curl -s -H 'Exponent-SDK-Version: 44.0.0' -H 'Exponent-Platform: android' -H 'Exponent-Version: 0.0.25' -H 'Accept: application/expo+json,application/json' -H 'Expo-Release-Channel: default' -H 'Expo-Api-Version: 1' -H 'Expo-Client-Environment: STANDALONE' -H 'Exponent-Accept-Signature: true' -H 'Expo-JSON-Error: true' -H 'Host: exp.host' -H 'User-Agent: okhttp/3.12.1' --compressed 'https://exp.host/@facepunch/RustCompanion' | python -c 'import sys, json; print(json.loads(json.load(sys.stdin)["manifestString"])["bundleUrl"])'
+```

package/docs/PairingFlow.md

@@ -0,0 +1,19 @@
+# Rust+ Pairing Flow
+
+The procedure for pairing with a Rust Server and Smart Devices in the official Rust+ app is like so:
+
+- Player installs Rust+ mobile app from Apple App Store or Google Play Store.
+- Player logs in to Rust+ mobile app with Steam Account.
+- Player gets redirected back to the Rust+ mobile app with a Steam OpenId Auth Token.
+- Rust+ mobile app sends the `ExponentPushToken` ([expo app](https://expo.io/) notification token) for your device along with your Steam Auth Token to the `/api/push/register` endpoint of the Rust Companion API.
+- Rust Companion API returns a refreshed Steam Auth Token which expires after 2 weeks.
+- Player connects to Rust Server in game.
+- Player goes to Rust+ menu in game.
+- Player clicks "Pair with Server".
+- Rust game server communicates with Rust Companion API with `serverToken` from `companion.id` file in Rust game server folder. (I haven't checked this, but assume that's how it works)
+- Rust Companion API sends a notification to the registered device via the `ExponentPushToken`.
+- The received Pairing Notification contains the Server Information required for the Rust+ app to connect to the WebSocket running on `app.port` configured in `server.cfg` while also authenticating as the Steam Account associated with the Steam OpenId token sent in previous steps.
+- Player clicks "Pair" on "Smart Alarms" and "Smart Switches" in game.
+- Rust game server communicates with Rust Companion API. (like above, I haven't checked this, but assume so)
+- Rust Companion API sends another notification to the registered device.
+- The received Pairing Notification contains the Entity Id and Entity Type (such as Smart Alarm or Smart Switch) as well as the Server Information you get from the normal Server Pairing process.

package/donate.md

@@ -0,0 +1,10 @@
+# Donate
+
+Thank you for considering donating, this helps support my work on this project 😁
+
+## How can I donate?
+
+- Bitcoin: bc1qy22smke8n4c54evdxmp7lpy9p0e6m9tavtlg2q
+- Ethereum: 0xc64CFbA5D0BF7664158c5671F64d446395b3bF3D
+- Buy me a Coffee: [https://ko-fi.com/liamcottle](https://ko-fi.com/liamcottle)
+- Sponsor on GitHub: [https://github.com/sponsors/liamcottle](https://github.com/sponsors/liamcottle)

package/examples/10_shoot_autoturret.js

@@ -0,0 +1,100 @@
+const RustPlus = require('../rustplus');
+const Camera = require("../camera");
+var rustplus = new RustPlus('ip', 'port', 'playerId', 'playerToken');
+
+function delay(time) {
+    return new Promise(resolve => setTimeout(resolve, time));
+}
+
+rustplus.on('connected', async () => {
+
+    console.log("connected");
+
+    // get a camera (should be an autoturret for this example)
+    const turret = rustplus.getCamera("TURRET1");
+
+    // wait until subscribed to autoturret camera
+    turret.on('subscribed', async () => {
+
+        // check if camera is an auto turret
+        if(!turret.isAutoTurret()){
+            console.log("Camera is not an auto turret!");
+            await rustplus.disconnect();
+            return;
+        }
+
+        console.log("subscribed to autoturret camera");
+        await delay(500);
+
+        const shootCount = 3;
+        const shootDelay = 250;
+        const moveDelay = 500;
+        const moveAmount = 5;
+
+        // shoot autoturret
+        console.log("shooting");
+        for(let i = 0; i < shootCount; i++){
+            await delay(shootDelay);
+            await turret.shoot();
+        }
+
+        // move autoturret left
+        console.log("moving left");
+        await delay(moveDelay);
+        await turret.move(Camera.Buttons.NONE, -moveAmount, 0);
+
+        // shoot autoturret
+        console.log("shooting");
+        for(let i = 0; i < shootCount; i++){
+            await delay(shootDelay);
+            await turret.shoot();
+        }
+
+        // move autoturret up
+        console.log("moving up");
+        await delay(moveDelay);
+        await turret.move(Camera.Buttons.NONE, 0, moveAmount);
+
+        // shoot autoturret
+        console.log("shooting");
+        for(let i = 0; i < shootCount; i++){
+            await delay(shootDelay);
+            await turret.shoot();
+        }
+
+        // move autoturret right
+        console.log("moving right");
+        await delay(moveDelay);
+        await turret.move(Camera.Buttons.NONE, moveAmount, 0);
+
+        // shoot autoturret
+        console.log("shooting");
+        for(let i = 0; i < shootCount; i++){
+            await delay(shootDelay);
+            await turret.shoot();
+        }
+
+        // move autoturret down
+        console.log("moving down");
+        await delay(moveDelay);
+        await turret.move(Camera.Buttons.NONE, 0, -moveAmount);
+
+        // shoot autoturret
+        console.log("shooting");
+        for(let i = 0; i < shootCount; i++){
+            await delay(shootDelay);
+            await turret.shoot();
+        }
+
+        console.log("disconnecting");
+        await rustplus.disconnect();
+
+    });
+
+    // subscribe to autoturret camera
+    await turret.subscribe();
+
+});
+
+// connect to rust server
+rustplus.connect();

package/examples/1_send_team_chat.js

@@ -0,0 +1,16 @@
+const RustPlus = require('@rustwirebot/rustplus.js');
+var rustplus = new RustPlus('ip', 'port', 'playerId', 'playerToken');
+
+// wait until connected before sending commands
+rustplus.on('connected', () => {
+
+    // send message to team chat
+    rustplus.sendTeamMessage('Hello from rustplus.js!');
+
+    // disconnect from rust server
+    rustplus.disconnect();
+
+});
+
+// connect to rust server
+rustplus.connect();

package/examples/2_turn_smart_switch_on.js

@@ -0,0 +1,21 @@
+const RustPlus = require('@rustwirebot/rustplus.js');
+var rustplus = new RustPlus('ip', 'port', 'playerId', 'playerToken');
+
+// wait until connected before sending commands
+rustplus.on('connected', () => {
+
+    // turn smart switch on by entity id
+    rustplus.turnSmartSwitchOn(1234567, (message) => {
+
+        // log result
+        console.log("turnSmartSwitchOn result: " + JSON.stringify(message));
+
+        // disconnect from rust server
+        rustplus.disconnect();
+
+    });
+    
+});
+
+// connect to rust server
+rustplus.connect();

package/examples/3_turn_smart_switch_off.js

@@ -0,0 +1,21 @@
+const RustPlus = require('@rustwirebot/rustplus.js');
+var rustplus = new RustPlus('ip', 'port', 'playerId', 'playerToken');
+
+// wait until connected before sending commands
+rustplus.on('connected', () => {
+
+    // turn smart switch off by entity id
+    rustplus.turnSmartSwitchOff(1234567, (message) => {
+
+        // log result
+        console.log("turnSmartSwitchOff result: " + JSON.stringify(message));
+
+        // disconnect from rust server
+        rustplus.disconnect();
+
+    });
+    
+});
+
+// connect to rust server
+rustplus.connect();