@nbtca/prompt 1.4.2 → 1.5.1

package/dist/features/student-timetable.js

@@ -1,48 +1,27 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { createNbtTimetableClient, timetableToIcs, TimetableError, } from '@nbtca/nbtcal/timetable';
+import { createNbtTimetableClient, findAcademicTerm, 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 { loginWithStudentPassword, restoreNbtSession, } from '../auth/nbt-auth.js';
 import { createSessionStore } from '../auth/session-store.js';
-import { clearScheduleCache } from './schedule-store.js';
+import { clearScheduleCache, termKey } from './schedule-store.js';
 import { fmt, t } from '../i18n/index.js';
+import { sanitizeAcademicTerm, sanitizeTimetable } from './timetable-sanitize.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;
-    }
+    const selected = findAcademicTerm(catalog, selector);
+    if (selected)
+        return selected;
+    if (!selector?.trim())
+        throw new Error('The current academic term could not be determined.');
     throw new Error('Unknown academic term. Run `nbtca schedule terms` first.');
 }
 export function relevantTerms(catalog) {
@@ -65,41 +44,66 @@ function displaySemesterLabel(term) {
         : term.semesterLabel;
 }
 export function isSessionExpired(error) {
-    return (error instanceof AuthError && error.code === 'SESSION_EXPIRED') || (error instanceof TimetableError && error.code === 'SESSION_EXPIRED');
+    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;
+            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;
+            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;
+            case 'HTTP_ERROR':
+                return trans.httpError;
+            case 'NETWORK_ERROR':
+                return trans.network;
+            case 'INVALID_TERM_CATALOG':
+            case 'INVALID_TIMETABLE':
+                return trans.invalidData;
         }
     }
-    if (error instanceof Error && error.message === 'Unknown academic term. Run `nbtca schedule terms` first.') {
+    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.') {
+    if (error instanceof Error &&
+        error.message === 'The current academic term could not be determined.') {
         return trans.currentTermUnknown;
     }
     return trans.genericError;
@@ -109,11 +113,10 @@ async function interactiveLogin(isInteractive) {
     if (!isInteractive) {
         throw new AuthError('INVALID_CREDENTIALS', 'credentials', 'Interactive login requires a terminal.');
     }
-    const username = await runSecretInput({
+    const username = await runTextInput({
         message: trans.studentId,
         placeholder: trans.studentIdHint,
         allowEmpty: false,
-        mask: '•',
     });
     if (!username)
         throw new AuthError('INVALID_CREDENTIALS', 'credentials', 'Student id is required.');
@@ -183,19 +186,25 @@ export function writePrivateIcs(filePath, contents) {
     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,
+            encoding: 'utf8',
+            flag: 'wx',
+            mode: 0o600,
         });
         fs.renameSync(temporaryPath, resolved);
         try {
             fs.chmodSync(resolved, 0o600);
         }
-        catch { /* Best effort on non-POSIX filesystems. */ }
+        catch {
+            /* Best effort on non-POSIX filesystems. */
+        }
     }
     finally {
         try {
             fs.unlinkSync(temporaryPath);
         }
-        catch { /* Rename or the original error is authoritative. */ }
+        catch {
+            /* Rename or the original error is authoritative. */
+        }
     }
 }
 function clientFor(session) {
@@ -213,13 +222,13 @@ async function resolveWeekOneMonday(explicitValue, hasAuthoritativeDates, isInte
         placeholder: t().timetable.weekOneHint,
         allowEmpty: false,
     });
-    return value || undefined;
+    return value === null || value === '' ? undefined : value;
 }
 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 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;
@@ -233,7 +242,7 @@ export async function runStudentTimetableCommand(subcommandValue, options) {
         : subcommand === 'logout'
             ? ['--plain']
             : [...commonFlags];
-    const invalidFlag = [...options.flags].find((flag) => !allowedFlags.some((allowed) => (allowed.endsWith('=') ? flag.startsWith(allowed) : flag === allowed)));
+    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;
@@ -266,7 +275,7 @@ export async function runStudentTimetableCommand(subcommandValue, options) {
         }
         return await withAuthenticatedSession(async (session) => {
             const client = clientFor(session);
-            const catalog = await client.listTerms();
+            const catalog = (await client.listTerms()).map(sanitizeAcademicTerm);
             if (subcommand === 'terms') {
                 stdout.write(`${trans.candidateTerms}\n`);
                 for (const term of relevantTerms(catalog)) {
@@ -275,12 +284,14 @@ export async function runStudentTimetableCommand(subcommandValue, options) {
                 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 timetable = sanitizeTimetable(await client.fetchTerm(selected));
+            const outputFlag = flagValue(options.flags, '--output=');
+            const output = outputFlag === undefined || outputFlag === ''
+                ? `timetable-${termKey(selected)}.ics`
+                : outputFlag;
             const weekOneMonday = await resolveWeekOneMonday(flagValue(options.flags, '--week-one='), timetable.calendarDays.length > 0, isInteractive);
             const ics = timetableToIcs(timetable, {
-                weekOneMonday,
+                ...(weekOneMonday === undefined ? {} : { weekOneMonday }),
                 calendarName: fmt(trans.calendarName, {
                     year: selected.academicYearLabel,
                     semester: displaySemesterLabel(selected),
@@ -310,37 +321,3 @@ export async function runStudentTimetableCommand(subcommandValue, options) {
         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,5 +1,6 @@
 import { applyColorModePreference, loadPreferences, resetPreferences, setColorMode, setIconMode, } from '../config/preferences.js';
 import { resetIconCache } from '../core/icons.js';
+import { resetCapabilities } from '../core/capabilities.js';
 import { t } from '../i18n/index.js';
 const ICON_MODES = ['auto', 'ascii', 'unicode'];
 const COLOR_MODES = ['auto', 'on', 'off'];
@@ -8,7 +9,7 @@ function formatThemeSummary() {
     const prefs = loadPreferences();
     return `${trans.theme.iconMode}: ${prefs.iconMode}, ${trans.theme.colorMode}: ${prefs.colorMode}`;
 }
-export function runThemeCommand(args) {
+export function runThemeCommand(args, options = {}) {
     const trans = t();
     const [scope, value] = args;
     if (!scope) {
@@ -17,26 +18,29 @@ export function runThemeCommand(args) {
     if (scope === 'reset') {
         const saved = resetPreferences();
         resetIconCache();
-        applyColorModePreference(false);
+        applyColorModePreference(options.forcePlain === true);
+        resetCapabilities();
         const message = saved ? trans.theme.reset : trans.theme.resetSessionOnly;
         return { ok: true, message };
     }
     if (scope === 'icon') {
-        const mode = (value || '').toLowerCase();
+        const mode = (value?.toLowerCase() ?? '');
         if (!ICON_MODES.includes(mode)) {
             return { ok: false, message: `${trans.theme.invalidValue} auto, ascii, unicode` };
         }
         const saved = setIconMode(mode);
         resetIconCache();
+        resetCapabilities();
         return { ok: true, message: saved ? trans.theme.updated : trans.theme.updatedSessionOnly };
     }
     if (scope === 'color') {
-        const mode = (value || '').toLowerCase();
+        const mode = (value?.toLowerCase() ?? '');
         if (!COLOR_MODES.includes(mode)) {
             return { ok: false, message: `${trans.theme.invalidValue} auto, on, off` };
         }
         const saved = setColorMode(mode);
-        applyColorModePreference(false);
+        applyColorModePreference(options.forcePlain === true);
+        resetCapabilities();
         return { ok: true, message: saved ? trans.theme.updated : trans.theme.updatedSessionOnly };
     }
     return { ok: false, message: trans.theme.usage };

package/dist/features/timetable-sanitize.js

@@ -0,0 +1,40 @@
+import { sanitizeTerminalLine } from '../core/text.js';
+import { termKey } from './schedule-store.js';
+export function sanitizeAcademicTerm(term) {
+    termKey(term);
+    return {
+        ...term,
+        academicYearLabel: sanitizeTerminalLine(term.academicYearLabel),
+        semesterLabel: sanitizeTerminalLine(term.semesterLabel),
+    };
+}
+function sanitizeUnresolvedItem(item) {
+    return {
+        ...item,
+        sourceFields: Object.fromEntries(Object.entries(item.sourceFields).map(([key, value]) => [key, sanitizeTerminalLine(value)])),
+    };
+}
+export function sanitizeTimetable(timetable) {
+    const untimedCourses = timetable.untimedCourses?.map((course) => ({
+        ...course,
+        courseName: sanitizeTerminalLine(course.courseName),
+        teacherNames: course.teacherNames.map(sanitizeTerminalLine),
+        campus: course.campus === null ? null : sanitizeTerminalLine(course.campus),
+        location: course.location === null ? null : sanitizeTerminalLine(course.location),
+    }));
+    return {
+        ...timetable,
+        meetings: timetable.meetings.map((meeting) => ({
+            ...meeting,
+            courseName: sanitizeTerminalLine(meeting.courseName),
+            teacherNames: meeting.teacherNames.map(sanitizeTerminalLine),
+            location: meeting.location === null ? null : sanitizeTerminalLine(meeting.location),
+        })),
+        ...(untimedCourses === undefined ? {} : { untimedCourses }),
+        unresolvedItems: timetable.unresolvedItems.map(sanitizeUnresolvedItem),
+        periods: timetable.periods.map((period) => ({
+            ...period,
+            label: period.label === null ? null : sanitizeTerminalLine(period.label),
+        })),
+    };
+}

package/dist/features/update.js

@@ -2,32 +2,27 @@ 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, or `signal` aborting
- * the request — e.g. the caller quit before this settled).
- */
-async function fetchLatestVersion(signal) {
+async function fetchLatestVersion() {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3000);
-    const onExternalAbort = () => controller.abort();
-    signal?.addEventListener('abort', onExternalAbort);
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, 3000);
+    timeout.unref();
     try {
         const res = await fetch(NPM_REGISTRY_URL, {
             signal: controller.signal,
-            headers: { 'Accept': 'application/json' },
+            headers: { Accept: 'application/json' },
         });
         if (!res.ok)
             return null;
         const data = (await res.json());
-        return data.version ?? null;
+        return typeof data.version === 'string' ? data.version : null;
     }
     catch {
         return null;
     }
     finally {
         clearTimeout(timeout);
-        signal?.removeEventListener('abort', onExternalAbort);
     }
 }
 function isNewer(local, remote) {
@@ -42,31 +37,19 @@ function isNewer(local, remote) {
     }
     return false;
 }
-/**
- * Non-blocking update check for TUI startup.
- * 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(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)}`;
-}
 export async function runUpdateCheck() {
     const trans = t();
     const latest = await fetchLatestVersion();
     if (!latest) {
-        console.log(chalk.yellow(trans.update.checkFailed));
-        return;
+        console.error(chalk.yellow(trans.update.checkFailed));
+        return false;
     }
     if (isNewer(APP_INFO.version, latest)) {
-        console.log(chalk.yellow(`${fmt(trans.update.available, { latest, current: APP_INFO.version })}`));
+        console.log(chalk.yellow(fmt(trans.update.available, { latest, current: APP_INFO.version })));
         console.log(chalk.dim(trans.update.command));
     }
     else {
-        console.log(chalk.green(`${fmt(trans.update.upToDate, { version: APP_INFO.version })}`));
+        console.log(chalk.green(fmt(trans.update.upToDate, { version: APP_INFO.version })));
     }
+    return true;
 }

package/dist/i18n/index.js

@@ -1,10 +1,68 @@
 import fs from 'fs';
-import path from 'path';
+import path, { dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 import { getConfigDir, getWritableConfigDir } from '../config/paths.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const unsafeTranslationKeys = new Set(['__proto__', 'constructor', 'prototype']);
+function childPath(parent, key) {
+    return `${parent}.${key}`;
+}
+function assertTranslationNode(value, pathName) {
+    if (typeof value === 'string')
+        return;
+    assertTranslationObject(value, pathName);
+}
+function assertTranslationObject(value, pathName) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError(`${pathName} must be a plain object`);
+    }
+    const prototype = Reflect.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`${pathName} must be a plain object`);
+    }
+    for (const [key, child] of Object.entries(value)) {
+        const currentPath = childPath(pathName, key);
+        if (unsafeTranslationKeys.has(key)) {
+            throw new TypeError(`${currentPath} uses an unsafe key`);
+        }
+        assertTranslationNode(child, currentPath);
+    }
+}
+function assertMatchingTranslationShape(candidate, reference, pathName) {
+    for (const key of Object.keys(candidate)) {
+        if (!Object.hasOwn(reference, key)) {
+            throw new TypeError(`${childPath(pathName, key)} is not in the reference translation`);
+        }
+    }
+    for (const key of Object.keys(reference)) {
+        const currentPath = childPath(pathName, key);
+        if (!Object.hasOwn(candidate, key)) {
+            throw new TypeError(`${currentPath} is missing`);
+        }
+        const candidateNode = candidate[key];
+        const referenceNode = reference[key];
+        if (candidateNode === undefined || referenceNode === undefined) {
+            throw new TypeError(`${currentPath} is missing`);
+        }
+        if (typeof candidateNode !== typeof referenceNode) {
+            throw new TypeError(`${currentPath} has a mismatched leaf type`);
+        }
+        if (typeof candidateNode !== 'string' && typeof referenceNode !== 'string') {
+            assertMatchingTranslationShape(candidateNode, referenceNode, currentPath);
+        }
+    }
+}
+export function validateTranslationShape(candidate, reference) {
+    assertTranslationObject(candidate, 'translations');
+    if (reference === undefined)
+        return;
+    assertTranslationObject(reference, 'reference');
+    assertMatchingTranslationShape(candidate, reference, 'translations');
+}
+function assertTranslations(candidate, reference) {
+    validateTranslationShape(candidate, reference);
+}
 let currentLanguage = 'zh';
 function getLanguageConfigPath() {
     return path.join(getConfigDir(), 'language.json');
@@ -16,8 +74,11 @@ export function loadLanguagePreference() {
     try {
         const configPath = getLanguageConfigPath();
         const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        if (config.language === 'zh' || config.language === 'en') {
-            currentLanguage = config.language;
+        if (typeof config === 'object' && config !== null && 'language' in config) {
+            const language = config.language;
+            if (language === 'zh' || language === 'en') {
+                currentLanguage = language;
+            }
         }
     }
     catch { }
@@ -40,24 +101,27 @@ export function getCurrentLanguage() {
 export function setLanguage(language) {
     currentLanguage = language;
 }
-function loadTranslations(language) {
-    try {
-        const translationPath = path.join(__dirname, 'locales', `${language}.json`);
-        const content = fs.readFileSync(translationPath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        const fallbackPath = path.join(__dirname, 'locales', 'zh.json');
-        const content = fs.readFileSync(fallbackPath, 'utf-8');
-        return JSON.parse(content);
-    }
+function parseTranslationFile(language) {
+    const translationPath = path.join(__dirname, 'locales', `${language}.json`);
+    const content = fs.readFileSync(translationPath, 'utf-8');
+    return JSON.parse(content);
+}
+function loadTranslations() {
+    const english = parseTranslationFile('en');
+    assertTranslations(english);
+    const chinese = parseTranslationFile('zh');
+    assertTranslations(chinese, english);
+    return { en: english, zh: chinese };
 }
 const translationsCache = new Map();
 export function t() {
-    if (!translationsCache.has(currentLanguage)) {
-        translationsCache.set(currentLanguage, loadTranslations(currentLanguage));
-    }
-    return translationsCache.get(currentLanguage);
+    const cached = translationsCache.get(currentLanguage);
+    if (cached !== undefined)
+        return cached;
+    const translations = loadTranslations();
+    translationsCache.set('en', translations.en);
+    translationsCache.set('zh', translations.zh);
+    return translations[currentLanguage];
 }
 export function fmt(template, vars) {
     return template.replace(/\{(\w+)\}/g, (_, key) => {

package/dist/i18n/locales/en.json

@@ -46,6 +46,7 @@
     "loading": "Loading event calendar...",
     "noEvents": "No upcoming events",
     "error": "Failed to load event calendar",
+    "stale": "offline, showing last known",
     "errorHint": "Please try again later or visit https://nbtca.space",
     "eventsFound": "events found",
     "dateTime": "Date & Time",
@@ -113,7 +114,6 @@
     "opening": "Opening browser...",
     "browserOpened": "Knowledge base opened in browser",
     "browserError": "Failed to open browser",
-    "browserErrorHint": "Please visit manually: https://docs.nbtca.space",
     "retry": "Retry?",
     "tocTitle": "Table of Contents",
     "tableHint": "diagrams and tables render better in browser",
@@ -124,7 +124,7 @@
     "githubTokenHint": "Tip: set GITHUB_TOKEN for a higher rate limit.",
     "fetchDirFailed": "Failed to fetch directory: {error}",
     "fetchFileFailed": "Failed to fetch file: {error}",
-    "searchPrompt": "Search documents by title:",
+    "searchPrompt": "Search documents:",
     "searchPlaceholder": "Enter keyword...",
     "searching": "Searching documents...",
     "searchResults": "results found",
@@ -142,12 +142,14 @@
     "repair": "Repair Service",
     "opening": "Opening...",
     "opened": "Opened in browser",
-    "error": "Failed to open browser"
+    "error": "Failed to open browser",
+    "openManually": "Open manually: {url}"
   },
   "status": {
     "checking": "Checking service status...",
     "summaryOk": "All services are healthy",
     "summaryFail": "Some services are unavailable",
+    "summaryIntranet": "Public services are healthy; intranet availability depends on your network",
     "service": "Service",
     "health": "Health",
     "code": "Code",
@@ -361,6 +363,9 @@
     "invalidFlagHint": "Run `nbtca --help` to see command usage.",
     "invalidLang": "Invalid language. Use `zh` or `en`.",
     "invalidNext": "Invalid --next value. Use --next=<number> (>= 1).",
+    "eventsHeatmapConflict": "--heatmap cannot be combined with --today, --week, --month, --next, or --search.",
+    "eventsRangeConflict": "Choose only one event range: --today, --week, or --month.",
+    "unexpectedArguments": "Unexpected arguments for {command}.",
     "requiresTty": "Interactive mode requires a TTY terminal.",
     "requiresTtyHint": "Use `nbtca --help` for command mode."
   }