@anjishnusengupta/ny-cli 3.1.0 → 4.0.0

package/README.md

@@ -6,7 +6,7 @@
 
 <br/>
 
-[![Version](https://img.shields.io/badge/v3.0.0-a855f7?style=flat-square&label=release)](https://github.com/AnjishnuSengupta/ny-cli/releases)
+[![Version](https://img.shields.io/badge/v4.0.0-a855f7?style=flat-square&label=release)](https://github.com/AnjishnuSengupta/ny-cli/releases)
 [![npm](https://img.shields.io/npm/v/@anjishnusengupta/ny-cli?style=flat-square&color=22c55e&label=npm)](https://www.npmjs.com/package/@anjishnusengupta/ny-cli)
 [![License](https://img.shields.io/badge/MIT-3b82f6?style=flat-square&label=license)](LICENSE)
 [![Stars](https://img.shields.io/github/stars/AnjishnuSengupta/ny-cli?style=flat-square&color=fbbf24)](https://github.com/AnjishnuSengupta/ny-cli/stargazers)
@@ -26,33 +26,33 @@
 
 <br/>
 
-## 🎯 What's New in v3.0.0
+## 🎯 What's New in v4.0.0
 
 <table>
 <tr>
-<td>🔧</td>
-<td><b>Self-Hosted Scraping</b></td>
-<td>Uses the <code>aniwatch</code> npm package directly — no external API dependency</td>
+<td>🎙️</td>
+<td><b>Sub / Dub Selection</b></td>
+<td>Choose between sub (Japanese + subtitles) or dub (English audio) when you select an anime — preference is saved per anime</td>
 </tr>
 <tr>
 <td>⚡</td>
-<td><b>Parallel Server Racing</b></td>
-<td><code>Promise.any()</code> races HD-1, HD-2, StreamTape & StreamSB simultaneously for fastest response</td>
+<td><b>Background Episode Fetching</b></td>
+<td>Episodes load in the background while you pick sub or dub — zero extra wait time</td>
 </tr>
 <tr>
-<td>🔄</td>
-<td><b>Sub/Dub Fallback</b></td>
-<td>Automatically falls back from sub to dub if all sub servers fail</td>
+<td>🌐</td>
+<td><b>Global Network Compatibility</b></td>
+<td>Happy Eyeballs (RFC 6555) dual-stack support — works on IPv4-only, IPv6-only, or dual-stack networks worldwide</td>
 </tr>
 <tr>
-<td>🚫</td>
-<td><b>Zero External APIs</b></td>
-<td>Everything runs locally via Node.js — no cold-start delays or API rate limits</td>
+<td>🛡️</td>
+<td><b>Resilient Connectivity</b></td>
+<td>Mixed IPv4/IPv6 DNS servers, 3-endpoint online check, exponential-backoff retries, crash protection for transient socket errors</td>
 </tr>
 <tr>
 <td>☁️</td>
-<td><b>Cloud Sync</b></td>
-<td>Watch history syncs between CLI and <a href="https://nyanime.tech">nyanime.tech</a> web app</td>
+<td><b>Category-Aware Cloud Sync</b></td>
+<td>Sub/dub preference syncs to <a href="https://nyanime.tech">nyanime.tech</a> — Continue Watching remembers your choice</td>
 </tr>
 </table>
 
@@ -74,9 +74,9 @@
 │                                                                 │
 │   ▸ HLS Streaming        ▸ User Accounts       ▸ POSIX Shell    │
 │   ▸ Multi-Server         ▸ Watch History       ▸ Node.js 18+    │
-│   ▸ Sub/Dub Toggle       ▸ Cloud Sync          ▸ aniwatch pkg   │
+│   ▸ Sub/Dub Select       ▸ Cloud Sync          ▸ aniwatch pkg   │
 │   ▸ Skip Intro           ▸ Continue Watch      ▸ Self-Hosted    │
-│   ▸ Auto Subtitles       ▸ Random Anime        ▸ XDG Dirs       │
+│   ▸ Auto Subtitles       ▸ Random Anime        ▸ Dual-Stack     │
 │   ▸ MPV/VLC/IINA         ▸ Profile System      ▸ Zero Config    │
 │                                                                 │
 ╰─────────────────────────────────────────────────────────────────╯
@@ -93,10 +93,12 @@
 
 | Feature | Description |
 |:--------|:------------|
+| **🎙️ Sub/Dub Selection** | Choose sub or dub per anime — preference saved and synced to cloud |
 | **🔄 Multi-Server Racing** | Races HD-1, HD-2, StreamTape, StreamSB in parallel via `Promise.any()` |
 | **⏭️ Skip Intro** | Press `s` during intro to skip — uses API-provided timestamps |
 | **📝 Multi-Language Subs** | Auto-selects English, with all available languages loaded for switching |
 | **🔁 Sub/Dub Fallback** | If all sub servers fail, automatically retries with dub |
+| **🌐 Dual-Stack Networking** | Happy Eyeballs (RFC 6555) — works on any IPv4, IPv6, or dual-stack network |
 | **🎚️ Player Support** | MPV (recommended), VLC, IINA — auto-detected or configurable |
 
 </details>
@@ -111,8 +113,8 @@
 | **🔐 Browser Auth** | Login via nyanime.tech — just paste your User ID |
 | **📜 Watch History** | Track all watched episodes with timestamps |
 | **☁️ Cloud Sync** | Seamless sync between CLI and nyanime.tech website |
-| **📍 Continue Watching** | Resume from exactly where you left off |
-| **🎲 Random Mode** | Discover new anime with random selection |
+| **📍 Continue Watching** | Resume from where you left off — remembers your sub/dub choice |
+| **🎲 Random Mode** | Discover new anime with random selection + sub/dub prompt |
 | **🔍 Quick Search** | Search directly from command line or interactive menu |
 
 </details>
@@ -128,22 +130,28 @@
 <div align="center">
 
 ```
-╔══════════════════════════════════════════╗
-║                                          ║
-║   $ ny-cli "one piece"                   ║
-║                                          ║
-║   Searching for 'one piece'...           ║
-║   1) One Piece (TV, 1120 eps)            ║
-║   2) One Piece Film: Red (Movie)         ║
-║                                          ║
-║   Select [1-20]: 1                       ║
-║   Loading episodes...                    ║
-║   Episode [1-1120]: 1120                 ║
-║                                          ║
-║   ▸ Starting playback...                 ║
-║     One Piece - Episode 1120             ║
-║                                          ║
-╚══════════════════════════════════════════╝
+╔══════════════════════════════════════════════╗
+║                                              ║
+║   $ ny-cli "one piece"                       ║
+║                                              ║
+║   Searching for 'one piece'...               ║
+║   1) One Piece (TV, 1155 sub / 1143 dub)     ║
+║   2) One Piece Film: Red (Movie, 1 sub)      ║
+║                                              ║
+║   Select [1-20]: 1                           ║
+║   Loading episodes...                        ║
+║                                              ║
+║   1) Sub (Japanese audio + subtitles)        ║
+║   2) Dub (English audio)                     ║
+║   Sub or Dub? [1/2]: 1                       ║
+║                                              ║
+║   One Piece (1155 eps) [SUB]                 ║
+║   Episode [1-1155]: 1155                     ║
+║                                              ║
+║   ▸ Starting playback...                     ║
+║     One Piece - Episode 1155 [SUB]           ║
+║                                              ║
+╚══════════════════════════════════════════════╝
 ```
 
 </div>

package/backend.mjs

@@ -7,54 +7,141 @@
 import dns from "node:dns";
 import https from "node:https";
 import http from "node:http";
+import os from "node:os";
+
+// ── Safety net: prevent unhandled errors from crashing the process ──────
+// The aniwatch library can emit socket errors that aren't caught internally.
+process.on("uncaughtException", (err) => {
+  // Silently ignore connection errors during retry/fallback — they're expected
+  if (["ENETUNREACH", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "EHOSTUNREACH", "EAI_AGAIN"].includes(err.code)) {
+    return;
+  }
+  // For other errors, output JSON so the shell script can parse it
+  console.log(JSON.stringify({ error: err.message || "Unexpected error" }));
+  process.exit(1);
+});
 
 // Use public DNS (Cloudflare + Google) to bypass ISP-level domain blocking.
-// dns.resolve{4,6} uses these servers; dns.lookup uses the OS resolver.
-dns.setServers(["1.1.1.1", "8.8.8.8", "1.0.0.1", "8.8.4.4"]);
+// Include BOTH IPv4 and IPv6 DNS server addresses so resolution works on:
+//   - IPv4-only WiFi / hotspots
+//   - IPv6-only carrier networks (T-Mobile, etc.)
+//   - Dual-stack environments
+// Order: put the family matching the system first to minimise latency.
+const DNS_V4 = ["1.1.1.1", "8.8.8.8", "1.0.0.1", "8.8.4.4"];
+const DNS_V6 = ["2606:4700:4700::1111", "2001:4860:4860::8888", "2606:4700:4700::1001", "2001:4860:4860::8844"];
 
-// Custom lookup: prefer IPv6 (bypasses SNI-based DPI blocking on many ISPs),
-// fall back to IPv4 via dns.resolve4, then OS resolver as last resort.
-// Note: IPv4-only consistently fails due to ISP blocking; IPv6 is required.
+// ── Detect system IPv6 connectivity ─────────────────────────────────────
+// Check if the system has a routable (non-link-local, non-loopback) IPv6 address.
+// If there's no IPv6 address, connecting to IPv6 endpoints will fail with ENETUNREACH.
+function systemHasIPv6() {
+  try {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const addr of interfaces[name]) {
+        if (
+          addr.family === "IPv6" &&
+          !addr.internal &&
+          !addr.address.startsWith("fe80") &&   // skip link-local
+          !addr.address.startsWith("::1")        // skip loopback
+        ) {
+          return true;
+        }
+      }
+    }
+  } catch {}
+  return false;
+}
+
+const HAS_IPV6 = systemHasIPv6();
+
+// ── Configure DNS servers based on system network capabilities ────────
+// On IPv6-only networks, IPv4 DNS servers (1.1.1.1) are unreachable.
+// On IPv4-only WiFi, IPv6 DNS servers are unreachable.
+// Order the server list so reachable servers come first.
+try {
+  const servers = HAS_IPV6
+    ? [...DNS_V6, ...DNS_V4]   // IPv6 DNS first, then IPv4 fallback
+    : [...DNS_V4, ...DNS_V6]; // IPv4 DNS first (most common)
+  dns.setServers(servers);
+} catch {
+  // If setServers fails (unusual), leave the OS defaults in place.
+}
+
+// ── DNS resolution with timeout ─────────────────────────────────────────
+// Wraps dns.resolve{4,6} with a timeout to prevent hanging on unresponsive DNS.
+function resolveWithTimeout(resolver, hostname, timeoutMs = 3000) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve([]), timeoutMs);
+    resolver(hostname, (err, addrs) => {
+      clearTimeout(timer);
+      resolve(err || !addrs ? [] : addrs);
+    });
+  });
+}
+
+// ── Custom DNS lookup (Happy Eyeballs compatible) ───────────────────────
+// When called with `all: true` (by Node.js autoSelectFamily / Happy Eyeballs),
+// returns addresses from BOTH families so Node can race connections and pick
+// whichever connects first.  When called for a single address, returns the
+// best-available family based on system capability.
 function customLookup(hostname, options, callback) {
   if (typeof options === "function") { callback = options; options = {}; }
 
-  // Cache resolved addresses per hostname for the lifetime of this process
-  const cacheKey = hostname;
-  if (customLookup._cache && customLookup._cache[cacheKey]) {
-    const cached = customLookup._cache[cacheKey];
-    if (options.all) {
-      return callback(null, [{ address: cached.address, family: cached.family }]);
-    }
-    return callback(null, cached.address, cached.family);
-  }
+  const wantAll = !!options.all;
 
-  dns.resolve6(hostname, (err6, addr6) => {
-    if (!err6 && addr6 && addr6.length > 0) {
-      if (!customLookup._cache) customLookup._cache = {};
-      customLookup._cache[cacheKey] = { address: addr6[0], family: 6 };
-      if (options.all) {
-        return callback(null, addr6.map(a => ({ address: a, family: 6 })));
-      }
-      return callback(null, addr6[0], 6);
-    }
-    dns.resolve4(hostname, (err4, addr4) => {
-      if (!err4 && addr4 && addr4.length > 0) {
-        if (!customLookup._cache) customLookup._cache = {};
-        customLookup._cache[cacheKey] = { address: addr4[0], family: 4 };
-        if (options.all) {
-          return callback(null, addr4.map(a => ({ address: a, family: 4 })));
-        }
-        return callback(null, addr4[0], 4);
+  if (wantAll) {
+    // ── Happy Eyeballs path: resolve both families in parallel ──
+    Promise.all([
+      HAS_IPV6 ? resolveWithTimeout(dns.resolve6.bind(dns), hostname) : Promise.resolve([]),
+      resolveWithTimeout(dns.resolve4.bind(dns), hostname),
+    ]).then(([v6, v4]) => {
+      const results = [];
+      // IPv6 first (preferred when available), then IPv4
+      for (const a of v6) results.push({ address: a, family: 6 });
+      for (const a of v4) results.push({ address: a, family: 4 });
+
+      if (results.length > 0) {
+        return callback(null, results);
       }
-      dns.lookup(hostname, options, callback);
+      // All custom DNS failed — fall back to OS resolver
+      dns.lookup(hostname, { all: true }, callback);
+    }).catch(() => {
+      dns.lookup(hostname, { all: true }, callback);
     });
-  });
+  } else {
+    // ── Single-address path ──
+    const tryIPv4 = () => {
+      resolveWithTimeout(dns.resolve4.bind(dns), hostname).then((v4) => {
+        if (v4.length > 0) return callback(null, v4[0], 4);
+        // Last resort: OS resolver
+        dns.lookup(hostname, options, callback);
+      }).catch(() => dns.lookup(hostname, options, callback));
+    };
+
+    if (HAS_IPV6) {
+      resolveWithTimeout(dns.resolve6.bind(dns), hostname).then((v6) => {
+        if (v6.length > 0) return callback(null, v6[0], 6);
+        tryIPv4();
+      }).catch(() => tryIPv4());
+    } else {
+      tryIPv4();
+    }
+  }
 }
 
-// Replace global agents so ALL http/https requests use our DNS.
-// keepAlive reduces connection overhead for multiple requests to the same host.
-http.globalAgent = new http.Agent({ lookup: customLookup, keepAlive: true });
-https.globalAgent = new https.Agent({ lookup: customLookup, keepAlive: true });
+// ── Replace global HTTP agents ──────────────────────────────────────────
+// autoSelectFamily enables Node.js "Happy Eyeballs" (RFC 6555): when the
+// lookup returns both IPv4 and IPv6 addresses, Node races connections and
+// uses whichever family connects first.  This ensures the app works on
+// IPv4-only WiFi, IPv6-only networks, and dual-stack setups alike.
+const agentOptions = {
+  lookup: customLookup,
+  keepAlive: true,
+  autoSelectFamily: true,
+  autoSelectFamilyAttemptTimeout: 2500, // ms before trying the next family
+};
+http.globalAgent = new http.Agent(agentOptions);
+https.globalAgent = new https.Agent(agentOptions);
 
 // Dynamic import so aniwatch picks up patched global agents
 const { HiAnime } = await import("aniwatch");
@@ -64,15 +151,26 @@ const hianime = new HiAnime.Scraper();
 const action = process.argv[2];
 
 // Retry helper: retries an async fn up to `retries` times with a delay between attempts.
-async function withRetry(fn, { retries = 2, delay = 1000, label = "" } = {}) {
+// On transient network errors (ENETUNREACH, ECONNRESET, etc.) it retries automatically.
+async function withRetry(fn, { retries = 3, delay = 1200, label = "" } = {}) {
+  const TRANSIENT_CODES = new Set([
+    "ENETUNREACH", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT",
+    "EHOSTUNREACH", "EAI_AGAIN", "EPIPE", "ERR_SOCKET_CONNECTION_TIMEOUT",
+    "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_SOCKET", "ENOTFOUND",
+  ]);
   let lastErr;
   for (let i = 0; i <= retries; i++) {
     try {
       return await fn();
     } catch (err) {
       lastErr = err;
+      const isTransient = TRANSIENT_CODES.has(err.code) ||
+        (err.cause && TRANSIENT_CODES.has(err.cause.code)) ||
+        /timeout|ENETUNREACH|ECONNR|socket/i.test(err.message);
       if (i < retries) {
-        await new Promise(r => setTimeout(r, delay));
+        // Longer back-off for transient network errors
+        const backoff = isTransient ? delay * (i + 1) : delay;
+        await new Promise(r => setTimeout(r, backoff));
       }
     }
   }

package/install.sh

@@ -25,7 +25,7 @@ printf "  ╚═╝  ╚═══╝   ╚═╝          ╚═════╝
 printf "${RESET}\n"
 printf "${DIM}${CYAN}       ⟨ Your Gateway to Anime Streaming ⟩${RESET}\n"
 printf "${DIM}       ─────────────────────────────────────${RESET}\n"
-printf "${DIM}            v3.1.0 • nyanime.tech${RESET}\n"
+printf "${DIM}            v4.0.0 • nyanime.tech${RESET}\n"
 printf "\n"
 
 REPO_URL="https://raw.githubusercontent.com/AnjishnuSengupta/ny-cli/main"

package/ny-cli

@@ -1,7 +1,7 @@
 #!/bin/sh
 # ══════════════════════════════════════════════════════════════════════════════
 # NY-CLI - Terminal-based Anime Streaming Client
-# Version: 3.1.0
+# Version: 4.0.0
 # Author: Anjishnu Sengupta
 # Website: https://nyanime.tech
 # Repository: https://github.com/AnjishnuSengupta/ny-cli
@@ -10,7 +10,7 @@
 # Just install and run - no external API dependency!
 # ══════════════════════════════════════════════════════════════════════════════
 
-VERSION="3.1.0"
+VERSION="4.0.0"
 
 # ══════════════════════════════════════════════════════════════════════════════
 # BACKEND CONFIGURATION (Self-hosted via aniwatch npm package)
@@ -295,9 +295,11 @@ do_logout() {
 # WATCH HISTORY & CLOUD SYNC
 # ══════════════════════════════════════════════════════════════════════════════
 
-# Check if online
+# Check if online (try multiple endpoints — google is blocked in some countries)
 is_online() {
-    curl -s --connect-timeout 2 --max-time 3 "https://www.google.com" >/dev/null 2>&1
+    curl -s --connect-timeout 2 --max-time 3 "https://www.google.com" >/dev/null 2>&1 \
+        || curl -s --connect-timeout 2 --max-time 3 "https://cloudflare.com/cdn-cgi/trace" >/dev/null 2>&1 \
+        || curl -s --connect-timeout 2 --max-time 3 "https://www.nyanime.tech" >/dev/null 2>&1
 }
 
 # Fetch cloud history and merge with local history
@@ -325,27 +327,29 @@ fetch_and_merge_cloud_history() {
         local cloud_tmp="${CACHE_DIR}/cloud_merged.tmp"
         > "$cloud_tmp"
         
-        # Extract each history item with slug and title
+        # Extract each history item with slug, title, and category
         printf '%s' "$response" | tr '{' '\n' | grep '"animeSlug"' | while read -r item; do
-            local slug title ep_num
+            local slug title ep_num category
             slug=$(printf '%s' "$item" | sed -n 's/.*"animeSlug"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
             title=$(printf '%s' "$item" | sed -n 's/.*"animeTitle"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
             ep_num=$(printf '%s' "$item" | sed -n 's/.*"episodeNum"[[:space:]]*:[[:space:]]*\([0-9]*\).*/\1/p')
+            category=$(printf '%s' "$item" | sed -n 's/.*"category"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
             
             if [ -n "$slug" ] && [ -n "$title" ]; then
                 [ -z "$ep_num" ] && ep_num=1
+                [ -z "$category" ] && category="sub"
                 # Check if this anime is already in local history
                 if [ -f "$HISTORY_FILE" ]; then
                     if ! grep -q "^${slug}|" "$HISTORY_FILE" 2>/dev/null; then
-                        # Add to local history (new entry from cloud)
+                        # Add to local history (new entry from cloud) with category
                         local timestamp
                         timestamp=$(date +%s)
-                        printf '%s|%s|%s|%s\n' "$slug" "$title" "$ep_num" "$timestamp" >> "$cloud_tmp"
+                        printf '%s|%s|%s|%s|%s\n' "$slug" "$title" "$ep_num" "$timestamp" "$category" >> "$cloud_tmp"
                     fi
                 else
                     local timestamp
                     timestamp=$(date +%s)
-                    printf '%s|%s|%s|%s\n' "$slug" "$title" "$ep_num" "$timestamp" >> "$cloud_tmp"
+                    printf '%s|%s|%s|%s|%s\n' "$slug" "$title" "$ep_num" "$timestamp" "$category" >> "$cloud_tmp"
                 fi
             fi
         done
@@ -373,15 +377,15 @@ fetch_and_merge_cloud_history() {
 
 # Save watch progress to pending sync file (for offline support)
 save_pending_sync() {
-    local anime_slug="$1" anime_title="$2" ep_num="$3"
+    local anime_slug="$1" anime_title="$2" ep_num="$3" category="${4:-sub}"
     local sync_time
     sync_time=$(date +%s)
     
     # Remove existing entry for this anime
     [ -f "$PENDING_SYNC_FILE" ] && grep -v "^${anime_slug}|" "$PENDING_SYNC_FILE" > "${PENDING_SYNC_FILE}.tmp" 2>/dev/null && mv "${PENDING_SYNC_FILE}.tmp" "$PENDING_SYNC_FILE"
     
-    # Add new entry: anime_slug|anime_title|ep_num|sync_time
-    printf '%s|%s|%s|%s\n' "$anime_slug" "$anime_title" "$ep_num" "$sync_time" >> "$PENDING_SYNC_FILE"
+    # Add new entry: anime_slug|anime_title|ep_num|sync_time|category
+    printf '%s|%s|%s|%s|%s\n' "$anime_slug" "$anime_title" "$ep_num" "$sync_time" "$category" >> "$PENDING_SYNC_FILE"
 }
 
 # Sync pending history to cloud via nyanime API
@@ -399,25 +403,26 @@ sync_pending_history() {
     local synced=0
     local temp_file="${PENDING_SYNC_FILE}.syncing"
     
-    # Process each pending entry
-    while IFS='|' read -r anime_slug anime_title ep_num sync_time; do
+    # Process each pending entry (slug|title|ep_num|sync_time|category)
+    while IFS='|' read -r anime_slug anime_title ep_num sync_time category; do
         [ -z "$anime_slug" ] && continue
         [ -z "$anime_title" ] && anime_title="$anime_slug"
         [ -z "$ep_num" ] && ep_num=1
+        [ -z "$category" ] && category="sub"
         
-        # Sync via nyanime API with slug-based format
+        # Sync via nyanime API with slug-based format + category
         local response
         response=$(curl -s -X POST "${NYANIME_BASE}/api/cli/sync-watch" \
             -H "Content-Type: application/json" \
             -H "X-Firebase-UID: ${firebase_uid}" \
-            -d "{\"animeSlug\": \"${anime_slug}\", \"animeTitle\": \"${anime_title}\", \"episodeNum\": ${ep_num}}" \
+            -d "{\"animeSlug\": \"${anime_slug}\", \"animeTitle\": \"${anime_title}\", \"episodeNum\": ${ep_num}, \"category\": \"${category}\"}" \
             --connect-timeout 5 --max-time 10 2>/dev/null)
         
         if printf '%s' "$response" | grep -q '"success"' 2>/dev/null; then
             synced=$((synced + 1))
         else
             # Keep failed entries for retry
-            printf '%s|%s|%s|%s\n' "$anime_slug" "$anime_title" "$ep_num" "$sync_time" >> "$temp_file"
+            printf '%s|%s|%s|%s|%s\n' "$anime_slug" "$anime_title" "$ep_num" "$sync_time" "$category" >> "$temp_file"
         fi
     done < "$PENDING_SYNC_FILE"
     
@@ -433,15 +438,15 @@ sync_pending_history() {
 
 # Background sync daemon (called during playback)
 start_sync_daemon() {
-    local anime_slug="$1" anime_title="$2" ep_num="$3"
+    local anime_slug="$1" anime_title="$2" ep_num="$3" category="${4:-sub}"
     
     # Create a background process that syncs every 10 seconds
     (
         while true; do
             sleep "$SYNC_INTERVAL"
             
-            # Save to pending sync with slug and title
-            save_pending_sync "$anime_slug" "$anime_title" "$ep_num"
+            # Save to pending sync with slug, title, and category
+            save_pending_sync "$anime_slug" "$anime_title" "$ep_num" "$category"
             
             # Try to sync if online
             sync_pending_history >/dev/null 2>&1
@@ -456,7 +461,7 @@ stop_sync_daemon() {
 }
 
 save_to_history() {
-    local anime_slug="$1" title="$2" episode="$3"
+    local anime_slug="$1" title="$2" episode="$3" category="${4:-sub}"
     local timestamp
     timestamp=$(date +%s)
     
@@ -466,9 +471,9 @@ save_to_history() {
         mv "${HISTORY_FILE}.tmp" "$HISTORY_FILE" 2>/dev/null || true
     fi
     
-    # Create new entry and prepend to history
+    # Create new entry and prepend to history (slug|title|episode|timestamp|category)
     local new_entry
-    new_entry=$(printf '%s|%s|%s|%s\n' "$anime_slug" "$title" "$episode" "$timestamp")
+    new_entry=$(printf '%s|%s|%s|%s|%s\n' "$anime_slug" "$title" "$episode" "$timestamp" "$category")
     
     if [ -f "$HISTORY_FILE" ] && [ -s "$HISTORY_FILE" ]; then
         printf '%s\n' "$new_entry" | cat - "$HISTORY_FILE" > "${HISTORY_FILE}.tmp"
@@ -483,8 +488,8 @@ save_to_history() {
         mv "${HISTORY_FILE}.tmp" "$HISTORY_FILE"
     fi
     
-    # Save to pending sync for cloud backup (slug, title, episode)
-    save_pending_sync "$anime_slug" "$title" "$episode"
+    # Save to pending sync for cloud backup (slug, title, episode, category)
+    save_pending_sync "$anime_slug" "$title" "$episode" "$category"
     
     # Try immediate sync if online
     sync_pending_history >/dev/null 2>&1 &
@@ -498,7 +503,7 @@ save_to_history() {
 # Usage: call_backend <action> [args...]
 # Returns JSON to stdout (pino logger noise is filtered out)
 call_backend() {
-    NODE_ENV=production node "$BACKEND_SCRIPT" "$@" 2>/dev/null | grep -m1 '"success"\|"error"'
+    LOG_LEVEL=silent NODE_ENV=production node "$BACKEND_SCRIPT" "$@" 2>/dev/null | grep -m1 '"success"\|"error"'
 }
 
 # JSON parsing helpers (pure POSIX shell)
@@ -529,13 +534,15 @@ search_anime() {
     
     # Parse animes array from response
     # Each anime has: id, name, type, episodes.sub, episodes.dub
-    printf '%s' "$response" | tr '{' '\n' | grep '"id"' | while IFS= read -r line; do
+    # After tr '{' split, "sub" and "dub" are on the line AFTER "id", so merge them
+    printf '%s' "$response" | tr '{' '\n' | awk '/"id"/{buf=$0; getline; print buf $0}' | while IFS= read -r line; do
         local id name type sub
         id=$(printf '%s' "$line" | grep -oP '"id"\s*:\s*"\K[^"]+' 2>/dev/null)
         name=$(printf '%s' "$line" | grep -oP '"name"\s*:\s*"\K[^"]+' 2>/dev/null)
         type=$(printf '%s' "$line" | grep -oP '"type"\s*:\s*"\K[^"]+' 2>/dev/null)
         sub=$(printf '%s' "$line" | grep -oP '"sub"\s*:\s*\K[0-9]+' 2>/dev/null)
-        [ -n "$id" ] && [ -n "$name" ] && printf '%s|%s|%s|%s\n' "$id" "$name" "${type:-TV}" "${sub:-0}"
+        dub=$(printf '%s' "$line" | grep -oP '"dub"\s*:\s*\K[0-9]+' 2>/dev/null)
+        [ -n "$id" ] && [ -n "$name" ] && printf '%s|%s|%s|%s|%s\n' "$id" "$name" "${type:-TV}" "${sub:-0}" "${dub:-0}"
     done
 }
 
@@ -799,7 +806,10 @@ do_search() {
     printf '%s\n' "$results" | while IFS='|' read -r id title type eps_sub eps_dub; do
         local info=""
         [ -n "$type" ] && info="$type"
-        [ -n "$eps_sub" ] && [ "$eps_sub" != "0" ] && info="$info, ${eps_sub} eps"
+        if [ -n "$eps_sub" ] && [ "$eps_sub" != "0" ]; then
+            info="$info, ${eps_sub} sub"
+            [ -n "$eps_dub" ] && [ "$eps_dub" != "0" ] && [ "$eps_dub" != "null" ] && info="$info / ${eps_dub} dub"
+        fi
         [ -n "$info" ] && info=" ${DIM}($info)${RESET}"
         printf '%b\n' "  ${WHITE}$(printf '%2d' $i))${RESET} ${title}${info}"
         i=$((i + 1))
@@ -821,15 +831,41 @@ do_search() {
 }
 
 watch_anime() {
-    local anime_id="$1" anime_title="$2"
+    local anime_id="$1" anime_title="$2" category="${3:-}"
     
-    printf "\n"
-    episodes=$(get_episodes "$anime_id")
-    [ -z "$episodes" ] && msg_error "No episodes" && return
+    # Start fetching episodes in background while we ask sub/dub
+    local ep_cache="${CACHE_DIR}/ep_fetch.tmp"
+    rm -f "$ep_cache" 2>/dev/null
+    msg "Loading episodes..."
+    (get_episodes "$anime_id" > "$ep_cache" 2>/dev/null) &
+    local ep_fetch_pid=$!
+    
+    # Ask sub/dub preference if not already chosen
+    if [ -z "$category" ]; then
+        printf "\n"
+        printf '%b\n' "  ${GREEN}1)${RESET} Sub ${DIM}(Japanese audio + subtitles)${RESET}"
+        printf '%b\n' "  ${YELLOW}2)${RESET} Dub ${DIM}(English audio)${RESET}"
+        prompt "Sub or Dub? [1/2]: "
+        read -r cat_choice
+        case "$cat_choice" in
+            2|d|D|dub|Dub|DUB) category="dub" ;;
+            *) category="sub" ;;
+        esac
+    fi
+    
+    # Wait for episode fetch to complete
+    wait $ep_fetch_pid 2>/dev/null
+    episodes=$(cat "$ep_cache" 2>/dev/null)
+    rm -f "$ep_cache" 2>/dev/null
+    
+    [ -z "$episodes" ] && msg_error "No episodes found" && return
     
     ep_count=$(printf '%s\n' "$episodes" | wc -l)
     
-    printf '%b\n' "\n${CYAN}${anime_title}${RESET} ${DIM}(${ep_count} eps)${RESET}"
+    local cat_label
+    [ "$category" = "dub" ] && cat_label="${YELLOW}DUB${RESET}" || cat_label="${GREEN}SUB${RESET}"
+    
+    printf '%b\n' "\n${CYAN}${anime_title}${RESET} ${DIM}(${ep_count} eps)${RESET} [${cat_label}]"
     print_line
     
     if [ "$ep_count" -gt 20 ]; then
@@ -856,30 +892,33 @@ watch_anime() {
     [ -z "$ep_line" ] && msg_error "Invalid" && return
     
     episode_id=$(printf '%s' "$ep_line" | cut -d'|' -f2)
-    play_episode "$anime_id" "$anime_title" "$ep_choice" "$episode_id" "$episodes"
+    play_episode "$anime_id" "$anime_title" "$ep_choice" "$episode_id" "$episodes" "$category"
 }
 
 play_episode() {
-    local anime_id="$1" anime_title="$2" ep_num="$3" episode_id="$4" episodes="$5"
+    local anime_id="$1" anime_title="$2" ep_num="$3" episode_id="$4" episodes="$5" category="${6:-sub}"
     
     printf "\n"
     
-    # Get streaming sources with fallback to multiple servers
-    if ! get_stream_with_fallback "$episode_id" "sub"; then
+    # Get streaming sources with the user's chosen category
+    if ! get_stream_with_fallback "$episode_id" "$category"; then
         msg_error "No stream available for this episode"
         return
     fi
     
     [ -z "$STREAM_URL" ] && msg_error "No stream URL found" && return
     
-    # Save to history (slug, title, episode)
-    save_to_history "$anime_id" "$anime_title" "$ep_num"
+    # Save to history with category preference (slug, title, episode, category)
+    save_to_history "$anime_id" "$anime_title" "$ep_num" "$category"
     
-    # Start background sync daemon during playback (slug, title, episode)
-    start_sync_daemon "$anime_id" "$anime_title" "$ep_num"
+    # Start background sync daemon during playback (slug, title, episode, category)
+    start_sync_daemon "$anime_id" "$anime_title" "$ep_num" "$category"
+    
+    local cat_label
+    [ "$category" = "dub" ] && cat_label="DUB" || cat_label="SUB"
     
     # Play the video with referer header
-    play_video "$STREAM_URL" "${anime_title} - Episode ${ep_num}" "$STREAM_SUBTITLES" "$STREAM_REFERER"
+    play_video "$STREAM_URL" "${anime_title} - Episode ${ep_num} [${cat_label}]" "$STREAM_SUBTITLES" "$STREAM_REFERER"
     
     # Stop sync daemon after playback ends
     stop_sync_daemon
@@ -900,13 +939,13 @@ play_episode() {
             next_line=$(printf '%s\n' "$episodes" | grep "^${next_ep}|")
             if [ -n "$next_line" ]; then
                 next_id=$(printf '%s' "$next_line" | cut -d'|' -f2)
-                play_episode "$anime_id" "$anime_title" "$next_ep" "$next_id" "$episodes"
+                play_episode "$anime_id" "$anime_title" "$next_ep" "$next_id" "$episodes" "$category"
             else
                 msg_info "No more episodes"
             fi
             ;;
-        r) play_episode "$anime_id" "$anime_title" "$ep_num" "$episode_id" "$episodes" ;;
-        s) watch_anime "$anime_id" "$anime_title" ;;
+        r) play_episode "$anime_id" "$anime_title" "$ep_num" "$episode_id" "$episodes" "$category" ;;
+        s) watch_anime "$anime_id" "$anime_title" "$category" ;;
     esac
 }
 
@@ -931,8 +970,11 @@ do_continue() {
     print_line
     
     i=1
-    head -10 "$HISTORY_FILE" | while IFS='|' read -r id title episode ts; do
-        printf '%b\n' "  ${WHITE}$(printf '%2d' $i))${RESET} $title ${DIM}(Ep $episode)${RESET}"
+    head -10 "$HISTORY_FILE" | while IFS='|' read -r id title episode ts category; do
+        [ -z "$category" ] && category="sub"
+        local cat_badge
+        [ "$category" = "dub" ] && cat_badge="${YELLOW}DUB${RESET}" || cat_badge="${GREEN}SUB${RESET}"
+        printf '%b\n' "  ${WHITE}$(printf '%2d' $i))${RESET} $title ${DIM}(Ep $episode)${RESET} [${cat_badge}]"
         i=$((i + 1))
     done
     print_line
@@ -948,17 +990,21 @@ do_continue() {
     anime_id=$(printf '%s' "$selected" | cut -d'|' -f1)
     anime_title=$(printf '%s' "$selected" | cut -d'|' -f2)
     last_ep=$(printf '%s' "$selected" | cut -d'|' -f3)
+    category=$(printf '%s' "$selected" | cut -d'|' -f5)
+    [ -z "$category" ] && category="sub"
     
     episodes=$(get_episodes "$anime_id")
     next_ep=$((last_ep + 1))
     next_line=$(printf '%s\n' "$episodes" | grep "^${next_ep}|")
     
     if [ -n "$next_line" ]; then
-        msg_info "Continuing Episode ${next_ep}"
+        local cat_label
+        [ "$category" = "dub" ] && cat_label="DUB" || cat_label="SUB"
+        msg_info "Continuing Episode ${next_ep} [${cat_label}]"
         episode_id=$(printf '%s' "$next_line" | cut -d'|' -f2)
-        play_episode "$anime_id" "$anime_title" "$next_ep" "$episode_id" "$episodes"
+        play_episode "$anime_id" "$anime_title" "$next_ep" "$episode_id" "$episodes" "$category"
     else
-        watch_anime "$anime_id" "$anime_title"
+        watch_anime "$anime_id" "$anime_title" "$category"
     fi
 }
 
@@ -1019,14 +1065,7 @@ do_random() {
     
     case "$ans" in
         [nN]*) return ;;
-        *)
-            episodes=$(get_episodes "$anime_id")
-            first=$(printf '%s\n' "$episodes" | head -1)
-            [ -n "$first" ] && {
-                ep_id=$(printf '%s' "$first" | cut -d'|' -f2)
-                play_episode "$anime_id" "$anime_title" "1" "$ep_id" "$episodes"
-            }
-            ;;
+        *) watch_anime "$anime_id" "$anime_title" ;;
     esac
 }
 
@@ -1100,7 +1139,7 @@ main_menu() {
             
             printf '%b\n' "${CYAN}╭────────────────────────────────────────╮${RESET}"
             printf '%b\n' "${CYAN}│${RESET}  ${WHITE}1)${RESET} 👤 Profile                         ${CYAN}│${RESET}"
-            printf '%b\n' "${CYAN}│${RESET}  ${WHITE}2)${RESET} ▶️  Continue Watching              ${CYAN}│${RESET}"
+            printf '%b\n' "${CYAN}│${RESET}  ${WHITE}2)${RESET} ▶️  Continue Watching               ${CYAN}│${RESET}"
             printf '%b\n' "${CYAN}│${RESET}  ${WHITE}3)${RESET} 🔍 Search                          ${CYAN}│${RESET}"
             printf '%b\n' "${CYAN}│${RESET}  ${WHITE}4)${RESET} 📚 Trending                        ${CYAN}│${RESET}"
             printf '%b\n' "${CYAN}│${RESET}  ${WHITE}5)${RESET} 🎲 Random                          ${CYAN}│${RESET}"
@@ -1168,10 +1207,13 @@ main() {
                     printf '%b\n' "\n${CYAN}Results:${RESET}"
                     print_line
                     i=1
-                    printf '%s\n' "$results" | while IFS='|' read -r id title type eps; do
+                    printf '%s\n' "$results" | while IFS='|' read -r id title type eps_sub eps_dub; do
                         local info=""
                         [ -n "$type" ] && info="$type"
-                        [ -n "$eps" ] && [ "$eps" != "0" ] && info="$info, ${eps} eps"
+                        if [ -n "$eps_sub" ] && [ "$eps_sub" != "0" ]; then
+                            info="$info, ${eps_sub} sub"
+                            [ -n "$eps_dub" ] && [ "$eps_dub" != "0" ] && [ "$eps_dub" != "null" ] && info="$info / ${eps_dub} dub"
+                        fi
                         [ -n "$info" ] && info=" ${DIM}($info)${RESET}"
                         printf '%b\n' "  ${WHITE}$(printf '%2d' $i))${RESET} ${title}${info}"
                         i=$((i + 1))
@@ -1196,10 +1238,13 @@ main() {
                 printf '%b\n' "\n${CYAN}Results:${RESET}"
                 print_line
                 i=1
-                printf '%s\n' "$results" | while IFS='|' read -r id title type eps; do
+                printf '%s\n' "$results" | while IFS='|' read -r id title type eps_sub eps_dub; do
                     local info=""
                     [ -n "$type" ] && info="$type"
-                    [ -n "$eps" ] && [ "$eps" != "0" ] && info="$info, ${eps} eps"
+                    if [ -n "$eps_sub" ] && [ "$eps_sub" != "0" ]; then
+                        info="$info, ${eps_sub} sub"
+                        [ -n "$eps_dub" ] && [ "$eps_dub" != "0" ] && [ "$eps_dub" != "null" ] && info="$info / ${eps_dub} dub"
+                    fi
                     [ -n "$info" ] && info=" ${DIM}($info)${RESET}"
                     printf '%b\n' "  ${WHITE}$(printf '%2d' $i))${RESET} ${title}${info}"
                     i=$((i + 1))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjishnusengupta/ny-cli",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "Terminal-based anime streaming client — self-hosted scraping via aniwatch",
   "main": "backend.mjs",
   "bin": {