@nbtca/prompt 1.3.2 → 1.4.2

package/dist/features/student-timetable.js

@@ -0,0 +1,346 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { createNbtTimetableClient, timetableToIcs, TimetableError, } from '@nbtca/nbtcal/timetable';
+import { runSecretInput, runTextInput } from '../core/components/text-input.js';
+import { runMenu } from '../core/components/menu.js';
+import { glyph } from '../core/theme.js';
+import { AuthError } from '../auth/errors.js';
+import { loginWithStudentPassword, restoreNbtSession } from '../auth/nbt-auth.js';
+import { createSessionStore } from '../auth/session-store.js';
+import { clearScheduleCache } from './schedule-store.js';
+import { fmt, t } from '../i18n/index.js';
+export const JWXT_ORIGIN = 'https://jwxt-443.webvpn.nbt.edu.cn';
+function flagValue(flags, prefix) {
+    const flag = [...flags].find((value) => value.startsWith(prefix));
+    return flag?.slice(prefix.length);
+}
+function semesterAlias(value) {
+    if (value === '1')
+        return '3';
+    if (value === '2')
+        return '12';
+    if (value === '3')
+        return '16';
+    return value;
+}
+export function resolveTerm(catalog, selector) {
+    if (catalog.length === 0)
+        throw new Error('No academic terms are available.');
+    if (!selector) {
+        const current = catalog.filter((term) => term.current);
+        if (current.length !== 1)
+            throw new Error('The current academic term could not be determined.');
+        return current[0];
+    }
+    const exact = catalog.find((term) => `${term.academicYear}:${term.semester}` === selector);
+    if (exact)
+        return exact;
+    const shorthand = /^(\d{4})[-/:](\d+)$/.exec(selector);
+    if (shorthand?.[1] && shorthand[2]) {
+        const semester = semesterAlias(shorthand[2]);
+        const matched = catalog.find((term) => term.academicYear === shorthand[1] && term.semester === semester);
+        if (matched)
+            return matched;
+    }
+    throw new Error('Unknown academic term. Run `nbtca schedule terms` first.');
+}
+export function relevantTerms(catalog) {
+    const selected = catalog.find((term) => term.current);
+    const currentYear = Number.parseInt(selected?.academicYear ?? '', 10);
+    if (!Number.isInteger(currentYear))
+        return [...catalog].slice(0, 15);
+    return catalog.filter((term) => {
+        const year = Number.parseInt(term.academicYear, 10);
+        return Number.isInteger(year) && year <= currentYear && year >= currentYear - 4;
+    });
+}
+function displaySemesterLabel(term) {
+    const aliases = { '3': '1', '12': '2', '16': '3' };
+    const aliased = aliases[term.semester];
+    if (aliased)
+        return fmt(t().timetable.semesterNumber, { number: aliased });
+    return /^\d+$/.test(term.semesterLabel)
+        ? fmt(t().timetable.semesterNumber, { number: term.semesterLabel })
+        : term.semesterLabel;
+}
+export function isSessionExpired(error) {
+    return (error instanceof AuthError && error.code === 'SESSION_EXPIRED') || (error instanceof TimetableError && error.code === 'SESSION_EXPIRED');
+}
+export function safeMessage(error) {
+    const trans = t().timetable;
+    if (error instanceof AuthError) {
+        switch (error.code) {
+            case 'INVALID_CREDENTIALS': return trans.invalidCredentials;
+            case 'ACCOUNT_LOCKED': return trans.accountLocked;
+            case 'ACCOUNT_INACTIVE': return trans.accountInactive;
+            case 'INTERACTIVE_CHALLENGE': return trans.challenge;
+            case 'SESSION_EXPIRED': return trans.sessionExpired;
+            case 'TIMEOUT': return trans.timeout;
+            case 'NETWORK': return trans.network;
+            case 'UNTRUSTED_URL': return trans.untrustedUrl;
+            case 'HTTP_ERROR': return trans.httpError;
+            case 'LOGIN_PAGE_CHANGED': return trans.loginChanged;
+            case 'UNEXPECTED_RESPONSE': return trans.unexpectedResponse;
+            default: return trans.genericError;
+        }
+    }
+    if (error instanceof TimetableError) {
+        switch (error.code) {
+            case 'MISSING_CALENDAR_DATES': return trans.missingDates;
+            case 'MISSING_PERIOD_TIME': return trans.missingPeriod;
+            case 'TERM_MISMATCH': return trans.termMismatch;
+            case 'SESSION_EXPIRED': return trans.sessionExpired;
+            default: return trans.invalidData;
+        }
+    }
+    if (error instanceof Error && error.message === 'Unknown academic term. Run `nbtca schedule terms` first.') {
+        return trans.unknownTerm;
+    }
+    if (error instanceof Error && error.message === 'No academic terms are available.')
+        return trans.noTerms;
+    if (error instanceof Error && error.message === 'The current academic term could not be determined.') {
+        return trans.currentTermUnknown;
+    }
+    return trans.genericError;
+}
+async function interactiveLogin(isInteractive) {
+    const trans = t().timetable;
+    if (!isInteractive) {
+        throw new AuthError('INVALID_CREDENTIALS', 'credentials', 'Interactive login requires a terminal.');
+    }
+    const username = await runSecretInput({
+        message: trans.studentId,
+        placeholder: trans.studentIdHint,
+        allowEmpty: false,
+        mask: '•',
+    });
+    if (!username)
+        throw new AuthError('INVALID_CREDENTIALS', 'credentials', 'Student id is required.');
+    const password = await runSecretInput({
+        message: trans.password,
+        placeholder: trans.passwordHint,
+        allowEmpty: false,
+    });
+    if (!password)
+        throw new AuthError('INVALID_CREDENTIALS', 'credentials', 'Password is required.');
+    return loginWithStudentPassword(username, password);
+}
+export async function withAuthenticatedSession(operation, options) {
+    let persisted = options.oneShot ? null : options.store.load();
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let session = null;
+        const wasRestored = persisted !== null;
+        let savedBeforeOperation = false;
+        try {
+            if (!wasRestored && !options.oneShot) {
+                options.stderr.write(`${t().timetable.loginWillSave}\n`);
+            }
+            session = persisted
+                ? await (options.restoreSession ?? restoreNbtSession)(persisted)
+                : await (options.login ?? interactiveLogin)(options.isInteractive);
+            if (!options.oneShot && !wasRestored) {
+                options.store.save(await session.snapshot());
+                savedBeforeOperation = true;
+            }
+            const result = await operation(session);
+            if (!options.oneShot) {
+                try {
+                    options.store.save(await session.snapshot());
+                }
+                catch {
+                    // A new session was already saved before the operation, or a restored
+                    // session still has its previous atomic file. Do not turn a completed
+                    // export into a reported failure just because its TTL could not refresh.
+                    if (!savedBeforeOperation && !wasRestored)
+                        throw new Error('Session persistence failed.');
+                    options.stderr.write(`${t().timetable.sessionRefreshFailed}\n`);
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            if (isSessionExpired(error)) {
+                if (!options.oneShot)
+                    options.store.clear();
+                persisted = null;
+                if (!wasRestored || !options.isInteractive || attempt > 0)
+                    throw error;
+                options.stderr.write(`${t().timetable.expiredRelogin}\n`);
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            await session?.close();
+        }
+    }
+    throw new AuthError('SESSION_EXPIRED', 'session', 'The campus login session has expired.');
+}
+export function writePrivateIcs(filePath, contents) {
+    const resolved = path.resolve(filePath);
+    const temporaryPath = path.join(path.dirname(resolved), `.${path.basename(resolved)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        fs.writeFileSync(temporaryPath, contents, {
+            encoding: 'utf8', flag: 'wx', mode: 0o600,
+        });
+        fs.renameSync(temporaryPath, resolved);
+        try {
+            fs.chmodSync(resolved, 0o600);
+        }
+        catch { /* Best effort on non-POSIX filesystems. */ }
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporaryPath);
+        }
+        catch { /* Rename or the original error is authoritative. */ }
+    }
+}
+function clientFor(session) {
+    return createNbtTimetableClient(session.timetableTransport, { baseUrl: JWXT_ORIGIN });
+}
+async function resolveWeekOneMonday(explicitValue, hasAuthoritativeDates, isInteractive) {
+    if (hasAuthoritativeDates)
+        return explicitValue;
+    if (explicitValue)
+        return explicitValue;
+    if (!isInteractive)
+        return undefined;
+    const value = await runTextInput({
+        message: t().timetable.weekOne,
+        placeholder: t().timetable.weekOneHint,
+        allowEmpty: false,
+    });
+    return value || undefined;
+}
+export async function runStudentTimetableCommand(subcommandValue, options) {
+    const subcommand = (subcommandValue ?? 'export').toLowerCase();
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const isInteractive = options.isInteractive ?? (!!process.stdin.isTTY && !!process.stdout.isTTY);
+    const store = options.store ?? createSessionStore();
+    const oneShot = options.flags.has('--one-shot') || options.flags.has('--no-save');
+    const trans = t().timetable;
+    if (!['login', 'logout', 'status', 'terms', 'export'].includes(subcommand)) {
+        stderr.write(`${trans.unknownCommand}\n`);
+        return 1;
+    }
+    const commonFlags = new Set(['--plain', '--one-shot', '--no-save']);
+    const allowedFlags = subcommand === 'export'
+        ? [...commonFlags, '--term=', '--output=', '--week-one=']
+        : subcommand === 'logout'
+            ? ['--plain']
+            : [...commonFlags];
+    const invalidFlag = [...options.flags].find((flag) => !allowedFlags.some((allowed) => (allowed.endsWith('=') ? flag.startsWith(allowed) : flag === allowed)));
+    if (invalidFlag) {
+        stderr.write(`${fmt(trans.invalidOption, { flag: invalidFlag })}\n`);
+        return 1;
+    }
+    try {
+        if (subcommand === 'logout') {
+            store.clear();
+            clearScheduleCache();
+            stdout.write(`${trans.loggedOut}\n`);
+            return 0;
+        }
+        if (subcommand === 'status') {
+            const persisted = oneShot ? null : store.load();
+            stdout.write(persisted
+                ? `${fmt(trans.savedStatus, { account: persisted.accountHint ? ` (${persisted.accountHint})` : '' })}\n`
+                : `${trans.noSavedStatus}\n`);
+            return persisted ? 0 : 1;
+        }
+        if (subcommand === 'login') {
+            const session = await interactiveLogin(isInteractive);
+            try {
+                if (!oneShot)
+                    store.save(await session.snapshot());
+                stdout.write(`${oneShot ? trans.loginOneShot : trans.loginSaved}\n`);
+            }
+            finally {
+                await session.close();
+            }
+            return 0;
+        }
+        return await withAuthenticatedSession(async (session) => {
+            const client = clientFor(session);
+            const catalog = await client.listTerms();
+            if (subcommand === 'terms') {
+                stdout.write(`${trans.candidateTerms}\n`);
+                for (const term of relevantTerms(catalog)) {
+                    stdout.write(`${term.current ? '*' : ' '} ${term.academicYear}:${term.semester}  ${term.academicYearLabel} ${displaySemesterLabel(term)}\n`);
+                }
+                return 0;
+            }
+            const selected = resolveTerm(catalog, flagValue(options.flags, '--term='));
+            const timetable = await client.fetchTerm(selected);
+            const output = flagValue(options.flags, '--output=')
+                || `timetable-${selected.academicYear}-${selected.semester}.ics`;
+            const weekOneMonday = await resolveWeekOneMonday(flagValue(options.flags, '--week-one='), timetable.calendarDays.length > 0, isInteractive);
+            const ics = timetableToIcs(timetable, {
+                weekOneMonday,
+                calendarName: fmt(trans.calendarName, {
+                    year: selected.academicYearLabel,
+                    semester: displaySemesterLabel(selected),
+                }),
+            });
+            writePrivateIcs(output, ics);
+            stdout.write(`${fmt(trans.exported, {
+                count: timetable.meetings.length,
+                file: path.resolve(output),
+            })}\n`);
+            const actionableWarnings = timetable.warnings.filter((warning) => warning.code !== 'CALENDAR_DATES_UNAVAILABLE' || !weekOneMonday);
+            if (actionableWarnings.length > 0) {
+                stderr.write(`${fmt(trans.warnings, { count: actionableWarnings.length })}\n`);
+            }
+            if (timetable.unresolvedItems.length > 0) {
+                stderr.write(`${fmt(trans.unresolvedPractice, { count: timetable.unresolvedItems.length })}\n`);
+            }
+            return 0;
+        }, { oneShot, isInteractive, store, stderr });
+    }
+    catch (error) {
+        if (!isInteractive && error instanceof AuthError && error.code === 'INVALID_CREDENTIALS') {
+            stderr.write(`${trans.noSession}\n`);
+            return 2;
+        }
+        stderr.write(`${safeMessage(error)}\n`);
+        return 1;
+    }
+}
+export async function showStudentTimetableMenu() {
+    while (true) {
+        const trans = t();
+        const footer = `${glyph.updown()} ${trans.menu.hintMove}   ${glyph.enter()} ${trans.menu.hintOpen}   q ${trans.menu.hintQuit}`;
+        const action = await runMenu({
+            title: trans.timetable.menuTitle,
+            options: [
+                { value: 'export', label: trans.timetable.actionExport },
+                { value: 'terms', label: trans.timetable.actionTerms },
+                { value: 'status', label: trans.timetable.actionStatus },
+                { value: 'login', label: trans.timetable.actionLogin },
+                { value: 'logout', label: trans.timetable.actionLogout },
+            ],
+            footer,
+        });
+        if (action === null)
+            return;
+        const flags = new Set();
+        if (action === 'export') {
+            const term = await runTextInput({
+                message: trans.timetable.termPrompt,
+                placeholder: trans.timetable.termPromptHint,
+            });
+            if (term === null)
+                continue;
+            if (term.trim())
+                flags.add(`--term=${term.trim()}`);
+        }
+        await runStudentTimetableCommand(action, {
+            flags,
+            isInteractive: true,
+        });
+    }
+}

package/dist/features/theme.js

@@ -1,6 +1,3 @@
-/**
- * Theme CLI command handler (non-interactive)
- */
 import { applyColorModePreference, loadPreferences, resetPreferences, setColorMode, setIconMode, } from '../config/preferences.js';
 import { resetIconCache } from '../core/icons.js';
 import { t } from '../i18n/index.js';

package/dist/features/update.js

@@ -1,24 +1,22 @@
-/**
- * Version update checker
- * Non-blocking check against npm registry for newer versions.
- */
 import chalk from 'chalk';
 import { APP_INFO } from '../config/data.js';
 import { t, fmt } from '../i18n/index.js';
 const NPM_REGISTRY_URL = `https://registry.npmjs.org/@nbtca/prompt/latest`;
 /**
  * Fetch latest version from npm registry.
- * Returns null on any failure (network, timeout, parse).
+ * Returns null on any failure (network, timeout, parse, or `signal` aborting
+ * the request — e.g. the caller quit before this settled).
  */
-async function fetchLatestVersion() {
+async function fetchLatestVersion(signal) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const onExternalAbort = () => controller.abort();
+    signal?.addEventListener('abort', onExternalAbort);
     try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3000);
         const res = await fetch(NPM_REGISTRY_URL, {
             signal: controller.signal,
             headers: { 'Accept': 'application/json' },
         });
-        clearTimeout(timeout);
         if (!res.ok)
             return null;
         const data = (await res.json());
@@ -27,10 +25,11 @@ async function fetchLatestVersion() {
     catch {
         return null;
     }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener('abort', onExternalAbort);
+    }
 }
-/**
- * Compare semver strings. Returns true if remote > local.
- */
 function isNewer(local, remote) {
     const parse = (v) => v.split('.').map(Number);
     const l = parse(local);
@@ -45,18 +44,17 @@ function isNewer(local, remote) {
 }
 /**
  * Non-blocking update check for TUI startup.
- * Resolves to a notification string or null.
+ * Resolves to a notification string or null. Pass `signal` so a caller that
+ * quits before this settles can cancel the in-flight request instead of
+ * leaving it to hold the process open.
  */
-export async function checkForUpdate() {
-    const latest = await fetchLatestVersion();
+export async function checkForUpdate(signal) {
+    const latest = await fetchLatestVersion(signal);
     if (!latest || !isNewer(APP_INFO.version, latest))
         return null;
     const trans = t();
     return `${fmt(trans.update.available, { latest, current: APP_INFO.version })}  ${chalk.dim(trans.update.command)}`;
 }
-/**
- * Explicit update check command (nbtca update).
- */
 export async function runUpdateCheck() {
     const trans = t();
     const latest = await fetchLatestVersion();

package/dist/i18n/index.js

@@ -1,7 +1,3 @@
-/**
- * Internationalization (i18n) System
- * Multi-language support for the application
- */
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -9,25 +5,13 @@ import { dirname } from 'path';
 import { getConfigDir, getWritableConfigDir } from '../config/paths.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-/**
- * Language configuration
- */
-let currentLanguage = 'zh'; // Default to Chinese
-/**
- * Get language configuration file path (read, with legacy fallback)
- */
+let currentLanguage = 'zh';
 function getLanguageConfigPath() {
     return path.join(getConfigDir(), 'language.json');
 }
-/**
- * Get writable language configuration file path (XDG, creates dir)
- */
 function getWritableLanguageConfigPath() {
     return path.join(getWritableConfigDir(), 'language.json');
 }
-/**
- * Load language preference from config file
- */
 export function loadLanguagePreference() {
     try {
         const configPath = getLanguageConfigPath();
@@ -36,61 +20,39 @@ export function loadLanguagePreference() {
             currentLanguage = config.language;
         }
     }
-    catch {
-        // If loading fails (file missing or invalid), use default (Chinese)
-    }
+    catch { }
     return currentLanguage;
 }
-/**
- * Save language preference to config file
- */
 export function saveLanguagePreference(language) {
+    setLanguage(language);
     try {
         const configPath = getWritableLanguageConfigPath();
         fs.writeFileSync(configPath, JSON.stringify({ language }, null, 2));
-        currentLanguage = language;
         return true;
     }
     catch {
         return false;
     }
 }
-/**
- * Get current language
- */
 export function getCurrentLanguage() {
     return currentLanguage;
 }
-/**
- * Set current language
- */
 export function setLanguage(language) {
     currentLanguage = language;
-    return saveLanguagePreference(language);
 }
-/**
- * Load translation file
- */
 function loadTranslations(language) {
     try {
         const translationPath = path.join(__dirname, 'locales', `${language}.json`);
         const content = fs.readFileSync(translationPath, 'utf-8');
         return JSON.parse(content);
     }
-    catch (err) {
-        // Fallback to Chinese if loading fails
+    catch {
         const fallbackPath = path.join(__dirname, 'locales', 'zh.json');
         const content = fs.readFileSync(fallbackPath, 'utf-8');
         return JSON.parse(content);
     }
 }
-/**
- * Translation cache
- */
-let translationsCache = new Map();
-/**
- * Get translations for current language
- */
+const translationsCache = new Map();
 export function t() {
     if (!translationsCache.has(currentLanguage)) {
         translationsCache.set(currentLanguage, loadTranslations(currentLanguage));
@@ -103,11 +65,7 @@ export function fmt(template, vars) {
         return val !== undefined ? String(val) : `{${key}}`;
     });
 }
-/**
- * Clear translation cache (useful when switching languages)
- */
 export function clearTranslationCache() {
     translationsCache.clear();
 }
-// Initialize language preference on module load
 loadLanguagePreference();