gdk-version-archiver 1.0.0-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ConMaster
+
+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,41 @@
+# GDK Version Archiver
+
+**NOTICE: THIS TOOL DOES NOT HELP YOU TO PIRATE THE GAME. YOU MUST OWN A LEGITIMATE COPY OF MINECRAFT TO USE THIS TOOL.**
+
+A CLI tool for archiving and managing Minecraft GDK installations on Windows. It captures current installations as mirrors and manages them using tags for easy version switching.
+
+- **Archive Versions**: Capture installed Appx packages to local mirrors.
+- **Tagging**: Use tags like `current` or `beta` to manage different versions. Default is `current` tag and is also hardcoded to always be used.
+- **Protected File Handling**: Automatically copies encrypted files via internal instructions.
+- **Concurrent Copying**: Fast archiving using a task concurrency channel.
+
+## Setup and Usage
+
+**Prerequisites**: Windows OS, [Bun](https://bun.sh/) runtime, and Powershell.
+
+```bash
+pnpm install
+npm run build
+```
+
+Binary name: `gdk-archive-manager`
+
+- **Archive**: `bunx gdk-archive-manager archive [package-pattern]`
+   - `--tag <name>`: Target tag (default: `current`).
+   - `--force`: Overwrite existing mirrors.
+   - `--concurrency <n>`: Parallel file copy limit. Default is `10`, recommended is to follow default value.
+- **List**: `bunx gdk-archive-manager list` - Show stored mirrors and tags.
+- **Run**: `bunx gdk-archive-manager run --tag <name>` - Launch a tagged version. Default is `current` tag.
+
+Global flags: `--verbose`, `--tag <name>`.
+
+## Storage and Mechanics
+
+Data is stored in `%APPDATA%\ConMaster.BedrockArchiver\clients\`.
+
+- `mirrors/`: Full version file structures.
+- `tags/`: Junctions pointing to specific mirrors.
+
+The tool bypasses GDK file protections by invoking a copy instruction within the package context. It then uses symlink junctions to allow external tools to reference a static path while the underlying version is updated.
+
+MIT License

package/bin/cli

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../dist/cli.js";

package/dist/cli.js

@@ -0,0 +1,1102 @@
+import { copyFile, mkdir, readFile, realpath, rm, rmdir, stat, symlink } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { exit } from "node:process";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+//#region node_modules/.pnpm/con-utils@0.0.2/node_modules/con-utils/dist/format-helper-CE23_M3S.js
+var FormatCode = class FormatCode$1 {
+	prefixes;
+	suffixes;
+	constructor(prefix, suffix) {
+		this.prefixes = prefix;
+		this.suffixes = suffix;
+	}
+	static create(format, reset) {
+		return new FormatCode$1([format], reset === void 0 ? [] : [reset]);
+	}
+	static createForegroundRGB(red, green, blue) {
+		return new FormatCode$1([
+			38,
+			2,
+			red,
+			green,
+			blue
+		], [39]);
+	}
+	static createBackgroundRGB(red, green, blue) {
+		return new FormatCode$1([
+			48,
+			2,
+			red,
+			green,
+			blue
+		], [49]);
+	}
+	get prefix() {
+		return this.compile(this.prefixes);
+	}
+	get suffix() {
+		return this.compile(this.suffixes);
+	}
+	compile(format) {
+		return `\x1b[${format.join(";")}m`;
+	}
+	merge(format) {
+		pushUnique([...this.prefixes], ...format.prefixes);
+		pushUnique([...this.suffixes], ...this.suffixes);
+		return new FormatCode$1(this.prefixes, this.suffixes);
+	}
+	get wrap() {
+		return (raw) => `${this.prefix}${raw}${this.suffix}`;
+	}
+	get format() {
+		return (template, ...args) => this.wrap(template.reduce((acc, part, i) => acc + this.wrap(part) + (args[i] ?? ""), ""));
+	}
+};
+const DIM$1 = FormatCode.create(2, 22);
+const ITALIC = FormatCode.create(3, 23);
+const UNDERLINE = FormatCode.create(4, 24);
+const INVERSE = FormatCode.create(7, 27);
+const CENSOR = FormatCode.create(8, 28);
+const CANCELED = FormatCode.create(9, 29);
+const SOFT_RESET = [
+	21,
+	22,
+	23,
+	24,
+	25,
+	27,
+	28,
+	29,
+	39,
+	49,
+	54,
+	55,
+	65
+].join(";");
+/**
+* Pushes value into array if it's not already present.
+* Returns true if inserted, false if already existed.
+*/
+function pushUnique(arr, ...values) {
+	for (const value of values) {
+		if (arr.includes(value)) continue;
+		arr.push(value);
+	}
+}
+var Format = class {
+	/**
+	* Wraps words in a string to fit within a specified print length.
+	* @param text The input string to wrap.
+	* @param printLength The maximum length of each line.
+	* @returns A generator yielding wrapped lines.
+	*/
+	static *wrapWords(text, printLength) {
+		const words = text.split(/\s+/);
+		const currentLineWords = [];
+		let currentLength = 0;
+		for (const word of words) {
+			const wordLength = word.length;
+			if (currentLength + wordLength + currentLineWords.length > printLength && currentLineWords.length > 0) {
+				yield currentLineWords.join(" ");
+				currentLineWords.length = 0;
+				currentLength = 0;
+			}
+			currentLineWords.push(word);
+			currentLength += wordLength;
+		}
+		if (currentLineWords.length > 0) yield currentLineWords.join(" ");
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/con-utils@0.0.2/node_modules/con-utils/dist/con-cli.js
+var ValueTypeValidator = class {
+	toString() {
+		return this.name;
+	}
+};
+const VALID_BOOLEAN_TYPES = new Set([
+	"false",
+	"true",
+	"0",
+	"1"
+]);
+var BooleanTypeValidator = class extends ValueTypeValidator {
+	name = "bool";
+	description = "Boolean Type (true/false)";
+	isValid(input) {
+		return VALID_BOOLEAN_TYPES.has(input.toLowerCase());
+	}
+	coerce(input) {
+		input = input.toLowerCase();
+		return input === "false" || input === "0" ? false : Boolean(input);
+	}
+};
+var NumberTypeValidator = class extends ValueTypeValidator {
+	name = "number";
+	description = "Floating point number type";
+	isValid(input) {
+		return !isNaN(Number(input));
+	}
+	coerce(input) {
+		return Number(input);
+	}
+};
+var StringTypeValidator = class extends ValueTypeValidator {
+	name = "string";
+	description = "Raw string type";
+	isValid(input) {
+		return typeof input === "string";
+	}
+	coerce(input) {
+		return input;
+	}
+};
+/**
+* Represents a command-line argument with validation and type coercion.
+* @template T - The type of the argument value after validation
+*/
+var ArgumentLike = class {
+	name;
+	validator;
+	description;
+	defaultValue;
+	constructor(name, opts) {
+		this.name = name.toLowerCase();
+		this.validator = opts.validator;
+		this.description = opts?.description ?? void 0;
+		this.defaultValue = opts.defaultValue;
+	}
+	/**
+	* Determines if this argument is required (has no default value).
+	* @returns True if the argument must be provided
+	*/
+	isRequired() {
+		return this.defaultValue === null;
+	}
+	/**
+	* Validates and coerces a string value to the argument's type.
+	* @param value - The string value to enforce
+	* @returns The coerced value of type T
+	* @throws {Error} If the value is invalid or required argument is missing
+	*/
+	enforce(value) {
+		if (value === void 0 || value === null) if (this.defaultValue === null) throw new Error("Following argument is required and can't be omitted! " + this.name);
+		else return this.defaultValue;
+		if (!this.validator.isValid(value)) throw new Error("Following argument has not valid value! " + this.name + " -> " + value);
+		return this.validator.coerce(value);
+	}
+	/**
+	* Returns a string representation of this argument for help text.
+	* @returns Formatted string like `<name:type>` or `[name:type]`
+	*/
+	toString() {
+		const $ = `${this.name}:${this.validator.toString()}`;
+		return this.isRequired() ? `<${$}>` : `[${$}]`;
+	}
+};
+/**
+* Represents a named flag that accepts a value.
+* @template T - The type of the flag value
+*/
+var ValueFlag = class extends ArgumentLike {
+	long;
+	short;
+	isValueFlag;
+	constructor(name, opts) {
+		super(name, opts);
+		this.long = opts.long?.toLowerCase();
+		this.short = opts.short?.toLowerCase();
+		this.isValueFlag = true;
+	}
+	/**
+	* Determines if this flag accepts a value.
+	* @returns True if this flag is value-based
+	*/
+	isValueBased() {
+		return this.isValueFlag;
+	}
+	/**
+	* Returns a string representation of this flag for help text.
+	* @returns Formatted string like `--long, -s`
+	*/
+	toString() {
+		return [this.long && `--${this.long}`, this.short && `-${this.short}`].filter(Boolean).join(", ");
+	}
+};
+/**
+* Represents a boolean flag (presence indicator).
+*/
+var Flag = class extends ValueFlag {
+	constructor(name, opts) {
+		const { description: description$1, long, short } = opts ?? {};
+		super(name, {
+			validator: new BooleanTypeValidator(),
+			defaultValue: false,
+			description: description$1,
+			long,
+			short
+		});
+		this.isValueFlag = false;
+	}
+};
+/**
+* A collection of flags with lookup capabilities by name, long form, or short form.
+*/
+var FlagsGroup = class {
+	flags = /* @__PURE__ */ new Set();
+	map = /* @__PURE__ */ new Map();
+	base = null;
+	constructor(base) {
+		this.base = base ?? null;
+	}
+	/**
+	* Checks if a flag exists in this group or inherited from base groups.
+	* @param valueFlag - The flag to check for
+	* @returns True if the flag is registered
+	*/
+	hasFlag(valueFlag) {
+		return this.hasOwnFlag(valueFlag) || (this.base?.hasFlag(valueFlag) ?? false);
+	}
+	/**
+	* Checks if a flag exists directly in this group (not inherited).
+	* @param valueFlag - The flag to check for
+	* @returns True if the flag is registered in this group
+	*/
+	hasOwnFlag(valueFlag) {
+		return this.flags.has(valueFlag);
+	}
+	/**
+	* Adds flags and registers their searchable keys.
+	* @param flags - The flags to add
+	* @returns This group for chaining
+	*/
+	add(...flags) {
+		for (const flag of flags) {
+			this.flags.add(flag);
+			this.setGeneralInternal(flag.name, flag);
+			if (flag.long) this.setLongInternal(flag.long, flag);
+			if (flag.short) this.setShortInternal(flag.short, flag);
+		}
+		return this;
+	}
+	/**
+	* Adds a short alias for an existing flag.
+	* @param flag - The flag to add an alias for
+	* @param short - The short form alias
+	* @returns This group for chaining
+	*/
+	addShortAlias(flag, short) {
+		this.flags.add(flag);
+		this.setGeneralInternal(flag.name, flag);
+		this.setShortInternal(short, flag);
+		return this;
+	}
+	/**
+	* Adds a long alias for an existing flag.
+	* @param flag - The flag to add an alias for
+	* @param long - The long form alias
+	* @returns This group for chaining
+	*/
+	addLongAlias(flag, long) {
+		this.flags.add(flag);
+		this.setGeneralInternal(flag.name, flag);
+		this.setLongInternal(long, flag);
+		return this;
+	}
+	setLongInternal(key, flag) {
+		this.map.set(`long:${key}`, flag);
+	}
+	setShortInternal(key, flag) {
+		this.map.set(`short:${key}`, flag);
+	}
+	setGeneralInternal(key, flag) {
+		this.map.set(`flag:${key}`, flag);
+	}
+	getLong(key) {
+		return this.map.get(`long:${key}`) ?? this.base?.getLong(key) ?? null;
+	}
+	/**
+	* Retrieves a flag by its short form name.
+	* @param key - The short form name
+	* @returns The flag or null if not found
+	*/
+	getShort(key) {
+		return this.map.get(`short:${key}`) ?? this.base?.getShort(key) ?? null;
+	}
+	/**
+	* Retrieves a flag by its primary name.
+	* @param name - The flag name
+	* @returns The flag or null if not found
+	*/
+	getByName(name) {
+		return this.map.get(`flag:${name}`) ?? this.base?.getByName(name) ?? null;
+	}
+	/**
+	* Gets all flags directly registered in this group.
+	* @returns A read-only set of all flags
+	*/
+	getAll() {
+		return this.flags;
+	}
+};
+const dim$1 = DIM$1.wrap;
+var CommandHelpStringBuilder = class {
+	static *buildHelp(command, preferredWidth$1) {
+		yield dim$1(` Usage of ${command.syntax()}`);
+		yield "";
+		yield dim$1("  " + "-".repeat(preferredWidth$1));
+		yield* Format.wrapWords(command.description ?? "", preferredWidth$1).map((e) => dim$1("   ") + e);
+		yield dim$1("  " + "-".repeat(preferredWidth$1));
+		yield "";
+		yield* this.buildFlags(command);
+		yield "";
+	}
+	static *buildFlags(command) {
+		yield dim$1("Flags:");
+		yield* command.flags.getAll().values().map((e) => "  " + e.toString().padEnd(20) + " " + dim$1(e.description ?? ""));
+	}
+};
+const dim = DIM$1.wrap;
+var Command = class {
+	parent;
+	uniqueHelpFlag;
+	name;
+	flags;
+	description;
+	onFlags;
+	constructor(name, description$1, parent = null) {
+		this.name = name.toLowerCase();
+		this.description = description$1 ?? "";
+		this.flags = new FlagsGroup(parent?.flags ?? null);
+		this.parent = parent;
+		this.uniqueHelpFlag = new Flag("help", {
+			description: "Show's help message",
+			short: "?",
+			long: "help"
+		});
+		this.flags.add(this.uniqueHelpFlag);
+		this.flags.addShortAlias(this.uniqueHelpFlag, "h");
+	}
+	getParentCommand() {
+		return this.parent ?? null;
+	}
+	*getHelp() {
+		yield* CommandHelpStringBuilder.buildHelp(this, preferredWidth);
+	}
+	*getFlags() {
+		yield dim("Flags:");
+		yield* this.flags.getAll().values().map((e) => "  " + e.toString().padEnd(20) + " " + dim(e.description ?? ""));
+	}
+	getFullPathName() {
+		return `${this.parent ? this.parent.getFullPathName() + " " : ""}${this.name}`;
+	}
+};
+var CommandAction = class CommandAction$1 extends Command {
+	argumentsTypes;
+	action = null;
+	constructor(name, opts) {
+		super(name, opts.description, opts.parent);
+		this.argumentsTypes = opts.argTypes;
+	}
+	*getHelp() {
+		yield* super.getHelp();
+		if (!this.argumentsTypes.length) return;
+		yield dim("  Arguments:");
+		yield* this.argumentsTypes.map((e) => `    ${e.toString().padEnd(20)} ${dim(e.description ?? "")}`);
+		yield "";
+	}
+	static create(name, description$1, parent, args) {
+		return new CommandAction$1(name, {
+			argTypes: args,
+			description: description$1,
+			parent
+		});
+	}
+	syntax() {
+		return `${this.getFullPathName()} ${this.argumentsTypes.map((e) => e.isRequired() ? `<${e.name}:${e.validator.name}>` : `[${e.name}:${e.validator.name}]`).join(" ")}`;
+	}
+};
+var GroupCommand = class GroupCommand$1 extends Command {
+	action = null;
+	subcommands = /* @__PURE__ */ new Map();
+	static create(name, description$1, parent) {
+		return new GroupCommand$1(name, description$1, parent);
+	}
+	createGroup(name, description$1) {
+		const cmd = GroupCommand$1.create(name, description$1, this);
+		this.subcommands.set(name, cmd);
+		return cmd;
+	}
+	createAction(name, description$1, args) {
+		const cmd = CommandAction.create(name, description$1, this, args);
+		this.subcommands.set(name, cmd);
+		return cmd;
+	}
+	syntax() {
+		return `${this.getFullPathName()} <${this.subcommands.keys().toArray().join("|")}>`;
+	}
+	*getHelp() {
+		yield* super.getHelp();
+		yield dim("  SubCommands:");
+		let p = preferredWidth - 25;
+		yield* this.subcommands.values().map((e) => `    ${e.name.padEnd(20)} ${dim((e.description?.length ?? 0) > p ? (e.description?.substring(0, p) ?? "") + "..." : e.description ?? "")}`);
+		yield "";
+	}
+};
+let preferredWidth = 75;
+/**
+* Represents the result of parsing a command-line input.
+* Contains the matched command, parsed arguments, and resolved flags.
+*/
+var ParseResult = class {
+	constructor(command, args, flags) {
+		this.command = command;
+		this.args = args;
+		this.flags = flags;
+	}
+	/**
+	* Gets the value of a flag, falling back to its default if not provided.
+	* @template T - The type of the flag value
+	* @param flag - The flag to retrieve
+	* @returns The flag value or its default value
+	*/
+	getValue(flag) {
+		return this.flags.get(flag) ?? flag.defaultValue;
+	}
+	/**
+	* Gets the executable function for this command if it's an action command.
+	* @returns The bound action function or null if this is a group command
+	*/
+	getExecutable() {
+		if ("action" in this.command && typeof this.command["action"] === "function") return this.command.action.bind(null, this, ...this.args);
+		return null;
+	}
+};
+/**
+* Error thrown during command-line parsing.
+* Contains context about where and why parsing failed.
+*/
+var ParserError = class extends Error {
+	command;
+	argv;
+	index;
+	flags;
+	constructor(command, message, argv, index, flags) {
+		super(message);
+		this.command = command;
+		this.name = new.target.name;
+		this.argv = argv;
+		this.index = index;
+		this.flags = flags ?? null;
+	}
+};
+/**
+* Parses command-line arguments into commands, flags, and positional arguments.
+*/
+var CommandsParser = class CommandsParser$1 {
+	argv;
+	index;
+	lastError = null;
+	constructor(argv, index) {
+		this.argv = argv;
+		this.index = index;
+	}
+	/**
+	* Parses the provided command against the command-line arguments.
+	* @param command - The command to parse
+	* @returns The parse result containing the matched command and parsed values
+	* @throws {ParserError} If parsing fails
+	*/
+	parse(command) {
+		if (command instanceof GroupCommand) return this.parseGroupCommand(command);
+		else if (command instanceof CommandAction) return this.parseActionCommand(command);
+		else throw new ParserError(command, "Unsupported command type", this.argv, this.index);
+	}
+	parseGroupCommand(command) {
+		const RESULT = new ParseResult(command, [], /* @__PURE__ */ new Map());
+		let argument = this.getArgument();
+		if (!argument) {
+			if (!command.action) throw new ParserError(command, `Expected subcommand name, received none: ${command.getFullPathName()}`, this.argv, this.index);
+			return new ParseResult(command, [], /* @__PURE__ */ new Map());
+		}
+		if (argument.startsWith("-")) {
+			while (argument = this.getArgument()) {
+				const flag = CommandsParser$1.parseFlag(argument);
+				if (!flag) break;
+				const result = this.resolveFlag(command.flags, flag, this.getArgument(1));
+				if (!result) if (this.getLastError()) throw new ParserError(command, this.getLastError(), this.argv, this.index, new Set(RESULT.flags.keys()));
+				else throw new ParserError(command, "Failed to resolve tag with name: " + flag.name, this.argv, this.index, new Set(RESULT.flags.keys()));
+				const { flag: FLAG_TYPE, nextValueUsed, value } = result;
+				this.index++;
+				if (nextValueUsed) this.index++;
+				RESULT.flags.set(FLAG_TYPE, value);
+			}
+			if (!argument) return RESULT;
+		}
+		const sub = argument.toLowerCase();
+		const cmd = command.subcommands.get(sub);
+		if (!cmd) throw new ParserError(command, `Unknown subcommand: ${command.getFullPathName()} >>${sub}<<`, this.argv, this.index, new Set(RESULT.flags.keys()));
+		this.index++;
+		try {
+			const HRESULT = this.parse(cmd);
+			for (const flag of RESULT.flags.keys()) if (!HRESULT.flags.has(flag)) HRESULT.flags.set(flag, RESULT.flags.get(flag));
+			return HRESULT;
+		} catch (error) {
+			if (error instanceof ParserError) {
+				const flags = error.flags;
+				if (flags) RESULT.flags.keys().forEach((_) => flags.add(_));
+				else error.flags = new Set(RESULT.flags.keys());
+			}
+			throw error;
+		}
+	}
+	parseActionCommand(command) {
+		const positionals = [];
+		let argument;
+		const FLAGS_MAP = /* @__PURE__ */ new Map();
+		while (argument = this.getArgument()) {
+			const flag = CommandsParser$1.parseFlag(argument);
+			this.index++;
+			if (!flag) {
+				positionals.push(argument);
+				continue;
+			}
+			const result = this.resolveFlag(command.flags, flag, this.getArgument());
+			if (!result) if (this.getLastError()) throw new ParserError(command, this.getLastError(), this.argv, this.index, new Set(FLAGS_MAP.keys()));
+			else {
+				positionals.push(argument);
+				continue;
+			}
+			const { flag: FLAG_TYPE, nextValueUsed, value } = result;
+			if (nextValueUsed) this.index++;
+			FLAGS_MAP.set(FLAG_TYPE, value);
+		}
+		const finalArgs = [];
+		for (let idx = 0; idx < command.argumentsTypes.length; idx++) {
+			const def = command.argumentsTypes[idx];
+			const posVal = positionals[idx];
+			if (typeof posVal === "undefined") {
+				if (def.isRequired()) throw new ParserError(command, `Missing required argument: ${command.getFullPathName()} ... ${def.toString()}`, this.argv, this.index, new Set(FLAGS_MAP.keys()));
+				finalArgs.push(def.defaultValue);
+			} else {
+				if (!def.validator.isValid(posVal)) throw new ParserError(command, `Invalid value: ${posVal}`, this.argv, this.index, new Set(FLAGS_MAP.keys()));
+				finalArgs.push(def.enforce(posVal));
+			}
+		}
+		for (let j = command.argumentsTypes.length; j < positionals.length; j++) finalArgs.push(positionals[j]);
+		return new ParseResult(command, finalArgs, FLAGS_MAP);
+	}
+	resolveFlag(group, flag, next) {
+		const FLAG_TYPE = flag.isLong ? group.getLong(flag.name) : group.getShort(flag.name);
+		if (!FLAG_TYPE) return this.setLastError(null);
+		let nextValueUsed = false;
+		if (FLAG_TYPE.isValueBased()) {
+			let { value } = flag;
+			if (value === null) {
+				nextValueUsed = true;
+				value = next;
+			}
+			if (value === null) {
+				if (FLAG_TYPE.defaultValue) return {
+					flag: FLAG_TYPE,
+					value: null,
+					nextValueUsed
+				};
+				return this.setLastError("Flag with no default value, requires value to be set explicitly, flag: " + flag.name);
+			}
+			if (!FLAG_TYPE.validator.isValid(value)) return this.setLastError("Incorrect type passed as value for flag: " + flag.name + " value: " + value);
+			return {
+				flag: FLAG_TYPE,
+				value: FLAG_TYPE.validator.coerce(value),
+				nextValueUsed
+			};
+		} else if (flag.value) return this.setLastError("Syntax error, this flag doesn't supports values: " + flag.name + " value: " + flag.value);
+		return {
+			flag: FLAG_TYPE,
+			value: true,
+			nextValueUsed
+		};
+	}
+	getLastError() {
+		return this.lastError;
+	}
+	setLastError(error) {
+		this.lastError = error;
+		return null;
+	}
+	getArgument(relative = 0) {
+		return this.argv[this.index + (relative ?? 0)] ?? null;
+	}
+	/**
+	* Parses a flag string into its components (name, type, and optional value).
+	* @param argument - The argument string to parse (e.g., "-f", "--flag=value")
+	* @returns The parsed flag result or null if the argument is not a flag
+	*/
+	static parseFlag(argument) {
+		if (argument.length < 2 || argument[0] !== "-") return null;
+		const isLongBit = argument[1] === "-", hasValueIndex = argument.indexOf("="), hasValueBit = hasValueIndex !== -1;
+		let name, value = hasValueBit ? argument.substring(hasValueIndex + 1) : null;
+		if (isLongBit) name = argument.substring(2, hasValueBit ? hasValueIndex : void 0);
+		else {
+			name = argument[1];
+			if (!value && argument.length > 2) value = argument.substring(2);
+		}
+		return {
+			name: name.toLowerCase(),
+			isLong: isLongBit,
+			value
+		};
+	}
+};
+/**
+* Main entry point for parsing and executing command-line arguments.
+* Handles parsing, flag resolution, and command execution with error handling.
+*/
+var CommandLine = class {
+	constructor() {}
+	/**
+	* Parses command-line arguments and executes the appropriate command.
+	* @param argv - The command-line arguments to parse (typically process.argv)
+	* @param command - The root command to parse against
+	* @throws {ParserError} If parsing fails or validation errors occur
+	*/
+	static async run(argv, command) {
+		const parser = new CommandsParser(argv, 2);
+		try {
+			const result = parser.parse(command);
+			if (result.flags.has(result.command.uniqueHelpFlag)) return void console.info(Array.from(result.command.getHelp()).join("\r\n"));
+			for (const flag of result.flags.keys()) for (let command$1 = result.command; command$1; command$1 = command$1.getParentCommand()) if (command$1.flags.hasOwnFlag(flag)) command$1.onFlags?.(result);
+			result.getExecutable()?.();
+			return;
+		} catch (err) {
+			if (err instanceof ParserError) {
+				if (!err.flags?.has(err.command.uniqueHelpFlag)) console.error(FormatCode.create(31, 39).wrap("->" + err.message));
+				console.error("\n", Array.from(err.command.getHelp()).join("\r\n"));
+			} else throw err;
+		}
+	}
+	/**
+	* Creates a new group command for organizing subcommands.
+	* @param name - The name of the command group
+	* @param description - A description of what this command group does
+	* @returns A new GroupCommand instance
+	*/
+	static createGroup(name, description$1) {
+		return GroupCommand.create(name, description$1, null);
+	}
+	/**
+	* Creates a new action command that executes a handler function.
+	* @template T - The tuple type of arguments the action accepts
+	* @param name - The name of the command
+	* @param description - A description of what this command does
+	* @param args - The argument definitions for this command
+	* @returns A new CommandAction instance
+	*/
+	static createAction(name, description$1, args) {
+		return CommandAction.create(name, description$1, null, args);
+	}
+};
+
+//#endregion
+//#region package.json
+var description = "";
+
+//#endregion
+//#region node_modules/.pnpm/con-utils@0.0.2/node_modules/con-utils/dist/general.js
+/**
+* Manages concurrent execution of tasks with a maximum concurrency limit.
+*/
+var TaskConcurrencyChannel = class {
+	/**
+	* Set of promises currently being tracked.
+	*/
+	stack = /* @__PURE__ */ new Set();
+	/**
+	* Maximum number of concurrent tasks allowed.
+	*/
+	concurrency;
+	/**
+	* Create a new TaskConcurrencyChannel.
+	* @param maxConcurrency The maximum number of tasks to run concurrently.
+	*/
+	constructor(maxConcurrency) {
+		this.concurrency = maxConcurrency;
+	}
+	/**
+	* Add a task to the queue. Waits if concurrency limit is reached.
+	* @param task The task to execute.
+	*/
+	async push(task) {
+		const promise = Promise.resolve(task).then((_) => void this.stack.delete(promise), (_) => void 0);
+		this.stack.add(promise);
+		if (this.stack.size >= this.concurrency) await Promise.any(this.stack);
+	}
+	/**
+	* Get a promise that resolves when all tasks complete.
+	* @returns A promise that resolves when the stack is empty.
+	*/
+	getAwaiter() {
+		return Promise.all(this.stack).then((_) => void 0);
+	}
+};
+
+//#endregion
+//#region src/logger.ts
+let LOG_ENABLED = false;
+const SET_VERBOSE = (value) => LOG_ENABLED = value;
+const rgb = FormatCode.createForegroundRGB;
+const INFO_CODE = rgb(80, 175, 199);
+const WARN_CODE = rgb(199, 133, 80);
+const E = rgb(199, 80, 96).wrap, I = INFO_CODE.wrap, W = WARN_CODE.wrap;
+const ACCENT = FormatCode.create(92, 39).wrap;
+const DIM = DIM$1.wrap;
+const OUTPUT = (raw) => process.stderr.write(raw);
+const LOG = (string) => void (LOG_ENABLED ? OUTPUT(DIM(`| ` + string)) : null);
+const INFO = (string) => void OUTPUT(I(`| ` + string));
+const WARN = (string) => void OUTPUT(W(`| ` + string));
+const ERROR = (string) => void OUTPUT(E(`| ` + string));
+
+//#endregion
+//#region src/constants.ts
+const { APPDATA, SAVE_DATA_PATH } = import.meta.env;
+if (!(SAVE_DATA_PATH || APPDATA)) {
+	console.error("Couldn't find path to store the mirrors");
+	exit(-1);
+}
+const DEFAULT_APPDATA_FOLDER_NAME = "ConMaster.BedrockArchiver";
+const PREFERRED_PATH = resolve(SAVE_DATA_PATH ?? join(APPDATA ?? ".", DEFAULT_APPDATA_FOLDER_NAME, "clients"));
+const MIRRORS_FOLDER_PATH = join(PREFERRED_PATH, "mirrors");
+const TAGS_FOLDER_PATH = join(PREFERRED_PATH, "tags");
+
+//#endregion
+//#region src/cli/root.ts
+const ROOT = CommandLine.createGroup(">.", description);
+const VERBOSE = new Flag("verbose", {
+	description: "Shows LOG messages",
+	long: "verbose"
+});
+const TAG = new ValueFlag("tag", {
+	defaultValue: "current",
+	description: "Environment Tag under this instance operates, archiving performs tag redirection of this name",
+	validator: new StringTypeValidator(),
+	long: "tag"
+});
+ROOT.flags.add(VERBOSE, TAG);
+ROOT.onFlags = (options) => {
+	if (options.getValue(VERBOSE)) SET_VERBOSE(true);
+};
+const ENVIRONMENT_INFO = (options) => {
+	LOG(`-----------------------\n`);
+	LOG(`DATA:  ${ACCENT(PREFERRED_PATH)}\n`);
+	LOG(`TAG:   ${ACCENT(options.getValue(TAG))} ${options.getValue(TAG) === TAG.defaultValue ? "(default)" : ""}\n`);
+	LOG(`-----------------------\n`);
+};
+
+//#endregion
+//#region src/cli/instruction.ts
+const INSTRUCTION = ROOT.createAction("instruction", "Internal use", [new ArgumentLike("data", {
+	defaultValue: null,
+	validator: new StringTypeValidator(),
+	description: "BASE64 Encoded data"
+})]);
+INSTRUCTION.action = async (_, base64) => {
+	let data;
+	try {
+		LOG(`Trying to transform BASE64 to string\n`);
+		const RAW = atob(base64);
+		LOG(`Parsing as JSON\n`);
+		data = JSON.parse(RAW);
+		LOG(`Checking data validity\n`);
+		if (!Array.isArray(data)) return void ERROR("INVALID INSTRUCTION FORMAT");
+		if (typeof data[0] !== "number" || !(data[0] in InstructionType)) return void ERROR("INVALID INSTRUCTION FORMAT");
+	} catch {
+		ERROR("INVALID INSTRUCTION FORMAT");
+		return;
+	}
+	switch (data[0]) {
+		case InstructionType.Copy:
+			if (!await copyFile(data[1], data[2]).then((_$1) => true, (_$1) => false)) {
+				setTimeout(() => null, 5e3);
+				ERROR("FAILED TO COPY THIS ITEM: " + data[1]);
+				return;
+			}
+			break;
+		default:
+			ERROR("Unknown instruction");
+			return;
+	}
+};
+let InstructionType = /* @__PURE__ */ function(InstructionType$1) {
+	InstructionType$1[InstructionType$1["Copy"] = 1] = "Copy";
+	return InstructionType$1;
+}({});
+function createCommand(...args) {
+	const [EXECUTABLE, SELF_CLI] = Bun.argv;
+	return [
+		EXECUTABLE,
+		SELF_CLI,
+		INSTRUCTION.name,
+		btoa(JSON.stringify(args))
+	];
+}
+
+//#endregion
+//#region src/pwsh-helper.ts
+var PowershellHelper = class PowershellHelper {
+	static POWERSHELL_EXECUTABLE = "powershell";
+	static async GetAppxPackage(packageNameLike) {
+		LOG(`Requesting Packages\n`);
+		let { output, exitCode } = await PowershellHelper.runRawCommand(`((Get-AppxPackage -Name ${packageNameLike}) | ForEach-Object { "$($_.PackageFamilyName);$($_.Version);$($_.InstallLocation)" })`);
+		if (exitCode != 0) return null;
+		LOG(`Parsing and Resoling Installation Paths\n`);
+		return output?.trim().split("\n").map((e) => {
+			const [PackageFamilyName, Version, InstallationPath] = e.trim().split(";");
+			return {
+				PackageFamilyName,
+				Version,
+				InstallationPath
+			};
+		}).filter((e) => e?.PackageFamilyName) ?? null;
+	}
+	static async runRawCommand(command) {
+		LOG(`Spawning PWSH command\n`);
+		const process$1 = Bun.spawn({
+			cmd: [
+				this.POWERSHELL_EXECUTABLE,
+				"-NoProfile",
+				"-NonInteractive",
+				"-Command",
+				command
+			],
+			stdout: "pipe",
+			stderr: "pipe",
+			stdin: "ignore"
+		});
+		LOG(`Waiting for exit\n`);
+		const stdout = await new Response(process$1.stdout).text();
+		const stderr = await new Response(process$1.stderr).text();
+		const code = await process$1.exited;
+		LOG(`PWSH Process exited with code: ${code}\n`);
+		return {
+			exitCode: code,
+			output: code === 0 ? stdout : stderr.length > 0 ? stderr : null
+		};
+	}
+	static async InvokeCommandInDesktopPackage(packageFamilyName, appId, executable, args) {
+		let cmd = `Invoke-CommandInDesktopPackage -PackageFamilyName ${packageFamilyName} -AppId ${appId} -Command ${JSON.stringify(executable)}`;
+		if (args.length > 0) cmd += ` -Args '${args.map((_) => `"${_}"`).join(" ")}'`;
+		await this.runRawCommand(cmd);
+	}
+};
+
+//#endregion
+//#region src/cli/archive.ts
+const RECURSIVE_GLOB = new Bun.Glob("**/*");
+const ARCHIVE = ROOT.createAction("archive", "Archive current version", [new ArgumentLike("package-name", {
+	defaultValue: "*minecraftuwp*",
+	validator: new StringTypeValidator(),
+	description: "Minecraft GDK Installation Package Name Pattern (*minecraftuwp*)"
+})]);
+const FORCE_TAG = new Flag("force", {
+	long: "force",
+	description: "Forces to overwrite archive folder if expected version is already archived."
+});
+const CONCURRENCY_TAG = new ValueFlag("concurrency", {
+	short: "c",
+	defaultValue: 10,
+	validator: new NumberTypeValidator(),
+	long: "concurrency",
+	description: "Forces to overwrite archive folder if expected version is already archived."
+});
+ARCHIVE.flags.add(FORCE_TAG, CONCURRENCY_TAG);
+ARCHIVE.action = async (_, packageName) => {
+	const isForced = _.getValue(FORCE_TAG);
+	INFO(`TARGET: ${ACCENT(packageName)}\n`);
+	INFO(`----------------------------\n`);
+	const data = await PowershellHelper.GetAppxPackage(packageName);
+	LOG(`Found ${data?.length ?? 0} matches. . .\n`);
+	if (!data || !data.length) return void ERROR("Failed to obtain installation\n");
+	const packageInfo = data[0];
+	if (!packageInfo) {
+		ERROR("FAILED TO RESOLVE PACKAGE\n");
+		ERROR(`Minecraft Package Not Found: Looking for preview? Run with *minecraftwindowsbeta*\n`);
+		return;
+	}
+	const { InstallationPath, PackageFamilyName, Version } = packageInfo;
+	if (!PackageFamilyName.toLowerCase().includes("minecraft")) return void ERROR(`Minecraft Package Not Found: Looking for preview? Run with *minecraftwindowsbeta*\n`);
+	LOG(`RESOLVING REAL PATH FOR: ${JSON.stringify(InstallationPath)}\n`);
+	LOG(`----------------------------\n`);
+	let path = await realpath(InstallationPath).catch((_$1) => null);
+	if (!path) {
+		ERROR("FAILED TO RESOLVE INSTALLATION PATH\n");
+		return;
+	}
+	INFO(`NAME:     ${ACCENT(PackageFamilyName)}\n`);
+	INFO(`VERSION:  ${ACCENT(realVersion(Version))}\n`);
+	INFO(`PATH:     ${ACCENT(toURL(path))}\n`);
+	const REAL_VERSION = realVersion(Version);
+	const appId = await getPackageApplicationId(path);
+	if (!appId) return void ERROR("FAILED TO GET APPLICATION ID");
+	INFO(`APPID:     ${ACCENT(appId)}\n`);
+	const isPreview = PackageFamilyName.toLowerCase().match(/beta|preview|candidate/)?.[0];
+	const name = `minecraft${isPreview ? "-" + isPreview : ""}_${REAL_VERSION}`;
+	ENVIRONMENT_INFO(_);
+	const ARCHIVE_FOLDER = join(MIRRORS_FOLDER_PATH, name);
+	let OLD_FILES;
+	const KNOWN_FOLDERS = /* @__PURE__ */ new Set();
+	const KNOWN_FILES = /* @__PURE__ */ new Set();
+	if (existsSync(ARCHIVE_FOLDER)) if (!isForced) return void ERROR("This version is already archived, if you are sure you can use --force tag to rewrite this version.\n");
+	else OLD_FILES = new Set(Array.from(RECURSIVE_GLOB.scanSync({
+		cwd: ARCHIVE_FOLDER,
+		dot: true,
+		absolute: false,
+		onlyFiles: true,
+		followSymlinks: false
+	})).map((e) => e.toLowerCase()));
+	else {
+		LOG(`Creating archive folder for this version, ${name}\n`);
+		if (!await mkdir(ARCHIVE_FOLDER, { recursive: true }).then((_$1) => true, (_$1) => false)) return void ERROR("Something went wrong when creating folder\n");
+		OLD_FILES = /* @__PURE__ */ new Set();
+	}
+	INFO(`Invoking external process to decrypt the main executable and move it to archive\n`);
+	const EXE_PATH = "Minecraft.Windows.exe";
+	const SRC_EXE_PATH = join(path, EXE_PATH);
+	const FINAL_EXE_PATH = join(ARCHIVE_FOLDER, EXE_PATH);
+	const [runtime, ...args] = createCommand(InstructionType.Copy, SRC_EXE_PATH, FINAL_EXE_PATH);
+	await PowershellHelper.InvokeCommandInDesktopPackage(PackageFamilyName, appId, runtime, args);
+	const startTime = performance.now();
+	await new Promise((res) => setTimeout(res, 1e3));
+	LOG(`ORIGINAL STATS\n`);
+	let { size } = await stat(SRC_EXE_PATH);
+	while (performance.now() - startTime > 15 * 1e3) {
+		LOG(`WAITING FOR NEW STATS TO MATCH ORIGINAL\n`);
+		await new Promise((res) => setTimeout(res, 3e3));
+		if ((await stat(FINAL_EXE_PATH).catch((_$1) => null))?.size === size) break;
+	}
+	INFO(`Successfully copied encrypted file: ${EXE_PATH}\n`);
+	KNOWN_FILES.add(EXE_PATH.toLowerCase());
+	const concurrency = _.getValue(CONCURRENCY_TAG);
+	if (concurrency < 1) WARN(`Concurrency can not be less than 1!!!\n`);
+	const channel = new TaskConcurrencyChannel(concurrency);
+	let failedFiles = [];
+	const FILTER = /(gamelaunchhelper.exe|layout.xml|layout_[^.\\\/]+.xml|minecraft.windows.exe)$/;
+	let files = 0;
+	for await (const file of RECURSIVE_GLOB.scan({
+		cwd: path,
+		absolute: false,
+		dot: true,
+		followSymlinks: false,
+		onlyFiles: true
+	})) {
+		files++;
+		if (FILTER.test(file.toLowerCase())) continue;
+		let lio = file.lastIndexOf("\\");
+		const folder = file.substring(0, lio);
+		if (lio > 0 && !KNOWN_FOLDERS.has(folder)) {
+			const ABSOLUTE_FOLDER = join(ARCHIVE_FOLDER, folder);
+			INFO(`\x1b[36m${folder}\n`);
+			if (!existsSync(ABSOLUTE_FOLDER) && !await mkdir(join(ARCHIVE_FOLDER, folder), { recursive: true }).then((_$1) => true, (_$1) => false)) return void ERROR(`FAILED TO CREATE FOLDER IN ARCHIVE PATHS, MAYBE ITS TOO LONG? ${ARCHIVE_FOLDER.length + folder.length + 1}, ${folder}\n`);
+			KNOWN_FOLDERS.add(folder);
+		}
+		await channel.push((async () => {
+			if (!await copyFile(join(path, file), join(ARCHIVE_FOLDER, file)).then((_$1) => true, (_$1) => false)) failedFiles.push(file);
+			else KNOWN_FILES.add(file.toLowerCase());
+		})());
+	}
+	await channel.getAwaiter();
+	if (failedFiles.length) {
+		ERROR(`Something went wrong when coping these specific files: \n${failedFiles.join("\n")}\n`);
+		return;
+	}
+	if (isForced) WARN(`FILES TO REMOVE: ${OLD_FILES.difference(KNOWN_FILES).size}\n`);
+	for (const file of OLD_FILES.difference(KNOWN_FILES)) {
+		WARN(`Removing ${ACCENT(file)}\n`);
+		await channel.push(rm(join(ARCHIVE_FOLDER, file)));
+	}
+	await channel.getAwaiter();
+	INFO(`TOTAL FILES ARCHIVED: ${ACCENT(String(files))}\n`);
+	const tags = [_.getValue(TAG).toLowerCase()];
+	if (tags[0] !== TAG.defaultValue) tags.push(TAG.defaultValue?.toLowerCase() ?? "current");
+	for (let tag of tags) {
+		tag = join(TAGS_FOLDER_PATH, tag);
+		LOG(`REMOVING OLD TAG: ${tag}\n`);
+		await rmdir(tag).catch((_$1) => null);
+		LOG(`CREATING NEW TAG: ${_.getValue(TAG).toLowerCase()}\n`);
+		await symlink(ARCHIVE_FOLDER, tag, "junction").catch((_$1) => null);
+	}
+	INFO(`OUTPUT: ${ACCENT(pathToFileURL(join(TAGS_FOLDER_PATH, tags[0])).href)}\n`);
+};
+function realVersion(version) {
+	const [MA = 1, MI = 0, B = 0, P = 0] = version.split(".").map(Number);
+	return [
+		MA,
+		MI,
+		Math.floor(B / 100),
+		P + B % 100
+	].join(".");
+}
+function toURL(path) {
+	return `file:///${encodeURI(path.replaceAll("\\", "/"))}`;
+}
+async function getPackageApplicationId(installationPath) {
+	LOG(`Trying to read file: /AppxManifest.xml\n`);
+	return await readFile(join(installationPath, "AppxManifest.xml")).then((_) => {
+		LOG(`Trying to search for application id\n`);
+		const id = _.toString().match(/<Application(?:\s+[^>]*)??\s+Id\s*=\s*["']([^"']+)["']/is)?.[1];
+		if (!id) {
+			LOG(`FAILED TO SEARCH APPLICATION ID`);
+			return null;
+		}
+		return id;
+	}).catch((_) => (LOG(`FAILED TO READ FILE OR FAILED TO SEARCH FOR APPLICATION ID`), null));
+}
+
+//#endregion
+//#region src/cli/list.ts
+const LIST = ROOT.createAction("list", "List your installations", []);
+LIST.action = async (_) => {
+	ENVIRONMENT_INFO(_);
+	INFO(`----------------------------\n`);
+	INFO(`MIRRORS:\n`);
+	for await (const folder of new Bun.Glob("*").scan({
+		cwd: PREFERRED_PATH + "\\mirrors",
+		onlyFiles: false
+	})) INFO(`  ${ACCENT(folder)}\n`);
+	INFO(`\n`);
+	INFO(`TAGS:\n`);
+	for await (const folder of new Bun.Glob("*").scan({
+		cwd: PREFERRED_PATH + "\\tags",
+		onlyFiles: false
+	})) INFO(`  ${ACCENT(folder)}\n`);
+	INFO(`\n`);
+	INFO(`----------------------------\n`);
+};
+
+//#endregion
+//#region src/cli/run.ts
+const RUN = ROOT.createAction("run", "Start new minecraft instance from tag or mirror version id", [new ArgumentLike("package-name", {
+	defaultValue: "",
+	validator: new StringTypeValidator(),
+	description: "Minecraft GDK Installation Mirror Id if empty then tag is used"
+})]);
+RUN.action = async (_, packageName) => {
+	ENVIRONMENT_INFO(_);
+	Bun.spawn({
+		cmd: [TAGS_FOLDER_PATH + "\\" + _.getValue(TAG) + "\\Minecraft.Windows.exe"],
+		detached: true,
+		stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		]
+	}).unref();
+};
+
+//#endregion
+//#region src/cli/main.ts
+CommandLine.run(Bun.argv, ROOT);
+
+//#endregion

package/package.json

@@ -0,0 +1,38 @@
+{
+   "name": "gdk-version-archiver",
+   "version": "1.0.0-alpha",
+   "description": "",
+   "keywords": [],
+   "license": "MIT",
+   "author": "conmaster2112",
+   "bin": {
+      "gdkva": "./bin/cli"
+   },
+   "files": [
+      "bin/cli",
+      "dist/*",
+      "package.json",
+      "README.md",
+      "LICENSE"
+   ],
+   "type": "module",
+   "scripts": {
+      "build": "rolldown -c",
+      "gdk-archive-manager": "rolldown -c && bun ./dist/cli.js"
+   },
+   "devDependencies": {
+      "@types/bun": "^1.3.5",
+      "@typescript/native-preview": "7.0.0-dev.20260108.1",
+      "con-utils": "^0.0.2",
+      "oxfmt": "^0.23.0",
+      "oxlint": "^1.38.0",
+      "rolldown": "1.0.0-beta.59",
+      "rolldown-plugin-dts": "^0.20.0",
+      "typescript": "6.0.0-dev.20260108"
+   },
+   "engines": {
+      "bun": ">=1.0.0",
+      "node": "please-use-bun"
+   },
+   "packageManager": "pnpm@10.25.0"
+}