mineflayer-viaproxy 0.7.0

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+export declare enum AuthType {
+    NONE = "NONE",
+    OPENAUTHMOD = "OPENAUTHMOD",
+    ACCOUNT = "ACCOUNT"
+}
+export interface ViaProxyOpts {
+    forceViaProxy?: boolean;
+    javaPath?: string;
+    localPort?: number;
+    localAuth?: AuthType;
+    viaProxyLocation?: string;
+    viaProxyWorkingDir?: string;
+    autoUpdate?: boolean;
+    viaProxyConfig?: Partial<ViaProxyConfig>;
+    viaProxyStdoutCb?: (data: any) => void;
+    viaProxyStderrCb?: (data: any) => void;
+}
+export interface ViaProxyConfig {
+    backendProxyUrl: string;
+    [key: string]: string | number | boolean;
+}
+export { ViaProxySettings } from './config';

package/dist/types/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = void 0;
+var AuthType;
+(function (AuthType) {
+    AuthType["NONE"] = "NONE";
+    AuthType["OPENAUTHMOD"] = "OPENAUTHMOD";
+    AuthType["ACCOUNT"] = "ACCOUNT";
+})(AuthType || (exports.AuthType = AuthType = {}));
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;AAAA,IAAY,QAIX;AAJD,WAAY,QAAQ;IAChB,yBAAa,CAAA;IACb,uCAA2B,CAAA;IAC3B,+BAAmB,CAAA;AACvB,CAAC,EAJW,QAAQ,wBAAR,QAAQ,QAInB"}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export declare enum AuthType {
+    NONE = "NONE",
+    OPENAUTHMOD = "OPENAUTHMOD",
+    ACCOUNT = "ACCOUNT"
+}
+export interface ViaProxyOpts {
+    forceViaProxy?: boolean;
+    javaPath?: string;
+    localPort?: number;
+    localAuth?: AuthType;
+    viaProxyLocation?: string;
+    viaProxyWorkingDir?: string;
+    autoUpdate?: boolean;
+    viaProxyConfig?: Partial<ViaProxyConfig>;
+    viaProxyStdoutCb?: (data: any) => void;
+    viaProxyStderrCb?: (data: any) => void;
+}
+export interface ViaProxyConfig {
+    backendProxyUrl: string;
+    [key: string]: string | number | boolean;
+}

package/dist/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = void 0;
+var AuthType;
+(function (AuthType) {
+    AuthType["NONE"] = "NONE";
+    AuthType["OPENAUTHMOD"] = "OPENAUTHMOD";
+    AuthType["ACCOUNT"] = "ACCOUNT";
+})(AuthType || (exports.AuthType = AuthType = {}));
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,IAAY,QAIX;AAJD,WAAY,QAAQ;IAChB,yBAAa,CAAA;IACb,uCAA2B,CAAA;IAC3B,+BAAmB,CAAA;AACvB,CAAC,EAJW,QAAQ,wBAAR,QAAQ,QAInB"}

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+import { Bot } from "mineflayer";
+import { ClientOptions } from "minecraft-protocol";
+import { ViaProxySettings } from "./types";
+import { ViaProxyV3Config } from "./types/config";
+export declare function validateOptions(options: ClientOptions): ClientOptions & {
+    profilesFolder: string;
+};
+export declare function openAuthLogin(bot: Bot): Promise<void>;
+export declare function findOpenPort(): Promise<number>;
+export declare function getSupportedMCVersions(javaLoc: string, cwd: string, filename: string): Promise<string[]>;
+export declare function fetchViaProxyJar(path: string, version: string, filename: string): Promise<string | void>;
+export declare function fetchGeyserJar(pluginDir: string, verAndBuild: string, filename: string): Promise<string | void>;
+export declare function verifyViaProxyLoc(cwd: string, autoUpdate: boolean | undefined, javaLoc: string, location?: string): Promise<string>;
+export declare function verifyGeyserLoc(pluginDir: string, autoUpdate?: boolean, location?: string): Promise<string>;
+export declare function checkJavaVersion(javaLoc: string): Promise<number>;
+export declare function openViaProxyGUI(javaLoc: string, fullpath: string, cwd: string): Promise<void>;
+export declare function loadProxySaves(cwd: string, javaLoc: string, location: string): Promise<ViaProxySettings>;
+export declare function modifyProxySaves(cwd: string, javaLoc: string, location: string, data: ViaProxyV3Config): Promise<void>;
+export declare function identifyAccount(username: string, bedrock: boolean, javaLoc: string, location: string, wantedCwd: string, depth?: number, open?: boolean): Promise<number>;
+export declare function configureGeyserConfig(pluginDir: string, localPort: number): void;

package/dist/utils.js

@@ -0,0 +1,544 @@
+"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 });
+exports.validateOptions = validateOptions;
+exports.openAuthLogin = openAuthLogin;
+exports.findOpenPort = findOpenPort;
+exports.getSupportedMCVersions = getSupportedMCVersions;
+exports.fetchViaProxyJar = fetchViaProxyJar;
+exports.fetchGeyserJar = fetchGeyserJar;
+exports.verifyViaProxyLoc = verifyViaProxyLoc;
+exports.verifyGeyserLoc = verifyGeyserLoc;
+exports.checkJavaVersion = checkJavaVersion;
+exports.openViaProxyGUI = openViaProxyGUI;
+exports.loadProxySaves = loadProxySaves;
+exports.modifyProxySaves = modifyProxySaves;
+exports.identifyAccount = identifyAccount;
+exports.configureGeyserConfig = configureGeyserConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const child_process_1 = require("child_process");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const path_2 = __importDefault(require("path"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const convNmp_1 = require("./convNmp");
+const debug = require("debug")("mineflayer-viaproxy");
+const minecraftFolderPath = require("minecraft-folder-path");
+function validateOptions(options) {
+    if (options.profilesFolder == null) {
+        options.profilesFolder = path_2.default.join(minecraftFolderPath, "nmp-cache");
+    }
+    return options;
+}
+function openAuthLogin(bot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const listener = (packet) => {
+            const channel = packet.channel;
+            if (channel !== "oam:join")
+                return;
+            bot._client.write("login_plugin_response", {
+                messageId: packet.messageId,
+                data: Buffer.from([1]),
+            });
+            bot._client.removeListener("login_plugin_request", listener);
+        };
+        bot._client.removeAllListeners("login_plugin_request");
+        bot._client.on("login_plugin_request", listener);
+    });
+}
+function findOpenPort() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const net = require("net");
+        const server = net.createServer();
+        return new Promise((resolve, reject) => {
+            server.listen(0, () => {
+                const port = server.address().port;
+                server.close(() => {
+                    resolve(port);
+                });
+            });
+        });
+    });
+}
+function viaProxyAvailable(cwd, use8) {
+    let regex;
+    if (use8) {
+        regex = /ViaProxy-\d+\.\d+\.\d+(-SNAPSHOT)?(-RELEASE)?\+java8\.jar/;
+    }
+    else {
+        regex = /ViaProxy-\d+\.\d+\.\d+(-SNAPSHOT)?(-RELEASE)?\.jar/;
+    }
+    const valid = [];
+    const files = (0, fs_1.readdirSync)(cwd);
+    for (const file of files) {
+        if (regex.test(file))
+            valid.push(file);
+    }
+    if (valid.length === 0)
+        return null;
+    valid.sort(isGreaterThan);
+    return (0, path_1.join)(cwd, valid[0]);
+}
+function extractVersion(viaProxyPath) {
+    const filename = viaProxyPath.split("/").pop();
+    const version = filename.split("-")[1].split(".jar")[0];
+    return version;
+}
+function isGreaterThan(src, test) {
+    const srcArr = src.split(".").map((x) => parseInt(x));
+    const testArr = test.split(".").map((x) => parseInt(x));
+    for (let i = 0; i < srcArr.length; i++) {
+        if (srcArr[i] > testArr[i])
+            return 1;
+        if (srcArr[i] < testArr[i])
+            return -1;
+    }
+    return 0;
+}
+function geyserAvailable(cwd) {
+    const regex = /Geyser-\d+\.\d+\.\d+\.jar/;
+    const files = (0, fs_1.readdirSync)(cwd);
+    for (const file of files) {
+        if (regex.test(file))
+            return (0, path_1.join)(cwd, file);
+    }
+    return null;
+}
+function getViaProxyJarVersion() {
+    return __awaiter(this, arguments, void 0, function* (use8 = false) {
+        const req = yield fetch(constants_1.BASE_VIAPROXY_URL);
+        const html = yield req.text();
+        const versions = html.match(/ViaProxy-([0-9.]+)/);
+        if (versions == null) {
+            throw new Error("Failed to get ViaProxy version.");
+        }
+        const version = versions[1];
+        const snapshot = html.includes('SNAPSHOT');
+        let filename = 'ViaProxy-';
+        filename += version;
+        filename += snapshot ? '-SNAPSHOT' : '-RELEASE';
+        filename += use8 ? '+java8' : '';
+        filename += '.jar';
+        return { version, snapshot, filename };
+    });
+}
+function getSupportedMCVersions(javaLoc, cwd, filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const test = (0, child_process_1.exec)(`${(0, constants_1.VIA_PROXY_CMD)(javaLoc, filename, true)} --list-versions`, { cwd: cwd });
+        let versions = [];
+        let seeStartVersions = false;
+        yield new Promise((resolve, reject) => {
+            let stdOutListener = (data) => {
+                var _a, _b;
+                const strData = data.toString();
+                if (!strData.includes("===") && !seeStartVersions)
+                    return;
+                else if (strData.includes("===") && seeStartVersions) {
+                    (_a = test.stdout) === null || _a === void 0 ? void 0 : _a.removeListener("data", stdOutListener);
+                    (_b = test.stderr) === null || _b === void 0 ? void 0 : _b.removeListener("data", stdErrListener);
+                    resolve();
+                    return;
+                }
+                if (strData.includes("===")) {
+                    seeStartVersions = true;
+                    return;
+                }
+                const split = strData.split("\x1B[0m");
+                const version = split[split.length - 1].split('\n')[0];
+                versions.push(version);
+            };
+            let stdErrListener = (data) => {
+                var _a, _b;
+                console.error(data.toString());
+                (_a = test.stdout) === null || _a === void 0 ? void 0 : _a.removeListener("data", stdOutListener);
+                (_b = test.stderr) === null || _b === void 0 ? void 0 : _b.removeListener("data", stdErrListener);
+                reject();
+                return;
+            };
+            if (test.stdout != null) {
+                test.stdout.on("data", stdOutListener);
+            }
+            if (test.stderr != null) {
+                test.stderr.on("data", stdErrListener);
+            }
+        });
+        return versions;
+    });
+}
+function getGeyserJarVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resp = yield fetch(`${constants_1.BASE_GEYSER_URL}/versions/latest/builds/latest`);
+        const version = resp.url.split("versions/")[1].split("/")[0];
+        const buildVer = resp.url.split("builds/")[1].split("/")[0];
+        const filename = `Geyser-${version}-${buildVer}.jar`;
+        return { version: `${version}-${buildVer}`, filename };
+    });
+}
+function fetchViaProxyJar(path, version, filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = `${constants_1.BASE_VIAPROXY_URL}/artifact/build/libs/${filename}`;
+        const resp2 = yield fetch(url);
+        if (!resp2.ok) {
+            console.error(`Failed to download ViaProxy jar: ${resp2.statusText}`);
+            return;
+        }
+        const filepath = (0, path_1.join)(path, filename);
+        const fileStream = (0, fs_1.createWriteStream)(filepath);
+        const stream = new WritableStream({
+            write(chunk) {
+                fileStream.write(chunk);
+            },
+        });
+        if (!resp2.body)
+            throw new Error("No body in response");
+        yield resp2.body.pipeTo(stream);
+        return filepath;
+    });
+}
+function fetchGeyserJar(pluginDir, verAndBuild, filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [version, build] = verAndBuild.split("-");
+        const url = `${constants_1.BASE_GEYSER_URL}/versions/${version}/builds/${build}/downloads/viaproxy`;
+        const resp2 = yield fetch(url);
+        if (!resp2.ok) {
+            console.error(`Failed to download Geyser jar: ${resp2.statusText}`);
+            return;
+        }
+        const filepath = (0, path_1.join)(pluginDir, filename);
+        const fileStream = (0, fs_1.createWriteStream)(filepath);
+        const stream = new WritableStream({
+            write(chunk) {
+                fileStream.write(chunk);
+            },
+        });
+        if (!resp2.body)
+            throw new Error("No body in response");
+        yield resp2.body.pipeTo(stream);
+        return filepath;
+    });
+}
+function verifyViaProxyLoc(cwd_1) {
+    return __awaiter(this, arguments, void 0, function* (cwd, autoUpdate = true, javaLoc, location) {
+        if (!location || !(0, fs_1.existsSync)(location)) {
+            const javaVer = yield checkJavaVersion(javaLoc);
+            if (!autoUpdate) {
+                const viaProxy = viaProxyAvailable(cwd, javaVer < 17);
+                if (viaProxy) {
+                    debug("Found ViaProxy jar in directory. Using that.");
+                    return viaProxy;
+                }
+            }
+            const { version, filename } = yield getViaProxyJarVersion(javaVer < 17);
+            if (autoUpdate) {
+                const testLoc = (0, path_1.join)(cwd, filename);
+                if ((0, fs_1.existsSync)(testLoc)) {
+                    if (isGreaterThan(extractVersion(testLoc), version) >= 0) {
+                        debug(`Found version  ${extractVersion(testLoc)} of ViaProxy, which is good enough. Skipping download.`);
+                        return testLoc;
+                    }
+                    else {
+                        debug("Found older version of ViaProxy. Deleting.");
+                        (0, fs_1.unlinkSync)(testLoc);
+                    }
+                }
+                else {
+                    const available = viaProxyAvailable(cwd, javaVer < 17);
+                    if (available) {
+                        if (isGreaterThan(extractVersion(available), version) >= 0) {
+                            debug(`Found version ${extractVersion(available)} of ViaProxy, which is good enough. Skipping download.`);
+                            return available;
+                        }
+                        else {
+                            debug(`Found older version of ViaProxy. Deleting and installing newer.`);
+                            (0, fs_1.unlinkSync)(available);
+                        }
+                    }
+                }
+            }
+            debug(`Fetching ViaProxy for java version ${version}.`);
+            const jar = yield fetchViaProxyJar(cwd, version, filename);
+            if (!jar)
+                throw new Error("Failed to fetch ViaProxy jar.");
+            return jar;
+        }
+        return location;
+    });
+}
+function verifyGeyserLoc(pluginDir_1) {
+    return __awaiter(this, arguments, void 0, function* (pluginDir, autoUpdate = true, location) {
+        if (!location || !(0, fs_1.existsSync)(location)) {
+            if (!autoUpdate) {
+                const geyser = geyserAvailable(pluginDir);
+                if (geyser) {
+                    debug("Found Geyser jar in directory. Using that.");
+                    return geyser;
+                }
+            }
+            const { version, filename } = yield getGeyserJarVersion();
+            if (autoUpdate) {
+                const testLoc = (0, path_1.join)(pluginDir, filename);
+                if ((0, fs_1.existsSync)(testLoc)) {
+                    debug("Geyser jar already exists, skipping download.");
+                    return testLoc;
+                }
+                else {
+                    const available = geyserAvailable(pluginDir);
+                    if (available) {
+                        (0, fs_1.unlinkSync)(available);
+                    }
+                }
+            }
+            debug(`Downloading Geyser jar at ${pluginDir}`);
+            const jar = yield fetchGeyserJar(pluginDir, version, filename);
+            if (!jar)
+                throw new Error("Failed to fetch Geyser jar.");
+            return jar;
+        }
+        return location;
+    });
+}
+function checkJavaVersion(javaLoc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { stderr: stdout, exitCode } = yield (0, child_process_1.exec)(`${javaLoc} -version`);
+        if (exitCode != null && exitCode !== 0) {
+            throw new Error("Failed to check Java version. Most likely, java is not installed.");
+        }
+        return yield new Promise((resolve, reject) => {
+            if (stdout != null) {
+                stdout.on("data", (data) => {
+                    const version = data.split(" ")[2].replace(/"/g, "");
+                    const major = parseInt(version.split(".")[0]);
+                    resolve(major);
+                });
+            }
+        });
+    });
+}
+function openViaProxyGUI(javaLoc, fullpath, cwd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("opening ViaProxy. This is done to add your account.\nSimply close the window when you're done to allow the mineflayer code to continue.");
+        const test = (0, child_process_1.exec)((0, constants_1.VIA_PROXY_CMD)(javaLoc, fullpath, false), { cwd: cwd });
+        yield new Promise((resolve, reject) => {
+            test.on("close", (code) => {
+                resolve();
+            });
+            test.on("error", (err) => {
+                reject(err);
+            });
+            test.on("exit", (code) => {
+                resolve();
+            });
+        });
+    });
+}
+function loadProxySaves(cwd, javaLoc, location) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const loc = (0, path_1.join)(cwd, "saves.json");
+        if (!(0, fs_1.existsSync)(loc)) {
+            debug("No saves.json found. Creating one by running ViaProxy CLI.");
+            debug(`Running command: ${(0, constants_1.VIA_PROXY_CMD)(javaLoc, location, true)}`);
+            const process = (0, child_process_1.exec)((0, constants_1.VIA_PROXY_CMD)(javaLoc, location, true), { cwd: cwd });
+            yield new Promise((resolve) => setTimeout(resolve, 3000));
+            process.kill();
+            yield new Promise((resolve) => setTimeout(() => resolve(), 2000));
+            const data = JSON.parse((0, fs_1.readFileSync)(loc, "utf-8"));
+            return data;
+        }
+        const data = JSON.parse((0, fs_1.readFileSync)(loc, "utf-8"));
+        debug("Loaded existing saves.json file for ViaProxy.");
+        return data;
+    });
+}
+function modifyProxySaves(cwd, javaLoc, location, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const loc = (0, path_1.join)(cwd, "saves.json");
+        const saves = yield loadProxySaves(cwd, javaLoc, location);
+        const { newest, key } = latestAccountsKey(saves);
+        switch (newest) {
+            case 3:
+                const dataTyped = data;
+                const data1 = saves[key];
+                data1.push(...dataTyped.accountsV3);
+                break;
+            case 4:
+                const dataTyped4 = (0, convNmp_1.convToV4)(data);
+                const data4 = saves[key];
+                data4.push(...dataTyped4.accountsV4);
+                break;
+            default:
+                throw new Error(`Unsupported accounts version: ${newest}`);
+        }
+        (0, fs_1.writeFileSync)(loc, JSON.stringify(saves, null, 2), "utf-8");
+    });
+}
+function assertDepth(depth) {
+    if (depth < 0)
+        throw new Error("Invalid depth received (below zero). This should never be manually specified.");
+}
+function latestAccountsKey(saves) {
+    const versions = Object.keys(saves)
+        .filter((k) => k.startsWith("accountsV"))
+        .map((k) => Number(k.slice("accountsV".length)))
+        .filter((n) => Number.isFinite(n))
+        .sort((a, b) => a - b);
+    if (versions.length === 0)
+        throw new Error("No accountsV* keys found in saves.json.");
+    const newest = versions[versions.length - 1];
+    return { newest, key: `accountsV${newest}` };
+}
+function isBedrock(acc) {
+    var _a;
+    return (_a = acc.accountType) === null || _a === void 0 ? void 0 : _a.includes("Bedrock");
+}
+function isMicrosoft(acc) {
+    var _a;
+    return (_a = acc.accountType) === null || _a === void 0 ? void 0 : _a.includes("Microsoft");
+}
+function withSingleRetry(depth, open, onOpen, action) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield action();
+        }
+        catch (err) {
+            if (depth >= 1)
+                throw err;
+            if (!open)
+                throw err;
+            yield onOpen();
+            return yield action();
+        }
+    });
+}
+function getV3Names(accounts) {
+    var _a, _b, _c, _d;
+    const bedrockNames = [];
+    const javaNames = [];
+    for (const acc of accounts) {
+        if (isBedrock(acc))
+            bedrockNames.push((_b = (_a = acc.bedrockSession) === null || _a === void 0 ? void 0 : _a.mcChain) === null || _b === void 0 ? void 0 : _b.displayName);
+        else if (isMicrosoft(acc))
+            javaNames.push((_d = (_c = acc.javaSession) === null || _c === void 0 ? void 0 : _c.mcProfile) === null || _d === void 0 ? void 0 : _d.name);
+    }
+    return {
+        bedrockNames: bedrockNames.filter(Boolean),
+        javaNames: javaNames.filter(Boolean),
+        findBedrockIndex: (username) => accounts.findIndex((a) => { var _a, _b; return isBedrock(a) && ((_b = (_a = a.bedrockSession) === null || _a === void 0 ? void 0 : _a.mcChain) === null || _b === void 0 ? void 0 : _b.displayName) === username; }),
+        findJavaIndex: (username) => accounts.findIndex((a) => { var _a, _b; return isMicrosoft(a) && ((_b = (_a = a.javaSession) === null || _a === void 0 ? void 0 : _a.mcProfile) === null || _b === void 0 ? void 0 : _b.name) === username; }),
+    };
+}
+function getV4Names(accounts) {
+    var _a, _b, _c, _d;
+    const bedrockNames = [];
+    const javaNames = [];
+    for (const acc of accounts) {
+        if (isBedrock(acc)) {
+            const jwt1 = (_a = acc.minecraftCertificateChain) === null || _a === void 0 ? void 0 : _a.identityJwt;
+            if (!jwt1)
+                continue;
+            const decoded = jsonwebtoken_1.default.decode(jwt1, { complete: true });
+            const displayName = decoded ? (_c = (_b = decoded.payload) === null || _b === void 0 ? void 0 : _b.extraData) === null || _c === void 0 ? void 0 : _c.displayName : undefined;
+            if (displayName)
+                bedrockNames.push(displayName);
+        }
+        else if (isMicrosoft(acc)) {
+            const name = (_d = acc.minecraftProfile) === null || _d === void 0 ? void 0 : _d.name;
+            if (name)
+                javaNames.push(name);
+        }
+    }
+    return {
+        bedrockNames,
+        javaNames,
+        findBedrockIndex: (username) => accounts.findIndex((acc) => {
+            var _a, _b, _c;
+            if (!isBedrock(acc))
+                return false;
+            const jwt1 = (_a = acc.minecraftCertificateChain) === null || _a === void 0 ? void 0 : _a.identityJwt;
+            const decoded = jwt1 ? jsonwebtoken_1.default.decode(jwt1, { complete: true }) : null;
+            const dn = decoded ? (_c = (_b = decoded.payload) === null || _b === void 0 ? void 0 : _b.extraData) === null || _c === void 0 ? void 0 : _c.displayName : undefined;
+            return dn === username;
+        }),
+        findJavaIndex: (username) => accounts.findIndex((acc) => { var _a; return isMicrosoft(acc) && ((_a = acc.minecraftProfile) === null || _a === void 0 ? void 0 : _a.name) === username; }),
+    };
+}
+function identifyAccount(username_1, bedrock_1, javaLoc_1, location_1, wantedCwd_1) {
+    return __awaiter(this, arguments, void 0, function* (username, bedrock, javaLoc, location, wantedCwd, depth = 0, open = true) {
+        assertDepth(depth);
+        const onOpen = () => __awaiter(this, void 0, void 0, function* () {
+            debug(`Opening GUI.\nLocation: ${location}`);
+            yield openViaProxyGUI(javaLoc, location, wantedCwd);
+        });
+        const saves = yield withSingleRetry(depth, open, onOpen, () => __awaiter(this, void 0, void 0, function* () { return yield loadProxySaves(wantedCwd, javaLoc, location); })).catch((err) => __awaiter(this, void 0, void 0, function* () {
+            if (!open && depth === 0) {
+                debug(`Failed to load saves.json. Not opening GUI as 'open' is false.`);
+                return null;
+            }
+            throw err;
+        }));
+        if (saves == null)
+            return -1;
+        const { newest, key } = latestAccountsKey(saves);
+        const accounts = saves[key];
+        if (!Array.isArray(accounts) || accounts.length === 0) {
+            if (depth >= 1)
+                throw new Error("No accounts found.");
+            if (!open) {
+                debug(`No users in saves.json found. Not opening GUI as 'open' is false.`);
+                return -1;
+            }
+            debug(`No users in saves.json found. Opening GUI.`);
+            yield onOpen();
+            return identifyAccount(username, bedrock, javaLoc, location, wantedCwd, depth + 1, open);
+        }
+        const helper = newest === 3 ? getV3Names(accounts) :
+            newest === 4 ? getV4Names(accounts) :
+                null;
+        if (!helper)
+            throw new Error(`Unsupported account version: ${newest}.`);
+        debug(`Available Bedrock users: ${helper.bedrockNames.length ? helper.bedrockNames.join(", ") : "None"}`);
+        debug(`Available Java users: ${helper.javaNames.length ? helper.javaNames.join(", ") : "None"}`);
+        const names = bedrock ? helper.bedrockNames : helper.javaNames;
+        const label = bedrock ? "Bedrock" : "Microsoft";
+        const exists = names.includes(username);
+        if (!exists) {
+            if (depth >= 1) {
+                if (names.length === 0)
+                    throw new Error(`No ${label} accounts found${bedrock ? " (even after opening GUI)" : ""}.`);
+                throw new Error(`No ${label} account saved with the account name ${username}.\nOptions: ${names.join(", ")}`);
+            }
+            if (!open) {
+                debug(`No ${label} account saved with the account name ${username}. Not opening GUI as 'open' is false.`);
+                return -1;
+            }
+            debug(`No ${label} account saved with the account name ${username}. Opening GUI.`);
+            yield onOpen();
+            return identifyAccount(username, bedrock, javaLoc, location, wantedCwd, depth + 1, open);
+        }
+        const idx = bedrock ? helper.findBedrockIndex(username) : helper.findJavaIndex(username);
+        return idx;
+    });
+}
+function configureGeyserConfig(pluginDir, localPort) {
+    const configPath = (0, path_1.join)(pluginDir, "Geyser/config.yml");
+    if (!(0, fs_1.existsSync)(configPath)) {
+        throw new Error("Geyser config not found.");
+    }
+    const config = (0, fs_1.readFileSync)(configPath, "utf-8");
+    const parsed = js_yaml_1.default.load(config);
+    parsed["bedrock"]["port"] = localPort;
+    const newConfig = js_yaml_1.default.dump(parsed);
+    (0, fs_1.writeFileSync)(configPath, newConfig);
+}
+//# sourceMappingURL=utils.js.map