@mintlify/previewing 4.0.850 → 4.0.852

package/dist/__tests__/silentUpdateClient.test.js

@@ -18,10 +18,12 @@ describe('silentUpdateClient', () => {
     it('has latest client version already', async () => {
         const versionString = '0.0.100';
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = undefined;
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).not.toHaveBeenCalled();
@@ -31,10 +33,12 @@ describe('silentUpdateClient', () => {
     it('has no client version and downloads latest', async () => {
         const versionString = null;
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = undefined;
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
@@ -47,10 +51,12 @@ describe('silentUpdateClient', () => {
     it('always downloads latest for locally linked cli', async () => {
         const versionString = null;
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = LOCAL_LINKED_CLI_VERSION;
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
@@ -63,10 +69,12 @@ describe('silentUpdateClient', () => {
     it('compatible client version is latest and downloads latest', async () => {
         const versionString = null;
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = '4.2.0';
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
@@ -80,10 +88,12 @@ describe('silentUpdateClient', () => {
         vi.mocked(client.getCompatibleClientVersion).mockResolvedValueOnce('0.0.99');
         const versionString = '0.0.99';
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = '4.2.0';
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).not.toHaveBeenCalled();
@@ -94,10 +104,12 @@ describe('silentUpdateClient', () => {
         vi.mocked(client.getCompatibleClientVersion).mockResolvedValueOnce('0.0.99');
         const versionString = '0.0.98';
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = '4.2.0';
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({
@@ -111,10 +123,12 @@ describe('silentUpdateClient', () => {
         vi.mocked(client.getCompatibleClientVersion).mockResolvedValueOnce(undefined);
         const versionString = '0.0.98';
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = '4.2.0';
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).not.toHaveBeenCalled();
@@ -126,10 +140,12 @@ describe('silentUpdateClient', () => {
         vi.mocked(client.tryDownloadTargetMint).mockResolvedValueOnce('some error');
         const versionString = null;
         const clientVersion = undefined;
+        const localClientVersion = undefined;
         const cliVersion = '4.2.0';
         const { needsUpdate, error } = await silentUpdateClient({
             versionString,
             clientVersion,
+            localClientVersion,
             cliVersion,
         });
         expect(tryDownloadTargetMintSpy).toHaveBeenCalledWith({

package/dist/local-preview/index.js

@@ -11,6 +11,7 @@ const dev = async (argv) => {
     const hasInternet = await isOnline();
     const localSchema = argv['local-schema'];
     const clientVersion = argv['client-version'];
+    const localClientVersion = argv['local-client-version'];
     const packageName = argv.packageName;
     const groups = argv.groups;
     const cliVersion = argv.cliVersion;
@@ -19,7 +20,7 @@ const dev = async (argv) => {
     const versionString = (await pathExists(VERSION_PATH))
         ? fse.readFileSync(VERSION_PATH, 'utf8')
         : null;
-    if (!versionString && !hasInternet) {
+    if (!versionString && !localClientVersion && !hasInternet) {
         clearLogs();
         addLog(_jsx(ErrorLog, { message: `running ${packageName} dev after updating requires an internet connection.` }));
         await new Promise((resolve) => setTimeout(resolve, 50));
@@ -29,6 +30,7 @@ const dev = async (argv) => {
     const { needsUpdate, error } = await silentUpdateClient({
         versionString,
         clientVersion,
+        localClientVersion,
         cliVersion,
     });
     if (error) {

package/dist/local-preview/setupNext.js

@@ -24,7 +24,20 @@ import { CLIENT_PATH, NEXT_CONFIG_PATH, NEXT_ROUTER_SERVER_PATH, NEXT_SIDE_EFFEC
  */
 export const setupNext = async () => {
     const hostname = process.env.HOSTNAME || 'localhost';
-    const { config } = await JSON.parse(fse.readFileSync(NEXT_CONFIG_PATH, 'utf8'));
+    let config;
+    try {
+        const configFile = fse.readFileSync(NEXT_CONFIG_PATH, 'utf8');
+        config = JSON.parse(configFile).config;
+    }
+    catch (err) {
+        if (err instanceof Error &&
+            'code' in err &&
+            err.code === 'ENOENT' &&
+            NEXT_CONFIG_PATH.includes('.next/required-server-files.json')) {
+            throw new Error(`Client not built. Run: cd <path>/apps/client && STANDALONE_BUILD=true NEXT_PUBLIC_ENV=cli yarn build`);
+        }
+        throw err;
+    }
     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.

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

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

package/dist/local-preview/update.js

@@ -1,30 +1,160 @@
-import { getLatestClientVersion, tryDownloadTargetMint, getCompatibleClientVersion } from "./client.js";
-import { LOCAL_LINKED_CLI_VERSION } from "../constants.js";
-export const silentUpdateClient = async ({ versionString, clientVersion, cliVersion }) => {
+import { jsx as _jsx } from "react/jsx-runtime";
+import { spawn } from 'child_process';
+import fse from 'fs-extra';
+import path from 'path';
+import { LOCAL_LINKED_CLI_VERSION, MINT_PATH, DOT_MINTLIFY, CLIENT_PATH } from '../constants.js';
+import { clearLogs, addLog } from '../logging-state.js';
+import { SpinnerLog } from '../logs.js';
+import { getLatestClientVersion, tryDownloadTargetMint, getCompatibleClientVersion, } from './client.js';
+const MINT_BACKUP_PATH = path.join(DOT_MINTLIFY, 'mint-backup');
+const isCurrentlySymlinked = async () => {
+    if (!(await fse.pathExists(MINT_PATH)))
+        return false;
+    const stats = await fse.lstat(MINT_PATH);
+    return stats.isSymbolicLink();
+};
+const buildClient = async () => {
+    return new Promise((resolve) => {
+        clearLogs();
+        addLog(_jsx(SpinnerLog, { message: "building local client (this may take a few minutes)..." }));
+        const buildProcess = spawn('yarn', ['build'], {
+            cwd: CLIENT_PATH,
+            env: {
+                ...process.env,
+                STANDALONE_BUILD: 'true',
+                NEXT_PUBLIC_ENV: 'cli',
+                NEXT_PUBLIC_IS_LOCAL_CLIENT: 'true',
+            },
+            stdio: 'pipe',
+            shell: true,
+        });
+        let stderr = '';
+        buildProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        buildProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve(undefined);
+            }
+            else {
+                resolve(`Client build failed (exit code ${code}): ${stderr.slice(-500)}`);
+            }
+        });
+        buildProcess.on('error', (err) => {
+            resolve(`Client build error: ${err.message}`);
+        });
+    });
+};
+const restoreFromBackup = async () => {
+    try {
+        if (await isCurrentlySymlinked()) {
+            await fse.remove(MINT_PATH);
+        }
+        if (await fse.pathExists(MINT_BACKUP_PATH)) {
+            await fse.move(MINT_BACKUP_PATH, MINT_PATH);
+        }
+        return undefined;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : 'unknown error';
+    }
+};
+const symlinkLocalClient = async (targetPath) => {
+    try {
+        const resolvedPath = path.resolve(targetPath);
+        if (!(await fse.pathExists(resolvedPath))) {
+            return `Path does not exist: ${resolvedPath}`;
+        }
+        const stats = await fse.stat(resolvedPath);
+        if (!stats.isDirectory()) {
+            return `Path is not a directory: ${resolvedPath}`;
+        }
+        if (await fse.pathExists(MINT_PATH)) {
+            const existingStats = await fse.lstat(MINT_PATH);
+            if (existingStats.isSymbolicLink()) {
+                await fse.remove(MINT_PATH);
+            }
+            else {
+                if (await fse.pathExists(MINT_BACKUP_PATH)) {
+                    await fse.remove(MINT_BACKUP_PATH);
+                }
+                await fse.move(MINT_PATH, MINT_BACKUP_PATH);
+            }
+        }
+        await fse.ensureDir(path.dirname(MINT_PATH));
+        await fse.symlink(resolvedPath, MINT_PATH);
+        const buildError = await buildClient();
+        if (buildError) {
+            return buildError;
+        }
+        return undefined;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : 'unknown error';
+    }
+};
+export const silentUpdateClient = async ({ versionString, clientVersion, localClientVersion, cliVersion, }) => {
+    // Handle local client symlink
+    if (localClientVersion) {
+        const error = await symlinkLocalClient(localClientVersion);
+        return { needsUpdate: false, error };
+    }
+    // If currently symlinked but not using local client, restore from backup
+    if (await isCurrentlySymlinked()) {
+        const restoreError = await restoreFromBackup();
+        if (restoreError) {
+            return { needsUpdate: false, error: restoreError };
+        }
+        // Re-read version string after restore
+        const newVersionString = (await fse.pathExists(path.join(MINT_PATH, 'mint-version.txt')))
+            ? fse.readFileSync(path.join(MINT_PATH, 'mint-version.txt'), 'utf8')
+            : null;
+        // Continue with normal update logic using restored version
+        return silentUpdateClientInternal({
+            versionString: newVersionString,
+            clientVersion,
+            cliVersion,
+        });
+    }
+    return silentUpdateClientInternal({ versionString, clientVersion, cliVersion });
+};
+const silentUpdateClientInternal = async ({ versionString, clientVersion, cliVersion, }) => {
     const latestClientVersion = await getLatestClientVersion();
     const hasLatestClientVersion = latestClientVersion && versionString && versionString.trim() === latestClientVersion.trim();
     if (clientVersion) {
         // always download specific client version if provided
-        const error = await tryDownloadTargetMint({ targetVersion: clientVersion, existingVersion: versionString });
+        const error = await tryDownloadTargetMint({
+            targetVersion: clientVersion,
+            existingVersion: versionString,
+        });
         return { needsUpdate: false, error };
     }
     else if ((!versionString || cliVersion === LOCAL_LINKED_CLI_VERSION) && latestClientVersion) {
         // if no version exists, download latest
-        const error = await tryDownloadTargetMint({ targetVersion: latestClientVersion, existingVersion: null });
+        const error = await tryDownloadTargetMint({
+            targetVersion: latestClientVersion,
+            existingVersion: null,
+        });
         return { needsUpdate: false, error };
     }
     else if (cliVersion && !hasLatestClientVersion) {
         // if not on latest, check whether to download latest or max
         const maxClientVersion = await getCompatibleClientVersion({ cliVersion });
         const hasMaxClientVersion = maxClientVersion && versionString && versionString.trim() === maxClientVersion.trim();
-        if (maxClientVersion === "latest" && latestClientVersion) {
+        if (maxClientVersion === 'latest' && latestClientVersion) {
             // if latest, download latest
-            const error = await tryDownloadTargetMint({ targetVersion: latestClientVersion, existingVersion: versionString });
+            const error = await tryDownloadTargetMint({
+                targetVersion: latestClientVersion,
+                existingVersion: versionString,
+            });
             return { needsUpdate: false, error };
         }
         else if (maxClientVersion && !hasMaxClientVersion) {
             // if maxxed out, needs update
-            const error = await tryDownloadTargetMint({ targetVersion: maxClientVersion, existingVersion: versionString });
+            const error = await tryDownloadTargetMint({
+                targetVersion: maxClientVersion,
+                existingVersion: versionString,
+            });
             return { needsUpdate: true, error };
         }
         else {