torrent-tui 0.0.1

package/src/index.ts

@@ -0,0 +1,320 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { VERSION } from "./constants";
+import { getPeers } from "./torrent/get_peers";
+
+class CliExit extends Error {}
+
+function fail(msg: string): never {
+	console.error(msg);
+	process.exitCode = 1;
+	throw new CliExit();
+}
+
+function printHelp(): void {
+	console.log(`torrent-tui ${VERSION}
+
+Usage:
+  torrent-tui                         Start the terminal UI
+  torrent-tui <file.torrent>          Announce and print peers
+  torrent-tui <file.torrent> --verify Verify local pieces and trackers
+  torrent-tui <file.torrent> --handshake
+                                      Connect to peers and print handshake summary
+  torrent-tui <file.torrent> --download
+                                      Download from the command line
+
+Options:
+  --help, -h                          Show this help
+  --version, -v                       Print the version`);
+}
+
+function validateTorrentArg(arg: string): string {
+	if (!arg.toLowerCase().endsWith(".torrent")) {
+		fail(`Error: '${arg}' is not a .torrent file`);
+	}
+	if (!existsSync(arg)) {
+		fail(`Error: File not found: '${arg}'`);
+	}
+	return arg;
+}
+
+function sep(): void {
+	console.log("-".repeat(44));
+}
+
+async function loadTorrent(torrentPath: string) {
+	const { decode } = await import("./torrent/parser");
+	const { TorrentMetadata } = await import("./torrent/metadata");
+	const { TorrentSession } = await import("./torrent/session");
+	const { loadConfig } = await import("./config/index");
+
+	const config = loadConfig();
+	const { resolvePath } = await import("./utils/paths");
+	const downloadPath = resolvePath(config.downloadPath);
+	const raw = new Uint8Array(readFileSync(torrentPath));
+	const decoded = decode(raw);
+
+	if (
+		typeof decoded !== "object" ||
+		decoded === null ||
+		Array.isArray(decoded) ||
+		decoded instanceof Uint8Array
+	) {
+		fail("Invalid torrent file");
+	}
+
+	const metadata = new TorrentMetadata(
+		decoded as { [key: string]: import("./torrent/parser").BencodeValue },
+		raw,
+	);
+	const session = new TorrentSession(metadata, downloadPath);
+	return { metadata, session, downloadPath };
+}
+
+async function runVerify(torrentPath: string): Promise<void> {
+	const { log } = await import("./torrent/metadata");
+	const { announce } = await import("./torrent/tracker/announce");
+	const { metadata, session, downloadPath } = await loadTorrent(torrentPath);
+
+	metadata.logSummary();
+	await session.start();
+
+	const trackerResult = await announce(metadata).catch(() => null);
+	const peers = trackerResult?.peers ?? [];
+
+	let valid = 0;
+	let missing = 0;
+	const corrupt = 0;
+	for (let i = 0; i < metadata.pieceCount; i++) {
+		if (session.storage.hasPiece(i)) valid++;
+		else missing++;
+	}
+
+	console.log("");
+	sep();
+	console.log("  Verify Summary");
+	sep();
+	log(
+		"storage",
+		`${metadata.files.map((f) => join(downloadPath, f.path)).join(", ")}`,
+	);
+	log(
+		"verify",
+		`${valid} valid   ${missing} missing   ${corrupt} corrupt   (${metadata.pieceCount} total)`,
+	);
+	log("tracker", `${peers.length} peers`);
+	console.log("");
+	for (const file of metadata.files) {
+		const fullPath = join(downloadPath, file.path);
+		console.log(`  ${existsSync(fullPath) ? "✓" : "✗"}  ${fullPath}`);
+	}
+	sep();
+}
+
+async function runHandshake(torrentPath: string): Promise<void> {
+	const { announce } = await import("./torrent/tracker/announce");
+	const { PeerManager } = await import("./torrent/peer/manager");
+	const { getPeerId, peerIdToString } = await import("./torrent/peer/peer-id");
+	const { metadata, session } = await loadTorrent(torrentPath);
+
+	metadata.logSummary();
+	const { log } = await import("./torrent/metadata");
+	log("peer-id", peerIdToString(getPeerId()));
+
+	// session.start() internally logs storage + verify
+	await session.start();
+
+	// announce() internally logs tracker result
+	const trackerResult = await announce(metadata).catch(() => null);
+	const peers = trackerResult?.peers ?? [];
+
+	console.log("");
+
+	// manager.start() internally logs the listener port
+	const manager = new PeerManager(metadata);
+	await manager.start();
+
+	// connect() logs one "handshake" line per peer (success or timeout)
+	await manager.connect(peers);
+
+	// Wait up to 15s for bitfields and unchokes to arrive
+	await new Promise((r) => setTimeout(r, 15_000));
+
+	const connected = [...manager.connections.values()];
+	const unchoked = connected.filter((c) => !c.amChoked);
+	const failed = peers.length - connected.length;
+
+	// Summary
+	const W = 80;
+	const line = "-".repeat(W);
+	console.log(`\n${line}`);
+	console.log("  Connection Summary");
+	console.log(line);
+	console.log(`  attempted    ${peers.length}`);
+	console.log(
+		`  connected    ${connected.length}    unchoked ${unchoked.length}    failed ${failed}`,
+	);
+
+	if (connected.length > 0) {
+		const AW = 46; // address column width (fits longest IPv6+port)
+		const CW = 10; // client ID column
+		const PW = 13; // pieces column
+		console.log("");
+		console.log(
+			`  ${"address".padEnd(AW)}  ${"client".padEnd(CW)}  ${"pieces".padEnd(PW)}  choked`,
+		);
+		console.log(`  ${"-".repeat(W - 2)}`);
+		for (const c of connected) {
+			const addr = `${c.address}:${c.port}`.padEnd(AW);
+			const client = c.peerId.slice(0, 8).padEnd(CW);
+			const pieces = `${c.countPiecesPublic()}/${metadata.pieceCount}`.padEnd(
+				PW,
+			);
+			const choked = c.amChoked ? "yes" : "no";
+			console.log(`  ${addr}  ${client}  ${pieces}  ${choked}`);
+		}
+	}
+	console.log(line);
+
+	manager.close();
+}
+
+async function runDownload(torrentPath: string): Promise<void> {
+	const { announce } = await import("./torrent/tracker/announce");
+	const { PeerManager } = await import("./torrent/peer/manager");
+	const { getPeerId, peerIdToString } = await import("./torrent/peer/peer-id");
+	const { metadata, session } = await loadTorrent(torrentPath);
+	const { log } = await import("./torrent/metadata");
+
+	metadata.logSummary();
+	log("peer-id", peerIdToString(getPeerId()));
+
+	await session.start();
+
+	const trackerResult = await announce(metadata).catch(() => null);
+	const peers = trackerResult?.peers ?? [];
+
+	console.log("");
+	const manager = new PeerManager(metadata);
+	await manager.start();
+
+	// connect() now resolves only after each handshake completes —
+	// so all handshake logs finish before the progress bar starts
+	await manager.connect(peers);
+
+	if (manager.connections.size === 0) {
+		log("error", "no peers connected — cannot download");
+		manager.close();
+		return;
+	}
+
+	const unchoked = manager.getUnchoked().length;
+	log("peers", `${manager.connections.size} connected   ${unchoked} unchoked`);
+
+	manager.startChoking();
+	const downloader = session.download(manager);
+	log("log file", downloader.getLogFilePath());
+	console.log("");
+
+	await new Promise<void>((resolve) => {
+		session.on("complete", () => resolve());
+		process.on("SIGINT", () => {
+			downloader.stop();
+			resolve();
+		});
+	});
+
+	const downloaded = session.storage.downloadedCount;
+	const W = 80;
+	const line = "-".repeat(W);
+
+	console.log(`\n${line}`);
+	console.log("  Download Summary");
+	console.log(line);
+	console.log(`  torrent      ${metadata.name}`);
+	console.log(
+		`  pieces       ${downloaded} / ${metadata.pieceCount} downloaded`,
+	);
+	console.log(`  status       ${session.status}`);
+
+	if (downloaded > 0) {
+		const resumeDir = join(
+			(await import("./utils/paths")).getDataDir(),
+			"resume",
+		);
+		const hex = Buffer.from(metadata.infoHash).toString("hex");
+		console.log(`  resume       ${resumeDir}/${hex}.json`);
+	}
+
+	console.log("");
+	console.log("  files");
+	for (const file of metadata.files) {
+		const fullPath = join(session.downloadPath, file.path);
+		console.log(`    ${existsSync(fullPath) ? "✓" : "✗"}  ${fullPath}`);
+	}
+	console.log(line);
+
+	manager.close();
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+
+	if (args.includes("--help") || args.includes("-h")) {
+		printHelp();
+		return;
+	}
+
+	if (args.includes("--version") || args.includes("-v")) {
+		console.log(VERSION);
+		return;
+	}
+
+	const torrentArg = args.find((a) => !a.startsWith("--"));
+	const isVerify = args.includes("--verify");
+	const isHandshake = args.includes("--handshake");
+	const isDownload = args.includes("--download");
+
+	if (torrentArg) {
+		const torrentPath = validateTorrentArg(torrentArg);
+
+		if (isVerify) {
+			await runVerify(torrentPath).catch((e) =>
+				fail(`Error: ${e instanceof Error ? e.message : e}`),
+			);
+			return;
+		}
+
+		if (isHandshake) {
+			await runHandshake(torrentPath).catch((e) =>
+				fail(`Error: ${e instanceof Error ? e.message : e}`),
+			);
+			return;
+		}
+
+		if (isDownload) {
+			await runDownload(torrentPath).catch((e) =>
+				fail(`Error: ${e instanceof Error ? e.message : e}`),
+			);
+			return;
+		}
+
+		try {
+			await getPeers(torrentPath, 6881, 50);
+		} catch (e) {
+			fail(`Error: ${e instanceof Error ? e.message : e}`);
+		}
+
+		return;
+	}
+
+	const { App } = await import("./app");
+	const app = new App();
+	app.start();
+}
+
+main().catch((err: unknown) => {
+	if (err instanceof CliExit) return;
+	process.exitCode = 1;
+	console.error(`Error: ${err instanceof Error ? err.message : err}`);
+});

package/src/layout/add-torrent-dialog.ts

@@ -0,0 +1,170 @@
+import { readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { BoxRenderable, type CliRenderer, TextRenderable } from "@opentui/core";
+import { getTheme } from "../theme";
+import type { LayoutDimensions } from "../types/layout";
+import { resolvePath } from "../utils/paths";
+
+const DIALOG_WIDTH  = 60;
+const DIALOG_HEIGHT = 16;
+const INNER_W       = DIALOG_WIDTH - 2;
+const MARGIN        = 2;
+
+function truncateName(name: string): string {
+	const max = INNER_W - MARGIN * 2;
+	return name.length > max ? name.slice(0, max - 1) + "…" : name;
+}
+
+function setBg(node: BoxRenderable, bg: string | undefined): void {
+	(node as unknown as { backgroundColor: string | undefined }).backgroundColor = bg;
+}
+
+export class AddTorrentDialog {
+	private renderer: CliRenderer;
+	private layout: LayoutDimensions;
+	private torrentFolder: string;
+	private container: BoxRenderable | null = null;
+	private isOpen = false;
+	private files: Array<{ name: string; path: string }> = [];
+	private selectedIndex = 0;
+	private itemRows: BoxRenderable[] = [];
+
+	onSelect?: (filePath: string) => void;
+
+	constructor(renderer: CliRenderer, layout: LayoutDimensions, torrentFolder: string) {
+		this.renderer = renderer;
+		this.layout = layout;
+		this.torrentFolder = resolvePath(torrentFolder);
+	}
+
+	open(): void {
+		if (this.isOpen) return;
+		this.isOpen = true;
+		this.selectedIndex = 0;
+		this.files = this.scanTorrentFiles();
+		this.build();
+	}
+
+	close(): void {
+		if (!this.isOpen) return;
+		this.isOpen = false;
+		this.container?.destroy();
+		this.container = null;
+		this.itemRows = [];
+	}
+
+	getIsOpen(): boolean {
+		return this.isOpen;
+	}
+
+	handleInput(key: string): boolean {
+		if (!this.isOpen) return false;
+
+		if (key === "j" || key === "down") {
+			if (this.selectedIndex < this.files.length - 1) {
+				this.selectedIndex++;
+				this.updateHighlight();
+			}
+			return true;
+		}
+		if (key === "k" || key === "up") {
+			if (this.selectedIndex > 0) {
+				this.selectedIndex--;
+				this.updateHighlight();
+			}
+			return true;
+		}
+		if (key === "return") {
+			const file = this.files[this.selectedIndex];
+			if (file) {
+				const path = file.path;
+				this.close();
+				this.onSelect?.(path);
+			}
+			return true;
+		}
+		return false;
+	}
+
+	updateLayout(layout: LayoutDimensions): void {
+		this.layout = layout;
+	}
+
+	private updateHighlight(): void {
+		const theme = getTheme();
+		for (let i = 0; i < this.itemRows.length; i++) {
+			setBg(this.itemRows[i]!, i === this.selectedIndex ? theme.bgTertiary : undefined);
+		}
+	}
+
+	private build(): void {
+		const theme = getTheme();
+		const left = Math.max(0, Math.floor((this.layout.terminal.width  - DIALOG_WIDTH)  / 2));
+		const top  = Math.max(0, Math.floor((this.layout.terminal.height - DIALOG_HEIGHT) / 2));
+
+		const container = new BoxRenderable(this.renderer, {
+			position: "absolute",
+			left,
+			top,
+			width: DIALOG_WIDTH,
+			height: DIALOG_HEIGHT,
+			border: true,
+			borderColor: theme.border,
+			flexDirection: "column",
+		});
+
+		// Title row
+		const titleRow = new BoxRenderable(this.renderer, {
+			width: INNER_W,
+			height: 1,
+			flexDirection: "row",
+			justifyContent: "space-between",
+			paddingLeft: MARGIN,
+			paddingRight: MARGIN,
+		});
+		titleRow.add(new TextRenderable(this.renderer, { content: "Add Torrent", fg: theme.accent }));
+		titleRow.add(new TextRenderable(this.renderer, { content: "Esc to close", fg: theme.fgMuted }));
+		container.add(titleRow);
+
+		// Spacer
+		container.add(new TextRenderable(this.renderer, { content: "" }));
+
+		this.itemRows = [];
+
+		if (this.files.length === 0) {
+			container.add(new TextRenderable(this.renderer, {
+				content: " ".repeat(MARGIN) + `No .torrent files in ${this.torrentFolder}`,
+				fg: theme.fgMuted,
+			}));
+		} else {
+			for (let i = 0; i < this.files.length; i++) {
+				const file = this.files[i]!;
+				const row = new BoxRenderable(this.renderer, {
+					width: INNER_W,
+					height: 1,
+					backgroundColor: i === this.selectedIndex ? theme.bgTertiary : undefined,
+				});
+				row.add(new TextRenderable(this.renderer, {
+					content: " ".repeat(MARGIN) + truncateName(file.name),
+					fg: i === this.selectedIndex ? theme.fgPrimary : theme.fgSecondary,
+				}));
+				container.add(row);
+				this.itemRows.push(row);
+			}
+		}
+
+		this.renderer.root.add(container);
+		this.container = container;
+	}
+
+	private scanTorrentFiles(): Array<{ name: string; path: string }> {
+		if (!existsSync(this.torrentFolder)) return [];
+		try {
+			return readdirSync(this.torrentFolder)
+				.filter((f) => f.toLowerCase().endsWith(".torrent"))
+				.map((f) => ({ name: f, path: join(this.torrentFolder, f) }));
+		} catch {
+			return [];
+		}
+	}
+}

package/src/layout/confirm-dialog.ts

@@ -0,0 +1,141 @@
+import { BoxRenderable, type CliRenderer, TextRenderable } from "@opentui/core";
+import { getTheme } from "../theme";
+import type { LayoutDimensions } from "../types/layout";
+
+const DIALOG_WIDTH  = 38;
+const DIALOG_HEIGHT = 7;
+
+export class ConfirmDialog {
+	private renderer: CliRenderer;
+	private layout: LayoutDimensions;
+	private container: BoxRenderable | null = null;
+	private confirmBtn: TextRenderable | null = null;
+	private cancelBtn: TextRenderable | null = null;
+	private isOpen = false;
+	private focusedBtn: "confirm" | "cancel" = "cancel";
+
+	onConfirm?: () => void;
+	onCancel?: () => void;
+
+	constructor(renderer: CliRenderer, layout: LayoutDimensions) {
+		this.renderer = renderer;
+		this.layout = layout;
+	}
+
+	open(message: string): void {
+		if (this.isOpen) return;
+		this.isOpen = true;
+		this.focusedBtn = "cancel";
+		this.build(message);
+	}
+
+	close(): void {
+		if (!this.isOpen) return;
+		this.isOpen = false;
+		this.container?.destroy();
+		this.container = null;
+		this.confirmBtn = null;
+		this.cancelBtn = null;
+	}
+
+	getIsOpen(): boolean {
+		return this.isOpen;
+	}
+
+	handleInput(key: string): boolean {
+		if (!this.isOpen) return false;
+		if (key === "tab" || key === "h" || key === "l" || key === "left" || key === "right") {
+			this.focusedBtn = this.focusedBtn === "confirm" ? "cancel" : "confirm";
+			this.updateButtons();
+			return true;
+		}
+		if (key === "return" || key === "y") {
+			if (key === "y" || this.focusedBtn === "confirm") {
+				this.close();
+				this.onConfirm?.();
+				return true;
+			}
+			this.close();
+			this.onCancel?.();
+			return true;
+		}
+		if (key === "n" || key === "escape") {
+			this.close();
+			this.onCancel?.();
+			return true;
+		}
+		return true;
+	}
+
+	updateLayout(layout: LayoutDimensions): void {
+		this.layout = layout;
+	}
+
+	private updateButtons(): void {
+		const theme = getTheme();
+		if (this.confirmBtn) {
+			(this.confirmBtn as unknown as { fg: string }).fg =
+				this.focusedBtn === "confirm" ? theme.error : theme.fgMuted;
+		}
+		if (this.cancelBtn) {
+			(this.cancelBtn as unknown as { fg: string }).fg =
+				this.focusedBtn === "cancel" ? theme.accent : theme.fgMuted;
+		}
+	}
+
+	private build(message: string): void {
+		const theme = getTheme();
+		const left = Math.max(0, Math.floor((this.layout.terminal.width  - DIALOG_WIDTH)  / 2));
+		const top  = Math.max(0, Math.floor((this.layout.terminal.height - DIALOG_HEIGHT) / 2));
+
+		const container = new BoxRenderable(this.renderer, {
+			position: "absolute",
+			left,
+			top,
+			width: DIALOG_WIDTH,
+			height: DIALOG_HEIGHT,
+			border: true,
+			borderColor: theme.warning,
+			flexDirection: "column",
+		});
+
+		const inner = DIALOG_WIDTH - 2;
+
+		container.add(new TextRenderable(this.renderer, { content: " ".repeat(inner) }));
+		container.add(new TextRenderable(this.renderer, {
+			content: ("  " + message).padEnd(inner),
+			fg: theme.fgPrimary,
+		}));
+		container.add(new TextRenderable(this.renderer, { content: " ".repeat(inner) }));
+		container.add(new TextRenderable(this.renderer, {
+			content: "  Files will be deleted from disk.".padEnd(inner),
+			fg: theme.fgSecondary,
+		}));
+		container.add(new TextRenderable(this.renderer, { content: " ".repeat(inner) }));
+
+		const btnRow = new BoxRenderable(this.renderer, {
+			width: inner,
+			height: 1,
+			flexDirection: "row",
+			justifyContent: "space-between",
+			paddingLeft: 2,
+			paddingRight: 2,
+		});
+
+		this.confirmBtn = new TextRenderable(this.renderer, {
+			content: "[y] Confirm",
+			fg: theme.fgMuted,
+		});
+		this.cancelBtn = new TextRenderable(this.renderer, {
+			content: "[n] Cancel",
+			fg: theme.accent,
+		});
+
+		btnRow.add(this.confirmBtn);
+		btnRow.add(this.cancelBtn);
+		container.add(btnRow);
+
+		this.renderer.root.add(container);
+		this.container = container;
+	}
+}

package/src/layout/content-window.ts

@@ -0,0 +1,80 @@
+import { BoxRenderable, type CliRenderer } from "@opentui/core";
+import type { Store } from "../store";
+import { getTheme } from "../theme";
+import type { LayoutDimensions } from "../types/layout";
+import { filterTorrents } from "../utils/filter";
+import { TorrentTable } from "./torrent-view";
+
+function innerLayout(layout: LayoutDimensions): LayoutDimensions {
+	return {
+		...layout,
+		content: {
+			...layout.content,
+			width: layout.content.width - 2,
+			height: layout.content.height - 2,
+		},
+	};
+}
+
+export class ContentWindow {
+	private renderer: CliRenderer;
+	private store: Store;
+	private layout: LayoutDimensions;
+	private container: BoxRenderable;
+	private torrentTable: TorrentTable;
+
+	constructor(renderer: CliRenderer, store: Store, layout: LayoutDimensions) {
+		this.renderer = renderer;
+		this.store = store;
+		this.layout = layout;
+		this.torrentTable = new TorrentTable(renderer, innerLayout(layout));
+		this.container = this.build();
+		this.renderer.root.add(this.container);
+	}
+
+	update(focusArea: "sidebar" | "table", selectedIndex: number): void {
+		const theme = getTheme();
+		const state = this.store.getState();
+		(this.container as unknown as { borderColor: string }).borderColor =
+			focusArea === "table" ? theme.accent : theme.border;
+		const visible = filterTorrents(state.torrents, state.selectedView);
+		this.torrentTable.update(visible, selectedIndex, focusArea);
+	}
+
+	updateLayout(layout: LayoutDimensions): void {
+		this.layout = layout;
+		(this.container as unknown as { left: number }).left = layout.content.x;
+		(this.container as unknown as { top: number }).top = layout.content.y;
+		(this.container as unknown as { width: number }).width = layout.content.width;
+		(this.container as unknown as { height: number }).height = layout.content.height;
+		this.torrentTable.updateLayout(innerLayout(layout));
+	}
+
+	private build(): BoxRenderable {
+		const theme = getTheme();
+		const layout = this.layout;
+
+		const container = new BoxRenderable(this.renderer, {
+			position: "absolute",
+			left: layout.content.x,
+			top: layout.content.y,
+			width: layout.content.width,
+			height: layout.content.height,
+			border: true,
+			borderColor: theme.border,
+		});
+
+		// Inner wrapper offset by 1 on each side to sit inside the border
+		const inner = new BoxRenderable(this.renderer, {
+			position: "absolute",
+			left: 1,
+			top: 1,
+			width: layout.content.width - 2,
+			height: layout.content.height - 2,
+		});
+		inner.add(this.torrentTable.getContainer());
+		container.add(inner);
+
+		return container;
+	}
+}