Hunt

package.json

@@ -1,6 +1,6 @@
 {
   "name": "torhunt",
-  "version": "1.6.0",
+  "version": "1.9.0",
   "description": "A sleek, zero-setup torrent finder and downloader that lives right in your terminal.",
   "type": "module",
   "bin": {
@@ -48,11 +48,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/baairon/torlink.git"
+    "url": "git+https://github.com/pseudoshell/torhunt.git"
   },
-  "homepage": "https://torlink.bairon.dev",
+  "homepage": "https://github.com/pseudoshell/torhunt",
   "bugs": {
-    "url": "https://github.com/baairon/torlink/issues"
+    "url": "https://github.com/pseudoshell/torhunt/issues"
   },
   "publishConfig": {
     "access": "public"

scripts/render-previews-impl.tsx

@@ -87,6 +87,8 @@ function makeStore(
       theme: "electric-cyan",
       spinner: "dots",
       trackers: [],
+      preventSleep: true,
+      onComplete: "none",
     } as Config,
     setConfig: noop,
     theme: DEFAULT_THEME,
@@ -124,6 +126,14 @@ function makeStore(
     openFolderPicker: noop,
     searchModeTrigger: 0,
     triggerSearch: noop,
+    bookmarks: [],
+    addBookmark: noop,
+    removeBookmark: noop,
+    clearBookmarks: noop,
+    searchHistory: [],
+    pushSearchHistory: noop,
+    clearSearchHistory: noop,
+    updateVersion: null,
     quitAll: noop,
     listRows: 14,
     compact: false,

src/config/config.ts

@@ -2,18 +2,24 @@ import { promises as fs } from "node:fs";
 import { configFile, defaultDownloadDir } from "./paths";
 import { serializeWrites, writeJsonAtomic } from "../util/atomic";
 
+export type OnCompleteAction = "none" | "sleep" | "shutdown";
+
 export interface Config {
   downloadDir: string;
   trackers: string[];
   theme: string;
   spinner: string;
+  preventSleep: boolean;
+  onComplete: OnCompleteAction;
 }
 
 export const defaultConfig: Config = {
   downloadDir: defaultDownloadDir,
   trackers: [],
   theme: "electric-cyan",
-  spinner: "dots",
+  spinner: "meter",
+  preventSleep: true,
+  onComplete: "none",
 };
 
 export async function loadConfig(): Promise<Config> {
@@ -38,6 +44,14 @@ export async function loadConfig(): Promise<Config> {
         typeof parsed.spinner === "string" && parsed.spinner
           ? parsed.spinner
           : defaultConfig.spinner,
+      preventSleep:
+        typeof parsed.preventSleep === "boolean"
+          ? parsed.preventSleep
+          : defaultConfig.preventSleep,
+      onComplete:
+        parsed.onComplete === "sleep" || parsed.onComplete === "shutdown" || parsed.onComplete === "none"
+          ? parsed.onComplete
+          : defaultConfig.onComplete,
     };
     return cfg;
   } catch {

src/config/paths.ts

@@ -21,6 +21,10 @@ export const queueFile = path.join(dataDir, "queue.json");
 
 export const historyFile = path.join(dataDir, "history.json");
 
+export const bookmarksFile = path.join(dataDir, "bookmarks.json");
+
+export const searchHistoryFile = path.join(dataDir, "search-history.json");
+
 export const seedsFile = path.join(dataDir, "seeds.json");
 
 // Per-torrent .torrent metadata, captured during download so a re-seed can

src/download/bookmarks.test.ts

@@ -0,0 +1,38 @@
+import { promises as fs } from "node:fs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadBookmarks, saveBookmarks, type BookmarkItem } from "./bookmarks";
+import { bookmarksFile } from "../config/paths";
+
+describe("bookmarks persistence", () => {
+  beforeEach(async () => {
+    await fs.rm(bookmarksFile, { force: true }).catch(() => {});
+  });
+
+  afterEach(async () => {
+    await fs.rm(bookmarksFile, { force: true }).catch(() => {});
+  });
+
+  it("saves and loads bookmark items", async () => {
+    const items: BookmarkItem[] = [
+      {
+        id: "bm-1",
+        name: "Test Movie 1080p",
+        magnet: "magnet:?xt=urn:btih:1234567890abcdef",
+        source: "yts",
+        sizeBytes: 1500000000,
+        bookmarkedAt: Date.now(),
+      },
+    ];
+
+    await saveBookmarks(items);
+    const loaded = await loadBookmarks();
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0]?.id).toBe("bm-1");
+    expect(loaded[0]?.name).toBe("Test Movie 1080p");
+  });
+
+  it("returns empty array when file does not exist", async () => {
+    const loaded = await loadBookmarks();
+    expect(loaded).toEqual([]);
+  });
+});

src/download/bookmarks.ts

@@ -0,0 +1,52 @@
+import { promises as fs, mkdirSync, writeFileSync, renameSync } from "node:fs";
+import path from "node:path";
+import { bookmarksFile } from "../config/paths";
+import { serializeWrites, writeJsonAtomic } from "../util/atomic";
+import type { SourceId } from "../sources/types";
+
+export const BOOKMARKS_CAP = 200;
+
+export interface BookmarkItem {
+  id: string;
+  name: string;
+  source?: SourceId;
+  magnet: string;
+  sizeBytes: number;
+  bookmarkedAt: number;
+}
+
+const write = serializeWrites();
+
+export function saveBookmarks(items: BookmarkItem[]): Promise<void> {
+  return write(() => writeJsonAtomic(bookmarksFile, items.slice(0, BOOKMARKS_CAP)));
+}
+
+export function saveBookmarksSync(items: BookmarkItem[]): void {
+  try {
+    mkdirSync(path.dirname(bookmarksFile), { recursive: true });
+    const tmp = `${bookmarksFile}.sync.tmp`;
+    writeFileSync(tmp, JSON.stringify(items.slice(0, BOOKMARKS_CAP), null, 2), "utf8");
+    renameSync(tmp, bookmarksFile);
+  } catch {}
+}
+
+function isBookmarkItem(v: unknown): v is BookmarkItem {
+  if (!v || typeof v !== "object") return false;
+  const r = v as Record<string, unknown>;
+  return typeof r.id === "string" && typeof r.name === "string" && typeof r.magnet === "string";
+}
+
+export async function loadBookmarks(): Promise<BookmarkItem[]> {
+  let raw: string;
+  try {
+    raw = await fs.readFile(bookmarksFile, "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return Array.isArray(parsed) ? parsed.filter(isBookmarkItem).slice(0, BOOKMARKS_CAP) : [];
+  } catch {
+    return [];
+  }
+}

src/sources/searchHistory.test.ts

@@ -0,0 +1,73 @@
+import { promises as fs } from "node:fs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  addSearchQuery,
+  clearSearchHistory,
+  loadSearchHistory,
+  saveSearchHistory,
+} from "./searchHistory";
+import { searchHistoryFile } from "../config/paths";
+
+describe("searchHistory module", () => {
+  beforeEach(async () => {
+    await fs.rm(searchHistoryFile, { force: true }).catch(() => {});
+  });
+
+  afterEach(async () => {
+    await fs.rm(searchHistoryFile, { force: true }).catch(() => {});
+  });
+
+  describe("addSearchQuery", () => {
+    it("adds new search query to the front", () => {
+      const history = ["Inception", "Interstellar"];
+      const result = addSearchQuery(history, "Oppenheimer");
+      expect(result).toEqual(["Oppenheimer", "Inception", "Interstellar"]);
+    });
+
+    it("moves existing duplicate to the front and avoids duplicate entries (case-insensitive)", () => {
+      const history = ["Oppenheimer", "Inception", "Interstellar"];
+      const result = addSearchQuery(history, "inception");
+      expect(result).toEqual(["inception", "Oppenheimer", "Interstellar"]);
+    });
+
+    it("ignores empty or whitespace queries", () => {
+      const history = ["Inception"];
+      expect(addSearchQuery(history, "")).toEqual(["Inception"]);
+      expect(addSearchQuery(history, "   ")).toEqual(["Inception"]);
+    });
+
+    it("ignores raw magnet links", () => {
+      const history = ["Inception"];
+      expect(
+        addSearchQuery(history, "magnet:?xt=urn:btih:1234567890abcdef"),
+      ).toEqual(["Inception"]);
+    });
+
+    it("enforces maxItems limit", () => {
+      const history = ["a", "b", "c"];
+      const result = addSearchQuery(history, "d", 3);
+      expect(result).toEqual(["d", "a", "b"]);
+    });
+  });
+
+  describe("persistence", () => {
+    it("saves and loads search history from disk", async () => {
+      const items = ["House of the Dragon", "The Batman", "Dune 2"];
+      await saveSearchHistory(items);
+      const loaded = await loadSearchHistory();
+      expect(loaded).toEqual(items);
+    });
+
+    it("returns empty array when file does not exist", async () => {
+      const loaded = await loadSearchHistory();
+      expect(loaded).toEqual([]);
+    });
+
+    it("clears search history", async () => {
+      await saveSearchHistory(["House of the Dragon"]);
+      await clearSearchHistory();
+      const loaded = await loadSearchHistory();
+      expect(loaded).toEqual([]);
+    });
+  });
+});

src/sources/searchHistory.ts

@@ -0,0 +1,50 @@
+import { promises as fs } from "node:fs";
+import { searchHistoryFile } from "../config/paths";
+import { serializeWrites, writeJsonAtomic } from "../util/atomic";
+
+export const MAX_SEARCH_HISTORY = 50;
+
+/**
+ * Pure helper to add a search query into history list:
+ * - Trims whitespace
+ * - Drops empty queries or magnet link URLs
+ * - Removes existing duplicate if present
+ * - Inserts the new query at the beginning (most recent first)
+ * - Limits the list to maxItems (default 50)
+ */
+export function addSearchQuery(
+  history: string[],
+  query: string,
+  maxItems: number = MAX_SEARCH_HISTORY,
+): string[] {
+  const trimmed = query.trim();
+  if (!trimmed) return history;
+  // Don't clutter search history with raw magnet URIs
+  if (/^magnet:\?/i.test(trimmed)) return history;
+
+  const withoutDuplicate = history.filter(
+    (item) => item.toLowerCase() !== trimmed.toLowerCase(),
+  );
+  return [trimmed, ...withoutDuplicate].slice(0, maxItems);
+}
+
+const write = serializeWrites();
+
+export async function loadSearchHistory(): Promise<string[]> {
+  try {
+    const raw = await fs.readFile(searchHistoryFile, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+
+export function saveSearchHistory(history: string[]): Promise<void> {
+  return write(() => writeJsonAtomic(searchHistoryFile, history));
+}
+
+export function clearSearchHistory(): Promise<void> {
+  return saveSearchHistory([]);
+}