nekostream 2026.2.3 → 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.3",
+  "version": "2026.2.5",
   "description": "Bettter version of NekoStream ",
   "keywords": [
     "anime",