@mintlify/previewing 4.0.526 → 4.0.528

package/dist/__tests__/dev.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/dev.test.js

@@ -0,0 +1,125 @@
+import { prebuild } from '@mintlify/prebuild';
+import fse from 'fs-extra';
+import isOnline from 'is-online';
+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';
+const originalChdir = process.chdir;
+vi.mock('fs-extra', () => {
+    const mocks = {
+        ensureDir: vi.fn().mockResolvedValue(undefined),
+        pathExists: vi.fn().mockResolvedValue(true),
+        readFileSync: vi.fn().mockReturnValue('1.0.0'),
+        emptyDirSync: vi.fn().mockResolvedValue(undefined),
+    };
+    return {
+        ...mocks,
+        default: mocks,
+    };
+});
+vi.mock('../local-preview/client.js', () => ({
+    getTargetMintVersion: vi.fn().mockResolvedValue('1.0.0'),
+    downloadTargetMint: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('is-online', () => ({
+    default: vi.fn().mockResolvedValue(true),
+}));
+vi.mock('@mintlify/prebuild', () => ({
+    prebuild: vi.fn().mockResolvedValue(undefined),
+}));
+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 emptyYargs = {
+    _: [],
+    $0: '',
+};
+describe('dev', () => {
+    beforeEach(() => {
+        process.chdir = vi.fn();
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.chdir = originalChdir;
+    });
+    it('happy path', async () => {
+        await dev(emptyYargs);
+        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
+        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(emptyYargs);
+        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
+        expect(buildLoggerMock().fail).toHaveBeenCalledWith(errorText);
+        expect(processExitMock).toHaveBeenCalledWith(1);
+    });
+});
+describe('dev with no internet', () => {
+    beforeEach(() => {
+        process.chdir = vi.fn();
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.chdir = originalChdir;
+    });
+    it('fails if no existing version', async () => {
+        vi.mocked(isOnline).mockResolvedValueOnce(false);
+        vi.mocked(fse.pathExists).mockResolvedValueOnce();
+        await dev(emptyYargs).catch(() => { });
+        expect(processExitMock).toHaveBeenCalledWith(1);
+        expect(buildLoggerMock().fail).toHaveBeenCalledWith('Running mintlify dev afer 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(emptyYargs);
+        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(prebuildMock).toHaveBeenCalled();
+        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
+        expect(runMock).toHaveBeenCalled();
+    });
+});
+describe('dev downloads new version', () => {
+    beforeEach(() => {
+        process.chdir = vi.fn();
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.chdir = originalChdir;
+    });
+    it('happy path', async () => {
+        vi.mocked(getTargetMintVersion).mockResolvedValueOnce('1.0.1');
+        await dev(emptyYargs);
+        expect(buildLoggerMock).toHaveBeenCalledWith('Preparing local Mintlify instance...');
+        expect(downloadTargetMintMock).toHaveBeenCalled();
+        expect(prebuildMock).toHaveBeenCalled();
+        expect(buildLoggerMock().succeed).toHaveBeenCalledWith('Local Mintlify instance is ready. Launching your site...');
+        expect(runMock).toHaveBeenCalled();
+    });
+});

package/dist/__tests__/downloadTargetMint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/downloadTargetMint.test.js

@@ -0,0 +1,219 @@
+import fse from 'fs-extra';
+import { pipeline } from 'node:stream/promises';
+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 utils from '../util.js';
+vi.mock('fs-extra', () => {
+    const mocks = {
+        existsSync: vi.fn().mockReturnValue(true),
+        moveSync: vi.fn().mockReturnValue(undefined),
+        ensureDirSync: vi.fn().mockReturnValue(undefined),
+        removeSync: vi.fn().mockReturnValue(undefined),
+        writeFileSync: vi.fn().mockReturnValue(undefined),
+        createWriteStream: vi.fn().mockReturnValue({ write: vi.fn(), end: vi.fn() }),
+    };
+    return {
+        ...mocks,
+        default: mocks,
+    };
+});
+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),
+}));
+vi.mock('node:stream/promises', () => ({
+    pipeline: vi.fn(),
+}));
+vi.mock('got', () => {
+    const mocks = {
+        stream: vi.fn().mockReturnValue({ pipe: vi.fn(), on: vi.fn() }),
+    };
+    return {
+        ...mocks,
+        default: mocks,
+    };
+});
+vi.mock('tar', () => {
+    const mocks = {
+        x: vi.fn(),
+    };
+    return {
+        ...mocks,
+        default: mocks,
+    };
+});
+const buildLoggerMock = vi.mocked(utils.buildLogger);
+const restoreMintlifyLastMock = vi.mocked(utils.restoreMintlifyLast);
+const pipelineMock = vi.mocked(pipeline);
+const GET_TAR_URL_SPY = vi.spyOn(constants, 'GET_TAR_URL');
+const writeFileSyncMock = vi.mocked(fse.writeFileSync);
+const tarMock = vi.mocked(tar);
+const existsSyncMock = vi.mocked(fse.existsSync);
+const moveSyncMock = vi.mocked(fse.moveSync);
+const removeSyncMock = vi.mocked(fse.removeSync);
+const processExitMock = mockProcessExit();
+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,
+        });
+        // Verify backup was created
+        expect(existsSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+        expect(moveSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY, constants.DOT_MINTLIFY_LAST, {
+            overwrite: true,
+        });
+        expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+        // Verify download and extraction
+        expect(GET_TAR_URL_SPY).toHaveBeenCalledWith(targetMintVersion);
+        expect(pipelineMock).toHaveBeenCalled();
+        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);
+        expect(writeFileSyncMock).toHaveBeenCalledWith(constants.VERSION_PATH, targetMintVersion);
+        // Verify no restore was needed
+        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,
+        });
+        // Verify backup was created
+        expect(existsSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+        expect(moveSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY, constants.DOT_MINTLIFY_LAST, {
+            overwrite: true,
+        });
+        expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+        // Verify download and extraction
+        expect(GET_TAR_URL_SPY).toHaveBeenCalledWith(clientVersion);
+        expect(pipelineMock).toHaveBeenCalled();
+        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);
+        expect(writeFileSyncMock).toHaveBeenCalledWith(constants.VERSION_PATH, clientVersion);
+        // Verify no restore was needed
+        expect(restoreMintlifyLastMock).not.toHaveBeenCalled();
+    });
+    describe('downloadTargetMint with backup version', () => {
+        beforeEach(() => {
+            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'));
+            await downloadTargetMint({
+                logger,
+                targetVersion: targetMintVersion,
+                existingVersion: versionString,
+            });
+            // Verify backup was created
+            expect(existsSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+            expect(moveSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY, constants.DOT_MINTLIFY_LAST, {
+                overwrite: true,
+            });
+            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');
+            // Verify use backup version
+            expect(restoreMintlifyLastMock).toHaveBeenCalled();
+            // Verify no extraction
+            expect(tarMock.x).not.toHaveBeenCalled();
+            // Verify no cleanup
+            expect(removeSyncMock).not.toHaveBeenCalled();
+            expect(writeFileSyncMock).not.toHaveBeenCalled();
+        });
+        it('fails to extract new version', async () => {
+            const logger = buildLoggerMock();
+            const targetMintVersion = '1.0.1';
+            const versionString = '1.0.0';
+            pipelineMock.mockResolvedValue(undefined);
+            tarMock.x.mockImplementation(() => {
+                throw new Error('Zlib error');
+            });
+            await downloadTargetMint({
+                logger,
+                targetVersion: targetMintVersion,
+                existingVersion: versionString,
+            });
+            // Verify backup was created
+            expect(existsSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+            expect(moveSyncMock).toHaveBeenCalledWith(constants.DOT_MINTLIFY, constants.DOT_MINTLIFY_LAST, {
+                overwrite: true,
+            });
+            expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
+            // Verify download success
+            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');
+            // Verify use backup version
+            expect(restoreMintlifyLastMock).toHaveBeenCalled();
+            // Verify no cleanup
+            expect(removeSyncMock).not.toHaveBeenCalled();
+            expect(writeFileSyncMock).not.toHaveBeenCalled();
+        });
+    });
+    describe('downloadTargetMint without backup version', () => {
+        beforeEach(() => {
+            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'));
+            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(processExitMock).toHaveBeenCalledWith(1);
+        });
+        it('fails to extract new version with no fallback', async () => {
+            const logger = buildLoggerMock();
+            const targetMintVersion = '1.0.1';
+            const versionString = null;
+            pipelineMock.mockResolvedValue(undefined);
+            tarMock.x.mockImplementation(() => {
+                throw new Error('Zlib error');
+            });
+            await downloadTargetMint({
+                logger,
+                targetVersion: targetMintVersion,
+                existingVersion: versionString,
+            });
+            expect(logger.fail).toHaveBeenCalledWith('Failed to extract Mintlify framework version 1.0.1, Error: Zlib error');
+            expect(processExitMock).toHaveBeenCalledWith(1);
+        });
+    });
+});

package/dist/constants.d.ts

@@ -1,6 +1,7 @@
 export declare const INSTALL_PATH: string;
 export declare const HOME_DIR: string;
 export declare const DOT_MINTLIFY: string;
+export declare const DOT_MINTLIFY_LAST = ".mintlify-last";
 export declare const MINT_PATH: string;
 export declare const VERSION_PATH: string;
 export declare const CLIENT_PATH: string;

package/dist/constants.js

@@ -5,6 +5,7 @@ import * as url from 'url';
 export const INSTALL_PATH = url.fileURLToPath(new URL('.', import.meta.url));
 export const HOME_DIR = os.homedir();
 export const DOT_MINTLIFY = path.join(HOME_DIR, '.mintlify');
+export const DOT_MINTLIFY_LAST = '.mintlify-last';
 export const MINT_PATH = path.join(DOT_MINTLIFY, 'mint');
 export const VERSION_PATH = path.join(MINT_PATH, 'mint-version.txt');
 export const CLIENT_PATH = path.join(MINT_PATH, 'apps', 'client');

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

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

package/dist/local-preview/client.js

@@ -1,90 +1,73 @@
-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 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, VERSION_PATH, MINT_PATH, TAR_PATH, TARGET_MINT_VERSION_URL, GET_TAR_URL, } from '../constants.js';
-export const getTargetMintVersion = (logger) => __awaiter(void 0, void 0, void 0, function* () {
-    const hasInternet = yield isOnline();
+import { DOT_MINTLIFY, DOT_MINTLIFY_LAST, VERSION_PATH, TAR_PATH, TARGET_MINT_VERSION_URL, GET_TAR_URL, } from '../constants.js';
+import { restoreMintlifyLast } from '../util.js';
+export const getTargetMintVersion = async (logger) => {
+    const hasInternet = await isOnline();
     if (!hasInternet) {
         return undefined;
     }
     try {
-        const response = yield got(TARGET_MINT_VERSION_URL);
+        const response = await got(TARGET_MINT_VERSION_URL);
         return response.body;
     }
     catch (error) {
         logger.text = `Failed to fetch the latest Mintlify version: ${error instanceof Error ? error.message : 'Unknown error'}`;
-        return undefined;
-    }
-});
-export const fallbackMintClient = (logger, versionString) => __awaiter(void 0, void 0, void 0, function* () {
-    logger.text = `Using version: ${versionString}`;
-    const oldTarUrl = GET_TAR_URL(versionString);
-    try {
-        yield pipeline(got.stream(oldTarUrl), fse.createWriteStream(TAR_PATH));
-    }
-    catch (error) {
-        logger.fail(`Failed to download Mintlify framework version ${versionString}, ${error}`);
-        process.exit(1);
     }
-    try {
-        yield extractMintClient(logger);
-    }
-    catch (error) {
-        logger.fail(`Failed to extract Mintlify framework version ${versionString}, ${error}`);
-        process.exit(1);
+    return undefined;
+};
+export const downloadTargetMint = async ({ logger, targetVersion, existingVersion, }) => {
+    if (fse.existsSync(DOT_MINTLIFY)) {
+        fse.moveSync(DOT_MINTLIFY, DOT_MINTLIFY_LAST, { overwrite: true });
     }
-});
-export const extractMintClient = (logger) => __awaiter(void 0, void 0, void 0, function* () {
-    logger.text = 'Extracting Mintlify framework...';
-    tar.x({
-        sync: true,
-        file: TAR_PATH,
-        cwd: DOT_MINTLIFY,
-        onwarn: (_code, message, _data) => {
-            throw new Error(message);
-        },
-    });
-});
-export const downloadTargetMint = (logger, targetMintVersion, versionString, clientVersion) => __awaiter(void 0, void 0, void 0, function* () {
-    fse.emptyDirSync(MINT_PATH);
+    fse.ensureDirSync(DOT_MINTLIFY);
     logger.text = 'Downloading Mintlify framework...';
-    const tarUrl = clientVersion ? GET_TAR_URL(clientVersion) : GET_TAR_URL(targetMintVersion);
-    let currentVersion = clientVersion || targetMintVersion;
+    const tarUrl = GET_TAR_URL(targetVersion);
+    let currentVersion = targetVersion.trim();
     try {
-        yield pipeline(got.stream(tarUrl), fse.createWriteStream(TAR_PATH));
+        await pipeline(got.stream(tarUrl), fse.createWriteStream(TAR_PATH));
     }
     catch (error) {
-        if (versionString) {
-            currentVersion = versionString;
-            yield fallbackMintClient(logger, versionString);
+        if (existingVersion) {
+            logger.warn(`Failed to download Mintlify framework version ${currentVersion}, ${error}, falling back to existing version: ${existingVersion}`);
+            currentVersion = existingVersion;
+            restoreMintlifyLast();
+            return;
         }
         else {
+            logger.fail(`Failed to download Mintlify framework version ${currentVersion}, ${error}`);
             process.exit(1);
         }
     }
     try {
-        yield extractMintClient(logger);
+        logger.text = 'Extracting Mintlify framework...';
+        tar.x({
+            sync: true,
+            file: TAR_PATH,
+            cwd: DOT_MINTLIFY,
+            onwarn: (_code, message, _data) => {
+                throw new Error(message);
+            },
+        });
     }
     catch (error) {
-        if (versionString && currentVersion !== versionString) {
-            currentVersion = versionString;
-            yield fallbackMintClient(logger, versionString);
+        if (existingVersion) {
+            logger.warn(`Failed to extract Mintlify framework version ${currentVersion}, ${error}, using existing version: ${existingVersion}`);
+            currentVersion = existingVersion;
+            restoreMintlifyLast();
+            return;
         }
         else {
+            logger.fail(`Failed to extract Mintlify framework version ${currentVersion}, ${error}`);
             process.exit(1);
         }
     }
     fse.removeSync(TAR_PATH);
-    fse.writeFileSync(VERSION_PATH, targetMintVersion);
-});
+    if (fse.existsSync(DOT_MINTLIFY_LAST)) {
+        fse.removeSync(DOT_MINTLIFY_LAST);
+    }
+    fse.writeFileSync(VERSION_PATH, currentVersion);
+};

package/dist/local-preview/index.js

@@ -1,59 +1,46 @@
-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 { prebuild } from '@mintlify/prebuild';
-import open from 'better-opn';
-import Chalk from 'chalk';
-import express from 'express';
 import fse, { pathExists } from 'fs-extra';
-import { createServer } from 'http';
 import isOnline from 'is-online';
-import { pathToFileURL } from 'node:url';
-import { Server as SocketServer } from 'socket.io';
-import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, NEXT_CONFIG_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, NEXT_SIDE_EFFECT_PATH, NEXT_ROUTER_SERVER_PATH, } from '../constants.js';
-import { buildLogger, maybeFixMissingWindowsEnvVar } from '../util.js';
+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 { getTargetMintVersion, downloadTargetMint } from './client.js';
-import listener from './listener/index.js';
-const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+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 = yield isOnline();
+    const hasInternet = await isOnline();
     const localSchema = argv['local-schema'];
     const clientVersion = argv['client-version'];
-    yield fse.ensureDir(DOT_MINTLIFY);
-    const versionString = (yield pathExists(VERSION_PATH))
+    await fse.ensureDir(DOT_MINTLIFY);
+    const versionString = (await pathExists(VERSION_PATH))
         ? fse.readFileSync(VERSION_PATH, 'utf8')
         : null;
     if (!versionString && !hasInternet) {
         logger.fail('Running mintlify dev afer updating requires an internet connection.');
         process.exit(1);
     }
-    const targetMintVersion = yield getTargetMintVersion(logger);
+    const targetMintVersion = await getTargetMintVersion(logger);
     if (!targetMintVersion) {
-        logger.text =
-            'Failed to get latest Mintlify client version. Your current version is: ' +
-                versionString +
-                ', which may not be the latest Mintlify client version.';
+        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.`);
     }
     const shouldDownload = versionString !== targetMintVersion || clientVersion !== undefined;
     if (shouldDownload && hasInternet && targetMintVersion) {
-        yield downloadTargetMint(logger, targetMintVersion, versionString, clientVersion);
+        await downloadTargetMint({
+            logger,
+            targetVersion: clientVersion ?? targetMintVersion,
+            existingVersion: versionString,
+        });
     }
     // clear preexisting prebuild files
     fse.emptyDirSync(NEXT_PUBLIC_PATH);
     fse.emptyDirSync(NEXT_PROPS_PATH);
     process.chdir(CLIENT_PATH);
     try {
-        yield prebuild(CMD_EXEC_PATH, { localSchema });
+        await prebuild(CMD_EXEC_PATH, { localSchema });
     }
     catch (err) {
         const errorText = err instanceof Error && err.message ? err.message : 'Prebuild step failed';
@@ -61,82 +48,6 @@ const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
         process.exit(1);
     }
     logger.succeed('Local Mintlify instance is ready. Launching your site...');
-    yield run(argv);
-});
-/**
- * When creating a standalone build, next.js outputs a server.js file that can be used as
- * an entry point into the server. However, because we want to customize some parts of the
- * http server (adding a socket.io server, serving the whole public directory), we
- * create the server ourselves, and just reproduce the setup that next.js would do.
- *
- * Because we need to directly import from node_modules files, this solution seems very hacky,
- * but it is arguably no more hacky than using the server.js that ships with the standalone
- * build.
- *
- * This function attempts to replicate the behavior of two next.js files:
- * - environment setup from server.js
- * - initialization of the request handler from start-server.ts
- *
- * Links:
- * - [standalone build](https://nextjs.org/docs/pages/api-reference/next-config-js/output#automatically-copying-traced-files)
- * - [server.js](https://github.com/vercel/next.js/blob/492156b4c5e2559b2a280f7d483cd85a8e8742a9/packages/next/src/build/utils.ts#L2108-L2113) (created programmatically)
- * - [start-server.ts](https://github.com/vercel/next.js/blob/492156b4c5e2559b2a280f7d483cd85a8e8742a9/packages/next/src/server/lib/start-server.ts#L296-L308)
- *
- * @returns the request handler provided by next.js
- */
-const setupNext = () => __awaiter(void 0, void 0, void 0, function* () {
-    const hostname = process.env.HOSTNAME || 'localhost';
-    const { config } = yield JSON.parse(fse.readFileSync(NEXT_CONFIG_PATH, 'utf8'));
-    process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
-    // The server.js provided by next.js's standalone build does a similar import of this file.
-    // Not sure what side effects are being created, but want to change as little as possible.
-    // Also, Windows requires us to use `pathToFileURL` (see #899)
-    yield import(pathToFileURL(NEXT_SIDE_EFFECT_PATH).href);
-    const { initialize } = yield import(pathToFileURL(NEXT_ROUTER_SERVER_PATH).href);
-    const [requestHandler] = yield initialize({
-        dir: CLIENT_PATH,
-        dev: false,
-        hostname,
-        minimalMode: true,
-    });
-    return requestHandler;
-});
-const run = (argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const port = argv.port || '3000';
-    const currentPort = parseInt(port, 10) || 3000;
-    const app = express();
-    const server = createServer(app);
-    const io = new SocketServer(server);
-    const requestHandler = yield setupNext();
-    // next-server is bugged, public files added after starting aren't served
-    app.use('/', express.static(NEXT_PUBLIC_PATH));
-    app.all('*', (req, res) => requestHandler(req, res));
-    const onChange = () => {
-        io.emit('reload');
-    };
-    server.listen(currentPort, () => {
-        console.log(`${Chalk.green(`Your local preview is available at http://localhost:${port}`)}`);
-        // Note: We wait for this exact text to be sure the server is ready in the cli e2e test,
-        // if it changes, the test will fail/require an update.
-        console.log(`${Chalk.green('Press Ctrl+C any time to stop the local preview.')}`);
-        /**
-         * We're running into a known bug with the `open` package, where Windows machines error out because process.env.SYSTEMROOT is not set:
-         * https://github.com/sindresorhus/open/issues/292
-         *
-         * Let's use the same workaround that this project did:
-         * https://github.com/sanity-io/sanity/pull/4221/files#diff-aeb574e1becf61f21fdf87fbea709669c93d604d660dad4b0f9e24527a2fb54bR256-R262
-         */
-        maybeFixMissingWindowsEnvVar();
-        if (argv.open) {
-            void open(`http://localhost:${port}`);
-        }
-        // exit with successful status
-        const onExit = () => {
-            process.exit(0);
-        };
-        process.on('SIGINT', onExit);
-        process.on('SIGTERM', onExit);
-    });
-    listener(onChange);
-});
+    await run(argv);
+};
 export default dev;