@mintlify/previewing 4.0.630 → 4.0.631

package/dist/__tests__/dev.test.js

@@ -3,15 +3,15 @@ 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 { silentUpdateClient } from '../local-preview/update.js';
 import * as logs from '../logging-state.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'),
+        readFileSync: vi.fn().mockReturnValue('0.0.100'),
         emptyDirSync: vi.fn().mockResolvedValue(undefined),
     };
     return {
@@ -19,9 +19,8 @@ vi.mock('fs-extra', () => {
         default: mocks,
     };
 });
-vi.mock('../local-preview/client.js', () => ({
-    getTargetMintVersion: vi.fn().mockResolvedValue('1.0.0'),
-    downloadTargetMint: vi.fn().mockResolvedValue(undefined),
+vi.mock('../local-preview/update.js', () => ({
+    silentUpdateClient: vi.fn().mockResolvedValue({ needsUpdate: false, error: undefined }),
 }));
 vi.mock('is-online', () => ({
     default: vi.fn().mockResolvedValue(true),
@@ -39,11 +38,12 @@ vi.mock('../util.js', () => {
 });
 const prebuildMock = vi.mocked(prebuild);
 const runMock = vi.mocked(run);
-const downloadTargetMintMock = vi.mocked(downloadTargetMint);
+const silentUpdateClientMock = vi.mocked(silentUpdateClient);
 const defaultYargs = {
     _: [],
     $0: '',
     packageName: 'mintlify',
+    cliVersion: '1.0.0',
 };
 const addLogSpy = vi.spyOn(logs, 'addLog');
 const processExitMock = mockProcessExit();
@@ -58,6 +58,7 @@ describe('dev', () => {
     it('happy path', async () => {
         await dev(defaultYargs);
         expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
+        expect(silentUpdateClientMock).toHaveBeenCalled();
         expect(prebuildMock).toHaveBeenCalled();
         expect(runMock).toHaveBeenCalled();
     });
@@ -87,45 +88,4 @@ describe('dev', () => {
         }));
         expect(processExitMock).toHaveBeenCalledWith(1);
     });
-    it('has existing version but fails to get targetMintVersion', async () => {
-        vi.mocked(isOnline).mockResolvedValueOnce(false);
-        vi.mocked(getTargetMintVersion).mockResolvedValueOnce(undefined);
-        await dev(defaultYargs);
-        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(runMock).toHaveBeenCalled();
-    });
-    it('downloads client with --client-version arg', async () => {
-        await dev({ ...defaultYargs, 'client-version': '1.0.3' });
-        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
-        expect(downloadTargetMintMock).toHaveBeenCalled();
-        expect(prebuildMock).toHaveBeenCalled();
-        expect(runMock).toHaveBeenCalled();
-    });
-    it('downloads client if no existing version', async () => {
-        vi.mocked(fse.pathExists).mockResolvedValueOnce();
-        await dev(defaultYargs);
-        expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
-        expect(downloadTargetMintMock).toHaveBeenCalled();
-        expect(prebuildMock).toHaveBeenCalled();
-        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(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { updateCommand: 'mintlify update' } }));
-        expect(prebuildMock).toHaveBeenCalled();
-        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(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { updateCommand: 'mint update' } }));
-        expect(prebuildMock).toHaveBeenCalled();
-        expect(runMock).toHaveBeenCalled();
-    });
 });

package/dist/__tests__/downloadTargetMint.test.js

@@ -1,10 +1,8 @@
 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 logs from '../logging-state.js';
 import * as utils from '../util.js';
 vi.mock('fs-extra', () => {
     const mocks = {
@@ -53,8 +51,6 @@ 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();
-const addLogSpy = vi.spyOn(logs, 'addLog');
 describe('downloadTargetMint', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -74,10 +70,8 @@ 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();
         // Verify cleanup
         expect(removeSyncMock).toHaveBeenCalledWith(constants.TAR_PATH);
@@ -101,10 +95,8 @@ 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();
         // Verify cleanup
         expect(removeSyncMock).toHaveBeenCalledWith(constants.TAR_PATH);
@@ -122,6 +114,7 @@ describe('downloadTargetMint', () => {
             const versionString = '1.0.0';
             const errorMessage = 'connection timed out';
             pipelineMock.mockRejectedValue(new Error(errorMessage));
+            // does not throw
             await downloadTargetMint({
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
@@ -132,13 +125,6 @@ describe('downloadTargetMint', () => {
                 overwrite: true,
             });
             expect(fse.ensureDirSync).toHaveBeenCalledWith(constants.DOT_MINTLIFY);
-            // Verify download fail
-            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
@@ -155,6 +141,7 @@ describe('downloadTargetMint', () => {
             tarMock.x.mockImplementation(() => {
                 throw new Error(errorMessage);
             });
+            // does not throw
             await downloadTargetMint({
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
@@ -166,15 +153,7 @@ 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(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
@@ -191,17 +170,10 @@ describe('downloadTargetMint', () => {
             const versionString = null;
             const errorMessage = 'connection timed out';
             pipelineMock.mockRejectedValue(new Error(errorMessage));
-            await downloadTargetMint({
+            await expect(downloadTargetMint({
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
-            });
-            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);
+            })).rejects.toThrow(`failed to install mintlify framework version ${targetMintVersion}, Error: ${errorMessage}`);
         });
         it('fails to extract new version with no fallback', async () => {
             const targetMintVersion = '1.0.1';
@@ -211,16 +183,10 @@ describe('downloadTargetMint', () => {
             tarMock.x.mockImplementation(() => {
                 throw new Error(errorMessage);
             });
-            await downloadTargetMint({
+            await expect(downloadTargetMint({
                 targetVersion: targetMintVersion,
                 existingVersion: versionString,
-            });
-            expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({
-                props: {
-                    message: `failed to extract mintlify framework version ${targetMintVersion}, Error: ${errorMessage}`,
-                },
-            }));
-            expect(processExitMock).toHaveBeenCalledWith(1);
+            })).rejects.toThrow(`failed to extract mintlify framework version ${targetMintVersion}, Error: ${errorMessage}`);
         });
     });
 });

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

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

package/dist/__tests__/silentUpdateClient.test.js

@@ -0,0 +1,142 @@
+import { LOCAL_LINKED_CLI_VERSION } from '../constants.js';
+import * as client from '../local-preview/client.js';
+import { silentUpdateClient } from '../local-preview/update.js';
+vi.mock('../local-preview/client.js', () => ({
+    getLatestClientVersion: vi.fn().mockResolvedValue('0.0.100'),
+    downloadTargetMint: vi.fn().mockResolvedValue(undefined),
+    tryDownloadTargetMint: vi.fn().mockResolvedValue(undefined),
+    getCompatibleClientVersion: vi.fn().mockResolvedValue('latest'),
+}));
+const tryDownloadTargetMintSpy = vi.spyOn(client, 'tryDownloadTargetMint');
+describe('silentUpdateClient', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('has latest client version already', async () => {
+        const versionString = '0.0.100';
+        const clientVersion = undefined;
+        const cliVersion = undefined;
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).not.toHaveBeenCalled();
+        expect(needsUpdate).toBe(false);
+        expect(error).toBeUndefined();
+    });
+    it('has no client version and downloads latest', async () => {
+        const versionString = null;
+        const clientVersion = undefined;
+        const cliVersion = undefined;
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
+            targetVersion: '0.0.100',
+            existingVersion: null,
+        });
+        expect(needsUpdate).toBe(false);
+        expect(error).toBeUndefined();
+    });
+    it('always downloads latest for locally linked cli', async () => {
+        const versionString = null;
+        const clientVersion = undefined;
+        const cliVersion = LOCAL_LINKED_CLI_VERSION;
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
+            targetVersion: '0.0.100',
+            existingVersion: null,
+        });
+        expect(needsUpdate).toBe(false);
+        expect(error).toBeUndefined();
+    });
+    it('compatible client version is latest and downloads latest', async () => {
+        const versionString = null;
+        const clientVersion = undefined;
+        const cliVersion = '4.2.0';
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
+            targetVersion: '0.0.100',
+            existingVersion: null,
+        });
+        expect(needsUpdate).toBe(false);
+        expect(error).toBeUndefined();
+    });
+    it('compatible client version is max and already has max', async () => {
+        vi.mocked(client.getCompatibleClientVersion).mockResolvedValueOnce('0.0.99');
+        const versionString = '0.0.99';
+        const clientVersion = undefined;
+        const cliVersion = '4.2.0';
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).not.toHaveBeenCalled();
+        expect(needsUpdate).toBe(true);
+        expect(error).toBeUndefined();
+    });
+    it('compatible client version is max and downloads max', async () => {
+        vi.mocked(client.getCompatibleClientVersion).mockResolvedValueOnce('0.0.99');
+        const versionString = '0.0.98';
+        const clientVersion = undefined;
+        const cliVersion = '4.2.0';
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
+            targetVersion: '0.0.99',
+            existingVersion: '0.0.98',
+        });
+        expect(needsUpdate).toBe(true);
+        expect(error).toBeUndefined();
+    });
+    it('compatible client version not found', async () => {
+        vi.mocked(client.getCompatibleClientVersion).mockResolvedValueOnce(undefined);
+        const versionString = '0.0.98';
+        const clientVersion = undefined;
+        const cliVersion = '4.2.0';
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).not.toHaveBeenCalled();
+        expect(needsUpdate).toBe(true);
+        expect(error).toBeUndefined();
+    });
+    it('error with downloading target mint', async () => {
+        vi.mocked(client.downloadTargetMint).mockRejectedValueOnce(new Error('some error'));
+        vi.mocked(client.tryDownloadTargetMint).mockResolvedValueOnce('some error');
+        const versionString = null;
+        const clientVersion = undefined;
+        const cliVersion = '4.2.0';
+        const { needsUpdate, error } = await silentUpdateClient({
+            versionString,
+            clientVersion,
+            cliVersion,
+        });
+        expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
+            targetVersion: '0.0.100',
+            existingVersion: null,
+        });
+        expect(needsUpdate).toBe(false);
+        expect(error).toBe('some error');
+    });
+});

package/dist/constants.d.ts

@@ -12,6 +12,8 @@ export declare const NEXT_PUBLIC_PATH: string;
 export declare const NEXT_PROPS_PATH: string;
 export declare const MINT_CLIENT_RELEASES_CLOUDFRONT_URL = "https://releases.mintlify.com";
 export declare const TARGET_MINT_VERSION_URL = "https://releases.mintlify.com/mint-version.txt";
+export declare const MINT_VERSION_MAP_URL = "https://releases.mintlify.com/mint-version-map.json";
 export declare const TAR_PATH: string;
 export declare const CMD_EXEC_PATH: string;
 export declare const SUPPORTED_MEDIA_EXTENSIONS: string[];
+export declare const LOCAL_LINKED_CLI_VERSION = "linked to local package";

package/dist/constants.js

@@ -17,6 +17,7 @@ export const NEXT_PUBLIC_PATH = path.join(CLIENT_PATH, 'public');
 export const NEXT_PROPS_PATH = path.join(CLIENT_PATH, 'src', '_props');
 export const MINT_CLIENT_RELEASES_CLOUDFRONT_URL = 'https://releases.mintlify.com';
 export const TARGET_MINT_VERSION_URL = `${MINT_CLIENT_RELEASES_CLOUDFRONT_URL}/mint-version.txt`;
+export const MINT_VERSION_MAP_URL = `${MINT_CLIENT_RELEASES_CLOUDFRONT_URL}/mint-version-map.json`;
 export const TAR_PATH = path.join(DOT_MINTLIFY, `mint.tar.gz`);
 // command execution location
 export const CMD_EXEC_PATH = process.cwd();
@@ -37,3 +38,4 @@ export const SUPPORTED_MEDIA_EXTENSIONS = [
     'bmp',
     'mp4',
 ];
+export const LOCAL_LINKED_CLI_VERSION = 'linked to local package';

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { getTargetMintVersion, downloadTargetMint } from './local-preview/client.js';
+import { LOCAL_LINKED_CLI_VERSION } from './constants.js';
+import { getLatestClientVersion, downloadTargetMint, getVersionMap } from './local-preview/client.js';
 import dev from './local-preview/index.js';
 import { getClientVersion } from './util.js';
 export * from './logs.js';
 export * from './logging-state.js';
-export { dev, getClientVersion, getTargetMintVersion, downloadTargetMint };
+export { dev, getClientVersion, getLatestClientVersion, downloadTargetMint, getVersionMap, LOCAL_LINKED_CLI_VERSION, };

package/dist/index.js

@@ -1,6 +1,7 @@
-import { getTargetMintVersion, downloadTargetMint } from './local-preview/client.js';
+import { LOCAL_LINKED_CLI_VERSION } from './constants.js';
+import { getLatestClientVersion, downloadTargetMint, getVersionMap, } from './local-preview/client.js';
 import dev from './local-preview/index.js';
 import { getClientVersion } from './util.js';
 export * from './logs.js';
 export * from './logging-state.js';
-export { dev, getClientVersion, getTargetMintVersion, downloadTargetMint };
+export { dev, getClientVersion, getLatestClientVersion, downloadTargetMint, getVersionMap, LOCAL_LINKED_CLI_VERSION, };

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

@@ -1,5 +1,13 @@
-export declare const getTargetMintVersion: () => Promise<string | undefined>;
+export declare const getLatestClientVersion: () => Promise<string | undefined>;
 export declare const downloadTargetMint: ({ targetVersion, existingVersion, }: {
     targetVersion: string;
     existingVersion: string | null;
 }) => Promise<void>;
+export declare const getVersionMap: () => Promise<string | undefined>;
+export declare const getCompatibleClientVersion: ({ cliVersion }: {
+    cliVersion: string;
+}) => Promise<string | undefined>;
+export declare const tryDownloadTargetMint: ({ targetVersion, existingVersion }: {
+    targetVersion: string;
+    existingVersion: string | null;
+}) => Promise<string | undefined>;

package/dist/local-preview/client.js

@@ -1,14 +1,12 @@
-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 } from '../logging-state.js';
-import { ErrorLog, SpinnerLog, WarningLog } from '../logs.js';
+import yaml from 'js-yaml';
+import { DOT_MINTLIFY, DOT_MINTLIFY_LAST, VERSION_PATH, TAR_PATH, TARGET_MINT_VERSION_URL, MINT_VERSION_MAP_URL, } from '../constants.js';
 import { restoreMintlifyLast, getTarUrl } from '../util.js';
-export const getTargetMintVersion = async () => {
+export const getLatestClientVersion = async () => {
     const hasInternet = await isOnline();
     if (!hasInternet) {
         return undefined;
@@ -26,8 +24,6 @@ export const downloadTargetMint = async ({ targetVersion, existingVersion, }) =>
         fse.moveSync(DOT_MINTLIFY, DOT_MINTLIFY_LAST, { overwrite: true });
     }
     fse.ensureDirSync(DOT_MINTLIFY);
-    clearLogs();
-    addLog(_jsx(SpinnerLog, { message: "installing mintlify framework..." }));
     const tarUrl = getTarUrl(targetVersion);
     let currentVersion = targetVersion.trim();
     try {
@@ -35,21 +31,15 @@ export const downloadTargetMint = async ({ targetVersion, existingVersion, }) =>
     }
     catch (error) {
         if (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 {
-            clearLogs();
-            addLog(_jsx(ErrorLog, { message: `failed to install mintlify framework version ${currentVersion}, ${error}` }));
-            process.exit(1);
+            throw new Error(`failed to install mintlify framework version ${currentVersion}, ${error}`);
         }
     }
     try {
-        clearLogs();
-        addLog(_jsx(SpinnerLog, { message: "extracting mintlify framework..." }));
         tar.x({
             sync: true,
             file: TAR_PATH,
@@ -61,22 +51,53 @@ export const downloadTargetMint = async ({ targetVersion, existingVersion, }) =>
     }
     catch (error) {
         if (existingVersion) {
-            clearLogs();
-            addLog(_jsx(WarningLog, { message: `failed to extract mintlify framework version ${currentVersion}, ${error}, using existing version: ${existingVersion}` }));
             currentVersion = existingVersion;
             restoreMintlifyLast();
             return;
         }
         else {
-            clearLogs();
-            addLog(_jsx(ErrorLog, { message: `failed to extract mintlify framework version ${currentVersion}, ${error}` }));
-            process.exit(1);
+            throw new Error(`failed to extract mintlify framework version ${currentVersion}, ${error}`);
         }
     }
-    clearLogs();
     fse.removeSync(TAR_PATH);
     if (fse.existsSync(DOT_MINTLIFY_LAST)) {
         fse.removeSync(DOT_MINTLIFY_LAST);
     }
     fse.writeFileSync(VERSION_PATH, currentVersion);
 };
+export const getVersionMap = async () => {
+    try {
+        const response = await got(MINT_VERSION_MAP_URL);
+        return response.body;
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+export const getCompatibleClientVersion = async ({ cliVersion }) => {
+    const versionMap = await getVersionMap();
+    if (!versionMap) {
+        return undefined;
+    }
+    const versionMapObj = yaml.load(versionMap);
+    if (cliVersion && versionMapObj[cliVersion]) {
+        const { max } = versionMapObj[cliVersion];
+        if (max !== "") {
+            return max;
+        }
+        else {
+            return "latest";
+        }
+    }
+    return undefined;
+};
+export const tryDownloadTargetMint = async ({ targetVersion, existingVersion }) => {
+    let error;
+    try {
+        await downloadTargetMint({ targetVersion, existingVersion });
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : 'unknown error';
+    }
+    return error;
+};

package/dist/local-preview/index.js

@@ -4,8 +4,8 @@ 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 { addLog, clearLogs } from '../logging-state.js';
-import { ErrorLog, SpinnerLog, UpdateLog, WarningLog } from '../logs.js';
-import { getTargetMintVersion, downloadTargetMint } from './client.js';
+import { ErrorLog, SpinnerLog } from '../logs.js';
+import { silentUpdateClient } from './update.js';
 import { run } from './run.js';
 const dev = async (argv) => {
     const hasInternet = await isOnline();
@@ -13,6 +13,7 @@ const dev = async (argv) => {
     const clientVersion = argv['client-version'];
     const packageName = argv.packageName;
     const groups = argv.groups;
+    const cliVersion = argv.cliVersion;
     await fse.ensureDir(DOT_MINTLIFY);
     const versionString = (await pathExists(VERSION_PATH))
         ? fse.readFileSync(VERSION_PATH, 'utf8')
@@ -23,31 +24,19 @@ const dev = async (argv) => {
         await new Promise((resolve) => setTimeout(resolve, 50));
         process.exit(1);
     }
-    const targetMintVersion = await getTargetMintVersion();
-    if (!targetMintVersion) {
-        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
-    if (clientVersion !== undefined || (!versionString && hasInternet && targetMintVersion)) {
-        const version = clientVersion ?? targetMintVersion;
-        if (version) {
-            await downloadTargetMint({
-                targetVersion: version,
-                existingVersion: versionString,
-            });
-        }
-    }
-    if (versionString && targetMintVersion && versionString.trim() !== targetMintVersion.trim()) {
-        addLog(_jsx(UpdateLog, { updateCommand: `${packageName} update` }));
+    addLog(_jsx(SpinnerLog, { message: "preparing local preview..." }));
+    const { needsUpdate, error } = await silentUpdateClient({ versionString, clientVersion, cliVersion });
+    if (error) {
+        clearLogs();
+        addLog(_jsx(ErrorLog, { message: error }));
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        process.exit(1);
     }
     // clear preexisting prebuild files
     fse.emptyDirSync(NEXT_PUBLIC_PATH);
     fse.emptyDirSync(NEXT_PROPS_PATH);
     process.chdir(CLIENT_PATH);
     try {
-        clearLogs();
-        addLog(_jsx(SpinnerLog, { message: "preparing local preview..." }));
         await prebuild(CMD_EXEC_PATH, { localSchema, groups });
     }
     catch (err) {
@@ -57,6 +46,6 @@ const dev = async (argv) => {
         await new Promise((resolve) => setTimeout(resolve, 50));
         process.exit(1);
     }
-    await run(argv);
+    await run({ ...argv, needsUpdate });
 };
 export default dev;

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

@@ -1,2 +1,4 @@
 import { ArgumentsCamelCase } from 'yargs';
-export declare const run: (argv: ArgumentsCamelCase) => Promise<void>;
+export declare const run: (argv: ArgumentsCamelCase & {
+    needsUpdate: boolean;
+}) => Promise<void>;

package/dist/local-preview/run.js

@@ -5,7 +5,7 @@ import { createServer } from 'http';
 import { Server as SocketServer } from 'socket.io';
 import { NEXT_PUBLIC_PATH } from '../constants.js';
 import { addLog, removeLastLog } from '../logging-state.js';
-import { LaunchLog } from '../logs.js';
+import { LaunchLog, UpdateLog } from '../logs.js';
 import { maybeFixMissingWindowsEnvVar } from '../util.js';
 import listener from './listener/index.js';
 import { getLocalNetworkIp } from './network.js';
@@ -26,6 +26,9 @@ export const run = async (argv) => {
     };
     server.listen(currentPort, () => {
         removeLastLog();
+        if (argv.needsUpdate) {
+            addLog(_jsx(UpdateLog, { updateCommand: `${argv.packageName} update` }));
+        }
         addLog(_jsx(LaunchLog, { localUrl: `http://localhost:${port}`, networkUrl: localIp ? `http://${localIp}:${port}` : undefined }));
         /**
          * We're running into a known bug with the `open` package, where Windows machines error out because process.env.SYSTEMROOT is not set:

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

@@ -0,0 +1,6 @@
+export type VersionMap = {
+    [key: string]: {
+        min: string;
+        max: string;
+    };
+};

package/dist/local-preview/types.js

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

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

@@ -0,0 +1,8 @@
+export declare const silentUpdateClient: ({ versionString, clientVersion, cliVersion }: {
+    versionString: string | null;
+    clientVersion: string | undefined;
+    cliVersion: string | undefined;
+}) => Promise<{
+    needsUpdate: boolean;
+    error: string | undefined;
+}>;