@mintlify/cli 4.0.976 → 4.0.978

package/__test__/brokenLinks.test.ts

@@ -1,4 +1,4 @@
-import { getBrokenInternalLinks } from '@mintlify/link-rot';
+import { buildGraph, getBrokenExternalLinks } from '@mintlify/link-rot';
 import { MdxPath } from '@mintlify/link-rot/dist/graph.js';
 import * as previewing from '@mintlify/previewing';
 import { mockProcessExit } from 'vitest-mock-process';
@@ -14,11 +14,18 @@ vi.mock('../src/helpers.js', async () => {
   };
 });
 
+const mockGraph = {
+  precomputeFileResolutions: vi.fn(),
+  getBrokenInternalLinks: vi.fn().mockReturnValue([]),
+  getExternalPathsByNode: vi.fn().mockReturnValue(new Map()),
+};
+
 vi.mock('@mintlify/link-rot', async () => {
   const actual = await import('@mintlify/link-rot');
   return {
     ...actual,
-    getBrokenInternalLinks: vi.fn(),
+    buildGraph: vi.fn(),
+    getBrokenExternalLinks: vi.fn(),
   };
 });
 
@@ -29,15 +36,12 @@ const processExitMock = mockProcessExit();
 describe('brokenLinks', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
+    vi.mocked(buildGraph).mockResolvedValue(mockGraph as never);
+    mockGraph.getBrokenInternalLinks.mockReturnValue([]);
   });
 
   it('success with no broken links', async () => {
     vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(getBrokenInternalLinks).mockResolvedValueOnce([]);
 
     await runCommand('broken-links');
 
@@ -56,7 +60,7 @@ describe('brokenLinks', () => {
 
   it('fails with broken links', async () => {
     vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(getBrokenInternalLinks).mockResolvedValueOnce([
+    mockGraph.getBrokenInternalLinks.mockReturnValue([
       {
         relativeDir: '.',
         filename: 'introduction.mdx',
@@ -87,7 +91,7 @@ describe('brokenLinks', () => {
 
   it('fails when checking throws error', async () => {
     vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(getBrokenInternalLinks).mockRejectedValueOnce(new Error('some error'));
+    vi.mocked(buildGraph).mockRejectedValueOnce(new Error('some error'));
 
     await runCommand('broken-links');
 
@@ -104,3 +108,73 @@ describe('brokenLinks', () => {
     expect(processExitMock).toHaveBeenCalledWith(1);
   });
 });
+
+describe('brokenLinks --check-external', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(buildGraph).mockResolvedValue(mockGraph as never);
+    mockGraph.getBrokenInternalLinks.mockReturnValue([]);
+  });
+
+  it('success with no broken external links', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+    vi.mocked(getBrokenExternalLinks).mockResolvedValueOnce([]);
+
+    await runCommand('broken-links', '--check-external');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'no broken links found' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('fails with broken external links', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+    vi.mocked(getBrokenExternalLinks).mockResolvedValueOnce([
+      {
+        url: 'https://example.com/broken',
+        status: 404,
+        sources: [{ file: 'introduction.mdx', originalPath: 'https://example.com/broken' }],
+      },
+    ]);
+
+    await runCommand('broken-links', '--check-external');
+
+    expect(clearLogsSpy).toHaveBeenCalled();
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: {
+          brokenLinksByFile: {
+            'introduction.mdx': ['https://example.com/broken (404)'],
+          },
+        },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('fails when external link checking throws error', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+    vi.mocked(getBrokenExternalLinks).mockRejectedValueOnce(new Error('network error'));
+
+    await runCommand('broken-links', '--check-external');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'network error' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('does not check external links without --check-external flag', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+
+    await runCommand('broken-links');
+
+    expect(getBrokenExternalLinks).not.toHaveBeenCalled();
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+});

package/bin/cli.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { validate, getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl } from '@mintlify/common';
-import { getBrokenInternalLinks, renameFilesAndUpdateLinksInContent } from '@mintlify/link-rot';
+import { buildGraph, getBrokenExternalLinks, renameFilesAndUpdateLinksInContent, } from '@mintlify/link-rot';
 import { addLog, dev, validateBuild, ErrorLog, SpinnerLog, SuccessLog, Logs, clearLogs, BrokenLinksLog, WarningLog, } from '@mintlify/previewing';
 import { checkUrl } from '@mintlify/scraping';
 import { render, Text } from 'ink';
@@ -158,10 +158,21 @@ export const cli = ({ packageName = 'mint' }) => {
         }
         yield terminate(0);
     }))
-        .command('broken-links', 'check for invalid internal links', (yargs) => yargs.option('check-anchors', {
+        .command('broken-links', 'check for broken links', (yargs) => yargs
+        .option('check-anchors', {
         type: 'boolean',
         default: false,
         description: 'also validate anchor links (e.g. #section) against heading slugs',
+    })
+        .option('check-external', {
+        type: 'boolean',
+        default: false,
+        description: 'also check external links for broken URLs',
+    })
+        .option('check-snippets', {
+        type: 'boolean',
+        default: false,
+        description: 'also check links inside <Snippet> components',
     }), (argv) => __awaiter(void 0, void 0, void 0, function* () {
         const hasMintJson = yield checkForMintJson();
         if (!hasMintJson) {
@@ -169,25 +180,46 @@ export const cli = ({ packageName = 'mint' }) => {
         }
         addLog(_jsx(SpinnerLog, { message: "checking for broken links..." }));
         try {
-            const brokenLinks = yield getBrokenInternalLinks(undefined, {
+            const graph = yield buildGraph(undefined, {
+                checkSnippets: argv['check-snippets'],
+            });
+            graph.precomputeFileResolutions();
+            const brokenInternalLinks = graph.getBrokenInternalLinks({
                 checkAnchors: argv['check-anchors'],
             });
-            if (brokenLinks.length === 0) {
-                clearLogs();
-                addLog(_jsx(SuccessLog, { message: "no broken links found" }));
-                yield terminate(0);
-            }
             const brokenLinksByFile = {};
-            brokenLinks.forEach((mdxPath) => {
+            brokenInternalLinks.forEach((mdxPath) => {
                 const filename = path.join(mdxPath.relativeDir, mdxPath.filename);
-                const brokenLinksForFile = brokenLinksByFile[filename];
-                if (brokenLinksForFile) {
-                    brokenLinksForFile.push(mdxPath.originalPath);
+                const existing = brokenLinksByFile[filename];
+                if (existing) {
+                    existing.push(mdxPath.originalPath);
                 }
                 else {
                     brokenLinksByFile[filename] = [mdxPath.originalPath];
                 }
             });
+            if (argv['check-external']) {
+                const brokenExternalLinks = yield getBrokenExternalLinks(graph);
+                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 (Object.keys(brokenLinksByFile).length === 0) {
+                clearLogs();
+                addLog(_jsx(SuccessLog, { message: "no broken links found" }));
+                yield terminate(0);
+            }
             clearLogs();
             addLog(_jsx(BrokenLinksLog, { brokenLinksByFile: brokenLinksByFile }));
         }