torrent-tui 0.0.1

package/src/torrent/metadata.ts

@@ -0,0 +1,190 @@
+import { SHA1 } from "bun";
+import { extractInfoBytes } from "./parser.ts";
+import type { BencodeValue } from "./parser.ts";
+import type { FileInfo } from "./types.ts";
+
+const TEXT_DECODER = new TextDecoder();
+
+export function log(prefix: string, message: string): void {
+	const pad = 10;
+	console.log(`  ${prefix.padEnd(pad)}  ${message}`);
+}
+
+export class TorrentMetadata {
+	readonly name: string;
+	readonly totalSize: number;
+	readonly pieceLength: number;
+	readonly pieceCount: number;
+	readonly pieceHashes: Uint8Array[];
+	readonly files: FileInfo[];
+	readonly infoHash: Uint8Array;
+	readonly announceList: string[][];
+
+	constructor(decoded: { [key: string]: BencodeValue }, rawTorrentBytes: Uint8Array) {
+		const info = decoded["info"];
+		if (
+			typeof info !== "object" ||
+			info === null ||
+			Array.isArray(info) ||
+			info instanceof Uint8Array
+		) {
+			throw new Error("Missing or invalid info dict");
+		}
+		const infoDict = info as { [key: string]: BencodeValue };
+
+		// name
+		const nameRaw = infoDict["name"];
+		if (!(nameRaw instanceof Uint8Array) && typeof nameRaw !== "string") {
+			throw new Error("Missing name in info dict");
+		}
+		this.name =
+			nameRaw instanceof Uint8Array
+				? TEXT_DECODER.decode(nameRaw)
+				: nameRaw;
+
+		// piece length
+		const pl = infoDict["piece length"];
+		if (typeof pl !== "number") throw new Error("Missing piece length");
+		this.pieceLength = pl;
+
+		// piece hashes
+		const piecesRaw = infoDict["pieces"];
+		if (!(piecesRaw instanceof Uint8Array)) {
+			throw new Error("Missing or invalid pieces");
+		}
+		if (piecesRaw.length % 20 !== 0) {
+			throw new Error("pieces length is not a multiple of 20");
+		}
+		this.pieceHashes = [];
+		for (let i = 0; i < piecesRaw.length; i += 20) {
+			this.pieceHashes.push(piecesRaw.slice(i, i + 20));
+		}
+		this.pieceCount = this.pieceHashes.length;
+
+		// file list
+		this.files = [];
+		let offset = 0;
+		const lengthField = infoDict["length"];
+		const filesField = infoDict["files"];
+
+		if (typeof lengthField === "number") {
+			// single-file torrent
+			this.files.push({ path: this.name, length: lengthField, offset: 0 });
+			this.totalSize = lengthField;
+		} else if (Array.isArray(filesField)) {
+			// multi-file torrent
+			for (const entry of filesField) {
+				if (
+					typeof entry !== "object" ||
+					entry === null ||
+					Array.isArray(entry) ||
+					entry instanceof Uint8Array
+				) {
+					throw new Error("Invalid file entry");
+				}
+				const fileDict = entry as { [key: string]: BencodeValue };
+				const fileLen = fileDict["length"];
+				const filePath = fileDict["path"];
+				if (typeof fileLen !== "number") throw new Error("Invalid file length");
+				if (!Array.isArray(filePath)) throw new Error("Invalid file path");
+
+				const parts = filePath.map((p) => {
+					if (p instanceof Uint8Array) return TEXT_DECODER.decode(p);
+					if (typeof p === "string") return p;
+					throw new Error("Invalid path component");
+				});
+
+				const joinedPath = [this.name, ...parts].join("/");
+				this.files.push({ path: joinedPath, length: fileLen, offset });
+				offset += fileLen;
+			}
+			this.totalSize = offset;
+		} else {
+			throw new Error("info dict must have length or files");
+		}
+
+		// Hash the raw bytes from the original file — not a re-encoded version.
+		// BEP 3: must extract the substring directly, not decode-encode roundtrip.
+		this.infoHash = SHA1.hash(extractInfoBytes(rawTorrentBytes)) as unknown as Uint8Array;
+
+		// announce list (BEP 12)
+		const announceListRaw = decoded["announce-list"];
+		if (Array.isArray(announceListRaw)) {
+			this.announceList = announceListRaw
+				.filter(Array.isArray)
+				.map((tier) =>
+					(tier as BencodeValue[])
+						.map((url) => {
+							if (url instanceof Uint8Array) return TEXT_DECODER.decode(url);
+							if (typeof url === "string") return url;
+							return null;
+						})
+						.filter((u): u is string => u !== null),
+				)
+				.filter((tier) => tier.length > 0);
+		} else {
+			const announce = decoded["announce"];
+			const announceStr =
+				announce instanceof Uint8Array
+					? TEXT_DECODER.decode(announce)
+					: typeof announce === "string"
+						? announce
+						: null;
+			this.announceList = announceStr ? [[announceStr]] : [];
+		}
+	}
+
+	formatSize(): string {
+		const gb = this.totalSize / (1024 * 1024 * 1024);
+		if (gb >= 1) return `${gb.toFixed(1)} GB`;
+		const mb = this.totalSize / (1024 * 1024);
+		if (mb >= 1) return `${mb.toFixed(1)} MB`;
+		return `${(this.totalSize / 1024).toFixed(1)} KB`;
+	}
+
+	formatPieceLength(): string {
+		const kb = this.pieceLength / 1024;
+		if (kb >= 1024) return `${(kb / 1024).toFixed(0)} MB`;
+		return `${kb.toFixed(0)} KB`;
+	}
+
+	// Returns which files a piece touches and the byte ranges within each file
+	pieceToFileRanges(
+		pieceIndex: number,
+	): Array<{ file: FileInfo; fileOffset: number; length: number }> {
+		const pieceStart = pieceIndex * this.pieceLength;
+		const isLastPiece = pieceIndex === this.pieceCount - 1;
+		const pieceLen = isLastPiece
+			? this.totalSize - pieceStart
+			: this.pieceLength;
+		const pieceEnd = pieceStart + pieceLen;
+
+		const ranges: Array<{ file: FileInfo; fileOffset: number; length: number }> =
+			[];
+
+		for (const file of this.files) {
+			const fileEnd = file.offset + file.length;
+			const overlapStart = Math.max(pieceStart, file.offset);
+			const overlapEnd = Math.min(pieceEnd, fileEnd);
+			if (overlapStart >= overlapEnd) continue;
+			ranges.push({
+				file,
+				fileOffset: overlapStart - file.offset,
+				length: overlapEnd - overlapStart,
+			});
+		}
+
+		return ranges;
+	}
+
+	logSummary(): void {
+		const httpTrackers = this.announceList.flat().filter((u) => u.startsWith("http")).length;
+		const udpTrackers = this.announceList.flat().filter((u) => u.startsWith("udp")).length;
+		const trackerParts = [
+			httpTrackers > 0 ? `${httpTrackers} HTTP` : "",
+			udpTrackers > 0 ? `${udpTrackers} UDP` : "",
+		].filter(Boolean).join("  ");
+
+		log("torrent", `${this.name}   ${this.formatSize()}   ${this.pieceCount} × ${this.formatPieceLength()}   ${trackerParts || "no trackers"}`);
+	}
+}

package/src/torrent/parser.ts

@@ -0,0 +1,216 @@
+export type BencodeValue =
+	| string
+	| number
+	| Uint8Array
+	| BencodeValue[]
+	| { [key: string]: BencodeValue };
+
+const TEXT_DECODER = new TextDecoder(); // bytes -> string
+const TEXT_ENCODER = new TextEncoder(); // string -> bytes
+
+/**
+ * i<num>e -> number
+ */
+export function parseIntB(data: Uint8Array, i: number): [number, number] {
+	if (data[i] !== 105) throw new Error("Invalid integer"); // check for "i"
+	i++;
+	const start = i;
+	while (i < data.length && data[i] !== 101) i++; // loop until "e"
+	if (i >= data.length) throw new Error("Unterminated integer");
+	const value = Number.parseInt(TEXT_DECODER.decode(data.slice(start, i)), 10);
+	return [value, i + 1];
+}
+
+/**
+ * <len>:<bytes> -> Uint8Array (raw binary string)
+ */
+export function parseByteString(
+	data: Uint8Array,
+	i: number,
+): [Uint8Array, number] {
+	let j = i;
+	while (j < data.length && data[j] !== 58) j++;
+	if (j >= data.length) throw new Error("Invalid string: missing separator");
+	const len = Number.parseInt(TEXT_DECODER.decode(data.slice(i, j)), 10);
+	if (len < 0) throw new Error("Invalid string: negative length");
+	j++;
+	if (j + len > data.length)
+		throw new Error("Invalid string: length exceeds data");
+	return [data.slice(j, j + len), j + len];
+}
+
+/**
+ * <len>:<str> -> string (UTF-8 text)
+ */
+export function parseStringB(data: Uint8Array, i: number): [string, number] {
+	const [bytes, newI] = parseByteString(data, i);
+	return [TEXT_DECODER.decode(bytes), newI];
+}
+
+/**
+ * l<items>e -> BencodeValue[]
+ */
+export function parseListB(
+	data: Uint8Array,
+	i: number,
+): [BencodeValue[], number] {
+	if (data[i] !== 108) throw new Error("Invalid list"); // check for "l"
+	i++;
+	const arr: BencodeValue[] = [];
+	while (i < data.length && data[i] !== 101) {
+		const [val, newI] = parseAny(data, i);
+		arr.push(val);
+		i = newI;
+	}
+	if (i >= data.length) throw new Error("Unterminated list");
+	return [arr, i + 1];
+}
+
+/**
+ * d<key-value>e -> { [key: string]: BencodeValue }
+ */
+export function parseDictB(
+	data: Uint8Array,
+	i: number,
+): [{ [key: string]: BencodeValue }, number] {
+	if (data[i] !== 100) throw new Error("Invalid dictionary"); // check for "d"
+	i++;
+	const dict: { [key: string]: BencodeValue } = {};
+	while (i < data.length && data[i] !== 101) {
+		const [key, newI] = parseStringB(data, i);
+		const keyStr = key;
+		const [val, nextI] = parseAny(data, newI);
+		dict[keyStr] = val;
+		i = nextI;
+	}
+	if (i >= data.length) throw new Error("Unterminated dictionary");
+	return [dict, i + 1];
+}
+
+/**
+ * Parse any bencode value
+ */
+export function parseAny(data: Uint8Array, i: number): [BencodeValue, number] {
+	const byte = data[i];
+	if (byte === undefined) throw new Error(`Invalid bencode type at index ${i}`);
+	if (byte === 105) return parseIntB(data, i);
+	if (byte === 108) return parseListB(data, i);
+	if (byte === 100) return parseDictB(data, i);
+	if (byte >= 48 && byte <= 57) return parseByteString(data, i);
+	throw new Error(`Invalid bencode type at index ${i}: ${byte}`);
+}
+
+/**
+ * Decodes bencode data to BencodeValue
+ */
+export function decode(data: Uint8Array): BencodeValue {
+	const [result, index] = parseAny(data, 0);
+	if (index < data.length) throw new Error(`Extra data at index ${index}`);
+	return result;
+}
+
+/**
+ * Skips over a single bencode value and returns the index after it.
+ * Used to extract raw byte ranges without decoding.
+ */
+function skipValue(data: Uint8Array, i: number): number {
+	const byte = data[i];
+	if (byte === undefined) throw new Error(`Unexpected end at ${i}`);
+	if (byte === 105) { // integer: i<digits>e
+		while (i < data.length && data[i] !== 101) i++;
+		return i + 1;
+	}
+	if (byte === 108) { // list: l<items>e
+		i++;
+		while (i < data.length && data[i] !== 101) i = skipValue(data, i);
+		return i + 1;
+	}
+	if (byte === 100) { // dict: d<key><value>...e
+		i++;
+		while (i < data.length && data[i] !== 101) {
+			i = skipValue(data, i); // key
+			i = skipValue(data, i); // value
+		}
+		return i + 1;
+	}
+	if (byte >= 48 && byte <= 57) { // string: <len>:<bytes>
+		let j = i;
+		while (j < data.length && data[j] !== 58) j++;
+		const len = Number.parseInt(TEXT_DECODER.decode(data.slice(i, j)), 10);
+		return j + 1 + len;
+	}
+	throw new Error(`Unknown bencode type at ${i}: ${byte}`);
+}
+
+/**
+ * Extracts the raw bytes of the 'info' dict from a torrent file.
+ * This is what must be SHA-1 hashed for the info_hash — NOT a re-encoded version.
+ * BEP 3: "clients must extract the substring directly, not perform a decode-encode roundtrip."
+ */
+export function extractInfoBytes(data: Uint8Array): Uint8Array {
+	if (data[0] !== 100) throw new Error("Torrent file is not a bencode dict");
+	let i = 1;
+	while (i < data.length && data[i] !== 101) {
+		const [key, afterKey] = parseStringB(data, i);
+		const valueStart = afterKey;
+		if (key === "info") {
+			const valueEnd = skipValue(data, valueStart);
+			return data.slice(valueStart, valueEnd);
+		}
+		i = skipValue(data, valueStart);
+	}
+	throw new Error("No 'info' key found in torrent file");
+}
+
+/**
+ * Encodes BencodeValue to bencode bytes
+ */
+export function encode(value: BencodeValue): Uint8Array {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			throw new Error(
+				"Cannot encode non-finite numbers (NaN, Infinity, -Infinity)",
+			);
+		}
+		return TEXT_ENCODER.encode(`i${value}e`);
+	}
+	if (typeof value === "string") {
+		const bytes = TEXT_ENCODER.encode(value);
+		const len = TEXT_ENCODER.encode(String(bytes.length));
+		return Uint8Array.from([...len, 58, ...bytes]);
+	}
+	if (value instanceof Uint8Array) {
+		const len = TEXT_ENCODER.encode(String(value.length));
+		return Uint8Array.from([...len, 58, ...value]);
+	}
+	if (Array.isArray(value)) {
+		const parts: Uint8Array[] = [TEXT_ENCODER.encode("l")];
+		for (const item of value) parts.push(encode(item));
+		parts.push(TEXT_ENCODER.encode("e"));
+		return concat(parts);
+	}
+	if (typeof value === "object" && value !== null) {
+		const parts: Uint8Array[] = [TEXT_ENCODER.encode("d")];
+		const keys = Object.keys(value).sort();
+		for (const key of keys) {
+			const val = value[key];
+			if (val === undefined) continue;
+			parts.push(encode(key));
+			parts.push(encode(val));
+		}
+		parts.push(TEXT_ENCODER.encode("e"));
+		return concat(parts);
+	}
+	throw new Error(`Unsupported type: ${typeof value}`);
+}
+
+function concat(arrays: Uint8Array[]): Uint8Array {
+	const total = arrays.reduce((sum, a) => sum + a.length, 0);
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}

package/src/torrent/peer/connection.ts

@@ -0,0 +1,278 @@
+import { EventEmitter } from "node:events";
+import { createConnection } from "node:net";
+import type { Socket } from "node:net";
+import { log } from "../metadata.ts";
+import { MessageBuffer } from "./message-buffer.ts";
+import {
+	MSG,
+	decode as decodeMsg,
+	encode as encodeMsg,
+	encodeHave,
+	encodeRequest,
+	encodeCancel,
+	decodeHave,
+	decodePiece,
+	decodeRequest,
+} from "./protocol.ts";
+import { buildHandshake, parseHandshake, HANDSHAKE_LEN } from "./handshake.ts";
+import { getPeerId } from "./peer-id.ts";
+
+const KEEPALIVE_INTERVAL_MS = 120_000;
+const CONNECT_TIMEOUT_MS = 10_000;
+const IDLE_TIMEOUT_MS = 120_000;
+
+export class PeerConnection extends EventEmitter {
+	readonly address: string;
+	readonly port: number;
+	peerId: string = "";
+
+	amChoked = true;
+	amInterested = false;
+	peerChoked = true;
+	peerInterested = false;
+	piecesBitfield: Uint8Array = new Uint8Array(0);
+	suppressDisconnect = false;
+
+	// Per-peer rate tracking — reset every 10s by PeerManager
+	downloadedThisInterval = 0;
+	uploadedThisInterval = 0;
+	downloadBytesPerSec = 0;
+	uploadBytesPerSec = 0;
+
+	private socket: Socket | null = null;
+	private buf = new MessageBuffer();
+	private handshakeDone = false;
+	private handshakeBuffer = new Uint8Array(0);
+	private keepaliveTimer: ReturnType<typeof setInterval> | null = null;
+	private idleTimer: ReturnType<typeof setTimeout> | null = null;
+	private infoHash: Uint8Array;
+	private settle?: (err?: Error) => void;
+
+	constructor(
+		address: string,
+		port: number,
+		infoHash: Uint8Array,
+	) {
+		super();
+		this.address = address;
+		this.port = port;
+		this.infoHash = infoHash;
+	}
+
+	connect(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			this.settle = (err?: Error) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout); // clear here so 10s guard stays active until handshake
+				this.settle = undefined;
+				if (err) reject(err);
+				else resolve();
+			};
+
+			const sock = createConnection({ host: this.address, port: this.port });
+			this.socket = sock;
+
+			// 10s covers both TCP connect AND handshake completion.
+			// Do NOT clear on TCP connect — only clear when promise settles.
+			const timeout = setTimeout(() => {
+				log("timeout", `${this.address}:${this.port}  after ${CONNECT_TIMEOUT_MS / 1000}s`);
+				sock.destroy();
+				this.settle?.(new Error("connect timeout"));
+			}, CONNECT_TIMEOUT_MS);
+
+			sock.once("connect", () => {
+				sock.write(buildHandshake(this.infoHash, getPeerId()));
+				this.resetIdleTimer();
+				// Timeout continues running until handshake completes or times out
+			});
+
+			sock.on("data", (chunk: Buffer) => {
+				this.resetIdleTimer();
+				this.onData(new Uint8Array(chunk));
+			});
+
+			sock.once("error", (err) => {
+				log("error", `${this.address}:${this.port}  ${err.message}`);
+				this.settle?.(err); // settle() clears timeout
+			});
+
+			sock.once("close", () => {
+				this.cleanup();
+				this.settle?.(new Error("closed before handshake"));
+				this.emit("disconnect");
+			});
+		});
+	}
+
+	private onData(chunk: Uint8Array): void {
+		if (!this.handshakeDone) {
+			// Accumulate until we have 68 bytes
+			const merged = new Uint8Array(this.handshakeBuffer.length + chunk.length);
+			merged.set(this.handshakeBuffer);
+			merged.set(chunk, this.handshakeBuffer.length);
+			this.handshakeBuffer = merged;
+
+			if (this.handshakeBuffer.length < HANDSHAKE_LEN) return;
+
+			try {
+				const result = parseHandshake(this.handshakeBuffer, this.infoHash);
+				this.peerId = result.peerId;
+				this.handshakeDone = true;
+				this.startKeepalive();
+				log("handshake", `${this.address}:${this.port}   ${this.peerId.slice(0, 8)}`);
+				this.settle?.(); // resolve the connect() promise
+				const remainder = this.handshakeBuffer.slice(HANDSHAKE_LEN);
+				this.handshakeBuffer = new Uint8Array(0);
+				if (remainder.length > 0) this.onMessages(this.buf.push(remainder));
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				log("handshake", `${this.address}:${this.port}   fail  ${msg}`);
+				this.settle?.(new Error(msg));
+				this.socket?.destroy();
+			}
+			return;
+		}
+
+		this.onMessages(this.buf.push(chunk));
+	}
+
+	private onMessages(messages: Uint8Array[]): void {
+		for (const raw of messages) {
+			const msg = decodeMsg(raw);
+			switch (msg.type) {
+				case MSG.CHOKE:
+					this.amChoked = true;
+					this.emit("choke");
+					break;
+				case MSG.UNCHOKE:
+					this.amChoked = false;
+					this.emit("unchoke");
+					break;
+				case MSG.INTERESTED:
+					this.peerInterested = true;
+					break;
+				case MSG.NOT_INTERESTED:
+					this.peerInterested = false;
+					break;
+				case MSG.HAVE:
+					if (msg.payload) {
+						const idx = decodeHave(msg.payload);
+						this.emit("have", idx);
+					}
+					break;
+				case MSG.BITFIELD:
+					if (msg.payload) {
+						this.piecesBitfield = msg.payload;
+						this.emit("bitfield", msg.payload);
+					}
+					break;
+				case MSG.PIECE:
+					if (msg.payload) {
+						const { index, begin, block } = decodePiece(msg.payload);
+						this.downloadedThisInterval += block.length;
+						this.emit("piece", index, begin, block);
+					}
+					break;
+				case MSG.REQUEST:
+					if (msg.payload) {
+						const req = decodeRequest(msg.payload);
+						this.emit("request", req.index, req.begin, req.length);
+					}
+					break;
+				case MSG.KEEPALIVE:
+					break;
+			}
+		}
+	}
+
+	countPiecesPublic(): number {
+		let n = 0;
+		for (const byte of this.piecesBitfield) {
+			let b = byte;
+			while (b) { n += b & 1; b >>>= 1; }
+		}
+		return n;
+	}
+
+	hasPiece(index: number): boolean {
+		const byte = Math.floor(index / 8);
+		const bit = 7 - (index % 8);
+		return ((this.piecesBitfield[byte] ?? 0) & (1 << bit)) !== 0;
+	}
+
+	sendInterested(): void {
+		this.amInterested = true;
+		this.write(encodeMsg({ type: MSG.INTERESTED }));
+	}
+
+	sendNotInterested(): void {
+		this.amInterested = false;
+		this.write(encodeMsg({ type: MSG.NOT_INTERESTED }));
+	}
+
+	sendRequest(index: number, begin: number, length: number): void {
+		this.write(encodeRequest(index, begin, length));
+	}
+
+	sendCancel(index: number, begin: number, length: number): void {
+		this.write(encodeCancel(index, begin, length));
+	}
+
+	sendHave(index: number): void {
+		this.write(encodeHave(index));
+	}
+
+	sendBitfield(bitfield: Uint8Array): void {
+		this.write(encodeMsg({ type: MSG.BITFIELD, payload: bitfield }));
+	}
+
+	sendChoke(): void {
+		this.peerChoked = true;
+		this.write(encodeMsg({ type: MSG.CHOKE }));
+	}
+
+	sendUnchoke(): void {
+		this.peerChoked = false;
+		this.write(encodeMsg({ type: MSG.UNCHOKE }));
+	}
+
+	sendPiece(index: number, begin: number, block: Uint8Array): void {
+		const payload = new Uint8Array(8 + block.length);
+		const view = new DataView(payload.buffer);
+		view.setUint32(0, index);
+		view.setUint32(4, begin);
+		payload.set(block, 8);
+		this.write(encodeMsg({ type: MSG.PIECE, payload }));
+		this.uploadedThisInterval += block.length;
+	}
+
+	private startKeepalive(): void {
+		this.keepaliveTimer = setInterval(() => {
+			this.write(encodeMsg({ type: MSG.KEEPALIVE }));
+		}, KEEPALIVE_INTERVAL_MS);
+	}
+
+	private resetIdleTimer(): void {
+		if (this.idleTimer) clearTimeout(this.idleTimer);
+		this.idleTimer = setTimeout(() => {
+			log("timeout", `${this.address}:${this.port}  idle`);
+			this.socket?.destroy();
+		}, IDLE_TIMEOUT_MS);
+	}
+
+	private write(data: Uint8Array): void {
+		this.socket?.write(data);
+	}
+
+	private cleanup(): void {
+		if (this.keepaliveTimer) clearInterval(this.keepaliveTimer);
+		if (this.idleTimer) clearTimeout(this.idleTimer);
+	}
+
+	destroy(): void {
+		this.cleanup();
+		this.socket?.destroy();
+	}
+}