baltica 0.1.19 → 0.1.20

package/dist/client/client.d.ts

@@ -43,6 +43,7 @@ export declare class Client extends Emitter<ClientEvents> {
     startGameData: StartGamePacket;
     /** Whether we should continue after sending Login (Proxy use) */
     cancelPastLogin: boolean;
+    private disconnectReason?;
     constructor(options: Partial<ClientOptions>);
     /** Connect to the server and start sending/receiving packets. */
     connect(): Promise<[StartGamePacket]>;
@@ -53,6 +54,8 @@ export declare class Client extends Emitter<ClientEvents> {
     processPacket(buffer: Buffer): void;
     /** Do not call this, leaving it public incase someone needs to override this for some reason. */
     handleGamePackets(): void;
+    disconnect(reason?: string): void;
+    private cleanup;
     startEncryption(iv: Buffer): void;
     private waitForSessionReady;
     /**

package/dist/client/client.js

@@ -44,9 +44,7 @@ class Client extends shared_1.Emitter {
             });
         /** Create ClientData to store and handle auth data */
         this.data = new types_2.ClientData(this);
-        const time = Date.now();
-        /** Session event gets mojang (minecraft) auth session */
-        /** NOTE! This takes like 30-100ms for offline mode which kinda feels slow but not really */
+        this.raknet.on("disconnect", () => this.cleanup());
         this.once("session", () => {
             this.sessionReady = true;
         });
@@ -184,11 +182,23 @@ class Client extends shared_1.Emitter {
             }
         });
         this.on("DisconnectPacket", (packet) => {
-            this.status = raknet_1.ConnectionStatus.Disconnected;
-            this.raknet.disconnect();
-            console.log(packet.message);
+            this.disconnect(packet.message.message ?? undefined);
         });
     }
+    disconnect(reason) {
+        if (this.status === raknet_1.ConnectionStatus.Disconnected)
+            return;
+        this.disconnectReason = reason;
+        this.raknet.disconnect();
+    }
+    cleanup() {
+        this.status = raknet_1.ConnectionStatus.Disconnected;
+        this._encryptionEnabled = false;
+        this._compressionEnabled = false;
+        this.sessionReady = false;
+        this.emit("disconnect", this.disconnectReason);
+        this.disconnectReason = undefined;
+    }
     startEncryption(iv) {
         this.packetEncryptor = new shared_1.PacketEncryptor(this, iv);
         this._encryptionEnabled = true;

package/dist/client/types/client-events.d.ts

@@ -7,6 +7,7 @@ type ClientEvents = {
 } & {
     packet: [packet: InstanceType<(typeof Protocol)[PacketNames]>];
     connect: [];
+    disconnect: [reason?: string];
 } & {
     [K in `${number}`]: [buffer: Buffer];
 };

package/dist/shared/auth/authentication.d.ts

@@ -1,4 +1,4 @@
-import { authenticate as xboxAuthenticate, live, xnet } from "@xboxreplay/xboxlive-auth";
+import { live, xnet } from "@xboxreplay/xboxlive-auth";
 import type { AuthenticateResponse, Email } from "@xboxreplay/xboxlive-auth";
 export interface BedrockTokens {
     chains: string[];
@@ -10,11 +10,12 @@ export interface AuthOptions {
     email: string;
     password: string;
     clientPublicKey: string;
+    cacheDir?: string;
 }
 /**
  * Authenticates with Xbox Live using email/password and obtains Minecraft Bedrock tokens
- * NOTE: Only works if 2FA is DISABLED on the Microsoft account
+ * Caches Xbox user token (~14 days valid) to minimize login requests
  */
 export declare function authenticateWithCredentials(options: AuthOptions): Promise<BedrockTokens>;
-export { xboxAuthenticate as authenticate, live, xnet };
+export { live, xnet };
 export type { AuthenticateResponse, Email };

package/dist/shared/auth/authentication.js

@@ -1,39 +1,144 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xnet = exports.live = exports.authenticate = void 0;
+exports.xnet = exports.live = void 0;
 exports.authenticateWithCredentials = authenticateWithCredentials;
 const xboxlive_auth_1 = require("@xboxreplay/xboxlive-auth");
-Object.defineProperty(exports, "authenticate", { enumerable: true, get: function () { return xboxlive_auth_1.authenticate; } });
 Object.defineProperty(exports, "live", { enumerable: true, get: function () { return xboxlive_auth_1.live; } });
 Object.defineProperty(exports, "xnet", { enumerable: true, get: function () { return xboxlive_auth_1.xnet; } });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const raknet_1 = require("@sanctumterra/raknet");
 const MINECRAFT_BEDROCK_RELYING_PARTY = "https://multiplayer.minecraft.net/";
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).slice(0, 6);
+}
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function getCacheFile(cacheDir, email) {
+    return path.join(cacheDir, `${hashString(email)}_xbl-user-cache.json`);
+}
+function loadCache(cacheFile) {
+    try {
+        if (fs.existsSync(cacheFile)) {
+            const cached = JSON.parse(fs.readFileSync(cacheFile, "utf-8"));
+            // Check if token is still valid (with 1 hour buffer)
+            const expiresAt = new Date(cached.notAfter).getTime();
+            if (Date.now() < expiresAt - 3600000) {
+                return cached;
+            }
+            raknet_1.Logger.info("Cached user token expired");
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+function saveCache(cacheFile, userToken, userHash, notAfter) {
+    try {
+        ensureDir(path.dirname(cacheFile));
+        const data = {
+            userToken,
+            userHash,
+            notAfter,
+            obtainedOn: Date.now(),
+        };
+        fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+    }
+    catch {
+        /* ignore */
+    }
+}
 /**
  * Authenticates with Xbox Live using email/password and obtains Minecraft Bedrock tokens
- * NOTE: Only works if 2FA is DISABLED on the Microsoft account
+ * Caches Xbox user token (~14 days valid) to minimize login requests
  */
 async function authenticateWithCredentials(options) {
-    const { email, password, clientPublicKey } = options;
-    raknet_1.Logger.info("Authenticating with Xbox Live...");
+    const { email, password, clientPublicKey, cacheDir } = options;
+    const cacheFile = cacheDir ? getCacheFile(cacheDir, email) : null;
+    let userToken;
+    let userHash;
+    // Try to use cached user token first
+    const cached = cacheFile ? loadCache(cacheFile) : null;
+    if (cached) {
+        raknet_1.Logger.info("Using cached Xbox user token...");
+        userToken = cached.userToken;
+        userHash = cached.userHash;
+    }
+    else {
+        // Fresh login required
+        raknet_1.Logger.info("Authenticating with Xbox Live...");
+        const accessToken = await freshLogin(email, password);
+        // Exchange for Xbox user token (valid ~14 days)
+        const userTokenResp = await xboxlive_auth_1.xnet.exchangeRpsTicketForUserToken(accessToken, "t");
+        userToken = userTokenResp.Token;
+        userHash = userTokenResp.DisplayClaims.xui[0].uhs;
+        // Cache the user token
+        if (cacheFile) {
+            saveCache(cacheFile, userToken, userHash, userTokenResp.NotAfter);
+        }
+    }
+    // Get XSTS token for Minecraft Bedrock (short-lived, always fetch fresh)
+    const xstsResp = await xboxlive_auth_1.xnet.exchangeTokenForXSTSToken(userToken, {
+        XSTSRelyingParty: MINECRAFT_BEDROCK_RELYING_PARTY,
+        sandboxId: "RETAIL",
+    });
+    const xuid = xstsResp.DisplayClaims.xui[0].xid || "";
+    // Get Minecraft Bedrock chains
+    const chains = await getMinecraftBedrockChains(xstsResp.Token, userHash, clientPublicKey);
+    const gamertag = extractGamertagFromChains(chains);
+    raknet_1.Logger.info(`Authenticated as: ${gamertag} (${xuid})`);
+    return { chains, xuid, gamertag, userHash };
+}
+async function freshLogin(email, password) {
     try {
         const liveToken = await xboxlive_auth_1.live.authenticateWithCredentials({
             email: email,
             password,
         });
-        // Exchange for Xbox user token
-        const userTokenResp = await xboxlive_auth_1.xnet.exchangeRpsTicketForUserToken(liveToken.access_token, "t");
-        const userHash = userTokenResp.DisplayClaims.xui[0].uhs;
-        // Get XSTS token for Minecraft Bedrock
-        const xstsResp = await xboxlive_auth_1.xnet.exchangeTokenForXSTSToken(userTokenResp.Token, {
-            XSTSRelyingParty: MINECRAFT_BEDROCK_RELYING_PARTY,
-            sandboxId: "RETAIL",
-        });
-        const xuid = xstsResp.DisplayClaims.xui[0].xid || "";
-        // Get Minecraft Bedrock chains using the client's public key
-        const chains = await getMinecraftBedrockChains(xstsResp.Token, userHash, clientPublicKey);
-        const gamertag = extractGamertagFromChains(chains);
-        raknet_1.Logger.info(`Authenticated as: ${gamertag} (${xuid})`);
-        return { chains, xuid, gamertag, userHash };
+        return liveToken.access_token;
     }
     catch (error) {
         const err = error;
@@ -41,22 +146,6 @@ async function authenticateWithCredentials(options) {
             throw new Error("Authentication failed: Invalid credentials or 2FA is enabled.\n" +
                 "Direct email/password login only works with 2FA DISABLED.");
         }
-        // Check for Xbox Live specific errors
-        const xErr = err.data?.attributes?.extra?.body?.XErr;
-        if (xErr) {
-            const xboxErrors = {
-                2148916233: "No Xbox profile exists for this account. Create one at https://xbox.com/live",
-                2148916227: "Account banned by Xbox for violating Community Standards.",
-                2148916229: "Account restricted - guardian permission required. Visit https://account.microsoft.com/family/",
-                2148916234: "Must accept Xbox Terms of Service. Login at https://xbox.com",
-                2148916235: "Account region not authorized by Xbox.",
-                2148916236: "Account requires age verification. Login at https://login.live.com",
-                2148916238: "Account under 18 must be added to a family by an adult.",
-            };
-            if (xboxErrors[xErr]) {
-                throw new Error(`Xbox Live error: ${xboxErrors[xErr]}`);
-            }
-        }
         throw error;
     }
 }
@@ -72,6 +161,13 @@ async function getMinecraftBedrockChains(xstsToken, userHash, clientPublicKey) {
     });
     if (!response.ok) {
         const text = await response.text();
+        if (response.status === 401) {
+            throw new Error("Minecraft Bedrock authentication failed (401 UNAUTHORIZED).\n" +
+                "This usually means:\n" +
+                "  1. The account does not have an Xbox profile (create one at xbox.com)\n" +
+                "  2. The account does not own Minecraft Bedrock Edition\n" +
+                "  3. The account needs to accept Xbox/Minecraft terms of service");
+        }
         throw new Error(`Minecraft Bedrock auth failed: ${response.status} - ${text}`);
     }
     const data = (await response.json());

package/dist/shared/auth.js

@@ -106,6 +106,7 @@ async function authenticateWithEmailPassword(client) {
             email: client.options.email,
             password: client.options.password,
             clientPublicKey: client.data.loginData.clientX509,
+            cacheDir: client.options.tokensFolder,
         });
         const profile = {
             name: tokens.gamertag,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "baltica",
   "description": "Library for Minecraft Bedrock Edition community developers.",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "minecraft": "1.21.130",
   "main": "dist/index.js",
   "license": "MIT",
@@ -21,9 +21,9 @@
     }
   ],
   "dependencies": {
-    "@sanctumterra/raknet": "^1.4.7",
+    "@sanctumterra/raknet": "^1.4.8",
     "@serenityjs/binarystream": "^3.0.10",
-    "@serenityjs/protocol": "^0.8.14",
+    "@serenityjs/protocol": "^0.8.17",
     "@xboxreplay/xboxlive-auth": "^5.1.0",
     "jose": "^5.10.0",
     "prismarine-auth": "^2.7.0",
@@ -31,8 +31,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@types/node": "^22.17.1",
+    "@types/node": "^22.19.6",
     "@types/uuid-1345": "^0.99.25",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   }
 }