patcher.ts

/**
 * This code is distributed under the CC-BY-NC 4.0 license:
 * https://creativecommons.org/licenses/by-nc/4.0/
 *
 * Original author: Luuxis
 * Fork author: Benjas333
 */

import { spawn } from 'child_process';
import fs from 'fs';
import path from 'path';
import { EventEmitter } from 'events';
import { getPathLibraries, getFileFromArchive } from '../utils/Index.js';

interface ForgePatcherOptions {
	path: string;
	loader: {
		type: string;
	};
}

interface Config {
	java: string;
	minecraft: string;
	minecraftJson: string;
}

interface ProfileData {
	client: string;
	[key: string]: any;
}

interface Processor {
	jar: string;
	args: string[];
	classpath: string[];
	sides?: string[];
}

export interface Profile {
	data: Record<string, ProfileData>;
	processors?: any[];
	libraries?: Array<{ name?: string }>; // The universal jar/libraries reference
	path?: string;
}

export default class ForgePatcher extends EventEmitter {
	private readonly options: ForgePatcherOptions;

	constructor(options: ForgePatcherOptions) {
		super();
		this.options = options;
	}

	public async patcher(profile: Profile, config: Config, neoForgeOld: boolean = true): Promise<void> {
		const { processors } = profile;

		for (const [_, processor] of Object.entries(processors)) {
			if (processor.sides && !processor.sides.includes('client')) continue;

			const jarInfo = getPathLibraries(processor.jar);
			const jarPath = path.resolve(this.options.path, 'libraries', jarInfo.path, jarInfo.name);

			const args = processor.args
				.map(arg => this.setArgument(arg, profile, config, neoForgeOld))
				.map(arg => this.computePath(arg));

			const classPaths = processor.classpath.map(cp => {
				const cpInfo = getPathLibraries(cp);
				return `"${path.join(this.options.path, 'libraries', cpInfo.path, cpInfo.name)}"`;
			});
			let mainClass: string | null = null;
			try {
				mainClass = await this.readJarManifest(jarPath);
			} catch (error) {
				this.emit('error', `Failed to read the JAR manifest: ${error.message || error}`);
				continue;
			}
			if (!mainClass) {
				this.emit('error', `Impossible to determine the main class in the JAR: ${jarPath}`);
				continue;
			}

			await new Promise<void>((resolve) => {
				const spawned = spawn(
					`"${path.resolve(config.java)}"`,
					[
						'-classpath',
						[`"${jarPath}"`, ...classPaths].join(path.delimiter),
						mainClass,
						...args
					],
					{ shell: true }
				);

				spawned.stdout.on('data', data => {
					this.emit('patch', data.toString('utf-8'));
				});

				spawned.stderr.on('data', data => {
					this.emit('patch', data.toString('utf-8'));
				});

				spawned.on('close', code => {
					if (code !== 0) this.emit('error', `Forge patcher exited with code: ${code}`);
					resolve();
				});
			});
		}
	}

	public check(profile: Profile): boolean {
		const { processors } = profile;
		let files: string[] = [];

		for (const processor of Object.values(processors)) {
			if (processor.sides && !processor.sides.includes('client')) continue;

			processor.args.forEach(arg => {
				const finalArg = arg.replace('{', '').replace('}', '');
				if (profile.data[finalArg]) {
					if (finalArg === 'BINPATCH') return;
					files.push(profile.data[finalArg].client);
				}
			});
		}

		files = Array.from(new Set(files));

		for (const file of files) {
			const lib = getPathLibraries(file.replace('[', '').replace(']', ''));
			const filePath = path.resolve(this.options.path, 'libraries', lib.path, lib.name);
			if (!fs.existsSync(filePath)) return false;
		}
		return true;
	}

	private setArgument(arg: string, profile: Profile, config: Config, neoForgeOld: boolean): string {
		const finalArg = arg.replace('{', '').replace('}', '');

		const universalLib = profile.libraries.find(lib => {
			if (this.options.loader.type === 'forge') return lib.name.startsWith('net.minecraftforge:forge');
			else return lib.name.startsWith(neoForgeOld ? 'net.neoforged:forge' : 'net.neoforged:neoforge');
		});

		if (profile.data[finalArg]) {
			if (finalArg === 'BINPATCH') {
				const jarInfo = getPathLibraries(profile.path || (universalLib?.name ?? ''));
				return `"${path.join(this.options.path, 'libraries', jarInfo.path, jarInfo.name).replace('.jar', '-clientdata.lzma')}"`;
			}
			return profile.data[finalArg].client;
		}

		return arg
			.replace('{SIDE}', 'client')
			.replace('{ROOT}', `"${path.dirname(path.resolve(this.options.path, 'forge'))}"`)
			.replace('{MINECRAFT_JAR}', `"${config.minecraft}"`)
			.replace('{MINECRAFT_VERSION}', `"${config.minecraftJson}"`)
			.replace('{INSTALLER}', `"${path.join(this.options.path, 'libraries')}"`)
			.replace('{LIBRARY_DIR}', `"${path.join(this.options.path, 'libraries')}"`);
	}

	private computePath(arg: string): string {
		if (arg.startsWith('[')) {
			const libInfo = getPathLibraries(arg.replace('[', '').replace(']', ''));
			return `"${path.join(this.options.path, 'libraries', libInfo.path, libInfo.name)}"`;
		}
		return arg;
	}

	private async readJarManifest(jarPath: string): Promise<string | null> {
		const manifestContent: any = await getFileFromArchive(jarPath, 'META-INF/MANIFEST.MF');
		if (!manifestContent) return null;

		const mainClassLine = manifestContent.toString().split('Main-Class: ')[1];
		if (!mainClassLine) return null;
		return mainClassLine.split('\r\n')[0];
	}
}