@mintlify/cli 4.0.604 → 4.0.606

package/CONTRIBUTING.md

@@ -43,3 +43,7 @@ If for some reason the release workflow is broken or we can't access AWS program
 ## Manually overriding the client version used locally
 
 Run `mintlify dev --client-version x.x.xxxx` with the client version you would like to use and that version will be downloaded instead of the latest client version.
+
+## Breaking changes
+
+If cli or client contain breaking changes that require they are both updated together, change the MINIMUM_CLI_VERSION to make sure `mint dev` will silently update to a minimum viable CLI version.

package/__test__/brokenLinks.test.ts

@@ -0,0 +1,106 @@
+import { getBrokenInternalLinks } 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';
+
+import { checkForMintJson } from '../src/helpers.js';
+import { runCommand } from './utils.js';
+
+vi.mock('../src/helpers.js', async () => {
+  const actual = await import('../src/helpers.js');
+  return {
+    ...actual,
+    checkForMintJson: vi.fn(),
+  };
+});
+
+vi.mock('@mintlify/link-rot', async () => {
+  const actual = await import('@mintlify/link-rot');
+  return {
+    ...actual,
+    getBrokenInternalLinks: vi.fn(),
+  };
+});
+
+const addLogSpy = vi.spyOn(previewing, 'addLog');
+const clearLogsSpy = vi.spyOn(previewing, 'clearLogs');
+const processExitMock = mockProcessExit();
+
+describe('brokenLinks', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('success with no broken links', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+    vi.mocked(getBrokenInternalLinks).mockResolvedValueOnce([]);
+
+    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('success with broken links', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+    vi.mocked(getBrokenInternalLinks).mockResolvedValueOnce([
+      {
+        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(0);
+  });
+
+  it('error with broken links', async () => {
+    vi.mocked(checkForMintJson).mockResolvedValueOnce(true);
+    vi.mocked(getBrokenInternalLinks).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);
+  });
+});

package/__test__/{cli.test.ts → checkPort.test.ts}

@@ -1,9 +1,17 @@
-import { dev } from '@mintlify/previewing';
+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', () => ({ dev: vi.fn() }));
+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 {
@@ -25,7 +33,11 @@ vi.mock('detect-port', () => ({
   default: (port: number) => (allowedPorts.includes(port) ? port : port + 1),
 }));
 
-describe('cli', () => {
+const devSpy = vi.spyOn(previewing, 'dev');
+const addLogSpy = vi.spyOn(previewing, 'addLog');
+const processExitMock = mockProcessExit();
+
+describe('checkPort', () => {
   let originalArgv: string[];
 
   beforeEach(() => {
@@ -49,28 +61,32 @@ describe('cli', () => {
   it('should run dev command', async () => {
     await runCommand('dev');
 
-    expect(dev).toHaveBeenCalledWith(expect.objectContaining({ port: 3000 }));
+    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 () => {
-    const consoleSpy = vi.spyOn(console, 'log');
-
     await runCommand('dev', '--port=5000');
 
-    expect(consoleSpy).toHaveBeenCalledTimes(2);
-    expect(consoleSpy).toHaveBeenCalledWith(`Port 5000 is already in use. Trying 5001 instead.`);
-    expect(consoleSpy).toHaveBeenCalledWith(`Port 5001 is already in use. Trying 5002 instead.`);
-    expect(dev).toHaveBeenCalledWith(expect.objectContaining({ port: 5002 }));
+    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 () => {
-    const consoleSpy = vi.spyOn(console, 'log');
-
     await runCommand('dev', '--port=8000');
 
-    expect(consoleSpy).toHaveBeenCalledTimes(9);
-    expect(consoleSpy).toHaveBeenLastCalledWith(
-      `Port 8008 is already in use. Trying 8009 instead.`
+    expect(addLogSpy).toHaveBeenCalledTimes(10);
+    expect(addLogSpy).toHaveBeenLastCalledWith(
+      expect.objectContaining({ props: { message: 'no available port found' } })
     );
+    expect(processExitMock).toHaveBeenCalledWith(1);
   });
 });

package/__test__/minVersion.test.ts

@@ -1,25 +1,36 @@
-import { dev } from '@mintlify/previewing';
+import * as previewing from '@mintlify/previewing';
 
 import { LOCAL_LINKED_VERSION } from '../src/constants.js';
 import { getCliVersion } from '../src/helpers.js';
 import * as updateModule from '../src/update.js';
 import { runCommand } from './utils.js';
 
-vi.mock('../src/helpers.js', async (importOriginal) => {
-  const original = await importOriginal();
+vi.mock('@mintlify/previewing', async () => {
+  const originalModule =
+    await vi.importActual<typeof import('@mintlify/previewing')>('@mintlify/previewing');
   return {
-    // @ts-expect-error - this is a mock
-    ...original,
-    getCliVersion: vi.fn(),
+    ...originalModule,
+    dev: vi.fn().mockResolvedValue(undefined),
+    addLog: vi.fn().mockResolvedValue(undefined),
   };
 });
 
-vi.mock('@mintlify/previewing', () => ({ dev: vi.fn() }));
+vi.mock('../src/helpers.js', async () => {
+  const originalModule =
+    await vi.importActual<typeof import('../src/helpers.js')>('../src/helpers.js');
+  return {
+    ...originalModule,
+    getCliVersion: vi.fn(),
+  };
+});
 
 vi.mock('../src/update.js', () => ({
   update: vi.fn().mockResolvedValue(undefined),
 }));
 
+const devSpy = vi.spyOn(previewing, 'dev');
+const addLogSpy = vi.spyOn(previewing, 'addLog');
+
 describe('minimum version', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -36,7 +47,8 @@ describe('minimum version', () => {
     await runCommand('dev');
 
     expect(updateSpy).toHaveBeenCalled();
-    expect(dev).toHaveBeenCalled();
+    expect(devSpy).toHaveBeenCalled();
+    expect(addLogSpy).not.toHaveBeenCalled();
   });
   it('should not update the cli if the version is above the minimum', async () => {
     vi.mocked(getCliVersion).mockReturnValueOnce('4.2.1');
@@ -45,7 +57,8 @@ describe('minimum version', () => {
     await runCommand('dev');
 
     expect(updateSpy).not.toHaveBeenCalled();
-    expect(dev).toHaveBeenCalled();
+    expect(devSpy).toHaveBeenCalled();
+    expect(addLogSpy).not.toHaveBeenCalled();
   });
   it('should not update the cli if the version is linked to local package', async () => {
     vi.mocked(getCliVersion).mockReturnValueOnce(LOCAL_LINKED_VERSION);
@@ -54,6 +67,7 @@ describe('minimum version', () => {
     await runCommand('dev');
 
     expect(updateSpy).not.toHaveBeenCalled();
-    expect(dev).toHaveBeenCalled();
+    expect(devSpy).toHaveBeenCalled();
+    expect(addLogSpy).not.toHaveBeenCalled();
   });
 });

package/__test__/openApiCheck.test.ts

@@ -0,0 +1,127 @@
+import { getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl, validate } from '@mintlify/common';
+import * as previewing from '@mintlify/previewing';
+import { mockProcessExit } from 'vitest-mock-process';
+
+import { readLocalOpenApiFile } from '../src/helpers.js';
+import { mockValidOpenApiDocument, runCommand } from './utils.js';
+
+vi.mock('@mintlify/common', () => ({
+  getOpenApiDocumentFromUrl: vi.fn(),
+  isAllowedLocalSchemaUrl: vi.fn(),
+  validate: vi.fn(),
+}));
+
+vi.mock('../src/helpers.js', async () => {
+  const originalModule = await import('../src/helpers.js');
+  return {
+    ...originalModule,
+    readLocalOpenApiFile: vi.fn(),
+  };
+});
+
+const addLogSpy = vi.spyOn(previewing, 'addLog');
+const processExitMock = mockProcessExit();
+
+describe('openApiCheck', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('valid openApi file from url', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(true);
+    vi.mocked(getOpenApiDocumentFromUrl).mockResolvedValueOnce(mockValidOpenApiDocument);
+
+    await runCommand('openapi-check', 'https://petstore3.swagger.io/api/v3/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'OpenAPI definition is valid.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('invalid openApi file from url', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(true);
+    vi.mocked(getOpenApiDocumentFromUrl).mockRejectedValueOnce(
+      new Error('Could not parse OpenAPI document.')
+    );
+
+    await runCommand('openapi-check', 'https://petstore3.swagger.io/api/v3/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'Could not parse OpenAPI document.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('valid openApi file from localhost', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(true);
+    vi.mocked(getOpenApiDocumentFromUrl).mockResolvedValueOnce(mockValidOpenApiDocument);
+
+    await runCommand('openapi-check', 'http://localhost:3000/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'OpenAPI definition is valid.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('invalid openApi file from localhost', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(false);
+    vi.mocked(readLocalOpenApiFile).mockResolvedValueOnce(undefined);
+
+    await runCommand('openapi-check', 'http://localhost:3000/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: {
+          message:
+            'failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.',
+        },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('valid openApi file from local file', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(false);
+    vi.mocked(readLocalOpenApiFile).mockResolvedValueOnce(mockValidOpenApiDocument);
+    vi.mocked(validate).mockResolvedValueOnce({
+      valid: true,
+      errors: [],
+    });
+
+    await runCommand('openapi-check', 'test/openapi.yaml');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'OpenAPI definition is valid.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('invalid openApi file from local file', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(false);
+    vi.mocked(readLocalOpenApiFile).mockResolvedValueOnce(mockValidOpenApiDocument);
+    vi.mocked(validate).mockRejectedValueOnce(new Error('some schema parsing error'));
+
+    await runCommand('openapi-check', 'test/openapi.yaml');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'some schema parsing error' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+});

package/__test__/update.test.ts

@@ -1,25 +1,25 @@
-import { getTargetMintVersion, downloadTargetMint } from '@mintlify/previewing';
-import { execSync } from 'node:child_process';
-import { mockProcessExit } from 'vitest-mock-process';
+import * as previewing from '@mintlify/previewing';
 
-import { getLatestCliVersion, getVersions } from '../src/helpers.js';
+import { getLatestCliVersion, getVersions, execAsync } from '../src/helpers.js';
 import { update } from '../src/update.js';
 
-vi.mock('node:child_process', () => ({
-  execSync: vi.fn(),
-}));
-
-vi.mock('@mintlify/previewing', () => ({
-  getClientVersion: vi.fn(),
-  getTargetMintVersion: vi.fn(),
-  downloadTargetMint: vi.fn(),
-}));
+vi.mock('@mintlify/previewing', async () => {
+  const originalModule =
+    await vi.importActual<typeof import('@mintlify/previewing')>('@mintlify/previewing');
+  return {
+    ...originalModule,
+    getClientVersion: vi.fn(),
+    getTargetMintVersion: vi.fn(),
+    downloadTargetMint: vi.fn(),
+  };
+});
 
-vi.mock('../src/helpers.js', async (importOriginal) => {
-  const original = await importOriginal();
+vi.mock('../src/helpers.js', async () => {
+  const originalModule =
+    await vi.importActual<typeof import('../src/helpers.js')>('../src/helpers.js');
   return {
-    // @ts-expect-error - this is a mock
-    ...original,
+    ...originalModule,
+    execAsync: vi.fn(),
     getLatestCliVersion: vi.fn(),
     getVersions: vi.fn().mockReturnValue({
       cli: '1.0.0',
@@ -28,7 +28,7 @@ vi.mock('../src/helpers.js', async (importOriginal) => {
   };
 });
 
-const processExitMock = mockProcessExit();
+const addLogSpy = vi.spyOn(previewing, 'addLog');
 
 describe('update', () => {
   beforeEach(() => {
@@ -44,16 +44,50 @@ describe('update', () => {
       cli: '1.0.0',
       client: '1.0.0',
     });
-    vi.mocked(getTargetMintVersion).mockResolvedValue('2.0.0');
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('2.0.0');
     vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
-    vi.mocked(execSync).mockReturnValue(Buffer.from(''));
-    vi.mocked(downloadTargetMint).mockResolvedValue();
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+    vi.mocked(previewing.downloadTargetMint).mockResolvedValue();
 
     await update({ packageName: 'mintlify' });
 
-    expect(execSync).toHaveBeenCalledWith('npm install -g mintlify@latest --silent');
-    expect(downloadTargetMint).toHaveBeenCalledWith({
-      logger: expect.any(Object),
+    expect(addLogSpy).toHaveBeenCalledTimes(4);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating mintlify package...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating mintlify client to 2.0.0...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'updated mintlify to the latest version: 2.0.0' },
+      })
+    );
+    expect(execAsync).toHaveBeenCalledWith('npm install -g mintlify@latest --silent');
+    expect(previewing.downloadTargetMint).toHaveBeenCalledWith({
+      targetVersion: '2.0.0',
+      existingVersion: '1.0.0',
+    });
+  });
+
+  it('should update the cli and client successfully - silently', async () => {
+    vi.mocked(getVersions).mockReturnValue({
+      cli: '1.0.0',
+      client: '1.0.0',
+    });
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('2.0.0');
+    vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+    vi.mocked(previewing.downloadTargetMint).mockResolvedValue();
+
+    await update({ packageName: 'mintlify', silent: true });
+
+    expect(addLogSpy).not.toHaveBeenCalled();
+    expect(execAsync).toHaveBeenCalledWith('npm install -g mintlify@latest --silent');
+    expect(previewing.downloadTargetMint).toHaveBeenCalledWith({
       targetVersion: '2.0.0',
       existingVersion: '1.0.0',
     });
@@ -65,14 +99,38 @@ describe('update', () => {
       client: '1.0.0',
     });
     vi.mocked(getLatestCliVersion).mockReturnValue('1.0.0');
-    vi.mocked(getTargetMintVersion).mockResolvedValue('1.0.0');
-    vi.mocked(execSync).mockReturnValue(Buffer.from(''));
-    vi.mocked(downloadTargetMint).mockResolvedValue();
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('1.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+    vi.mocked(previewing.downloadTargetMint).mockResolvedValue();
 
     await update({ packageName: 'mintlify' });
 
-    expect(execSync).not.toHaveBeenCalled();
-    expect(downloadTargetMint).not.toHaveBeenCalled();
+    expect(addLogSpy).toHaveBeenCalledTimes(2);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'already up to date' } })
+    );
+    expect(execAsync).not.toHaveBeenCalled();
+    expect(previewing.downloadTargetMint).not.toHaveBeenCalled();
+  });
+
+  it('should return when already up to date - silently', async () => {
+    vi.mocked(getVersions).mockReturnValue({
+      cli: '1.0.0',
+      client: '1.0.0',
+    });
+    vi.mocked(getLatestCliVersion).mockReturnValue('1.0.0');
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('1.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+    vi.mocked(previewing.downloadTargetMint).mockResolvedValue();
+
+    await update({ packageName: 'mintlify', silent: true });
+
+    expect(addLogSpy).not.toHaveBeenCalled();
+    expect(execAsync).not.toHaveBeenCalled();
+    expect(previewing.downloadTargetMint).not.toHaveBeenCalled();
   });
 
   it('should only update cli if client version is up to date', async () => {
@@ -81,13 +139,26 @@ describe('update', () => {
       client: '2.0.0',
     });
     vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
-    vi.mocked(getTargetMintVersion).mockResolvedValue('2.0.0');
-    vi.mocked(execSync).mockReturnValue(Buffer.from(''));
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('2.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
 
     await update({ packageName: 'mintlify' });
 
-    expect(execSync).toHaveBeenCalledWith('npm install -g mintlify@latest --silent');
-    expect(downloadTargetMint).not.toHaveBeenCalled();
+    expect(addLogSpy).toHaveBeenCalledTimes(3);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating mintlify package...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'updated mintlify to the latest version: 2.0.0' },
+      })
+    );
+
+    expect(execAsync).toHaveBeenCalledWith('npm install -g mintlify@latest --silent');
+    expect(previewing.downloadTargetMint).not.toHaveBeenCalled();
   });
 
   it('should only update client if cli version is up to date', async () => {
@@ -96,14 +167,26 @@ describe('update', () => {
       client: '1.0.0',
     });
     vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
-    vi.mocked(getTargetMintVersion).mockResolvedValue('2.0.0');
-    vi.mocked(execSync).mockReturnValue(Buffer.from(''));
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('2.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
 
     await update({ packageName: 'mintlify' });
 
-    expect(execSync).not.toHaveBeenCalled();
-    expect(downloadTargetMint).toHaveBeenCalledWith({
-      logger: expect.any(Object),
+    expect(addLogSpy).toHaveBeenCalledTimes(3);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating mintlify client to 2.0.0...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'updated mintlify to the latest version: 2.0.0' },
+      })
+    );
+
+    expect(execAsync).not.toHaveBeenCalled();
+    expect(previewing.downloadTargetMint).toHaveBeenCalledWith({
       targetVersion: '2.0.0',
       existingVersion: '1.0.0',
     });
@@ -115,13 +198,21 @@ describe('update', () => {
       client: '1.0.0',
     });
     vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
-    vi.mocked(getTargetMintVersion).mockResolvedValue('2.0.0');
-    vi.mocked(execSync).mockImplementation(() => {
-      throw new Error('Update failed');
-    });
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('2.0.0');
+    vi.mocked(execAsync).mockRejectedValue(new Error('Update failed'));
 
     await update({ packageName: 'mintlify' });
-    expect(processExitMock).toHaveBeenCalledWith(1);
+
+    expect(addLogSpy).toHaveBeenCalledTimes(3);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating mintlify package...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'failed to update mintlify@latest' } })
+    );
   });
 
   it('should handle client update failure', async () => {
@@ -130,11 +221,21 @@ describe('update', () => {
       client: '1.0.0',
     });
     vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
-    vi.mocked(getTargetMintVersion).mockResolvedValue('2.0.0');
-    vi.mocked(execSync).mockReturnValue(Buffer.from(''));
-    vi.mocked(downloadTargetMint).mockRejectedValue(new Error('Download failed'));
+    vi.mocked(previewing.getTargetMintVersion).mockResolvedValue('2.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+    vi.mocked(previewing.downloadTargetMint).mockRejectedValue(new Error('Download failed'));
 
     await update({ packageName: 'mintlify' });
-    expect(processExitMock).toHaveBeenCalledWith(1);
+
+    expect(addLogSpy).toHaveBeenCalledTimes(4);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating mintlify client to 2.0.0...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'failed to update mintlify client to 2.0.0' } })
+    );
   });
 });

package/__test__/utils.ts

@@ -9,3 +9,12 @@ export async function runCommand(...args: string[]) {
   process.argv = ['node', 'cli.js', ...args];
   return cli();
 }
+
+export const mockValidOpenApiDocument = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Test API',
+    version: '1.0.0',
+  },
+  components: {},
+};