@mintlify/cli 4.0.1812 → 4.1.1

package/bin/brokenLinks.js

@@ -1,122 +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 { buildGraph, getBrokenExternalLinks, getFilesLinksDependOn } from '@mintlify/link-rot';
-import { addLog, clearLogs, BrokenLinksLog, ErrorLog, SpinnerLog, SuccessLog, WarningLog, } from '@mintlify/previewing';
-import fs from 'node:fs/promises';
-import path from 'path';
-import { autoUpgradeIfNeeded, CMD_EXEC_PATH, findDocsRoot, terminate } from './helpers.js';
-import { resolveExplicitFiles } from './resolveFiles.js';
-export const brokenLinksHandler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    yield autoUpgradeIfNeeded();
-    addLog(_jsx(SpinnerLog, { message: "checking for broken links..." }));
-    try {
-        const docsRoot = yield findDocsRoot(CMD_EXEC_PATH);
-        const fileArgs = ((_a = argv.files) !== null && _a !== void 0 ? _a : []).map(String).filter(Boolean);
-        const sourceFiles = fileArgs.length > 0
-            ? new Set((yield resolveExplicitFiles(CMD_EXEC_PATH, fileArgs)).map((file) => path.relative(docsRoot, path.resolve(CMD_EXEC_PATH, file))))
-            : undefined;
-        // One unparseable page shouldn't hide every other result: report it and keep going
-        const parseErrorsByFile = new Map();
-        const graph = yield buildGraph(docsRoot, {
-            checkSnippets: argv['check-snippets'],
-            onParseError: (filePath, error) => parseErrorsByFile.set(filePath, error.message),
-        });
-        graph.precomputeFileResolutions();
-        // With --files, a failure elsewhere only matters when a selected link needs that
-        // file: an anchor pointing at it, or a snippet the selected page renders
-        const dependencies = sourceFiles
-            ? getFilesLinksDependOn(graph, sourceFiles, {
-                checkAnchors: argv['check-anchors'],
-                checkSnippets: argv['check-snippets'],
-            })
-            : undefined;
-        const parseErrors = [...parseErrorsByFile]
-            .filter(([filePath]) => !sourceFiles ||
-            sourceFiles.has(filePath) ||
-            (dependencies === null || dependencies === void 0 ? void 0 : dependencies.has(filePath.split(path.sep).join('/'))))
-            .map(([, message]) => message);
-        const brokenInternalLinks = graph
-            .getBrokenInternalLinks({
-            checkAnchors: argv['check-anchors'],
-        })
-            .filter(({ relativeDir, filename }) => !sourceFiles || sourceFiles.has(path.join(relativeDir, filename)));
-        const brokenLinksByFile = {};
-        brokenInternalLinks.forEach((mdxPath) => {
-            const filename = path.join(mdxPath.relativeDir, mdxPath.filename);
-            const existing = brokenLinksByFile[filename];
-            if (existing) {
-                existing.push(mdxPath.originalPath);
-            }
-            else {
-                brokenLinksByFile[filename] = [mdxPath.originalPath];
-            }
-        });
-        if (argv['check-external']) {
-            const brokenExternalLinks = yield getBrokenExternalLinks(graph, sourceFiles ? { sourceFiles } : undefined);
-            for (const result of brokenExternalLinks) {
-                for (const source of result.sources) {
-                    const label = result.status
-                        ? `${result.url} (${result.status})`
-                        : `${result.url} (${result.error})`;
-                    const existing = brokenLinksByFile[source.file];
-                    if (existing) {
-                        existing.push(label);
-                    }
-                    else {
-                        brokenLinksByFile[source.file] = [label];
-                    }
-                }
-            }
-        }
-        if (argv['check-redirects']) {
-            const brokenRedirects = graph.getBrokenRedirects();
-            if (brokenRedirects.length > 0) {
-                const configFilename = yield fs
-                    .access(path.join(docsRoot, 'docs.json'))
-                    .then(() => 'docs.json')
-                    .catch(() => 'mint.json');
-                const labels = brokenRedirects.map(({ source, destination }) => `${source} → ${destination}`);
-                const existing = brokenLinksByFile[configFilename];
-                if (existing) {
-                    existing.push(...labels);
-                }
-                else {
-                    brokenLinksByFile[configFilename] = labels;
-                }
-            }
-        }
-        const hasBrokenLinks = Object.keys(brokenLinksByFile).length > 0;
-        if (!hasBrokenLinks && parseErrors.length === 0) {
-            clearLogs();
-            addLog(_jsx(SuccessLog, { message: "no broken links found" }));
-            yield terminate(0);
-        }
-        clearLogs();
-        if (hasBrokenLinks) {
-            addLog(_jsx(BrokenLinksLog, { brokenLinksByFile: brokenLinksByFile }));
-        }
-        else {
-            addLog(_jsx(SuccessLog, { message: "no broken links found in the files that parsed" }));
-        }
-        for (const message of parseErrors) {
-            addLog(_jsx(ErrorLog, { message: message }));
-        }
-        if (parseErrors.length > 0) {
-            addLog(_jsx(WarningLog, { message: `skipped ${parseErrors.length} file(s) that could not be parsed; links in them were not checked` }));
-        }
-    }
-    catch (err) {
-        addLog(_jsx(ErrorLog, { message: err instanceof Error ? err.message : 'unknown error' }));
-        yield terminate(1);
-    }
-    yield terminate(1);
-});

package/bin/callbackServer.js

@@ -1,65 +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 { CALLBACK_PORT, DASHBOARD_URL } from './constants.js';
-export function startCallbackServer() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { default: http } = yield import('http');
-        let resolveCode;
-        let rejectCode;
-        let closed = false;
-        const codePromise = new Promise((res, rej) => {
-            resolveCode = res;
-            rejectCode = rej;
-        });
-        const server = http.createServer((req, res) => {
-            res.setHeader('Access-Control-Allow-Origin', DASHBOARD_URL);
-            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204);
-                res.end();
-                return;
-            }
-            if (req.method === 'POST') {
-                let body = '';
-                req.on('data', (chunk) => {
-                    body += chunk;
-                });
-                req.on('end', () => {
-                    try {
-                        const { code } = JSON.parse(body);
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true }));
-                        closed = true;
-                        server.close();
-                        resolveCode(code);
-                    }
-                    catch (_a) {
-                        res.writeHead(400);
-                        res.end(JSON.stringify({ error: 'invalid body' }));
-                    }
-                });
-            }
-            else {
-                res.writeHead(405);
-                res.end();
-            }
-        });
-        server.listen(CALLBACK_PORT, 'localhost');
-        const close = () => {
-            if (!closed) {
-                closed = true;
-                server.close();
-                rejectCode(new Error('Login cancelled'));
-            }
-        };
-        return { codePromise, close };
-    });
-}