@nbtca/prompt 1.3.2 → 1.4.1

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/update.js

@@ -8,17 +8,19 @@ 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,6 +29,10 @@ async function fetchLatestVersion() {
     catch {
         return null;
     }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener('abort', onExternalAbort);
+    }
 }
 /**
  * Compare semver strings. Returns true if remote > local.
@@ -45,10 +51,12 @@ 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();

package/dist/i18n/locales/en.json

@@ -8,7 +8,9 @@
     "error": "Error",
     "success": "Success",
     "goodbye": "Goodbye!",
-    "current": "current"
+    "current": "current",
+    "moreAbove": "{count} more above",
+    "moreBelow": "{count} more below"
   },
   "menu": {
     "events": "Events",
@@ -17,11 +19,16 @@
     "docsDesc": "Knowledge base",
     "status": "Status",
     "statusDesc": "Online status",
+    "timetable": "My Timetable",
+    "timetableDesc": "Sign in to JWXT, choose a term and export ICS",
     "links": "Links",
     "linksDesc": "website · GitHub · roadmap",
     "settings": "Settings",
     "settingsDesc": "language · theme · about",
-    "chooseAction": "nbtca"
+    "chooseAction": "nbtca",
+    "hintMove": "move",
+    "hintOpen": "open",
+    "hintQuit": "quit"
   },
   "about": {
     "title": "About",
@@ -58,18 +65,34 @@
     "pastEvents": "Past Events",
     "pastEventsDesc": "Recent activity history",
     "noPastEvents": "No past events in the last 30 days",
-    "viewPastDetail": "Select an event for details:"
+    "viewPastDetail": "Select an event for details:",
+    "next": "Next",
+    "recentActivity": "Recent",
+    "inPrefix": "in",
+    "startingNow": "starting now",
+    "thisWeek": "This Week",
+    "thisMonth": "This Month",
+    "search": "Search",
+    "searchPrompt": "Search events",
+    "searchPlaceholder": "keyword…",
+    "searchNoResults": "No matching events",
+    "exportIcs": "Export .ics",
+    "exportSuccess": "Saved",
+    "exportError": "Could not write the .ics file",
+    "recurringLabel": "recurring"
   },
   "docs": {
     "loading": "Loading documentation list...",
     "loadingDir": "Loading directory",
-    "categoryTutorial": "Tutorials",
+    "categoryAbout": "About NBTCA",
+    "categoryGuide": "Guide",
     "categoryRepairLogs": "Repair Logs",
     "categoryEvents": "Event Docs",
-    "categoryProcess": "Process",
+    "categoryConcepts": "Reference",
     "categoryRepair": "Repair",
     "categoryArchived": "Archived",
     "categoryReadme": "Project README",
+    "overviewLabel": "Overview",
     "chooseCategory": "Docs",
     "refreshCache": "Refresh cache",
     "cacheCleared": "Documentation cache cleared",
@@ -106,7 +129,10 @@
     "searching": "Searching documents...",
     "searchResults": "results found",
     "searchNoResults": "No documents match your search",
-    "loadingFile": "Loading"
+    "loadingFile": "Loading",
+    "readerLinksTitle": "Jump to",
+    "readerLinksHint": "links",
+    "readerNoLinks": "This page has no links to other docs"
   },
   "links": {
     "choose": "Links",
@@ -150,6 +176,114 @@
     "watchJsonConflict": "--watch cannot be used with --json.",
     "intervalNeedsWatch": "--interval requires --watch."
   },
+  "timetable": {
+    "menuTitle": "My Timetable",
+    "actionExport": "Export ICS",
+    "actionTerms": "List terms",
+    "actionLogin": "Sign in or refresh session",
+    "actionLogout": "Sign out",
+    "actionStatus": "Login status",
+    "termPrompt": "Term code",
+    "termPromptHint": "Leave empty for current, for example 2026:3",
+    "unknownCommand": "Unknown timetable command. Use login, logout, status, terms, or export.",
+    "loggedOut": "Local login session cleared.",
+    "savedStatus": "A login session is saved{account}.",
+    "noSavedStatus": "No login session is saved.",
+    "loginSaved": "Login verified and session saved.",
+    "loginOneShot": "Login verified; no session was saved.",
+    "loginWillSave": "A local bearer session will be saved after success; use --one-shot to avoid this.",
+    "sessionRefreshFailed": "The operation completed, but the saved session expiry could not be refreshed.",
+    "candidateTerms": "Candidate JWXT terms (not every term necessarily has a personal timetable):",
+    "semesterNumber": "Semester {number}",
+    "expiredRelogin": "The saved login session expired. Please sign in again.",
+    "studentId": "Student id",
+    "studentIdHint": "Sent only to the school authentication service",
+    "password": "Password",
+    "passwordHint": "Input is masked and never saved",
+    "weekOne": "First teaching Monday (YYYY-MM-DD)",
+    "weekOneHint": "JWXT returned no start date; confirm it against the official calendar",
+    "exported": "Exported {count} timetable meetings to {file}",
+    "warnings": "{count} record(s) could not be fully resolved; verify the imported calendar.",
+    "unresolvedPractice": "{count} practice record(s) lacked a confirmed weekday/period and were not added to the ICS.",
+    "calendarName": "{year} {semester} Timetable",
+    "invalidOption": "Option {flag} is not valid for this timetable command.",
+    "invalidArguments": "Too many timetable arguments. Use login, logout, status, terms, or export.",
+    "noSession": "No usable login session. Run `nbtca schedule login` in an interactive terminal.",
+    "invalidCredentials": "The student id or password was rejected.",
+    "accountLocked": "The account is temporarily locked. Try later or use the official school page.",
+    "accountInactive": "The account is inactive. Activate it on the official school page first.",
+    "challenge": "The school requires a slider or browser challenge; CLI login stopped safely.",
+    "sessionExpired": "The login session expired. Please sign in again.",
+    "timeout": "The school service timed out.",
+    "network": "Could not connect to the school service.",
+    "untrustedUrl": "The school returned an unapproved redirect; the request stopped safely.",
+    "httpError": "The school login service returned an error status.",
+    "loginChanged": "The school login page changed; credentials were not submitted.",
+    "unexpectedResponse": "A valid JWXT session could not be confirmed after login.",
+    "missingDates": "JWXT returned no calendar dates. Provide --week-one=YYYY-MM-DD.",
+    "missingPeriod": "JWXT returned no usable period times, so export cannot continue safely.",
+    "termMismatch": "JWXT returned a different academic term. Try again.",
+    "invalidData": "The timetable response format is not currently recognized.",
+    "unknownTerm": "Unknown term. Run `nbtca schedule terms` first.",
+    "noTerms": "JWXT returned no available terms.",
+    "currentTermUnknown": "JWXT did not identify one current term. Choose one with --term=year:code.",
+    "genericError": "The timetable operation failed.",
+    "hubToday": "Today",
+    "hubWeek": "This week",
+    "hubSwitchTerm": "Switch term",
+    "hubExport": "Export .ics",
+    "hubLogout": "Log out",
+    "hubUnresolved": "Needs attention",
+    "unresolvedTitle": "Needs attention",
+    "unresolvedEmpty": "Nothing needs attention",
+    "unresolvedUnknownItem": "Unnamed item",
+    "nextClass": "Next",
+    "noClassToday": "No classes today",
+    "noNextClass": "No upcoming classes",
+    "nowLabel": "now",
+    "weekLabel": "Week",
+    "promptWeekOne": "First-week Monday (YYYY-MM-DD)",
+    "menuEntry": "Schedule",
+    "semester1": "Term 1",
+    "semester2": "Term 2",
+    "weekLabel2": "Week {week}",
+    "academicYearSuffix": "{year}",
+    "onBreak": "On break · {title}",
+    "publicUnavailable": "Academic calendar not available yet",
+    "daysUntilBreak": "{days} days until {title}",
+    "publicLoginAction": "Log in to see my timetable",
+    "publicLoginHint": "Log in to export your timetable (.ics)",
+    "weekOneAutoFailed": "Couldn't infer the term's first week automatically — please confirm it once",
+    "weekdayMon": "Mon",
+    "weekdayTue": "Tue",
+    "weekdayWed": "Wed",
+    "weekdayThu": "Thu",
+    "weekdayFri": "Fri",
+    "weekdaySat": "Sat",
+    "weekdaySun": "Sun",
+    "todayHeading": "Today · {weekday} · Week {week}",
+    "classDone": "Done",
+    "classLive": "In progress",
+    "minutesRemaining": "{minutes}m left",
+    "timelineEnd": "—",
+    "termNotStarted": "Term hasn't started yet",
+    "termStartsIn": "Classes begin {date} · {days} days to go",
+    "hubTermDensity": "Term density",
+    "termDensityTitle": "Term density",
+    "termDensityThisWeek": "This week",
+    "weekOverviewTitle": "Week overview",
+    "weekAheadClasses": "Classes",
+    "weekAheadBusy": "Busy",
+    "weekAheadFree": "Free",
+    "weekAheadNone": "N/A",
+    "termPreviewWeek": "Week 1 preview",
+    "hubFullGrid": "Full grid",
+    "detailTime": "Time",
+    "detailLocation": "Location",
+    "detailTeacher": "Teacher",
+    "detailWeeks": "Weeks",
+    "teacherSeparator": ", "
+  },
   "theme": {
     "current": "Current theme settings",
     "chooseAction": "Settings",
@@ -197,11 +331,15 @@
     "cmdTheme": "View or set theme",
     "cmdLang": "Set language",
     "cmdUpdate": "Check for updates",
+    "cmdSchedule": "Personal timetable login, term lookup and ICS export",
     "flagVersion": "Show version",
     "flagHelp": "Show help",
     "flagOpen": "Open in browser (URL commands)",
     "flagJson": "JSON output (events, status)",
     "flagToday": "Today only (events)",
+    "flagWeek": "Events this week",
+    "flagMonth": "Events this month",
+    "flagSearch": "Filter events by keyword",
     "flagNext": "Limit to next N (events)",
     "flagWatch": "Live refresh (status)",
     "flagInterval": "Refresh interval (status --watch)",
@@ -210,6 +348,11 @@
     "flagHeatmap": "Activity heatmap (events)",
     "flagPlain": "Disable colors",
     "flagNoLogo": "Skip logo",
+    "flagOneShot": "Do not read or save a login session",
+    "flagNoSave": "Alias for --one-shot",
+    "flagTerm": "Select a term (for example 2026:3)",
+    "flagOutput": "ICS output path",
+    "flagWeekOne": "First teaching Monday when JWXT has no dates",
     "unknownCommand": "Unknown command: {command}",
     "unknownCommandHint": "Run `nbtca --help` to see available commands.",
     "unknownFlag": "Unknown flag: {flag}",