@mintlify/cli 4.0.1813 → 4.1.2

package/__test__/brokenLinks.test.ts

@@ -1,283 +0,0 @@
-import { buildGraph, getBrokenExternalLinks } from '@mintlify/link-rot';
-import { MdxPath } from '@mintlify/link-rot/dist/graph.js';
-import { addLog, clearLogs } from '@mintlify/previewing';
-import path from 'node:path';
-import { mockProcessExit } from 'vitest-mock-process';
-
-import { checkForMintJson, CMD_EXEC_PATH, findDocsRoot } from '../src/helpers.js';
-import { resolveExplicitFiles } from '../src/resolveFiles.js';
-import { runCommand } from './utils.js';
-
-vi.mock('@mintlify/previewing', async (importOriginal) => {
-  const mod = await importOriginal<typeof import('@mintlify/previewing')>();
-  return { ...mod, addLog: vi.fn(), clearLogs: vi.fn() };
-});
-
-vi.mock('../src/helpers.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../src/helpers.js')>();
-  return {
-    ...actual,
-    checkForMintJson: vi.fn(),
-    findDocsRoot: vi.fn(),
-  };
-});
-
-vi.mock('../src/resolveFiles.js', () => ({
-  resolveExplicitFiles: vi.fn(),
-}));
-
-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,
-    buildGraph: vi.fn(),
-    getBrokenExternalLinks: vi.fn(),
-  };
-});
-
-const addLogSpy = vi.mocked(addLog);
-const clearLogsSpy = vi.mocked(clearLogs);
-const processExitMock = mockProcessExit();
-
-describe('brokenLinks', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(buildGraph).mockResolvedValue(mockGraph as never);
-    vi.mocked(resolveExplicitFiles).mockResolvedValue([]);
-    vi.mocked(findDocsRoot).mockResolvedValue(CMD_EXEC_PATH);
-    mockGraph.getBrokenInternalLinks.mockReturnValue([]);
-  });
-
-  it('success with no broken links', async () => {
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-
-    await runCommand('broken-links');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'checking for broken links...' },
-      })
-    );
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'no broken links found' },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(0);
-  });
-
-  it('fails with broken links', async () => {
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    mockGraph.getBrokenInternalLinks.mockReturnValue([
-      {
-        relativeDir: '.',
-        filename: 'introduction.mdx',
-        originalPath: '/api/invalid-path',
-        pathType: 'internal',
-      } as MdxPath,
-    ]);
-
-    await runCommand('broken-links');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'checking for broken links...' },
-      })
-    );
-    expect(clearLogsSpy).toHaveBeenCalled();
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: {
-          brokenLinksByFile: {
-            'introduction.mdx': ['/api/invalid-path'],
-          },
-        },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-
-  it('checks only files matching the provided option', async () => {
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(resolveExplicitFiles).mockResolvedValueOnce(['guides/selected.mdx']);
-    mockGraph.getBrokenInternalLinks.mockReturnValue([
-      {
-        relativeDir: 'guides',
-        filename: 'selected.mdx',
-        originalPath: '/api/selected-invalid',
-        pathType: 'internal',
-      } as MdxPath,
-      {
-        relativeDir: 'guides',
-        filename: 'other.mdx',
-        originalPath: '/api/other-invalid',
-        pathType: 'internal',
-      } as MdxPath,
-    ]);
-
-    await runCommand('broken-links', '--files', 'guides/selected.mdx', 'guides/**/*.mdx');
-
-    expect(resolveExplicitFiles).toHaveBeenCalledWith(CMD_EXEC_PATH, [
-      'guides/selected.mdx',
-      'guides/**/*.mdx',
-    ]);
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: {
-          brokenLinksByFile: {
-            [path.join('guides', 'selected.mdx')]: ['/api/selected-invalid'],
-          },
-        },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-
-  it('builds the graph from the docs root when run inside a content folder', async () => {
-    const docsRoot = path.resolve(CMD_EXEC_PATH, '..', '..');
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(findDocsRoot).mockResolvedValue(docsRoot);
-    vi.mocked(resolveExplicitFiles).mockResolvedValueOnce(['apis.mdx']);
-    mockGraph.getBrokenInternalLinks.mockReturnValue([]);
-
-    await runCommand('broken-links', '--files', 'apis.mdx');
-
-    expect(buildGraph).toHaveBeenCalledWith(docsRoot, expect.anything());
-    expect(processExitMock).toHaveBeenCalledWith(0);
-  });
-
-  it('rebases matched files onto the docs root so nested links still resolve', async () => {
-    const docsRoot = path.resolve(CMD_EXEC_PATH, '..', '..');
-    const nested = path.relative(docsRoot, path.join(CMD_EXEC_PATH, 'apis.mdx'));
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(findDocsRoot).mockResolvedValue(docsRoot);
-    vi.mocked(resolveExplicitFiles).mockResolvedValueOnce(['apis.mdx']);
-    mockGraph.getBrokenInternalLinks.mockReturnValue([
-      {
-        relativeDir: path.dirname(nested),
-        filename: 'apis.mdx',
-        originalPath: '/docs/authenticate',
-        pathType: 'internal',
-      } as MdxPath,
-    ]);
-
-    await runCommand('broken-links', '--files', 'apis.mdx');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { brokenLinksByFile: { [nested]: ['/docs/authenticate'] } },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-
-  it('fails when checking throws error', async () => {
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(buildGraph).mockRejectedValueOnce(new Error('some error'));
-
-    await runCommand('broken-links');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'checking for broken links...' },
-      })
-    );
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'some error' },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-});
-
-describe('brokenLinks --check-external', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(buildGraph).mockResolvedValue(mockGraph as never);
-    vi.mocked(resolveExplicitFiles).mockResolvedValue([]);
-    vi.mocked(findDocsRoot).mockResolvedValue(CMD_EXEC_PATH);
-    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('checks external links only from matching files', async () => {
-    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
-    vi.mocked(resolveExplicitFiles).mockResolvedValueOnce(['selected.mdx']);
-    vi.mocked(getBrokenExternalLinks).mockResolvedValueOnce([]);
-
-    await runCommand('broken-links', '--files', 'selected.mdx', '--check-external');
-
-    expect(getBrokenExternalLinks).toHaveBeenCalledWith(mockGraph, {
-      sourceFiles: new Set(['selected.mdx']),
-    });
-    expect(processExitMock).toHaveBeenCalledWith(0);
-  });
-
-  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/__test__/checkPort.test.ts

@@ -1,92 +0,0 @@
-import * as previewing from '@mintlify/previewing';
-import inquirer from 'inquirer';
-import { mockProcessExit } from 'vitest-mock-process';
-
-import { runCommand } from './utils.js';
-
-vi.mock('@mintlify/previewing', async () => {
-  const originalModule =
-    await vi.importActual<typeof import('@mintlify/previewing')>('@mintlify/previewing');
-  return {
-    ...originalModule,
-    dev: vi.fn(),
-  };
-});
-
-vi.mock('readline/promises', () => {
-  return {
-    createInterface: () => {
-      return {
-        close: () => undefined,
-        question: (question: string) => {
-          console.log(question);
-          return 'y';
-        },
-      };
-    },
-  };
-});
-
-const allowedPorts = [3000, 5002];
-
-vi.mock('detect-port', () => ({
-  default: (port: number) => (allowedPorts.includes(port) ? port : port + 1),
-}));
-
-const devSpy = vi.spyOn(previewing, 'dev');
-const addLogSpy = vi.spyOn(previewing, 'addLog');
-const processExitMock = mockProcessExit();
-
-describe('checkPort', () => {
-  let originalArgv: string[];
-
-  beforeEach(() => {
-    // Remove all cached modules, otherwise the same results are shown in subsequent tests.
-    vi.resetModules();
-
-    // mock inquirer prompt
-    vi.spyOn(inquirer, 'prompt').mockResolvedValue({ action: 'continue' });
-
-    // Keep track of original process arguments.
-    originalArgv = process.argv;
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-
-    // Set process arguments back to the original value.
-    process.argv = originalArgv;
-  });
-
-  it('should run dev command', async () => {
-    await runCommand('dev');
-
-    expect(devSpy).toHaveBeenCalledWith(expect.objectContaining({ port: 3000 }));
-  });
-
-  it('port 5000 and 5001 should be taken and 5002 should be accepted by the user and available.', async () => {
-    await runCommand('dev', '--port=5000');
-
-    expect(addLogSpy).toHaveBeenCalledTimes(2);
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'port 5000 is already in use. trying 5001 instead' },
-      })
-    );
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'port 5001 is already in use. trying 5002 instead' },
-      })
-    );
-  });
-
-  it('fails after the 10th used port', async () => {
-    await runCommand('dev', '--port=8000');
-
-    expect(addLogSpy).toHaveBeenCalledTimes(10);
-    expect(addLogSpy).toHaveBeenLastCalledWith(
-      expect.objectContaining({ props: { message: 'no available port found' } })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-});

package/__test__/deploy-github-actions.test.ts

@@ -1,202 +0,0 @@
-import { execFileSync, spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { deployFromGithubActions } from '../src/deploy-github-actions.js';
-
-const real = vi.hoisted(() => ({ spawn: undefined as unknown as typeof spawn }));
-vi.mock('node:child_process', async (importOriginal) => {
-  const original = await importOriginal<typeof import('node:child_process')>();
-  real.spawn = original.spawn;
-  return { ...original, spawn: vi.fn() };
-});
-
-const apiUrl = 'https://leaves.mintlify.com';
-const env = {
-  PATH: process.env.PATH,
-  HOME: process.env.HOME,
-  GITHUB_ACTIONS: 'true',
-  GITHUB_REPOSITORY: 'acme/monorepo',
-  ACTIONS_ID_TOKEN_REQUEST_URL: 'https://token.actions.example.com/request?api-version=2.0',
-  ACTIONS_ID_TOKEN_REQUEST_TOKEN: 'request-token',
-};
-const write = {
-  remote: 'https://git.example.com/repo.git',
-  branch: 'main',
-  token: 'write-token',
-  tokenExpiresAt: '2026-12-01T00:00:00.000Z',
-};
-let repo: string;
-
-const gitIn = (cwd: string, ...args: string[]) =>
-  execFileSync('git', args, { cwd, encoding: 'utf8' }).trim();
-const response = (body: unknown, status = 200) => new Response(JSON.stringify(body), { status });
-const pushCall = () => vi.mocked(spawn).mock.calls.find(([, args]) => args[0] === 'push');
-const stubFetch = (...bodies: Response[]) => {
-  const request = vi.fn();
-  for (const body of bodies) request.mockResolvedValueOnce(body);
-  vi.stubGlobal('fetch', request);
-  return request;
-};
-
-function pushExitsWith(code: number) {
-  vi.mocked(spawn).mockImplementation(((command: string, args: string[], options: object) => {
-    if (args[0] !== 'push') return real.spawn(command, args, options);
-    const child = new EventEmitter();
-    setImmediate(() => child.emit('close', code));
-    return child;
-  }) as typeof spawn);
-}
-
-beforeEach(() => {
-  vi.resetAllMocks();
-  pushExitsWith(0);
-  repo = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-gha-'));
-  fs.mkdirSync(path.join(repo, 'docs'));
-  fs.writeFileSync(path.join(repo, 'docs', 'docs.json'), '{}\n');
-  fs.writeFileSync(path.join(repo, 'app.ts'), 'export {};\n');
-  gitIn(repo, 'init', '-q', '-b', 'main');
-  gitIn(
-    repo,
-    '-c',
-    'user.name=Ada',
-    '-c',
-    'user.email=ada@acme.dev',
-    'commit',
-    '-q',
-    '--allow-empty',
-    '-m',
-    'root'
-  );
-  gitIn(repo, 'add', '-A');
-  gitIn(
-    repo,
-    '-c',
-    'user.name=Ada',
-    '-c',
-    'user.email=ada@acme.dev',
-    'commit',
-    '-q',
-    '-m',
-    'update docs'
-  );
-});
-afterEach(() => {
-  vi.unstubAllGlobals();
-  fs.rmSync(repo, { recursive: true, force: true });
-});
-
-describe('mint deploy in GitHub Actions', () => {
-  it('pushes only the docs directory as the site root', async () => {
-    const request = stubFetch(response({ value: 'oidc-jwt' }), response(write));
-    const directory = path.join(repo, 'docs');
-
-    await expect(
-      deployFromGithubActions({ apiUrl, directory, subdomain: 'my-docs' }, undefined, env)
-    ).resolves.toBe('https://my-docs.mintlify.site/');
-
-    expect(request.mock.calls[0]?.[0]).toBe(
-      `${env.ACTIONS_ID_TOKEN_REQUEST_URL}&audience=${encodeURIComponent(apiUrl)}`
-    );
-    expect(request.mock.calls[1]?.[0]).toBe(`${apiUrl}/api/agent/deployments/github-actions/token`);
-    expect(request.mock.calls[1]?.[1].headers.Authorization).toBe('Bearer oidc-jwt');
-
-    const [, args, options] = pushCall() ?? [];
-    const commit = String(args?.[3]).replace(':refs/heads/main', '');
-    expect(args).toEqual(['push', '--force', write.remote, `${commit}:refs/heads/main`]);
-    expect(args?.join(' ')).not.toContain('write-token');
-    expect(gitIn(repo, 'rev-parse', `${commit}^{tree}`)).toBe(
-      gitIn(repo, 'rev-parse', 'HEAD:docs')
-    );
-    expect(gitIn(repo, 'log', '-1', '--format=%an <%ae>%n%s', commit)).toBe(
-      'Ada <ada@acme.dev>\nupdate docs'
-    );
-    expect(gitIn(repo, 'log', '-1', '--format=%b', commit)).toBe(
-      `Deployed from acme/monorepo@${gitIn(repo, 'rev-parse', 'HEAD')}`
-    );
-    expect(options?.env).toMatchObject({
-      GIT_CONFIG_COUNT: '1',
-      GIT_CONFIG_KEY_0: `http.${write.remote}.extraHeader`,
-      GIT_CONFIG_VALUE_0: `Authorization: Basic ${Buffer.from('x-access-token:write-token').toString('base64')}`,
-    });
-  });
-
-  it('pushes the whole tree from the repository root', async () => {
-    stubFetch(response({ value: 'oidc-jwt' }), response(write));
-    await deployFromGithubActions(
-      { apiUrl, directory: repo, subdomain: 'my-docs' },
-      undefined,
-      env
-    );
-    const commit = String(pushCall()?.[1]?.[3]).replace(':refs/heads/main', '');
-    expect(gitIn(repo, 'rev-parse', `${commit}^{tree}`)).toBe(
-      gitIn(repo, 'rev-parse', 'HEAD^{tree}')
-    );
-  });
-
-  it('appends to existing git config environment entries', async () => {
-    stubFetch(response({ value: 'oidc-jwt' }), response(write));
-    await deployFromGithubActions({ apiUrl, directory: repo, subdomain: 'my-docs' }, undefined, {
-      ...env,
-      GIT_CONFIG_COUNT: '2',
-      GIT_CONFIG_KEY_0: 'core.quotepath',
-      GIT_CONFIG_VALUE_0: 'false',
-      GIT_CONFIG_KEY_1: 'color.ui',
-      GIT_CONFIG_VALUE_1: 'false',
-    });
-    expect(pushCall()?.[2]?.env).toMatchObject({
-      GIT_CONFIG_COUNT: '3',
-      GIT_CONFIG_KEY_2: `http.${write.remote}.extraHeader`,
-    });
-  });
-
-  it('asks for id-token: write when OIDC is unavailable', async () => {
-    const request = stubFetch();
-    await expect(
-      deployFromGithubActions({ apiUrl, directory: repo, subdomain: 'my-docs' }, undefined, {
-        ...env,
-        ACTIONS_ID_TOKEN_REQUEST_URL: undefined,
-      })
-    ).rejects.toThrow('permissions: id-token: write');
-    expect(request).not.toHaveBeenCalled();
-  });
-
-  it('requires --subdomain', async () => {
-    await expect(
-      deployFromGithubActions({ apiUrl, directory: repo }, undefined, env)
-    ).rejects.toThrow('--subdomain');
-  });
-
-  it('fails clearly when the directory is not in the checkout', async () => {
-    const request = stubFetch();
-    await expect(
-      deployFromGithubActions(
-        { apiUrl, directory: os.tmpdir(), subdomain: 'my-docs' },
-        undefined,
-        env
-      )
-    ).rejects.toThrow('Could not read');
-    expect(request).not.toHaveBeenCalled();
-  });
-
-  it('explains how to trust the repository on 403', async () => {
-    stubFetch(response({ value: 'oidc-jwt' }), response({ error: 'forbidden' }, 403));
-    await expect(
-      deployFromGithubActions({ apiUrl, directory: repo, subdomain: 'my-docs' }, undefined, env)
-    ).rejects.toThrow(
-      "This repository/branch isn't trusted to deploy my-docs. Run `mint deploy --github` locally"
-    );
-    expect(pushCall()).toBeUndefined();
-  });
-
-  it('fails when git push fails', async () => {
-    pushExitsWith(1);
-    stubFetch(response({ value: 'oidc-jwt' }), response(write));
-    await expect(
-      deployFromGithubActions({ apiUrl, directory: repo, subdomain: 'my-docs' }, undefined, env)
-    ).rejects.toThrow('git push to the site repository failed');
-  });
-});