@mintlify/previewing 4.0.1539 → 4.0.1541

package/dist/__tests__/dev.test.js

@@ -1,8 +1,8 @@
 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 { isOnline } from '../local-preview/is-online.js';
 import { run } from '../local-preview/run.js';
 import { silentUpdateClient } from '../local-preview/update.js';
 import * as logs from '../logging-state.js';
@@ -27,8 +27,8 @@ vi.mock('../local-preview/update.js', () => ({
 vi.mock('../local-preview/preview-lock.js', () => ({
     acquirePreviewLock: vi.fn().mockReturnValue(vi.fn()),
 }));
-vi.mock('is-online', () => ({
-    default: vi.fn().mockResolvedValue(true),
+vi.mock('../local-preview/is-online.js', () => ({
+    isOnline: vi.fn().mockResolvedValue(true),
 }));
 vi.mock('@mintlify/prebuild', () => ({
     prebuild: vi.fn().mockResolvedValue(undefined),

package/dist/__tests__/is-online.test.d.ts

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

package/dist/__tests__/is-online.test.js

@@ -0,0 +1,87 @@
+import os from 'node:os';
+import { isOnline } from '../local-preview/is-online.js';
+const externalInterfaces = {
+    eth0: [
+        {
+            address: '203.0.113.5',
+            netmask: '255.255.255.0',
+            family: 'IPv4',
+            mac: '00:00:00:00:00:00',
+            internal: false,
+            cidr: '203.0.113.5/24',
+        },
+    ],
+};
+const internalInterfaces = {
+    lo: [
+        {
+            address: '127.0.0.1',
+            netmask: '255.0.0.0',
+            family: 'IPv4',
+            mac: '00:00:00:00:00:00',
+            internal: true,
+            cidr: '127.0.0.1/8',
+        },
+    ],
+};
+const okResponse = () => ({
+    ok: true,
+    body: { cancel: vi.fn().mockResolvedValue(undefined) },
+});
+describe('isOnline', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.unstubAllGlobals();
+    });
+    it('returns false without probing when every interface is internal', async () => {
+        vi.spyOn(os, 'networkInterfaces').mockReturnValue(internalInterfaces);
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(isOnline()).resolves.toBe(false);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    it('returns true when one probe succeeds and aborts the other', async () => {
+        vi.spyOn(os, 'networkInterfaces').mockReturnValue(externalInterfaces);
+        const unhandled = [];
+        const onUnhandled = (reason) => {
+            unhandled.push(reason);
+        };
+        process.on('unhandledRejection', onUnhandled);
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (String(url).includes('cloudflare')) {
+                return new Promise((_resolve, reject) => {
+                    init?.signal?.addEventListener('abort', () => {
+                        reject(init.signal?.reason ?? new Error('The operation was aborted'));
+                    });
+                });
+            }
+            return Promise.resolve(okResponse());
+        }));
+        await expect(isOnline(1_000)).resolves.toBe(true);
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        process.off('unhandledRejection', onUnhandled);
+        expect(unhandled).toEqual([]);
+    });
+    it('returns false when every probe fails', async () => {
+        vi.spyOn(os, 'networkInterfaces').mockReturnValue(externalInterfaces);
+        vi.stubGlobal('fetch', vi.fn(async () => ({ ok: false, status: 503 })));
+        await expect(isOnline()).resolves.toBe(false);
+    });
+    it('aborts a hung probe and does not surface the abort as an unhandled rejection', async () => {
+        vi.spyOn(os, 'networkInterfaces').mockReturnValue(externalInterfaces);
+        const unhandled = [];
+        const onUnhandled = (reason) => {
+            unhandled.push(reason);
+        };
+        process.on('unhandledRejection', onUnhandled);
+        vi.stubGlobal('fetch', vi.fn((_url, init) => new Promise((_resolve, reject) => {
+            init?.signal?.addEventListener('abort', () => {
+                reject(init.signal?.reason ?? new Error('The operation was aborted'));
+            });
+        })));
+        await expect(isOnline(20)).resolves.toBe(false);
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        process.off('unhandledRejection', onUnhandled);
+        expect(unhandled).toEqual([]);
+    });
+});

package/dist/__tests__/packages-runtime-wiring.test.js

@@ -30,7 +30,7 @@ vi.mock('@mintlify/prebuild', () => ({
     prebuild: vi.fn().mockResolvedValue(undefined),
     getFileListSync: vi.fn().mockReturnValue([]),
 }));
-vi.mock('is-online', () => ({ default: vi.fn().mockResolvedValue(true) }));
+vi.mock('../local-preview/is-online.js', () => ({ isOnline: vi.fn().mockResolvedValue(true) }));
 vi.mock('../local-preview/update.js', () => ({
     silentUpdateClient: vi.fn().mockResolvedValue({ needsUpdate: false, error: undefined }),
 }));

package/dist/__tests__/validate-build.test.js

@@ -1,12 +1,12 @@
 import { prebuild } from '@mintlify/prebuild';
-import isOnline from 'is-online';
+import { isOnline } from '../local-preview/is-online.js';
 import { checkBuild } from '../local-preview/validate-build.js';
 import { addLog } from '../logging-state.js';
 vi.mock('@mintlify/prebuild', async (importOriginal) => {
     const mod = await importOriginal();
     return { ...mod, prebuild: vi.fn() };
 });
-vi.mock('is-online', () => ({ default: vi.fn() }));
+vi.mock('../local-preview/is-online.js', () => ({ isOnline: vi.fn() }));
 vi.mock('fs-extra', () => {
     const mocks = {
         ensureDir: vi.fn().mockResolvedValue(undefined),

package/dist/local-preview/client.js

@@ -1,11 +1,11 @@
 import fse from 'fs-extra';
 import got from 'got';
-import isOnline from 'is-online';
 import yaml from 'js-yaml';
 import { pipeline } from 'node:stream/promises';
 import * as tar from 'tar';
 import { PREVIEW_PATH, PREVIEW_LAST_PATH, VERSION_PATH, TAR_PATH, TARGET_MINT_VERSION_URL, MINT_VERSION_MAP_URL, } from '../constants.js';
 import { restoreMintlifyLast, getTarUrl } from '../util.js';
+import { isOnline } from './is-online.js';
 export const getLatestClientVersion = async () => {
     const hasInternet = await isOnline();
     if (!hasInternet) {

package/dist/local-preview/export.js

@@ -5,7 +5,6 @@ import AdmZip from 'adm-zip';
 import express from 'express';
 import fse, { pathExists } from 'fs-extra';
 import { createServer } from 'http';
-import isOnline from 'is-online';
 import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -17,6 +16,7 @@ import { applyBasePathToExport, findBasePathConflict, normalizeExportBasePath, }
 import { generateExportLlmsTxt } from './export-llms.js';
 import { writeSearchIndex } from './export-search.js';
 import { getGroupFilteredRoutes } from './getGroupFilteredRoutes.js';
+import { isOnline } from './is-online.js';
 import { setupNext } from './setupNext.js';
 import { silentUpdateClient } from './update.js';
 const CONCURRENCY = 10;

package/dist/local-preview/index.js

@@ -1,7 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { getFileListSync, prebuild } from '@mintlify/prebuild';
 import fse, { pathExists } from 'fs-extra';
-import isOnline from 'is-online';
 import pathUtil from 'path';
 import { CLIENT_PATH, CMD_EXEC_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, PREVIEW_PATH, configurePreviewPath, } from '../constants.js';
 import { addLog, clearLogs } from '../logging-state.js';
@@ -9,6 +8,7 @@ import { ErrorLog, SpinnerLog } from '../logs.js';
 import { seedPreviewFromShared } from '../util.js';
 import { timeDev, timeDevSync } from './dev-timing.js';
 import { ensureDocsConfig } from './ensure-docs-config.js';
+import { isOnline } from './is-online.js';
 import { startPackagesDev } from './packages/index.js';
 import { acquirePreviewLock } from './preview-lock.js';
 import { run } from './run.js';

package/dist/local-preview/is-online.d.ts

@@ -0,0 +1 @@
+export declare const isOnline: (timeoutMs?: number) => Promise<boolean>;

package/dist/local-preview/is-online.js

@@ -0,0 +1,38 @@
+import os from 'node:os';
+const PROBE_URLS = [
+    'https://captive.apple.com/hotspot-detect.html',
+    'https://cloudflare.com/cdn-cgi/trace',
+];
+const DEFAULT_TIMEOUT_MS = 5_000;
+const hasExternalNetworkInterface = () => {
+    const interfaces = os.networkInterfaces();
+    return Object.values(interfaces).some((entries) => entries?.some((entry) => entry && !entry.internal));
+};
+export const isOnline = async (timeoutMs = DEFAULT_TIMEOUT_MS) => {
+    if (!hasExternalNetworkInterface()) {
+        return false;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        await Promise.any(PROBE_URLS.map(async (url) => {
+            const response = await fetch(url, { signal: controller.signal });
+            if (!response.ok) {
+                throw new Error(`connectivity check failed with status ${response.status}`);
+            }
+            try {
+                await response.body?.cancel();
+            }
+            catch { }
+            return true;
+        }));
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+        controller.abort();
+    }
+};

package/dist/local-preview/validate-build.js

@@ -1,11 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { prebuild } from '@mintlify/prebuild';
 import fse, { pathExists } from 'fs-extra';
-import isOnline from 'is-online';
 import { CLIENT_PATH, CMD_EXEC_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, PREVIEW_PATH, configureSharedPreviewPath, } from '../constants.js';
 import { addLog, clearLogs } from '../logging-state.js';
 import { ErrorLog, SpinnerLog, SuccessLog } from '../logs.js';
 import { timeDev, timeDevSync } from './dev-timing.js';
+import { isOnline } from './is-online.js';
 import { silentUpdateClient } from './update.js';
 export const checkBuild = async (argv) => {
     configureSharedPreviewPath();