@nbtca/prompt 1.0.23 → 1.0.24

package/dist/features/docs.js

@@ -7,11 +7,11 @@ import { marked } from 'marked';
 import TerminalRenderer from 'marked-terminal';
 import chalk from 'chalk';
 import open from 'open';
-import { select, isCancel, confirm } from '@clack/prompts';
+import { select, isCancel, confirm, text } from '@clack/prompts';
 import { error, warning, success, createSpinner } from '../core/ui.js';
 import { pickIcon } from '../core/icons.js';
 import { spawn, execFileSync } from 'child_process';
-import { URLS } from '../config/data.js';
+import { APP_INFO, GITHUB_REPO, URLS } from '../config/data.js';
 import { t } from '../i18n/index.js';
 function detectTerminalType() {
     const term = (process.env['TERM'] || '').toLowerCase();
@@ -38,8 +38,26 @@ function commandExists(cmd) {
         return false;
     }
 }
-const TERMINAL_TYPE = detectTerminalType();
-const HAS_GLOW = commandExists('glow');
+let _terminalType = null;
+function getTerminalType() {
+    if (_terminalType === null)
+        _terminalType = detectTerminalType();
+    return _terminalType;
+}
+let _hasGlow = null;
+function hasGlow() {
+    if (_hasGlow === null)
+        _hasGlow = commandExists('glow');
+    return _hasGlow;
+}
+let _markedConfigured = false;
+function ensureMarkedConfigured() {
+    if (_markedConfigured)
+        return;
+    _markedConfigured = true;
+    // @ts-ignore - marked v11 / marked-terminal v7 type incompatibility
+    marked.setOptions({ renderer: new TerminalRenderer(getRendererOptions(getTerminalType())) });
+}
 // ─── marked-terminal renderer ─────────────────────────────────────────────────
 function getRendererOptions(type) {
     // Cap at 80 columns — optimal prose reading width regardless of terminal size
@@ -82,10 +100,7 @@ function getRendererOptions(type) {
         }
     };
 }
-// @ts-ignore
-marked.setOptions({ renderer: new TerminalRenderer(getRendererOptions(TERMINAL_TYPE)) });
 // ─── GitHub data layer ────────────────────────────────────────────────────────
-const GITHUB_REPO = { owner: 'nbtca', repo: 'documents', branch: 'main' };
 const GITHUB_TOKEN = process.env['GITHUB_TOKEN'] || process.env['GH_TOKEN'];
 const SKIP_NAMES = new Set(['node_modules', 'package.json', 'pnpm-lock.yaml']);
 const DIR_CACHE_TTL_MS = 5 * 60 * 1000;
@@ -96,15 +111,13 @@ const fileCache = new Map();
 const renderCache = new Map();
 function getDocCategories() {
     const trans = t();
-    const withIcon = (unicodeIcon, asciiIcon, label) => `${pickIcon(unicodeIcon, asciiIcon)} ${label}`;
     return [
-        { name: withIcon('📖', '[DOC]', trans.docs.categoryTutorial), path: 'tutorial' },
-        { name: withIcon('🔧', '[LOG]', trans.docs.categoryRepairLogs), path: '维修日' },
-        { name: withIcon('🎉', '[EVT]', trans.docs.categoryEvents), path: '相关活动举办' },
-        { name: withIcon('📋', '[PROC]', trans.docs.categoryProcess), path: 'process' },
-        { name: withIcon('🛠', '[FIX]', trans.docs.categoryRepair), path: 'repair' },
-        { name: withIcon('📦', '[ARC]', trans.docs.categoryArchived), path: 'archived' },
-        { name: withIcon('📄', '[README]', trans.docs.categoryReadme), path: 'README.md' },
+        { name: trans.docs.categoryTutorial, path: 'tutorial' },
+        { name: trans.docs.categoryRepairLogs, path: '维修日' },
+        { name: trans.docs.categoryEvents, path: '相关活动举办' },
+        { name: trans.docs.categoryProcess, path: 'process' },
+        { name: trans.docs.categoryRepair, path: 'repair' },
+        { name: trans.docs.categoryArchived, path: 'archived' },
     ];
 }
 function getFreshCacheValue(cache, key) {
@@ -144,7 +157,7 @@ async function fetchGitHubDirectory(path = '', options = {}) {
     try {
         const headers = {
             'Accept': 'application/vnd.github.v3+json',
-            'User-Agent': 'NBTCA-CLI'
+            'User-Agent': `NBTCA-CLI/${APP_INFO.version}`
         };
         if (GITHUB_TOKEN)
             headers['Authorization'] = `Bearer ${GITHUB_TOKEN}`;
@@ -156,7 +169,7 @@ async function fetchGitHubDirectory(path = '', options = {}) {
             .map((item) => ({
             name: item.name,
             path: item.path,
-            type: item.type === 'dir' ? 'dir' : 'file',
+            type: (item.type === 'dir' ? 'dir' : 'file'),
             sha: item.sha
         }))
             .sort((a, b) => {
@@ -176,11 +189,12 @@ async function fetchGitHubDirectory(path = '', options = {}) {
         }
         const trans = t();
         const errorMessage = err instanceof Error ? err.message : String(err);
-        if (err.response?.status === 403) {
-            const rateLimitRemaining = err.response.headers['x-ratelimit-remaining'];
-            const rateLimitReset = err.response.headers['x-ratelimit-reset'];
-            if (rateLimitRemaining === '0') {
-                const resetDate = new Date(parseInt(rateLimitReset) * 1000);
+        const axiosErr = err;
+        if (axiosErr.response?.status === 403) {
+            const rateLimitRemaining = axiosErr.response.headers?.['x-ratelimit-remaining'];
+            const rateLimitReset = axiosErr.response.headers?.['x-ratelimit-reset'];
+            if (rateLimitRemaining === '0' && rateLimitReset) {
+                const resetDate = new Date(Number.parseInt(rateLimitReset, 10) * 1000);
                 throw new Error(`${trans.docs.githubRateLimited.replace('{time}', resetDate.toLocaleTimeString())}\n${trans.docs.githubTokenHint}`);
             }
             throw new Error(`${trans.docs.githubForbidden}\n${trans.docs.githubTokenHint}`);
@@ -197,7 +211,7 @@ async function fetchGitHubRawContent(path, options = {}) {
     }
     const url = `https://raw.githubusercontent.com/${GITHUB_REPO.owner}/${GITHUB_REPO.repo}/${GITHUB_REPO.branch}/${path}`;
     try {
-        const response = await axios.get(url, { timeout: 15000, headers: { 'User-Agent': 'NBTCA-CLI' } });
+        const response = await axios.get(url, { timeout: 15000, headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` } });
         const content = String(response.data);
         setCacheValue(fileCache, path, content, FILE_CACHE_TTL_MS);
         return { data: content, fromCache: false, staleFallback: false };
@@ -219,7 +233,7 @@ const CONTAINER_ICONS_ASCII = {
 const CONTAINER_ICONS_UNICODE = {
     info: 'ℹ️', tip: '💡', warning: '⚠️', danger: '🚨', details: '▶️'
 };
-function cleanMarkdownContent(content, type) {
+function cleanMarkdownContent(content, type = getTerminalType()) {
     let c = content;
     // 1. YAML frontmatter
     c = c.replace(/^---\n[\s\S]*?\n---\n?/m, '');
@@ -259,9 +273,17 @@ function cleanMarkdownContent(content, type) {
     c = c.replace(/\n{3,}/g, '\n\n');
     return c.trim();
 }
-function extractDocTitle(content) {
-    const match = content.match(/^#\s+(.+)$/m);
-    return match?.[1]?.trim() ?? null;
+function extractDocTitle(rawContent, cleanedContent) {
+    // 1. Try YAML frontmatter title: field (before it was stripped)
+    const fmMatch = rawContent.match(/^---\n[\s\S]*?\n---/m);
+    if (fmMatch) {
+        const titleMatch = fmMatch[0].match(/^title:\s*['"]?(.+?)['"]?\s*$/m);
+        if (titleMatch?.[1])
+            return titleMatch[1].trim();
+    }
+    // 2. Fallback to first # H1 heading in cleaned content
+    const h1Match = cleanedContent.match(/^#\s+(.+)$/m);
+    return h1Match?.[1]?.trim() ?? null;
 }
 /** Approximate reading time: ~200 words/min for technical Chinese/English prose. */
 function estimateReadTime(text) {
@@ -345,7 +367,7 @@ async function browseDirectory(dirPath = '') {
         const s = createSpinner(dirPath ? `${trans.docs.loadingDir}: ${dirPath}` : trans.docs.loading);
         const result = await fetchGitHubDirectory(dirPath);
         const items = result.data;
-        s.stop('');
+        s.stop(dirPath || trans.docs.chooseDoc);
         if (result.staleFallback) {
             warning(trans.docs.usingCachedData);
         }
@@ -354,15 +376,15 @@ async function browseDirectory(dirPath = '') {
             return;
         }
         const options = [
-            ...(dirPath ? [{ value: '__back__', label: chalk.gray(`${pickIcon('↑', '[..]')} ${trans.docs.upToParent}`) }] : []),
+            ...(dirPath ? [{ value: '__back__', label: chalk.dim(trans.docs.upToParent) }] : []),
             ...items.map(item => ({
                 value: item.path,
                 label: item.type === 'dir'
-                    ? chalk.cyan(`${pickIcon('📁', '[DIR]')} ${item.name}/`)
-                    : chalk.white(`${pickIcon('📄', '[MD]')} ${item.name}`),
-                hint: item.type === 'dir' ? 'dir' : '.md',
+                    ? chalk.cyan(`${item.name}/`)
+                    : item.name,
+                hint: item.type === 'dir' ? 'dir' : undefined,
             })),
-            { value: '__exit__', label: chalk.gray(`${pickIcon('✕', '[x]')} ${trans.docs.returnToMenu}`) },
+            { value: '__exit__', label: chalk.dim(trans.docs.returnToMenu) },
         ];
         const selected = await select({
             message: dirPath ? `${trans.docs.currentDir}: ${dirPath}` : trans.docs.chooseDoc,
@@ -387,7 +409,8 @@ async function browseDirectory(dirPath = '') {
     }
     catch (err) {
         error(trans.docs.loadError);
-        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${err.message}`));
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${errMsg}`));
         const retry = await confirm({ message: trans.docs.retry });
         if (!isCancel(retry) && retry) {
             await browseDirectory(dirPath);
@@ -398,6 +421,7 @@ async function browseDirectory(dirPath = '') {
 async function viewMarkdownFile(filePath) {
     const trans = t();
     try {
+        ensureMarkedConfigured();
         const s = createSpinner(`${trans.docs.loading.replace('...', '')}: ${filePath}`);
         const rawResult = await fetchGitHubRawContent(filePath);
         if (rawResult.staleFallback) {
@@ -411,15 +435,15 @@ async function viewMarkdownFile(filePath) {
             renderedDoc = cachedRendered;
         }
         else {
-            const cleaned = cleanMarkdownContent(rawContent, TERMINAL_TYPE);
-            const title = extractDocTitle(cleaned) || filePath.split('/').pop() || filePath;
+            const cleaned = cleanMarkdownContent(rawContent, getTerminalType());
+            const title = extractDocTitle(rawContent, cleaned) || filePath.split('/').pop() || filePath;
             const readTime = estimateReadTime(cleaned);
             const rendered = await marked(cleaned);
             renderedDoc = { fingerprint, cleaned, rendered, title, readTime };
             setCacheValue(renderCache, filePath, renderedDoc, RENDER_CACHE_TTL_MS);
         }
         s.stop(`${chalk.bold(renderedDoc.title)}  ${chalk.dim(renderedDoc.readTime)}`);
-        if (HAS_GLOW) {
+        if (hasGlow()) {
             await displayWithGlow(renderedDoc.cleaned);
         }
         else {
@@ -431,9 +455,9 @@ async function viewMarkdownFile(filePath) {
         const action = await select({
             message: trans.docs.chooseAction,
             options: [
-                { value: 'back', label: `${pickIcon('←', '[<]')} ${trans.docs.backToList}` },
-                { value: 'reread', label: `${pickIcon('↻', '[r]')} ${trans.docs.reread}` },
-                { value: 'browser', label: `${pickIcon('🌐', '[*]')} ${trans.docs.openBrowser}` },
+                { value: 'back', label: trans.docs.backToList },
+                { value: 'reread', label: trans.docs.reread },
+                { value: 'browser', label: trans.docs.openBrowser },
             ],
         });
         if (isCancel(action))
@@ -445,7 +469,8 @@ async function viewMarkdownFile(filePath) {
     }
     catch (err) {
         error(trans.docs.loadError);
-        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${err.message}`));
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${errMsg}`));
         const openBrowser = await confirm({ message: trans.docs.openBrowserPrompt });
         if (!isCancel(openBrowser) && openBrowser) {
             await openDocsInBrowser(filePath);
@@ -469,6 +494,60 @@ export async function openDocsInBrowser(path) {
     }
     console.log();
 }
+// ─── Search ────────────────────────────────────────────────────────────────────
+async function searchDocs() {
+    const trans = t();
+    const query = await text({
+        message: trans.docs.searchPrompt,
+        placeholder: trans.docs.searchPlaceholder,
+    });
+    if (isCancel(query) || !query.trim())
+        return;
+    const keyword = query.trim().toLowerCase();
+    const s = createSpinner(trans.docs.searching);
+    // Fetch all category directories in parallel
+    const categories = getDocCategories().filter(c => c.path !== 'README.md');
+    const results = [];
+    try {
+        const fetches = await Promise.allSettled(categories.map(async (cat) => {
+            const res = await fetchGitHubDirectory(cat.path);
+            return { items: res.data, category: cat.name };
+        }));
+        for (const result of fetches) {
+            if (result.status !== 'fulfilled')
+                continue;
+            for (const item of result.value.items) {
+                const nameLC = item.name.toLowerCase();
+                if (nameLC.includes(keyword)) {
+                    results.push({ name: item.name, path: item.path, category: result.value.category });
+                }
+            }
+        }
+        s.stop(`${results.length} ${trans.docs.searchResults}`);
+    }
+    catch {
+        s.error(trans.docs.loadError);
+        return;
+    }
+    if (results.length === 0) {
+        warning(trans.docs.searchNoResults);
+        return;
+    }
+    const selected = await select({
+        message: trans.docs.chooseDoc,
+        options: [
+            ...results.map(r => ({
+                value: r.path,
+                label: r.name,
+                hint: r.category,
+            })),
+            { value: '__back__', label: chalk.dim(trans.docs.returnToMenu) },
+        ],
+    });
+    if (isCancel(selected) || selected === '__back__')
+        return;
+    await viewMarkdownFile(selected);
+}
 // ─── Menu ─────────────────────────────────────────────────────────────────────
 export async function showDocsMenu() {
     while (true) {
@@ -476,9 +555,10 @@ export async function showDocsMenu() {
         const categories = getDocCategories();
         const options = [
             ...categories.map(cat => ({ value: cat.path, label: cat.name })),
-            { value: 'refresh-cache', label: chalk.gray(`${pickIcon('♻️', '[r]')} ${trans.docs.refreshCache}`) },
-            { value: 'browser', label: chalk.gray(`${pickIcon('🌐', '[*]')} ${trans.docs.openBrowser}`) },
-            { value: 'back', label: chalk.gray(`${pickIcon('←', '[^]')} ${trans.docs.returnToMenu}`) },
+            { value: 'search', label: chalk.dim(trans.docs.searchPrompt.replace(':', '')) },
+            { value: 'refresh-cache', label: chalk.dim(trans.docs.refreshCache) },
+            { value: 'browser', label: chalk.dim(trans.docs.openBrowser) },
+            { value: 'back', label: chalk.dim(trans.docs.returnToMenu) },
         ];
         const action = await select({
             message: trans.docs.chooseCategory,
@@ -486,19 +566,18 @@ export async function showDocsMenu() {
         });
         if (isCancel(action) || action === 'back')
             return;
-        if (action === 'refresh-cache') {
+        if (action === 'search') {
+            await searchDocs();
+        }
+        else if (action === 'refresh-cache') {
             clearDocsCache();
             success(trans.docs.cacheCleared);
         }
         else if (action === 'browser') {
             await openDocsInBrowser();
         }
-        else if (action === 'README.md') {
-            await viewMarkdownFile('README.md');
-        }
         else {
             await browseDirectory(action);
         }
     }
 }
-//# sourceMappingURL=docs.js.map

package/dist/features/links.js

@@ -0,0 +1,42 @@
+/**
+ * Links — open NBTCA resources in browser
+ */
+import open from 'open';
+import chalk from 'chalk';
+import { select, isCancel } from '@clack/prompts';
+import { createSpinner } from '../core/ui.js';
+import { URLS } from '../config/data.js';
+import { t } from '../i18n/index.js';
+async function openUrl(url) {
+    const trans = t();
+    const s = createSpinner(trans.links.opening);
+    try {
+        await open(url);
+        s.stop(trans.links.opened);
+    }
+    catch {
+        s.error(trans.links.error);
+        console.log(chalk.dim(`  ${url}`));
+    }
+}
+export async function showLinksMenu() {
+    const trans = t();
+    const selected = await select({
+        message: trans.links.choose,
+        options: [
+            { value: URLS.homepage, label: trans.links.website },
+            { value: URLS.github, label: trans.links.github },
+            { value: URLS.roadmap, label: trans.links.roadmap },
+            { value: URLS.repair, label: trans.links.repair },
+            { value: '__back__', label: chalk.dim(trans.common.back) },
+        ],
+    });
+    if (isCancel(selected) || selected === '__back__')
+        return;
+    await openUrl(selected);
+}
+/** Direct openers for CLI non-interactive mode */
+export async function openHomepage() { await openUrl(URLS.homepage); }
+export async function openGithub() { await openUrl(URLS.github); }
+export async function openRoadmap() { await openUrl(URLS.roadmap); }
+export async function openRepairService() { await openUrl(URLS.repair); }

package/dist/features/settings.js

@@ -0,0 +1,120 @@
+/**
+ * Unified settings — language, theme, about
+ */
+import { select, isCancel, note } from '@clack/prompts';
+import chalk from 'chalk';
+import { applyColorModePreference, loadPreferences, resetPreferences, setColorMode, setIconMode, } from '../config/preferences.js';
+import { pickIcon } from '../core/icons.js';
+import { resetIconCache } from '../core/icons.js';
+import { padEndV } from '../core/text.js';
+import { success, warning } from '../core/ui.js';
+import { APP_INFO, URLS } from '../config/data.js';
+import { t, getCurrentLanguage, setLanguage, clearTranslationCache } from '../i18n/index.js';
+function notifyResult(saved, successMsg, warningMsg) {
+    if (saved) {
+        success(successMsg);
+    }
+    else {
+        warning(warningMsg);
+    }
+}
+function showAbout() {
+    const trans = t();
+    const pad = 12;
+    const row = (label, value) => `${chalk.dim(padEndV(label, pad))}${value}`;
+    const link = (label, url) => row(label, chalk.cyan(url));
+    const content = [
+        row(trans.about.project, APP_INFO.name),
+        row(trans.about.version, `v${APP_INFO.version}`),
+        row(trans.about.description, APP_INFO.fullDescription),
+        '',
+        link(trans.about.github, APP_INFO.repository),
+        link(trans.about.website, URLS.homepage),
+        link(trans.about.email, URLS.email),
+        '',
+        row(trans.about.license, `MIT  ${pickIcon('·', '|')}  ${trans.about.author}: m1ngsama`),
+    ].join('\n');
+    note(content, trans.about.title);
+}
+export async function showSettingsMenu() {
+    while (true) {
+        const trans = t();
+        const prefs = loadPreferences();
+        const currentLang = getCurrentLanguage();
+        const action = await select({
+            message: trans.theme.chooseAction,
+            options: [
+                { value: 'language', label: trans.language.selectLanguage.replace(':', ''), hint: currentLang === 'zh' ? trans.language.zh : trans.language.en },
+                { value: 'icon', label: trans.theme.iconMode, hint: prefs.iconMode },
+                { value: 'color', label: trans.theme.colorMode, hint: prefs.colorMode },
+                { value: 'reset', label: trans.theme.reset },
+                { value: 'about', label: trans.about.title },
+                { value: 'back', label: chalk.dim(trans.common.back) },
+            ],
+        });
+        if (isCancel(action) || action === 'back')
+            return;
+        if (action === 'about') {
+            showAbout();
+            continue;
+        }
+        if (action === 'language') {
+            const language = await select({
+                message: trans.language.selectLanguage,
+                options: [
+                    { value: 'zh', label: trans.language.zh, hint: currentLang === 'zh' ? trans.common.current : undefined },
+                    { value: 'en', label: trans.language.en, hint: currentLang === 'en' ? trans.common.current : undefined },
+                ],
+                initialValue: currentLang,
+            });
+            if (isCancel(language))
+                continue;
+            if (language !== currentLang) {
+                const saved = setLanguage(language);
+                clearTranslationCache();
+                notifyResult(saved, t().language.changed, t().language.changedSessionOnly);
+            }
+            continue;
+        }
+        if (action === 'icon') {
+            const mode = await select({
+                message: trans.theme.chooseIconMode,
+                options: [
+                    { value: 'auto', label: trans.theme.modeAuto, hint: prefs.iconMode === 'auto' ? trans.common.current : undefined },
+                    { value: 'ascii', label: trans.theme.modeAscii, hint: prefs.iconMode === 'ascii' ? trans.common.current : undefined },
+                    { value: 'unicode', label: trans.theme.modeUnicode, hint: prefs.iconMode === 'unicode' ? trans.common.current : undefined },
+                ],
+                initialValue: prefs.iconMode,
+            });
+            if (isCancel(mode))
+                continue;
+            const saved = setIconMode(mode);
+            resetIconCache();
+            notifyResult(saved, trans.theme.updated, trans.theme.updatedSessionOnly);
+            continue;
+        }
+        if (action === 'color') {
+            const mode = await select({
+                message: trans.theme.chooseColorMode,
+                options: [
+                    { value: 'auto', label: trans.theme.modeAuto, hint: prefs.colorMode === 'auto' ? trans.common.current : undefined },
+                    { value: 'on', label: trans.theme.modeOn, hint: prefs.colorMode === 'on' ? trans.common.current : undefined },
+                    { value: 'off', label: trans.theme.modeOff, hint: prefs.colorMode === 'off' ? trans.common.current : undefined },
+                ],
+                initialValue: prefs.colorMode,
+            });
+            if (isCancel(mode))
+                continue;
+            const saved = setColorMode(mode);
+            applyColorModePreference(false);
+            notifyResult(saved, trans.theme.updated, trans.theme.updatedSessionOnly);
+            continue;
+        }
+        if (action === 'reset') {
+            const saved = resetPreferences();
+            resetIconCache();
+            applyColorModePreference(false);
+            notifyResult(saved, trans.theme.reset, trans.theme.resetSessionOnly);
+        }
+    }
+}

package/dist/features/status.js

@@ -1,17 +1,20 @@
 import axios from 'axios';
 import chalk from 'chalk';
-import { URLS } from '../config/data.js';
+import { APP_INFO, URLS } from '../config/data.js';
 import { pickIcon } from '../core/icons.js';
 import { padEndV } from '../core/text.js';
-import { createSpinner, success, warning } from '../core/ui.js';
+import { createSpinner } from '../core/ui.js';
 import { t } from '../i18n/index.js';
-const SERVICE_TARGETS = [
-    { name: 'Website', url: URLS.homepage },
-    { name: 'Docs', url: URLS.docs },
-    { name: 'Calendar', url: URLS.calendar },
-    { name: 'GitHub', url: URLS.github },
-    { name: 'Roadmap', url: URLS.roadmap },
-];
+function getServiceTargets() {
+    const trans = t();
+    return [
+        { name: trans.status.serviceWebsite, url: URLS.homepage },
+        { name: trans.status.serviceDocs, url: URLS.docs },
+        { name: trans.status.serviceCalendar, url: URLS.calendar },
+        { name: trans.status.serviceGithub, url: URLS.github },
+        { name: trans.status.serviceRoadmap, url: URLS.roadmap },
+    ];
+}
 async function checkService(name, url, timeoutMs) {
     const start = Date.now();
     try {
@@ -19,7 +22,7 @@ async function checkService(name, url, timeoutMs) {
             timeout: timeoutMs,
             maxRedirects: 5,
             validateStatus: () => true,
-            headers: { 'User-Agent': 'NBTCA-CLI/2.4.0' },
+            headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` },
         });
         const latencyMs = Date.now() - start;
         const ok = response.status >= 200 && response.status < 400;
@@ -49,7 +52,7 @@ async function checkServiceWithRetry(name, url, timeoutMs, retries) {
 export async function checkServices(options = {}) {
     const timeoutMs = options.timeoutMs ?? 6000;
     const retries = options.retries ?? 1;
-    return Promise.all(SERVICE_TARGETS.map((service) => checkServiceWithRetry(service.name, service.url, timeoutMs, retries)));
+    return Promise.all(getServiceTargets().map((service) => checkServiceWithRetry(service.name, service.url, timeoutMs, retries)));
 }
 export function serializeServiceStatus(items) {
     return items.map((item) => ({
@@ -87,7 +90,6 @@ export function renderServiceStatusTable(items, options) {
     const trans = t();
     const nameWidth = 10;
     const statusWidth = 9;
-    const codeWidth = 7;
     const latencyWidth = 10;
     const h = pickIcon('─', '-');
     const v = pickIcon('│', '|');
@@ -100,19 +102,17 @@ export function renderServiceStatusTable(items, options) {
     const bottomLeft = pickIcon('└', '+');
     const bottomMid = pickIcon('┴', '+');
     const bottomRight = pickIcon('┘', '+');
-    const top = `${topLeft}${h.repeat(nameWidth + 2)}${topMid}${h.repeat(statusWidth + 2)}${topMid}${h.repeat(codeWidth + 2)}${topMid}${h.repeat(latencyWidth + 2)}${topMid}${h.repeat(34)}${topRight}`;
-    const divider = `${midLeft}${h.repeat(nameWidth + 2)}${midMid}${h.repeat(statusWidth + 2)}${midMid}${h.repeat(codeWidth + 2)}${midMid}${h.repeat(latencyWidth + 2)}${midMid}${h.repeat(34)}${midRight}`;
-    const bottom = `${bottomLeft}${h.repeat(nameWidth + 2)}${bottomMid}${h.repeat(statusWidth + 2)}${bottomMid}${h.repeat(codeWidth + 2)}${bottomMid}${h.repeat(latencyWidth + 2)}${bottomMid}${h.repeat(34)}${bottomRight}`;
-    const header = `${v} ${padEndV(trans.status.service, nameWidth)} ${v} ${padEndV(trans.status.health, statusWidth)} ${v} ${padEndV(trans.status.code, codeWidth)} ${v} ${padEndV(trans.status.latency, latencyWidth)} ${v} ${padEndV(trans.status.url, 34)} ${v}`;
+    const top = `${topLeft}${h.repeat(nameWidth + 2)}${topMid}${h.repeat(statusWidth + 2)}${topMid}${h.repeat(latencyWidth + 2)}${topRight}`;
+    const divider = `${midLeft}${h.repeat(nameWidth + 2)}${midMid}${h.repeat(statusWidth + 2)}${midMid}${h.repeat(latencyWidth + 2)}${midRight}`;
+    const bottom = `${bottomLeft}${h.repeat(nameWidth + 2)}${bottomMid}${h.repeat(statusWidth + 2)}${bottomMid}${h.repeat(latencyWidth + 2)}${bottomRight}`;
+    const header = `${v} ${padEndV(trans.status.service, nameWidth)} ${v} ${padEndV(trans.status.health, statusWidth)} ${v} ${padEndV(trans.status.latency, latencyWidth)} ${v}`;
     const lines = [dim(top), header, dim(divider)];
     for (const item of items) {
         const statusLabel = item.ok
             ? green(`${pickIcon('●', 'OK')} ${trans.status.up}`)
             : red(`${pickIcon('●', '!!')} ${trans.status.down}`);
-        const code = item.statusCode ? String(item.statusCode) : '-';
         const latency = item.latencyMs != null ? `${item.latencyMs}ms` : '-';
-        const url = item.url.length > 34 ? `${item.url.slice(0, 31)}...` : item.url;
-        lines.push(`${v} ${padEndV(cyan(item.name), nameWidth)} ${v} ${padEndV(statusLabel, statusWidth)} ${v} ${padEndV(code, codeWidth)} ${v} ${padEndV(latency, latencyWidth)} ${v} ${padEndV(url, 34)} ${v}`);
+        lines.push(`${v} ${padEndV(cyan(item.name), nameWidth)} ${v} ${padEndV(statusLabel, statusWidth)} ${v} ${padEndV(latency, latencyWidth)} ${v}`);
     }
     lines.push(dim(bottom));
     return lines.join('\n');
@@ -129,12 +129,5 @@ export async function showServiceStatus() {
         spinner.stop(trans.status.summaryOk);
     }
     console.log(renderServiceStatusTable(items, { color: !!process.stdout.isTTY }));
-    if (hasFailures) {
-        warning(trans.status.summaryFail);
-    }
-    else {
-        success(trans.status.summaryOk);
-    }
     return items;
 }
-//# sourceMappingURL=status.js.map