amule-ec-client 0.5.1 → 0.6.0

package/dist/index.mjs

@@ -0,0 +1,1077 @@
+import { n as Packet, r as Flags, t as Request } from "./Request-C0UUuQIX.mjs";
+import { a as EcPrefs, i as ECTagName, n as ECOpCode, o as ProtocolVersion, r as ECSearchType, t as ECDetailLevel } from "./Codes-CjiW7Pdl.mjs";
+import { a as StringTag, c as UInt128Tag, d as UShortTag, f as findNumericTag, i as Ipv4Tag, l as UIntTag, n as DoubleTag, o as Tag, r as Hash16Tag, s as UByteTag, t as CustomTag, u as ULongTag } from "./Tag-CZF6BRMY.mjs";
+import { n as PARTSIZE, t as ChunkStatus } from "./download-details-OM0FJUhZ.mjs";
+import * as net from "net";
+import * as zlib from "zlib";
+import * as crypto from "crypto";
+//#region src/exceptions/index.ts
+var AmuleException = class extends Error {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "AmuleException";
+	}
+};
+var InvalidECException = class extends AmuleException {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "InvalidECException";
+	}
+};
+var CommunicationException = class extends AmuleException {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "CommunicationException";
+	}
+};
+var ServerException = class extends AmuleException {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ServerException";
+	}
+};
+//#endregion
+//#region src/ec/Encoding.ts
+/**
+* Reads a UTF-8 encoded number from a buffer
+* Treats UTF-8 bytes as a Unicode code point and returns the numeric value
+*/
+function readUtf8Number(buffer, offset) {
+	const firstByte = buffer[offset];
+	let length;
+	if ((firstByte & 128) === 0) length = 1;
+	else if ((firstByte & 224) === 192) length = 2;
+	else if ((firstByte & 240) === 224) length = 3;
+	else if ((firstByte & 248) === 240) length = 4;
+	else throw new Error(`Invalid UTF-8 first byte: 0x${firstByte.toString(16)}`);
+	const codePoint = buffer.subarray(offset, offset + length).toString("utf-8").codePointAt(0);
+	if (codePoint === void 0) throw new Error("Failed to decode UTF-8 number");
+	return {
+		value: BigInt(codePoint),
+		newOffset: offset + length
+	};
+}
+/**
+* Encodes a number as UTF-8 code point
+* Treats the number as a Unicode code point and encodes it as UTF-8
+*/
+function encodeUtf8Number(value) {
+	const num = Number(value);
+	const str = String.fromCodePoint(num);
+	return Buffer.from(str, "utf-8");
+}
+/**
+* Gets the number of bytes needed to encode a value as UTF-8 code point
+*/
+function numberLength(value) {
+	const num = Number(value);
+	if (num < 128) return 1;
+	else if (num < 2048) return 2;
+	else if (num < 65536) return 3;
+	else if (num < 1114112) return 4;
+	else throw new Error(`Code point out of range: ${num}`);
+}
+//#endregion
+//#region src/ec/tag/TagParser.ts
+const TAG_NAME_SIZE = 2;
+const TAG_TYPE_SIZE = 1;
+const TAG_LENGTH_SIZE = 4;
+const SUBTAG_COUNT_SIZE = 2;
+var TagParser = class {
+	buffer;
+	offset;
+	useUtf8Numbers;
+	constructor(buffer, offset = 0, useUtf8Numbers = false) {
+		this.buffer = buffer;
+		this.offset = offset;
+		this.useUtf8Numbers = useUtf8Numbers;
+	}
+	/**
+	* Parse a single tag from the current position
+	*/
+	parseTag() {
+		return this.parseTagWithMetadata().tag;
+	}
+	/**
+	* Internal parse that returns metadata needed for nested tag calculation
+	*/
+	parseTagWithMetadata() {
+		const tagNameAndSubtags = this.readNumber(TAG_NAME_SIZE);
+		const tagName = tagNameAndSubtags >> 1 & 65535;
+		const hasSubtags = (tagNameAndSubtags & 1) !== 0;
+		const tagType = this.buffer.readUInt8(this.offset);
+		this.offset += TAG_TYPE_SIZE;
+		const tagLength = this.readNumber(TAG_LENGTH_SIZE);
+		let valueStartIndex = this.offset;
+		const subTags = [];
+		let theoreticalLength = 0;
+		let valueEndIndex;
+		if (!hasSubtags) valueEndIndex = valueStartIndex + tagLength - 1;
+		else {
+			const subTagCount = this.readNumber(SUBTAG_COUNT_SIZE);
+			valueStartIndex = this.offset;
+			for (let i = 0; i < subTagCount; i++) {
+				const result = this.parseTagWithMetadata();
+				subTags.push(result.tag);
+				theoreticalLength += result.theoreticalLength;
+			}
+			if (subTags.length > subTagCount) throw new InvalidECException(`Error parsing subtags list - Expected subtags ${subTagCount} found subtags ${subTags.length}`);
+			valueEndIndex = this.offset + (tagLength - theoreticalLength - 1);
+			theoreticalLength += SUBTAG_COUNT_SIZE;
+		}
+		const valueSize = valueEndIndex - this.offset + 1;
+		const tagValue = this.buffer.subarray(this.offset, this.offset + valueSize);
+		this.offset += valueSize;
+		theoreticalLength += tagValue.length;
+		theoreticalLength += TAG_NAME_SIZE;
+		theoreticalLength += TAG_TYPE_SIZE;
+		theoreticalLength += TAG_LENGTH_SIZE;
+		const tag = this.createTagFromValue(tagName, tagType, tagValue);
+		if (subTags.length > 0) tag.nestedTags = subTags;
+		return {
+			tag,
+			theoreticalLength,
+			endIndex: this.offset - 1
+		};
+	}
+	/**
+	* Parse multiple tags
+	*/
+	parseTags(count) {
+		const tags = [];
+		for (let i = 0; i < count; i++) tags.push(this.parseTag());
+		return tags;
+	}
+	/**
+	* Read a number with the given fixed size.
+	* In UTF-8 mode, reads as UTF-8 codepoint. Otherwise reads as big-endian integer.
+	*/
+	readNumber(fixedSize) {
+		if (this.useUtf8Numbers) {
+			const result = readUtf8Number(this.buffer, this.offset);
+			this.offset = result.newOffset;
+			return Number(result.value);
+		} else {
+			let value;
+			switch (fixedSize) {
+				case 1:
+					value = this.buffer.readUInt8(this.offset);
+					break;
+				case 2:
+					value = this.buffer.readUInt16BE(this.offset);
+					break;
+				case 4:
+					value = this.buffer.readUInt32BE(this.offset);
+					break;
+				default: throw new InvalidECException(`Unsupported number size: ${fixedSize}`);
+			}
+			this.offset += fixedSize;
+			return value;
+		}
+	}
+	/**
+	* Create a tag instance based on type and raw value bytes
+	*/
+	createTagFromValue(name, type, value) {
+		switch (type) {
+			case 1: return new CustomTag(name, value);
+			case 2: return new UByteTag(name, value.length > 0 ? value.readUInt8(0) : 0);
+			case 3: return new UShortTag(name, value.length >= 2 ? value.readUInt16BE(0) : 0);
+			case 4: return new UIntTag(name, value.length >= 4 ? value.readUInt32BE(0) : 0);
+			case 5: return new ULongTag(name, value.length >= 8 ? value.readBigUInt64BE(0) : 0n);
+			case 10: return new UInt128Tag(name, value.length >= 16 ? this.parseUInt128(value) : 0n);
+			case 6: return new StringTag(name, value[value.length - 1] === 0 ? value.toString("utf-8", 0, value.length - 1) : value.toString("utf-8"));
+			case 7: return new DoubleTag(name, value.length >= 8 ? value.readDoubleBE(0) : 0);
+			case 8: {
+				if (value.length !== 6) throw new InvalidECException(`Ipv4Tag value must be 6 bytes long, got ${value.length}`);
+				const address = `${value[0]}.${value[1]}.${value[2]}.${value[3]}`;
+				const port = value.readUInt16BE(4);
+				const tag = new Ipv4Tag(name);
+				tag["value"] = {
+					address,
+					port
+				};
+				return tag;
+			}
+			case 9: return new Hash16Tag(name, value);
+			default: throw new InvalidECException(`Unknown tag type: ${type} for tag ${name}`);
+		}
+	}
+	parseUInt128(value) {
+		if (value.length < 16) throw new InvalidECException(`UInt128 value must be at least 16 bytes long, got ${value.length}`);
+		return value.readBigUInt64BE(0) << 64n | value.readBigUInt64BE(8);
+	}
+	/**
+	* Get current offset
+	*/
+	getOffset() {
+		return this.offset;
+	}
+};
+//#endregion
+//#region src/ec/packet/PacketParser.ts
+/**
+* Packet Parser - Deserializes EC packets from binary data
+*/
+var PacketParser = class {
+	static HEADER_SIZE = 8;
+	/**
+	* Parse a packet from a buffer
+	*/
+	static parse(buffer) {
+		if (buffer.length < this.HEADER_SIZE) throw new InvalidECException(`Buffer too small: ${buffer.length} bytes`);
+		const flags = Flags.fromBuffer(buffer, 0);
+		const dataLength = buffer.readUInt32BE(4);
+		if (buffer.length < this.HEADER_SIZE + dataLength) throw new InvalidECException(`Incomplete packet: expected ${this.HEADER_SIZE + dataLength} bytes, got ${buffer.length}`);
+		let data = buffer.subarray(this.HEADER_SIZE, this.HEADER_SIZE + dataLength);
+		if (flags.isZlib()) data = this.decompress(data);
+		return this.parsePacketData(data, flags);
+	}
+	/**
+	* Parse packet data (after decompression)
+	*/
+	static parsePacketData(data, flags) {
+		let offset = 0;
+		const opCode = data.readUInt8(offset);
+		offset += 1;
+		const useUtf8 = flags.isUtf8Numbers();
+		let tagCount;
+		if (useUtf8) {
+			tagCount = data.readUInt8(offset);
+			offset += 1;
+		} else {
+			tagCount = data.readUInt16BE(offset);
+			offset += 2;
+		}
+		return new Packet(opCode, flags, new TagParser(data, offset, useUtf8).parseTags(tagCount));
+	}
+	/**
+	* Decompress ZLIB data
+	*/
+	static decompress(data) {
+		try {
+			return zlib.inflateSync(data);
+		} catch (error) {
+			throw new InvalidECException(`Failed to decompress packet: ${error}`);
+		}
+	}
+	/**
+	* Calculate expected packet size from header
+	*/
+	static getExpectedPacketSize(headerBuffer) {
+		if (headerBuffer.length < this.HEADER_SIZE) throw new InvalidECException("Header buffer too small");
+		const dataLength = headerBuffer.readUInt32BE(4);
+		return this.HEADER_SIZE + dataLength;
+	}
+	/**
+	* Check if buffer contains a complete packet
+	*/
+	static hasCompletePacket(buffer) {
+		if (buffer.length < this.HEADER_SIZE) return false;
+		const expectedSize = this.getExpectedPacketSize(buffer);
+		return buffer.length >= expectedSize;
+	}
+};
+//#endregion
+//#region src/ec/tag/TagEncoder.ts
+var TagEncoder = class {
+	useUtf8Numbers;
+	constructor(useUtf8Numbers = false) {
+		this.useUtf8Numbers = useUtf8Numbers;
+	}
+	/**
+	* Calculate total size needed for a tag (Physical Buffer Size)
+	*/
+	calculateTagSize(tag) {
+		let size = 0;
+		if (this.useUtf8Numbers) {
+			const hasSubtags = (tag.nestedTags?.length ?? 0) > 0 ? 1 : 0;
+			const nameAndSubtags = (tag.name & 65535) << 1 | hasSubtags;
+			size += numberLength(nameAndSubtags);
+		} else size += 2;
+		size += 1;
+		const reportedLength = this.calculateReportedLength(tag);
+		if (this.useUtf8Numbers) size += numberLength(reportedLength);
+		else size += 4;
+		if ((tag.nestedTags?.length ?? 0) > 0) {
+			const nestedCount = tag.nestedTags?.length ?? 0;
+			if (this.useUtf8Numbers) size += numberLength(nestedCount);
+			else size += 2;
+		}
+		if (tag.nestedTags) for (const nestedTag of tag.nestedTags) size += this.calculateTagSize(nestedTag);
+		size += this.calculateValueSize(tag);
+		return size;
+	}
+	/**
+	* Calculate the "Reported Length" of the tag content.
+	* This logic mimics Jamule's computeTagLength, which assumes FIXED header sizes
+	* (2 bytes name, 1 byte type, 4 bytes length, 2 bytes subtag count)
+	* even when UTF-8 encoding is used.
+	*/
+	calculateReportedLength(tag) {
+		let length = 0;
+		if (tag.nestedTags) for (const nestedTag of tag.nestedTags) {
+			length += this.calculateReportedLength(nestedTag);
+			length += 7;
+			if ((nestedTag.nestedTags?.length ?? 0) > 0) length += 2;
+		}
+		length += this.calculateValueSize(tag);
+		return length;
+	}
+	/**
+	* Calculate size of tag value
+	*/
+	calculateValueSize(tag) {
+		const encoded = tag.encodeValue();
+		switch (tag.type) {
+			case 1:
+				if (encoded.length === 0) return 0;
+				return encoded.length;
+			case 6: return encoded.length;
+			case 2: return 1;
+			case 3: return 2;
+			case 4: return 4;
+			case 5: return 8;
+			case 10: return 16;
+			case 7: return 8;
+			case 8: return 6;
+			case 9: return 16;
+			default: return 0;
+		}
+	}
+	/**
+	* Encode a tag to a buffer
+	*/
+	encodeTag(tag, buffer, offset) {
+		let currentOffset = offset;
+		const hasSubtags = (tag.nestedTags?.length ?? 0) > 0 ? 1 : 0;
+		const nameAndSubtags = (tag.name & 65535) << 1 | hasSubtags;
+		if (this.useUtf8Numbers) {
+			const encoded = encodeUtf8Number(nameAndSubtags);
+			encoded.copy(buffer, currentOffset);
+			currentOffset += encoded.length;
+		} else {
+			buffer.writeUInt16BE(nameAndSubtags, currentOffset);
+			currentOffset += 2;
+		}
+		buffer.writeUInt8(tag.type, currentOffset);
+		currentOffset += 1;
+		const tagLength = this.calculateReportedLength(tag);
+		if (this.useUtf8Numbers) {
+			const encoded = encodeUtf8Number(tagLength);
+			encoded.copy(buffer, currentOffset);
+			currentOffset += encoded.length;
+		} else {
+			buffer.writeUInt32BE(tagLength, currentOffset);
+			currentOffset += 4;
+		}
+		const nestedCount = tag.nestedTags?.length ?? 0;
+		if (hasSubtags) if (this.useUtf8Numbers) {
+			const encoded = encodeUtf8Number(nestedCount);
+			encoded.copy(buffer, currentOffset);
+			currentOffset += encoded.length;
+		} else {
+			buffer.writeUInt16BE(nestedCount, currentOffset);
+			currentOffset += 2;
+		}
+		if (tag.nestedTags) for (const nestedTag of tag.nestedTags) currentOffset = this.encodeTag(nestedTag, buffer, currentOffset);
+		currentOffset = this.encodeValue(tag, buffer, currentOffset);
+		return currentOffset;
+	}
+	/**
+	* Encode tag value to buffer
+	*/
+	encodeValue(tag, buffer, offset) {
+		const encoded = tag.encodeValue();
+		switch (tag.type) {
+			case 1:
+				if (encoded.length > 0) {
+					encoded.copy(buffer, offset);
+					return offset + encoded.length;
+				}
+				return offset;
+			case 2:
+			case 3:
+			case 4:
+			case 5:
+			case 6:
+			case 7:
+			case 8:
+			case 9:
+			case 10:
+				encoded.copy(buffer, offset);
+				return offset + encoded.length;
+			default: return offset;
+		}
+	}
+	/**
+	* Encode multiple tags
+	*/
+	encodeTags(tags) {
+		let totalSize = 0;
+		for (const tag of tags) totalSize += this.calculateTagSize(tag);
+		const buffer = Buffer.allocUnsafe(totalSize);
+		let offset = 0;
+		for (const tag of tags) offset = this.encodeTag(tag, buffer, offset);
+		return buffer;
+	}
+};
+//#endregion
+//#region src/ec/packet/PacketWriter.ts
+/**
+* Packet Writer - Serializes EC packets to binary data
+*/
+var PacketWriter = class {
+	static HEADER_SIZE = 8;
+	/**
+	* Write a packet to a buffer
+	*/
+	static write(packet) {
+		const useUtf8 = packet.flags.isUtf8Numbers();
+		const useZlib = packet.flags.isZlib();
+		let data = this.encodePacketData(packet, useUtf8);
+		if (useZlib) data = this.compress(data);
+		const buffer = Buffer.allocUnsafe(this.HEADER_SIZE + data.length);
+		packet.flags.writeToBuffer(buffer, 0);
+		buffer.writeUInt32BE(data.length, 4);
+		data.copy(buffer, this.HEADER_SIZE);
+		return buffer;
+	}
+	/**
+	* Encode packet data (before compression)
+	*/
+	static encodePacketData(packet, useUtf8) {
+		const encoder = new TagEncoder(useUtf8);
+		let size = 1;
+		if (useUtf8) {
+			const countBuf = encodeUtf8Number(packet.tags.length);
+			size += countBuf.length;
+		} else size += 2;
+		for (const tag of packet.tags) size += encoder.calculateTagSize(tag);
+		const buffer = Buffer.allocUnsafe(size);
+		let offset = 0;
+		buffer.writeUInt8(packet.opCode, offset);
+		offset += 1;
+		if (useUtf8) {
+			const countBuf = encodeUtf8Number(packet.tags.length);
+			countBuf.copy(buffer, offset);
+			offset += countBuf.length;
+		} else {
+			buffer.writeUInt16BE(packet.tags.length, offset);
+			offset += 2;
+		}
+		for (const tag of packet.tags) offset = encoder.encodeTag(tag, buffer, offset);
+		return buffer;
+	}
+	/**
+	* Compress data with ZLIB
+	*/
+	static compress(data) {
+		return zlib.deflateSync(data, { level: zlib.constants.Z_BEST_COMPRESSION });
+	}
+};
+//#endregion
+//#region src/request/AuthRequest.ts
+/**
+* Auth Request - Send client info to initiate authentication
+*/
+var AuthClientInfoRequest = class extends Request {
+	constructor(clientName = "amule-ts-client", clientVersion = "1.0.0") {
+		super(2);
+		this.addTag(new StringTag(256, clientName));
+		this.addTag(new StringTag(257, clientVersion));
+		this.addTag(new UShortTag(2, 516));
+		this.addTag(new CustomTag(12, Buffer.alloc(0)));
+		this.addTag(new CustomTag(13, Buffer.alloc(0)));
+	}
+};
+/**
+* Auth Password Request - Send hashed password after receiving salt
+*/
+var AuthPasswordRequest = class extends Request {
+	constructor(hashedPassword) {
+		super(80);
+		this.addTag(new Hash16Tag(1, hashedPassword));
+	}
+};
+//#endregion
+//#region src/response/AuthSaltResponse.ts
+var AuthSaltResponse = class AuthSaltResponse {
+	salt;
+	constructor(salt) {
+		this.salt = salt;
+	}
+	static fromPacket(packet) {
+		const saltTag = findNumericTag(packet.tags, 11);
+		if (!saltTag) throw new InvalidECException("Missing salt tag in auth salt response");
+		return new AuthSaltResponse(saltTag.getLong());
+	}
+};
+//#endregion
+//#region src/auth/PasswordHasher.ts
+/**
+* Password Hasher for aMule EC authentication
+*/
+var PasswordHasher = class {
+	/**
+	* Hash a password with salt using MD5
+	*
+	* This matches aMule's password hashing algorithm (from jamule):
+	* 1. saltHash = MD5(salt.toHexString().uppercase())
+	* 2. passwordHash = MD5(password)
+	* 3. return MD5(passwordHash.toHex().lowercase() + saltHash.toHex().lowercase())
+	*
+	* @param password The password to hash
+	* @param salt The salt received from the server
+	* @returns The hashed password as a Buffer
+	*/
+	static hash(password, salt) {
+		const saltHexUpper = salt.toString(16).toUpperCase().padStart(16, "0");
+		const saltHash = crypto.createHash("md5").update(saltHexUpper, "utf-8").digest();
+		const passwordHashHex = crypto.createHash("md5").update(password, "utf-8").digest().toString("hex").toLowerCase();
+		const saltHashHex = saltHash.toString("hex").toLowerCase();
+		return crypto.createHash("md5").update(passwordHashHex + saltHashHex, "utf-8").digest();
+	}
+	/**
+	* Hash a password without salt (for testing)
+	*/
+	static hashWithoutSalt(password) {
+		const lowerPassword = password.toLowerCase();
+		const md5Hash = crypto.createHash("md5");
+		md5Hash.update(lowerPassword, "utf-8");
+		return md5Hash.digest();
+	}
+};
+//#endregion
+//#region src/client/AmuleConnection.ts
+/**
+* AmuleConnection - Manages the low-level connection to aMule EC
+*/
+var AmuleConnection = class {
+	host;
+	port;
+	password;
+	timeout;
+	socket;
+	connected = false;
+	buffer = Buffer.allocUnsafe(0);
+	pendingResponses = [];
+	connectionPromise;
+	requestTimeout = 0;
+	debug = false;
+	/**
+	* Enable or disable debug logging
+	*/
+	setDebug(enabled) {
+		this.debug = !!enabled;
+	}
+	/**
+	* Internal debug logger
+	*/
+	log(...args) {
+		if (!this.debug) return;
+		console.log("[DEBUG]", ...args);
+	}
+	constructor(host, port, password, timeout, requestTimeout = 0) {
+		this.host = host;
+		this.port = port;
+		this.password = password;
+		this.timeout = timeout;
+		this.requestTimeout = Math.max(0, requestTimeout);
+	}
+	/**
+	* Set default timeout for a single request/response cycle.
+	* Use 0 to disable.
+	*/
+	setRequestTimeout(timeoutMs) {
+		this.requestTimeout = Math.max(0, timeoutMs || 0);
+	}
+	/**
+	* Get current default timeout for requests.
+	*/
+	getRequestTimeout() {
+		return this.requestTimeout;
+	}
+	/**
+	* Reject and clear all pending responses.
+	*/
+	rejectAllPending(error) {
+		while (this.pendingResponses.length > 0) {
+			const pending = this.pendingResponses.shift();
+			if (pending?.timeoutHandle) clearTimeout(pending.timeoutHandle);
+			pending?.reject(error);
+		}
+	}
+	/**
+	* Reconnect to the server
+	*/
+	async reconnect() {
+		if (this.connectionPromise) return this.connectionPromise;
+		this.connectionPromise = (async () => {
+			this.connected = false;
+			if (this.socket) this.socket.destroy();
+			this.socket = new net.Socket();
+			if (this.timeout > 0) this.socket.setTimeout(this.timeout);
+			this.socket.on("data", (data) => this.handleData(Buffer.isBuffer(data) ? data : Buffer.from(data)));
+			this.socket.on("error", (error) => this.handleError(error));
+			this.socket.on("timeout", () => this.handleTimeout());
+			this.socket.on("close", () => this.handleClose());
+			try {
+				await this.connectSocket();
+				await this.authenticate();
+				this.connected = true;
+			} finally {
+				this.connectionPromise = void 0;
+			}
+		})();
+		return this.connectionPromise;
+	}
+	/**
+	* Connect socket to server
+	*/
+	connectSocket() {
+		return new Promise((resolve, reject) => {
+			if (!this.socket) return reject(new CommunicationException("Socket not initialized"));
+			this.socket.connect(this.port, this.host, () => {
+				resolve();
+			});
+			this.socket.once("error", reject);
+		});
+	}
+	/**
+	* Perform authentication handshake
+	*/
+	async authenticate() {
+		this.log("Starting authentication...");
+		const clientInfoRequest = new AuthClientInfoRequest();
+		this.log("Sending client info...");
+		const saltPacket = await this.sendRequestNoAuth(clientInfoRequest);
+		this.log("Received salt response");
+		if (saltPacket.opCode === 3) throw new ServerException("Authentication failed: server rejected client");
+		if (saltPacket.opCode !== 79) throw new ServerException(`Unexpected response to client info: ${saltPacket.opCode}`);
+		const saltResponse = AuthSaltResponse.fromPacket(saltPacket);
+		this.log("Salt:", saltResponse.salt);
+		const hashedPassword = PasswordHasher.hash(this.password, saltResponse.salt);
+		this.log("Hashed password:", hashedPassword.toString("hex"));
+		const authRequest = new AuthPasswordRequest(hashedPassword);
+		this.log("Sending hashed password...");
+		const authPacket = await this.sendRequestNoAuth(authRequest);
+		this.log("Received auth response");
+		if (authPacket.opCode === 3) throw new ServerException("Authentication failed: invalid password");
+		if (authPacket.opCode !== 4) throw new ServerException(`Unexpected auth response: ${authPacket.opCode}`);
+		this.log("Authentication successful!");
+	}
+	/**
+	* Handle incoming data
+	*/
+	handleData(data) {
+		this.log("Received data:", data.length, "bytes, hex:", data.toString("hex").substring(0, 100));
+		this.buffer = Buffer.concat([this.buffer, data]);
+		while (PacketParser.hasCompletePacket(this.buffer)) try {
+			const packet = PacketParser.parse(this.buffer);
+			this.log("Parsed packet, opCode:", packet.opCode);
+			const consumedBytes = PacketParser.getExpectedPacketSize(this.buffer);
+			this.buffer = this.buffer.subarray(consumedBytes);
+			const pending = this.pendingResponses.shift();
+			if (pending) pending.resolve(packet);
+		} catch (error) {
+			this.log("Parse error:", error);
+			const pending = this.pendingResponses.shift();
+			if (pending) pending.reject(error);
+			this.buffer = Buffer.allocUnsafe(0);
+			break;
+		}
+	}
+	/**
+	* Handle socket error
+	*/
+	handleError(error) {
+		this.connected = false;
+		this.rejectAllPending(new CommunicationException(`Socket error: ${error.message}`));
+	}
+	/**
+	* Handle socket timeout
+	*/
+	handleTimeout() {
+		this.connected = false;
+		this.rejectAllPending(new CommunicationException("Socket timeout"));
+	}
+	/**
+	* Handle socket close
+	*/
+	handleClose() {
+		this.log("Socket closed! connected:", this.connected, "pendingResponses:", this.pendingResponses.length);
+		this.connected = false;
+		this.rejectAllPending(new CommunicationException("Socket closed"));
+	}
+	/**
+	* Send a request and wait for response
+	*/
+	async sendRequest(request, timeoutMs) {
+		if (!this.connected) await this.reconnect();
+		try {
+			return await this.sendRequestNoAuth(request, timeoutMs);
+		} catch (error) {
+			this.connected = false;
+			throw error;
+		}
+	}
+	/**
+	* Send a request without checking authentication
+	*/
+	async sendRequestNoAuth(request, timeoutMs) {
+		if (!this.socket) throw new CommunicationException("Socket not initialized");
+		const packet = request.buildPacket();
+		const buffer = PacketWriter.write(packet);
+		this.log("Sending request:", packet.opCode.toString(16), "Size:", buffer.length);
+		const responsePromise = new Promise((resolve, reject) => {
+			const pending = {
+				resolve: (packet) => {
+					if (pending.timeoutHandle) clearTimeout(pending.timeoutHandle);
+					resolve(packet);
+				},
+				reject: (error) => {
+					if (pending.timeoutHandle) clearTimeout(pending.timeoutHandle);
+					reject(error);
+				}
+			};
+			const effectiveTimeout = timeoutMs ?? this.requestTimeout;
+			if (effectiveTimeout > 0) pending.timeoutHandle = setTimeout(() => {
+				if (!this.pendingResponses.includes(pending)) return;
+				this.connected = false;
+				this.rejectAllPending(new CommunicationException(`Request timeout after ${effectiveTimeout}ms`));
+				if (this.socket && !this.socket.destroyed) this.socket.destroy();
+			}, effectiveTimeout);
+			this.pendingResponses.push(pending);
+		});
+		this.socket.write(buffer);
+		return responsePromise;
+	}
+};
+//#endregion
+//#region src/model/index.ts
+let FileStatus = /* @__PURE__ */ function(FileStatus) {
+	FileStatus[FileStatus["READY"] = 0] = "READY";
+	FileStatus[FileStatus["EMPTY"] = 1] = "EMPTY";
+	FileStatus[FileStatus["WAITINGFORHASH"] = 2] = "WAITINGFORHASH";
+	FileStatus[FileStatus["HASHING"] = 3] = "HASHING";
+	FileStatus[FileStatus["ERROR"] = 4] = "ERROR";
+	FileStatus[FileStatus["INSUFFICIENT"] = 5] = "INSUFFICIENT";
+	FileStatus[FileStatus["UNKNOWN"] = 6] = "UNKNOWN";
+	FileStatus[FileStatus["PAUSED"] = 7] = "PAUSED";
+	FileStatus[FileStatus["COMPLETING"] = 8] = "COMPLETING";
+	FileStatus[FileStatus["COMPLETE"] = 9] = "COMPLETE";
+	FileStatus[FileStatus["ALLOCATING"] = 10] = "ALLOCATING";
+	return FileStatus;
+}({});
+let DownloadCommand = /* @__PURE__ */ function(DownloadCommand) {
+	DownloadCommand[DownloadCommand["SWAP_A4AF_THIS"] = 22] = "SWAP_A4AF_THIS";
+	DownloadCommand[DownloadCommand["SWAP_A4AF_THIS_AUTO"] = 23] = "SWAP_A4AF_THIS_AUTO";
+	DownloadCommand[DownloadCommand["SWAP_A4AF_OTHERS"] = 24] = "SWAP_A4AF_OTHERS";
+	DownloadCommand[DownloadCommand["PAUSE"] = 25] = "PAUSE";
+	DownloadCommand[DownloadCommand["RESUME"] = 26] = "RESUME";
+	DownloadCommand[DownloadCommand["STOP"] = 27] = "STOP";
+	DownloadCommand[DownloadCommand["DELETE"] = 29] = "DELETE";
+	return DownloadCommand;
+}({});
+let SearchType = /* @__PURE__ */ function(SearchType) {
+	SearchType[SearchType["GLOBAL"] = 1] = "GLOBAL";
+	SearchType[SearchType["KAD"] = 2] = "KAD";
+	SearchType[SearchType["LOCAL"] = 0] = "LOCAL";
+	SearchType[SearchType["WEB"] = 3] = "WEB";
+	return SearchType;
+}({});
+//#endregion
+//#region src/client/AmuleClient.ts
+/**
+* Main aMule EC Client
+*/
+var AmuleClient = class {
+	connection;
+	constructor(options) {
+		this.connection = new AmuleConnection(options.host, options.port, options.password, options.timeout || 0, options.requestTimeout || 0);
+	}
+	/**
+	* Set default timeout for individual request/response cycles.
+	* Use 0 to disable request timeout.
+	*/
+	setRequestTimeout(timeoutMs) {
+		this.connection.setRequestTimeout(timeoutMs);
+	}
+	/**
+	* Get current default timeout for requests.
+	*/
+	getRequestTimeout() {
+		return this.connection.getRequestTimeout();
+	}
+	/**
+	* Reconnect to the server
+	*/
+	async reconnect() {
+		await this.connection.reconnect();
+	}
+	/**
+	* Get server statistics
+	*/
+	async getStats() {
+		const { StatsRequest } = await import("./StatsRequest-B8v9LLHG.mjs");
+		const { StatsResponseParser } = await import("./StatsResponse-BVUxNPbz.mjs");
+		const request = new StatsRequest();
+		const packet = await this.connection.sendRequest(request);
+		return StatsResponseParser.fromPacket(packet);
+	}
+	/**
+	* Get incremental updates for files, clients, servers, and friends
+	*/
+	async getUpdate(detailLevel = 4) {
+		const { UpdateRequest } = await import("./UpdateRequest-Bunl73Ga.mjs");
+		const { UpdateResponseParser } = await import("./UpdateResponse-1LhyH9Zf.mjs");
+		const request = new UpdateRequest(detailLevel);
+		const packet = await this.connection.sendRequest(request);
+		return UpdateResponseParser.fromPacket(packet);
+	}
+	/**
+	* Start an asynchronous search
+	*/
+	async searchAsync(query, searchType, filters) {
+		const { SearchRequest } = await import("./SearchRequest-CNqz-K1Z.mjs");
+		const request = new SearchRequest(query, searchType, filters);
+		await this.connection.sendRequest(request);
+		return query;
+	}
+	/**
+	* Get search status (0-1)
+	*/
+	async searchStatus() {
+		const { SearchStatusRequest } = await import("./SearchStatusRequest-Bv6iaC9Y.mjs");
+		const { SearchProgressResponse } = await import("./SearchProgressResponse-Bputc9Ww.mjs");
+		const request = new SearchStatusRequest();
+		const packet = await this.connection.sendRequest(request);
+		return SearchProgressResponse.fromPacket(packet).progress;
+	}
+	/**
+	* Get search results
+	*/
+	async searchResults() {
+		const { SearchResultsRequest } = await import("./SearchResultsRequest-DKG508KF.mjs");
+		const { SearchResultsResponseParser } = await import("./SearchResultsResponse-ChNrKJ6_.mjs");
+		const request = new SearchResultsRequest();
+		const packet = await this.connection.sendRequest(request);
+		return SearchResultsResponseParser.fromPacket(packet);
+	}
+	/**
+	* Perform a synchronous search (waits for results)
+	*/
+	async searchSync(query, searchType, filters, timeout = 3e4) {
+		await this.searchAsync(query, searchType, filters);
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) {
+			if (await this.searchStatus() >= 1) return await this.searchResults();
+			await new Promise((resolve) => setTimeout(resolve, 500));
+		}
+		throw new Error("Search timeout");
+	}
+	/**
+	* Stop current search
+	*/
+	async searchStop() {
+		const { SearchStopRequest } = await import("./SearchStopRequest-rET-2Nsz.mjs");
+		const request = new SearchStopRequest();
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Download a file from search results
+	*/
+	async downloadSearchResult(hash) {
+		const { DownloadFileRequest } = await import("./DownloadFileRequest-CcNqsBo7.mjs");
+		const request = new DownloadFileRequest(hash);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Download from an ed2k link
+	*/
+	async downloadEd2kLink(link) {
+		const { AddLinkRequest } = await import("./AddLinkRequest-DwUbSMXD.mjs");
+		const request = new AddLinkRequest(link);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Get download queue
+	*/
+	async getDownloadQueue() {
+		const { DownloadQueueRequest } = await import("./DownloadQueueRequest-bd7lFiMj.mjs");
+		const { DownloadQueueResponseParser } = await import("./DownloadQueueResponse-DyP1rLTV.mjs");
+		const request = new DownloadQueueRequest();
+		const packet = await this.connection.sendRequest(request);
+		return DownloadQueueResponseParser.fromPacket(packet).files;
+	}
+	/**
+	* Get shared files
+	*/
+	async getSharedFiles() {
+		const { SharedFilesRequest } = await import("./SharedFilesRequest-D2M3K0eB.mjs");
+		const { SharedFilesResponseParser } = await import("./SharedFilesResponse-BiXT_oCx.mjs");
+		const request = new SharedFilesRequest();
+		const packet = await this.connection.sendRequest(request);
+		return SharedFilesResponseParser.fromPacket(packet).files;
+	}
+	/**
+	* Reload shared files list
+	*/
+	async reloadSharedFiles() {
+		const { ReloadSharedFilesRequest } = await import("./ReloadSharedFilesRequest-CPwAEJYG.mjs");
+		const request = new ReloadSharedFilesRequest();
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Get client upload/download queue (clients we are uploading to/downloading from)
+	*/
+	async getClientQueue() {
+		const { ClientQueueRequest } = await import("./ClientQueueRequest-D9FaX5K9.mjs");
+		const { ClientQueueResponseParser } = await import("./ClientQueueResponse-FVQBR_8b.mjs");
+		const request = new ClientQueueRequest();
+		const packet = await this.connection.sendRequest(request);
+		return ClientQueueResponseParser.fromPacket(packet).clients;
+	}
+	/**
+	* Get the list of servers
+	*/
+	async getServerList() {
+		const { ServerListRequest } = await import("./ServerListRequest-FwFQBp12.mjs");
+		const { ServerListResponseParser } = await import("./ServerListResponse-ZAKSSCPZ.mjs");
+		const request = new ServerListRequest();
+		const packet = await this.connection.sendRequest(request);
+		return ServerListResponseParser.fromPacket(packet).servers;
+	}
+	/**
+	* Connect to a specific server
+	*/
+	async connectToServer(ip, port) {
+		const { ServerConnectRequest } = await import("./ServerConnectRequest-CcO2-Eqd.mjs");
+		const request = new ServerConnectRequest(ip, port);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Disconnect from the current server
+	*/
+	async disconnectFromServer() {
+		const { ServerDisconnectRequest } = await import("./ServerDisconnectRequest-DEORM3SF.mjs");
+		const request = new ServerDisconnectRequest();
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Create a category
+	*/
+	async createCategory(category) {
+		const { CreateCategoryRequest } = await import("./CreateCategoryRequest-Br6yfDhZ.mjs");
+		const request = new CreateCategoryRequest(category);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Update a category
+	*/
+	async updateCategory(id, category) {
+		const { UpdateCategoryRequest } = await import("./UpdateCategoryRequest-CgzH7SxP.mjs");
+		const request = new UpdateCategoryRequest(id, category);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Delete a category
+	*/
+	async deleteCategory(id) {
+		const { DeleteCategoryRequest } = await import("./DeleteCategoryRequest-C2-p6sx0.mjs");
+		const request = new DeleteCategoryRequest(id);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Get all categories
+	*/
+	async getCategories() {
+		const { GetPreferencesRequest } = await import("./GetPreferencesRequest-C94Su9IH.mjs");
+		const { PreferencesResponseParser } = await import("./PreferencesResponse-Dth-n2sA.mjs");
+		const request = new GetPreferencesRequest(1);
+		const packet = await this.connection.sendRequest(request);
+		return PreferencesResponseParser.fromPacket(packet).categories;
+	}
+	/**
+	* Set file category
+	*/
+	async setFileCategory(hash, categoryId) {
+		const { SetFileCategoryRequest } = await import("./SetFileCategoryRequest-BwEPJVeR.mjs");
+		const request = new SetFileCategoryRequest(hash, categoryId);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Send a download command (PAUSE, RESUME, STOP, DELETE, etc.)
+	*/
+	async sendDownloadCommand(hash, command) {
+		const { DownloadCommandRequest } = await import("./DownloadCommandRequest-CaULjfNi.mjs");
+		const request = new DownloadCommandRequest(hash, command);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Pause a download
+	*/
+	async pauseDownload(hash) {
+		await this.sendDownloadCommand(hash, 25);
+	}
+	/**
+	* Resume a download
+	*/
+	async resumeDownload(hash) {
+		await this.sendDownloadCommand(hash, 26);
+	}
+	/**
+	* Stop a download
+	*/
+	async stopDownload(hash) {
+		await this.sendDownloadCommand(hash, 27);
+	}
+	/**
+	* Delete a download
+	*/
+	async deleteDownload(hash) {
+		await this.sendDownloadCommand(hash, 29);
+	}
+	/**
+	* Trigger a server list update from an URL.
+	*/
+	async updateServerListFromUrl(url) {
+		const { ServerUpdateFromUrlRequest } = await import("./ServerUpdateFromUrlRequest-D4xBqJDJ.mjs");
+		const request = new ServerUpdateFromUrlRequest(url);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Set upload priority for a shared file.
+	*/
+	async setSharedFilePriority(hash, priority) {
+		const { SharedFilePriorityRequest } = await import("./SharedFilePriorityRequest-j6ImgagV.mjs");
+		const request = new SharedFilePriorityRequest(hash, priority);
+		await this.connection.sendRequest(request);
+	}
+	/**
+	* Get daemon preferences for general/connection/servers/security sections.
+	*/
+	async getPreferences() {
+		const { GetPreferencesRequest } = await import("./GetPreferencesRequest-C94Su9IH.mjs");
+		const { PreferencesDetailsResponseParser } = await import("./PreferencesDetailsResponse-BjMxbvVY.mjs");
+		const request = new GetPreferencesRequest(2118);
+		const packet = await this.connection.sendRequest(request);
+		return PreferencesDetailsResponseParser.fromPacket(packet).preferences;
+	}
+	/**
+	* Set daemon preferences. Only sections present in the input object are sent.
+	*/
+	async setPreferences(preferences) {
+		if (!preferences.general && !preferences.connection && !preferences.servers && !preferences.security) return;
+		const { SetPreferencesRequest } = await import("./SetPreferencesRequest-D2fVIH3P.mjs");
+		const request = new SetPreferencesRequest(preferences);
+		await this.connection.sendRequest(request);
+	}
+};
+//#endregion
+export { AmuleClient, AmuleException, ChunkStatus, CommunicationException, CustomTag, DoubleTag, DownloadCommand, ECDetailLevel, ECOpCode, ECSearchType, ECTagName, EcPrefs, FileStatus, Flags, Hash16Tag, InvalidECException, Ipv4Tag, PARTSIZE, Packet, PacketParser, PacketWriter, ProtocolVersion, SearchType, ServerException, StringTag, Tag, UByteTag, UInt128Tag, UIntTag, ULongTag, UShortTag };
+
+//# sourceMappingURL=index.mjs.map