@mintlify/previewing 4.0.593 → 4.0.595

package/dist/__tests__/dev.test.js

@@ -5,7 +5,7 @@ import { mockProcessExit } from 'vitest-mock-process';
 import { dev } from '../index.js';
 import { downloadTargetMint, getTargetMintVersion } from '../local-preview/client.js';
 import { run } from '../local-preview/run.js';
-import * as utils from '../util.js';
+import * as logs from '../logs.js';
 const originalChdir = process.chdir;
 vi.mock('fs-extra', () => {
     const mocks = {
@@ -33,30 +33,20 @@ vi.mock('../local-preview/run.js', () => ({
     run: vi.fn().mockResolvedValue(undefined),
 }));
 vi.mock('../util.js', () => {
-    const mockLogger = {
-        text: '',
-        succeed: vi.fn(),
-        fail: vi.fn(),
-        warn: vi.fn(),
-        start: vi.fn(),
-        stop: vi.fn(),
-        stopAndPersist: vi.fn(),
-    };
     return {
-        buildLogger: vi.fn().mockReturnValue(mockLogger),
         maybeFixMissingWindowsEnvVar: vi.fn(),
     };
 });
 const prebuildMock = vi.mocked(prebuild);
 const runMock = vi.mocked(run);
-const buildLoggerMock = vi.mocked(utils.buildLogger);
-const processExitMock = mockProcessExit();
 const downloadTargetMintMock = vi.mocked(downloadTargetMint);
 const defaultYargs = {
     _: [],
     $0: '',
     packageName: 'mintlify',
 };
+const addLogSpy = vi.spyOn(logs, 'addLog');
+const processExitMock = mockProcessExit();
 describe('dev', () => {
     beforeEach(() => {
         process.chdir = vi.fn();
@@ -67,73 +57,75 @@ describe('dev', () => {
     });
     it('happy path', async () => {
         await dev(defaultYargs);
-        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
         expect(prebuildMock).toHaveBeenCalled();
-        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
         expect(runMock).toHaveBeenCalled();
     });
     it('prebuild fails', async () => {
         const errorText = 'Some OpenAPI or docs.json schema error';
         prebuildMock.mockRejectedValueOnce(new Error(errorText));
         await dev(defaultYargs);
-        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
-        expect(buildLoggerMock().fail).toHaveBeenCalledWith(errorText);
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: errorText } }));
         expect(processExitMock).toHaveBeenCalledWith(1);
     });
     it('fails if no existing client version and no internet', async () => {
         vi.mocked(isOnline).mockResolvedValueOnce(false);
         vi.mocked(fse.pathExists).mockResolvedValueOnce();
         await dev(defaultYargs).catch(() => { });
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+            props: { message: 'running mintlify dev after updating requires an internet connection.' },
+        }));
         expect(processExitMock).toHaveBeenCalledWith(1);
-        expect(buildLoggerMock().fail).toHaveBeenCalledWith('Running mintlify dev after updating requires an internet connection.');
     });
     it('fails if no existing client version and no internet - mint command', async () => {
         vi.mocked(isOnline).mockResolvedValueOnce(false);
         vi.mocked(fse.pathExists).mockResolvedValueOnce();
         await dev({ ...defaultYargs, packageName: 'mint' }).catch(() => { });
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+            props: { message: 'running mint dev after updating requires an internet connection.' },
+        }));
         expect(processExitMock).toHaveBeenCalledWith(1);
-        expect(buildLoggerMock().fail).toHaveBeenCalledWith('Running mint dev after updating requires an internet connection.');
     });
     it('has existing version but fails to get targetMintVersion', async () => {
         vi.mocked(isOnline).mockResolvedValueOnce(false);
         vi.mocked(getTargetMintVersion).mockResolvedValueOnce(undefined);
         await dev(defaultYargs);
-        expect(buildLoggerMock().warn).toHaveBeenCalledWith('Failed to get latest Mintlify client version. Your current version is: 1.0.0, which may not be the latest Mintlify client version.');
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+            props: {
+                message: 'failed to retrieve latest version. Your current version is: 1.0.0, which may not be the latest version.',
+            },
+        }));
         expect(prebuildMock).toHaveBeenCalled();
-        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
         expect(runMock).toHaveBeenCalled();
     });
     it('downloads client with --client-version arg', async () => {
         await dev({ ...defaultYargs, 'client-version': '1.0.3' });
-        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
         expect(downloadTargetMintMock).toHaveBeenCalled();
         expect(prebuildMock).toHaveBeenCalled();
-        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
         expect(runMock).toHaveBeenCalled();
     });
     it('downloads client if no existing version', async () => {
         vi.mocked(fse.pathExists).mockResolvedValueOnce();
         await dev(defaultYargs);
-        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
         expect(downloadTargetMintMock).toHaveBeenCalled();
         expect(prebuildMock).toHaveBeenCalled();
-        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
         expect(runMock).toHaveBeenCalled();
     });
     it('warns about update if target version is different from existing version', async () => {
         vi.mocked(getTargetMintVersion).mockResolvedValueOnce('1.0.1');
         await dev(defaultYargs);
-        expect(buildLoggerMock().warn).toHaveBeenCalledWith('An update is available. Run `mintlify update` to update to the latest version.');
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { updateCommand: 'mintlify update' } }));
         expect(prebuildMock).toHaveBeenCalled();
-        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
         expect(runMock).toHaveBeenCalled();
     });
     it('warns about update if target version is different from existing version - mint command', async () => {
         vi.mocked(getTargetMintVersion).mockResolvedValueOnce('1.0.1');
         await dev({ ...defaultYargs, packageName: 'mint' });
-        expect(buildLoggerMock().warn).toHaveBeenCalledWith('An update is available. Run `mint update` to update to the latest version.');
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { updateCommand: 'mint update' } }));
         expect(prebuildMock).toHaveBeenCalled();
-        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
         expect(runMock).toHaveBeenCalled();
     });
 });

package/dist/__tests__/downloadTargetMint.test.js

@@ -4,6 +4,7 @@ import tar from 'tar';
 import { mockProcessExit } from 'vitest-mock-process';
 import * as constants from '../constants.js';
 import { downloadTargetMint } from '../local-preview/client.js';
+import * as logs from '../logs.js';
 import * as utils from '../util.js';
 vi.mock('fs-extra', () => {
     const mocks = {
@@ -20,15 +21,6 @@ vi.mock('fs-extra', () => {
     };
 });
 vi.mock('../util.js', () => ({
-    buildLogger: vi.fn().mockReturnValue({
-        text: '',
-        succeed: vi.fn(),
-        fail: vi.fn(),
-        warn: vi.fn(),
-        start: vi.fn(),
-        stop: vi.fn(),
-        stopAndPersist: vi.fn(),
-    }),
     restoreMintlifyLast: vi.fn().mockReturnValue(undefined),
     getTarUrl: vi.fn().mockReturnValue('https://asdfghjkl.cloudfront.net/mint-1.0.1.tar.gz'),
 }));
@@ -53,7 +45,6 @@ vi.mock('tar', () => {
         default: mocks,
     };
 });
-const buildLoggerMock = vi.mocked(utils.buildLogger);
 const restoreMintlifyLastMock = vi.mocked(utils.restoreMintlifyLast);
 const pipelineMock = vi.mocked(pipeline);
 const getTarUrlMock = vi.mocked(utils.getTarUrl);
@@ -63,17 +54,16 @@ const existsSyncMock = vi.mocked(fse.existsSync);
 const moveSyncMock = vi.mocked(fse.moveSync);
 const removeSyncMock = vi.mocked(fse.removeSync);
 const processExitMock = mockProcessExit();
+const addLogSpy = vi.spyOn(logs, 'addLog');
 describe('downloadTargetMint', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
     it('downloads and extracts a new version happy path', async () => {
-        const logger = buildLoggerMock();
         const targetMintVersion = '1.0.1';
         const versionString = '1.0.0';
         pipelineMock.mockResolvedValue(undefined);
         await downloadTargetMint({
-            logger,
             targetVersion: targetMintVersion,
             existingVersion: versionString,
         });
@@ -84,10 +74,11 @@ describe('downloadTargetMint', () => {
         });
         expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
         // Verify download and extraction
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'installing mintlify framework...' } }));
         expect(getTarUrlMock).toHaveBeenCalledWith(targetMintVersion);
         expect(pipelineMock).toHaveBeenCalled();
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'extracting mintlify framework...' } }));
         expect(tarMock.x).toHaveBeenCalled();
-        expect(logger.text).toBe('Extracting Mintlify framework...');
         // Verify cleanup
         expect(removeSyncMock).toHaveBeenCalledWith(constants.TAR_PATH);
         expect(removeSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY_LAST);
@@ -96,12 +87,10 @@ describe('downloadTargetMint', () => {
         expect(restoreMintlifyLastMock).not.toHaveBeenCalled();
     });
     it('downloads and extracts a specific client version happy path', async () => {
-        const logger = buildLoggerMock();
         const versionString = '1.0.0';
         const clientVersion = '2.0.0';
         pipelineMock.mockResolvedValue(undefined);
         await downloadTargetMint({
-            logger,
             targetVersion: clientVersion,
             existingVersion: versionString,
         });
@@ -112,10 +101,11 @@ describe('downloadTargetMint', () => {
         });
         expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
         // Verify download and extraction
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'installing mintlify framework...' } }));
         expect(getTarUrlMock).toHaveBeenCalledWith(clientVersion);
         expect(pipelineMock).toHaveBeenCalled();
+        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'extracting mintlify framework...' } }));
         expect(tarMock.x).toHaveBeenCalled();
-        expect(logger.text).toBe('Extracting Mintlify framework...');
         // Verify cleanup
         expect(removeSyncMock).toHaveBeenCalledWith(constants.TAR_PATH);
         expect(removeSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY_LAST);
@@ -128,12 +118,11 @@ describe('downloadTargetMint', () => {
             vi.clearAllMocks();
         });
         it('fails to download new version', async () => {
-            const logger = buildLoggerMock();
             const targetMintVersion = '1.0.1';
             const versionString = '1.0.0';
-            pipelineMock.mockRejectedValue(new Error('connection timed out'));
+            const errorMessage = 'connection timed out';
+            pipelineMock.mockRejectedValue(new Error(errorMessage));
             await downloadTargetMint({
-                logger,
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
             });
@@ -144,7 +133,12 @@ describe('downloadTargetMint', () => {
             });
             expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
             // Verify download fail
-            expect(logger.warn).toHaveBeenCalledWith('Failed to download Mintlify framework version 1.0.1, Error: connection timed out, falling back to existing version: 1.0.0');
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'installing mintlify framework...' } }));
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+                props: {
+                    message: `failed to install mintlify framework version ${targetMintVersion}, Error: ${errorMessage}, falling back to existing version: ${versionString}`,
+                },
+            }));
             // Verify use backup version
             expect(restoreMintlifyLastMock).toHaveBeenCalled();
             // Verify no extraction
@@ -154,15 +148,14 @@ describe('downloadTargetMint', () => {
             expect(writeFileSyncMock).not.toHaveBeenCalled();
         });
         it('fails to extract new version', async () => {
-            const logger = buildLoggerMock();
             const targetMintVersion = '1.0.1';
             const versionString = '1.0.0';
+            const errorMessage = 'zlib error';
             pipelineMock.mockResolvedValue(undefined);
             tarMock.x.mockImplementation(() => {
-                throw new Error('Zlib error');
+                throw new Error(errorMessage);
             });
             await downloadTargetMint({
-                logger,
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
             });
@@ -173,9 +166,15 @@ describe('downloadTargetMint', () => {
             });
             expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
             // Verify download success
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'installing mintlify framework...' } }));
             expect(pipelineMock).toHaveBeenCalled();
             // Verify extraction fail
-            expect(logger.warn).toHaveBeenCalledWith('Failed to extract Mintlify framework version 1.0.1, Error: Zlib error, using existing version: 1.0.0');
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'extracting mintlify framework...' } }));
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+                props: {
+                    message: `failed to extract mintlify framework version ${targetMintVersion}, Error: ${errorMessage}, using existing version: ${versionString}`,
+                },
+            }));
             // Verify use backup version
             expect(restoreMintlifyLastMock).toHaveBeenCalled();
             // Verify no cleanup
@@ -188,32 +187,39 @@ describe('downloadTargetMint', () => {
             vi.clearAllMocks();
         });
         it('fails to download new version with no fallback', async () => {
-            const logger = buildLoggerMock();
             const targetMintVersion = '1.0.1';
             const versionString = null;
-            pipelineMock.mockRejectedValue(new Error('connection timed out'));
+            const errorMessage = 'connection timed out';
+            pipelineMock.mockRejectedValue(new Error(errorMessage));
             await downloadTargetMint({
-                logger,
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
             });
-            expect(logger.fail).toHaveBeenCalledWith('Failed to download Mintlify framework version 1.0.1, Error: connection timed out');
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'installing mintlify framework...' } }));
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+                props: {
+                    message: `failed to install mintlify framework version ${targetMintVersion}, Error: ${errorMessage}`,
+                },
+            }));
             expect(processExitMock).toHaveBeenCalledWith(1);
         });
         it('fails to extract new version with no fallback', async () => {
-            const logger = buildLoggerMock();
             const targetMintVersion = '1.0.1';
             const versionString = null;
+            const errorMessage = 'zlib error';
             pipelineMock.mockResolvedValue(undefined);
             tarMock.x.mockImplementation(() => {
-                throw new Error('Zlib error');
+                throw new Error(errorMessage);
             });
             await downloadTargetMint({
-                logger,
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
             });
-            expect(logger.fail).toHaveBeenCalledWith('Failed to extract Mintlify framework version 1.0.1, Error: Zlib error');
+            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
+                props: {
+                    message: `failed to extract mintlify framework version ${targetMintVersion}, Error: ${errorMessage}`,
+                },
+            }));
             expect(processExitMock).toHaveBeenCalledWith(1);
         });
     });

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { getTargetMintVersion, downloadTargetMint } from './local-preview/client.js';
 import dev from './local-preview/index.js';
 import { getClientVersion } from './util.js';
+export * from './logs.js';
 export { dev, getClientVersion, getTargetMintVersion, downloadTargetMint };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { getTargetMintVersion, downloadTargetMint } from './local-preview/client.js';
 import dev from './local-preview/index.js';
 import { getClientVersion } from './util.js';
+export * from './logs.js';
 export { dev, getClientVersion, getTargetMintVersion, downloadTargetMint };

package/dist/local-preview/client.d.ts

@@ -1,7 +1,5 @@
-import type { Ora as OraType } from 'ora';
-export declare const getTargetMintVersion: (logger?: OraType) => Promise<string | undefined>;
-export declare const downloadTargetMint: ({ logger, targetVersion, existingVersion, }: {
-    logger: OraType | undefined;
+export declare const getTargetMintVersion: () => Promise<string | undefined>;
+export declare const downloadTargetMint: ({ targetVersion, existingVersion, }: {
     targetVersion: string;
     existingVersion: string | null;
 }) => Promise<void>;

package/dist/local-preview/client.js

@@ -1,11 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import fse from 'fs-extra';
 import got from 'got';
 import isOnline from 'is-online';
 import { pipeline } from 'node:stream/promises';
 import tar from 'tar';
 import { DOT_MINTLIFY, DOT_MINTLIFY_LAST, VERSION_PATH, TAR_PATH, TARGET_MINT_VERSION_URL, } from '../constants.js';
+import { addLog, clearLogs, ErrorLog, SpinnerLog, WarningLog } from '../logs.js';
 import { restoreMintlifyLast, getTarUrl } from '../util.js';
-export const getTargetMintVersion = async (logger) => {
+export const getTargetMintVersion = async () => {
     const hasInternet = await isOnline();
     if (!hasInternet) {
         return undefined;
@@ -15,20 +17,16 @@ export const getTargetMintVersion = async (logger) => {
         return response.body;
     }
     catch (error) {
-        if (logger) {
-            logger.text = `Failed to fetch the latest Mintlify version: ${error instanceof Error ? error.message : 'Unknown error'}`;
-        }
+        return undefined;
     }
-    return undefined;
 };
-export const downloadTargetMint = async ({ logger, targetVersion, existingVersion, }) => {
+export const downloadTargetMint = async ({ targetVersion, existingVersion, }) => {
     if (fse.existsSync(DOT_MINTLIFY)) {
         fse.moveSync(DOT_MINTLIFY, DOT_MINTLIFY_LAST, { overwrite: true });
     }
     fse.ensureDirSync(DOT_MINTLIFY);
-    if (logger) {
-        logger.text = 'Downloading Mintlify framework...';
-    }
+    clearLogs();
+    addLog(_jsx(SpinnerLog, { message: "installing mintlify framework..." }));
     const tarUrl = getTarUrl(targetVersion);
     let currentVersion = targetVersion.trim();
     try {
@@ -36,24 +34,21 @@ export const downloadTargetMint = async ({ logger, targetVersion, existingVersio
     }
     catch (error) {
         if (existingVersion) {
-            if (logger) {
-                logger.warn(`Failed to download Mintlify framework version ${currentVersion}, ${error}, falling back to existing version: ${existingVersion}`);
-            }
+            clearLogs();
+            addLog(_jsx(WarningLog, { message: `failed to install mintlify framework version ${currentVersion}, ${error}, falling back to existing version: ${existingVersion}` }));
             currentVersion = existingVersion;
             restoreMintlifyLast();
             return;
         }
         else {
-            if (logger) {
-                logger.fail(`Failed to download Mintlify framework version ${currentVersion}, ${error}`);
-            }
+            clearLogs();
+            addLog(_jsx(ErrorLog, { message: `failed to install mintlify framework version ${currentVersion}, ${error}` }));
             process.exit(1);
         }
     }
     try {
-        if (logger) {
-            logger.text = 'Extracting Mintlify framework...';
-        }
+        clearLogs();
+        addLog(_jsx(SpinnerLog, { message: "extracting mintlify framework..." }));
         tar.x({
             sync: true,
             file: TAR_PATH,
@@ -65,17 +60,15 @@ export const downloadTargetMint = async ({ logger, targetVersion, existingVersio
     }
     catch (error) {
         if (existingVersion) {
-            if (logger) {
-                logger.warn(`Failed to extract Mintlify framework version ${currentVersion}, ${error}, using existing version: ${existingVersion}`);
-            }
+            clearLogs();
+            addLog(_jsx(WarningLog, { message: `failed to extract mintlify framework version ${currentVersion}, ${error}, using existing version: ${existingVersion}` }));
             currentVersion = existingVersion;
             restoreMintlifyLast();
             return;
         }
         else {
-            if (logger) {
-                logger.fail(`Failed to extract Mintlify framework version ${currentVersion}, ${error}`);
-            }
+            clearLogs();
+            addLog(_jsx(ErrorLog, { message: `failed to extract mintlify framework version ${currentVersion}, ${error}` }));
             process.exit(1);
         }
     }

package/dist/local-preview/index.js

@@ -1,16 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { prebuild } from '@mintlify/prebuild';
 import fse, { pathExists } from 'fs-extra';
 import isOnline from 'is-online';
 import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, } from '../constants.js';
-import { buildLogger } from '../util.js';
+import { addLog, clearLogs, ErrorLog, SpinnerLog, UpdateLog, WarningLog } from '../logs.js';
 import { getTargetMintVersion, downloadTargetMint } from './client.js';
 import { run } from './run.js';
 const dev = async (argv) => {
-    // Note: We wait for specific text in the logger to be sure the server is ready when we e2e test the cli.
-    // If the cli output does not exactly match:
-    // "- Preparing local Mintlify instance...\n✔ Local Mintlify instance is ready. Launching your site...\nYour local preview is available at http://localhost:3000\nPress Ctrl+C any time to stop the local preview."
-    // the test will fail/require an update.
-    const logger = buildLogger('Preparing local Mintlify instance...');
     const hasInternet = await isOnline();
     const localSchema = argv['local-schema'];
     const clientVersion = argv['client-version'];
@@ -20,13 +16,14 @@ const dev = async (argv) => {
         ? fse.readFileSync(VERSION_PATH, 'utf8')
         : null;
     if (!versionString && !hasInternet) {
-        logger.fail(`Running ${packageName} dev after updating requires an internet connection.`);
+        clearLogs();
+        addLog(_jsx(ErrorLog, { message: `running ${packageName} dev after updating requires an internet connection.` }));
+        await new Promise((resolve) => setTimeout(resolve, 50));
         process.exit(1);
     }
-    const targetMintVersion = await getTargetMintVersion(logger);
+    const targetMintVersion = await getTargetMintVersion();
     if (!targetMintVersion) {
-        logger.stopAndPersist({ symbol: '✓' });
-        logger.warn(`Failed to get latest Mintlify client version. Your current version is: ${versionString?.trim()}, which may not be the latest Mintlify client version.`);
+        addLog(_jsx(WarningLog, { message: `failed to retrieve latest version. Your current version is: ${versionString?.trim()}, which may not be the latest version.` }));
     }
     // update the client if the user has provided a version with --client-version
     // or if there is no version and there is internet and the target version is available
@@ -34,28 +31,28 @@ const dev = async (argv) => {
         const version = clientVersion ?? targetMintVersion;
         if (version) {
             await downloadTargetMint({
-                logger,
                 targetVersion: version,
                 existingVersion: versionString,
             });
         }
     }
     if (versionString && targetMintVersion && versionString.trim() !== targetMintVersion.trim()) {
-        logger.warn(`An update is available. Run \`${packageName} update\` to update to the latest version.`);
+        addLog(_jsx(UpdateLog, { updateCommand: `${packageName} update` }));
     }
     // clear preexisting prebuild files
     fse.emptyDirSync(NEXT_PUBLIC_PATH);
     fse.emptyDirSync(NEXT_PROPS_PATH);
     process.chdir(CLIENT_PATH);
     try {
+        addLog(_jsx(SpinnerLog, { message: "preparing local preview..." }));
         await prebuild(CMD_EXEC_PATH, { localSchema });
     }
     catch (err) {
-        const errorText = err instanceof Error && err.message ? err.message : 'Prebuild step failed';
-        logger.fail(errorText);
+        const errorText = err instanceof Error && err.message ? err.message : 'prebuild step failed';
+        addLog(_jsx(ErrorLog, { message: errorText }));
+        await new Promise((resolve) => setTimeout(resolve, 50));
         process.exit(1);
     }
-    logger.succeed('Local Mintlify instance is ready. Launching your site...');
     await run(argv);
 };
 export default dev;

package/dist/local-preview/listener/index.js

@@ -1,3 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { findAndRemoveImports, hasImports, getFileCategory, openApiCheck, stringifyTree, } from '@mintlify/common';
 import { createPage, MintConfigUpdater, DocsConfigUpdater, preparseMdxTree, } from '@mintlify/prebuild';
 import Chalk from 'chalk';
@@ -8,6 +9,7 @@ import fs from 'fs/promises';
 import yaml from 'js-yaml';
 import pathUtil from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH, CLIENT_PATH } from '../../constants.js';
+import { AddedLog, addChangeLog, DeletedLog, EditedLog } from '../../logs.js';
 import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
 import { getDocsState } from './getDocsState.js';
@@ -28,32 +30,8 @@ const listener = (callback) => {
 };
 const onAddEvent = async (filename, callback) => {
     try {
-        const category = await onUpdateEvent(filename, callback);
-        switch (category) {
-            case 'page':
-                console.log('New page detected: ', filename);
-                break;
-            case 'snippet-v2':
-            case 'snippet':
-                console.log('New snippet detected: ', filename);
-                break;
-            case 'mintConfig':
-            case 'docsConfig':
-                console.log('Config added');
-                break;
-            case 'openApi':
-                console.log('OpenApi spec added: ', filename);
-                break;
-            case 'css':
-                console.log('CSS file added: ', filename);
-                break;
-            case 'js':
-                console.log('JS file added: ', filename);
-                break;
-            case 'staticFile':
-                console.log('Static file added: ', filename);
-                break;
-        }
+        await onUpdateEvent(filename, callback);
+        addChangeLog(_jsx(AddedLog, { filename: filename }));
     }
     catch (error) {
         console.error(error.message);
@@ -61,32 +39,8 @@ const onAddEvent = async (filename, callback) => {
 };
 const onChangeEvent = async (filename, callback) => {
     try {
-        const category = await onUpdateEvent(filename, callback);
-        switch (category) {
-            case 'page':
-                console.log('Page edited: ', filename);
-                break;
-            case 'snippet-v2':
-            case 'snippet':
-                console.log('Snippet edited: ', filename);
-                break;
-            case 'mintConfig':
-            case 'docsConfig':
-                console.log('Config edited');
-                break;
-            case 'openApi':
-                console.log('OpenApi spec edited: ', filename);
-                break;
-            case 'css':
-                console.log('CSS file edited: ', filename);
-                break;
-            case 'js':
-                console.log('JS file edited: ', filename);
-                break;
-            case 'staticFile':
-                console.log('Static file edited: ', filename);
-                break;
-        }
+        await onUpdateEvent(filename, callback);
+        addChangeLog(_jsx(EditedLog, { filename: filename }));
     }
     catch (error) {
         console.error(error.message);
@@ -107,36 +61,16 @@ const onUnlinkEvent = async (filename) => {
             await fse.remove(targetPath);
         }
         switch (potentialCategory) {
-            case 'page':
-                console.log(`Page deleted: ${filename}`);
-                break;
-            case 'snippet-v2':
-            case 'snippet':
-                console.log(`Snippet deleted: ${filename}`);
-                break;
             case 'mintConfig':
-                console.error('⚠️ mint.json has been deleted.');
+                console.error('mint.json has been deleted.');
                 await validateConfigFiles();
                 break;
             case 'docsConfig':
-                console.error('⚠️ docs.json has been deleted.');
+                console.error('docs.json has been deleted.');
                 await validateConfigFiles();
                 break;
-            case 'potentialJsonOpenApiSpec':
-            case 'potentialYamlOpenApiSpec':
-                await updateOpenApiFiles();
-                await updateGeneratedNav();
-                break;
-            case 'css':
-                console.log(`CSS file deleted: ${filename}`);
-                break;
-            case 'js':
-                console.log(`JS file deleted: ${filename}`);
-                break;
-            case 'staticFile':
-                console.log('Static file deleted: ', filename);
-                break;
         }
+        addChangeLog(_jsx(DeletedLog, { filename: filename }));
     }
     catch (error) {
         console.error(error.message);

package/dist/local-preview/network.d.ts

@@ -0,0 +1 @@
+export declare const getLocalNetworkIp: () => string | undefined;