torrent-tui 0.0.1

package/src/torrent/storage.ts

@@ -0,0 +1,197 @@
+import {
+	existsSync,
+	mkdirSync,
+	openSync,
+	closeSync,
+	ftruncateSync,
+	readSync,
+	writeSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { SHA1 } from "bun";
+import { log } from "./metadata.ts";
+import type { TorrentMetadata } from "./metadata.ts";
+
+function formatSize(bytes: number): string {
+	const gb = bytes / (1024 * 1024 * 1024);
+	if (gb >= 1) return `${gb.toFixed(1)} GB`;
+	const mb = bytes / (1024 * 1024);
+	if (mb >= 1) return `${mb.toFixed(1)} MB`;
+	return `${(bytes / 1024).toFixed(1)} KB`;
+}
+
+export class StorageManager {
+	private readonly downloadPath: string;
+	private readonly downloadedPieces = new Set<number>();
+
+	constructor(
+		private readonly metadata: TorrentMetadata,
+		basePath: string,
+	) {
+		this.downloadPath = basePath;
+	}
+
+	async setup(): Promise<void> {
+		for (const file of this.metadata.files) {
+			const fullPath = join(this.downloadPath, file.path);
+			const dir = dirname(fullPath);
+			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+			if (!existsSync(fullPath)) {
+				// Sparse file: tells the OS the file size with no RAM allocation.
+				// Unwritten regions read as zeros.
+				const fd = openSync(fullPath, "w");
+				ftruncateSync(fd, file.length);
+				closeSync(fd);
+				log("storage", `created   ${fullPath}  (${formatSize(file.length)})`);
+			} else {
+				log("storage", `exists    ${fullPath}  (${formatSize(file.length)})`);
+			}
+		}
+	}
+
+	readPieceSync(pieceIndex: number): Buffer {
+		const ranges = this.metadata.pieceToFileRanges(pieceIndex);
+		const isLastPiece = pieceIndex === this.metadata.pieceCount - 1;
+		const pieceLen = isLastPiece
+			? this.metadata.totalSize - pieceIndex * this.metadata.pieceLength
+			: this.metadata.pieceLength;
+
+		const result = Buffer.allocUnsafe(pieceLen);
+		let written = 0;
+
+		for (const { file, fileOffset, length } of ranges) {
+			const fullPath = join(this.downloadPath, file.path);
+			const fd = openSync(fullPath, "r");
+			readSync(fd, result, written, length, fileOffset);
+			closeSync(fd);
+			written += length;
+		}
+
+		return result;
+	}
+
+	async readPiece(pieceIndex: number): Promise<Uint8Array> {
+		return this.readPieceSync(pieceIndex);
+	}
+
+	writePieceSync(pieceIndex: number, data: Uint8Array): void {
+		const ranges = this.metadata.pieceToFileRanges(pieceIndex);
+		let offset = 0;
+
+		for (const { file, fileOffset, length } of ranges) {
+			const fullPath = join(this.downloadPath, file.path);
+			const fd = openSync(fullPath, "r+");
+			writeSync(fd, data, offset, length, fileOffset);
+			closeSync(fd);
+			offset += length;
+		}
+
+		this.downloadedPieces.add(pieceIndex);
+	}
+
+	async writePiece(pieceIndex: number, data: Uint8Array): Promise<void> {
+		this.writePieceSync(pieceIndex, data);
+	}
+
+	async verifyPiece(pieceIndex: number): Promise<boolean> {
+		const expected = this.metadata.pieceHashes[pieceIndex];
+		if (!expected) return false;
+
+		const data = this.readPieceSync(pieceIndex);
+		if (isAllZero(data)) return false;
+
+		const actual = new SHA1().update(data).digest() as unknown as Uint8Array;
+		return bufEqual(actual, expected);
+	}
+
+	// Opens each file once and reads through it sequentially — no per-piece open/close.
+	async verifyAll(): Promise<{ valid: number; missing: number; corrupt: number }> {
+		let valid = 0;
+		let missing = 0;
+		let corrupt = 0;
+
+		const pieceBuf = Buffer.allocUnsafe(this.metadata.pieceLength);
+
+		for (let i = 0; i < this.metadata.pieceCount; i++) {
+			const isLastPiece = i === this.metadata.pieceCount - 1;
+			const pieceLen = isLastPiece
+				? this.metadata.totalSize - i * this.metadata.pieceLength
+				: this.metadata.pieceLength;
+
+			const data = pieceBuf.subarray(0, pieceLen);
+			let written = 0;
+
+			for (const { file, fileOffset, length } of this.metadata.pieceToFileRanges(i)) {
+				const fullPath = join(this.downloadPath, file.path);
+				const fd = openSync(fullPath, "r");
+				readSync(fd, data, written, length, fileOffset);
+				closeSync(fd);
+				written += length;
+			}
+
+			if (isAllZero(data)) {
+				missing++;
+				continue;
+			}
+
+			const expected = this.metadata.pieceHashes[i];
+			if (!expected) { corrupt++; continue; }
+
+			const actual = new SHA1().update(data).digest() as unknown as Uint8Array;
+			if (bufEqual(actual, expected)) {
+				valid++;
+				this.downloadedPieces.add(i);
+			} else {
+				corrupt++;
+			}
+		}
+
+		log("verify", `${this.metadata.pieceCount} pieces checked   ${valid} valid   ${missing} missing   ${corrupt} corrupt`);
+		return { valid, missing, corrupt };
+	}
+
+	markPiece(index: number): void {
+		this.downloadedPieces.add(index);
+	}
+
+	hasPiece(pieceIndex: number): boolean {
+		return this.downloadedPieces.has(pieceIndex);
+	}
+
+	get downloadedCount(): number {
+		return this.downloadedPieces.size;
+	}
+
+	getDownloadedPieces(): ReadonlySet<number> {
+		return this.downloadedPieces;
+	}
+
+	getBitfield(): Uint8Array {
+		const byteCount = Math.ceil(this.metadata.pieceCount / 8);
+		const bitfield = new Uint8Array(byteCount);
+		for (const i of this.downloadedPieces) {
+			const byte = Math.floor(i / 8);
+			const bit = 7 - (i % 8);
+			if (byte < byteCount) {
+				bitfield[byte] = (bitfield[byte] ?? 0) | (1 << bit);
+			}
+		}
+		return bitfield;
+	}
+}
+
+function isAllZero(buf: Uint8Array): boolean {
+	for (let i = 0; i < buf.length; i++) {
+		if (buf[i] !== 0) return false;
+	}
+	return true;
+}
+
+function bufEqual(a: Uint8Array, b: Uint8Array): boolean {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false;
+	}
+	return true;
+}

package/src/torrent/tracker/announce.ts

@@ -0,0 +1,36 @@
+import { log } from "../metadata.ts";
+import { announceHTTP } from "./http-tracker.ts";
+import { announceUDP } from "./udp-tracker.ts";
+import type { TorrentMetadata } from "../metadata.ts";
+import type { TrackerResponse } from "../types.ts";
+
+export async function announce(
+	metadata: TorrentMetadata,
+	port = 6881,
+	numwant = 50,
+): Promise<TrackerResponse> {
+	const flat = metadata.announceList.flat();
+	const hasHTTP = flat.some((u) => u.startsWith("http"));
+	const udpUrls = [...new Set(flat.filter((u) => u.startsWith("udp://")))];
+
+	const [httpPeers, udpResults] = await Promise.all([
+		hasHTTP ? announceHTTP(metadata, port, numwant) : Promise.resolve([]),
+		Promise.allSettled(udpUrls.map((u) => announceUDP(u, metadata, port))),
+	]);
+
+	const seen = new Set<string>(httpPeers.map((p) => `${p.ip}:${p.port}`));
+	const allPeers = [...httpPeers];
+
+	for (const r of udpResults) {
+		if (r?.status === "fulfilled") {
+			for (const p of r.value) {
+				const k = `${p.ip}:${p.port}`;
+				if (!seen.has(k)) { seen.add(k); allPeers.push(p); }
+			}
+		}
+	}
+
+	log("tracker", `${allPeers.length} unique peers`);
+
+	return { complete: 0, incomplete: 0, interval: 1800, peers: allPeers };
+}

package/src/torrent/tracker/http-tracker.ts

@@ -0,0 +1,143 @@
+import { decode } from "../parser.ts";
+import { log } from "../metadata.ts";
+import { getPeerId } from "../peer/peer-id.ts";
+import type { TorrentMetadata } from "../metadata.ts";
+import type { PeerInfo, TrackerResponse } from "../types.ts";
+
+const TEXT_DECODER = new TextDecoder();
+
+// RFC 3986: unreserved characters must NOT be percent-encoded.
+// Encoding them anyway causes tracker hash mismatches (Ubuntu's tracker enforces this).
+function encodeBytes(buf: Uint8Array): string {
+	let result = "";
+	for (const byte of buf) {
+		if (
+			(byte >= 0x30 && byte <= 0x39) || // 0-9
+			(byte >= 0x41 && byte <= 0x5a) || // A-Z
+			(byte >= 0x61 && byte <= 0x7a) || // a-z
+			byte === 0x2d || // -
+			byte === 0x5f || // _
+			byte === 0x2e || // .
+			byte === 0x7e    // ~
+		) {
+			result += String.fromCharCode(byte);
+		} else {
+			result += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+		}
+	}
+	return result;
+}
+
+function parseDictPeers(list: import("../parser.ts").BencodeValue[]): PeerInfo[] {
+	const peers: PeerInfo[] = [];
+	for (const entry of list) {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry) || entry instanceof Uint8Array) continue;
+		const ipRaw = entry["ip"];
+		const port = entry["port"];
+		if (typeof port !== "number") continue;
+		const ip = ipRaw instanceof Uint8Array ? TEXT_DECODER.decode(ipRaw) : typeof ipRaw === "string" ? ipRaw : null;
+		if (ip) peers.push({ ip, port });
+	}
+	return peers;
+}
+
+function parseCompactPeers(data: Uint8Array): PeerInfo[] {
+	const peers: PeerInfo[] = [];
+	if (data.length % 6 !== 0) return peers;
+	for (let i = 0; i < data.length; i += 6) {
+		const ip = `${data[i]}.${data[i + 1]}.${data[i + 2]}.${data[i + 3]}`;
+		const port = ((data[i + 4] ?? 0) << 8) | (data[i + 5] ?? 0);
+		peers.push({ ip, port });
+	}
+	return peers;
+}
+
+async function announceToTracker(
+	url: string,
+	metadata: TorrentMetadata,
+	peerId: Uint8Array,
+	port: number,
+	numwant: number,
+): Promise<PeerInfo[]> {
+	const params = [
+		`info_hash=${encodeBytes(metadata.infoHash)}`,
+		`peer_id=${encodeBytes(peerId)}`,
+		`port=${port}`,
+		`uploaded=0`,
+		`downloaded=0`,
+		`left=${metadata.totalSize}`,
+		`compact=1`,
+		`event=started`,
+		`numwant=${numwant}`,
+	].join("&");
+
+	const fullUrl = url.includes("?") ? `${url}&${params}` : `${url}?${params}`;
+
+	// AbortSignal.timeout doesn't abort TCP-level hangs in Bun — use Promise.race
+	const res = await Promise.race([
+		fetch(fullUrl, { headers: { "User-Agent": "torrent-tui/0.1" } }),
+		new Promise<never>((_, rej) => setTimeout(() => rej(new Error("The operation timed out.")), 10_000)),
+	]);
+
+	if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+	const buffer = new Uint8Array(await res.arrayBuffer());
+	const decoded = decode(buffer);
+
+	if (
+		typeof decoded !== "object" ||
+		decoded === null ||
+		Array.isArray(decoded) ||
+		decoded instanceof Uint8Array
+	) {
+		throw new Error("Invalid tracker response");
+	}
+
+	if ("failure reason" in decoded) {
+		throw new Error(`Tracker failure: ${TEXT_DECODER.decode(decoded["failure reason"] as Uint8Array)}`);
+	}
+
+	const peersRaw = decoded["peers"];
+
+	// Compact format: binary blob, 6 bytes per IPv4 peer
+	if (peersRaw instanceof Uint8Array) {
+		return parseCompactPeers(peersRaw);
+	}
+
+	// Dictionary format: list of {ip, port, peer id} dicts (used for IPv6 or non-compact)
+	if (Array.isArray(peersRaw)) {
+		return parseDictPeers(peersRaw);
+	}
+
+	return [];
+}
+
+export async function announceHTTP(
+	metadata: TorrentMetadata,
+	port = 6881,
+	numwant = 50,
+): Promise<PeerInfo[]> {
+	const peerId = getPeerId();
+	const urls = [...new Set(
+		metadata.announceList.flat().filter((u) => u.startsWith("http://") || u.startsWith("https://")),
+	)];
+
+	const results = await Promise.allSettled(
+		urls.map((u) => announceToTracker(u, metadata, peerId, port, numwant)),
+	);
+
+	const peers: PeerInfo[] = [];
+	for (let i = 0; i < results.length; i++) {
+		const r = results[i];
+		const url = urls[i];
+		if (r === undefined || url === undefined) continue;
+		if (r.status === "fulfilled") {
+			peers.push(...r.value);
+			log("tracker", `${url}   ${r.value.length} peers`);
+		} else {
+			const reason = r.reason instanceof Error ? r.reason.message : String(r.reason);
+			log("tracker", `${url}   failed  ${reason}`);
+		}
+	}
+	return peers;
+}

package/src/torrent/tracker/udp-tracker.ts

@@ -0,0 +1,136 @@
+import { createSocket } from "node:dgram";
+import { randomBytes } from "node:crypto";
+import { log } from "../metadata.ts";
+import { getPeerId } from "../peer/peer-id.ts";
+import type { TorrentMetadata } from "../metadata.ts";
+import type { PeerInfo } from "../types.ts";
+
+const CONNECT_MAGIC = 0x41727101980n; // BEP 15 magic connection ID
+const CONNECT_ACTION = 0;
+const ANNOUNCE_ACTION = 1;
+const TIMEOUT_MS = 5_000;
+const MAX_RETRIES = 1; // no retries on initial announce — re-announces can retry later
+
+function randomTransactionId(): number {
+	return randomBytes(4).readUInt32BE(0);
+}
+
+function buildConnectRequest(): { buf: Buffer; txId: number } {
+	const buf = Buffer.alloc(16);
+	const view = new DataView(buf.buffer);
+	view.setBigInt64(0, CONNECT_MAGIC);
+	view.setInt32(8, CONNECT_ACTION);
+	const txId = randomTransactionId();
+	view.setUint32(12, txId);
+	return { buf, txId };
+}
+
+function buildAnnounceRequest(
+	connId: bigint, // treated as unsigned
+	metadata: TorrentMetadata,
+	listenPort: number,
+): { buf: Buffer; txId: number } {
+	const buf = Buffer.alloc(98);
+	const view = new DataView(buf.buffer);
+	let offset = 0;
+
+	view.setBigUint64(offset, connId); offset += 8;
+	view.setInt32(offset, ANNOUNCE_ACTION); offset += 4;
+	const txId = randomTransactionId();
+	view.setUint32(offset, txId); offset += 4;
+	buf.set(metadata.infoHash, offset); offset += 20;
+	buf.set(getPeerId(), offset); offset += 20;
+	view.setBigInt64(offset, 0n); offset += 8;            // downloaded
+	view.setBigInt64(offset, BigInt(metadata.totalSize)); offset += 8; // left
+	view.setBigInt64(offset, 0n); offset += 8;            // uploaded
+	view.setInt32(offset, 2); offset += 4;                // event: started
+	view.setUint32(offset, 0); offset += 4;               // ip: default
+	view.setUint32(offset, 0); offset += 4;               // key
+	view.setInt32(offset, 50); offset += 4;               // num_want
+	view.setUint16(offset, listenPort);                    // port
+
+	return { buf, txId };
+}
+
+function parseCompactPeers(buf: Buffer, offset: number): PeerInfo[] {
+	const peers: PeerInfo[] = [];
+	while (offset + 6 <= buf.length) {
+		const ip = `${buf[offset]}.${buf[offset + 1]}.${buf[offset + 2]}.${buf[offset + 3]}`;
+		const port = buf.readUInt16BE(offset + 4);
+		peers.push({ ip, port });
+		offset += 6;
+	}
+	return peers;
+}
+
+function sendAndReceive(
+	socket: ReturnType<typeof createSocket>,
+	buf: Buffer,
+	host: string,
+	port: number,
+): Promise<Buffer> {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(new Error("timeout"));
+		}, TIMEOUT_MS);
+
+		socket.once("message", (msg) => {
+			clearTimeout(timer);
+			resolve(msg as Buffer);
+		});
+
+		socket.send(buf, port, host, (err) => {
+			if (err) { clearTimeout(timer); reject(err); }
+		});
+	});
+}
+
+export async function announceUDP(
+	url: string,
+	metadata: TorrentMetadata,
+	listenPort = 6881,
+): Promise<PeerInfo[]> {
+	const parsed = new URL(url);
+	const host = parsed.hostname;
+	const port = Number(parsed.port) || 80;
+	const label = `${host}:${port}`;
+
+	for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+		const socket = createSocket("udp4");
+
+		try {
+			// Step 1: connect
+			const { buf: connectBuf, txId: connectTx } = buildConnectRequest();
+			const connectResp = await sendAndReceive(socket, connectBuf, host, port);
+
+			const view = new DataView(connectResp.buffer, connectResp.byteOffset);
+			if (view.getInt32(0) !== CONNECT_ACTION) throw new Error("bad connect action");
+			if (view.getUint32(4) !== connectTx) throw new Error("connect txId mismatch");
+			const connId = view.getBigUint64(8);
+
+			// Step 2: announce
+			const { buf: annBuf, txId: annTx } = buildAnnounceRequest(connId, metadata, listenPort);
+			const annResp = await sendAndReceive(socket, annBuf, host, port);
+
+			const annView = new DataView(annResp.buffer, annResp.byteOffset);
+			if (annView.getInt32(0) !== ANNOUNCE_ACTION) throw new Error("bad announce action");
+			if (annView.getUint32(4) !== annTx) throw new Error("announce txId mismatch");
+
+			const peers = parseCompactPeers(annResp, 20);
+			log("tracker", `udp://${label}   ${peers.length} peers`);
+			return peers;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			if (attempt < MAX_RETRIES) {
+				// silent retry
+			} else {
+				log("tracker", `udp://${label}   failed  ${msg}`);
+				throw err;
+			}
+		} finally {
+			socket.close();
+		}
+	}
+
+	throw new Error("max retries exceeded");
+}

package/src/torrent/types.ts

@@ -0,0 +1,25 @@
+export interface PeerInfo {
+	ip: string;
+	port: number;
+}
+
+export interface TrackerResponse {
+	complete: number;
+	incomplete: number;
+	interval: number;
+	peers: PeerInfo[];
+}
+
+export interface FileInfo {
+	path: string;
+	length: number;
+	offset: number; // byte offset in the flat concatenated stream
+}
+
+export type TorrentStatus =
+	| "created"
+	| "verifying"
+	| "ready"
+	| "downloading"
+	| "seeding"
+	| "stopped";

package/src/types/layout.ts

@@ -0,0 +1,6 @@
+export interface LayoutDimensions {
+	terminal: { width: number; height: number };
+	sidebar: { x: number; y: number; width: number; height: number };
+	content: { x: number; y: number; width: number; height: number };
+	statusBar: { x: number; y: number; width: number; height: number };
+}

package/src/utils/env.ts

@@ -0,0 +1,8 @@
+// Typed environment variable accessors
+
+export const env = {
+	OTUI_SHOW_STATS: process.env.OTUI_SHOW_STATS === "true",
+	SHOW_CONSOLE: process.env.SHOW_CONSOLE === "true",
+	CONFIG_PATH: process.env.CONFIG_PATH,
+	DEV: process.env.DEV === "true",
+} as const;

package/src/utils/filter.ts

@@ -0,0 +1,12 @@
+import type { TorrentState } from "../store";
+
+export function filterTorrents(torrents: TorrentState[], view: string): TorrentState[] {
+	switch (view) {
+		case "Downloading": return torrents.filter((t) => t.status === "downloading");
+		case "Seeding":
+		case "Completed":   return torrents.filter((t) => t.status === "seeding");
+		case "Paused":      return torrents.filter((t) => t.status === "paused");
+		case "Stopped":     return torrents.filter((t) => t.status === "stopped" || t.status === "error");
+		default:            return torrents;
+	}
+}

package/src/utils/layout.ts

@@ -0,0 +1,32 @@
+import { SIDEBAR_WIDTH } from "../constants";
+import type { LayoutDimensions } from "../types/layout";
+
+const STATUS_BAR_HEIGHT = 1;
+
+export function calculateLayout(
+	terminalWidth: number,
+	terminalHeight: number,
+): LayoutDimensions {
+	const contentHeight = terminalHeight - STATUS_BAR_HEIGHT;
+	return {
+		terminal: { width: terminalWidth, height: terminalHeight },
+		sidebar: {
+			x: 0,
+			y: 0,
+			width: SIDEBAR_WIDTH,
+			height: contentHeight,
+		},
+		content: {
+			x: SIDEBAR_WIDTH,
+			y: 0,
+			width: terminalWidth - SIDEBAR_WIDTH,
+			height: contentHeight,
+		},
+		statusBar: {
+			x: 0,
+			y: contentHeight,
+			width: terminalWidth,
+			height: STATUS_BAR_HEIGHT,
+		},
+	};
+}

package/src/utils/paths.ts

@@ -0,0 +1,17 @@
+import { APP_NAME } from "../constants";
+
+export function getConfigDir(): string {
+	return `${process.env.XDG_CONFIG_HOME ?? `${process.env.HOME}/.config`}/${APP_NAME}`;
+}
+
+export function getConfigPath(filename: string): string {
+	return `${getConfigDir()}/${filename}`;
+}
+
+export function getDataDir(): string {
+	return `${process.env.XDG_DATA_HOME ?? `${process.env.HOME}/.local/share`}/${APP_NAME}`;
+}
+
+export function resolvePath(p: string): string {
+	return p.replace(/^~/, process.env.HOME ?? ".");
+}