nekostream 2026.4.1 → 2026.4.2

package/dist/cli/flows/anime-flow.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAnimeMenu = openAnimeMenu;
+exports.showAnimeList = showAnimeList;
+exports.showUserDataList = showUserDataList;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_wrapper_1 = __importDefault(require("../../prompts-wrapper"));
+const providers_1 = require("../../providers");
+const player_1 = require("../../player");
+const ui_1 = require("../../ui");
+const storage_1 = require("../../storage");
+const discord_1 = require("../../discord");
+const feedback_1 = require("../feedback");
+const USER_LIST_PAGE_SIZE = 20;
+function episodeLabel(episode) {
+    return episode.title || `Episode ${episode.number}`;
+}
+function singleLine(value) {
+    return value.replace(/\r?\n|\r/g, ' ').trim();
+}
+/** Placeholder detail used when a provider cannot serve its detail page. */
+function fallbackDetail(providerName, animeId, episodes) {
+    const firstTitle = episodes.length > 0 ? episodes[0].title : undefined;
+    return {
+        id: animeId,
+        source: providerName,
+        title: firstTitle ? firstTitle.split(' - ')[0] : animeId,
+        genres: [],
+    };
+}
+async function selectEpisode(anime, episodes) {
+    (0, ui_1.clearScreen)();
+    (0, ui_1.printBanner)(`Provider: ${anime.source.toUpperCase()}`, anime.title);
+    (0, ui_1.drawAnimeCard)(anime);
+    (0, feedback_1.flushStdin)();
+    const choices = episodes.map((episode, index) => ({
+        title: `${chalk_1.default.bold(String(index + 1).padStart(2))}. ${singleLine(episodeLabel(episode))}`,
+        value: episode,
+    }));
+    const { episode } = await (0, prompts_wrapper_1.default)({
+        type: 'grid',
+        name: 'episode',
+        message: 'Chọn tập phim (Esc: quay lại)',
+        choices,
+    });
+    return episode;
+}
+async function selectServer(providerName, servers) {
+    const { server } = await (0, prompts_wrapper_1.default)({
+        type: 'select',
+        name: 'server',
+        message: 'Chọn server phát (Esc: quay lại)',
+        choices: servers.map((entry, index) => {
+            const quality = chalk_1.default.gray(`[${entry.quality || 'Auto'}]`);
+            const detail = providerName === 'animevietsub'
+                ? quality
+                : chalk_1.default.gray(`[${entry.quality || 'Auto'}] (${entry.type || 'stream'})`);
+            return {
+                title: `${chalk_1.default.bold(`${index + 1}.`)} ${entry.name} ${detail}`,
+                value: entry,
+            };
+        }),
+    });
+    return server;
+}
+async function playEpisode(providerName, anime, episode, streamInfo) {
+    (0, ui_1.printSuccess)('\nSẵn sàng phát. Đang mở player...');
+    (0, storage_1.saveHistoryEntry)({
+        provider: providerName,
+        animeId: anime.id,
+        animeTitle: anime.title,
+        episodeId: episode.id,
+        episodeTitle: episodeLabel(episode),
+    });
+    try {
+        (0, discord_1.setWatchingPresence)(anime.title, episodeLabel(episode), providerName);
+        await (0, player_1.launchPlayer)(streamInfo);
+        (0, discord_1.setBrowsingPresence)('Đang xem thông tin phim', providerName, 'Thông tin Phim', anime.title);
+        (0, ui_1.printSuccess)('\nTrình phát đã đóng.');
+        await (0, feedback_1.sleep)(500);
+    }
+    catch (error) {
+        await (0, feedback_1.reportFailure)('Lỗi player', error);
+    }
+}
+/**
+ * Server selection and playback for one episode. Returns when the user backs
+ * out or a playback attempt finishes.
+ */
+async function runEpisodeSession(providerName, anime, episode) {
+    const provider = (0, providers_1.getProvider)(providerName);
+    while (true) {
+        (0, ui_1.clearScreen)();
+        (0, ui_1.printBanner)('Chọn server', anime.title);
+        (0, ui_1.drawAnimeInfoCard)(anime, episodeLabel(episode));
+        const servers = await (0, feedback_1.withSpinner)('Đang tải server phát...', 'Không tải được server phát', () => provider.getVideoServers(episode.href || episode.id));
+        if (servers === undefined)
+            return;
+        if (servers.length === 0) {
+            await (0, feedback_1.reportEmpty)('Không tìm thấy server phát cho tập này.');
+            return;
+        }
+        const server = await selectServer(providerName, servers);
+        if (!server)
+            return;
+        const streamInfo = await (0, feedback_1.withSpinner)('Đang lấy stream URL...', 'Không lấy được stream', () => provider.extractStreamUrl(server));
+        if (streamInfo === undefined)
+            continue;
+        if (!streamInfo || !streamInfo.url) {
+            await (0, feedback_1.reportEmpty)('Không lấy được stream URL.');
+            continue;
+        }
+        await playEpisode(providerName, anime, episode, streamInfo);
+        return;
+    }
+}
+/** Detail view for one anime: browse episodes, pick a server, and play. */
+async function openAnimeMenu(providerName, animeId) {
+    (0, discord_1.setBrowsingPresence)('Đang tải thông tin phim', providerName, 'Tải dữ liệu');
+    const provider = (0, providers_1.getProvider)(providerName);
+    const episodes = await (0, feedback_1.withSpinner)('Đang tải thông tin phim và danh sách tập...', 'Không tải được danh sách tập', () => provider.getEpisodes(animeId));
+    if (episodes === undefined)
+        return;
+    if (episodes.length === 0) {
+        (0, ui_1.printEmpty)('\nKhông tìm thấy tập phim nào.');
+        await (0, feedback_1.sleep)(feedback_1.NOTICE_DELAY_MS);
+        return;
+    }
+    // A 401 on the detail page must not block episode playback, so failures here
+    // fall back to a synthetic detail record.
+    let anime = null;
+    if (provider.getAnimeDetail) {
+        try {
+            anime = await provider.getAnimeDetail(animeId);
+        }
+        catch {
+            // Detail unavailable — episodes still work.
+        }
+    }
+    const detail = anime ?? fallbackDetail(providerName, animeId, episodes);
+    while (true) {
+        (0, discord_1.setBrowsingPresence)('Đang xem thông tin phim', providerName, 'Thông tin Phim', detail.title);
+        const episode = await selectEpisode(detail, episodes);
+        if (!episode)
+            return;
+        await runEpisodeSession(providerName, detail, episode);
+    }
+}
+/** Searchable list of anime cards from search results or home rails. */
+async function showAnimeList(providerName, title, list) {
+    (0, discord_1.setBrowsingPresence)(`Danh sách: ${title}`, providerName, title);
+    while (true) {
+        (0, ui_1.clearScreen)();
+        (0, ui_1.printBanner)(`Provider: ${providerName.toUpperCase()}`, title.toUpperCase());
+        (0, feedback_1.flushStdin)();
+        const { animeId } = await (0, prompts_wrapper_1.default)({
+            type: 'search',
+            name: 'animeId',
+            message: 'Chọn anime (Esc: quay lại)',
+            pageSize: 15,
+            choices: list.map((anime, index) => {
+                const meta = singleLine(anime.status || anime.year?.toString() || '');
+                return {
+                    title: `${chalk_1.default.bold(String(index + 1).padStart(2))}. ${singleLine(anime.title)}${meta ? chalk_1.default.gray(` - ${meta}`) : ''}`,
+                    value: anime.id,
+                };
+            }),
+        });
+        if (!animeId)
+            return;
+        await openAnimeMenu(providerName, animeId);
+    }
+}
+/** Paginated list of a signed-in user's saved anime, selectable for playback. */
+async function showUserDataList(title, items, providerName) {
+    (0, discord_1.setBrowsingPresence)(`Đang xem ${title}`, providerName, title);
+    if (items.length === 0) {
+        (0, ui_1.printEmpty)('\nDanh sách đang trống.');
+        await (0, feedback_1.sleep)(1500);
+        return;
+    }
+    let offset = 0;
+    while (true) {
+        (0, ui_1.clearScreen)();
+        (0, ui_1.printBanner)(title, `${items.length} anime`);
+        const page = items.slice(offset, offset + USER_LIST_PAGE_SIZE);
+        const choices = page.map((item, index) => {
+            const episode = item.episodeNumber ? chalk_1.default.gray(` [Tập ${item.episodeNumber}]`) : '';
+            const status = item.status ? chalk_1.default.cyan(` (${item.status})`) : '';
+            return {
+                title: `${chalk_1.default.bold(String(offset + index + 1).padStart(3))}. ${item.title}${episode}${status}`,
+                value: item.animeId,
+            };
+        });
+        const remaining = items.length - offset - USER_LIST_PAGE_SIZE;
+        if (remaining > 0) {
+            choices.push({ title: chalk_1.default.yellow(`▼ Xem thêm (${remaining} còn lại)`), value: '__next__' });
+        }
+        if (offset > 0) {
+            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: 'search',
+            name: 'animeId',
+            message: 'Chọn anime để xem (Esc: quay lại)',
+            pageSize: USER_LIST_PAGE_SIZE,
+            choices,
+        });
+        if (!animeId || animeId === '__back__')
+            return;
+        if (animeId === '__next__') {
+            offset = Math.min(offset + USER_LIST_PAGE_SIZE, items.length - 1);
+            continue;
+        }
+        if (animeId === '__prev__') {
+            offset = Math.max(0, offset - USER_LIST_PAGE_SIZE);
+            continue;
+        }
+        await openAnimeMenu(providerName, animeId);
+    }
+}

package/dist/cli/flows/auth-flow.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginToProvider = loginToProvider;
+const chalk_1 = __importDefault(require("chalk"));
+const auth_service_1 = require("../../scrapers/auth-service");
+const ui_1 = require("../../ui");
+const feedback_1 = require("../feedback");
+/**
+ * Run the interactive browser login for a provider and report the outcome.
+ * Returns whether the session was established.
+ */
+async function loginToProvider(provider) {
+    try {
+        const status = provider === 'animevietsub'
+            ? await (0, auth_service_1.loginAnimeVietsubInteractive)()
+            : await (0, auth_service_1.loginAnime47Interactive)();
+        (0, ui_1.printSuccess)('\nĐăng nhập thành công!');
+        if (status.userDisplayName) {
+            console.log(chalk_1.default.cyan(`   Xin chào, ${status.userDisplayName}!`));
+        }
+        await (0, feedback_1.sleep)(feedback_1.NOTICE_DELAY_MS);
+        return true;
+    }
+    catch (error) {
+        // A cancelled login surfaces as a Playwright timeout, which deserves a
+        // clearer message than the raw error text.
+        if (error instanceof Error && error.name === 'TimeoutError') {
+            console.log(chalk_1.default.red('\nĐăng nhập thất bại/Đã hủy: Hết thời gian chờ (Timeout).'));
+        }
+        else {
+            console.log(chalk_1.default.red(`\nĐăng nhập thất bại: ${(0, feedback_1.formatError)(error)}`));
+        }
+        await (0, feedback_1.sleep)(feedback_1.NOTICE_DELAY_MS);
+        return false;
+    }
+}

package/dist/cli/flows/provider-lists.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_LABELS = void 0;
+exports.listTitle = listTitle;
+exports.openProviderList = openProviderList;
+const auth_service_1 = require("../../scrapers/auth-service");
+const feedback_1 = require("../feedback");
+const anime_flow_1 = require("./anime-flow");
+exports.PROVIDER_LABELS = {
+    animevietsub: 'AnimeVietsub',
+    anime47: 'Anime47',
+};
+const ANIME47_LIST_TITLES = {
+    favorites: 'Yêu thích',
+    history: 'Lịch sử xem',
+    watching: 'Đang xem',
+    completed: 'Hoàn thành',
+    plan_to_watch: 'Dự định xem',
+};
+const ANIMEVIETSUB_LIST_TITLES = {
+    favorites: 'Hộp phim / Yêu thích',
+    history: 'Lịch sử xem',
+};
+function listTitle(provider, request) {
+    if (request.kind === 'notifications')
+        return 'Thông báo';
+    if (provider === 'animevietsub') {
+        const action = request.listType === 'history' ? 'history' : 'favorites';
+        return ANIMEVIETSUB_LIST_TITLES[action];
+    }
+    return ANIME47_LIST_TITLES[request.listType];
+}
+function notificationsToItems(result) {
+    if (result.notifications) {
+        return result.notifications.map((entry) => ({
+            animeId: entry.animeId || '',
+            title: entry.title,
+            url: entry.url,
+            thumbnail: entry.thumbnail,
+        }));
+    }
+    return result.items;
+}
+function fetchProviderData(provider, request) {
+    if (provider === 'animevietsub') {
+        if (request.kind === 'notifications')
+            return (0, auth_service_1.fetchAnimeVietsubNotifications)();
+        const listType = request.listType === 'history' ? 'history' : 'favorites';
+        return (0, auth_service_1.fetchAllAnimeVietsubList)(listType);
+    }
+    if (request.kind === 'notifications')
+        return (0, auth_service_1.fetchAnime47Notifications)();
+    return (0, auth_service_1.fetchAllAnime47List)(request.listType === 'favorites' ? 'favorite' : request.listType);
+}
+/**
+ * Fetch a provider-side list behind a spinner and hand it to the interactive
+ * list view. Titles can be overridden for menus that use shorter labels.
+ */
+async function openProviderList(provider, request, title = listTitle(provider, request)) {
+    const outcome = await (0, feedback_1.withSilentSpinner)(`Đang tải dữ liệu từ ${exports.PROVIDER_LABELS[provider]}...`, () => fetchProviderData(provider, request));
+    if (!outcome.ok) {
+        await (0, feedback_1.reportFailure)('Lỗi', outcome.error);
+        return;
+    }
+    const result = outcome.value;
+    if (!result.success) {
+        await (0, feedback_1.reportFailure)(result.error || 'Không tải được dữ liệu.');
+        return;
+    }
+    const items = request.kind === 'notifications' ? notificationsToItems(result) : result.items;
+    await (0, anime_flow_1.showUserDataList)(title, items, provider);
+}

package/dist/cli/menus/history-menu.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHistoryMenu = showHistoryMenu;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_wrapper_1 = __importDefault(require("../../prompts-wrapper"));
+const ui_1 = require("../../ui");
+const storage_1 = require("../../storage");
+const discord_1 = require("../../discord");
+const feedback_1 = require("../feedback");
+const anime_flow_1 = require("../flows/anime-flow");
+const ACTION_CLEAR = -2;
+const ACTION_BACK = -1;
+async function confirmClearHistory() {
+    const { confirm } = await (0, prompts_wrapper_1.default)({
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Bạn có chắc muốn xóa toàn bộ lịch sử?',
+    });
+    if (!confirm)
+        return;
+    (0, storage_1.clearHistory)();
+    (0, ui_1.printSuccess)('Đã xóa lịch sử.');
+    await (0, feedback_1.sleep)(feedback_1.CONFIRM_DELAY_MS);
+}
+/** Local watch history, newest first, selectable to resume playback. */
+async function showHistoryMenu() {
+    (0, discord_1.setBrowsingPresence)('Đang xem Lịch Sử', undefined, 'Lịch sử Toàn cục');
+    while (true) {
+        (0, ui_1.clearScreen)();
+        (0, ui_1.printBanner)('Tiếp tục xem', 'Mở lại bộ phim bạn xem gần đây');
+        const history = (0, storage_1.loadHistory)();
+        if (history.length === 0) {
+            (0, ui_1.printEmpty)('Lịch sử xem đang trống.');
+            await (0, feedback_1.sleep)(feedback_1.NOTICE_DELAY_MS);
+            return;
+        }
+        const choices = [{ separator: 'LỊCH SỬ LOCAL' }];
+        history.forEach((item, index) => {
+            choices.push({
+                title: `${chalk_1.default.magenta(item.provider)} | ${chalk_1.default.bold.white(item.animeTitle)} - ${chalk_1.default.cyan(item.episodeTitle)}`,
+                description: `Đã xem: ${new Date(item.timestamp).toLocaleString()}`,
+                value: index,
+            });
+        });
+        choices.push({ title: chalk_1.default.red('Xóa lịch sử'), description: '', value: ACTION_CLEAR });
+        choices.push({ title: chalk_1.default.gray('Quay lại Home'), description: '', value: ACTION_BACK });
+        const { selectedIndex } = await (0, prompts_wrapper_1.default)({
+            type: 'select',
+            name: 'selectedIndex',
+            message: 'Chọn tập muốn xem tiếp (Esc: quay lại)',
+            choices,
+        });
+        if (selectedIndex === undefined || selectedIndex === ACTION_BACK)
+            return;
+        if (selectedIndex === ACTION_CLEAR) {
+            await confirmClearHistory();
+            continue;
+        }
+        const item = history[selectedIndex];
+        await (0, anime_flow_1.openAnimeMenu)(item.provider, item.animeId);
+    }
+}

package/dist/cli/menus/home-menu.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHomeMenu = showHomeMenu;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_wrapper_1 = __importDefault(require("../../prompts-wrapper"));
+const providers_1 = require("../../providers");
+const provider_types_1 = require("../../provider-types");
+const ui_1 = require("../../ui");
+const storage_1 = require("../../storage");
+const discord_1 = require("../../discord");
+const logger_1 = require("../../logger");
+const auth_service_1 = require("../../scrapers/auth-service");
+const feedback_1 = require("../feedback");
+const anime_flow_1 = require("../flows/anime-flow");
+const provider_lists_1 = require("../flows/provider-lists");
+const auth_flow_1 = require("../flows/auth-flow");
+const history_menu_1 = require("./history-menu");
+const settings_menu_1 = require("./settings-menu");
+const HOME_LIST_TITLES = {
+    favorites: 'Hộp phim',
+    history_provider: 'Lịch sử',
+    watching: 'Đang xem',
+    completed: 'Hoàn thành',
+    plan_to_watch: 'Dự định xem',
+    notifications: 'Thông báo',
+};
+/** AnimeHay has no account features, so it reports a permanently anonymous status. */
+function anonymousStatus(provider) {
+    return {
+        provider: provider,
+        loggedIn: false,
+        cookieCount: 0,
+        hasAuthLikeCookie: false,
+        userDisplayName: undefined,
+    };
+}
+function resolveAuthStatus(provider) {
+    return (0, provider_types_1.isAccountProviderId)(provider) ? (0, auth_service_1.getAuthStatus)(provider) : anonymousStatus(provider);
+}
+function homeListRequest(action) {
+    if (action === 'notifications')
+        return { kind: 'notifications' };
+    const listType = action === 'history_provider' ? 'history' : action;
+    return { kind: 'list', listType };
+}
+function accountChoices(provider, status) {
+    if (!(0, provider_types_1.isAccountProviderId)(provider))
+        return [];
+    if (!status.loggedIn) {
+        const label = provider === 'anime47' ? 'Đăng nhập Anime47' : 'Đăng nhập AnimeVietsub';
+        return [{ title: chalk_1.default.green(label), value: 'login' }];
+    }
+    const listActions = provider === 'anime47'
+        ? ['favorites', 'history_provider', 'watching', 'completed', 'plan_to_watch', 'notifications']
+        : ['favorites', 'history_provider', 'notifications'];
+    return [
+        ...listActions.map((action) => ({
+            title: action === 'favorites' && provider === 'anime47'
+                ? 'Hộp phim / Yêu thích'
+                : HOME_LIST_TITLES[action],
+            value: action,
+        })),
+        { title: chalk_1.default.yellow('Đăng xuất'), value: 'logout' },
+    ];
+}
+function homeChoices(provider, status) {
+    const username = status.loggedIn ? status.userDisplayName || 'MEMBER' : 'KHÁCH';
+    return [
+        { separator: 'KHÁM PHÁ' },
+        { title: 'Tìm anime', value: 'search', description: 'Tìm theo tên phim' },
+        { title: 'Đang thịnh hành', value: 'trending', description: 'Danh sách nổi bật từ provider' },
+        { title: 'Mới cập nhật', value: 'latest', description: 'Các tập/phim vừa được cập nhật' },
+        { separator: `TÀI KHOẢN : ${username.toUpperCase()}` },
+        ...accountChoices(provider, status),
+        { separator: 'HỆ THỐNG' },
+        { title: 'Tiếp tục xem (Lịch sử Local)', value: 'history' },
+        { title: 'Cài đặt hệ thống', value: 'settings' },
+        { title: 'Đổi Provider', value: 'change_provider' },
+        { title: chalk_1.default.red('Thoát ứng dụng'), value: 'exit' },
+    ];
+}
+function renderHome(provider, status) {
+    (0, ui_1.clearScreen)();
+    const usernameDisplay = status.loggedIn
+        ? chalk_1.default.green(`${status.userDisplayName || 'Đã đăng nhập'} (${status.cookieCount || 0} cookies)`)
+        : chalk_1.default.red('Chưa đăng nhập');
+    (0, ui_1.printBanner)(`Provider: ${provider.toUpperCase()}`, 'Trang chủ');
+    (0, ui_1.printStatusStrip)([
+        { label: 'Tài khoản', value: usernameDisplay },
+        { label: 'Provider', value: chalk_1.default.green(provider) },
+    ]);
+    (0, logger_1.debugTrace)('home rendered', { provider, loggedIn: status.loggedIn });
+}
+async function runSearch(provider) {
+    const { keyword } = await (0, prompts_wrapper_1.default)({
+        type: 'text',
+        name: 'keyword',
+        message: 'Nhập tên anime cần tìm (Esc: quay lại)',
+    });
+    if (!keyword)
+        return;
+    const results = await (0, feedback_1.withSpinner)(`Đang tìm "${keyword}" trên ${provider}...`, 'Tìm kiếm thất bại', () => (0, providers_1.getProvider)(provider).search(keyword));
+    if (results === undefined)
+        return;
+    if (results.length === 0) {
+        (0, ui_1.printEmpty)('\nKhông tìm thấy kết quả phù hợp.');
+        await (0, feedback_1.sleep)(feedback_1.NOTICE_DELAY_MS);
+        return;
+    }
+    (0, discord_1.setBrowsingPresence)(`Đang Tìm kiếm: ${keyword}`, provider, 'Tìm kiếm');
+    await (0, anime_flow_1.showAnimeList)(provider, `Kết quả tìm kiếm: ${keyword}`, results);
+}
+async function runHomeRail(provider, rail) {
+    const label = rail === 'trending' ? 'thịnh hành' : 'mới cập nhật';
+    const results = await (0, feedback_1.withSpinner)(`Đang tải danh sách ${label}...`, `Không tải được danh sách ${label}`, () => (0, providers_1.getProvider)(provider).getHomeCards(rail));
+    if (results === undefined)
+        return;
+    if (results.length === 0) {
+        (0, ui_1.printEmpty)(`\nProvider này chưa có danh sách ${label}.`);
+        await (0, feedback_1.sleep)(feedback_1.NOTICE_DELAY_MS);
+        return;
+    }
+    const title = rail === 'trending' ? 'Đang thịnh hành' : 'Mới cập nhật';
+    (0, discord_1.setBrowsingPresence)(`Đang Xem ${rail === 'trending' ? 'Xu hướng' : 'Cập nhật gần đây'}`, provider, title);
+    await (0, anime_flow_1.showAnimeList)(provider, title, results);
+}
+async function changeProvider(current) {
+    const { newProvider } = await (0, prompts_wrapper_1.default)({
+        type: 'select',
+        name: 'newProvider',
+        message: 'Chọn provider',
+        choices: provider_types_1.PROVIDER_IDS.map((name) => ({ title: name, value: name })),
+    });
+    return newProvider ?? current;
+}
+function exitApplication() {
+    (0, ui_1.clearScreen)();
+    (0, discord_1.clearDiscordPresence)();
+    console.log(chalk_1.default.magenta('\nCảm ơn bạn đã dùng NekoStream CLI.\n'));
+    process.exit(0);
+}
+/** The main home loop. Runs until the user chooses to exit. */
+async function showHomeMenu() {
+    let currentProvider = (0, storage_1.loadSettings)().defaultProvider;
+    while (true) {
+        (0, discord_1.setBrowsingPresence)('Đang lướt Menu Chính');
+        const status = resolveAuthStatus(currentProvider);
+        renderHome(currentProvider, status);
+        const { action } = await (0, prompts_wrapper_1.default)({
+            type: 'select',
+            name: 'action',
+            message: 'Trang chủ',
+            choices: homeChoices(currentProvider, status),
+        });
+        if (!action || action === 'exit')
+            exitApplication();
+        if ((0, provider_types_1.isHomeListAction)(action)) {
+            if ((0, provider_types_1.isAccountProviderId)(currentProvider)) {
+                const request = homeListRequest(action);
+                await (0, provider_lists_1.openProviderList)(currentProvider, request, HOME_LIST_TITLES[action]);
+            }
+            continue;
+        }
+        switch (action) {
+            case 'login':
+                if ((0, provider_types_1.isAccountProviderId)(currentProvider))
+                    await (0, auth_flow_1.loginToProvider)(currentProvider);
+                break;
+            case 'logout':
+                if ((0, provider_types_1.isAccountProviderId)(currentProvider))
+                    (0, auth_service_1.logoutProvider)(currentProvider);
+                console.log(chalk_1.default.yellow('\nĐã đăng xuất.'));
+                await (0, feedback_1.sleep)(feedback_1.CONFIRM_DELAY_MS);
+                break;
+            case 'search':
+                await runSearch(currentProvider);
+                break;
+            case 'trending':
+            case 'latest':
+                await runHomeRail(currentProvider, action);
+                break;
+            case 'history':
+                await (0, history_menu_1.showHistoryMenu)();
+                break;
+            case 'settings':
+                await (0, settings_menu_1.showSettingsMenu)();
+                // The default provider may have changed inside the settings menu.
+                currentProvider = (0, storage_1.loadSettings)().defaultProvider;
+                break;
+            case 'change_provider':
+                currentProvider = await changeProvider(currentProvider);
+                break;
+        }
+    }
+}