@heybox/hb-sdk 0.3.3 → 0.4.1

package/dist/cli-chunks/dev-v-tcA7mM.cjs

@@ -0,0 +1,955 @@
+'use strict';
+
+var node_module = require('node:module');
+var fs = require('node:fs');
+var fs$1 = require('node:fs/promises');
+var os = require('node:os');
+var path = require('node:path');
+var node_url = require('node:url');
+var net = require('node:net');
+var node_http = require('node:http');
+var browser = require('./browser-RAy8e8cV.cjs');
+var index = require('./index-DDqd9qAR.cjs');
+require('node:process');
+require('node:buffer');
+require('node:util');
+require('node:child_process');
+require('path');
+require('os');
+require('readline');
+require('tty');
+require('assert');
+require('events');
+require('stream');
+require('buffer');
+require('util');
+
+class Locked extends Error {
+	constructor(port) {
+		super(`${port} is locked`);
+	}
+}
+
+const lockedPorts = {
+	old: new Set(),
+	young: new Set(),
+};
+
+// On this interval, the old locked ports are discarded,
+// the young locked ports are moved to old locked ports,
+// and a new young set for locked ports are created.
+const releaseOldLockedPortsIntervalMs = 1000 * 15;
+
+// Keep `reserve` deliberately process-wide by port number.
+// It is meant to avoid in-process races, not to model every possible
+// IPv4/IPv6 or host-specific bind combination.
+const reservedPorts = new Set();
+
+// Lazily create timeout on first use
+let timeout;
+
+const getLocalHosts = () => {
+	const interfaces = os.networkInterfaces();
+
+	// Add undefined value for createServer function to use default host,
+	// and default IPv4 host in case createServer defaults to IPv6.
+	const results = new Set([undefined, '0.0.0.0']);
+
+	for (const _interface of Object.values(interfaces)) {
+		for (const config of _interface) {
+			results.add(config.address);
+		}
+	}
+
+	return results;
+};
+
+const checkAvailablePort = options =>
+	new Promise((resolve, reject) => {
+		const server = net.createServer();
+		server.unref();
+		server.on('error', reject);
+
+		server.listen(options, () => {
+			const {port} = server.address();
+			server.close(() => {
+				resolve(port);
+			});
+		});
+	});
+
+const getAvailablePort = async (options, hosts) => {
+	if (options.host || options.port === 0) {
+		return checkAvailablePort(options);
+	}
+
+	for (const host of hosts) {
+		try {
+			await checkAvailablePort({port: options.port, host}); // eslint-disable-line no-await-in-loop
+		} catch (error) {
+			if (!['EADDRNOTAVAIL', 'EINVAL'].includes(error.code)) {
+				throw error;
+			}
+		}
+	}
+
+	return options.port;
+};
+
+const isLockedPort = port => lockedPorts.old.has(port) || lockedPorts.young.has(port) || reservedPorts.has(port);
+
+const portCheckSequence = function * (ports) {
+	if (ports) {
+		yield * ports;
+	}
+
+	yield 0; // Fall back to 0 if anything else failed
+};
+
+async function getPorts(options) {
+	let ports;
+	let exclude = new Set();
+
+	if (options) {
+		if (options.port) {
+			ports = typeof options.port === 'number' ? [options.port] : options.port;
+		}
+
+		if (options.exclude) {
+			const excludeIterable = options.exclude;
+
+			if (typeof excludeIterable[Symbol.iterator] !== 'function') {
+				throw new TypeError('The `exclude` option must be an iterable.');
+			}
+
+			for (const element of excludeIterable) {
+				if (typeof element !== 'number') {
+					throw new TypeError('Each item in the `exclude` option must be a number corresponding to the port you want excluded.');
+				}
+
+				if (!Number.isSafeInteger(element)) {
+					throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
+				}
+			}
+
+			exclude = new Set(excludeIterable);
+		}
+	}
+
+	const {reserve, ...netOptions} = options ?? {};
+
+	if (timeout === undefined) {
+		timeout = setTimeout(() => {
+			timeout = undefined;
+
+			lockedPorts.old = lockedPorts.young;
+			lockedPorts.young = new Set();
+		}, releaseOldLockedPortsIntervalMs);
+
+		// Does not exist in some environments (Electron, Jest jsdom env, browser, etc).
+		if (timeout.unref) {
+			timeout.unref();
+		}
+	}
+
+	const hosts = getLocalHosts();
+
+	for (const port of portCheckSequence(ports)) {
+		try {
+			if (exclude.has(port)) {
+				continue;
+			}
+
+			let availablePort = await getAvailablePort({...netOptions, port}, hosts); // eslint-disable-line no-await-in-loop
+			while (isLockedPort(availablePort)) {
+				if (port !== 0) {
+					throw new Locked(port);
+				}
+
+				availablePort = await getAvailablePort({...netOptions, port}, hosts); // eslint-disable-line no-await-in-loop
+			}
+
+			if (reserve) {
+				reservedPorts.add(availablePort);
+			} else {
+				lockedPorts.young.add(availablePort);
+			}
+
+			return availablePort;
+		} catch (error) {
+			if (!['EADDRINUSE', 'EACCES'].includes(error.code) && !(error instanceof Locked)) {
+				throw error;
+			}
+		}
+	}
+
+	throw new Error('No available ports found');
+}
+
+const MINI_PROGRAM_URL_QUERY_PARAM$1 = 'mini_url';
+const LAN_ADDRESSES_PATH = '/__hb_sdk_lan_addresses__';
+const MOCK_NETWORK_PROXY_PATH = '/__hb_sdk_mock_network__';
+const MOCK_NETWORK_PROXY_BODY_LIMIT = 1024 * 1024;
+const DEV_LISTEN_HOST$1 = '0.0.0.0';
+const LOCAL_DEV_URL_HOST$1 = '127.0.0.1';
+const MOCK_HOST_ROOT_CANDIDATES = [
+    path.resolve(__dirname, 'devtools/mock-host'),
+    path.resolve(__dirname, '../devtools/mock-host'),
+    path.resolve(__dirname, '../../devtools/mock-host'),
+    path.resolve(__dirname, '../../../devtools/mock-host'),
+];
+async function startMiniProgramMockHostServer(options) {
+    const root = options.root ?? resolveMiniProgramMockHostRoot(options.rootCandidates);
+    assertCompleteMiniProgramMockHostRoot(root);
+    const server = createMiniProgramMockHostServer(root, {
+        appUrl: options.appUrl,
+        defaultLanAddressId: options.defaultLanAddressId,
+        fetchImpl: options.fetchImpl ?? fetch,
+        lanAddresses: options.lanAddresses ?? [],
+        macAppProtocol: options.macAppProtocol,
+    });
+    const port = await listenHttpServer(server, {
+        port: options.port,
+    }, options.getPort ?? getPorts);
+    return {
+        close: () => new Promise((resolve) => {
+            server.close(() => resolve());
+        }),
+        networkUrls: createMiniProgramMockHostNetworkUrls({
+            lanAddresses: options.lanAddresses,
+            port,
+        }),
+        port,
+        root,
+        server,
+        url: createMiniProgramMockHostUrl({
+            appUrl: options.appUrl,
+            port,
+        }),
+    };
+}
+function resolveMiniProgramMockHostRoot(candidates = MOCK_HOST_ROOT_CANDIDATES) {
+    const found = candidates.find(isCompleteMiniProgramMockHostRoot);
+    if (!found) {
+        throw createMissingMockHostError();
+    }
+    return found;
+}
+function assertCompleteMiniProgramMockHostRoot(root) {
+    if (!isCompleteMiniProgramMockHostRoot(root)) {
+        throw createMissingMockHostError();
+    }
+}
+function isCompleteMiniProgramMockHostRoot(root) {
+    return fs.existsSync(path.join(root, 'index.html')) && fs.existsSync(path.join(root, 'main.js'));
+}
+function createMissingMockHostError() {
+    return new Error('未找到完整的 hb-sdk mock host 静态产物。请先执行 @heybox/hb-sdk 的 build:mock-host。');
+}
+function createMiniProgramMockHostUrl(options) {
+    return createMiniProgramMockHostUrlWithHost({
+        ...options,
+        host: LOCAL_DEV_URL_HOST$1,
+    });
+}
+function createMiniProgramMockHostNetworkUrls(options) {
+    return (options.lanAddresses ?? []).map((address) => createMiniProgramMockHostUrlWithHost({
+        appUrl: address.appUrl,
+        host: address.address,
+        port: options.port,
+    }));
+}
+function createMiniProgramMockHostUrlWithHost(options) {
+    const url = new URL(`http://${options.host}:${options.port}/`);
+    url.searchParams.set(MINI_PROGRAM_URL_QUERY_PARAM$1, options.appUrl);
+    return url.toString();
+}
+function createMiniProgramMockHostServer(root, runtime) {
+    return node_http.createServer(async (request, response) => {
+        const requestUrl = new URL(request.url, 'http://localhost');
+        const pathname = decodeURIComponent(requestUrl.pathname);
+        if (isMockHostDocumentPath(pathname) && !requestUrl.searchParams.has(MINI_PROGRAM_URL_QUERY_PARAM$1)) {
+            const targetUrl = new URL(requestUrl);
+            targetUrl.pathname = '/';
+            targetUrl.searchParams.set(MINI_PROGRAM_URL_QUERY_PARAM$1, runtime.appUrl);
+            response.writeHead(302, {
+                location: `${targetUrl.pathname}${targetUrl.search}`,
+                'cache-control': 'no-store',
+            });
+            response.end();
+            return;
+        }
+        if (pathname === LAN_ADDRESSES_PATH) {
+            writeJsonResponse(response, 200, {
+                defaultLanAddressId: runtime.defaultLanAddressId,
+                lanAddresses: runtime.lanAddresses,
+                macAppProtocol: runtime.macAppProtocol,
+            });
+            return;
+        }
+        if (pathname === MOCK_NETWORK_PROXY_PATH) {
+            await handleMockNetworkProxy(request, response, runtime.fetchImpl);
+            return;
+        }
+        const targetPath = resolveStaticPath(root, pathname);
+        if (!targetPath) {
+            response.writeHead(404);
+            response.end('Not found');
+            return;
+        }
+        try {
+            const stat = fs.statSync(targetPath);
+            if (stat.isDirectory()) {
+                response.writeHead(404);
+                response.end('Not found');
+                return;
+            }
+            response.writeHead(200, {
+                'content-type': readContentType(targetPath),
+                'cache-control': 'no-store',
+            });
+            fs.createReadStream(targetPath).pipe(response);
+        }
+        catch {
+            response.writeHead(404);
+            response.end('Not found');
+        }
+    });
+}
+function isMockHostDocumentPath(pathname) {
+    return pathname === '/' || pathname === '/index.html';
+}
+async function handleMockNetworkProxy(request, response, fetchImpl) {
+    if (request.method === 'OPTIONS') {
+        writeJsonResponse(response, 204, undefined);
+        return;
+    }
+    if (request.method !== 'POST') {
+        writeJsonResponse(response, 405, {
+            code: 'METHOD_NOT_ALLOWED',
+            message: 'mock network proxy only supports POST',
+        });
+        return;
+    }
+    try {
+        const payload = await readJsonRequestBody(request);
+        const result = await requestMockNetwork(payload, fetchImpl);
+        writeJsonResponse(response, 200, result);
+    }
+    catch (error) {
+        writeJsonResponse(response, readMockNetworkErrorStatus(error), toMockNetworkErrorPayload(error));
+    }
+}
+async function requestMockNetwork(payload, fetchImpl) {
+    if (!isRecord(payload) || typeof payload.url !== 'string' || !payload.url.trim()) {
+        throw createMockNetworkError(400, 'INVALID_NETWORK_REQUEST', 'network.request url 必须是非空字符串');
+    }
+    const url = createMockNetworkUrl(payload.url, payload.params);
+    const method = typeof payload.method === 'string' && payload.method.trim() ? payload.method.trim().toUpperCase() : 'GET';
+    const headers = normalizeMockNetworkHeaders(payload.headers);
+    const controller = new AbortController();
+    const timeout = Number(payload.timeout) > 0 ? Number(payload.timeout) : 10000;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetchImpl(url.toString(), {
+            method,
+            headers,
+            body: createMockNetworkBody(method, payload.data, headers),
+            redirect: 'follow',
+            signal: controller.signal,
+        });
+        const contentType = response.headers.get('content-type') || '';
+        const text = await response.text();
+        clearTimeout(timer);
+        return {
+            data: contentType.includes('application/json') ? safeJsonParse(text) : text,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+        };
+    }
+    catch (error) {
+        clearTimeout(timer);
+        throw createMockNetworkError(502, 'MOCK_NETWORK_REQUEST_FAILED', error instanceof Error && error.name === 'AbortError'
+            ? `network.request timeout after ${timeout}ms`
+            : readErrorMessage(error));
+    }
+}
+function createMockNetworkUrl(input, params) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        throw createMockNetworkError(400, 'INVALID_NETWORK_REQUEST', 'network.request url 必须是合法 URL');
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        throw createMockNetworkError(400, 'INVALID_NETWORK_REQUEST', 'network.request 仅支持 HTTP(S) URL');
+    }
+    if (isRecord(params)) {
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                url.searchParams.set(key, String(value));
+            }
+        });
+    }
+    return url;
+}
+function normalizeMockNetworkHeaders(headers) {
+    const normalized = new Headers();
+    if (!isRecord(headers)) {
+        return normalized;
+    }
+    Object.entries(headers).forEach(([key, value]) => {
+        if (typeof value === 'string' && !isBlockedMockNetworkHeader(key)) {
+            normalized.set(key, value);
+        }
+    });
+    return normalized;
+}
+function isBlockedMockNetworkHeader(key) {
+    return [
+        'connection',
+        'content-length',
+        'host',
+        'keep-alive',
+        'proxy-authenticate',
+        'proxy-authorization',
+        'te',
+        'trailer',
+        'transfer-encoding',
+        'upgrade',
+    ].includes(key.toLowerCase());
+}
+function createMockNetworkBody(method, data, headers) {
+    if (data === undefined || method === 'GET' || method === 'HEAD') {
+        return undefined;
+    }
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/json');
+    }
+    return JSON.stringify(data);
+}
+function readJsonRequestBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        request.on('data', (chunk) => {
+            const buffer = Buffer.from(chunk);
+            size += buffer.byteLength;
+            if (size > MOCK_NETWORK_PROXY_BODY_LIMIT) {
+                reject(createMockNetworkError(413, 'REQUEST_ENTITY_TOO_LARGE', 'mock network proxy request body too large'));
+                request.destroy();
+                return;
+            }
+            chunks.push(buffer);
+        });
+        request.on('error', reject);
+        request.on('aborted', () => {
+            reject('mock network proxy request aborted');
+        });
+        request.on('end', () => {
+            const rawBody = Buffer.concat(chunks).toString('utf8');
+            if (!rawBody.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(rawBody));
+            }
+            catch {
+                reject(createMockNetworkError(400, 'INVALID_JSON', 'mock network proxy received invalid JSON'));
+            }
+        });
+    });
+}
+function writeJsonResponse(response, status, body) {
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+    });
+    response.end(body === undefined ? '' : JSON.stringify(body));
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function isRecord(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+function createMockNetworkError(status, code, message) {
+    const error = new Error(message);
+    error.code = code;
+    error.status = status;
+    return error;
+}
+function readMockNetworkErrorStatus(error) {
+    return isObjectLike(error) && typeof error.status === 'number' ? error.status : 500;
+}
+function toMockNetworkErrorPayload(error) {
+    if (isObjectLike(error) && typeof error.code === 'string' && typeof error.message === 'string') {
+        return {
+            code: error.code,
+            message: error.message,
+        };
+    }
+    return {
+        code: 'MOCK_NETWORK_ERROR',
+        message: readErrorMessage(error),
+    };
+}
+function isObjectLike(value) {
+    return (typeof value === 'object' || typeof value === 'function') && value !== null;
+}
+function resolveStaticPath(root, pathname) {
+    const safePathname = pathname === '/' ? '/index.html' : pathname;
+    const normalizedRoot = path.normalize(root);
+    const targetPath = path.normalize(path.join(normalizedRoot, safePathname));
+    if (targetPath !== normalizedRoot && !targetPath.startsWith(`${normalizedRoot}${path.sep}`)) {
+        return undefined;
+    }
+    return targetPath;
+}
+function readContentType(filePath) {
+    if (filePath.endsWith('.html')) {
+        return 'text/html; charset=utf-8';
+    }
+    if (filePath.endsWith('.js')) {
+        return 'text/javascript; charset=utf-8';
+    }
+    if (filePath.endsWith('.css')) {
+        return 'text/css; charset=utf-8';
+    }
+    if (filePath.endsWith('.json')) {
+        return 'application/json; charset=utf-8';
+    }
+    if (filePath.endsWith('.svg')) {
+        return 'image/svg+xml';
+    }
+    return 'application/octet-stream';
+}
+async function listenHttpServer(server, options, getPortImpl) {
+    const maxAttempts = 20;
+    const port = await getPortImpl({
+        host: DEV_LISTEN_HOST$1,
+        port: createPortCandidates(options.port, maxAttempts),
+    });
+    if (port < options.port || port >= options.port + maxAttempts) {
+        throw new Error(`无法找到可用 mock host 端口，起始端口: ${options.port}`);
+    }
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, DEV_LISTEN_HOST$1);
+    });
+    const address = server.address();
+    return address.port;
+}
+function createPortCandidates(startPort, count) {
+    return Array.from({ length: count }, (_, index) => startPort + index);
+}
+function readErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+
+const MINI_PROGRAM_URL_QUERY_PARAM = 'mini_url';
+const MINI_PROGRAM_RUNTIME_URL_QUERY_PARAM = 'runtime_url';
+const MINI_PROGRAM_DEV_SHELL_URL = 'heybox-mini-dev://sandbox';
+const OPEN_IN_APP_URL = 'https://api.xiaoheihe.cn/open_inapp/';
+function createMacAppProtocol(appUrl, options = {}) {
+    return createHeyboxProtocol(createMiniProgramDevShellOpenWindowPayload(appUrl, options));
+}
+function createMobileAppQrPayload(appUrl, options = {}) {
+    return `${OPEN_IN_APP_URL}#${createHeyboxProtocol(createMiniProgramDevShellOpenWindowPayload(appUrl, { ...options, encodeMiniUrl: false }))}`;
+}
+function createMiniProgramDevShellOpenWindowPayload(appUrl, options = {}) {
+    const devShellUrl = options.encodeMiniUrl === false
+        ? createPartiallyEncodedMiniProgramDevShellUrl(appUrl, options.runtimeUrl)
+        : createEncodedMiniProgramDevShellUrl(appUrl, options.runtimeUrl);
+    return {
+        protocol_type: 'openWindow',
+        full_screen: true,
+        mini_program: '1',
+        navigation_bar: {
+            title: '',
+        },
+        webview: {
+            url: devShellUrl,
+            pull: false,
+            refresh: false,
+        },
+    };
+}
+function createPartiallyEncodedMiniProgramDevShellUrl(appUrl, runtimeUrl) {
+    let devShellUrl = `${MINI_PROGRAM_DEV_SHELL_URL}?${MINI_PROGRAM_URL_QUERY_PARAM}=${appUrl}`;
+    if (hasRuntimeUrl(runtimeUrl)) {
+        devShellUrl += `&${MINI_PROGRAM_RUNTIME_URL_QUERY_PARAM}=${encodeURIComponent(runtimeUrl)}`;
+    }
+    return devShellUrl;
+}
+function createEncodedMiniProgramDevShellUrl(appUrl, runtimeUrl) {
+    const devShellUrl = new URL(MINI_PROGRAM_DEV_SHELL_URL);
+    devShellUrl.searchParams.set(MINI_PROGRAM_URL_QUERY_PARAM, appUrl);
+    if (hasRuntimeUrl(runtimeUrl)) {
+        devShellUrl.searchParams.set(MINI_PROGRAM_RUNTIME_URL_QUERY_PARAM, runtimeUrl);
+    }
+    return devShellUrl.toString();
+}
+function hasRuntimeUrl(runtimeUrl) {
+    return runtimeUrl !== undefined && runtimeUrl !== '';
+}
+function createHeyboxProtocol(payload) {
+    return `heybox://${encodeURIComponent(JSON.stringify(payload))}`;
+}
+
+const DEFAULT_APP_PORT = 5173;
+const DEFAULT_MOCK_PORT = 5174;
+const DEV_LISTEN_HOST = '0.0.0.0';
+const LOCAL_DEV_URL_HOST = '127.0.0.1';
+// Shared with Heybox H5 Vite plugins so hb-sdk can own the launch output.
+const MANAGED_DEV_OUTPUT_ENV = 'HEYBOX_DEV_SERVER_MANAGED_OUTPUT';
+const VITE_LOG_LEVEL = 'warn';
+async function runDevCommand(options, runtime = {}) {
+    const logger = runtime.logger ?? index.createCliLogger();
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const openUrl = runtime.openExternalUrl ?? browser.openExternalUrl;
+    const projectRoot = findProjectRoot(runtime.cwd ?? process.cwd());
+    const vite = await logger.task('正在加载项目 Vite', () => loadProjectVite(projectRoot), { successText: '已加载项目 Vite' });
+    const appServer = await logger.task('正在创建 Vite dev server', () => withManagedDevOutputEnv(() => vite.createServer(createViteServerOptions(projectRoot, options)), runtime.env), { successText: '已创建 Vite dev server' });
+    await logger.task('正在启动 Vite dev server', () => appServer.listen(options.port ?? DEFAULT_APP_PORT), {
+        successText: 'Vite dev server 已启动',
+    });
+    const appUrl = await logger.task('正在探测小程序入口', () => resolveViteAppUrl(appServer, options, fetchImpl), {
+        successText: '已确定小程序入口',
+    });
+    const lanAddresses = createLanAddressCandidates({
+        appUrl,
+        interfaces: (runtime.networkInterfaces ?? os.networkInterfaces)(),
+        runtimeUrl: options.runtimeUrl,
+        viteNetworkUrls: appServer.resolvedUrls?.network ?? [],
+    });
+    const closers = [() => appServer.close()];
+    let mockHost;
+    try {
+        mockHost = await logger.task('正在启动 Mock runtime host', () => startMiniProgramMockHostServer({
+            appUrl,
+            fetchImpl,
+            getPort: runtime.getPort ?? getPorts,
+            defaultLanAddressId: lanAddresses[0]?.id,
+            lanAddresses,
+            macAppProtocol: createMacAppProtocol(appUrl, { runtimeUrl: options.runtimeUrl }),
+            port: options.mockPort ?? DEFAULT_MOCK_PORT,
+            root: runtime.mockHostRoot,
+            rootCandidates: runtime.mockHostRootCandidates,
+        }), { successText: 'Mock runtime host 已启动' });
+    }
+    catch (error) {
+        await closeAll(closers);
+        throw error;
+    }
+    closers.push(() => mockHost.close());
+    logger.success('Mock runtime host 已就绪');
+    logger.info(`Mock runtime host: ${mockHost.url}`);
+    logger.info(`Mini program URL: ${appUrl}`);
+    logger.info('Mac APP: use the button in Mock runtime host');
+    logger.info('Mobile APP: scan the QR code in Mock runtime host');
+    if (options.open !== false) {
+        logger.debug('正在打开浏览器调试页');
+        void openUrl(mockHost.url);
+    }
+    installShutdownHandlers(closers, runtime.process ?? process);
+}
+function findProjectRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error('当前目录或父目录未找到 package.json');
+        }
+        current = parent;
+    }
+}
+async function loadProjectVite(projectRoot) {
+    const projectRequire = node_module.createRequire(path.join(projectRoot, 'package.json'));
+    try {
+        const packageJson = JSON.parse(await fs$1.readFile(path.join(projectRoot, 'package.json'), 'utf8'));
+        if (!hasPackageDependency(packageJson, 'vite')) {
+            throw new Error('package.json 未声明 vite');
+        }
+        const viteEntry = projectRequire.resolve('vite');
+        return (await import(node_url.pathToFileURL(viteEntry).href));
+    }
+    catch (error) {
+        throw new Error(`当前项目未安装 vite。请先安装项目依赖，或将 vite 放到项目 devDependencies。原始错误: ${index.readErrorMessage(error)}`);
+    }
+}
+function hasPackageDependency(packageJson, name) {
+    return Boolean(packageJson.dependencies?.[name] ||
+        packageJson.devDependencies?.[name] ||
+        packageJson.optionalDependencies?.[name] ||
+        packageJson.peerDependencies?.[name]);
+}
+function createViteServerOptions(projectRoot, options) {
+    const configFile = resolveProjectViteConfig(projectRoot);
+    const server = {
+        cors: true,
+        host: DEV_LISTEN_HOST,
+        port: options.port ?? DEFAULT_APP_PORT,
+        strictPort: false,
+    };
+    if (configFile) {
+        return {
+            configFile,
+            logLevel: VITE_LOG_LEVEL,
+            server,
+        };
+    }
+    return {
+        logLevel: VITE_LOG_LEVEL,
+        root: projectRoot,
+        server,
+    };
+}
+function resolveProjectViteConfig(projectRoot) {
+    const candidates = ['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs'];
+    return candidates.map((file) => path.join(projectRoot, file)).find((file) => fs.existsSync(file));
+}
+async function resolveViteAppUrl(server, options, fetchImpl) {
+    const candidates = createViteAppUrlCandidates(server, options);
+    for (const candidate of candidates) {
+        if (await canReachDocumentUrl(candidate, fetchImpl)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function createViteAppUrlCandidates(server, options) {
+    const localUrl = rewriteLocalhostUrl(server.resolvedUrls?.local[0]);
+    const origin = readViteOrigin(localUrl, options);
+    const candidates = [localUrl, createH5EntryUrl(origin, readViteBase(server, localUrl))].filter((url) => Boolean(url));
+    return Array.from(new Set(candidates));
+}
+function readViteOrigin(localUrl, options) {
+    if (localUrl) {
+        try {
+            return new URL(localUrl).origin;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const port = options.port ?? DEFAULT_APP_PORT;
+    return `http://${LOCAL_DEV_URL_HOST}:${port}`;
+}
+function readViteBase(server, localUrl) {
+    const base = server.config?.base;
+    if (base && base !== '/') {
+        return base;
+    }
+    if (localUrl) {
+        try {
+            return new URL(localUrl).pathname;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    return '/';
+}
+function createH5EntryUrl(origin, base) {
+    const pathname = `${ensureTrailingSlash(base)}src/index.html`;
+    return new URL(pathname, `${origin}/`).toString();
+}
+async function canReachDocumentUrl(url, fetchImpl) {
+    try {
+        const headResponse = await fetchImpl(url, {
+            method: 'HEAD',
+            redirect: 'follow',
+        });
+        if (headResponse.ok) {
+            return true;
+        }
+        if (headResponse.status !== 404 && headResponse.status !== 405) {
+            return false;
+        }
+        const getResponse = await fetchImpl(url, {
+            method: 'GET',
+            redirect: 'follow',
+        });
+        return getResponse.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith('/') ? value : `${value}/`;
+}
+function rewriteLocalhostUrl(input) {
+    if (!input) {
+        return undefined;
+    }
+    try {
+        const url = new URL(input);
+        if (isLocalhostHost(url.hostname)) {
+            url.hostname = LOCAL_DEV_URL_HOST;
+            return url.toString();
+        }
+    }
+    catch {
+        return input;
+    }
+    return input;
+}
+function isLocalhostHost(hostname) {
+    return hostname === 'localhost' || hostname === '::1' || hostname === '[::1]';
+}
+async function withManagedDevOutputEnv(action, env = process.env) {
+    const previous = env[MANAGED_DEV_OUTPUT_ENV];
+    env[MANAGED_DEV_OUTPUT_ENV] = '1';
+    try {
+        return await action();
+    }
+    finally {
+        if (previous === undefined) {
+            delete env[MANAGED_DEV_OUTPUT_ENV];
+        }
+        else {
+            env[MANAGED_DEV_OUTPUT_ENV] = previous;
+        }
+    }
+}
+function installShutdownHandlers(closers, processLike) {
+    const shutdown = async () => {
+        await closeAll(closers);
+        processLike.exit(0);
+    };
+    processLike.once('SIGINT', () => {
+        void shutdown();
+    });
+    processLike.once('SIGTERM', () => {
+        void shutdown();
+    });
+}
+async function closeAll(closers) {
+    await Promise.allSettled(closers.map((close) => close()));
+}
+function createLanAddressCandidates(options) {
+    const viteNetworkUrlByHost = new Map(options.viteNetworkUrls
+        .map((url) => [readUrlHost(url), url])
+        .filter((entry) => Boolean(entry[0])));
+    const candidates = Object.entries(options.interfaces)
+        .flatMap(([name, infos]) => (infos ?? []).map((info) => ({
+        info,
+        name,
+    })))
+        .filter(({ info }) => info.family === 'IPv4' && !info.internal && isPrivateIPv4(info.address))
+        .map(({ info, name }) => {
+        const appUrl = viteNetworkUrlByHost.get(info.address) ?? replaceUrlHost(options.appUrl, info.address);
+        if (!appUrl) {
+            return undefined;
+        }
+        const candidate = {
+            address: info.address,
+            appUrl,
+            id: `${name}-${info.address}`,
+            name,
+        };
+        const runtimeUrl = rewriteLoopbackUrlHost(options.runtimeUrl, info.address);
+        if (runtimeUrl !== undefined) {
+            candidate.mobileAppQrPayload = createMobileAppQrPayload(appUrl, { runtimeUrl });
+        }
+        else {
+            candidate.mobileAppQrPayload = createMobileAppQrPayload(appUrl);
+        }
+        return candidate;
+    })
+        .filter((candidate) => Boolean(candidate));
+    return candidates.sort((left, right) => {
+        const leftNetworkMatch = viteNetworkUrlByHost.has(left.address) ? 0 : 1;
+        const rightNetworkMatch = viteNetworkUrlByHost.has(right.address) ? 0 : 1;
+        if (leftNetworkMatch !== rightNetworkMatch) {
+            return leftNetworkMatch - rightNetworkMatch;
+        }
+        return readInterfacePriority(left.name) - readInterfacePriority(right.name) || left.name.localeCompare(right.name);
+    });
+}
+function rewriteLoopbackUrlHost(input, host) {
+    if (input === undefined || input === '') {
+        return undefined;
+    }
+    try {
+        const url = new URL(input);
+        if (isLoopbackHost(url.hostname)) {
+            url.hostname = host;
+            return url.toString();
+        }
+    }
+    catch {
+        return input;
+    }
+    return input;
+}
+function isLoopbackHost(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1' || hostname === '[::1]';
+}
+function readUrlHost(input) {
+    try {
+        return new URL(input).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+function replaceUrlHost(input, host) {
+    try {
+        const url = new URL(input);
+        url.hostname = host;
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function readInterfacePriority(name) {
+    const normalized = name.toLowerCase();
+    if (normalized.includes('wi-fi') || normalized.includes('wifi') || normalized.includes('wlan')) {
+        return 0;
+    }
+    if (normalized === 'en0') {
+        return 1;
+    }
+    if (normalized.startsWith('en') || normalized.includes('ethernet')) {
+        return 2;
+    }
+    return 3;
+}
+function isPrivateIPv4(address) {
+    const parts = address.split('.').map((part) => Number(part));
+    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+        return false;
+    }
+    return (parts[0] === 10 ||
+        (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) ||
+        (parts[0] === 192 && parts[1] === 168));
+}
+
+exports.runDevCommand = runDevCommand;