torrent-tui 0.0.1

package/src/torrent/peer/handshake.ts

@@ -0,0 +1,48 @@
+const PROTOCOL = "BitTorrent protocol";
+const PROTOCOL_BYTES = new TextEncoder().encode(PROTOCOL);
+const HANDSHAKE_LEN = 68;
+
+export function buildHandshake(
+	infoHash: Uint8Array,
+	peerId: Uint8Array,
+): Uint8Array {
+	const buf = new Uint8Array(HANDSHAKE_LEN);
+	buf[0] = 19; // pstrlen
+	buf.set(PROTOCOL_BYTES, 1); // pstr (19 bytes)
+	// bytes 20–27: reserved (zeros, already set)
+	buf.set(infoHash, 28); // info_hash
+	buf.set(peerId, 48); // peer_id
+	return buf;
+}
+
+export function parseHandshake(
+	data: Uint8Array,
+	expectedInfoHash: Uint8Array,
+): { peerId: string; reserved: Uint8Array } {
+	if (data.length < HANDSHAKE_LEN) {
+		throw new Error(`Handshake too short: ${data.length} bytes`);
+	}
+	if (data[0] !== 19) {
+		throw new Error(`Invalid pstrlen: ${data[0]}`);
+	}
+	const pstr = new TextDecoder().decode(data.slice(1, 20));
+	if (pstr !== PROTOCOL) {
+		throw new Error(`Unknown protocol: ${pstr}`);
+	}
+	const reserved = data.slice(20, 28);
+	const infoHash = data.slice(28, 48);
+	const peerId = data.slice(48, 68);
+
+	for (let i = 0; i < 20; i++) {
+		if (infoHash[i] !== expectedInfoHash[i]) {
+			throw new Error("info_hash mismatch");
+		}
+	}
+
+	return {
+		peerId: Buffer.from(peerId).toString("latin1"),
+		reserved,
+	};
+}
+
+export { HANDSHAKE_LEN };

package/src/torrent/peer/listener.ts

@@ -0,0 +1,52 @@
+import { createServer } from "node:net";
+import type { Server, Socket } from "node:net";
+import { log } from "../metadata.ts";
+
+const PORT_RANGE = [6881, 6882, 6883, 6884, 6885, 6886, 6887, 6888, 6889];
+
+export class PeerListener {
+	port: number = 0;
+	private server: Server | null = null;
+	private connectionCb: ((socket: Socket) => void) | null = null;
+
+	async listen(): Promise<void> {
+		for (const p of PORT_RANGE) {
+			const success = await this.tryListen(p);
+			if (success) {
+				this.port = p;
+				log("listener", `port ${p}`);
+				return;
+			}
+		}
+		throw new Error("No available port in range 6881–6889");
+	}
+
+	private tryListen(port: number): Promise<boolean> {
+		return new Promise((resolve) => {
+			const server = createServer((socket) => {
+				const remote = `${socket.remoteAddress}:${socket.remotePort}`;
+				log("inbound", remote);
+				this.connectionCb?.(socket);
+			});
+
+			server.once("listening", () => {
+				this.server = server;
+				resolve(true);
+			});
+
+			server.once("error", () => {
+				resolve(false);
+			});
+
+			server.listen(port);
+		});
+	}
+
+	onConnection(cb: (socket: Socket) => void): void {
+		this.connectionCb = cb;
+	}
+
+	close(): void {
+		this.server?.close();
+	}
+}

package/src/torrent/peer/manager.ts

@@ -0,0 +1,233 @@
+import { EventEmitter } from "node:events";
+import { log } from "../metadata.ts";
+import { PeerConnection } from "./connection.ts";
+import { PeerListener } from "./listener.ts";
+import { buildHandshake, parseHandshake, HANDSHAKE_LEN } from "./handshake.ts";
+import { getPeerId } from "./peer-id.ts";
+import type { TorrentMetadata } from "../metadata.ts";
+import type { PeerInfo } from "../types.ts";
+
+export class PeerManager extends EventEmitter {
+	readonly connections: Map<string, PeerConnection> = new Map();
+	private listener: PeerListener;
+	private maxConnections: number;
+	private infoHash: Uint8Array;
+	private pieceCount: number;
+	private chokeTimer: ReturnType<typeof setInterval> | null = null;
+	private optimisticTimer: ReturnType<typeof setInterval> | null = null;
+	private optimisticKey: string | null = null;
+	private unchokedKeys = new Set<string>();
+
+	constructor(metadata: TorrentMetadata, maxConnections = 50) {
+		super();
+		this.infoHash = metadata.infoHash;
+		this.pieceCount = metadata.pieceCount;
+		this.maxConnections = maxConnections;
+		this.listener = new PeerListener();
+	}
+
+	async start(): Promise<void> {
+		await this.listener.listen();
+		this.listener.onConnection((socket) => this.handleInbound(socket));
+	}
+
+	async connect(peers: PeerInfo[]): Promise<void> {
+		const unique = this.dedup(peers);
+		const toConnect = unique.slice(
+			0,
+			Math.max(0, this.maxConnections - this.connections.size),
+		);
+
+		await Promise.allSettled(
+			toConnect.map((p) => this.connectOne(p.ip, p.port)),
+		);
+	}
+
+	private async connectOne(ip: string, port: number): Promise<void> {
+		const key = `${ip}:${port}`;
+		if (this.connections.has(key)) return;
+
+		const conn = new PeerConnection(ip, port, this.infoHash);
+
+		conn.on("bitfield", () => {
+			if (conn.countPiecesPublic() > 0 && !conn.amInterested) conn.sendInterested();
+		});
+
+		conn.on("disconnect", () => {
+			this.connections.delete(key);
+		});
+
+		try {
+			await conn.connect();
+			this.connections.set(key, conn);
+			this.emit("peerAdded", conn);
+		} catch {
+			// timeout/error already logged by connection.ts
+		}
+	}
+
+	private handleInbound(socket: import("node:net").Socket): void {
+		let buf = new Uint8Array(0);
+
+		const onData = (chunk: Buffer) => {
+			const merged = new Uint8Array(buf.length + chunk.length);
+			merged.set(buf);
+			merged.set(new Uint8Array(chunk), buf.length);
+			buf = merged;
+
+			if (buf.length < HANDSHAKE_LEN) return;
+
+			socket.removeListener("data", onData);
+
+			try {
+				const result = parseHandshake(buf, this.infoHash);
+				socket.write(buildHandshake(this.infoHash, getPeerId()));
+
+				const ip = socket.remoteAddress ?? "unknown";
+				const port = socket.remotePort ?? 0;
+				const key = `${ip}:${port}`;
+				log("peer", `${key.padEnd(50)}  ok   ${result.peerId.slice(0, 8)}  (inbound)`);
+
+				// Wrap the existing socket in a PeerConnection
+				const conn = new PeerConnection(ip, port, this.infoHash);
+				// Hand off the already-connected socket by replaying the remainder
+				(conn as unknown as { socket: typeof socket }).socket = socket;
+				(conn as unknown as { handshakeDone: boolean }).handshakeDone = true;
+				(conn as unknown as { peerId: string }).peerId = result.peerId;
+
+				const remainder = buf.slice(HANDSHAKE_LEN);
+				if (remainder.length > 0) {
+					socket.emit("data", Buffer.from(remainder));
+				}
+
+				socket.on("data", (c: Buffer) => socket.emit("data", c));
+				this.connections.set(key, conn);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				log("handshake", `FAIL (inbound)  ${msg}`);
+				socket.destroy();
+			}
+		};
+
+		socket.on("data", onData);
+	}
+
+	getUnchoked(): PeerConnection[] {
+		return [...this.connections.values()].filter((c) => !c.amChoked);
+	}
+
+	startChoking(): void {
+		// BEP 3: recalculate every 10s, optimistic rotates every 30s
+		this.chokeTimer = setInterval(() => this.recalculateChokes(), 10_000);
+		this.optimisticTimer = setInterval(() => this.rotateOptimisticUnchoke(), 30_000);
+		// Run immediately so peers are unchoked on download start
+		this.recalculateChokes();
+	}
+
+	stopChoking(): void {
+		if (this.chokeTimer) clearInterval(this.chokeTimer);
+		if (this.optimisticTimer) clearInterval(this.optimisticTimer);
+		this.chokeTimer = null;
+		this.optimisticTimer = null;
+	}
+
+	private recalculateChokes(): void {
+		const peers = [...this.connections.values()];
+
+		// Snapshot rates and reset interval counters
+		for (const p of peers) {
+			p.downloadBytesPerSec = p.downloadedThisInterval;
+			p.uploadBytesPerSec = p.uploadedThisInterval;
+			p.downloadedThisInterval = 0;
+			p.uploadedThisInterval = 0;
+		}
+
+		// BEP 3: unchoke top 4 by download rate from them (reciprocation)
+		const interested = peers.filter((p) => p.peerInterested);
+		const sorted = [...interested].sort((a, b) => b.downloadBytesPerSec - a.downloadBytesPerSec);
+		const toUnchoke = new Set<string>();
+
+		for (let i = 0; i < Math.min(4, sorted.length); i++) {
+			const p = sorted[i];
+			if (p) toUnchoke.add(`${p.address}:${p.port}`);
+		}
+		if (this.optimisticKey) toUnchoke.add(this.optimisticKey);
+
+		// Apply choke/unchoke changes
+		for (const p of peers) {
+			const key = `${p.address}:${p.port}`;
+			const shouldUnchoke = toUnchoke.has(key);
+			const wasUnchoked = this.unchokedKeys.has(key);
+			if (shouldUnchoke && !wasUnchoked) p.sendUnchoke();
+			else if (!shouldUnchoke && wasUnchoked) p.sendChoke();
+		}
+		this.unchokedKeys = toUnchoke;
+
+		if (toUnchoke.size > 0) {
+			const labels = [...toUnchoke]
+				.slice(0, 4)
+				.map((k) => {
+					const c = this.connections.get(k);
+					const mbps = ((c?.downloadBytesPerSec ?? 0) / (1024 * 1024)).toFixed(1);
+					return `${c?.peerId.slice(0, 8) ?? k}(${mbps})`;
+				})
+				.join("  ");
+			const optLabel = this.optimisticKey
+				? `  opt: ${this.connections.get(this.optimisticKey)?.peerId.slice(0, 8) ?? this.optimisticKey}`
+				: "";
+			log("unchoke", `${labels}${optLabel}`);
+		}
+	}
+
+	private rotateOptimisticUnchoke(): void {
+		const choked = [...this.connections.values()].filter(
+			(p) => !this.unchokedKeys.has(`${p.address}:${p.port}`) && p.peerInterested,
+		);
+		if (choked.length === 0) return;
+
+		// BEP 3: new connections are 3× as likely — simplified: just pick random
+		const pick = choked[Math.floor(Math.random() * choked.length)];
+		if (!pick) return;
+
+		const key = `${pick.address}:${pick.port}`;
+		if (this.optimisticKey && this.optimisticKey !== key) {
+			// Choke the previous optimistic peer if not in regular slots
+			if (!this.unchokedKeys.has(this.optimisticKey)) {
+				this.connections.get(this.optimisticKey)?.sendChoke();
+			}
+		}
+		this.optimisticKey = key;
+		pick.sendUnchoke();
+		this.unchokedKeys.add(key);
+		log("unchoke-opt", `${pick.peerId.slice(0, 8)}  (optimistic slot)`);
+	}
+
+	private dedup(peers: PeerInfo[]): PeerInfo[] {
+		const seen = new Set<string>();
+		return peers.filter((p) => {
+			const k = `${p.ip}:${p.port}`;
+			if (seen.has(k)) return false;
+			seen.add(k);
+			return true;
+		});
+	}
+
+	private countBits(buf: Uint8Array): number {
+		let n = 0;
+		for (const byte of buf) {
+			let b = byte;
+			while (b) { n += b & 1; b >>>= 1; }
+		}
+		return n;
+	}
+
+	close(): void {
+		this.stopChoking();
+		for (const conn of this.connections.values()) {
+			conn.suppressDisconnect = true;
+			conn.destroy();
+		}
+		this.connections.clear();
+		this.listener.close();
+	}
+}

package/src/torrent/peer/message-buffer.ts

@@ -0,0 +1,31 @@
+export class MessageBuffer {
+	private buf = new Uint8Array(0);
+
+	push(chunk: Uint8Array): Uint8Array[] {
+		// Append chunk to internal buffer
+		const merged = new Uint8Array(this.buf.length + chunk.length);
+		merged.set(this.buf);
+		merged.set(chunk, this.buf.length);
+		this.buf = merged;
+
+		const messages: Uint8Array[] = [];
+
+		while (this.buf.length >= 4) {
+			const length =
+				((this.buf[0] ?? 0) << 24) |
+				((this.buf[1] ?? 0) << 16) |
+				((this.buf[2] ?? 0) << 8) |
+				(this.buf[3] ?? 0);
+
+			// length=0 is a keepalive — complete message is just the 4 length bytes
+			const totalLen = 4 + length;
+
+			if (this.buf.length < totalLen) break;
+
+			messages.push(this.buf.slice(0, totalLen));
+			this.buf = this.buf.slice(totalLen);
+		}
+
+		return messages;
+	}
+}

package/src/torrent/peer/peer-id.ts

@@ -0,0 +1,21 @@
+import { randomBytes } from "node:crypto";
+
+const PEER_ID_PREFIX = "-TT0001-";
+
+let _peerId: Uint8Array | null = null;
+
+export function getPeerId(): Uint8Array {
+	if (!_peerId) {
+		const prefix = Buffer.from(PEER_ID_PREFIX);
+		const random = randomBytes(20 - prefix.length);
+		_peerId = new Uint8Array(Buffer.concat([prefix, random]));
+	}
+	return _peerId;
+}
+
+export function peerIdToString(id: Uint8Array): string {
+	// Show ASCII prefix + hex for the random portion
+	const prefix = Buffer.from(id.slice(0, 8)).toString("ascii");
+	const hex = Buffer.from(id.slice(8)).toString("hex").slice(0, 12);
+	return `${prefix}${hex}...`;
+}

package/src/torrent/peer/protocol.ts

@@ -0,0 +1,123 @@
+export const MSG = {
+	KEEPALIVE: -1,
+	CHOKE: 0,
+	UNCHOKE: 1,
+	INTERESTED: 2,
+	NOT_INTERESTED: 3,
+	HAVE: 4,
+	BITFIELD: 5,
+	REQUEST: 6,
+	PIECE: 7,
+	CANCEL: 8,
+} as const;
+
+export type MessageType = (typeof MSG)[keyof typeof MSG];
+
+export interface PeerMessage {
+	type: MessageType;
+	payload?: Uint8Array;
+}
+
+export function encode(msg: PeerMessage): Uint8Array {
+	if (msg.type === MSG.KEEPALIVE) {
+		return new Uint8Array(4); // 4 zero bytes
+	}
+	const payload = msg.payload ?? new Uint8Array(0);
+	const buf = new Uint8Array(4 + 1 + payload.length);
+	const len = 1 + payload.length;
+	buf[0] = (len >>> 24) & 0xff;
+	buf[1] = (len >>> 16) & 0xff;
+	buf[2] = (len >>> 8) & 0xff;
+	buf[3] = len & 0xff;
+	buf[4] = msg.type as number;
+	buf.set(payload, 5);
+	return buf;
+}
+
+export function decode(raw: Uint8Array): PeerMessage {
+	const length =
+		((raw[0] ?? 0) << 24) |
+		((raw[1] ?? 0) << 16) |
+		((raw[2] ?? 0) << 8) |
+		(raw[3] ?? 0);
+
+	if (length === 0) return { type: MSG.KEEPALIVE };
+
+	const id = raw[4] as MessageType;
+	const payload = raw.length > 5 ? raw.slice(5) : undefined;
+	return { type: id, payload };
+}
+
+// Helpers to build specific message payloads
+
+export function encodeHave(pieceIndex: number): Uint8Array {
+	const payload = new Uint8Array(4);
+	payload[0] = (pieceIndex >>> 24) & 0xff;
+	payload[1] = (pieceIndex >>> 16) & 0xff;
+	payload[2] = (pieceIndex >>> 8) & 0xff;
+	payload[3] = pieceIndex & 0xff;
+	return encode({ type: MSG.HAVE, payload });
+}
+
+export function encodeRequest(
+	index: number,
+	begin: number,
+	length: number,
+): Uint8Array {
+	const payload = new Uint8Array(12);
+	const view = new DataView(payload.buffer);
+	view.setUint32(0, index);
+	view.setUint32(4, begin);
+	view.setUint32(8, length);
+	return encode({ type: MSG.REQUEST, payload });
+}
+
+export function encodeCancel(
+	index: number,
+	begin: number,
+	length: number,
+): Uint8Array {
+	const payload = new Uint8Array(12);
+	const view = new DataView(payload.buffer);
+	view.setUint32(0, index);
+	view.setUint32(4, begin);
+	view.setUint32(8, length);
+	return encode({ type: MSG.CANCEL, payload });
+}
+
+export function decodeHave(payload: Uint8Array): number {
+	return new DataView(payload.buffer, payload.byteOffset).getUint32(0);
+}
+
+export function decodeRequest(payload: Uint8Array): {
+	index: number;
+	begin: number;
+	length: number;
+} {
+	const view = new DataView(payload.buffer, payload.byteOffset);
+	return {
+		index: view.getUint32(0),
+		begin: view.getUint32(4),
+		length: view.getUint32(8),
+	};
+}
+
+export function decodePiece(payload: Uint8Array): {
+	index: number;
+	begin: number;
+	block: Uint8Array;
+} {
+	const view = new DataView(payload.buffer, payload.byteOffset);
+	return {
+		index: view.getUint32(0),
+		begin: view.getUint32(4),
+		block: payload.slice(8),
+	};
+}
+
+export function msgName(type: MessageType): string {
+	for (const [k, v] of Object.entries(MSG)) {
+		if (v === type) return k;
+	}
+	return `UNKNOWN(${type})`;
+}

package/src/torrent/piece-picker.ts

@@ -0,0 +1,58 @@
+import type { PeerConnection } from "./peer/connection.ts";
+
+export class PiecePicker {
+	private availability = new Map<number, number>(); // pieceIndex → peer count
+
+	constructor(
+		private pieceCount: number,
+		private hasPiece: (i: number) => boolean,
+		private isInProgress: (i: number) => boolean,
+	) {}
+
+	addPeer(conn: PeerConnection): void {
+		for (let i = 0; i < this.pieceCount; i++) {
+			if (conn.hasPiece(i)) {
+				this.availability.set(i, (this.availability.get(i) ?? 0) + 1);
+			}
+		}
+	}
+
+	removePeer(conn: PeerConnection): void {
+		for (let i = 0; i < this.pieceCount; i++) {
+			if (conn.hasPiece(i)) {
+				const n = (this.availability.get(i) ?? 1) - 1;
+				if (n <= 0) this.availability.delete(i);
+				else this.availability.set(i, n);
+			}
+		}
+	}
+
+	onHave(pieceIndex: number): void {
+		this.availability.set(pieceIndex, (this.availability.get(pieceIndex) ?? 0) + 1);
+	}
+
+	// Returns the lowest-availability unstarted piece this peer has that we need.
+	// In-progress pieces are handled by Tier 1 in nextBlock() — skip them here.
+	pick(conn: PeerConnection): number | null {
+		let best = -1;
+		let bestAvail = Infinity;
+
+		for (let i = 0; i < this.pieceCount; i++) {
+			if (this.hasPiece(i)) continue;
+			if (this.isInProgress(i)) continue; // Tier 1 handles these
+			if (!conn.hasPiece(i)) continue;
+
+			const avail = this.availability.get(i) ?? 1;
+			if (avail < bestAvail) {
+				bestAvail = avail;
+				best = i;
+			}
+		}
+
+		return best === -1 ? null : best;
+	}
+
+	availabilityOf(pieceIndex: number): number {
+		return this.availability.get(pieceIndex) ?? 0;
+	}
+}

package/src/torrent/session.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from "node:events";
+import { TorrentMetadata, log } from "./metadata.ts";
+import { StorageManager } from "./storage.ts";
+import { Downloader } from "./downloader.ts";
+import type { TorrentStatus } from "./types.ts";
+import type { PeerManager } from "./peer/manager.ts";
+
+export class TorrentSession extends EventEmitter {
+	readonly metadata: TorrentMetadata;
+	readonly storage: StorageManager;
+	readonly downloadPath: string;
+	status: TorrentStatus = "created";
+
+	constructor(metadata: TorrentMetadata, downloadPath: string) {
+		super();
+		this.metadata = metadata;
+		this.downloadPath = downloadPath;
+		this.storage = new StorageManager(metadata, downloadPath);
+	}
+
+	private transition(next: TorrentStatus): void {
+		const prev = this.status;
+		this.status = next;
+		this.emit("status", next, prev);
+	}
+
+	async start(): Promise<void> {
+		this.transition("verifying");
+		await this.storage.setup();
+		await this.storage.verifyAll();
+		this.transition("ready");
+	}
+
+	download(manager: PeerManager): Downloader {
+		this.transition("downloading");
+		const downloader = new Downloader(
+			this.metadata,
+			this.storage,
+			manager,
+			this.downloadPath,
+		);
+
+		downloader.on("piece:verified", (i: number) => this.emit("piece:verified", i));
+		downloader.on("piece:failed", (i: number, peer: string) => this.emit("piece:failed", i, peer));
+		downloader.on("progress", (dl: number, total: number, speed: number) =>
+			this.emit("progress", dl, total, speed),
+		);
+		downloader.on("complete", () => {
+			this.transition("seeding");
+			this.emit("complete");
+		});
+
+		downloader.start();
+		return downloader;
+	}
+}