@nbtca/prompt 1.5.0 → 1.5.2

package/dist/features/docs.js

@@ -1,7 +1,6 @@
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import chalk from 'chalk';
-import open from 'open';
 import { createHash } from 'node:crypto';
 import { runMenu, menuFooter } from '../core/components/menu.js';
 import { runTextInput } from '../core/components/text-input.js';
@@ -12,8 +11,9 @@ import { spawn, execFileSync } from 'child_process';
 import { URLS } from '../config/data.js';
 import { t, fmt, getCurrentLanguage } from '../i18n/index.js';
 import { enterScreen, breadcrumb } from '../core/transitions.js';
-import { sanitizeTerminalLine, sanitizeTerminalText, truncate } from '../core/text.js';
-import { createDocsClient } from '@nbtca/docs';
+import { sanitizeTerminalLine, sanitizeTerminalText, stripAnsi, truncate } from '../core/text.js';
+import { clearDocsClients, runDocsClientOperation } from './docs-client.js';
+import { launchBrowserUrl } from './links.js';
 function detectTerminalType() {
     const term = (process.env['TERM'] ?? '').toLowerCase();
     const termProgram = (process.env['TERM_PROGRAM'] ?? '').toLowerCase();
@@ -62,7 +62,8 @@ export function ensureMarkedConfigured() {
     if (_markedConfigured)
         return;
     _markedConfigured = true;
-    const extension = markedTerminal(getRendererOptions(getTerminalType()));
+    const terminalType = getTerminalType();
+    const extension = markedTerminal(getRendererOptions(terminalType));
     const renderer = extension.renderer ?? (extension.renderer = {});
     const renderExternalLink = renderer.link;
     if (renderExternalLink) {
@@ -147,9 +148,7 @@ const METADATA_CACHE_TTL_MS = 10 * 60 * 1000;
 const METADATA_CACHE_MAX = 200;
 const METADATA_CONCURRENCY = 4;
 const metadataCache = new Map();
-const metadataRequests = new Map();
 let cacheGeneration = 0;
-const docsClient = createDocsClient();
 function getFreshRender(key) {
     const entry = renderCache.get(key);
     return entry && entry.expiresAt > Date.now() ? entry.value : null;
@@ -176,14 +175,13 @@ function renderCacheKey(filePath) {
 }
 export function clearDocsCache() {
     cacheGeneration += 1;
-    docsClient.clear();
+    clearDocsClients();
     renderCache.clear();
     metadataCache.clear();
-    metadataRequests.clear();
 }
-async function fetchDocument(path) {
+async function fetchDocument(path, signal) {
     try {
-        return await docsClient.getDocument(path);
+        return await runDocsClientOperation(signal, (client) => client.getDocument(path));
     }
     catch (err) {
         const trans = t();
@@ -218,31 +216,31 @@ function setMetadata(path, value) {
             metadataCache.delete(oldest);
     }
 }
-function loadDocMetadata(path) {
+function loadDocMetadata(path, signal) {
     const cached = getFreshMetadata(path);
     if (cached)
         return Promise.resolve(cached);
-    const pending = metadataRequests.get(path);
-    if (pending)
-        return pending;
     const generation = cacheGeneration;
-    const request = fetchDocument(path).then((page) => {
+    return fetchDocument(path, signal).then((page) => {
         const metadata = metadataFromPage(page);
         if (generation === cacheGeneration)
             setMetadata(path, metadata);
         return metadata;
     });
-    metadataRequests.set(path, request);
-    const release = () => {
-        if (metadataRequests.get(path) === request)
-            metadataRequests.delete(path);
-    };
-    void request.then(release, release);
-    return request;
 }
-async function loadRenderedDoc(filePath) {
+function normalizeRenderedTasks(content, type) {
+    if (type !== 'basic')
+        return content;
+    return content
+        .split('\n')
+        .map((line) => /^\s*(?:[-*+]|\d+[.)])\s+\[X\](?:\s|$)/.test(stripAnsi(line))
+        ? line.replace('[X]', '[x]')
+        : line)
+        .join('\n');
+}
+async function loadRenderedDoc(filePath, signal) {
     const generation = cacheGeneration;
-    const page = await fetchDocument(filePath);
+    const page = await fetchDocument(filePath, signal);
     if (generation === cacheGeneration)
         setMetadata(filePath, metadataFromPage(page));
     const rawContent = page.content;
@@ -251,12 +249,14 @@ async function loadRenderedDoc(filePath) {
     const cached = getFreshRender(cacheKey);
     if (cached?.fingerprint === fingerprint)
         return { rawContent, renderedDoc: cached };
-    const cleaned = cleanMarkdownContent(rawContent, getTerminalType());
+    const terminalType = getTerminalType();
+    const cleaned = cleanMarkdownContent(rawContent, terminalType);
     const title = sanitizeTerminalLine(page.title) || cleanFileName(filePath.split('/').pop() ?? filePath);
+    const markedOutput = normalizeRenderedTasks(await marked(cleaned), terminalType);
     const renderedDoc = {
         fingerprint,
         cleaned,
-        rendered: await marked(cleaned),
+        rendered: chalk.level === 0 ? sanitizeTerminalText(markedOutput) : markedOutput,
         title,
         readTime: estimateReadTime(cleaned),
     };
@@ -392,10 +392,101 @@ function replaceDocumentComponents(content) {
     });
     return result;
 }
-export function cleanMarkdownContent(content, type = getTerminalType()) {
-    let c = sanitizeTerminalText(content);
-    c = c.replace(/^---\n[\s\S]*?\n---(?:\n|$)/, '');
-    c = processFencedCodeBlocks(c);
+function replaceHtmlCheckboxes(content, type) {
+    return content.replace(/<input\b([^>]*)\/?\s*>/gi, (tag, attributes) => {
+        const typeMatch = /(?:^|\s)type\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>/]+))/i.exec(attributes);
+        const inputType = (typeMatch?.[1] ?? typeMatch?.[2] ?? typeMatch?.[3] ?? '')
+            .trim()
+            .toLowerCase();
+        if (inputType !== 'checkbox')
+            return tag;
+        const checked = /(?:^|\s)checked(?=\s|=|\/|$)/i.test(attributes);
+        if (type === 'basic')
+            return checked ? '[x]' : '[ ]';
+        return checked ? '☑' : '☐';
+    });
+}
+function expandHtmlDetails(content) {
+    return content
+        .replace(/<summary\b[^>]*>([\s\S]*?)<\/summary\s*>/gi, (_match, label) => {
+        const summary = sanitizeTerminalLine(label);
+        return summary ? `\n\n### ${summary}\n\n` : '\n';
+    })
+        .replace(/<\/?(?:details|summary)\b[^>]*>/gi, '');
+}
+function transformOutsideFencedCodeBlocks(content, transform) {
+    const output = [];
+    let plain = [];
+    let fenceCharacter = '';
+    let fenceWidth = 0;
+    let listIndent = 0;
+    let listQuoteDepth = 0;
+    const flushPlain = () => {
+        if (plain.length === 0)
+            return;
+        output.push(transform(plain.join('\n')));
+        plain = [];
+    };
+    const lineContext = (line) => {
+        let rest = line;
+        let quoteDepth = 0;
+        for (;;) {
+            const quote = /^[ \t]{0,3}>[ \t]?/.exec(rest)?.[0];
+            if (!quote)
+                break;
+            quoteDepth += 1;
+            rest = rest.slice(quote.length);
+        }
+        return { quoteDepth, rest };
+    };
+    const fenceMarker = (line) => {
+        let { rest } = lineContext(line);
+        const list = /^[ \t]*(?:[-+*]|\d+[.)])[ \t]+/.exec(rest)?.[0];
+        if (list)
+            rest = rest.slice(list.length);
+        else if (listIndent > 0 && rest.startsWith(' '.repeat(listIndent))) {
+            rest = rest.slice(listIndent);
+        }
+        return /^ {0,3}(`{3,}|~{3,})/.exec(rest)?.[1];
+    };
+    for (const line of content.split('\n')) {
+        if (fenceWidth === 0) {
+            const { quoteDepth, rest } = lineContext(line);
+            const list = /^([ ]*)(?:[-+*]|\d+[.)])([ \t]+)/.exec(rest);
+            if (list) {
+                listIndent = list[0].length;
+                listQuoteDepth = quoteDepth;
+            }
+            else if (rest.trim() && (quoteDepth !== listQuoteDepth || rest.search(/\S/) < listIndent)) {
+                listIndent = 0;
+                listQuoteDepth = quoteDepth;
+            }
+            const opening = fenceMarker(line);
+            if (!opening) {
+                plain.push(line);
+                continue;
+            }
+            flushPlain();
+            fenceCharacter = opening[0] ?? '';
+            fenceWidth = opening.length;
+            output.push(line);
+            continue;
+        }
+        output.push(line);
+        const closing = fenceMarker(line);
+        const closingSuffix = closing ? line.slice(line.lastIndexOf(closing) + closing.length) : line;
+        if (closing?.[0] === fenceCharacter &&
+            closing.length >= fenceWidth &&
+            closingSuffix.trim() === '') {
+            fenceCharacter = '';
+            fenceWidth = 0;
+        }
+    }
+    flushPlain();
+    return output.join('\n');
+}
+function cleanMarkdownOutsideFences(content, terminalType) {
+    let c = content;
     c = c.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '');
     c = c.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, '');
     c = replaceDocumentComponents(c);
@@ -414,7 +505,7 @@ export function cleanMarkdownContent(content, type = getTerminalType()) {
     c = c.replace(/\[\[toc\]\]/gi, '');
     c = c.replace(/^(#{1,6}\s+[^\n]*?)\s*\{#[^}]+\}\s*$/gm, '$1');
     c = c.replace(/==([^=\n]+)==/g, '**$1**');
-    if (type === 'basic') {
+    if (terminalType === 'basic') {
         c = c.replace(/!\[([^\]]*)\]\([^)]+\)/g, (_match, alt) => `${pickIcon('📎', '[image]')} ${alt.length > 0 ? alt : 'image'}`);
     }
     else {
@@ -425,14 +516,27 @@ export function cleanMarkdownContent(content, type = getTerminalType()) {
         });
     }
     c = c.replace(/<!--[\s\S]*?-->/g, '');
-    c = c.replace(/<br\s*\/?>/gi, '\n'); // void: line break
-    c = c.replace(/<(?:hr|input|link|meta)\b[^>]*\/?>/gi, ''); // void: discard
+    c = replaceHtmlCheckboxes(c, terminalType);
+    c = expandHtmlDetails(c);
+    c = c.replace(/<br\s*\/?>/gi, '\n');
+    c = c.replace(/<(?:hr|input|link|meta)\b[^>]*\/?>/gi, '');
     c = c.replace(/<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)<\/\1>/gi, '$2');
     c = c.replace(/<[a-z][a-z0-9]*\b[^>]*\/>/gi, '');
     c = c.replace(/<\/(?:Split|TimelineEntry)>/gi, '');
-    c = c.replace(/^(\s*[-*+] )\[x\] /gim, '$1☑ ');
-    c = c.replace(/^(\s*[-*+] )\[ \] /gm, '$1☐ ');
-    c = c.replace(/\n{3,}/g, '\n\n');
+    if (terminalType === 'basic') {
+        c = c.replace(/^(\s*(?:[-*+]|\d+[.)]) )\[x\]/gim, '$1[x]');
+    }
+    else {
+        c = c.replace(/^(\s*(?:[-*+]|\d+[.)]) )\[x\] /gim, '$1☑ ');
+        c = c.replace(/^(\s*(?:[-*+]|\d+[.)]) )\[ \] /gm, '$1☐ ');
+    }
+    return c.replace(/\n{3,}/g, '\n\n');
+}
+export function cleanMarkdownContent(content, type = getTerminalType()) {
+    let c = sanitizeTerminalText(content);
+    c = c.replace(/^---\n[\s\S]*?\n---(?:\n|$)/, '');
+    c = processFencedCodeBlocks(c);
+    c = transformOutsideFencedCodeBlocks(c, (value) => cleanMarkdownOutsideFences(value, type));
     return c.trim();
 }
 function estimateReadTime(text) {
@@ -494,9 +598,9 @@ export function resolveInternalHref(href, fromPath) {
         target += '.md';
     return target;
 }
-export async function loadDocForReader(filePath) {
+export async function loadDocForReader(filePath, signal) {
     ensureMarkedConfigured();
-    const { renderedDoc } = await loadRenderedDoc(filePath);
+    const { renderedDoc } = await loadRenderedDoc(filePath, signal);
     const seen = new Set();
     const links = [];
     for (const raw of extractInternalLinks(renderedDoc.cleaned)) {
@@ -544,7 +648,7 @@ function listedDoc(item, metadata) {
         summary: sanitizeTerminalLine(metadata?.summary ?? ''),
     };
 }
-export async function fetchDocMetadata(items) {
+export async function fetchDocMetadata(items, signal) {
     const results = items.map((item) => listedDoc(item));
     let nextIndex = 0;
     async function worker() {
@@ -556,10 +660,17 @@ export async function fetchDocMetadata(items) {
             const item = items[index];
             if (!item)
                 continue;
+            if (signal?.aborted) {
+                throw signal.reason instanceof Error
+                    ? signal.reason
+                    : new DOMException('Aborted', 'AbortError');
+            }
             try {
-                results[index] = listedDoc(item, await loadDocMetadata(item.path));
+                results[index] = listedDoc(item, await loadDocMetadata(item.path, signal));
             }
-            catch {
+            catch (error) {
+                if (signal?.aborted)
+                    throw error;
                 results[index] = listedDoc(item);
             }
         }
@@ -568,8 +679,8 @@ export async function fetchDocMetadata(items) {
     await Promise.all(Array.from({ length: workerCount }, worker));
     return results;
 }
-export async function fetchSectionMetadata(section) {
-    const files = await fetchDocMetadata(section.files);
+export async function fetchSectionMetadata(section, signal) {
+    const files = await fetchDocMetadata(section.files, signal);
     return { ...section, count: files.length, files };
 }
 function searchDoc(result) {
@@ -585,8 +696,8 @@ function searchDoc(result) {
         section: result.section,
     };
 }
-export async function searchDocuments(query) {
-    return (await docsClient.search(query, { limit: 20 })).map(searchDoc);
+export async function searchDocuments(query, signal) {
+    return (await runDocsClientOperation(signal, (client) => client.search(query, { limit: 20 }))).map(searchDoc);
 }
 export function buildSections(all) {
     const groups = new Map();
@@ -627,11 +738,11 @@ export function getArchivedGroups(files) {
     }
     return groups;
 }
-export async function fetchAllDocs() {
-    return docsClient.listAll();
+export async function fetchAllDocs(signal) {
+    return runDocsClientOperation(signal, (client) => client.listAll());
 }
-export async function fetchSections() {
-    return buildSections(await fetchAllDocs());
+export async function fetchSections(signal) {
+    return buildSections(await fetchAllDocs(signal));
 }
 async function loadSections() {
     const trans = t();
@@ -646,9 +757,19 @@ async function loadSections() {
         return null;
     }
 }
-function pipeToPager(command, args, content) {
+function pipeToPager(command, args, content, plain = false) {
     return new Promise((resolve) => {
-        const child = spawn(command, args, { stdio: ['pipe', 'inherit', 'inherit'] });
+        const env = { ...process.env };
+        if (plain) {
+            delete env['FORCE_COLOR'];
+            env['NO_COLOR'] = '1';
+            env['CLICOLOR'] = '0';
+            env['CLICOLOR_FORCE'] = '0';
+        }
+        const child = spawn(command, args, {
+            stdio: ['pipe', 'inherit', 'inherit'],
+            ...(plain ? { env } : {}),
+        });
         let settled = false;
         const finish = (started) => {
             if (settled)
@@ -673,7 +794,9 @@ function pipeToPager(command, args, content) {
         }
     });
 }
-async function displayWithGlow(cleanedMarkdown) {
+export async function displayWithGlow(cleanedMarkdown) {
+    if (chalk.level === 0)
+        return false;
     const cols = String(Math.min(process.stdout.columns || 80, 80));
     return pipeToPager('glow', ['--pager', '--width', cols, '-'], cleanedMarkdown);
 }
@@ -699,16 +822,21 @@ async function displayWithLess(rendered, title, filePath, readTime, toc) {
         '',
     ].join('\n');
     const footer = ['', rule, chalk.dim(`  ${trans.docs.endOfDocument}`), ''].join('\n');
-    const fullContent = header + rendered + footer;
+    const plain = chalk.level === 0;
+    const fullContent = plain
+        ? sanitizeTerminalText(header + rendered + footer)
+        : header + rendered + footer;
     const pagerSetting = (process.env['PAGER'] ?? 'less').trim();
     const [pagerCommand = 'less', ...pagerArgs] = pagerSetting.split(/\s+/).filter(Boolean);
     const isLess = /(?:^|[\\/])less(?:\.exe)?$/i.test(pagerCommand);
-    const args = isLess ? [...pagerArgs, '-R', '-F', '-X', '-i', '-j4'] : pagerArgs;
+    const args = isLess
+        ? [...pagerArgs, ...(plain ? [] : ['-R']), '-F', '-X', '-i', '-j4']
+        : pagerArgs;
     if (!commandExists(pagerCommand)) {
         console.log(fullContent);
         return;
     }
-    if (!(await pipeToPager(pagerCommand, args, fullContent)))
+    if (!(await pipeToPager(pagerCommand, args, fullContent, plain)))
         console.log(fullContent);
 }
 async function showDocSection(section) {
@@ -798,7 +926,7 @@ async function viewMarkdownFile(filePath) {
         const { rawContent, renderedDoc } = await loadRenderedDoc(filePath);
         s.stop(`${chalk.bold(renderedDoc.title)}  ${chalk.dim(renderedDoc.readTime)}`);
         const toc = extractTOC(renderedDoc.cleaned);
-        if (hasGlow()) {
+        if (chalk.level > 0 && hasGlow()) {
             if (!(await displayWithGlow(renderedDoc.cleaned))) {
                 await displayWithLess(renderedDoc.rendered, renderedDoc.title, filePath, renderedDoc.readTime, toc);
             }
@@ -833,32 +961,60 @@ async function viewMarkdownFile(filePath) {
         }
     }
 }
-export async function openDocsInBrowser(path) {
+export async function openDocsInBrowser(path, signal) {
     const trans = t();
     const s = createSpinner(trans.docs.opening);
+    let url = docsUrlFromPath(path);
     try {
-        let route = path ? docsRouteFromPath(path) : '';
         if (path) {
             try {
-                route = (await loadDocMetadata(path)).route;
+                url = docsUrlFromRoute((await loadDocMetadata(path, signal)).route);
             }
             catch {
-                route = docsRouteFromPath(path);
+                if (signal?.aborted) {
+                    s.stop();
+                    return false;
+                }
+                url = docsUrlFromPath(path);
             }
         }
-        const encodedRoute = route
-            .split('/')
-            .map((segment) => encodeURIComponent(segment))
-            .join('/');
-        const url = path ? `${URLS.docs}${encodedRoute}` : URLS.docs;
-        await open(url);
+        if (signal?.aborted) {
+            s.stop();
+            return false;
+        }
+        if (!(await launchBrowserUrl(url)))
+            throw new Error('Browser launcher failed');
+        if (signal?.aborted) {
+            s.stop();
+            return false;
+        }
         s.stop(trans.docs.browserOpened);
+        console.log();
+        return true;
     }
     catch {
+        if (signal?.aborted) {
+            s.stop();
+            return false;
+        }
         s.error(trans.docs.browserError);
-        console.log(chalk.gray(`  ${trans.docs.browserErrorHint}`));
+        console.log(chalk.gray(`  ${fmt(t().links.openManually, { url })}`));
+        console.log();
+        return false;
     }
-    console.log();
+}
+function docsUrlFromRoute(route) {
+    const safeRoute = sanitizeTerminalLine(route);
+    if (!safeRoute)
+        return URLS.docs;
+    const encodedRoute = safeRoute
+        .split('/')
+        .map((segment) => encodeURIComponent(segment))
+        .join('/');
+    return `${URLS.docs}${encodedRoute}`;
+}
+export function docsUrlFromPath(path) {
+    return path ? docsUrlFromRoute(docsRouteFromPath(sanitizeTerminalLine(path))) : URLS.docs;
 }
 export function docsRouteFromPath(path) {
     const withoutExtension = path.replace(/\.md$/i, '');

package/dist/features/links.js

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import open from 'open';
+import { sanitizeTerminalLine } from '../core/text.js';
+import { fmt, t } from '../i18n/index.js';
+const BROWSER_LAUNCH_SETTLE_MS = 1000;
+function settleBrowserLauncher(child) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            finish(true);
+        }, BROWSER_LAUNCH_SETTLE_MS);
+        function finish(success) {
+            if (settled)
+                return;
+            settled = true;
+            child.off('close', onClose);
+            child.off('error', onError);
+            clearTimeout(timer);
+            resolve(success);
+        }
+        function onClose(code, signal) {
+            finish(code === 0 && signal === null);
+        }
+        function onError() {
+            finish(false);
+        }
+        child.once('close', onClose);
+        child.once('error', onError);
+        if (child.exitCode !== null || child.signalCode !== null) {
+            finish(child.exitCode === 0 && child.signalCode === null);
+            return;
+        }
+    });
+}
+export async function launchBrowserUrl(url) {
+    try {
+        return await settleBrowserLauncher(await open(url));
+    }
+    catch {
+        return false;
+    }
+}
+export async function openUrlInBrowser(url) {
+    const safeUrl = sanitizeTerminalLine(url);
+    if (await launchBrowserUrl(safeUrl))
+        return true;
+    const trans = t().links;
+    console.error(chalk.red(trans.error));
+    console.error(chalk.dim(fmt(trans.openManually, { url: safeUrl })));
+    return false;
+}

package/dist/features/status.js

@@ -4,6 +4,66 @@ import { pickIcon } from '../core/icons.js';
 import { padEndV, sanitizeTerminalLine, visualWidth } from '../core/text.js';
 import { c } from '../core/theme.js';
 import { t } from '../i18n/index.js';
+function abortError(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException('The status check was aborted.', 'AbortError');
+}
+function cancelResponseBody(response) {
+    try {
+        const body = response?.body;
+        if (!body)
+            return;
+        void body.cancel().catch(() => {
+            // Cancellation is best-effort and must not delay status results.
+        });
+    }
+    catch {
+        // A custom transport may expose an inaccessible, locked, or closed body.
+    }
+}
+function raceWithSignal(operation, signal, onLateValue) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(abortError(signal));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void operation
+            .then((value) => {
+            if (settled) {
+                try {
+                    onLateValue?.(value);
+                }
+                catch {
+                    // Late cleanup is best-effort.
+                }
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error instanceof Error ? error : new Error(String(error)));
+        })
+            .catch(() => {
+            // Both operation outcomes are handled above. This only guards cleanup code.
+        });
+        if (signal.aborted)
+            onAbort();
+    });
+}
 function getServiceTargets() {
     const trans = t();
     return [
@@ -17,25 +77,34 @@ function getServiceTargets() {
         { name: trans.status.serviceMirror, url: URLS.mirror, group: 'intranet', intranet: true },
     ];
 }
-async function checkService(name, url, timeoutMs) {
+async function checkService(name, url, timeoutMs, signal) {
     const start = Date.now();
     const controller = new AbortController();
+    const onAbort = () => {
+        controller.abort(signal?.reason);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    if (signal?.aborted)
+        onAbort();
     const timeout = setTimeout(() => {
         controller.abort();
     }, timeoutMs);
-    timeout.unref();
     let response;
     try {
-        response = await fetch(url, {
+        response = await raceWithSignal(fetch(url, {
             signal: controller.signal,
             redirect: 'follow',
             headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` },
-        });
+        }), controller.signal, cancelResponseBody);
+        if (signal?.aborted)
+            throw abortError(signal);
         const latencyMs = Date.now() - start;
         const ok = response.status >= 200 && response.status < 400;
         return { name, url, ok, statusCode: response.status, latencyMs };
     }
     catch (err) {
+        if (signal?.aborted)
+            throw abortError(signal);
         const latencyMs = Date.now() - start;
         const error = sanitizeTerminalLine(err instanceof Error
             ? err.name === 'AbortError'
@@ -46,21 +115,19 @@ async function checkService(name, url, timeoutMs) {
     }
     finally {
         clearTimeout(timeout);
-        try {
-            await response?.body?.cancel();
-        }
-        catch {
-            // The response may already be closed by the runtime.
-        }
+        signal?.removeEventListener('abort', onAbort);
+        cancelResponseBody(response);
     }
 }
-async function checkServiceWithRetry(target, timeoutMs, retries) {
-    let lastResult = await checkService(target.name, target.url, timeoutMs);
+async function checkServiceWithRetry(target, timeoutMs, retries, signal) {
+    let lastResult = await checkService(target.name, target.url, timeoutMs, signal);
     if (!lastResult.ok) {
         for (let attempt = 0; attempt < retries; attempt++) {
             if (!lastResult.error && !(lastResult.statusCode != null && lastResult.statusCode >= 500))
                 break;
-            lastResult = await checkService(target.name, target.url, timeoutMs);
+            if (signal?.aborted)
+                throw abortError(signal);
+            lastResult = await checkService(target.name, target.url, timeoutMs, signal);
             if (lastResult.ok)
                 break;
         }
@@ -74,7 +141,9 @@ async function checkServiceWithRetry(target, timeoutMs, retries) {
 export async function checkServices(options = {}) {
     const timeoutMs = options.timeoutMs ?? 6000;
     const retries = options.retries ?? 1;
-    return Promise.all(getServiceTargets().map((t) => checkServiceWithRetry(t, timeoutMs, retries)));
+    if (options.signal?.aborted)
+        throw abortError(options.signal);
+    return Promise.all(getServiceTargets().map((target) => checkServiceWithRetry(target, timeoutMs, retries, options.signal)));
 }
 export function serializeServiceStatus(items) {
     return items.map((item) => ({