nekostream 2026.2.2 → 2026.2.5

package/dist/index.js

@@ -215,9 +215,10 @@ async function showAnimeList(providerName, title, list) {
         (0, ui_1.printBanner)(`Provider: ${providerName.toUpperCase()}`, title.toUpperCase());
         flushStdin();
         const { animeId } = await (0, prompts_wrapper_1.default)({
-            type: 'select',
+            type: 'search',
             name: 'animeId',
             message: 'Chọn anime (Esc: quay lại)',
+            pageSize: 15,
             choices: list.map((anime, idx) => {
                 const desc = anime.status || anime.year?.toString() || '';
                 const cleanTitle = anime.title.replace(/\r?\n|\r/g, ' ').trim();
@@ -403,9 +404,10 @@ async function showUserDataList(title, items, providerName) {
             choices.push({ title: chalk_1.default.yellow('▲ Trang trước'), value: '__prev__' });
         choices.push({ title: chalk_1.default.gray('← Quay lại'), value: '__back__' });
         const { animeId } = await (0, prompts_wrapper_1.default)({
-            type: 'select',
+            type: 'search',
             name: 'animeId',
             message: 'Chọn anime để xem (Esc: quay lại)',
+            pageSize: PAGE_SIZE,
             choices
         });
         if (!animeId || animeId === '__back__')

package/dist/player.js

@@ -7,6 +7,7 @@ exports.launchPlayer = launchPlayer;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 function runWithTimeout(fn, ms) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -21,15 +22,50 @@ function runWithTimeout(fn, ms) {
         });
     });
 }
-async function repairElectron(basePath) {
-    const electronPkgPath = path_1.default.join(basePath, 'node_modules', 'electron', 'package.json');
+function electronExecutablePath(rootDir) {
+    if (process.platform === 'win32')
+        return path_1.default.join(rootDir, 'electron.exe');
+    if (process.platform === 'darwin')
+        return path_1.default.join(rootDir, 'Electron.app', 'Contents', 'MacOS', 'Electron');
+    return path_1.default.join(rootDir, 'electron');
+}
+function resolveElectronPackageDir(basePath) {
+    try {
+        return path_1.default.dirname(require.resolve('electron/package.json', { paths: [basePath, __dirname] }));
+    }
+    catch {
+        return path_1.default.join(basePath, 'node_modules', 'electron');
+    }
+}
+function resolveInstalledElectron(basePath) {
+    const electronBinary = require('electron');
+    if (typeof electronBinary === 'string' && fs_1.default.existsSync(electronBinary)) {
+        return electronBinary;
+    }
+    const electronPkgDir = resolveElectronPackageDir(basePath);
+    const directBinary = electronExecutablePath(path_1.default.join(electronPkgDir, 'dist'));
+    if (fs_1.default.existsSync(directBinary)) {
+        return directBinary;
+    }
+    throw new Error('Electron binary executable file not found');
+}
+function getElectronVersion(basePath) {
+    const electronPkgPath = path_1.default.join(resolveElectronPackageDir(basePath), 'package.json');
     if (!fs_1.default.existsSync(electronPkgPath)) {
         throw new Error('electron package.json not found');
     }
     const pkg = JSON.parse(fs_1.default.readFileSync(electronPkgPath, 'utf8'));
-    const version = pkg.version;
+    return pkg.version;
+}
+async function resolveCachedElectron(basePath) {
+    const version = getElectronVersion(basePath);
     const platform = process.platform;
     const arch = process.arch;
+    const cacheDir = path_1.default.join(os_1.default.homedir(), '.nekostream-cli', 'electron', version, `${platform}-${arch}`);
+    const cachedBinary = electronExecutablePath(cacheDir);
+    if (fs_1.default.existsSync(cachedBinary)) {
+        return cachedBinary;
+    }
     console.log(`[download] Downloading Electron v${version} for ${platform}-${arch}...`);
     const { downloadArtifact } = require('@electron/get');
     const zipPath = await downloadArtifact({
@@ -38,49 +74,44 @@ async function repairElectron(basePath) {
         platform,
         arch
     });
-    console.log('[extract] Extracting Electron zip to dist...');
-    const distDir = path_1.default.join(basePath, 'node_modules', 'electron', 'dist');
-    fs_1.default.mkdirSync(distDir, { recursive: true });
+    console.log('[extract] Extracting Electron zip to local cache...');
+    fs_1.default.mkdirSync(path_1.default.dirname(cacheDir), { recursive: true });
+    const tempDir = `${cacheDir}.tmp-${process.pid}`;
+    fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    fs_1.default.mkdirSync(tempDir, { recursive: true });
     try {
         // Try extract-zip with a 10s timeout to avoid deadlocking on Node v24+
         await runWithTimeout(async () => {
             const extract = require('extract-zip');
-            await extract(zipPath, { dir: distDir });
+            await extract(zipPath, { dir: tempDir });
         }, 10000);
         console.log('[ok] Extraction via extract-zip complete.');
     }
     catch (extractErr) {
         console.log('[warn] extract-zip timed out or failed. Falling back to native system extraction...');
         if (process.platform === 'win32') {
-            (0, child_process_1.execSync)(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${distDir}' -Force"`, { stdio: 'inherit' });
+            (0, child_process_1.execSync)(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${tempDir}' -Force"`, { stdio: 'inherit' });
         }
         else {
-            (0, child_process_1.execSync)(`unzip -o "${zipPath}" -d "${distDir}"`, { stdio: 'inherit' });
+            (0, child_process_1.execSync)(`unzip -o "${zipPath}" -d "${tempDir}"`, { stdio: 'inherit' });
         }
         console.log('[ok] Extraction via native fallback complete.');
     }
-    // Move types if present
-    const srcTypeDefPath = path_1.default.join(distDir, 'electron.d.ts');
-    const targetTypeDefPath = path_1.default.join(basePath, 'node_modules', 'electron', 'electron.d.ts');
-    if (fs_1.default.existsSync(srcTypeDefPath)) {
+    if (!fs_1.default.existsSync(electronExecutablePath(tempDir))) {
+        fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        throw new Error('Electron binary missing after cache extraction');
+    }
+    fs_1.default.rmSync(cacheDir, { recursive: true, force: true });
+    fs_1.default.renameSync(tempDir, cacheDir);
+    if (process.platform !== 'win32') {
         try {
-            fs_1.default.renameSync(srcTypeDefPath, targetTypeDefPath);
+            fs_1.default.chmodSync(cachedBinary, 0o755);
         }
-        catch (e) {
-            // Ignore
+        catch {
+            // Ignore chmod failures on filesystems that do not support it.
         }
     }
-    // Write path.txt reference
-    const platformPath = process.platform === 'win32' ? 'electron.exe' : (process.platform === 'darwin' ? 'Electron.app/Contents/MacOS/Electron' : 'electron');
-    const pathTxtPath = path_1.default.join(basePath, 'node_modules', 'electron', 'path.txt');
-    fs_1.default.writeFileSync(pathTxtPath, platformPath);
-    // Clear require cache for electron module to force reload
-    delete require.cache[require.resolve('electron')];
-    const electronBinary = require('electron');
-    if (!fs_1.default.existsSync(electronBinary)) {
-        throw new Error('Electron binary still missing after fallback repair');
-    }
-    return electronBinary;
+    return cachedBinary;
 }
 async function launchPlayer(streamInfo) {
     // If compiled, __dirname is .../dist. If dev, __dirname is root.
@@ -93,19 +124,16 @@ async function launchPlayer(streamInfo) {
     };
     let electronBinary;
     try {
-        electronBinary = require('electron');
-        if (!fs_1.default.existsSync(electronBinary)) {
-            throw new Error('Electron binary executable file not found');
-        }
+        electronBinary = resolveInstalledElectron(basePath);
     }
     catch (e) {
-        console.log('[warn] Electron is not installed correctly or missing. Attempting automatic download/repair...');
+        console.log('[warn] Electron binary is missing. Resolving cached player runtime...');
         try {
-            electronBinary = await repairElectron(basePath);
-            console.log('[ok] Electron repaired successfully.');
+            electronBinary = await resolveCachedElectron(basePath);
+            console.log('[ok] Electron runtime ready.');
         }
         catch (repairErr) {
-            throw new Error(`Failed to resolve or install Electron automatically. Please run "npm install electron" or "node node_modules/electron/install.js" manually.\nDetails: ${repairErr.message}`);
+            throw new Error(`Failed to resolve Electron runtime automatically. Please run "npm install electron" or reinstall NekoStream.\nDetails: ${repairErr.message}`);
         }
     }
     return new Promise((resolve, reject) => {

package/dist/prompts-wrapper.js

@@ -65,19 +65,49 @@ function getGridChoices(choices) {
         value: choice.value
     }));
 }
+function normalized(value) {
+    return value.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+}
 function gridLayout(choices) {
     const width = (0, text_1.terminalWidth)(96, 58);
     const longest = choices.reduce((max, choice) => Math.max(max, (0, text_1.visibleLength)(choice.name)), 0);
     const columnWidth = Math.max(14, Math.min(28, longest + 2));
     const columns = Math.max(1, Math.min(6, Math.floor(width / (columnWidth + 3)), choices.length));
-    const rows = Math.ceil(choices.length / columns);
-    return { columnWidth, columns, rows };
+    const maxRows = Math.max(6, Math.min(12, (process.stdout.rows || 30) - 12));
+    const rows = Math.max(1, Math.min(maxRows, Math.ceil(choices.length / columns)));
+    const pageSize = columns * rows;
+    return { columnWidth, columns, rows, pageSize };
+}
+function filterGridChoices(choices, query) {
+    const term = normalized(query.trim());
+    if (!term)
+        return choices;
+    return choices.filter((choice, index) => {
+        const haystack = normalized(`${index + 1} ${choice.name} ${String(choice.value?.number ?? '')}`);
+        return haystack.includes(term);
+    });
+}
+function findNumericChoice(choices, query) {
+    const raw = query.trim();
+    if (!/^\d+$/.test(raw))
+        return undefined;
+    const target = Number(raw);
+    return choices.find((choice, index) => {
+        const valueNumber = Number(choice.value?.number);
+        if (Number.isFinite(valueNumber) && valueNumber === target)
+            return true;
+        if (index + 1 === target)
+            return true;
+        return new RegExp(`\\b0*${target}\\b`).test(choice.name);
+    });
 }
 async function selectGrid(options, signal) {
     const choices = getGridChoices(options.choices || []);
     if (choices.length === 0)
         return undefined;
     let selected = 0;
+    let page = 0;
+    let query = '';
     let renderedLines = 0;
     const message = normalizeMessage(options.message || 'Chọn');
     const render = () => {
@@ -86,25 +116,34 @@ async function selectGrid(options, signal) {
             readline_1.default.cursorTo(process.stdout, 0);
             readline_1.default.clearScreenDown(process.stdout);
         }
-        const { columnWidth, columns, rows } = gridLayout(choices);
+        const filtered = filterGridChoices(choices, query);
+        const { columnWidth, columns, rows, pageSize } = gridLayout(filtered);
+        const pageCount = Math.max(1, Math.ceil(filtered.length / pageSize));
+        page = Math.max(0, Math.min(page, pageCount - 1));
+        selected = Math.max(0, Math.min(selected, Math.max(0, filtered.length - 1)));
+        const pageStart = page * pageSize;
+        const pageChoices = filtered.slice(pageStart, pageStart + pageSize);
+        const selectedOnPage = selected - pageStart;
         const lines = [
             `${theme_1.uiText.focus('?')} ${promptMessage(message)}`,
+            `${theme_1.uiText.label('Search')} ${theme_1.uiText.value(query || '')}${theme_1.uiText.subtle(query ? '' : 'Gõ số tập/tên để lọc')}`,
             formatSeparator('DANH SÁCH TẬP', false)
         ];
         for (let row = 0; row < rows; row++) {
             const cells = [];
             for (let col = 0; col < columns; col++) {
                 const index = col * rows + row;
-                if (index >= choices.length)
+                if (index >= pageChoices.length)
                     continue;
-                const prefix = index === selected ? theme_1.uiText.focus(theme_1.glyphs.pointer) : ' ';
-                const label = (0, text_1.truncate)(choices[index].name, columnWidth - 2);
-                const cell = `${prefix} ${index === selected ? theme_1.uiText.focus(label) : theme_1.uiText.value(label)}`;
+                const prefix = index === selectedOnPage ? theme_1.uiText.focus(theme_1.glyphs.pointer) : ' ';
+                const label = (0, text_1.truncate)(pageChoices[index].name, columnWidth - 2);
+                const cell = `${prefix} ${index === selectedOnPage ? theme_1.uiText.focus(label) : theme_1.uiText.value(label)}`;
                 cells.push((0, text_1.padRight)(cell, columnWidth));
             }
             lines.push(cells.join(theme_1.uiText.border(` ${theme_1.glyphs.vertical} `)));
         }
-        lines.push(chalk_1.default.gray('↑↓←→ di chuyển · Enter chọn · Esc quay lại'));
+        const pageLabel = filtered.length > pageSize ? ` · Trang ${page + 1}/${pageCount}` : '';
+        lines.push(chalk_1.default.gray(`↑↓←→ di chuyển · PgUp/PgDn trang · Enter chọn · Esc quay lại${pageLabel}`));
         process.stdout.write(`${lines.join('\n')}\n`);
         renderedLines = lines.length;
     };
@@ -128,23 +167,62 @@ async function selectGrid(options, signal) {
             reject(new Error('ESC_PRESSED'));
         };
         const onKeypress = (_str, key) => {
-            const { rows } = gridLayout(choices);
+            const filtered = filterGridChoices(choices, query);
+            const { rows, pageSize } = gridLayout(filtered);
+            const pageCount = Math.max(1, Math.ceil(filtered.length / pageSize));
             if (key?.name === 'escape') {
                 done(undefined);
                 return;
             }
+            if (key?.name === 'backspace') {
+                query = query.slice(0, -1);
+                selected = 0;
+                page = 0;
+                render();
+                return;
+            }
             if (key?.name === 'return' || key?.name === 'enter') {
-                done(choices[selected].value);
+                const numericChoice = findNumericChoice(choices, query);
+                if (numericChoice) {
+                    done(numericChoice.value);
+                    return;
+                }
+                if (filtered[selected]) {
+                    done(filtered[selected].value);
+                }
+                else {
+                    render();
+                }
+                return;
+            }
+            if (_str && _str >= ' ' && !key?.ctrl && !key?.meta && key?.name !== 'return') {
+                query += _str;
+                selected = 0;
+                page = 0;
+                render();
+                return;
+            }
+            if (key?.name === 'pageup') {
+                page = Math.max(0, page - 1);
+                selected = page * pageSize;
+                render();
+                return;
+            }
+            if (key?.name === 'pagedown') {
+                page = Math.min(pageCount - 1, page + 1);
+                selected = page * pageSize;
+                render();
                 return;
             }
             if (key?.name === 'up')
                 selected = Math.max(0, selected - 1);
             if (key?.name === 'down')
-                selected = Math.min(choices.length - 1, selected + 1);
+                selected = Math.min(filtered.length - 1, selected + 1);
             if (key?.name === 'left')
                 selected = Math.max(0, selected - rows);
             if (key?.name === 'right')
-                selected = Math.min(choices.length - 1, selected + rows);
+                selected = Math.min(filtered.length - 1, selected + rows);
+            page = Math.floor(selected / pageSize);
             render();
         };
         signal.addEventListener('abort', onAbort);
@@ -198,6 +276,40 @@ async function prompts(options) {
                 return {};
             return { [options.name]: result };
         }
+        if (options.type === 'search') {
+            const message = normalizeMessage(options.message || 'Tìm');
+            const includeBack = shouldOfferBack(options.message || '');
+            const baseChoices = mapChoices(options.choices || [], includeBack).filter((choice) => !(choice instanceof prompts_1.Separator));
+            const result = await (0, prompts_1.search)({
+                message: promptMessage(message),
+                pageSize: options.pageSize || 15,
+                source: async (term) => {
+                    const query = normalized(term || '');
+                    if (!query)
+                        return baseChoices.slice(0, options.pageSize || 15);
+                    return baseChoices.filter((choice, index) => {
+                        const haystack = normalized(`${index + 1} ${choice.name || ''} ${choice.description || ''}`);
+                        return haystack.includes(query);
+                    }).slice(0, options.searchLimit || 50);
+                },
+                theme: {
+                    helpMode: 'always',
+                    prefix: {
+                        idle: theme_1.uiText.focus('?'),
+                        done: theme_1.uiText.success('>')
+                    },
+                    icon: {
+                        cursor: theme_1.uiText.focus(theme_1.glyphs.pointer)
+                    },
+                    style: {
+                        keysHelpTip: () => chalk_1.default.gray('Gõ tên/số · Enter chọn · Esc quay lại')
+                    }
+                }
+            }, { signal: ac.signal, clearPromptOnDone: true });
+            if (result === '__GOBACK__')
+                return {};
+            return { [options.name]: result };
+        }
         if (options.type === 'text') {
             const result = await (0, prompts_1.input)({
                 message: promptMessage(normalizeMessage(options.message || 'Nhập')),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nekostream",
-  "version": "2026.2.2",
+  "version": "2026.2.5",
   "description": "Bettter version of NekoStream ",
   "keywords": [
     "anime",

package/player.html

@@ -28,61 +28,86 @@
       top: 0;
       left: 0;
       right: 0;
-      height: 44px;
+      height: 34px;
       z-index: 10000;
-      display: flex;
-      align-items: center;
-      justify-content: space-between;
-      background: linear-gradient(to bottom, rgba(5, 8, 13, 0.82), rgba(5, 8, 13, 0.22), rgba(5, 8, 13, 0));
-      color: rgba(255, 255, 255, 0.92);
+      background: transparent;
       -webkit-app-region: drag;
       user-select: none;
       pointer-events: auto;
     }
-    .nav-title {
-      min-width: 0;
-      padding-left: 16px;
-      font-size: 13px;
-      font-weight: 600;
-      letter-spacing: 0.01em;
-      color: rgba(255, 255, 255, 0.88);
-      text-shadow: 0 1px 3px rgba(0, 0, 0, 0.55);
-      overflow: hidden;
-      text-overflow: ellipsis;
-      white-space: nowrap;
-    }
     .window-controls {
+      position: absolute;
+      top: 8px;
+      right: 10px;
       display: flex;
-      height: 32px;
-      margin-right: 10px;
-      overflow: hidden;
-      border: 1px solid rgba(255, 255, 255, 0.12);
-      border-radius: 6px;
-      background: rgba(8, 12, 20, 0.38);
-      backdrop-filter: blur(10px);
+      flex-direction: row-reverse;
+      align-items: center;
+      gap: 0;
+      min-width: 28px;
+      height: 28px;
       pointer-events: auto;
       -webkit-app-region: no-drag;
     }
+    .window-dot {
+      width: 12px;
+      height: 12px;
+      padding: 0;
+      border: 1px solid rgba(255, 255, 255, 0.58);
+      border-radius: 999px;
+      background: rgba(255, 255, 255, 0.86);
+      box-shadow: 0 2px 12px rgba(0, 0, 0, 0.45);
+      cursor: pointer;
+      transition: transform 0.18s ease, background 0.18s ease, border-color 0.18s ease;
+    }
+    .window-controls:hover .window-dot,
+    .window-controls:focus-within .window-dot {
+      transform: scale(0.74);
+      background: rgba(255, 255, 255, 0.55);
+      border-color: rgba(255, 255, 255, 0.75);
+    }
     .window-btn {
-      width: 42px;
-      height: 32px;
+      width: 0;
+      height: 28px;
+      margin-right: 0;
+      padding: 0;
       display: inline-flex;
       align-items: center;
       justify-content: center;
       border: 0;
-      border-right: 1px solid rgba(255, 255, 255, 0.1);
-      background: transparent;
+      border-radius: 999px;
+      background: rgba(8, 12, 20, 0.58);
       color: rgba(255, 255, 255, 0.82);
-      font-size: 16px;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 4px 18px rgba(0, 0, 0, 0.38);
+      font-size: 14px;
       line-height: 1;
       cursor: pointer;
-      transition: background 0.15s ease, color 0.15s ease;
+      opacity: 0;
+      overflow: hidden;
+      transform: translateX(12px) scale(0.82);
+      transition: width 0.2s ease, margin-right 0.2s ease, opacity 0.16s ease, transform 0.2s ease, background 0.15s ease, color 0.15s ease;
+    }
+    .window-controls:hover .window-btn,
+    .window-controls:focus-within .window-btn {
+      width: 28px;
+      margin-right: 7px;
+      opacity: 1;
+      transform: translateX(0) scale(1);
+    }
+    .window-controls:hover #window-minimize,
+    .window-controls:focus-within #window-minimize {
+      transition-delay: 0.02s;
     }
-    .window-btn:last-child {
-      border-right: 0;
+    .window-controls:hover #window-maximize,
+    .window-controls:focus-within #window-maximize {
+      transition-delay: 0.05s;
+    }
+    .window-controls:hover #window-close,
+    .window-controls:focus-within #window-close {
+      transition-delay: 0.08s;
     }
     .window-btn:hover {
-      background: rgba(255, 255, 255, 0.14);
+      background: rgba(255, 255, 255, 0.18);
       color: #fff;
     }
     .window-btn.close:hover {
@@ -128,11 +153,11 @@
 </head>
 <body>
   <header id="top-nav">
-    <div class="nav-title" id="nav-title">NekoStream Player</div>
     <div class="window-controls">
-      <button class="window-btn" id="window-minimize" title="Minimize">-</button>
-      <button class="window-btn" id="window-maximize" title="Maximize">□</button>
       <button class="window-btn close" id="window-close" title="Close">×</button>
+      <button class="window-btn" id="window-maximize" title="Maximize">□</button>
+      <button class="window-btn" id="window-minimize" title="Minimize">-</button>
+      <button class="window-dot" title="Window controls" aria-label="Window controls"></button>
     </div>
   </header>
   <div id="loading-overlay">
@@ -165,10 +190,8 @@
 
     window.initPlayer = function(streamInfo, baseDir, cleanUA) {
       const container = document.getElementById('player-container');
-      const navTitle = document.getElementById('nav-title');
-      navTitle.textContent = streamInfo.provider ? `NekoStream · ${streamInfo.provider}` : 'NekoStream Player';
-      
-      if (streamInfo.type === 'iframe') {
+      
+      if (streamInfo.type === 'iframe') {
         const overlay = document.getElementById('loading-overlay');
         overlay.style.display = 'flex';