nekostream 2026.4.4 → 2026.11.1

package/desktop-main.js

@@ -0,0 +1,530 @@
+/**
+ * NekoStream Desktop Application Main Process (Electron)
+ * Bridges the Material 3 Web interface with native Windows desktop capabilities.
+ */
+
+globalThis.__NEKO_DESKTOP__ = true
+process.env.NEKO_DESKTOP = '1'
+
+const { app, BrowserWindow, session, ipcMain, shell, webFrameMain } = require('electron')
+const path = require('path')
+const {
+  AD_PROBE_HOSTS,
+  isIntrusiveAdHost,
+  hostnameOf,
+  hostMatches,
+  isProviderHost,
+  isStreamHost,
+  isPlaybackHost,
+} = require('./dist/player-policy')
+const { getResolvedBaseUrl } = require('./dist/scrapers/domain-resolver')
+
+// Disable Blink automation features for smoother provider playback
+app.commandLine.appendSwitch('disable-blink-features', 'AutomationControlled')
+app.commandLine.appendSwitch('enable-features', 'VaapiVideoDecoder')
+
+// Single instance lock
+const gotTheLock = app.requestSingleInstanceLock()
+if (!gotTheLock) {
+  app.quit()
+  process.exit(0)
+}
+
+let mainWindow = null
+let serverInstance = null
+
+function getIconPath() {
+  const iconExt = process.platform === 'win32' ? 'icon.ico' : 'icon.png'
+  const iconPath = path.join(__dirname, 'assets', iconExt)
+  return iconPath
+}
+
+async function startBackendServer() {
+  try {
+    const { ensureDataDir } = require('./dist/storage')
+    const { resolveProviderDomains } = require('./dist/cli/domain-startup')
+    const { initDiscord } = require('./dist/discord')
+    const { startWebServer, printWebServerBanner } = require('./dist/cli/web-server')
+
+    ensureDataDir()
+    await resolveProviderDomains().catch((err) => {
+      console.warn('[Desktop Startup] Warning resolving domains:', err.message)
+    })
+    await initDiscord().catch(() => {})
+
+    // Bind on 0.0.0.0 so other LAN devices can connect and test
+    const instance = await startWebServer(3000, '0.0.0.0')
+    if (typeof printWebServerBanner === 'function') {
+      printWebServerBanner({ mode: 'desktop', port: instance.port })
+    }
+    return instance
+  } catch (err) {
+    console.error('[Desktop Startup] Failed to start internal web server:', err)
+    throw err
+  }
+}
+
+function setupSessionSecurity() {
+  const sess = session.defaultSession
+
+  // Network-level ad-blocking (like browser extensions)
+  sess.webRequest.onBeforeRequest({ urls: ['*://*/*'] }, (details, callback) => {
+    const hostname = hostnameOf(details.url)
+    const lowerUrl = details.url.toLowerCase()
+
+    // 1. Unconditional block for intrusive / gambling / popup ad networks
+    const isIntrusiveAd =
+      isIntrusiveAdHost(hostname) ||
+      (lowerUrl.includes('banner') &&
+        (lowerUrl.includes('casino') ||
+          lowerUrl.includes('tai-xiu') ||
+          lowerUrl.includes('keo-nha-cai')))
+
+    if (isIntrusiveAd) {
+      return callback({ cancel: true })
+    }
+
+    // 2. Block ad tracking domains in players / iframes
+    if (details.url && details.url.includes('devtools-warning')) {
+      return callback({ cancel: true })
+    }
+
+    // Probes from local app or providers are allowed; other ad probes blocked
+    const fromLocal =
+      hostname === 'localhost' ||
+      hostname === '127.0.0.1' ||
+      isProviderHost(hostnameOf(details.referrer)) ||
+      isProviderHost(hostnameOf(details.initiator))
+
+    if (!fromLocal && hostMatches(hostname, AD_PROBE_HOSTS)) {
+      return callback({ cancel: true })
+    }
+
+    return callback({ cancel: false })
+  })
+
+  // Strip CSP and X-Frame-Options on playback hosts
+  sess.webRequest.onHeadersReceived({ urls: ['*://*/*'] }, (details, callback) => {
+    if (!isPlaybackHost(hostnameOf(details.url))) {
+      return callback({ cancel: false })
+    }
+    const responseHeaders = { ...details.responseHeaders }
+    for (const key of Object.keys(responseHeaders)) {
+      const lowerKey = key.toLowerCase()
+      if (
+        lowerKey === 'content-security-policy' ||
+        lowerKey === 'content-security-policy-report-only' ||
+        lowerKey === 'x-frame-options'
+      ) {
+        delete responseHeaders[key]
+      }
+    }
+    callback({ cancel: false, responseHeaders })
+  })
+
+  // Relax CORS and inject appropriate Referer for video streaming CDNs
+  sess.webRequest.onBeforeSendHeaders({ urls: ['*://*/*'] }, (details, callback) => {
+    const headers = { ...details.requestHeaders }
+    const url = details.url.toLowerCase()
+    let avsBase = 'https://animevietsub.news/'
+    try {
+      avsBase = getResolvedBaseUrl('animevietsub') || avsBase
+      if (!avsBase.endsWith('/')) avsBase += '/'
+    } catch {}
+
+    // Provider stream CDN referers
+    if (
+      url.includes('abyss') ||
+      url.includes('hydrax') ||
+      url.includes('iamcdn') ||
+      url.includes('short.ink')
+    ) {
+      headers['Referer'] = avsBase
+      headers['Origin'] = new URL(avsBase).origin
+    } else if (url.includes('anime47')) {
+      headers['Referer'] = 'https://anime47.com/'
+    }
+
+    callback({ requestHeaders: headers })
+  })
+
+  // Block permission requests except fullscreen and clipboard
+  sess.setPermissionRequestHandler((webContents, permission, callback) => {
+    if (permission === 'fullscreen' || permission.includes('clipboard')) {
+      return callback(true)
+    }
+    callback(false)
+  })
+}
+
+async function createMainWindow(appUrl) {
+  mainWindow = new BrowserWindow({
+    title: 'NekoStream',
+    width: 1360,
+    height: 860,
+    minWidth: 1024,
+    minHeight: 680,
+    center: true,
+    frame: true, // Native Windows Title Bar as requested
+    autoHideMenuBar: true, // Clean look without traditional Alt menu bar
+    backgroundColor: '#0f0b13', // Material 3 surface color (zero white flash)
+    icon: getIconPath(),
+    show: false,
+    webPreferences: {
+      preload: path.join(__dirname, 'desktop-preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false,
+      webSecurity: false, // Allows HLS playback across diverse provider CDNs without browser CORS blocks
+    },
+  })
+
+  mainWindow.once('ready-to-show', () => {
+    if (mainWindow) {
+      mainWindow.show()
+    }
+  })
+
+  // Deny all popup windows and ad tabs from players/iframes
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    if (url.startsWith('http://localhost') || url.startsWith('http://127.0.0.1')) {
+      return { action: 'allow' }
+    }
+    // Block popup windows from stream players
+    return { action: 'deny' }
+  })
+
+  // Prevent embedded iframes or external scripts from navigating the top-level main window
+  mainWindow.webContents.on('will-navigate', (event, targetUrl) => {
+    const isAllowed =
+      targetUrl.startsWith('http://localhost') ||
+      targetUrl.startsWith('http://127.0.0.1') ||
+      targetUrl.includes('.trycloudflare.com') ||
+      /^https?:\/\/(192\.168\.|10\.|172\.(1[6-9]|2\d|3[01])\.|100\.)/.test(targetUrl)
+
+    if (!isAllowed) {
+      event.preventDefault()
+      console.warn('[Security] Blocked unauthorized top-level window navigation to:', targetUrl)
+    }
+  })
+
+  // Frame script injector to neutralize anti-adblock detection & popup triggers in HDX / Abyss / Hydrax
+  const injectIntoFrame = (frame) => {
+    try {
+      if (!frame || (frame.isDestroyed && frame.isDestroyed())) return
+      // Never inject into the top-level main window
+      if (!frame.parent) return
+
+      const frameUrl = frame.url || ''
+      const host = hostnameOf(frameUrl)
+      // Only inject into stream hosts or any iframe under playback hosts
+      if (host && !isStreamHost(host) && !isPlaybackHost(host)) {
+        return
+      }
+
+      frame
+        .executeJavaScript(
+          `
+        (function() {
+          if (window.__neko_cleaner_active__) return;
+          window.__neko_cleaner_active__ = true;
+
+          // --- 0. Neutralize ServiceWorker in frames to prevent Mojo cross-origin crash (reason 123) ---
+          try {
+            if (window.navigator) {
+              Object.defineProperty(window.navigator, 'serviceWorker', {
+                get: function() {
+                  return {
+                    register: function() { return Promise.reject(new Error('ServiceWorker disabled')); },
+                    getRegistration: function() { return Promise.resolve(undefined); },
+                    getRegistrations: function() { return Promise.resolve([]); },
+                    addEventListener: function() {},
+                    removeEventListener: function() {},
+                    controller: null,
+                    ready: new Promise(function() {})
+                  };
+                },
+                configurable: true
+              });
+            }
+          } catch(e) {}
+
+          // --- 1. Neutralize window.open to prevent popup blockers from throwing on .focus() ---
+          // Anti-adblock scripts on Abyss/Hydrax catch .focus() TypeError on blocked windows to trigger
+          // "Due to certain reasons (AdBlock/Sandbox), ads are not being displayed..."
+          try {
+            window.open = function(url) {
+              return {
+                closed: false,
+                focus: function() {},
+                blur: function() {},
+                close: function() {},
+                postMessage: function() {},
+                location: { href: url || '' }
+              };
+            };
+          } catch(e) {}
+
+          // --- 2. Prevent anti-adblock document.write from wiping out the player ---
+          try {
+            const _origDocWrite = document.write.bind(document);
+            document.write = function(content) {
+              if (
+                typeof content === 'string' &&
+                (content.includes('AdBlock/Sandbox') ||
+                 content.includes('Due to certain reasons') ||
+                 content.includes('disable AdBlock') ||
+                 content.includes('removing the Sandbox'))
+              ) {
+                return;
+              }
+              return _origDocWrite(content);
+            };
+          } catch(e) {}
+
+          // --- 3. CSS block for ads ---
+          if (!document.getElementById('__neko_adblock__')) {
+            const style = document.createElement('style');
+            style.id = '__neko_adblock__';
+            style.textContent = [
+              'img[src*="in88"],img[src*="quayhu"],img[src*="nohu"],',
+              'img[src*="188bet"],img[src*="kubet"],img[src*="w88"],img[src*="fun88"],img[src*="sin88"],',
+              'div[style*="sin88"],div[style*="in88"],',
+              '[class*="art-ad"],[class*="artplayer-ad"],[class*="art-ads"],[class*="artplayer-ads"],',
+              '[class*="ads-container"],[class*="ad-container"],[class*="pause-ad"],[id*="pause-ad"],',
+              '[class*="ads-pause"],[id*="ads-pause"],[class*="overlay-ad"],[id*="overlay-ad"],',
+              '[class*="popup-ad"],[id*="popup-ad"],[class*="quangcao"],[id*="quangcao"],',
+              '[class*="qc-"],[id*="qc-"] { display:none!important }'
+            ].join('');
+            (document.head || document.documentElement).appendChild(style);
+          }
+
+          // --- 4. DOM cleaner & Abyss Overlay Bypass ---
+          const AD_TEXTS = ['Đóng quảng cáo', 'Đóng và xem tiếp', 'Quảng cáo'];
+          const AD_SRCS  = ['in88', 'quayhu', 'nohu', '188bet', 'kubet', 'w88', 'fun88', 'sin88'];
+
+          const clean = () => {
+            try {
+              // Bypass Abyss/Hydrax popup click-jacking by rewriting the overlay click event
+              const overlay = document.getElementById('overlay');
+              if (overlay) {
+                overlay.onclick = (e) => {
+                  if (e) {
+                    e.stopPropagation();
+                    e.preventDefault();
+                  }
+                  if (window.jwplayer && typeof window.jwplayer === 'function') {
+                    try {
+                      window.jwplayer().play();
+                    } catch(err) {}
+                  }
+                  overlay.remove();
+                };
+                overlay.ontouchend = overlay.onclick;
+
+                // Auto-remove overlay if player is active
+                if (document.querySelector('video') || (window.jwplayer && typeof window.jwplayer === 'function')) {
+                  try {
+                    window.jwplayer().play();
+                  } catch(e) {}
+                  overlay.remove();
+                }
+              }
+
+              if (!document.body) return;
+              document.querySelectorAll('div,section,article,button,a,span,img').forEach(el => {
+                const txt = (el.innerText || el.textContent || '').trim();
+                const src = (el.src || el.getAttribute('src') || el.getAttribute('href') || '').toLowerCase();
+                const isAdTxt = AD_TEXTS.some(t => txt === t || txt.startsWith(t));
+                const isAdSrc = AD_SRCS.some(k => src.includes(k));
+                if (!isAdTxt && !isAdSrc) return;
+
+                let node = el;
+                for (let i = 0; i < 10; i++) {
+                  const p = node.parentElement;
+                  if (!p || p === document.body || p === document.documentElement) break;
+                  if (p.querySelector('video') || p.querySelector('canvas')) break;
+
+                  const className = (p.className || '').toString().toLowerCase();
+                  const id = (p.id || '').toString().toLowerCase();
+                  const isAdContainer = className.includes('ad') || className.includes('qc') || className.includes('banner') || className.includes('popup') || className.includes('overlay') ||
+                                        id.includes('ad') || id.includes('qc') || id.includes('banner') || id.includes('popup') || id.includes('overlay');
+
+                  const cs = getComputedStyle(p);
+                  if (cs.position === 'fixed' || cs.position === 'absolute' || isAdContainer) {
+                    p.remove(); return;
+                  }
+                  node = p;
+                }
+                el.remove();
+              });
+            } catch(e) {}
+          };
+
+          clean();
+          setInterval(clean, 250);
+        })();
+      `
+        )
+        .catch(() => {})
+    } catch (err) {
+      console.error('[Desktop] Failed to inject frame:', err)
+    }
+  }
+
+  mainWindow.webContents.on('did-frame-finish-load', (e, isMainFrame, frameProcessId, frameRoutingId) => {
+    if (!isMainFrame) {
+      const frame = webFrameMain.fromId(frameProcessId, frameRoutingId)
+      if (frame) {
+        injectIntoFrame(frame)
+      }
+    }
+  })
+
+  mainWindow.webContents.on('frame-created', (e, details) => {
+    const frame = details.frame
+    injectIntoFrame(frame)
+    setTimeout(() => {
+      injectIntoFrame(frame)
+    }, 300)
+    setTimeout(() => {
+      injectIntoFrame(frame)
+    }, 1000)
+  })
+
+  // Recover gracefully if a subframe or renderer process encounters an unexpected termination
+  mainWindow.webContents.on('render-process-gone', (event, details) => {
+    console.error('[Desktop] Renderer process gone:', details)
+    if (details.reason !== 'clean-exit' && details.reason !== 'killed') {
+      console.warn('[Desktop] Attempting automatic window reload after unexpected crash...')
+      setTimeout(() => {
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.reload()
+        }
+      }, 500)
+    }
+  })
+
+  mainWindow.on('closed', () => {
+    mainWindow = null
+  })
+
+  await mainWindow.loadURL(appUrl)
+}
+
+// IPC Handlers
+ipcMain.on('window:minimize', () => {
+  if (mainWindow && !mainWindow.isDestroyed()) mainWindow.minimize()
+})
+
+ipcMain.on('window:maximize', () => {
+  if (mainWindow && !mainWindow.isDestroyed()) {
+    if (mainWindow.isMaximized()) mainWindow.unmaximize()
+    else mainWindow.maximize()
+  }
+})
+
+ipcMain.on('window:close', () => {
+  if (mainWindow && !mainWindow.isDestroyed()) mainWindow.close()
+})
+
+ipcMain.on('shell:openExternal', (event, url) => {
+  if (typeof url === 'string' && /^https?:\/\//i.test(url)) {
+    shell.openExternal(url)
+  }
+})
+
+ipcMain.on('window:navigate', (_event, targetUrl) => {
+  if (mainWindow && !mainWindow.isDestroyed() && typeof targetUrl === 'string') {
+    const isAllowed =
+      targetUrl.startsWith('http://localhost') ||
+      targetUrl.startsWith('http://127.0.0.1') ||
+      targetUrl.includes('.trycloudflare.com') ||
+      /^https?:\/\/(192\.168\.|10\.|172\.(1[6-9]|2\d|3[01])\.|100\.)/.test(targetUrl)
+
+    if (isAllowed) {
+      mainWindow.loadURL(targetUrl)
+    }
+  }
+})
+
+ipcMain.on('window:returnHome', () => {
+  if (mainWindow && !mainWindow.isDestroyed() && serverInstance?.url) {
+    mainWindow.loadURL(serverInstance.url)
+  }
+})
+
+// Protocol Registration
+if (process.defaultApp) {
+  if (process.argv.length >= 2) {
+    app.setAsDefaultProtocolClient('nekostream', process.execPath, [path.resolve(process.argv[1])])
+  }
+} else {
+  app.setAsDefaultProtocolClient('nekostream')
+}
+
+function handleDeepLink(link) {
+  if (!mainWindow || mainWindow.isDestroyed()) return
+  try {
+    if (link.startsWith('nekostream://')) {
+      const parsed = new URL(link)
+      const targetUrl = parsed.searchParams.get('url')
+      const code = parsed.searchParams.get('code')
+      if (targetUrl) {
+        mainWindow.loadURL(targetUrl)
+        return
+      }
+      if (code && serverInstance?.port) {
+        mainWindow.loadURL(`http://localhost:${serverInstance.port}/?party=${encodeURIComponent(code)}`)
+        return
+      }
+    } else if (link.includes('.trycloudflare.com') || link.includes('?party=')) {
+      mainWindow.loadURL(link)
+    }
+  } catch (err) {
+    console.warn('[Desktop] Error handling deep link:', err)
+  }
+}
+
+// App Lifecycle
+app.on('second-instance', (_event, commandLine) => {
+  if (mainWindow) {
+    if (mainWindow.isMinimized()) mainWindow.restore()
+    mainWindow.focus()
+
+    const deepLink = commandLine.find(
+      (arg) => typeof arg === 'string' && (arg.startsWith('nekostream://') || arg.includes('trycloudflare.com') || arg.includes('?party='))
+    )
+    if (deepLink) {
+      handleDeepLink(deepLink)
+    }
+  }
+})
+
+app.whenReady().then(async () => {
+  try {
+    setupSessionSecurity()
+    serverInstance = await startBackendServer()
+    await createMainWindow(serverInstance.url)
+  } catch (err) {
+    console.error('Fatal Desktop launch error:', err)
+    app.quit()
+  }
+})
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+app.on('before-quit', async () => {
+  try {
+    const { clearDiscordPresence } = require('./dist/discord')
+    clearDiscordPresence()
+  } catch {}
+  if (serverInstance && typeof serverInstance.close === 'function') {
+    await serverInstance.close().catch(() => {})
+  }
+})
+

package/desktop-preload.js

@@ -0,0 +1,14 @@
+const { contextBridge, ipcRenderer } = require('electron')
+
+contextBridge.exposeInMainWorld('desktopApi', {
+  isElectron: true,
+  platform: process.platform,
+  version: process.env.NEKOSTREAM_VERSION || '2026.4.5',
+  minimize: () => ipcRenderer.send('window:minimize'),
+  maximize: () => ipcRenderer.send('window:maximize'),
+  close: () => ipcRenderer.send('window:close'),
+  openExternal: (url) => ipcRenderer.send('shell:openExternal', url),
+  navigate: (url) => ipcRenderer.send('window:navigate', url),
+  returnHome: () => ipcRenderer.send('window:returnHome')
+})
+

package/dist/cli/application.js

@@ -8,10 +8,34 @@ const chalk_1 = __importDefault(require("chalk"));
 const discord_1 = require("../discord");
 const logger_1 = require("../logger");
 const storage_1 = require("../storage");
+const ui_1 = require("../ui");
+const theme_1 = require("./theme");
 const domain_startup_1 = require("./domain-startup");
 const home_menu_1 = require("./menus/home-menu");
 const update_check_1 = require("./update-check");
-const web_server_1 = require("./web-server");
+const player_1 = require("../player");
+function printHelp(version) {
+    const heading = (text) => chalk_1.default.hex(theme_1.palette.muted).bold(text);
+    const flag = (name) => chalk_1.default.hex(theme_1.palette.soft)(name);
+    console.log(`
+${chalk_1.default.hex(theme_1.palette.text).bold('nekostream')} ${chalk_1.default.hex(theme_1.palette.subtle)(`v${version}`)}
+${chalk_1.default.hex(theme_1.palette.muted)('stream anime from vietnamese providers, right in your terminal.')}
+
+${heading('USAGE')}
+  ${flag('$ nekostream [command|flags]')}
+
+${heading('FLAGS')}
+  ${flag('-v, --version')}        show version number and exit
+  ${flag('-h, --help')}           show this help message and exit
+  ${flag('--desktop, --app')}     launch native desktop player application (recommended)
+  ${flag('--web')}                launch desktop application (web redirected to desktop)
+
+${heading('EXAMPLES')}
+  ${flag('$ nekostream')}                     launch interactive terminal UI
+  ${flag('$ nekostream --desktop')}           launch native desktop application
+  ${flag('$ nekostream --version')}           print installed version
+`);
+}
 /**
  * Application entry point: bring up the runtime services, then hand control to
  * the home menu loop, which owns the interactive session until exit.
@@ -20,17 +44,38 @@ const web_server_1 = require("./web-server");
  * process when a newer version exists, so there is no point probing first.
  */
 async function runApplication() {
+    if (process.argv.includes('--version') || process.argv.includes('-v')) {
+        console.log(`nekostream v${(0, ui_1.getVersion)()}`);
+        return;
+    }
+    if (process.argv.includes('--help') || process.argv.includes('-h') || process.argv.includes('help')) {
+        printHelp((0, ui_1.getVersion)());
+        return;
+    }
+    if (process.argv.includes('--desktop') ||
+        process.argv.includes('desktop') ||
+        process.argv.includes('--app') ||
+        process.argv.includes('app')) {
+        console.log(`\n${chalk_1.default.hex(theme_1.palette.accent)('✶')} ${chalk_1.default.hex(theme_1.palette.soft)('desktop — đang khởi chạy ứng dụng native...')}`);
+        await (0, player_1.launchDesktopApp)();
+        return;
+    }
+    if (process.argv.includes('--web') || process.argv.includes('web')) {
+        console.log(`\n${chalk_1.default.hex(theme_1.palette.accent)('✶')} ${chalk_1.default.hex(theme_1.palette.soft)('NekoStream đã chuyển nền tảng sang Full Desktop app (tránh chặn iframe/CORS từ video providers).')}`);
+        console.log(`${chalk_1.default.hex(theme_1.palette.muted)('  Đang tự động chuyển hướng khởi chạy NekoStream Desktop...')}\n`);
+        await (0, player_1.launchDesktopApp)();
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        console.error(chalk_1.default.hex(theme_1.palette.yellow)('nekostream requires an interactive TTY terminal to run the interactive UI.'));
+        console.error(chalk_1.default.hex(theme_1.palette.subtle)("run 'nekostream --help' for available flags and options."));
+        process.exitCode = 2;
+        return;
+    }
     (0, storage_1.ensureDataDir)();
     await (0, update_check_1.checkUpdate)();
     await (0, domain_startup_1.resolveProviderDomains)();
     await (0, discord_1.initDiscord)();
     (0, logger_1.debugLog)('NekoStream CLI started');
-    if (process.argv.includes('--web') || process.argv.includes('web')) {
-        const instance = await (0, web_server_1.startWebServer)();
-        console.log(chalk_1.default.cyan(`\n[NekoStream Web] Giao diện Web đang chạy tại: ${chalk_1.default.bold.underline(instance.url)}`));
-        console.log(chalk_1.default.gray('Nhấn Ctrl+C để dừng server.\n'));
-        (0, web_server_1.openBrowser)(instance.url);
-        return new Promise(() => { });
-    }
     await (0, home_menu_1.showHomeMenu)();
 }

package/dist/cli/domain-startup.js

@@ -9,6 +9,7 @@ const ora_1 = __importDefault(require("ora"));
 const logger_1 = require("../logger");
 const domain_resolver_1 = require("../scrapers/domain-resolver");
 const feedback_1 = require("./feedback");
+const theme_1 = require("./theme");
 /**
  * The fast path — probing the domain already in use — normally answers well
  * inside this window, so no spinner is drawn at all and startup looks unchanged.
@@ -32,7 +33,7 @@ function summarize(outcomes) {
 function delayedSpinner(text) {
     let spinner;
     const timer = setTimeout(() => {
-        spinner = (0, ora_1.default)(text).start();
+        spinner = (0, ora_1.default)({ text, spinner: theme_1.spinnerStyle, color: 'yellow' }).start();
     }, SPINNER_DELAY_MS);
     return {
         stop: () => {
@@ -53,10 +54,10 @@ function delayedSpinner(text) {
  * simply mean the cached or seeded domain is used as-is.
  */
 async function resolveProviderDomains() {
-    const spinner = delayedSpinner('Đang dò domain provider...');
+    const spinner = delayedSpinner('đang dò domain provider...');
     let outcomes;
     try {
-        outcomes = await (0, domain_resolver_1.resolveAllDomains)();
+        outcomes = await (0, domain_resolver_1.resolveAllDomains)(undefined, { onlyStale: true });
     }
     finally {
         spinner.stop();
@@ -69,7 +70,7 @@ async function resolveProviderDomains() {
     // expected case and the whole point of the fast path.
     if (changed.length > 0) {
         for (const outcome of changed) {
-            console.log(chalk_1.default.cyan(`  Domain ${outcome.provider} đã đổi -> ${outcome.baseUrl}`));
+            console.log(`${chalk_1.default.hex(theme_1.palette.cyan)(`  domain ${outcome.provider} đã đổi`)} ${chalk_1.default.hex(theme_1.palette.subtle)('→')} ${chalk_1.default.hex(theme_1.palette.soft)(outcome.baseUrl)}`);
         }
         await (0, feedback_1.sleep)(feedback_1.CONFIRM_DELAY_MS);
         return;
@@ -79,7 +80,7 @@ async function resolveProviderDomains() {
     // cannot act on; with it, the line only follows visible work.
     if (failed.length > 0 && spinner.wasShown()) {
         const names = failed.map((o) => o.provider).join(', ');
-        console.log(chalk_1.default.yellow(`  Không dò được domain sống cho: ${names}. Dùng domain đã lưu.`));
+        console.log(chalk_1.default.hex(theme_1.palette.yellow)(`  không dò được domain sống cho: ${names}. dùng domain đã lưu.`));
         await (0, feedback_1.sleep)(feedback_1.CONFIRM_DELAY_MS);
     }
 }