open-nami 1.3.1 → 1.6.0

package/dist/cli.js

@@ -9,7 +9,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "open-nami",
-      version: "1.3.1",
+      version: "1.6.0",
       description: "Open Nami: terminal-first bulk social media profile downloader for Instagram, TikTok, Facebook & X.",
       type: "module",
       bin: {
@@ -73,11 +73,11 @@ var require_package = __commonJS({
 });
 
 // src/cli.tsx
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { render } from "ink";
 
 // src/app.tsx
-import { useState as useState9, useCallback as useCallback4, useRef as useRef5, useEffect as useEffect8, useMemo as useMemo3 } from "react";
+import { useState as useState10, useCallback as useCallback4, useRef as useRef5, useEffect as useEffect10, useMemo as useMemo3 } from "react";
 import { Box as Box15, Text as Text17, useApp, useInput as useInput5, useStdout as useStdout3 } from "ink";
 import Spinner4 from "ink-spinner";
 
@@ -730,16 +730,8 @@ async function clearCheckpoint(destDir) {
 }
 
 // src/lib/engines/dispatcher.ts
-import path10 from "path";
-import os5 from "os";
-import fs10 from "fs/promises";
-import fsSync from "fs";
-
-// src/lib/cookies.ts
-import fs2 from "fs";
-import fsPromises2 from "fs/promises";
-import path3 from "path";
-import os2 from "os";
+import path13 from "path";
+import fs13 from "fs/promises";
 
 // src/lib/config.ts
 import fs from "fs";
@@ -757,9 +749,25 @@ function loadConfig(configPath = getDefaultConfigPath()) {
     const raw = fs.readFileSync(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
+      let cookiesFromBrowser = "auto";
+      if (typeof parsed.cookiesFromBrowser === "string") {
+        const trimmed = parsed.cookiesFromBrowser.trim();
+        const lower = trimmed.toLowerCase();
+        if (lower === "none") {
+          cookiesFromBrowser = "none";
+        } else if (lower === "auto" || trimmed === "") {
+          cookiesFromBrowser = "auto";
+        } else {
+          const knownBrowsers = ["chrome", "edge", "brave", "firefox", "helium", "opera", "vivaldi"];
+          cookiesFromBrowser = knownBrowsers.includes(lower) ? lower : trimmed;
+        }
+      } else {
+        cookiesFromBrowser = "auto";
+      }
       return {
         theme: typeof parsed.theme === "string" ? parsed.theme : void 0,
         cookiesDir: typeof parsed.cookiesDir === "string" ? parsed.cookiesDir.trim() : void 0,
+        cookiesFromBrowser,
         downloadDir: typeof parsed.downloadDir === "string" ? parsed.downloadDir.trim() : void 0,
         writeMetadata: typeof parsed.writeMetadata === "boolean" ? parsed.writeMetadata : void 0,
         defaultLimit: typeof parsed.defaultLimit === "number" ? parsed.defaultLimit : void 0
@@ -781,22 +789,442 @@ function saveConfig(config, configPath = getDefaultConfigPath()) {
   }
 }
 
+// src/lib/cookies.ts
+import fs3 from "fs";
+import fsPromises2 from "fs/promises";
+import path4 from "path";
+import os3 from "os";
+
+// src/lib/cookies/browser-bridge.ts
+import { execSync } from "child_process";
+import fs2 from "fs";
+import os2 from "os";
+import path3 from "path";
+function listDetectedBrowsers() {
+  const isWin = process.platform === "win32";
+  const isMac = process.platform === "darwin";
+  const home = os2.homedir();
+  const candidates = [
+    {
+      id: "chrome",
+      name: "Google Chrome",
+      winDir: path3.join(
+        process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local"),
+        "Google",
+        "Chrome",
+        "User Data"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linuxDir: path3.join(home, ".config", "google-chrome"),
+      engine: "chrome"
+    },
+    {
+      id: "edge",
+      name: "Microsoft Edge",
+      winDir: path3.join(
+        process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local"),
+        "Microsoft",
+        "Edge",
+        "User Data"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "Microsoft Edge"),
+      linuxDir: path3.join(home, ".config", "microsoft-edge"),
+      engine: "edge"
+    },
+    {
+      id: "brave",
+      name: "Brave Browser",
+      winDir: path3.join(
+        process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local"),
+        "BraveSoftware",
+        "Brave-Browser",
+        "User Data"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "BraveSoftware", "Brave-Browser"),
+      linuxDir: path3.join(home, ".config", "BraveSoftware", "Brave-Browser"),
+      engine: "brave"
+    },
+    {
+      id: "firefox",
+      name: "Mozilla Firefox",
+      winDir: path3.join(
+        process.env.APPDATA || path3.join(home, "AppData", "Roaming"),
+        "Mozilla",
+        "Firefox",
+        "Profiles"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "Firefox", "Profiles"),
+      linuxDir: path3.join(home, ".mozilla", "firefox"),
+      engine: "firefox"
+    },
+    {
+      id: "helium",
+      name: "Helium",
+      winDir: path3.join(
+        process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local"),
+        "imput",
+        "Helium",
+        "User Data"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "net.imput.Helium"),
+      linuxDir: path3.join(home, ".config", "helium"),
+      engine: "chrome"
+    },
+    {
+      id: "opera",
+      name: "Opera",
+      winDir: path3.join(
+        process.env.APPDATA || path3.join(home, "AppData", "Roaming"),
+        "Opera Software",
+        "Opera Stable"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "com.operasoftware.Opera"),
+      linuxDir: path3.join(home, ".config", "opera"),
+      engine: "opera"
+    },
+    {
+      id: "vivaldi",
+      name: "Vivaldi",
+      winDir: path3.join(
+        process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local"),
+        "Vivaldi",
+        "User Data"
+      ),
+      macDir: path3.join(home, "Library", "Application Support", "Vivaldi"),
+      linuxDir: path3.join(home, ".config", "vivaldi"),
+      engine: "vivaldi"
+    }
+  ];
+  return candidates.map((c) => {
+    const profileDir = isWin ? c.winDir : isMac ? c.macDir : c.linuxDir;
+    return {
+      id: c.id,
+      name: c.name,
+      profileDir,
+      available: fs2.existsSync(profileDir),
+      engine: c.engine
+    };
+  });
+}
+function parseWindowsDefaultBrowserProgId(rawOutput) {
+  if (!rawOutput) return null;
+  const lines = rawOutput.split(/\r?\n/);
+  const pattern = /^\s*ProgId\s+REG_\w+\s+(\S.*)$/i;
+  for (const line of lines) {
+    const match = line.match(pattern);
+    if (match && match[1]) {
+      const progId = match[1].trim();
+      if (progId) return progId;
+    }
+  }
+  return null;
+}
+function mapProgIdToBrowserId(progId, commandOutput, platformOverride = "win32") {
+  const p = (progId || "").trim();
+  const pLower = p.toLowerCase();
+  const cmd = (commandOutput || "").toLowerCase();
+  const isWin = platformOverride === "win32";
+  const isMac = platformOverride === "darwin";
+  const home = os2.homedir();
+  const heliumDir = isWin ? path3.join(
+    process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local"),
+    "imput",
+    "Helium",
+    "User Data"
+  ) : isMac ? path3.join(home, "Library", "Application Support", "net.imput.Helium") : path3.join(home, ".config", "helium");
+  if (pLower.includes("helium") || cmd.includes("helium")) {
+    return {
+      id: "helium",
+      name: "Helium",
+      engine: "chrome",
+      profileDir: heliumDir
+    };
+  }
+  if (pLower.startsWith("chromehtml") || pLower.includes("chrome") || cmd.includes("chrome.exe")) {
+    return {
+      id: "chrome",
+      name: "Google Chrome",
+      engine: "chrome"
+    };
+  }
+  if (pLower.startsWith("msedge") || pLower.includes("edge") || pLower.startsWith("appxq0fevzme2pys62n3e0fbqsw5cj08ege9") || cmd.includes("msedge.exe")) {
+    return {
+      id: "edge",
+      name: "Microsoft Edge",
+      engine: "edge"
+    };
+  }
+  if (pLower.startsWith("brave") || pLower.includes("brave") || cmd.includes("brave.exe")) {
+    return {
+      id: "brave",
+      name: "Brave Browser",
+      engine: "brave"
+    };
+  }
+  if (pLower.startsWith("firefox") || pLower.includes("firefox") || cmd.includes("firefox.exe")) {
+    return {
+      id: "firefox",
+      name: "Mozilla Firefox",
+      engine: "firefox"
+    };
+  }
+  if (pLower.startsWith("opera") || pLower.includes("opera") || cmd.includes("opera.exe")) {
+    return {
+      id: "opera",
+      name: "Opera",
+      engine: "opera"
+    };
+  }
+  if (pLower.startsWith("vivaldi") || pLower.includes("vivaldi") || cmd.includes("vivaldi.exe")) {
+    return {
+      id: "vivaldi",
+      name: "Vivaldi",
+      engine: "vivaldi"
+    };
+  }
+  return {
+    id: pLower || "chromium",
+    name: p || "Chromium",
+    engine: "chromium"
+  };
+}
+function parseMacDefaultBrowserBundleId(rawOutput) {
+  if (!rawOutput) return null;
+  const blocks = rawOutput.split(/[{}]/);
+  let httpBundle = null;
+  for (const block of blocks) {
+    const isHttps = /LSHandlerURLScheme\s*=\s*https\b/i.test(block);
+    const isHttp = /LSHandlerURLScheme\s*=\s*http\b/i.test(block);
+    if (!isHttps && !isHttp) continue;
+    const roleMatch = block.match(/LSHandlerRole(?:All|Viewer)\s*=\s*["']?([^"';\s]+)["']?/i);
+    if (roleMatch && roleMatch[1]) {
+      const bundleId = roleMatch[1].trim();
+      if (isHttps) {
+        return bundleId;
+      }
+      if (!httpBundle) {
+        httpBundle = bundleId;
+      }
+    }
+  }
+  return httpBundle;
+}
+function mapBundleIdToBrowserId(bundleId) {
+  const lower = bundleId.toLowerCase();
+  if (lower.includes("helium")) {
+    const home = os2.homedir();
+    return {
+      id: "helium",
+      name: "Helium",
+      engine: "chrome",
+      profileDir: path3.join(home, "Library", "Application Support", "net.imput.Helium")
+    };
+  }
+  if (lower.includes("chrome")) {
+    return { id: "chrome", name: "Google Chrome", engine: "chrome" };
+  }
+  if (lower.includes("edge")) {
+    return { id: "edge", name: "Microsoft Edge", engine: "edge" };
+  }
+  if (lower.includes("brave")) {
+    return { id: "brave", name: "Brave Browser", engine: "brave" };
+  }
+  if (lower.includes("firefox")) {
+    return { id: "firefox", name: "Mozilla Firefox", engine: "firefox" };
+  }
+  if (lower.includes("opera")) {
+    return { id: "opera", name: "Opera", engine: "opera" };
+  }
+  if (lower.includes("vivaldi")) {
+    return { id: "vivaldi", name: "Vivaldi", engine: "vivaldi" };
+  }
+  if (lower.includes("safari")) {
+    return { id: "safari", name: "Safari", engine: "safari" };
+  }
+  return { id: lower, name: bundleId, engine: "chromium" };
+}
+function parseLinuxDefaultBrowserDesktop(rawOutput) {
+  if (!rawOutput) return null;
+  const lines = rawOutput.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("ERROR:") && !trimmed.includes("not found")) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function mapLinuxDesktopToBrowserId(desktopFile) {
+  const lower = desktopFile.toLowerCase();
+  if (lower.includes("helium")) {
+    const home = os2.homedir();
+    return {
+      id: "helium",
+      name: "Helium",
+      engine: "chrome",
+      profileDir: path3.join(home, ".config", "helium")
+    };
+  }
+  if (lower.includes("chrome")) {
+    return { id: "chrome", name: "Google Chrome", engine: "chrome" };
+  }
+  if (lower.includes("edge")) {
+    return { id: "edge", name: "Microsoft Edge", engine: "edge" };
+  }
+  if (lower.includes("brave")) {
+    return { id: "brave", name: "Brave Browser", engine: "brave" };
+  }
+  if (lower.includes("firefox")) {
+    return { id: "firefox", name: "Mozilla Firefox", engine: "firefox" };
+  }
+  if (lower.includes("opera")) {
+    return { id: "opera", name: "Opera", engine: "opera" };
+  }
+  if (lower.includes("vivaldi")) {
+    return { id: "vivaldi", name: "Vivaldi", engine: "vivaldi" };
+  }
+  return { id: lower.replace(/\.desktop$/, ""), name: desktopFile, engine: "chromium" };
+}
+function queryWindows(execute, platformOverride) {
+  let out = execute(
+    'reg query "HKCU\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\https\\UserChoice" /v ProgId'
+  );
+  let progId = parseWindowsDefaultBrowserProgId(out);
+  if (!progId) {
+    out = execute(
+      'reg query "HKCU\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice" /v ProgId'
+    );
+    progId = parseWindowsDefaultBrowserProgId(out);
+  }
+  if (progId) {
+    const cmdOut = execute(`reg query "HKCR\\${progId}\\shell\\open\\command"`);
+    return mapProgIdToBrowserId(progId, cmdOut, platformOverride ?? "win32");
+  }
+  return null;
+}
+function queryMac(execute) {
+  const out = execute(
+    "defaults read com.apple.LaunchServices/com.apple.launchservices.secure LSHandlers"
+  );
+  const bundleId = parseMacDefaultBrowserBundleId(out);
+  if (bundleId) {
+    return mapBundleIdToBrowserId(bundleId);
+  }
+  return null;
+}
+function queryLinux(execute) {
+  let out = execute("xdg-settings get default-web-browser");
+  let desktop = parseLinuxDefaultBrowserDesktop(out);
+  if (!desktop) {
+    out = execute("xdg-mime query default x-scheme-handler/https");
+    desktop = parseLinuxDefaultBrowserDesktop(out);
+  }
+  if (!desktop) {
+    out = execute("xdg-mime query default x-scheme-handler/http");
+    desktop = parseLinuxDefaultBrowserDesktop(out);
+  }
+  if (desktop) {
+    return mapLinuxDesktopToBrowserId(desktop);
+  }
+  return null;
+}
+function detectSystemDefaultBrowser(execFn, platformOverride) {
+  const platform = platformOverride ?? process.platform;
+  const execute = execFn ?? ((cmd) => {
+    try {
+      return execSync(cmd, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"],
+        timeout: 2500
+      });
+    } catch {
+      return "";
+    }
+  });
+  let detectedInfo = null;
+  if (platform === "win32") {
+    detectedInfo = queryWindows(execute, platform);
+  } else if (platform === "darwin") {
+    detectedInfo = queryMac(execute);
+  } else if (platform === "linux") {
+    detectedInfo = queryLinux(execute);
+  }
+  if (!detectedInfo && execFn && !platformOverride) {
+    if (platform !== "win32") detectedInfo = queryWindows(execute, "win32");
+    if (!detectedInfo && platform !== "darwin") detectedInfo = queryMac(execute);
+    if (!detectedInfo && platform !== "linux") detectedInfo = queryLinux(execute);
+  }
+  const allBrowsers = listDetectedBrowsers();
+  if (detectedInfo) {
+    const matched = allBrowsers.find((b) => b.id === detectedInfo.id);
+    if (matched) {
+      if (detectedInfo.profileDir) {
+        return {
+          ...matched,
+          profileDir: detectedInfo.profileDir,
+          available: fs2.existsSync(detectedInfo.profileDir)
+        };
+      }
+      return matched;
+    }
+    const profDir = detectedInfo.profileDir || "";
+    return {
+      id: detectedInfo.id,
+      name: detectedInfo.name || detectedInfo.id,
+      profileDir: profDir,
+      available: profDir ? fs2.existsSync(profDir) : false,
+      engine: detectedInfo.engine
+    };
+  }
+  const availableFallback = allBrowsers.find((b) => b.available);
+  return availableFallback || null;
+}
+function resolveBrowserCookieArg(browser) {
+  if (!browser) {
+    return null;
+  }
+  if (typeof browser === "string") {
+    const trimmed = browser.trim();
+    if (!trimmed || trimmed.toLowerCase() === "none") {
+      return null;
+    }
+    if (trimmed.toLowerCase() === "helium") {
+      const detectedHelium = listDetectedBrowsers().find((b) => b.id === "helium");
+      const profileDir = detectedHelium?.profileDir;
+      return profileDir ? `chrome:${profileDir}` : "chrome";
+    }
+    if (trimmed.toLowerCase() === "auto") {
+      const defaultBrowser = detectSystemDefaultBrowser();
+      return resolveBrowserCookieArg(defaultBrowser);
+    }
+    return trimmed;
+  }
+  if (!browser.id || browser.id.toLowerCase() === "none") {
+    return null;
+  }
+  if (browser.id.toLowerCase() === "helium") {
+    const profileDir = browser.profileDir || listDetectedBrowsers().find((b) => b.id === "helium")?.profileDir;
+    return profileDir ? `chrome:${profileDir}` : "chrome";
+  }
+  return browser.id;
+}
+
 // src/lib/cookies.ts
 var CANDIDATE_DIRS = [
-  path3.join(os2.homedir(), ".open-nami", "cookies"),
-  path3.join(os2.homedir(), ".nami", "cookies"),
-  path3.join(process.cwd(), "cookies")
+  path4.join(os3.homedir(), ".open-nami", "cookies"),
+  path4.join(os3.homedir(), ".nami", "cookies"),
+  path4.join(process.cwd(), "cookies")
 ];
 function getCandidateDirs(customDir) {
   const dirs = [];
   const configured = loadConfig().cookiesDir;
   const custom = customDir || process.env.OPEN_NAMI_COOKIES_DIR || process.env.NAMI_COOKIES_DIR || configured;
   if (custom && custom.trim()) {
-    dirs.push(path3.resolve(custom.trim()));
+    dirs.push(path4.resolve(custom.trim()));
   }
-  const seen = new Set(dirs.map((d) => path3.normalize(d).toLowerCase()));
+  const seen = new Set(dirs.map((d) => path4.normalize(d).toLowerCase()));
   for (const dir of CANDIDATE_DIRS) {
-    const norm = path3.normalize(dir).toLowerCase();
+    const norm = path4.normalize(dir).toLowerCase();
     if (!seen.has(norm)) {
       seen.add(norm);
       dirs.push(dir);
@@ -816,12 +1244,12 @@ function findCookieFile(platform, customDir) {
   const filenames = domainNames[platform] || [];
   const candidateDirs = getCandidateDirs(customDir);
   for (const dir of candidateDirs) {
-    if (!fs2.existsSync(dir)) continue;
+    if (!fs3.existsSync(dir)) continue;
     for (const file of filenames) {
-      const fullPath = path3.join(dir, file);
-      if (fs2.existsSync(fullPath)) {
+      const fullPath = path4.join(dir, file);
+      if (fs3.existsSync(fullPath)) {
         try {
-          const stats = fs2.statSync(fullPath);
+          const stats = fs3.statSync(fullPath);
           if (stats.size > 20) {
             return fullPath;
           }
@@ -837,14 +1265,14 @@ function detectAvailableCookies(customDir) {
   return platforms.filter((p) => Boolean(findCookieFile(p, customDir)));
 }
 async function createSafeCookieCopy(masterPath) {
-  const userTempDir = path3.join(os2.homedir(), ".open-nami", "temp");
+  const userTempDir = path4.join(os3.homedir(), ".open-nami", "temp");
   let targetDir = userTempDir;
   try {
     await fsPromises2.mkdir(userTempDir, { recursive: true, mode: 448 });
   } catch {
-    targetDir = os2.tmpdir();
+    targetDir = os3.tmpdir();
   }
-  const tempPath = path3.join(targetDir, `nami_cookie_${Date.now()}_${Math.random().toString(36).slice(2)}.txt`);
+  const tempPath = path4.join(targetDir, `nami_cookie_${Date.now()}_${Math.random().toString(36).slice(2)}.txt`);
   await fsPromises2.copyFile(masterPath, tempPath);
   await fsPromises2.chmod(tempPath, 384).catch(() => {
   });
@@ -860,141 +1288,6 @@ async function createSafeCookieCopy(masterPath) {
   };
 }
 
-// src/lib/known-folders.ts
-import { execFileSync } from "child_process";
-import fs3 from "fs";
-import os3 from "os";
-import path4 from "path";
-var KNOWN_FOLDER_DOWNLOADS_GUID = "{374DE290-123F-4565-9164-39C4925E467B}";
-var USER_SHELL_FOLDERS_REG_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
-function expandWindowsEnv(str, env = process.env, homeDir) {
-  return str.replace(/%([^%]+)%/g, (original, name) => {
-    if (homeDir && name.toLowerCase() === "userprofile") {
-      return homeDir;
-    }
-    const key = Object.keys(env).find((k) => k.toLowerCase() === name.toLowerCase());
-    if (key && env[key] !== void 0) {
-      return env[key];
-    }
-    return original;
-  });
-}
-function parseWindowsRegistryOutput(output, targetKey = KNOWN_FOLDER_DOWNLOADS_GUID) {
-  const lines = output.split(/\r?\n/);
-  const escaped = targetKey.replace(/[{}]/g, "\\$&");
-  const pattern = new RegExp(`^\\s*${escaped}\\s+REG_\\w+\\s+(.*)$`, "i");
-  for (const line of lines) {
-    const match = line.match(pattern);
-    if (match && match[1]) {
-      const rawPath = match[1].trim();
-      if (rawPath) return rawPath;
-    }
-  }
-  return void 0;
-}
-function parseLinuxUserDirsOutput(content) {
-  const lines = content.split(/\r?\n/);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("#")) continue;
-    const match = trimmed.match(/^XDG_DOWNLOAD_DIR=["']?([^"']+)["']?$/);
-    if (match && match[1]) {
-      return match[1].trim();
-    }
-  }
-  return void 0;
-}
-function isPathDriveAccessible(filePath, fsExists = fs3.existsSync, platform = process.platform) {
-  try {
-    if (fsExists(filePath)) {
-      return true;
-    }
-    if (platform === "win32") {
-      const match = filePath.match(/^([a-zA-Z]:[\\/])/i);
-      const driveRoot = match ? match[1] : path4.win32.parse(path4.win32.resolve(filePath)).root;
-      return fsExists(driveRoot);
-    }
-    const normalized = filePath.replace(/\\/g, "/");
-    const mountMatch = normalized.match(/^(\/(?:media(?:\/[^/]+)?|mnt|run\/media(?:\/[^/]+)?)\/[^/]+)/);
-    if (mountMatch) {
-      return fsExists(mountMatch[1]);
-    }
-    let curr = path4.posix.dirname(normalized);
-    while (curr && curr !== "/") {
-      if (fsExists(curr)) return true;
-      curr = path4.posix.dirname(curr);
-    }
-    return fsExists("/");
-  } catch {
-    return false;
-  }
-}
-function resolveWindowsDownloadsDir(options = {}) {
-  const homeDir = options.homeDir ?? os3.homedir();
-  const env = options.env ?? process.env;
-  const runQuery = options.regQueryFn ?? ((key, value) => {
-    try {
-      return execFileSync("reg", ["query", key, "/v", value], {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "ignore"]
-      });
-    } catch {
-      return "";
-    }
-  });
-  const checkAccessible = options.driveAccessibleFn ?? ((p) => isPathDriveAccessible(p, fs3.existsSync, "win32"));
-  let raw = parseWindowsRegistryOutput(
-    runQuery(USER_SHELL_FOLDERS_REG_KEY, KNOWN_FOLDER_DOWNLOADS_GUID),
-    KNOWN_FOLDER_DOWNLOADS_GUID
-  );
-  if (!raw) {
-    raw = parseWindowsRegistryOutput(runQuery(USER_SHELL_FOLDERS_REG_KEY, "Downloads"), "Downloads");
-  }
-  if (raw) {
-    const expanded = expandWindowsEnv(raw, env, homeDir);
-    if (checkAccessible(expanded)) {
-      return path4.win32.resolve(expanded);
-    }
-  }
-  return void 0;
-}
-function resolveLinuxDownloadsDir(options = {}) {
-  const homeDir = options.homeDir ?? os3.homedir();
-  const env = options.env ?? process.env;
-  const readFn = options.readFileFn ?? ((p) => {
-    try {
-      return fs3.readFileSync(p, "utf8");
-    } catch {
-      return "";
-    }
-  });
-  const checkAccessible = options.driveAccessibleFn ?? ((p) => isPathDriveAccessible(p, fs3.existsSync, "linux"));
-  const configHome = env.XDG_CONFIG_HOME || path4.join(homeDir, ".config");
-  const userDirsFile = path4.join(configHome, "user-dirs.dirs");
-  const content = readFn(userDirsFile);
-  if (!content) return void 0;
-  const raw = parseLinuxUserDirsOutput(content);
-  if (!raw) return void 0;
-  const expanded = raw.replace(/\$HOME/g, homeDir).replace(/\$\{HOME\}/g, homeDir);
-  if (checkAccessible(expanded)) {
-    return path4.posix.resolve(expanded);
-  }
-  return void 0;
-}
-function resolvePlatformDownloadsDir(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os3.homedir();
-  const defaultFallback = path4.join(homeDir, "Downloads");
-  if (platform === "win32") {
-    const resolved = resolveWindowsDownloadsDir(options);
-    if (resolved) return resolved;
-  } else if (platform === "linux") {
-    const resolved = resolveLinuxDownloadsDir(options);
-    if (resolved) return resolved;
-  }
-  return defaultFallback;
-}
-
 // src/lib/engines/extractors/instagram.ts
 import crypto from "crypto";
 
@@ -1379,8 +1672,8 @@ var InstagramExtractor = class {
     }
     const user = res.data.user;
     if (user.is_private) {
-      const fs14 = user.friendship_status;
-      const isFollowing = fs14 ? Boolean(fs14.following) : Boolean(user.followed_by_viewer);
+      const fs18 = user.friendship_status;
+      const isFollowing = fs18 ? Boolean(fs18.following) : Boolean(user.followed_by_viewer);
       if (!isFollowing) {
         throw new Error(`Instagram profile @${username} is private. You must provide a session cookie jar of an account following this profile.`);
       }
@@ -2947,6 +3240,30 @@ var FacebookExtractor = class {
   }
 };
 
+// src/lib/engines/core/plugin.ts
+var ExtractorPluginRegistry = class {
+  plugins = /* @__PURE__ */ new Map();
+  register(plugin) {
+    this.plugins.set(plugin.platform, plugin);
+  }
+  get(platform) {
+    return this.plugins.get(platform);
+  }
+  has(platform) {
+    return this.plugins.has(platform);
+  }
+  list() {
+    return Array.from(this.plugins.values());
+  }
+  findByUrl(url) {
+    return this.list().find((plugin) => plugin.canHandle(url));
+  }
+  clear() {
+    this.plugins.clear();
+  }
+};
+var defaultPluginRegistry = new ExtractorPluginRegistry();
+
 // src/lib/engines/extractors/index.ts
 function getExtractor(platform) {
   switch (platform) {
@@ -3750,7 +4067,7 @@ var PLATFORM_SLEEP = {
   facebook: "1.0-1.8"
 };
 function buildGalleryDlArgs(options) {
-  const { destDir, subDir, platform, cleanUrl, username, cookiePath, writeMetadata } = options;
+  const { destDir, subDir, platform, cleanUrl, username, cookiePath, cookiesFromBrowser, writeMetadata } = options;
   const args = [
     "-D",
     destDir,
@@ -3801,6 +4118,9 @@ function buildGalleryDlArgs(options) {
   if (cookiePath) {
     args.push("--cookies", cookiePath);
   }
+  if (cookiesFromBrowser && cookiesFromBrowser !== "none") {
+    args.push("--cookies-from-browser", cookiesFromBrowser);
+  }
   args.push("--", targetUrl);
   return args;
 }
@@ -3815,6 +4135,7 @@ async function runGalleryDl(options) {
     cleanUrl: profile.cleanUrl,
     username: profile.username,
     cookiePath,
+    cookiesFromBrowser: options.cookiesFromBrowser,
     writeMetadata: options.writeMetadata
   });
   let downloadedCount = 0;
@@ -3923,7 +4244,7 @@ import fs9 from "fs/promises";
 var YTDLP_ARCHIVE = "archive_yt-dlp.txt";
 var UA2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
 function buildYtDlpArgs(options) {
-  const { destDir, platform, cleanUrl, cookiePath, writeMetadata } = options;
+  const { destDir, platform, cleanUrl, cookiePath, cookiesFromBrowser, writeMetadata } = options;
   const args = [
     "-o",
     path9.join(destDir, "%(title).150B [%(id)s].%(ext)s"),
@@ -3957,6 +4278,9 @@ function buildYtDlpArgs(options) {
   if (cookiePath) {
     args.push("--cookies", cookiePath);
   }
+  if (cookiesFromBrowser && cookiesFromBrowser !== "none") {
+    args.push("--cookies-from-browser", cookiesFromBrowser);
+  }
   args.push("--", cleanUrl);
   return args;
 }
@@ -3969,6 +4293,7 @@ async function runYtDlp(options) {
     platform: profile.platform,
     cleanUrl: profile.cleanUrl,
     cookiePath,
+    cookiesFromBrowser: options.cookiesFromBrowser,
     writeMetadata: options.writeMetadata
   });
   let downloadedCount = 0;
@@ -4071,78 +4396,489 @@ async function runYtDlp(options) {
         skipped: skippedCount,
         error: err.message
       });
-    });
+    });
+  });
+}
+
+// src/lib/engines/core/task-manager.ts
+import path12 from "path";
+import os7 from "os";
+import fs12 from "fs/promises";
+import fsSync from "fs";
+
+// src/lib/engines/core/event-bus.ts
+import { EventEmitter } from "events";
+var EngineEventBus = class {
+  emitter = new EventEmitter();
+  constructor() {
+    this.emitter.setMaxListeners(50);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return () => this.emitter.off(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+  }
+  emit(event, payload) {
+    return this.emitter.emit(event, payload);
+  }
+  removeAllListeners(event) {
+    if (event !== void 0) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+  }
+};
+
+// src/lib/engines/storage/ledger.ts
+import fs10 from "fs";
+import path10 from "path";
+import os5 from "os";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var MediaLedger = class {
+  db = null;
+  inMemoryFallback = {
+    media: /* @__PURE__ */ new Map(),
+    checkpoints: /* @__PURE__ */ new Map()
+  };
+  isFallback = false;
+  resolvedPath;
+  constructor(dbPath, forceFallback = false) {
+    const resolvedPath = dbPath ?? (forceFallback ? ":memory:" : path10.join(os5.homedir(), ".open-nami", "nami.db"));
+    this.resolvedPath = resolvedPath;
+    if (forceFallback) {
+      this.isFallback = true;
+      this.loadFallbackDisk();
+      return;
+    }
+    try {
+      if (resolvedPath !== ":memory:") {
+        fs10.mkdirSync(path10.dirname(resolvedPath), { recursive: true });
+      }
+      const { DatabaseSync } = require2("node:sqlite");
+      this.db = new DatabaseSync(resolvedPath);
+      this.initTables();
+    } catch {
+      this.isFallback = true;
+      this.loadFallbackDisk();
+    }
+  }
+  loadFallbackDisk() {
+    if (this.resolvedPath === ":memory:") return;
+    try {
+      if (fs10.existsSync(this.resolvedPath)) {
+        const raw = fs10.readFileSync(this.resolvedPath, "utf8");
+        const data = JSON.parse(raw);
+        if (data && typeof data === "object") {
+          if (data.media && typeof data.media === "object") {
+            for (const [k, v] of Object.entries(data.media)) {
+              this.inMemoryFallback.media.set(k, v);
+            }
+          }
+          if (data.checkpoints && typeof data.checkpoints === "object") {
+            for (const [k, v] of Object.entries(data.checkpoints)) {
+              this.inMemoryFallback.checkpoints.set(k, v);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  flushFallbackDisk() {
+    if (this.resolvedPath === ":memory:") return;
+    try {
+      fs10.mkdirSync(path10.dirname(this.resolvedPath), { recursive: true });
+      const data = {
+        media: Object.fromEntries(this.inMemoryFallback.media),
+        checkpoints: Object.fromEntries(this.inMemoryFallback.checkpoints)
+      };
+      fs10.writeFileSync(this.resolvedPath, JSON.stringify(data, null, 2), "utf8");
+    } catch {
+    }
+  }
+  initTables() {
+    if (!this.db) return;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS media_ledger (
+        id TEXT PRIMARY KEY,
+        platform TEXT,
+        author TEXT,
+        url TEXT,
+        filename TEXT,
+        file_path TEXT,
+        downloaded_at TEXT
+      );
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        key TEXT PRIMARY KEY,
+        platform TEXT,
+        username TEXT,
+        target_dir TEXT,
+        cursors_json TEXT,
+        updated_at TEXT
+      );
+    `);
+  }
+  hasMedia(id) {
+    if (this.isFallback || !this.db) {
+      return this.inMemoryFallback.media.has(id);
+    }
+    const stmt = this.db.prepare("SELECT 1 FROM media_ledger WHERE id = ?");
+    const row = stmt.get(id);
+    return Boolean(row);
+  }
+  recordMedia(media) {
+    if (this.isFallback || !this.db) {
+      this.inMemoryFallback.media.set(media.id, media);
+      this.flushFallbackDisk();
+      return;
+    }
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO media_ledger (id, platform, author, url, filename, file_path, downloaded_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      media.id,
+      media.platform,
+      media.author,
+      media.url,
+      media.filename,
+      media.filePath,
+      media.downloadedAt
+    );
+  }
+  saveCheckpoint(checkpoint) {
+    const key = `${checkpoint.platform}:${checkpoint.username.toLowerCase()}`;
+    if (this.isFallback || !this.db) {
+      this.inMemoryFallback.checkpoints.set(key, checkpoint);
+      this.flushFallbackDisk();
+      return;
+    }
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO checkpoints (key, platform, username, target_dir, cursors_json, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      key,
+      checkpoint.platform,
+      checkpoint.username,
+      checkpoint.targetDir,
+      JSON.stringify(checkpoint.cursors),
+      checkpoint.updatedAt
+    );
+  }
+  getCheckpoint(platform, username) {
+    const key = `${platform}:${username.toLowerCase()}`;
+    if (this.isFallback || !this.db) {
+      return this.inMemoryFallback.checkpoints.get(key) || null;
+    }
+    const stmt = this.db.prepare(
+      "SELECT platform, username, target_dir, cursors_json, updated_at FROM checkpoints WHERE key = ?"
+    );
+    const row = stmt.get(key);
+    if (!row) return null;
+    return {
+      platform: row.platform,
+      username: row.username,
+      targetDir: row.target_dir,
+      cursors: JSON.parse(row.cursors_json || "{}"),
+      updatedAt: row.updated_at
+    };
+  }
+  clearCheckpoint(platform, username) {
+    const key = `${platform}:${username.toLowerCase()}`;
+    if (this.isFallback || !this.db) {
+      this.inMemoryFallback.checkpoints.delete(key);
+      this.flushFallbackDisk();
+      return;
+    }
+    const stmt = this.db.prepare("DELETE FROM checkpoints WHERE key = ?");
+    stmt.run(key);
+  }
+  close() {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch {
+      }
+      this.db = null;
+    }
+  }
+};
+
+// src/lib/known-folders.ts
+import { execFileSync } from "child_process";
+import fs11 from "fs";
+import os6 from "os";
+import path11 from "path";
+var KNOWN_FOLDER_DOWNLOADS_GUID = "{374DE290-123F-4565-9164-39C4925E467B}";
+var USER_SHELL_FOLDERS_REG_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
+function expandWindowsEnv(str, env = process.env, homeDir) {
+  return str.replace(/%([^%]+)%/g, (original, name) => {
+    if (homeDir && name.toLowerCase() === "userprofile") {
+      return homeDir;
+    }
+    const key = Object.keys(env).find((k) => k.toLowerCase() === name.toLowerCase());
+    if (key && env[key] !== void 0) {
+      return env[key];
+    }
+    return original;
+  });
+}
+function parseWindowsRegistryOutput(output, targetKey = KNOWN_FOLDER_DOWNLOADS_GUID) {
+  const lines = output.split(/\r?\n/);
+  const escaped = targetKey.replace(/[{}]/g, "\\$&");
+  const pattern = new RegExp(`^\\s*${escaped}\\s+REG_\\w+\\s+(.*)$`, "i");
+  for (const line of lines) {
+    const match = line.match(pattern);
+    if (match && match[1]) {
+      const rawPath = match[1].trim();
+      if (rawPath) return rawPath;
+    }
+  }
+  return void 0;
+}
+function parseLinuxUserDirsOutput(content) {
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^XDG_DOWNLOAD_DIR=["']?([^"']+)["']?$/);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  return void 0;
+}
+function isPathDriveAccessible(filePath, fsExists = fs11.existsSync, platform = process.platform) {
+  try {
+    if (fsExists(filePath)) {
+      return true;
+    }
+    if (platform === "win32") {
+      const match = filePath.match(/^([a-zA-Z]:[\\/])/i);
+      const driveRoot = match ? match[1] : path11.win32.parse(path11.win32.resolve(filePath)).root;
+      return fsExists(driveRoot);
+    }
+    const normalized = filePath.replace(/\\/g, "/");
+    const mountMatch = normalized.match(/^(\/(?:media(?:\/[^/]+)?|mnt|run\/media(?:\/[^/]+)?)\/[^/]+)/);
+    if (mountMatch) {
+      return fsExists(mountMatch[1]);
+    }
+    let curr = path11.posix.dirname(normalized);
+    while (curr && curr !== "/") {
+      if (fsExists(curr)) return true;
+      curr = path11.posix.dirname(curr);
+    }
+    return fsExists("/");
+  } catch {
+    return false;
+  }
+}
+function resolveWindowsDownloadsDir(options = {}) {
+  const homeDir = options.homeDir ?? os6.homedir();
+  const env = options.env ?? process.env;
+  const runQuery = options.regQueryFn ?? ((key, value) => {
+    try {
+      return execFileSync("reg", ["query", key, "/v", value], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+    } catch {
+      return "";
+    }
+  });
+  const checkAccessible = options.driveAccessibleFn ?? ((p) => isPathDriveAccessible(p, fs11.existsSync, "win32"));
+  let raw = parseWindowsRegistryOutput(
+    runQuery(USER_SHELL_FOLDERS_REG_KEY, KNOWN_FOLDER_DOWNLOADS_GUID),
+    KNOWN_FOLDER_DOWNLOADS_GUID
+  );
+  if (!raw) {
+    raw = parseWindowsRegistryOutput(runQuery(USER_SHELL_FOLDERS_REG_KEY, "Downloads"), "Downloads");
+  }
+  if (raw) {
+    const expanded = expandWindowsEnv(raw, env, homeDir);
+    if (checkAccessible(expanded)) {
+      return path11.win32.resolve(expanded);
+    }
+  }
+  return void 0;
+}
+function resolveLinuxDownloadsDir(options = {}) {
+  const homeDir = options.homeDir ?? os6.homedir();
+  const env = options.env ?? process.env;
+  const readFn = options.readFileFn ?? ((p) => {
+    try {
+      return fs11.readFileSync(p, "utf8");
+    } catch {
+      return "";
+    }
   });
+  const checkAccessible = options.driveAccessibleFn ?? ((p) => isPathDriveAccessible(p, fs11.existsSync, "linux"));
+  const configHome = env.XDG_CONFIG_HOME || path11.join(homeDir, ".config");
+  const userDirsFile = path11.join(configHome, "user-dirs.dirs");
+  const content = readFn(userDirsFile);
+  if (!content) return void 0;
+  const raw = parseLinuxUserDirsOutput(content);
+  if (!raw) return void 0;
+  const expanded = raw.replace(/\$HOME/g, homeDir).replace(/\$\{HOME\}/g, homeDir);
+  if (checkAccessible(expanded)) {
+    return path11.posix.resolve(expanded);
+  }
+  return void 0;
+}
+function resolvePlatformDownloadsDir(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const homeDir = options.homeDir ?? os6.homedir();
+  const defaultFallback = path11.join(homeDir, "Downloads");
+  if (platform === "win32") {
+    const resolved = resolveWindowsDownloadsDir(options);
+    if (resolved) return resolved;
+  } else if (platform === "linux") {
+    const resolved = resolveLinuxDownloadsDir(options);
+    if (resolved) return resolved;
+  }
+  return defaultFallback;
 }
 
-// src/lib/engines/dispatcher.ts
-var REFERER_MAP = {
-  tiktok: "https://www.tiktok.com/",
-  instagram: "https://www.instagram.com/",
-  x: "https://x.com/",
-  facebook: "https://www.facebook.com/"
-};
+// src/lib/engines/core/task-manager.ts
 function expandPath(dir) {
   if (dir.startsWith("~/") || dir.startsWith("~\\") || dir === "~") {
-    return path10.join(os5.homedir(), dir.slice(1));
+    return path12.join(os7.homedir(), dir.slice(1));
   }
   return dir;
 }
 function resolveDownloadBaseDir(customBaseDir) {
   if (customBaseDir && customBaseDir.trim()) {
-    return path10.resolve(expandPath(customBaseDir.trim()));
+    return path12.resolve(expandPath(customBaseDir.trim()));
   }
   const envDir = process.env.OPEN_NAMI_DIR || process.env.NAMI_DIR;
   if (envDir && envDir.trim()) {
-    return path10.resolve(expandPath(envDir.trim()));
+    return path12.resolve(expandPath(envDir.trim()));
   }
   const configDir = loadConfig().downloadDir;
   if (configDir && configDir.trim()) {
-    return path10.resolve(expandPath(configDir.trim()));
+    return path12.resolve(expandPath(configDir.trim()));
   }
   if (process.env.NAMI_BASE_DIR && process.env.NAMI_BASE_DIR.trim()) {
     const raw = process.env.NAMI_BASE_DIR.trim();
-    return path10.resolve(expandPath(raw.endsWith("downloads") ? raw : path10.join(raw, "downloads")));
+    return path12.resolve(expandPath(raw.endsWith("downloads") ? raw : path12.join(raw, "downloads")));
   }
-  return path10.join(resolvePlatformDownloadsDir(), "Open Nami");
+  return path12.join(resolvePlatformDownloadsDir(), "Open Nami");
 }
 function resolveDefaultDownloadDir(platform, username, baseDir) {
   const root = resolveDownloadBaseDir(baseDir);
-  return path10.join(root, platform, username);
+  return path12.join(root, platform, username);
 }
 async function cleanupEmptyCategoryDirs(targetDir) {
   const candidateDirs = ["All", "Stories", "Highlights", "Photos", "Videos"];
   for (const dirName of candidateDirs) {
-    const fullPath = path10.join(targetDir, dirName);
+    const fullPath = path12.join(targetDir, dirName);
     try {
       if (!fsSync.existsSync(fullPath)) continue;
-      const entries = await fs10.readdir(fullPath);
+      const entries = await fs12.readdir(fullPath);
       const nonArchiveEntries = entries.filter(
         (e) => e !== ".open-nami-archive.json" && e !== "archive.txt" && e !== "archive_yt-dlp.txt" && e !== "archive_gallery-dl.sqlite3"
       );
       if (nonArchiveEntries.length === 0) {
         for (const entry of entries) {
           try {
-            await fs10.unlink(path10.join(fullPath, entry));
+            await fs12.unlink(path12.join(fullPath, entry));
           } catch {
           }
         }
-        await fs10.rmdir(fullPath).catch(() => {
+        await fs12.rmdir(fullPath).catch(() => {
         });
       }
     } catch {
     }
   }
 }
+var TaskManager = class {
+  events;
+  ledger;
+  plugins;
+  constructor(eventBus, ledger, plugins) {
+    this.events = eventBus || new EngineEventBus();
+    this.ledger = ledger || new MediaLedger();
+    this.plugins = plugins || defaultPluginRegistry;
+  }
+  async execute(options) {
+    const { profile, choice } = options;
+    const targetDir = options.outputDir || resolveDefaultDownloadDir(profile.platform, profile.username);
+    this.events.emit("job:start", { profile, choice, outputDir: targetDir });
+    let downloadedCount = 0;
+    let skippedCount = 0;
+    const errors = [];
+    if (options.runnerOverrides?.nativeRunner) {
+      const subDir = choice === "all" ? "All" : choice.charAt(0).toUpperCase() + choice.slice(1);
+      const runRes = await options.runnerOverrides.nativeRunner(subDir);
+      downloadedCount += runRes.downloaded;
+      skippedCount += runRes.skipped;
+      if (!runRes.success) errors.push(runRes.error || "Execution failed");
+    }
+    await cleanupEmptyCategoryDirs(targetDir);
+    const result = {
+      success: errors.length === 0,
+      downloadedCount,
+      skippedCount,
+      errors,
+      outputDir: targetDir
+    };
+    this.events.emit("job:complete", { result });
+    return result;
+  }
+};
+var defaultTaskManager = new TaskManager();
+
+// src/lib/engines/dispatcher.ts
+var REFERER_MAP = {
+  tiktok: "https://www.tiktok.com/",
+  instagram: "https://www.instagram.com/",
+  x: "https://x.com/",
+  facebook: "https://www.facebook.com/"
+};
 async function dispatchDownload(options) {
   const { profile, choice, onProgress } = options;
   const targetDir = options.outputDir || resolveDefaultDownloadDir(profile.platform, profile.username);
-  await fs10.mkdir(targetDir, { recursive: true });
+  await fs13.mkdir(targetDir, { recursive: true });
+  const rawBrowserPref = options.cookiesFromBrowser ?? loadConfig().cookiesFromBrowser ?? "auto";
+  const resolvedBrowserArg = resolveBrowserCookieArg(rawBrowserPref);
+  const cookiesFromBrowser = resolvedBrowserArg ?? void 0;
+  defaultTaskManager.events.emit("job:start", { profile, choice, outputDir: targetDir });
   const masterCookie = findCookieFile(profile.platform);
   const cookieCopy = masterCookie ? await createSafeCookieCopy(masterCookie) : null;
   let totalDownloaded = 0;
   let totalSkipped = 0;
   const errors = [];
+  const recordError = (err) => {
+    errors.push(err);
+    defaultTaskManager.events.emit("job:error", { error: err });
+  };
+  const handleProgress = (progress) => {
+    defaultTaskManager.events.emit("job:progress", progress);
+    if (progress.currentFile && progress.statusText?.startsWith("Saved:")) {
+      try {
+        defaultTaskManager.ledger.recordMedia({
+          id: `${profile.platform}:${profile.username}:${progress.currentFile}`,
+          platform: profile.platform,
+          author: profile.username,
+          url: profile.cleanUrl || "",
+          filename: progress.currentFile,
+          filePath: path13.join(targetDir, progress.currentFile),
+          downloadedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    onProgress?.(progress);
+  };
   try {
     const jobs = [];
     if (choice === "photos") {
@@ -4166,7 +4902,7 @@ async function dispatchDownload(options) {
     const savedCheckpoint = options.resume ? await loadCheckpoint(targetDir) : null;
     const currentCursors = savedCheckpoint?.cursors ? { ...savedCheckpoint.cursors } : {};
     const defaultRunNative = async (subDir) => {
-      const dest = subDir === "All" ? targetDir : path10.join(targetDir, subDir);
+      const dest = subDir === "All" ? targetDir : path13.join(targetDir, subDir);
       const remainingLimit = globalLimit !== void 0 ? Math.max(0, globalLimit - totalDownloaded) : void 0;
       if (remainingLimit === 0) {
         return { success: true, downloaded: 0, skipped: 0 };
@@ -4208,8 +4944,8 @@ async function dispatchDownload(options) {
           jobName: `${profile.username} ${subDir}`,
           destDir: dest,
           destDirMap: subDir === "All" ? {
-            photo: path10.join(targetDir, "Photos"),
-            video: path10.join(targetDir, "Videos")
+            photo: path13.join(targetDir, "Photos"),
+            video: path13.join(targetDir, "Videos")
           } : void 0,
           cookiePath: cookieCopy?.filePath,
           referer: REFERER_MAP[profile.platform],
@@ -4218,7 +4954,7 @@ async function dispatchDownload(options) {
           writeMetadata: options.writeMetadata,
           defaultPlatform: profile.platform,
           defaultAuthor: profile.username,
-          onProgress
+          onProgress: handleProgress
         });
         return {
           success: res.errors.length === 0,
@@ -4232,35 +4968,43 @@ async function dispatchDownload(options) {
           success: false,
           downloaded: 0,
           skipped: 0,
-          error: errMsg
+          error: errMsg || "Execution failed"
         };
       }
     };
     const runNative = options.runnerOverrides?.nativeRunner ?? defaultRunNative;
-    const runGdl = options.runnerOverrides?.gdlRunner ?? ((subDir) => runGalleryDl({
-      profile,
-      targetDir,
-      subDir,
-      cookiePath: cookieCopy?.filePath,
-      signal: options.signal,
-      writeMetadata: options.writeMetadata,
-      onProgress
-    }));
-    const runYt = options.runnerOverrides?.ytRunner ?? (() => runYtDlp({
-      profile,
-      targetDir,
-      cookiePath: cookieCopy?.filePath,
-      signal: options.signal,
-      writeMetadata: options.writeMetadata,
-      onProgress
-    }));
+    const runGdl = (subDir) => {
+      const runnerOpts = {
+        profile,
+        targetDir,
+        subDir,
+        cookiePath: cookieCopy?.filePath,
+        cookiesFromBrowser,
+        signal: options.signal,
+        writeMetadata: options.writeMetadata,
+        onProgress: handleProgress
+      };
+      return options.runnerOverrides?.gdlRunner ? options.runnerOverrides.gdlRunner(subDir, runnerOpts) : runGalleryDl(runnerOpts);
+    };
+    const runYt = () => {
+      const runnerOpts = {
+        profile,
+        targetDir,
+        cookiePath: cookieCopy?.filePath,
+        cookiesFromBrowser,
+        signal: options.signal,
+        writeMetadata: options.writeMetadata,
+        onProgress: handleProgress
+      };
+      return options.runnerOverrides?.ytRunner ? options.runnerOverrides.ytRunner(runnerOpts) : runYtDlp(runnerOpts);
+    };
     for (const job of jobs) {
       if (options.signal?.aborted) break;
       if (globalLimit !== void 0 && totalDownloaded >= globalLimit) break;
       if (job.type === "all") {
         let res = await runNative("All");
         if ((!res.success || res.downloaded === 0 && res.skipped === 0) && !options.signal?.aborted) {
-          onProgress?.({
+          handleProgress({
             job: "Photos",
             downloadedCount: totalDownloaded,
             skippedCount: totalSkipped,
@@ -4269,8 +5013,8 @@ async function dispatchDownload(options) {
           const gdlPhotos = await runGdl("Photos");
           totalDownloaded += gdlPhotos.downloaded;
           totalSkipped += gdlPhotos.skipped;
-          if (!gdlPhotos.success && gdlPhotos.error) errors.push(`[Photos] ${gdlPhotos.error}`);
-          onProgress?.({
+          if (!gdlPhotos.success) recordError(gdlPhotos.error ? `[Photos] ${gdlPhotos.error}` : "[Photos] Execution failed");
+          handleProgress({
             job: "Videos",
             downloadedCount: totalDownloaded,
             skippedCount: totalSkipped,
@@ -4280,9 +5024,9 @@ async function dispatchDownload(options) {
           if (ytVideos.downloaded > 0 || ytVideos.skipped > 0 || ytVideos.success) {
             totalDownloaded += ytVideos.downloaded;
             totalSkipped += ytVideos.skipped;
-            if (!ytVideos.success && ytVideos.error) errors.push(`[Videos] ${ytVideos.error}`);
+            if (!ytVideos.success) recordError(ytVideos.error ? `[Videos] ${ytVideos.error}` : "[Videos] Execution failed");
           } else if (!options.signal?.aborted) {
-            onProgress?.({
+            handleProgress({
               job: "Videos",
               downloadedCount: totalDownloaded,
               skippedCount: totalSkipped,
@@ -4291,19 +5035,19 @@ async function dispatchDownload(options) {
             const gdlVideos = await runGdl("Videos");
             totalDownloaded += gdlVideos.downloaded;
             totalSkipped += gdlVideos.skipped;
-            if (!gdlVideos.success && gdlVideos.error) errors.push(`[Videos] ${gdlVideos.error}`);
+            if (!gdlVideos.success) recordError(gdlVideos.error ? `[Videos] ${gdlVideos.error}` : "[Videos] Execution failed");
           }
         } else {
           totalDownloaded += res.downloaded;
           totalSkipped += res.skipped;
-          if (!res.success && res.error) errors.push(`[All] ${res.error}`);
+          if (!res.success) recordError(res.error ? `[All] ${res.error}` : "[All] Execution failed");
         }
       } else if (job.type === "photos" || job.type === "stories" || job.type === "highlights") {
         const subDir = job.type === "photos" ? "Photos" : job.type === "stories" ? "Stories" : "Highlights";
         let res = await runNative(subDir);
         const isAuthError = Boolean(res.error && (res.error.includes("cookie") || res.error.includes("authenticated session") || res.error.includes("Settings (^s)")));
         if (!isAuthError && (!res.success || res.downloaded === 0 && res.skipped === 0) && !options.signal?.aborted) {
-          onProgress?.({
+          handleProgress({
             job: subDir,
             downloadedCount: totalDownloaded,
             skippedCount: totalSkipped,
@@ -4316,14 +5060,14 @@ async function dispatchDownload(options) {
         }
         totalDownloaded += res.downloaded;
         totalSkipped += res.skipped;
-        if (!res.success && res.error) errors.push(`[${subDir}] ${res.error}`);
+        if (!res.success) recordError(res.error ? `[${subDir}] ${res.error}` : `[${subDir}] Execution failed`);
       } else if (job.type === "videos") {
         let res = await runNative("Videos");
         if (res.downloaded > 0 || res.skipped > 0) {
           totalDownloaded += res.downloaded;
           totalSkipped += res.skipped;
         } else if (!options.signal?.aborted) {
-          onProgress?.({
+          handleProgress({
             job: "Videos",
             downloadedCount: totalDownloaded,
             skippedCount: totalSkipped,
@@ -4333,9 +5077,9 @@ async function dispatchDownload(options) {
           if (fbRes.downloaded > 0 || fbRes.skipped > 0 || fbRes.success) {
             totalDownloaded += fbRes.downloaded;
             totalSkipped += fbRes.skipped;
-            if (!fbRes.success && fbRes.error) errors.push(`[Videos] ${fbRes.error}`);
+            if (!fbRes.success) recordError(fbRes.error ? `[Videos] ${fbRes.error}` : "[Videos] Execution failed");
           } else if (!options.signal?.aborted) {
-            onProgress?.({
+            handleProgress({
               job: "Videos",
               downloadedCount: totalDownloaded,
               skippedCount: totalSkipped,
@@ -4344,7 +5088,7 @@ async function dispatchDownload(options) {
             const gdlRes = await runGdl("Videos");
             totalDownloaded += gdlRes.downloaded;
             totalSkipped += gdlRes.skipped;
-            if (!gdlRes.success && gdlRes.error) errors.push(`[Videos] ${gdlRes.error}`);
+            if (!gdlRes.success) recordError(gdlRes.error ? `[Videos] ${gdlRes.error}` : "[Videos] Execution failed");
           }
         }
       }
@@ -4353,13 +5097,19 @@ async function dispatchDownload(options) {
     if (errors.length === 0 && !options.signal?.aborted) {
       await clearCheckpoint(targetDir);
     }
-    return {
+    const engineResult = {
       success: errors.length === 0 || totalDownloaded > 0,
       downloadedCount: totalDownloaded,
       skippedCount: totalSkipped,
       errors,
       outputDir: targetDir
     };
+    defaultTaskManager.events.emit("job:complete", { result: engineResult });
+    return engineResult;
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    defaultTaskManager.events.emit("job:error", { error: errMsg || "Execution failed" });
+    throw err;
   } finally {
     if (cookieCopy) {
       await cookieCopy.cleanup();
@@ -4559,7 +5309,7 @@ function ProbingView({
 
 // src/components/views/downloading-view.tsx
 import { useState as useState5, useEffect as useEffect5 } from "react";
-import os6 from "os";
+import os8 from "os";
 import { Box as Box9, Text as Text11 } from "ink";
 import Spinner from "ink-spinner";
 
@@ -4695,35 +5445,51 @@ function DownloadingView({
     activeBadges.length > 0 ? /* @__PURE__ */ jsx12(Text11, { color: theme.gray, dimColor: theme.dimSecondary, children: activeBadges.join(" \xB7 ") }) : null,
     outputDir ? /* @__PURE__ */ jsxs9(Text11, { color: theme.gray, dimColor: theme.dimSecondary, children: [
       "saving to ",
-      shortenPath(outputDir, os6.homedir(), 54)
+      shortenPath(outputDir, os8.homedir(), 54)
     ] }) : null
   ] });
 }
 
 // src/components/views/completion-view.tsx
-import os7 from "os";
+import os9 from "os";
 import { Box as Box10, Text as Text12 } from "ink";
-import { Fragment as Fragment2, jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
 var DONE_LABEL = "\u21B5 download another";
+var LEDGER_INDEXED_LABEL = "\u2713 indexed in media ledger";
+function shouldShowLedgerBadge(result, showLedgerBadge) {
+  return showLedgerBadge ?? result.downloadedCount > 0;
+}
+function formatCompletionSummary(result) {
+  const isZero = result.downloadedCount === 0 && result.skippedCount === 0;
+  const plural = result.downloadedCount === 1 ? "" : "s";
+  const skipText = result.skippedCount > 0 ? ` (${result.skippedCount} archived)` : "";
+  return {
+    isZero,
+    headerPrefix: isZero ? "\u2713 profile scanned " : "\u2713 profile downloaded! ",
+    headerSuffix: isZero ? ": 0 media items found" : "saved to:",
+    itemsText: isZero ? "no photos or videos available" : `${result.downloadedCount} media item${plural} downloaded${skipText}`
+  };
+}
+function LedgerBadge({ theme }) {
+  return /* @__PURE__ */ jsx13(Text12, { color: theme.gray, dimColor: theme.dimSecondary, children: LEDGER_INDEXED_LABEL });
+}
 function CompletionView({
   profile,
   result,
   theme,
-  gapComponent: Gap2
+  gapComponent: Gap2,
+  showLedgerBadge
 }) {
-  const isZero = result.downloadedCount === 0 && result.skippedCount === 0;
-  const plural = result.downloadedCount === 1 ? "" : "s";
-  const skipText = result.skippedCount > 0 ? ` (${result.skippedCount} archived)` : "";
+  const { headerPrefix, headerSuffix, itemsText } = formatCompletionSummary(result);
+  const displayLedger = shouldShowLedgerBadge(result, showLedgerBadge);
   return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", alignItems: "center", children: [
-    /* @__PURE__ */ jsx13(Text12, { children: isZero ? /* @__PURE__ */ jsxs10(Fragment2, { children: [
-      /* @__PURE__ */ jsx13(Text12, { bold: true, color: theme.primary, children: "\u2713 profile scanned " }),
-      /* @__PURE__ */ jsx13(Text12, { color: theme.primary, children: "\u2014 0 media items found" })
-    ] }) : /* @__PURE__ */ jsxs10(Fragment2, { children: [
-      /* @__PURE__ */ jsx13(Text12, { bold: true, color: theme.primary, children: "\u2713 profile downloaded! " }),
-      /* @__PURE__ */ jsx13(Text12, { color: theme.primary, children: "saved to:" })
-    ] }) }),
-    /* @__PURE__ */ jsx13(Text12, { color: theme.gray, dimColor: theme.dimSecondary, children: shortenPath(result.outputDir, os7.homedir(), 60) }),
-    /* @__PURE__ */ jsx13(Text12, { color: theme.gray, dimColor: theme.dimSecondary, children: isZero ? "no photos or videos available" : `${result.downloadedCount} media item${plural} downloaded${skipText}` }),
+    /* @__PURE__ */ jsxs10(Text12, { children: [
+      /* @__PURE__ */ jsx13(Text12, { bold: true, color: theme.primary, children: headerPrefix }),
+      /* @__PURE__ */ jsx13(Text12, { color: theme.primary, children: headerSuffix })
+    ] }),
+    /* @__PURE__ */ jsx13(Text12, { color: theme.gray, dimColor: theme.dimSecondary, children: shortenPath(result.outputDir, os9.homedir(), 60) }),
+    /* @__PURE__ */ jsx13(Text12, { color: theme.gray, dimColor: theme.dimSecondary, children: itemsText }),
+    displayLedger && /* @__PURE__ */ jsx13(LedgerBadge, { theme }),
     /* @__PURE__ */ jsx13(Box10, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text12, { color: theme.gray, dimColor: theme.dimSecondary, children: [
       /* @__PURE__ */ jsx13(Text12, { bold: true, color: theme.primary, children: "[o]" }),
       " reveal in folder"
@@ -4765,18 +5531,220 @@ function ErrorView({ message, hint, columns, theme }) {
 }
 
 // src/components/views/settings-view.tsx
-import { useState as useState6, useMemo as useMemo2, useCallback } from "react";
+import { useState as useState6, useMemo as useMemo2, useCallback, useEffect as useEffect6 } from "react";
 import { Box as Box12, Text as Text14, useInput as useInput2 } from "ink";
-import fs11 from "fs";
-import path11 from "path";
-import os8 from "os";
-import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+import fs15 from "fs";
+import path15 from "path";
+import os11 from "os";
+
+// src/lib/diagnostics/doctor.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import os10 from "os";
+import fs14 from "fs";
+import path14 from "path";
+var execFileAsync = promisify(execFile);
+async function defaultCheckBinary(bin) {
+  const versionFlag = bin === "ffmpeg" ? "-version" : "--version";
+  try {
+    await execFileAsync(bin, [versionFlag], { timeout: 3e3 });
+    return true;
+  } catch {
+    if (bin === "gallery-dl" || bin === "yt-dlp") {
+      try {
+        const resolved = resolveEngineCommand(bin);
+        await execFileAsync(resolved.command, [...resolved.baseArgs, versionFlag], { timeout: 3e3 });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+}
+async function runDoctor(options = {}) {
+  const check = options.binaryChecker ?? defaultCheckBinary;
+  const [gdl, ytdlp, ffmpeg] = await Promise.all([
+    check("gallery-dl"),
+    check("yt-dlp"),
+    check("ffmpeg")
+  ]);
+  const availableCookies = detectAvailableCookies(options.cookiesDir);
+  const cookieStatus = {
+    instagram: availableCookies.includes("instagram"),
+    tiktok: availableCookies.includes("tiktok"),
+    facebook: availableCookies.includes("facebook"),
+    x: availableCookies.includes("x")
+  };
+  let storageOk = false;
+  try {
+    const testDir = options.storageDir || path14.join(os10.homedir(), ".open-nami");
+    fs14.mkdirSync(testDir, { recursive: true });
+    const testFile = path14.join(testDir, `.doctor_test_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+    fs14.writeFileSync(testFile, "ok");
+    fs14.unlinkSync(testFile);
+    storageOk = true;
+  } catch {
+  }
+  return {
+    nodeVersion: process.version,
+    binaries: {
+      "gallery-dl": gdl,
+      "yt-dlp": ytdlp,
+      ffmpeg
+    },
+    cookies: cookieStatus,
+    storageOk
+  };
+}
+
+// src/components/views/settings-view.tsx
+import { Fragment as Fragment2, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
 function expandDir(dir) {
   if (dir.startsWith("~/") || dir.startsWith("~\\") || dir === "~") {
-    return path11.join(os8.homedir(), dir.slice(1));
+    return path15.join(os11.homedir(), dir.slice(1));
   }
   return dir;
 }
+function resolveBrowserOptions(detected) {
+  const available = detected.filter((b) => b.available !== false);
+  return ["auto", "none", ...available.map((b) => b.id)];
+}
+function formatBrowserFeedback(cookiesFromBrowser, detectedBrowsers = [], defaultBrowser) {
+  if (cookiesFromBrowser === "auto") {
+    if (defaultBrowser) {
+      return `system default: ${defaultBrowser.name} (auto-extract session cookies)`;
+    }
+    return "system default: none detected (falls back to cookie files)";
+  }
+  if (!cookiesFromBrowser || cookiesFromBrowser === "none") {
+    return "manual cookie files only";
+  }
+  const found = detectedBrowsers.find((b) => b.id === cookiesFromBrowser);
+  const browserName = found ? found.name : cookiesFromBrowser;
+  return `live session cookies from ${browserName}`;
+}
+function cycleBrowserOption(current, options, forward = true) {
+  if (options.length === 0) return "auto";
+  const idx = options.indexOf(current);
+  const currentIndex = idx === -1 ? 0 : idx;
+  const nextIdx = forward ? (currentIndex + 1) % options.length : (currentIndex - 1 + options.length) % options.length;
+  return options[nextIdx];
+}
+function formatDoctorStorage(storageOk) {
+  return {
+    ok: storageOk,
+    text: storageOk ? "\u2713 SQLite ready" : "\u2717 SQLite unavailable"
+  };
+}
+function formatDoctorCookies(cookies) {
+  const platforms = Object.entries(cookies).filter(([_, ok]) => ok).map(([name]) => name);
+  const count = platforms.length;
+  const text = count > 0 ? `\u2713 ${count} (${platforms.join(", ")})` : "none detected";
+  return { count, platforms, text };
+}
+function DoctorCard({ boxWidth, theme, report }) {
+  const cookieSummary = report ? formatDoctorCookies(report.cookies) : { count: 0, platforms: [], text: "" };
+  const storageSummary = report ? formatDoctorStorage(report.storageOk) : { ok: false, text: "" };
+  return /* @__PURE__ */ jsxs12(
+    Box12,
+    {
+      width: boxWidth,
+      borderStyle: "round",
+      borderColor: theme.gray,
+      borderDimColor: theme.dimSecondary,
+      paddingX: 2,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs12(Box12, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx15(Text14, { color: theme.primary, bold: true, children: "System Diagnostics" }),
+          /* @__PURE__ */ jsx15(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: report ? report.nodeVersion : "checking\u2026" })
+        ] }),
+        report ? /* @__PURE__ */ jsxs12(Fragment2, { children: [
+          /* @__PURE__ */ jsxs12(Box12, { marginTop: 0, children: [
+            /* @__PURE__ */ jsxs12(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: [
+              "Engines:",
+              " "
+            ] }),
+            /* @__PURE__ */ jsxs12(
+              Text14,
+              {
+                color: report.binaries["gallery-dl"] ? "green" : "red",
+                dimColor: !report.binaries["gallery-dl"] && theme.dimSecondary,
+                children: [
+                  report.binaries["gallery-dl"] ? "\u2713" : "\u2717",
+                  " gallery-dl"
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs12(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: [
+              " ",
+              "\xB7",
+              " "
+            ] }),
+            /* @__PURE__ */ jsxs12(
+              Text14,
+              {
+                color: report.binaries["yt-dlp"] ? "green" : "red",
+                dimColor: !report.binaries["yt-dlp"] && theme.dimSecondary,
+                children: [
+                  report.binaries["yt-dlp"] ? "\u2713" : "\u2717",
+                  " yt-dlp"
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs12(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: [
+              " ",
+              "\xB7",
+              " "
+            ] }),
+            /* @__PURE__ */ jsxs12(
+              Text14,
+              {
+                color: report.binaries.ffmpeg ? "green" : "red",
+                dimColor: !report.binaries.ffmpeg && theme.dimSecondary,
+                children: [
+                  report.binaries.ffmpeg ? "\u2713" : "\u2717",
+                  " ffmpeg"
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs12(Box12, { justifyContent: "space-between", marginTop: 0, children: [
+            /* @__PURE__ */ jsxs12(Box12, { children: [
+              /* @__PURE__ */ jsxs12(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: [
+                "Storage:",
+                " "
+              ] }),
+              /* @__PURE__ */ jsx15(
+                Text14,
+                {
+                  color: storageSummary.ok ? "green" : "red",
+                  dimColor: !storageSummary.ok && theme.dimSecondary,
+                  children: storageSummary.text
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs12(Box12, { children: [
+              /* @__PURE__ */ jsxs12(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: [
+                "Cookies:",
+                " "
+              ] }),
+              /* @__PURE__ */ jsx15(
+                Text14,
+                {
+                  color: cookieSummary.count > 0 ? theme.primary : theme.gray,
+                  dimColor: cookieSummary.count === 0 && theme.dimSecondary,
+                  children: cookieSummary.text
+                }
+              )
+            ] })
+          ] })
+        ] }) : /* @__PURE__ */ jsx15(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: "checking system engines and storage\u2026" })
+      ]
+    }
+  );
+}
 var LIMIT_OPTIONS = [void 0, 10, 25, 50, 100];
 function SettingsView({
   boxWidth,
@@ -4785,9 +5753,14 @@ function SettingsView({
   focusedField: controlledFocus,
   onFocusChange,
   onSave,
-  onCancel
+  onCancel,
+  doctorChecker,
+  initialReport,
+  browsers: browsersProp,
+  defaultBrowser: defaultBrowserProp,
+  initialConfig: initialConfigProp
 }) {
-  const initialConfig = useMemo2(() => loadConfig(), []);
+  const initialConfig = useMemo2(() => initialConfigProp ?? loadConfig(), [initialConfigProp]);
   const [internalFocus, setInternalFocus] = useState6("cookies");
   const focusedField = controlledFocus ?? internalFocus;
   const setField = useCallback(
@@ -4797,16 +5770,64 @@ function SettingsView({
     },
     [onFocusChange]
   );
+  const defaultBrowser = useMemo2(() => {
+    return defaultBrowserProp !== void 0 ? defaultBrowserProp : detectSystemDefaultBrowser();
+  }, [defaultBrowserProp]);
+  const detectedBrowsers = useMemo2(() => {
+    return browsersProp ?? listDetectedBrowsers();
+  }, [browsersProp]);
+  const browserOptions = useMemo2(() => {
+    return resolveBrowserOptions(detectedBrowsers);
+  }, [detectedBrowsers]);
   const [cookiesDir, setCookiesDir] = useState6(initialConfig.cookiesDir ?? "");
+  const [cookiesFromBrowser, setCookiesFromBrowser] = useState6(
+    initialConfig.cookiesFromBrowser ?? "auto"
+  );
   const [downloadDir, setDownloadDir] = useState6(initialConfig.downloadDir ?? "");
   const [writeMetadata, setWriteMetadata] = useState6(Boolean(initialConfig.writeMetadata));
   const [defaultLimit, setDefaultLimit] = useState6(initialConfig.defaultLimit);
   const [saved, setSaved] = useState6(false);
+  const [doctorReport, setDoctorReport] = useState6(initialReport ?? null);
+  useEffect6(() => {
+    let cancelled = false;
+    const fetchReport = async () => {
+      try {
+        const options = {
+          cookiesDir: cookiesDir.trim() ? expandDir(cookiesDir.trim()) : void 0
+        };
+        let report;
+        if (doctorChecker) {
+          const res = await doctorChecker(options);
+          if (res && typeof res === "object" && "binaries" in res) {
+            report = res;
+          } else {
+            report = await runDoctor({
+              ...options,
+              binaryChecker: doctorChecker
+            });
+          }
+        } else {
+          report = await runDoctor(options);
+        }
+        if (!cancelled) {
+          setDoctorReport(report);
+        }
+      } catch {
+      }
+    };
+    if (initialReport === void 0 || doctorChecker !== void 0) {
+      fetchReport();
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, [cookiesDir, doctorChecker, initialReport]);
   const handleSave = useCallback(() => {
     const existing = loadConfig();
     const nextConfig = {
       ...existing,
       cookiesDir: cookiesDir.trim() ? cookiesDir.trim() : void 0,
+      cookiesFromBrowser,
       downloadDir: downloadDir.trim() ? downloadDir.trim() : void 0,
       writeMetadata,
       defaultLimit
@@ -4814,7 +5835,10 @@ function SettingsView({
     saveConfig(nextConfig);
     setSaved(true);
     onSave();
-  }, [cookiesDir, downloadDir, writeMetadata, defaultLimit, onSave]);
+  }, [cookiesDir, cookiesFromBrowser, downloadDir, writeMetadata, defaultLimit, onSave]);
+  const browserFeedback = useMemo2(() => {
+    return formatBrowserFeedback(cookiesFromBrowser, detectedBrowsers, defaultBrowser);
+  }, [cookiesFromBrowser, detectedBrowsers, defaultBrowser]);
   const cookieFeedback = useMemo2(() => {
     const dir = cookiesDir.trim();
     if (!dir) {
@@ -4825,7 +5849,7 @@ function SettingsView({
       };
     }
     const expanded = expandDir(dir);
-    if (!fs11.existsSync(expanded)) {
+    if (!fs15.existsSync(expanded)) {
       return {
         ok: false,
         text: "directory does not exist yet"
@@ -4848,14 +5872,20 @@ function SettingsView({
     if (!dir) {
       return "default: platform Downloads / Open Nami";
     }
-    return `target: ${path11.resolve(expandDir(dir))}`;
+    return `target: ${path15.resolve(expandDir(dir))}`;
   }, [downloadDir]);
   const cycleFocus = useCallback((forward = true) => {
-    const fields = ["cookies", "download", "metadata", "limit"];
+    const fields = ["cookies", "browser", "download", "metadata", "limit"];
     const idx = fields.indexOf(focusedField);
     const nextIdx = forward ? (idx + 1) % fields.length : (idx - 1 + fields.length) % fields.length;
     setField(fields[nextIdx]);
   }, [focusedField, setField]);
+  const cycleBrowser = useCallback((forward = true) => {
+    setCookiesFromBrowser((prev) => {
+      const next = cycleBrowserOption(prev ?? "auto", browserOptions, forward);
+      return next;
+    });
+  }, [browserOptions]);
   const cycleLimit = useCallback(() => {
     setDefaultLimit((prev) => {
       const idx = LIMIT_OPTIONS.indexOf(prev);
@@ -4872,6 +5902,20 @@ function SettingsView({
       handleSave();
       return;
     }
+    if (focusedField === "browser") {
+      if (input === " " || key.return) {
+        cycleBrowser(true);
+        return;
+      }
+      if (key.tab || key.downArrow) {
+        cycleFocus(true);
+        return;
+      }
+      if (key.upArrow) {
+        cycleFocus(false);
+        return;
+      }
+    }
     if (focusedField === "metadata") {
       if (input === " " || key.return) {
         setWriteMetadata((prev) => !prev);
@@ -4912,7 +5956,7 @@ function SettingsView({
           {
             value: cookiesDir,
             onChange: setCookiesDir,
-            onSubmit: () => setField("download"),
+            onSubmit: () => setField("browser"),
             focus: focusedField === "cookies",
             onTab: () => cycleFocus(true),
             onArrowDown: () => cycleFocus(true),
@@ -4925,6 +5969,26 @@ function SettingsView({
     ),
     /* @__PURE__ */ jsx15(Text14, { color: cookieFeedback.ok ? theme.primary : theme.gray, dimColor: !cookieFeedback.ok && theme.dimSecondary, children: cookieFeedback.text }),
     /* @__PURE__ */ jsx15(Gap2, {}),
+    /* @__PURE__ */ jsxs12(
+      Box12,
+      {
+        width: boxWidth,
+        borderStyle: "round",
+        borderColor: focusedField === "browser" ? theme.primary : theme.gray,
+        borderDimColor: focusedField !== "browser",
+        paddingX: 2,
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsxs12(Text14, { color: focusedField === "browser" ? theme.primary : theme.gray, bold: focusedField === "browser", children: [
+            focusedField === "browser" ? "\u25CF " : "\u25CB ",
+            "Browser Cookie Bridge"
+          ] }),
+          /* @__PURE__ */ jsx15(Text14, { color: cookiesFromBrowser && cookiesFromBrowser !== "none" ? theme.primary : theme.gray, bold: true, children: `[${(cookiesFromBrowser ?? "auto").toUpperCase()}]` })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx15(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: browserFeedback }),
+    /* @__PURE__ */ jsx15(Gap2, {}),
     /* @__PURE__ */ jsx15(
       FramedInput,
       {
@@ -4986,12 +6050,14 @@ function SettingsView({
       }
     ),
     /* @__PURE__ */ jsx15(Gap2, {}),
+    /* @__PURE__ */ jsx15(DoctorCard, { boxWidth, theme, report: doctorReport }),
+    /* @__PURE__ */ jsx15(Gap2, {}),
     /* @__PURE__ */ jsx15(Text14, { color: theme.gray, dimColor: theme.dimSecondary, children: saved ? "\u2713 preferences saved to ~/.open-nami/config.json" : "tab / \u2191\u2193 switch field \xB7 space toggle/cycle \xB7 ^s / \u21B5 save \xB7 esc back" })
   ] });
 }
 
 // src/components/views/watcher-view.tsx
-import { useState as useState7, useEffect as useEffect6, useRef as useRef3, useCallback as useCallback2 } from "react";
+import { useState as useState7, useEffect as useEffect7, useRef as useRef3, useCallback as useCallback2 } from "react";
 import { Box as Box13, Text as Text15, useInput as useInput3 } from "ink";
 import Spinner2 from "ink-spinner";
 
@@ -5278,9 +6344,9 @@ function startClipboardWatcher(options = {}) {
 }
 
 // src/lib/reveal.ts
-import fs12 from "fs";
+import fs16 from "fs";
 import { spawn as spawn4 } from "child_process";
-import path12 from "path";
+import path16 from "path";
 function buildOpenBrowserCommand(url, platform = process.platform) {
   try {
     const parsed = new URL(url.trim());
@@ -5307,12 +6373,12 @@ function openBrowser(url) {
   }
 }
 function getRevealCommand(targetPath, platform = process.platform, isDirectory) {
-  const pathModule = platform === "win32" ? path12.win32 : platform === "darwin" ? path12.posix : path12;
+  const pathModule = platform === "win32" ? path16.win32 : platform === "darwin" ? path16.posix : path16;
   const resolved = pathModule.resolve(targetPath);
   const isDir = isDirectory !== void 0 ? isDirectory : (() => {
     try {
-      if (fs12.existsSync(resolved)) {
-        return fs12.statSync(resolved).isDirectory();
+      if (fs16.existsSync(resolved)) {
+        return fs16.statSync(resolved).isDirectory();
       }
     } catch {
     }
@@ -5360,13 +6426,13 @@ function WatcherView({
   mediaChoiceRef.current = mediaChoice;
   const writeMetadataRef = useRef3(writeMetadata);
   writeMetadataRef.current = writeMetadata;
-  useEffect6(() => {
+  useEffect7(() => {
     const pulseTimer = setInterval(() => {
       setPulseTick((t) => t + 1);
     }, 120);
     return () => clearInterval(pulseTimer);
   }, []);
-  useEffect6(() => {
+  useEffect7(() => {
     const watcher = startClipboardWatcher({
       choice: mediaChoiceRef.current,
       getChoice: () => mediaChoiceRef.current,
@@ -5440,7 +6506,7 @@ function WatcherView({
     const target = outputDir || resolveDefaultDownloadDir("instagram", "watcher");
     revealInFileManager(target);
   }, [outputDir]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!onRegisterClickTargets) return;
     const targets = [
       { match: "Target:", padX: 1, action: () => {
@@ -5606,10 +6672,10 @@ function WatcherView({
 }
 
 // src/components/views/batch-view.tsx
-import { useState as useState8, useRef as useRef4, useCallback as useCallback3, useEffect as useEffect7 } from "react";
+import { useState as useState8, useRef as useRef4, useCallback as useCallback3, useEffect as useEffect8 } from "react";
 import { Box as Box14, Text as Text16, useInput as useInput4 } from "ink";
 import Spinner3 from "ink-spinner";
-import fs13 from "fs";
+import fs17 from "fs";
 
 // src/lib/batch.ts
 import fsPromises5 from "fs/promises";
@@ -5816,7 +6882,7 @@ function BatchView({
         setErrorMessage("Please enter a valid batch file path");
         return;
       }
-      if (!fs13.existsSync(trimmed)) {
+      if (!fs17.existsSync(trimmed)) {
         setErrorMessage(`File not found: ${trimmed}`);
         return;
       }
@@ -6148,7 +7214,7 @@ function BatchView({
       }
     }
   }, { isActive: Boolean(process.stdin.isTTY) });
-  useEffect7(() => {
+  useEffect8(() => {
     if (!onRegisterClickTargets) return;
     const targets = [];
     if (phase === "input") {
@@ -6649,6 +7715,80 @@ function frameRowSpan(row) {
   return [first + 1, line.trimEnd().length];
 }
 
+// src/lib/engines/core/use-engine-events.ts
+import { useState as useState9, useEffect as useEffect9 } from "react";
+var INITIAL_ENGINE_EVENT_STATE = {
+  isDownloading: false,
+  activeJob: void 0,
+  progress: void 0,
+  lastError: void 0,
+  lastResult: void 0
+};
+function subscribeToEngineEvents(bus, onChange) {
+  let state = { ...INITIAL_ENGINE_EVENT_STATE };
+  const onJobStart = (payload) => {
+    state = {
+      ...state,
+      isDownloading: true,
+      activeJob: payload,
+      progress: void 0,
+      lastError: void 0,
+      lastResult: void 0
+    };
+    onChange(state);
+  };
+  const onJobProgress = (payload) => {
+    state = {
+      ...state,
+      isDownloading: true,
+      progress: payload
+    };
+    onChange(state);
+  };
+  const onJobComplete = (payload) => {
+    state = {
+      ...state,
+      isDownloading: false,
+      lastResult: payload.result
+    };
+    onChange(state);
+  };
+  const onJobError = (payload) => {
+    state = {
+      ...state,
+      isDownloading: false,
+      lastError: payload.error
+    };
+    onChange(state);
+  };
+  const unsubStart = bus.on("job:start", onJobStart);
+  const unsubProgress = bus.on("job:progress", onJobProgress);
+  const unsubComplete = bus.on("job:complete", onJobComplete);
+  const unsubError = bus.on("job:error", onJobError);
+  return () => {
+    if (typeof bus.off === "function") {
+      bus.off("job:start", onJobStart);
+      bus.off("job:progress", onJobProgress);
+      bus.off("job:complete", onJobComplete);
+      bus.off("job:error", onJobError);
+    }
+    unsubStart?.();
+    unsubProgress?.();
+    unsubComplete?.();
+    unsubError?.();
+  };
+}
+function useEngineEvents(customBus) {
+  const bus = customBus || defaultTaskManager.events;
+  const [state, setState] = useState9(() => ({
+    ...INITIAL_ENGINE_EVENT_STATE
+  }));
+  useEffect9(() => {
+    return subscribeToEngineEvents(bus, setState);
+  }, [bus]);
+  return state;
+}
+
 // src/app.tsx
 import { Fragment as Fragment4, jsx as jsx18, jsxs as jsxs15 } from "react/jsx-runtime";
 var TAGLINE = "grab any profile. paste. download. done.";
@@ -6728,7 +7868,7 @@ function App({
   writeMetadata,
   version = "1.0.0"
 }) {
-  const [themeMode, setThemeMode] = useState9(initialThemeMode);
+  const [themeMode, setThemeMode] = useState10(initialThemeMode);
   const cycleTheme = useCallback4(() => {
     setThemeMode(nextThemeMode);
   }, []);
@@ -6763,18 +7903,19 @@ function InnerApp({
   const theme = useTheme();
   const { exit } = useApp();
   const { stdout } = useStdout3();
+  const engineEvents = useEngineEvents();
   const config = useMemo3(() => loadConfig(), []);
   const effectiveLimit = limit ?? config.defaultLimit;
   const effectiveWriteMetadata = writeMetadata ?? Boolean(config.writeMetadata);
-  const [urlInput, setUrlInput] = useState9(initialInput ?? "");
-  const [clipboardUrl, setClipboardUrl] = useState9(void 0);
-  const [settingsFocus, setSettingsFocus] = useState9("cookies");
-  const [batchClickTargets, setBatchClickTargets] = useState9([]);
-  const [watcherClickTargets, setWatcherClickTargets] = useState9([]);
+  const [urlInput, setUrlInput] = useState10(initialInput ?? "");
+  const [clipboardUrl, setClipboardUrl] = useState10(void 0);
+  const [settingsFocus, setSettingsFocus] = useState10("cookies");
+  const [batchClickTargets, setBatchClickTargets] = useState10([]);
+  const [watcherClickTargets, setWatcherClickTargets] = useState10([]);
   const columns = stdout?.columns && stdout.columns > 0 ? stdout.columns : 80;
   const boxWidth = Math.max(14, Math.min(64, columns - 6));
   const contentWidth = Math.max(10, Math.min(columns - 4, 78));
-  const [phase, setPhase] = useState9(() => {
+  const [phase, setPhase] = useState10(() => {
     if (initialInput) {
       const parsed = parseProfileInput(initialInput);
       if (parsed.platform !== "unknown" && parsed.cleanUrl) {
@@ -6786,7 +7927,7 @@ function InnerApp({
     }
     return { name: "input" };
   });
-  useEffect8(() => {
+  useEffect10(() => {
     try {
       const clip = readClipboard();
       if (clip && (clip.startsWith("http://") || clip.startsWith("https://") || clip.startsWith("@"))) {
@@ -6799,7 +7940,7 @@ function InnerApp({
   const clipboardAccepted = Boolean(clipboardUrl) && urlInput === clipboardUrl;
   const abortControllerRef = useRef5(null);
   const probingTimeoutRef = useRef5(null);
-  useEffect8(() => {
+  useEffect10(() => {
     return () => {
       abortControllerRef.current?.abort();
       if (probingTimeoutRef.current) {
@@ -7159,7 +8300,7 @@ function InnerApp({
       {
         profile: phase.profile,
         choice: phase.choice,
-        progress: phase.progress,
+        progress: engineEvents.progress ?? phase.progress,
         outputDir: resolveDefaultDownloadDir(phase.profile.platform, phase.profile.username, outputDir),
         writeMetadata: effectiveWriteMetadata,
         limit: effectiveLimit,
@@ -7439,7 +8580,7 @@ import { jsx as jsx19 } from "react/jsx-runtime";
 var resolveVersion = () => {
   try {
     if (typeof import.meta !== "undefined" && import.meta?.url) {
-      return createRequire(import.meta.url)("../package.json").version;
+      return createRequire2(import.meta.url)("../package.json").version;
     }
   } catch {
   }
@@ -7463,6 +8604,7 @@ var HELP = `
   Options:
     -h, --help           Show this help message
     -v, --version        Show version
+    --doctor             Run environment & dependency diagnostics
     -o, --output         Set custom output directory
     -w, --watch          Watch clipboard for profile links and auto-download
     -b, --batch <file>   Download multiple profiles listed in a text file (one URL/user per line)
@@ -7509,6 +8651,24 @@ async function main() {
     console.log(`open-nami v${VERSION}`);
     process.exit(0);
   }
+  if (args.includes("--doctor")) {
+    const report = await runDoctor();
+    console.log(`
+  \x1B[36mOpen Nami Doctor\x1B[0m (v${VERSION})
+`);
+    console.log(`  \x1B[1mRuntime:\x1B[0m Node.js ${report.nodeVersion}`);
+    console.log(`  \x1B[1mStorage:\x1B[0m ${report.storageOk ? "\x1B[32m\u2713 Ready\x1B[0m" : "\x1B[31m\u2717 Inaccessible\x1B[0m"}`);
+    console.log(`  \x1B[1mEngines:\x1B[0m`);
+    for (const [bin, ok] of Object.entries(report.binaries)) {
+      console.log(`    ${ok ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m"} ${bin}`);
+    }
+    console.log(`  \x1B[1mCookies:\x1B[0m`);
+    for (const [platform, ok] of Object.entries(report.cookies)) {
+      console.log(`    ${ok ? "\x1B[32m\u2713\x1B[0m" : "\x1B[90m\u25CB\x1B[0m"} ${platform}`);
+    }
+    console.log();
+    process.exit(0);
+  }
   const completionIdx = args.findIndex((arg) => arg === "--completion" || arg.startsWith("--completion="));
   if (completionIdx !== -1) {
     const arg = args[completionIdx];