@mintlify/previewing 4.0.527 → 4.0.529

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,220 @@
+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),
+    getTarUrl: vi.fn().mockReturnValue('https://asdfghjkl.cloudfront.net/mint-1.0.1.tar.gz'),
+}));
+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 getTarUrlMock = vi.mocked(utils.getTarUrl);
+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(getTarUrlMock).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(getTarUrlMock).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;
@@ -9,8 +10,8 @@ export declare const NEXT_ROUTER_SERVER_PATH: string;
 export declare const NEXT_CONFIG_PATH: string;
 export declare const NEXT_PUBLIC_PATH: string;
 export declare const NEXT_PROPS_PATH: string;
-export declare const TARGET_MINT_VERSION_URL = "https://mint-releases.b-cdn.net/mint-version.txt";
-export declare const GET_TAR_URL: (version: string) => string;
+export declare const MINT_CLIENT_RELEASES_CLOUDFRONT_URL = "https://d1ctpt7j8wusba.cloudfront.net";
+export declare const TARGET_MINT_VERSION_URL = "https://d1ctpt7j8wusba.cloudfront.net/mint-version.txt";
 export declare const TAR_PATH: string;
 export declare const CMD_EXEC_PATH: string;
 export declare const SUPPORTED_MEDIA_EXTENSIONS: 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');
@@ -14,8 +15,8 @@ export const NEXT_ROUTER_SERVER_PATH = path.join(NEXT_DIST_SERVER_PATH, 'lib', '
 export const NEXT_CONFIG_PATH = path.join(CLIENT_PATH, '.next', 'required-server-files.json');
 export const NEXT_PUBLIC_PATH = path.join(CLIENT_PATH, 'public');
 export const NEXT_PROPS_PATH = path.join(CLIENT_PATH, 'src', '_props');
-export const TARGET_MINT_VERSION_URL = 'https://mint-releases.b-cdn.net/mint-version.txt';
-export const GET_TAR_URL = (version) => `https://mint-releases.b-cdn.net/mint-${version}.tar.gz`;
+export const MINT_CLIENT_RELEASES_CLOUDFRONT_URL = 'https://d1ctpt7j8wusba.cloudfront.net';
+export const TARGET_MINT_VERSION_URL = `${MINT_CLIENT_RELEASES_CLOUDFRONT_URL}/mint-version.txt`;
 export const TAR_PATH = path.join(DOT_MINTLIFY, `mint.tar.gz`);
 // command execution location
 export const CMD_EXEC_PATH = process.cwd();

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, } from '../constants.js';
+import { restoreMintlifyLast, getTarUrl } 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 = getTarUrl(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);
+};