@mintlify/cli 4.0.1813 → 4.1.1

package/bin/og.js

@@ -1,145 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { parseFrontmatter, slugToTitle } from '@mintlify/common';
-import { renderOgCardPng } from '@mintlify/og';
-import { applyCardThemeOverride, applyThumbnailOverride, buildOgCardInput, checkOgCard, createLocalAssetLoaders, deriveOgThemeParams, getOgPageParams, MAX_OG_ASSET_BYTES, toOgFontAsset, toOgImageAsset, } from '@mintlify/og/config';
-import { getConfigObj } from '@mintlify/prebuild';
-import { addLog, ErrorLog, SuccessLog, WarningLog } from '@mintlify/previewing';
-import { validateDocsConfig } from '@mintlify/validation';
-import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import open from 'open';
-import { CMD_EXEC_PATH } from './helpers.js';
-const REMOTE_TIMEOUT_MS = 5000;
-const PAGE_EXTENSIONS = ['.mdx', '.md'];
-const MAX_REPORTED_ISSUES = 5;
-const readLimited = (response) => __awaiter(void 0, void 0, void 0, function* () {
-    const declared = Number(response.headers.get('content-length'));
-    if (declared > MAX_OG_ASSET_BYTES || !response.body)
-        return null;
-    const reader = response.body.getReader();
-    const chunks = [];
-    let size = 0;
-    for (let result = yield reader.read(); !result.done; result = yield reader.read()) {
-        size += result.value.byteLength;
-        if (size > MAX_OG_ASSET_BYTES) {
-            yield reader.cancel();
-            return null;
-        }
-        chunks.push(result.value);
-    }
-    const bytes = new Uint8Array(size);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return bytes;
-});
-const fetchAsset = (src) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    try {
-        const response = yield fetch(src, { signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS) });
-        if (!response.ok)
-            return null;
-        const bytes = yield readLimited(response);
-        return bytes && { bytes, contentType: (_a = response.headers.get('content-type')) !== null && _a !== void 0 ? _a : undefined };
-    }
-    catch (_b) {
-        return null;
-    }
-});
-const remoteLoaders = {
-    image: (src) => __awaiter(void 0, void 0, void 0, function* () {
-        const asset = yield fetchAsset(src);
-        return asset && toOgImageAsset(asset.bytes, asset.contentType);
-    }),
-    font: (src) => __awaiter(void 0, void 0, void 0, function* () {
-        const asset = yield fetchAsset(src);
-        return asset && toOgFontAsset(asset.bytes);
-    }),
-};
-const normalizePagePath = (page) => path.posix
-    .normalize(`/${(page !== null && page !== void 0 ? page : '').replace(/\\/g, '/')}`)
-    .replace(/^\/+|\/+$/g, '')
-    .replace(/\.mdx?$/, '') || 'index';
-const pageHref = (pagePath) => pagePath.replace(/(^|\/)index$/, '');
-const pageCandidates = (pagePath) => [pagePath, `${pagePath}/index`].flatMap((base) => PAGE_EXTENSIONS.map((extension) => `${base}${extension}`));
-const readPage = (pagePath) => __awaiter(void 0, void 0, void 0, function* () {
-    const root = path.resolve(CMD_EXEC_PATH);
-    for (const candidate of pageCandidates(pagePath)) {
-        const filePath = path.resolve(root, candidate);
-        if (!filePath.startsWith(`${root}${path.sep}`))
-            return null;
-        try {
-            return yield readFile(filePath, 'utf-8');
-        }
-        catch (_a) {
-            continue;
-        }
-    }
-    return null;
-});
-const stringAttribute = (attributes, key) => {
-    const value = attributes[key];
-    return typeof value === 'string' && value ? value : undefined;
-};
-const defaultOutputPath = (pagePath) => __awaiter(void 0, void 0, void 0, function* () {
-    return path.join(yield mkdtemp(path.join(os.tmpdir(), 'mintlify-og-')), `${pagePath.replace(/\//g, '-')}.png`);
-});
-export function ogCommand(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const rawConfig = yield getConfigObj(CMD_EXEC_PATH, 'docs');
-        if (!rawConfig) {
-            addLog(_jsx(ErrorLog, { message: "No docs.json found. Run mint og from your docs directory." }));
-            return 1;
-        }
-        const validation = validateDocsConfig(rawConfig);
-        if (!validation.success) {
-            const issues = validation.error.issues
-                .slice(0, MAX_REPORTED_ISSUES)
-                .map((issue) => `${issue.path.join('.') || 'docs.json'}: ${issue.message}`);
-            addLog(_jsx(ErrorLog, { message: `docs.json is invalid:\n${issues.join('\n')}` }));
-            return 1;
-        }
-        const docsConfig = validation.data;
-        const pagePath = normalizePagePath(options.page);
-        const contents = yield readPage(pagePath);
-        if (contents === null) {
-            addLog(_jsx(ErrorLog, { message: `Couldn't find a page at ${pageCandidates(pagePath).join(', ')}.` }));
-            return 1;
-        }
-        const { attributes } = parseFrontmatter(contents);
-        const pageParams = getOgPageParams({
-            path: pagePath,
-            title: (_b = (_a = stringAttribute(attributes, 'title')) !== null && _a !== void 0 ? _a : stringAttribute(attributes, 'sidebarTitle')) !== null && _b !== void 0 ? _b : slugToTitle(pageHref(pagePath)),
-            description: stringAttribute(attributes, 'description'),
-            thumbnail: attributes.thumbnail,
-        }, docsConfig);
-        const themeParams = applyThumbnailOverride(applyCardThemeOverride(deriveOgThemeParams(docsConfig), pageParams.thumbnail), options);
-        const input = yield buildOgCardInput(pageParams, themeParams, createLocalAssetLoaders(CMD_EXEC_PATH, remoteLoaders));
-        const png = yield renderOgCardPng(input);
-        const outputPath = options.output
-            ? path.resolve(options.output)
-            : yield defaultOutputPath(pagePath);
-        yield mkdir(path.dirname(outputPath), { recursive: true });
-        yield writeFile(outputPath, new Uint8Array(png));
-        for (const warning of checkOgCard(input, themeParams)) {
-            addLog(_jsx(WarningLog, { message: warning }));
-        }
-        addLog(_jsx(SuccessLog, { message: `Wrote ${outputPath}` }));
-        if (options.open && !process.env.CI)
-            yield open(outputPath);
-        return 0;
-    });
-}

package/bin/openApiCheck.js

@@ -1,99 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { applyOverlays, createOverlayRegistry, getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl, resolveOverlaysForSpec, validate, } from '@mintlify/common';
-import { discoverOverlayFiles, getMintIgnore, resolveFileRefs } from '@mintlify/prebuild';
-import { addLog, ErrorLog, SuccessLog, WarningLog } from '@mintlify/previewing';
-import { collectOpenApiOverlayConfig, extractOpenApiEntries, } from '@mintlify/validation';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { CMD_EXEC_PATH, readLocalOpenApiFile } from './helpers.js';
-export const getOpenApiFilenamesFromDocsConfig = (config) => {
-    var _a;
-    return extractOpenApiEntries((_a = config.api) === null || _a === void 0 ? void 0 : _a.openapi).map((entry) => entry.source);
-};
-/**
- * Builds the overlay registry so checks validate specs with overlays applied.
- * Throws when docs.json configures conflicting overlay lists, matching the build.
- */
-export const buildOverlayRegistryForCheck = (localSchema) => __awaiter(void 0, void 0, void 0, function* () {
-    // Discovery failures propagate and fail the check: silently skipping overlays would
-    // validate a different document than the one the build produces.
-    const mintIgnore = yield getMintIgnore(CMD_EXEC_PATH);
-    const discovered = yield discoverOverlayFiles(CMD_EXEC_PATH, mintIgnore);
-    let rawConfig;
-    try {
-        rawConfig = JSON.parse(yield fs.readFile(path.join(CMD_EXEC_PATH, 'docs.json'), 'utf-8'));
-    }
-    catch (_a) {
-        rawConfig = undefined;
-    }
-    if (rawConfig !== undefined) {
-        try {
-            rawConfig = (yield resolveFileRefs(rawConfig, CMD_EXEC_PATH)).resolved;
-        }
-        catch (_b) {
-            // Broken $refs are reported by regular config validation; collect from the root file.
-        }
-    }
-    const explicit = rawConfig == undefined ? undefined : collectOpenApiOverlayConfig(rawConfig);
-    if (explicit == undefined && discovered.length === 0)
-        return undefined;
-    return createOverlayRegistry({
-        explicit,
-        discovered,
-        localSchema,
-        loadLocalDocument: (normalizedPath) => readLocalOpenApiFile(normalizedPath),
-    });
-});
-const logOpenApiMessage = ({ level, message }) => {
-    addLog(level === 'success' ? (_jsx(SuccessLog, { message: message })) : level === 'warning' ? (_jsx(WarningLog, { message: message })) : (_jsx(ErrorLog, { message: message })));
-};
-export const checkOpenApiFile = (filename_1, localSchema_1, overlayRegistry_1, ...args_1) => __awaiter(void 0, [filename_1, localSchema_1, overlayRegistry_1, ...args_1], void 0, function* (filename, localSchema, overlayRegistry, report = logOpenApiMessage) {
-    try {
-        const overlays = overlayRegistry ? yield resolveOverlaysForSpec(overlayRegistry, filename) : [];
-        if (isAllowedLocalSchemaUrl(filename, localSchema)) {
-            yield getOpenApiDocumentFromUrl(filename, { overlays });
-            report({ level: 'success', message: 'OpenAPI definition is valid.' });
-            return true;
-        }
-        if (filename.startsWith('http://') && !localSchema) {
-            report({
-                level: 'warning',
-                message: 'include the --local-schema flag to check locally hosted OpenAPI files',
-            });
-            report({ level: 'warning', message: 'only https protocol is supported in production' });
-            return true;
-        }
-        const document = yield readLocalOpenApiFile(filename);
-        if (!document) {
-            throw new Error('failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.');
-        }
-        const overlaid = overlays.length > 0 ? applyOverlays(document, overlays) : document;
-        if (overlaid == undefined || typeof overlaid !== 'object') {
-            throw new Error('applying overlays produced an invalid OpenAPI document.');
-        }
-        yield validate(overlaid);
-        report({ level: 'success', message: 'OpenAPI definition is valid.' });
-        return true;
-    }
-    catch (err) {
-        if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
-            report({
-                level: 'error',
-                message: `file not found, please check the path provided: ${filename}`,
-            });
-        }
-        else {
-            report({ level: 'error', message: err instanceof Error ? err.message : 'unknown error' });
-        }
-        return false;
-    }
-});

package/bin/resolveFiles.js

@@ -1,114 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import fs from 'node:fs/promises';
-import path from 'node:path';
-const GLOB_CHARS = /[*?]/;
-const DOCS_FILE = /\.mdx?$/i;
-const REGEX_SPECIAL = /[.+^${}()|\\[\]]/;
-const SKIPPED_DIRS = new Set(['.git', 'node_modules']);
-function toPosix(filePath) {
-    return filePath.split(path.sep).join('/');
-}
-function normalizeArg(arg) {
-    return toPosix(arg).replace(/^\.\//, '');
-}
-function globToRegExp(pattern) {
-    let source = '';
-    let i = 0;
-    while (i < pattern.length) {
-        const char = pattern[i];
-        if (char === '*') {
-            if (pattern[i + 1] === '*') {
-                if (pattern[i + 2] === '/') {
-                    source += '(?:[^/]+/)*';
-                    i += 3;
-                }
-                else {
-                    source += '.*';
-                    i += 2;
-                }
-            }
-            else {
-                source += '[^/]*';
-                i += 1;
-            }
-        }
-        else if (char === '?') {
-            source += '[^/]';
-            i += 1;
-        }
-        else {
-            source += REGEX_SPECIAL.test(char) ? `\\${char}` : char;
-            i += 1;
-        }
-    }
-    return new RegExp(`^${source}$`);
-}
-function isFile(filePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return (yield fs.stat(filePath)).isFile();
-        }
-        catch (_a) {
-            return false;
-        }
-    });
-}
-function walk(baseDir_1) {
-    return __awaiter(this, arguments, void 0, function* (baseDir, dir = '') {
-        const entries = yield fs.readdir(path.join(baseDir, dir), { withFileTypes: true });
-        const files = [];
-        for (const entry of entries) {
-            if (SKIPPED_DIRS.has(entry.name))
-                continue;
-            const rel = dir ? `${dir}/${entry.name}` : entry.name;
-            if (entry.isDirectory()) {
-                files.push(...(yield walk(baseDir, rel)));
-            }
-            else {
-                files.push(rel);
-            }
-        }
-        return files;
-    });
-}
-export class NoMatchingFilesError extends Error {
-}
-export function resolveExplicitFiles(baseDir, args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let allFiles = null;
-        const matched = [];
-        const unmatched = [];
-        for (const arg of args) {
-            const pattern = normalizeArg(arg);
-            if (GLOB_CHARS.test(pattern)) {
-                allFiles = allFiles !== null && allFiles !== void 0 ? allFiles : (yield walk(baseDir));
-                const regex = globToRegExp(pattern);
-                const hits = allFiles.filter((file) => DOCS_FILE.test(file) && regex.test(file)).sort();
-                if (hits.length === 0) {
-                    unmatched.push(arg);
-                }
-                else {
-                    matched.push(...hits);
-                }
-            }
-            else if (yield isFile(path.join(baseDir, pattern))) {
-                matched.push(pattern);
-            }
-            else {
-                unmatched.push(arg);
-            }
-        }
-        if (unmatched.length > 0) {
-            throw new NoMatchingFilesError(`No matching files for: ${unmatched.join(', ')} (globs match .md and .mdx files)`);
-        }
-        return [...new Set(matched)];
-    });
-}

package/bin/score/client.js

@@ -1,40 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { authenticatedFetch } from '../authenticatedFetch.js';
-import { API_URL } from '../constants.js';
-export function resolveScoreForUrl(url) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const endpoint = new URL(`${API_URL}/api/cli/score`);
-        endpoint.searchParams.set('url', url);
-        const res = yield authenticatedFetch(endpoint.toString(), {
-            headers: { Accept: 'application/json' },
-        });
-        if (res.status !== 200 && res.status !== 202) {
-            const body = yield res.text().catch(() => '');
-            throw new Error(`API error (${res.status}): ${body || res.statusText}`);
-        }
-        return res.json();
-    });
-}
-export function fetchScoreBySlug(slug) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const endpoint = new URL(`${API_URL}/api/cli/score/${encodeURIComponent(slug)}`);
-        const res = yield authenticatedFetch(endpoint.toString(), {
-            headers: { Accept: 'application/json' },
-        });
-        if (res.status === 202)
-            return null;
-        if (!res.ok) {
-            const body = yield res.text().catch(() => '');
-            throw new Error(`API error (${res.status}): ${body || res.statusText}`);
-        }
-        return res.json();
-    });
-}

package/bin/score/index.js

@@ -1,211 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { addLog, ErrorLog, SpinnerLog, removeLastLog } from '@mintlify/previewing';
-import chalk from 'chalk';
-import { Text } from 'ink';
-import { getConfigValue } from '../config.js';
-import { terminate } from '../helpers.js';
-import { getAccessToken } from '../keyring.js';
-import { getCliSubdomains } from '../status.js';
-import { trackEvent } from '../telemetry/track.js';
-import { fetchScoreBySlug, resolveScoreForUrl } from './client.js';
-const POLL_INTERVAL_MS = 3000;
-const POLL_TIMEOUT_MS = 120000;
-function resolveFormat(argv) {
-    if (argv.format === 'table' || argv.format === 'plain' || argv.format === 'json')
-        return argv.format;
-    return 'table';
-}
-function statusIcon(status) {
-    switch (status) {
-        case 'pass':
-            return chalk.green('✓');
-        case 'warn':
-            return chalk.yellow('⚠');
-        case 'skip':
-            return chalk.dim('○');
-        case 'fail':
-        case 'error':
-            return chalk.red('✗');
-        default: {
-            const _exhaustive = status;
-            void _exhaustive;
-            return chalk.dim('?');
-        }
-    }
-}
-function plainStatusLabel(status) {
-    return status.toUpperCase();
-}
-function formatCheckName(name) {
-    return name
-        .replace(/[-_]+/g, ' ')
-        .replace(/([a-z])([A-Z])/g, '$1 $2')
-        .replace(/^./, (c) => c.toUpperCase())
-        .trim();
-}
-function renderChecks(checks, indent = 0) {
-    const lines = [];
-    const pad = '  '.repeat(indent + 1);
-    for (const check of checks) {
-        lines.push(`${pad}${statusIcon(check.status)}  ${formatCheckName(check.name)}`);
-        if (check.children && check.children.length > 0) {
-            lines.push(...renderChecks(check.children, indent + 1));
-        }
-    }
-    return lines;
-}
-function renderPlain(checks, prefix = '') {
-    const lines = [];
-    for (const check of checks) {
-        lines.push(`${prefix}${plainStatusLabel(check.status)}\t${check.name}`);
-        if (check.children && check.children.length > 0) {
-            lines.push(...renderPlain(check.children, prefix + '  '));
-        }
-    }
-    return lines;
-}
-function renderTable(score, opts) {
-    const scoreColor = score.overallScore >= 70 ? 'green' : score.overallScore >= 40 ? 'yellow' : 'red';
-    const header = (opts === null || opts === void 0 ? void 0 : opts.stale)
-        ? chalk.bold(`\nAgent Readiness Score — ${score.canonicalUrl}`) +
-            chalk.dim(` (last run ${new Date(score.computedAt).toLocaleString()})\n`)
-        : chalk.bold(`\nAgent Readiness Score — ${score.canonicalUrl}\n`);
-    const lines = [header];
-    lines.push(`  Score: ${chalk[scoreColor].bold(`${score.overallScore}%`)}\n`);
-    lines.push(chalk.bold('  Checks'));
-    lines.push(...renderChecks(score.checks));
-    return lines.join('\n');
-}
-function output(format, text) {
-    if (format === 'table') {
-        addLog(_jsx(Text, { children: text }));
-    }
-    else {
-        process.stdout.write(text + '\n');
-    }
-}
-function sleep(ms) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    });
-}
-function pollForScore(slug, afterIso, onAttempt) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const deadline = Date.now() + POLL_TIMEOUT_MS;
-        while (Date.now() < deadline) {
-            yield sleep(POLL_INTERVAL_MS);
-            onAttempt === null || onAttempt === void 0 ? void 0 : onAttempt();
-            const score = yield fetchScoreBySlug(slug);
-            if (!score)
-                continue;
-            if (afterIso === null)
-                return score;
-            if (new Date(score.computedAt).getTime() > new Date(afterIso).getTime())
-                return score;
-        }
-        throw new Error(`Score did not complete within ${POLL_TIMEOUT_MS / 1000}s`);
-    });
-}
-function resolveDefaultSubdomain() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fromConfig = getConfigValue('subdomain');
-        if (fromConfig)
-            return fromConfig;
-        const accessToken = yield getAccessToken();
-        if (!accessToken)
-            return undefined;
-        const subdomains = yield getCliSubdomains(accessToken);
-        return subdomains[0];
-    });
-}
-export const scoreHandler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const format = resolveFormat(argv);
-    try {
-        let url = argv.url;
-        if (!url) {
-            const subdomain = yield resolveDefaultSubdomain();
-            if (!subdomain) {
-                throw new Error('No URL provided and no default subdomain set. Run `mint login` to set one, or pass a URL: `mint score <url>`.');
-            }
-            url = `${subdomain}.mintlify.site`;
-        }
-        if (format === 'table')
-            addLog(_jsx(SpinnerLog, { message: "Checking agent readiness..." }));
-        const resolved = yield resolveScoreForUrl(url);
-        let final;
-        if (resolved.status === 'ready') {
-            const score = yield fetchScoreBySlug(resolved.slug);
-            if (format === 'table')
-                removeLastLog();
-            if (!score)
-                throw new Error('Score was unexpectedly unavailable');
-            final = score;
-        }
-        else if (resolved.status === 'stale_refresh_queued') {
-            const stale = yield fetchScoreBySlug(resolved.slug);
-            if (format === 'table')
-                removeLastLog();
-            if (!stale)
-                throw new Error('Stale score was unexpectedly unavailable');
-            if (format === 'table') {
-                output('table', renderTable(stale, { stale: true }));
-                addLog(_jsx(SpinnerLog, { message: "Refreshing score in the background..." }));
-            }
-            else {
-                process.stderr.write('Refreshing score in the background...\n');
-            }
-            final = yield pollForScore(resolved.slug, stale.computedAt);
-            if (format === 'table')
-                removeLastLog();
-        }
-        else {
-            if (format === 'table') {
-                removeLastLog();
-                addLog(_jsx(SpinnerLog, { message: "Queued a new scoring run. Waiting for first result..." }));
-            }
-            else {
-                process.stderr.write('Queued a new scoring run. Waiting for first result...\n');
-            }
-            final = yield pollForScore(resolved.slug, null);
-            if (format === 'table')
-                removeLastLog();
-        }
-        void trackEvent('cli.score.executed', {
-            url,
-            score: final.overallScore,
-            format,
-            status: resolved.status,
-        });
-        if (format === 'json') {
-            output(format, JSON.stringify(final, null, 2));
-        }
-        else if (format === 'plain') {
-            const lines = [`SCORE\t${final.overallScore}`, ...renderPlain(final.checks)];
-            output(format, lines.join('\n'));
-        }
-        else {
-            output(format, renderTable(final));
-        }
-        yield terminate(0);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'unknown error';
-        if (format === 'table') {
-            removeLastLog();
-            addLog(_jsx(ErrorLog, { message: message }));
-        }
-        else {
-            process.stderr.write(`Error: ${message}\n`);
-        }
-        yield terminate(1);
-    }
-});

package/bin/score/types.js

@@ -1 +0,0 @@
-export {};