torrent-tui 0.0.1

package/src/layout/torrent-view.ts

@@ -0,0 +1,250 @@
+import { BoxRenderable, type CliRenderer, TextRenderable } from "@opentui/core";
+import type { TorrentState } from "../store";
+import { getTheme } from "../theme";
+import type { LayoutDimensions } from "../types/layout";
+
+const PREFIX_W = 2;
+const SUFFIX_W = 3;
+const SIZE_W   = 9;
+const SEP_W    = 2;
+const STATUS_W = 13;
+const DL_W     = 12;
+const UL_W     = 12;
+const ETA_W    = 9;
+const PCT_W    = 5;
+
+const RIGHT_W = SIZE_W + SEP_W + STATUS_W + DL_W + UL_W + ETA_W + PCT_W + SUFFIX_W;
+
+function calcWidths(cw: number) {
+	const available = cw - PREFIX_W - RIGHT_W;
+	const nameWidth = Math.max(12, Math.min(Math.floor(cw * 0.4), available));
+	const gap = Math.max(0, available - nameWidth);
+	return { nameWidth, gap };
+}
+
+function rightGroup(size: string, status: string, dl: string, ul: string, eta: string, pct: string): string {
+	return (
+		size.padStart(SIZE_W) +
+		" ".repeat(SEP_W) +
+		status.padEnd(STATUS_W) +
+		dl.padEnd(DL_W) +
+		ul.padEnd(UL_W) +
+		eta.padEnd(ETA_W) +
+		pct.padStart(PCT_W) +
+		" ".repeat(SUFFIX_W)
+	);
+}
+
+function buildRow(left: string, nameWidth: number, gap: number, right: string, prefix = "  "): string {
+	return prefix + left.padEnd(nameWidth) + " ".repeat(gap) + right;
+}
+
+function truncate(s: string, max: number): string {
+	return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+	if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+	if (bytes >= 1e3) return `${Math.round(bytes / 1e3)} KB`;
+	return `${bytes} B`;
+}
+
+function formatSpeed(bps: number): string {
+	if (bps >= 1_000_000) return `${(bps / 1_000_000).toFixed(1)} MB/s`;
+	if (bps >= 1_000) return `${Math.round(bps / 1_000)} KB/s`;
+	return "";
+}
+
+function formatEta(secs: number | null): string {
+	if (!secs || secs <= 0) return "";
+	const h = Math.floor(secs / 3600);
+	const m = Math.floor((secs % 3600) / 60);
+	const s = Math.floor(secs % 60);
+	if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+	return `${m}:${String(s).padStart(2, "0")}`;
+}
+
+function setText(node: TextRenderable, content: string): void {
+	(node as unknown as { content: string }).content = content;
+}
+
+function setFg(node: TextRenderable, fg: string): void {
+	(node as unknown as { fg: string }).fg = fg;
+}
+
+function setBg(node: BoxRenderable, bg: string | undefined): void {
+	(node as unknown as { backgroundColor: string | undefined }).backgroundColor = bg;
+}
+
+interface TorrentRow {
+	metaRow:    BoxRenderable;
+	metaText:   TextRenderable;
+	barRow:     BoxRenderable;
+	filledText: TextRenderable;
+	emptyText:  TextRenderable;
+}
+
+export class TorrentTable {
+	private renderer: CliRenderer;
+	private layout: LayoutDimensions;
+	private widths: ReturnType<typeof calcWidths>;
+	private container:  BoxRenderable;
+	private headerText: TextRenderable;
+	private rows: TorrentRow[] = [];
+
+	private lastTorrents: TorrentState[] = [];
+	private lastSelectedIndex = 0;
+	private lastFocusArea: "sidebar" | "table" = "sidebar";
+
+	constructor(renderer: CliRenderer, layout: LayoutDimensions) {
+		this.renderer = renderer;
+		this.layout = layout;
+		this.widths = calcWidths(layout.content.width);
+		const built = this.buildShell(layout.content.width);
+		this.container  = built.container;
+		this.headerText = built.headerText;
+	}
+
+	getContainer(): BoxRenderable {
+		return this.container;
+	}
+
+	update(torrents: TorrentState[], selectedIndex: number, focusArea: "sidebar" | "table"): void {
+		this.lastTorrents = torrents;
+		this.lastSelectedIndex = selectedIndex;
+		this.lastFocusArea = focusArea;
+
+		if (torrents.length !== this.rows.length) {
+			this.rebuildRows(torrents.length);
+		}
+
+		for (let i = 0; i < torrents.length; i++) {
+			this.updateRow(this.rows[i]!, torrents[i]!, i === selectedIndex && focusArea === "table");
+		}
+	}
+
+	updateLayout(layout: LayoutDimensions): void {
+		this.layout = layout;
+		this.widths = calcWidths(layout.content.width);
+		(this.container as unknown as { width: number }).width = layout.content.width;
+		const { nameWidth, gap } = this.widths;
+		setText(
+			this.headerText,
+			buildRow("Name", nameWidth, gap, rightGroup("Size", "Status", "↓ Speed", "↑ Speed", "ETA", "%")),
+		);
+		this.update(this.lastTorrents, this.lastSelectedIndex, this.lastFocusArea);
+	}
+
+	private rebuildRows(count: number): void {
+		for (const row of this.rows) {
+			row.metaRow.destroy();
+			row.barRow.destroy();
+		}
+		this.rows = [];
+		for (let i = 0; i < count; i++) {
+			const row = this.createRow();
+			this.container.add(row.metaRow);
+			this.container.add(row.barRow);
+			this.rows.push(row);
+		}
+	}
+
+	private createRow(): TorrentRow {
+		const theme = getTheme();
+		const { nameWidth, gap } = this.widths;
+		const trailingW = gap + RIGHT_W;
+		const cw = this.layout.content.width;
+
+		const metaRow = new BoxRenderable(this.renderer, { width: cw, height: 1 });
+		const metaText = new TextRenderable(this.renderer, {
+			content: buildRow(" ".repeat(nameWidth), nameWidth, gap, " ".repeat(RIGHT_W)),
+			fg: theme.fgPrimary,
+		});
+		metaRow.add(metaText);
+
+		const barRow = new BoxRenderable(this.renderer, {
+			width: cw,
+			height: 1,
+			flexDirection: "row",
+		});
+		const filledText = new TextRenderable(this.renderer, {
+			content: "  ",
+			fg: theme.accent,
+		});
+		const emptyText = new TextRenderable(this.renderer, {
+			content: " ".repeat(nameWidth + trailingW),
+			fg: theme.fgMuted,
+		});
+		barRow.add(filledText);
+		barRow.add(emptyText);
+
+		return { metaRow, metaText, barRow, filledText, emptyText };
+	}
+
+	private updateRow(row: TorrentRow, torrent: TorrentState, isSelected: boolean): void {
+		const theme = getTheme();
+		const { nameWidth, gap } = this.widths;
+		const trailingW = gap + RIGHT_W;
+
+		const pct = torrent.totalPieces > 0
+			? Math.floor((torrent.downloadedPieces / torrent.totalPieces) * 100)
+			: 0;
+		const filledLen = Math.round((pct / 100) * nameWidth);
+		const emptyLen  = nameWidth - filledLen;
+
+		const barColor = (() => {
+			switch (torrent.status) {
+				case "seeding":   return theme.success;
+				case "paused":    return theme.warning;
+				case "stopped":   return theme.fgSecondary;
+				case "error":     return theme.error;
+				default:          return theme.accent;
+			}
+		})();
+
+		// No background color — use text prefix + color to match sidebar pattern
+		setBg(row.metaRow, undefined);
+		setBg(row.barRow, undefined);
+
+		const prefix = isSelected ? "> " : "  ";
+		const name   = truncate(torrent.name, nameWidth);
+		const status = torrent.status.charAt(0).toUpperCase() + torrent.status.slice(1);
+		const dl     = torrent.downloadBps > 0 ? `↓ ${formatSpeed(torrent.downloadBps)}` : "";
+		const ul     = torrent.uploadBps   > 0 ? `↑ ${formatSpeed(torrent.uploadBps)}`   : "";
+
+		setText(row.metaText, buildRow(name, nameWidth, gap, rightGroup(
+			formatBytes(torrent.totalSize), status, dl, ul, formatEta(torrent.etaSeconds), `${pct}%`,
+		), prefix));
+		setFg(row.metaText, isSelected ? theme.accent : theme.fgPrimary);
+
+		setText(row.filledText, "  " + "━".repeat(Math.max(0, filledLen)));
+		setFg(row.filledText, barColor);
+		setText(row.emptyText, "━".repeat(Math.max(0, emptyLen)) + " ".repeat(trailingW));
+	}
+
+	private buildShell(cw: number): { container: BoxRenderable; headerText: TextRenderable } {
+		const theme = getTheme();
+		const { nameWidth, gap } = this.widths;
+
+		const container = new BoxRenderable(this.renderer, {
+			position: "absolute",
+			left: 0,
+			top: 0,
+			width: cw,
+			flexDirection: "column",
+		});
+
+		const headerText = new TextRenderable(this.renderer, {
+			content: buildRow("Name", nameWidth, gap, rightGroup("Size", "Status", "↓ Speed", "↑ Speed", "ETA", "%")),
+			fg: theme.fgPrimary,
+		});
+
+		const spacer = new TextRenderable(this.renderer, { content: "" });
+
+		container.add(headerText);
+		container.add(spacer);
+
+		return { container, headerText };
+	}
+}

package/src/store/index.ts

@@ -0,0 +1,51 @@
+export interface TorrentState {
+	id: string;
+	name: string;
+	totalSize: number;
+	downloadedPieces: number;
+	totalPieces: number;
+	status: "verifying" | "downloading" | "paused" | "seeding" | "stopped" | "error";
+	downloadBps: number;
+	uploadBps: number;
+	peers: number;
+	etaSeconds: number | null;
+}
+
+export interface AppState {
+	selectedIndex: number;
+	selectedView: string;
+	torrents: TorrentState[];
+	totalDownloadBps: number;
+	totalUploadBps: number;
+}
+
+type Listener = (state: AppState) => void;
+
+export class Store {
+	private state: AppState;
+	private listeners: Set<Listener> = new Set();
+
+	constructor(initial: AppState) {
+		this.state = { ...initial };
+	}
+
+	getState(): AppState {
+		return { ...this.state };
+	}
+
+	setState(partial: Partial<AppState>): void {
+		this.state = { ...this.state, ...partial };
+		this.notify();
+	}
+
+	subscribe(listener: Listener): () => void {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+
+	private notify(): void {
+		for (const listener of this.listeners) {
+			listener(this.getState());
+		}
+	}
+}

package/src/theme/default.ts

@@ -0,0 +1,22 @@
+import type { ColorScheme } from "./types";
+
+// Default dark theme color scheme (Tokyo Night inspired)
+export const DEFAULT_COLORSCHEME: ColorScheme = {
+	bgPrimary: "#1a1a2e",
+	bgSecondary: "#16213e",
+	bgTertiary: "#0f3460",
+
+	fgPrimary: "#eaeaea",
+	fgSecondary: "#a0a0a0",
+	fgMuted: "#606060",
+
+	accent: "#7aa2f7",
+	accentHover: "#9dcfed",
+
+	success: "#9ece6a",
+	warning: "#e0af68",
+	error: "#f7768e",
+
+	border: "#414868",
+	borderFocused: "#7aa2f7",
+};

package/src/theme/index.ts

@@ -0,0 +1,19 @@
+import { DEFAULT_COLORSCHEME } from "./default";
+import type { ColorScheme } from "./types";
+
+let currentTheme: ColorScheme = { ...DEFAULT_COLORSCHEME };
+
+export function getTheme(): ColorScheme {
+	return currentTheme;
+}
+
+export function setTheme(theme: ColorScheme): void {
+	currentTheme = { ...theme };
+}
+
+export function resetTheme(): void {
+	currentTheme = { ...DEFAULT_COLORSCHEME };
+}
+
+export type { ColorScheme } from "./types";
+export { DEFAULT_COLORSCHEME };

package/src/theme/types.ts

@@ -0,0 +1,26 @@
+// Color scheme type definition
+
+export interface ColorScheme {
+	// Backgrounds
+	bgPrimary: string;
+	bgSecondary: string;
+	bgTertiary: string;
+
+	// Foregrounds
+	fgPrimary: string;
+	fgSecondary: string;
+	fgMuted: string;
+
+	// Accents
+	accent: string;
+	accentHover: string;
+
+	// Status
+	success: string;
+	warning: string;
+	error: string;
+
+	// Borders
+	border: string;
+	borderFocused: string;
+}

package/src/torrent/bridge.ts

@@ -0,0 +1,301 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { AppSettings } from "../config/settings";
+import type { Store, TorrentState } from "../store";
+import { getDataDir, resolvePath } from "../utils/paths";
+import { TorrentMetadata } from "./metadata";
+import { decode } from "./parser";
+import type { BencodeValue } from "./parser";
+import { TorrentSession } from "./session";
+import { announce } from "./tracker/announce";
+import { PeerManager } from "./peer/manager";
+import type { Downloader } from "./downloader";
+
+interface TorrentEntry {
+	torrentPath: string;
+	session: TorrentSession | null;
+	manager: PeerManager | null;
+	downloader: Downloader | null;
+	state: TorrentState;
+}
+
+interface SessionRegistry {
+	torrents: Array<{ infoHash: string; torrentPath: string }>;
+}
+
+export class TorrentBridge {
+	private store: Store;
+	private config: AppSettings;
+	private torrents: Map<string, TorrentEntry> = new Map();
+	private pendingFlush = false;
+	private downloadPath: string;
+
+	constructor(store: Store, config: AppSettings) {
+		this.store = store;
+		this.config = config;
+		this.downloadPath = resolvePath(config.downloadPath);
+	}
+
+	async restoreSession(): Promise<void> {
+		const registryPath = this.registryPath();
+		if (!existsSync(registryPath)) return;
+
+		let registry: SessionRegistry;
+		try {
+			registry = JSON.parse(readFileSync(registryPath, "utf-8")) as SessionRegistry;
+		} catch {
+			return;
+		}
+
+		for (const { infoHash, torrentPath } of registry.torrents) {
+			if (!existsSync(torrentPath)) continue;
+			try {
+				const metadata = this.parseTorrent(torrentPath);
+				const actualId = Buffer.from(metadata.infoHash).toString("hex");
+				if (actualId !== infoHash) continue;
+
+				const downloadedPieces = this.loadResumeCount(infoHash);
+				const entry: TorrentEntry = {
+					torrentPath,
+					session: null,
+					manager: null,
+					downloader: null,
+					state: {
+						id: infoHash,
+						name: metadata.name,
+						totalSize: metadata.totalSize,
+						downloadedPieces,
+						totalPieces: metadata.pieceCount,
+						status: "stopped",
+						downloadBps: 0,
+						uploadBps: 0,
+						peers: 0,
+						etaSeconds: null,
+					},
+				};
+				this.torrents.set(infoHash, entry);
+			} catch {
+				// skip invalid/unreadable torrent files
+			}
+		}
+
+		this.flushAll();
+	}
+
+	async addTorrent(torrentPath: string): Promise<void> {
+		const metadata = this.parseTorrent(torrentPath);
+		const id = Buffer.from(metadata.infoHash).toString("hex");
+
+		if (this.torrents.has(id)) return;
+
+		const entry: TorrentEntry = {
+			torrentPath,
+			session: null,
+			manager: null,
+			downloader: null,
+			state: {
+				id,
+				name: metadata.name,
+				totalSize: metadata.totalSize,
+				downloadedPieces: 0,
+				totalPieces: metadata.pieceCount,
+				status: "stopped",
+				downloadBps: 0,
+				uploadBps: 0,
+				peers: 0,
+				etaSeconds: null,
+			},
+		};
+		this.torrents.set(id, entry);
+		this.saveRegistry();
+		this.flushAll();
+
+		await this.runDownload(id, metadata);
+	}
+
+	async startTorrent(id: string): Promise<void> {
+		const entry = this.torrents.get(id);
+		if (!entry || entry.session !== null) return;
+		const metadata = this.parseTorrent(entry.torrentPath);
+		await this.runDownload(id, metadata);
+	}
+
+	async pauseTorrent(id: string): Promise<void> {
+		const entry = this.torrents.get(id);
+		if (!entry?.downloader || entry.state.status !== "downloading") return;
+		entry.downloader.pause();
+		this.updateEntry(id, { status: "paused", downloadBps: 0, etaSeconds: null });
+	}
+
+	async resumeTorrent(id: string): Promise<void> {
+		const entry = this.torrents.get(id);
+		if (!entry?.downloader || entry.state.status !== "paused") return;
+		entry.downloader.resume();
+		this.updateEntry(id, { status: "downloading" });
+	}
+
+	async removeTorrent(id: string, deleteFiles: boolean): Promise<void> {
+		const entry = this.torrents.get(id);
+		if (!entry) return;
+
+		entry.downloader?.stop();
+		entry.manager?.close();
+
+		if (deleteFiles) {
+			try {
+				const metadata = this.parseTorrent(entry.torrentPath);
+				if (metadata.files.length === 1 && metadata.files[0]) {
+					rmSync(join(this.downloadPath, metadata.files[0].path), { force: true });
+				} else {
+					rmSync(join(this.downloadPath, metadata.name), { recursive: true, force: true });
+				}
+			} catch {
+				// ignore deletion errors
+			}
+		}
+
+		this.torrents.delete(id);
+		this.saveRegistry();
+		this.flushAll();
+	}
+
+	async stopAll(): Promise<void> {
+		for (const entry of this.torrents.values()) {
+			entry.downloader?.stop();
+			entry.manager?.close();
+		}
+		this.torrents.clear();
+		this.store.setState({ torrents: [], totalDownloadBps: 0, totalUploadBps: 0 });
+	}
+
+	private async runDownload(id: string, metadata: TorrentMetadata): Promise<void> {
+		const entry = this.torrents.get(id);
+		if (!entry) return;
+
+		const session = new TorrentSession(metadata, this.downloadPath);
+		entry.session = session;
+
+		this.updateEntry(id, { status: "verifying" });
+
+		await session.start();
+		this.updateEntry(id, { downloadedPieces: session.storage.downloadedCount, status: "downloading" });
+
+		const trackerResult = await announce(metadata).catch(() => null);
+		const peers = trackerResult?.peers ?? [];
+
+		const manager = new PeerManager(metadata, this.config.maxConnections);
+		entry.manager = manager;
+
+		await manager.start();
+		await manager.connect(peers);
+
+		if (manager.connections.size === 0) {
+			this.updateEntry(id, { status: "error" });
+			return;
+		}
+
+		this.updateEntry(id, { peers: manager.connections.size });
+
+		manager.on("peerAdded", () => {
+			this.updateEntry(id, { peers: manager.connections.size });
+		});
+
+		// Attach listeners BEFORE session.download() — for already-complete torrents
+		session.on("progress", (dl: number, _total: number, speed: number) => {
+			if (!this.torrents.has(id)) return;
+			const uploadBps = [...manager.connections.values()].reduce(
+				(sum, c) => sum + c.uploadBytesPerSec,
+				0,
+			);
+			const remaining = metadata.pieceCount - dl;
+			const etaSeconds = speed > 0 ? Math.round((remaining * metadata.pieceLength) / speed) : null;
+			this.updateEntry(id, {
+				downloadedPieces: dl,
+				downloadBps: Math.round(speed),
+				uploadBps,
+				etaSeconds,
+				peers: manager.connections.size,
+			});
+		});
+
+		session.on("status", (next: string) => {
+			if (!this.torrents.has(id)) return;
+			this.updateEntry(id, { status: next as TorrentState["status"] });
+		});
+
+		session.on("complete", () => {
+			if (!this.torrents.has(id)) return;
+			this.updateEntry(id, { status: "seeding", downloadBps: 0, etaSeconds: null });
+		});
+
+		manager.startChoking();
+		const downloader = session.download(manager);
+		entry.downloader = downloader;
+	}
+
+	private parseTorrent(torrentPath: string): TorrentMetadata {
+		const raw = new Uint8Array(readFileSync(torrentPath));
+		const decoded = decode(raw);
+		if (
+			typeof decoded !== "object" ||
+			decoded === null ||
+			Array.isArray(decoded) ||
+			decoded instanceof Uint8Array
+		) {
+			throw new Error("Invalid torrent file");
+		}
+		return new TorrentMetadata(decoded as { [key: string]: BencodeValue }, raw);
+	}
+
+	private loadResumeCount(infoHash: string): number {
+		const path = join(getDataDir(), "resume", `${infoHash}.json`);
+		if (!existsSync(path)) return 0;
+		try {
+			const data = JSON.parse(readFileSync(path, "utf-8")) as { downloadedPieces?: number[] };
+			return data.downloadedPieces?.length ?? 0;
+		} catch {
+			return 0;
+		}
+	}
+
+	private registryPath(): string {
+		return join(getDataDir(), "session.json");
+	}
+
+	private saveRegistry(): void {
+		const dir = getDataDir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const entries = [...this.torrents.entries()].map(([infoHash, entry]) => ({
+			infoHash,
+			torrentPath: entry.torrentPath,
+		}));
+		try {
+			writeFileSync(this.registryPath(), JSON.stringify({ torrents: entries }, null, 2), "utf-8");
+		} catch {
+			// non-fatal
+		}
+	}
+
+	private updateEntry(id: string, partial: Partial<TorrentState>): void {
+		const entry = this.torrents.get(id);
+		if (!entry) return;
+		entry.state = { ...entry.state, ...partial };
+		this.scheduleFlush();
+	}
+
+	private scheduleFlush(): void {
+		if (this.pendingFlush) return;
+		this.pendingFlush = true;
+		setTimeout(() => {
+			this.pendingFlush = false;
+			this.flushAll();
+		}, 100);
+	}
+
+	private flushAll(): void {
+		const states = [...this.torrents.values()].map((e) => e.state);
+		const totalDownloadBps = states.reduce((s, t) => s + t.downloadBps, 0);
+		const totalUploadBps = states.reduce((s, t) => s + t.uploadBps, 0);
+		this.store.setState({ torrents: states, totalDownloadBps, totalUploadBps });
+	}
+}