@heybox/hb-sdk 0.6.5 → 0.6.6-alpha.0

package/dist/cli-chunks/dev-BjlyFzNU.cjs

@@ -0,0 +1,1976 @@
+'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 promises = require('node:dns/promises');
+var node_http = require('node:http');
+var node_crypto = require('node:crypto');
+var undici = require('undici');
+var browser = require('./browser-RAy8e8cV.cjs');
+var index = require('./index-Ck6a9STO.cjs');
+var context = require('./context-Do5YcZPw.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');
+require('./session-DUM4KQHQ.cjs');
+require('fs');
+require('constants');
+
+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 MANAGED_RUNTIME_PERMISSION_KEYS = new Set(['network.request']);
+/**
+ * 判断 permission key 是否由 Runtime 权限快照管理。
+ *
+ * @param key 待判断的 permission key。
+ * @returns 该 key 需要读取 Runtime 权限快照时返回 `true`。
+ */
+function isManagedMiniProgramRuntimePermissionKey(key) {
+    return MANAGED_RUNTIME_PERMISSION_KEYS.has(key);
+}
+/**
+ * 解析服务端权限快照；格式不完整时整份快照失效并 fail closed。
+ *
+ * @param snapshot 待校验的服务端权限快照。
+ * @returns 解析状态和通过校验的受管权限。
+ */
+function parseMiniProgramRuntimePermissions(snapshot) {
+    if (!isRecord$2(snapshot) || snapshot.schema_version !== 1 || !Array.isArray(snapshot.entries)) {
+        return { valid: false, permissions: {} };
+    }
+    if (snapshot.revision !== undefined && (typeof snapshot.revision !== 'number' || !Number.isInteger(snapshot.revision) || snapshot.revision < 0)) {
+        return { valid: false, permissions: {} };
+    }
+    const seenKeys = new Set();
+    const permissions = {};
+    for (const rawEntry of snapshot.entries) {
+        if (!isRecord$2(rawEntry) || typeof rawEntry.key !== 'string' || !rawEntry.key.trim()) {
+            return { valid: false, permissions: {} };
+        }
+        const key = rawEntry.key.trim();
+        if (seenKeys.has(key) || (rawEntry.status !== 'enabled' && rawEntry.status !== 'disabled') || !isRecord$2(rawEntry.config)) {
+            return { valid: false, permissions: {} };
+        }
+        seenKeys.add(key);
+        if (!isManagedMiniProgramRuntimePermissionKey(key)) {
+            continue;
+        }
+        if (key === 'network.request' && typeof rawEntry.config.useOfficialDomain !== 'boolean') {
+            return { valid: false, permissions: {} };
+        }
+        permissions[key] = {
+            key,
+            status: rawEntry.status,
+            config: { useOfficialDomain: rawEntry.config.useOfficialDomain },
+        };
+    }
+    return { valid: true, permissions };
+}
+function isRecord$2(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** Dev Shell 读取局域网 Dev Session endpoint 的 query 参数。 */
+/** Mock Host 创建和读取 Dev Session 的固定路径。 */
+const MINI_PROGRAM_DEV_CONTEXT_PATH = '/__hb_sdk__/dev-context';
+/** Dev Session 当前使用的 schema 版本。 */
+const MINI_PROGRAM_DEV_SESSION_SCHEMA_VERSION = 1;
+
+const MOCK_HOST_JSON_BODY_LIMIT = 1024 * 1024;
+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_HOST_JSON_BODY_LIMIT) {
+                reject(createMockHostError(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(createMockHostError(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 writeTokenNetworkJsonResponse(response, status, body) {
+    response.writeHead(status, {
+        'access-control-allow-headers': 'content-type',
+        'access-control-allow-methods': 'POST, OPTIONS',
+        'access-control-allow-origin': '*',
+        'access-control-allow-private-network': 'true',
+        'cache-control': 'no-store',
+        'content-type': 'application/json; charset=utf-8',
+    });
+    response.end(body === undefined ? '' : JSON.stringify(body));
+}
+function writeSerializedJsonResponse(response, status, body) {
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+    });
+    response.end(body);
+}
+function isRecord$1(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+function isObjectLike(value) {
+    return (typeof value === 'object' || typeof value === 'function') && value !== null;
+}
+function createMockHostError(status, code, message) {
+    const error = new Error(message);
+    error.code = code;
+    error.status = status;
+    return error;
+}
+function readMockHostErrorStatus(error) {
+    return isObjectLike(error) && typeof error.status === 'number' ? error.status : 500;
+}
+function toMockHostErrorPayload(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 readErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+
+const MAX_MOCK_NETWORK_REDIRECTS = 5;
+const MAX_MOCK_NETWORK_REQUEST_BODY = 2 * 1024 * 1024;
+const MAX_MOCK_NETWORK_RESPONSE_BODY = 5 * 1024 * 1024;
+async function handleMockNetworkProxy(request, response, fetchImpl, lookupHostname, cors = false) {
+    if (request.method === 'OPTIONS') {
+        writeNetworkJsonResponse(response, 204, undefined, cors);
+        return;
+    }
+    if (request.method !== 'POST') {
+        writeNetworkJsonResponse(response, 405, {
+            code: 'METHOD_NOT_ALLOWED',
+            message: 'mock network proxy only supports POST',
+        }, cors);
+        return;
+    }
+    try {
+        const payload = await readJsonRequestBody(request);
+        const result = await requestMockNetwork(payload, fetchImpl, lookupHostname);
+        writeNetworkJsonResponse(response, 200, result, cors);
+    }
+    catch (error) {
+        writeNetworkJsonResponse(response, readMockHostErrorStatus(error), toMockHostErrorPayload(error), cors);
+    }
+}
+function writeNetworkJsonResponse(response, status, body, cors) {
+    if (cors) {
+        writeTokenNetworkJsonResponse(response, status, body);
+        return;
+    }
+    writeJsonResponse(response, status, body);
+}
+async function requestMockNetwork(payload, fetchImpl, lookupHostname) {
+    if (!isRecord$1(payload) || typeof payload.url !== 'string' || !payload.url.trim()) {
+        throw createMockHostError(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 body = createMockNetworkBody(method, payload.data, headers);
+    const controller = new AbortController();
+    const timeout = Number(payload.timeout) > 0 ? Number(payload.timeout) : 10000;
+    const timer = setTimeout(() => controller.abort(), timeout);
+    const pinnedTargets = new Map();
+    const dispatcher = createPinnedNetworkDispatcher(pinnedTargets);
+    try {
+        const response = await fetchMockNetworkWithRedirects({
+            body,
+            dispatcher,
+            fetchImpl,
+            headers,
+            lookupHostname,
+            method,
+            pinnedTargets,
+            signal: controller.signal,
+            url,
+        });
+        const contentType = response.headers.get('content-type') || '';
+        const text = await readLimitedMockNetworkResponse(response);
+        return {
+            data: contentType.includes('application/json') ? safeJsonParse(text) : text,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+        };
+    }
+    catch (error) {
+        if (isObjectLike(error) && typeof error.status === 'number') {
+            throw error;
+        }
+        throw createMockHostError(502, 'MOCK_NETWORK_REQUEST_FAILED', error instanceof Error && error.name === 'AbortError' ? `network.request timeout after ${timeout}ms` : readErrorMessage(error));
+    }
+    finally {
+        clearTimeout(timer);
+        await dispatcher.close();
+    }
+}
+async function fetchMockNetworkWithRedirects(options) {
+    let url = options.url;
+    let method = options.method;
+    let body = options.body;
+    for (let redirectCount = 0; redirectCount <= MAX_MOCK_NETWORK_REDIRECTS; redirectCount += 1) {
+        const pinnedTarget = await resolvePublicMockNetworkTarget(url, options.lookupHostname);
+        options.pinnedTargets.set(createPinnedNetworkTargetKey(url), pinnedTarget);
+        const response = await options.fetchImpl(url.toString(), {
+            body,
+            dispatcher: options.dispatcher,
+            headers: options.headers,
+            method,
+            redirect: 'manual',
+            signal: options.signal,
+        });
+        if (![301, 302, 303, 307, 308].includes(response.status)) {
+            return response;
+        }
+        const location = response.headers.get('location');
+        if (!location) {
+            return response;
+        }
+        if (redirectCount === MAX_MOCK_NETWORK_REDIRECTS) {
+            throw createMockHostError(502, 'TOO_MANY_REDIRECTS', 'network.request redirect limit exceeded');
+        }
+        await response.body?.cancel();
+        url = new URL(location, url);
+        if (response.status === 303 || ((response.status === 301 || response.status === 302) && method === 'POST')) {
+            method = 'GET';
+            body = undefined;
+        }
+    }
+    throw createMockHostError(502, 'TOO_MANY_REDIRECTS', 'network.request redirect limit exceeded');
+}
+async function resolvePublicMockNetworkTarget(url, lookupHostname) {
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        throw createMockHostError(403, 'NETWORK_TARGET_DENIED', 'network.request redirect 仅支持 HTTP(S) URL');
+    }
+    if (url.username || url.password) {
+        throw createMockHostError(403, 'NETWORK_TARGET_DENIED', 'network.request URL 不允许包含凭据');
+    }
+    const addressFamily = net.isIP(url.hostname);
+    const addresses = addressFamily ? [{ address: url.hostname, family: addressFamily }] : await lookupHostname(url.hostname);
+    if (!addresses.length || addresses.some(({ address, family }) => !isPublicIpAddress(address, family))) {
+        throw createMockHostError(403, 'NETWORK_TARGET_DENIED', 'network.request 不允许指向本机、内网或保留地址');
+    }
+    return addresses[0];
+}
+function createPinnedNetworkDispatcher(pinnedTargets) {
+    const connect = undici.buildConnector({});
+    return new undici.Agent({
+        connect(options, callback) {
+            const hostname = normalizeNetworkHostname(options.hostname);
+            const target = pinnedTargets.get(`${options.protocol}//${hostname}:${options.port || (options.protocol === 'https:' ? '443' : '80')}`);
+            if (!target) {
+                callback(new Error('network.request target was not DNS-pinned'), null);
+                return;
+            }
+            connect({
+                ...options,
+                hostname: target.address,
+                servername: options.servername || hostname,
+            }, callback);
+        },
+    });
+}
+function createPinnedNetworkTargetKey(url) {
+    return `${url.protocol}//${normalizeNetworkHostname(url.hostname)}:${url.port || (url.protocol === 'https:' ? '443' : '80')}`;
+}
+function normalizeNetworkHostname(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+}
+const blockedNetworkTargets = createBlockedNetworkTargets();
+const publicIpv6Targets = createPublicIpv6Targets();
+function createBlockedNetworkTargets() {
+    const blockList = new net.BlockList();
+    for (const [network, prefix] of [
+        ['0.0.0.0', 8],
+        ['10.0.0.0', 8],
+        ['100.64.0.0', 10],
+        ['127.0.0.0', 8],
+        ['169.254.0.0', 16],
+        ['172.16.0.0', 12],
+        ['192.0.0.0', 24],
+        ['192.0.2.0', 24],
+        ['192.168.0.0', 16],
+        ['198.18.0.0', 15],
+        ['198.51.100.0', 24],
+        ['203.0.113.0', 24],
+        ['224.0.0.0', 4],
+        ['240.0.0.0', 4],
+    ]) {
+        blockList.addSubnet(network, prefix, 'ipv4');
+    }
+    for (const [network, prefix] of [
+        ['::', 128],
+        ['::1', 128],
+        ['fc00::', 7],
+        ['fe80::', 10],
+        ['ff00::', 8],
+        ['2001:db8::', 32],
+        ['2001::', 23],
+        ['2002::', 16],
+        ['3ffe::', 16],
+    ]) {
+        blockList.addSubnet(network, prefix, 'ipv6');
+    }
+    return blockList;
+}
+function createPublicIpv6Targets() {
+    const blockList = new net.BlockList();
+    blockList.addSubnet('2000::', 3, 'ipv6');
+    return blockList;
+}
+function isPublicIpAddress(address, family) {
+    if (family === 4 || net.isIP(address) === 4) {
+        return !blockedNetworkTargets.check(address, 'ipv4');
+    }
+    if (family === 6 || net.isIP(address) === 6) {
+        if (address.toLowerCase().startsWith('::ffff:')) {
+            return false;
+        }
+        return publicIpv6Targets.check(address, 'ipv6') && !blockedNetworkTargets.check(address, 'ipv6');
+    }
+    return false;
+}
+async function readLimitedMockNetworkResponse(response) {
+    if (!response.body) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        size += value.byteLength;
+        if (size > MAX_MOCK_NETWORK_RESPONSE_BODY) {
+            await reader.cancel();
+            throw createMockHostError(502, 'NETWORK_RESPONSE_TOO_LARGE', 'network.request response body too large');
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8');
+}
+function createMockNetworkUrl(input, params) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        throw createMockHostError(400, 'INVALID_NETWORK_REQUEST', 'network.request url 必须是合法 URL');
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+        throw createMockHostError(400, 'INVALID_NETWORK_REQUEST', 'network.request 仅支持 HTTP(S) URL');
+    }
+    if (isRecord$1(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$1(headers)) {
+        return normalized;
+    }
+    Object.entries(headers).forEach(([key, value]) => {
+        if (isSensitiveMockNetworkHeader(key)) {
+            throw createMockHostError(400, 'INVALID_NETWORK_REQUEST', `network.request 不允许设置敏感请求头: ${key}`);
+        }
+        if (typeof value === 'string' && !isBlockedMockNetworkHeader(key)) {
+            normalized.set(key, value);
+        }
+    });
+    return normalized;
+}
+function isSensitiveMockNetworkHeader(key) {
+    return ['authorization', 'cookie', 'proxy-authorization'].includes(key.toLowerCase());
+}
+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;
+    }
+    const body = typeof data === 'string' ? data : JSON.stringify(data);
+    if (Buffer.byteLength(body) > MAX_MOCK_NETWORK_REQUEST_BODY) {
+        throw createMockHostError(413, 'REQUEST_ENTITY_TOO_LARGE', 'network.request data exceeds 2097152 bytes');
+    }
+    if (typeof data === 'string') {
+        return body;
+    }
+    if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/json');
+    }
+    return body;
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+
+const DEV_SESSION_TTL_MS = 5 * 60 * 1000;
+const MAX_ACTIVE_DEV_SESSIONS = 64;
+const MAX_EXPIRED_DEV_SESSION_TOMBSTONES = 128;
+function createDevSessionRoutes(options) {
+    const devSessions = new Map();
+    const expiredDevSessions = new Set();
+    let revision = 0;
+    return {
+        match(pathname) {
+            const match = pathname.match(/^\/__hb_sdk__\/dev-context\/([a-f0-9]{64})(\/network)?$/);
+            if (!match) {
+                return undefined;
+            }
+            return {
+                kind: match[2] ? 'network' : 'context',
+                token: match[1],
+            };
+        },
+        async create(request, response) {
+            if (!request.headers['content-type']?.toLowerCase().startsWith('application/json')) {
+                writeJsonResponse(response, 400, { code: 'INVALID_DEV_SESSION', message: 'Dev Session body must be JSON' });
+                return;
+            }
+            try {
+                const payload = await readJsonRequestBody(request);
+                const validated = validateDevSessionCreatePayload(payload, options.allowedMiniUrlOrigins);
+                reapExpiredDevSessions(devSessions, expiredDevSessions, options.now());
+                revokeDevSessionForOrigin(devSessions, validated.miniUrlOrigin);
+                if (devSessions.size >= MAX_ACTIVE_DEV_SESSIONS) {
+                    throw createMockHostError(429, 'DEV_SESSION_LIMIT_REACHED', 'active Dev Session limit reached');
+                }
+                const expiresAt = options.now() + DEV_SESSION_TTL_MS;
+                const token = createDevSessionToken(devSessions);
+                const snapshot = {
+                    schema_version: MINI_PROGRAM_DEV_SESSION_SCHEMA_VERSION,
+                    revision: ++revision,
+                    expires_at: expiresAt,
+                    mini_url_origin: validated.miniUrlOrigin,
+                    runtime_permissions: validated.runtimePermissions,
+                };
+                devSessions.set(token, {
+                    expiresAt,
+                    miniUrlOrigin: validated.miniUrlOrigin,
+                    networkRequestEnabled: validated.networkRequestEnabled,
+                    serialized: JSON.stringify(snapshot),
+                });
+                const result = { expires_at: expiresAt, token };
+                writeJsonResponse(response, 201, result);
+            }
+            catch (error) {
+                const status = readMockHostErrorStatus(error);
+                writeJsonResponse(response, status === 500 ? 400 : status, {
+                    code: 'INVALID_DEV_SESSION',
+                    message: readErrorMessage(error),
+                });
+            }
+        },
+        async handle(route, request, response) {
+            if (route.kind === 'network') {
+                await handleTokenNetworkProxy(request, response, route.token, {
+                    devSessions,
+                    expiredDevSessions,
+                    fetchImpl: options.fetchImpl,
+                    lookupHostname: options.lookupHostname,
+                    now: options.now,
+                });
+                return;
+            }
+            if (request.method !== 'OPTIONS' && request.method !== 'GET') {
+                response.writeHead(405, { allow: 'GET', 'cache-control': 'no-store' });
+                response.end();
+                return;
+            }
+            const resolved = resolveDevSession(route.token, devSessions, expiredDevSessions, options.now());
+            if (resolved.status !== 200) {
+                writeDevSessionCorsResponse(response, resolved.status);
+                return;
+            }
+            writeDevSessionCorsResponse(response, request.method === 'OPTIONS' ? 204 : 200, request.method === 'GET' ? resolved.session.serialized : undefined);
+        },
+    };
+}
+function validateDevSessionCreatePayload(payload, allowedMiniUrlOrigins) {
+    if (!isRecord$1(payload) || Object.keys(payload).some((key) => !['mini_url_origin', 'runtime_permissions'].includes(key))) {
+        throw new TypeError('Dev Session body is invalid');
+    }
+    if (typeof payload.mini_url_origin !== 'string') {
+        throw new TypeError('mini_url_origin is invalid');
+    }
+    let miniUrlOrigin;
+    try {
+        miniUrlOrigin = new URL(payload.mini_url_origin);
+    }
+    catch {
+        throw new TypeError('mini_url_origin is invalid');
+    }
+    if (miniUrlOrigin.protocol !== 'http:' ||
+        payload.mini_url_origin !== miniUrlOrigin.origin ||
+        !isPrivateLanIpv4(miniUrlOrigin.hostname) ||
+        !allowedMiniUrlOrigins.has(miniUrlOrigin.origin)) {
+        throw new TypeError('mini_url_origin must be an allowed LAN origin');
+    }
+    const parsedPermissions = parseMiniProgramRuntimePermissions(payload.runtime_permissions);
+    if (!parsedPermissions.valid) {
+        throw new TypeError('runtime_permissions is invalid');
+    }
+    const networkPermission = parsedPermissions.permissions['network.request'];
+    if (networkPermission?.config.useOfficialDomain !== false) {
+        throw new TypeError('Dev Session does not allow official domains');
+    }
+    return {
+        miniUrlOrigin: miniUrlOrigin.origin,
+        networkRequestEnabled: networkPermission.status === 'enabled',
+        runtimePermissions: JSON.parse(JSON.stringify(payload.runtime_permissions)),
+    };
+}
+async function handleTokenNetworkProxy(request, response, token, runtime) {
+    const resolved = resolveDevSession(token, runtime.devSessions, runtime.expiredDevSessions, runtime.now());
+    if (resolved.status !== 200) {
+        writeTokenNetworkJsonResponse(response, resolved.status, undefined);
+        return;
+    }
+    if (!resolved.session.networkRequestEnabled) {
+        writeTokenNetworkJsonResponse(response, 403, {
+            code: 'PERMISSION_DENIED',
+            message: 'network.request is disabled for this Dev Session',
+        });
+        return;
+    }
+    if (request.method === 'OPTIONS') {
+        writeTokenNetworkJsonResponse(response, 204, undefined);
+        return;
+    }
+    if (request.method !== 'POST') {
+        writeTokenNetworkJsonResponse(response, 405, {
+            code: 'METHOD_NOT_ALLOWED',
+            message: 'Dev Session network proxy only supports POST',
+        });
+        return;
+    }
+    await handleMockNetworkProxy(request, response, runtime.fetchImpl, runtime.lookupHostname, true);
+}
+function resolveDevSession(token, devSessions, expiredDevSessions, now) {
+    const session = devSessions.get(token);
+    if (!session) {
+        return { status: expiredDevSessions.has(token) ? 410 : 404 };
+    }
+    if (now >= session.expiresAt) {
+        devSessions.delete(token);
+        addExpiredDevSessionTombstone(expiredDevSessions, token);
+        return { status: 410 };
+    }
+    return { session, status: 200 };
+}
+function reapExpiredDevSessions(devSessions, expiredDevSessions, now) {
+    for (const [token, session] of devSessions) {
+        if (now >= session.expiresAt) {
+            devSessions.delete(token);
+            addExpiredDevSessionTombstone(expiredDevSessions, token);
+        }
+    }
+}
+function addExpiredDevSessionTombstone(expiredDevSessions, token) {
+    expiredDevSessions.add(token);
+    while (expiredDevSessions.size > MAX_EXPIRED_DEV_SESSION_TOMBSTONES) {
+        const oldest = expiredDevSessions.values().next().value;
+        if (!oldest) {
+            break;
+        }
+        expiredDevSessions.delete(oldest);
+    }
+}
+function revokeDevSessionForOrigin(devSessions, miniUrlOrigin) {
+    for (const [token, session] of devSessions) {
+        if (session.miniUrlOrigin === miniUrlOrigin) {
+            devSessions.delete(token);
+        }
+    }
+}
+function createDevSessionToken(devSessions) {
+    let token;
+    do {
+        token = node_crypto.randomBytes(32).toString('hex');
+    } while (devSessions.has(token));
+    return token;
+}
+function isPrivateLanIpv4(hostname) {
+    const octets = hostname.split('.').map(Number);
+    if (octets.length !== 4 || octets.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+        return false;
+    }
+    return octets[0] === 10 || (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) || (octets[0] === 192 && octets[1] === 168);
+}
+function writeDevSessionCorsResponse(response, status, serializedBody) {
+    response.writeHead(status, {
+        'access-control-allow-methods': 'GET',
+        'access-control-allow-origin': '*',
+        'access-control-allow-private-network': 'true',
+        'cache-control': 'no-store',
+        ...(serializedBody === undefined ? {} : { 'content-type': 'application/json; charset=utf-8' }),
+    });
+    response.end(serializedBody ?? '');
+}
+
+async function selectAvailablePort(options) {
+    const maxAttempts = options.maxAttempts ?? 20;
+    const port = await options.getPort({
+        host: options.host,
+        port: createPortCandidates(options.startPort, maxAttempts),
+    });
+    if (port < options.startPort || port >= options.startPort + maxAttempts) {
+        throw new Error(`无法找到可用 ${options.label} 端口，起始端口: ${options.startPort}`);
+    }
+    return port;
+}
+function createPortCandidates(startPort, count) {
+    return Array.from({ length: count }, (_, index) => startPort + index);
+}
+
+const MINI_PROGRAM_URL_QUERY_PARAM$1 = 'mini_url';
+const MOCK_HOST_BOOTSTRAP_PATH = '/__hb_sdk_bootstrap__';
+const MOCK_NETWORK_PROXY_PATH = '/__hb_sdk_mock_network__';
+const DEV_PERMISSIONS_PATH = '/__hb_sdk__/dev-permissions';
+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 bootstrapJson = serializeMockHostBootstrap({
+        defaultLanAddressId: options.defaultLanAddressId,
+        devContext: options.devContext,
+        lanAddresses: options.lanAddresses ?? [],
+        macAppProtocol: options.macAppProtocol,
+        nativeAppLaunchUnavailableReason: options.nativeAppLaunchUnavailableReason,
+        runtimePermissions: options.runtimePermissions,
+    });
+    const server = createMiniProgramMockHostServer(root, {
+        appUrl: options.appUrl,
+        allowedMiniUrlOrigins: new Set((options.lanAddresses ?? []).map(({ appUrl }) => new URL(appUrl).origin)),
+        bootstrapJson,
+        fetchImpl: options.fetchImpl ?? fetch,
+        isLoopbackPeer: options.isLoopbackPeer ?? isLoopbackAddress,
+        lookupHostname: options.lookupHostname ?? (async (hostname) => promises.lookup(hostname, { all: true, verbatim: true })),
+        now: options.now ?? Date.now,
+        permissionController: options.permissionController,
+    });
+    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: createMiniProgramMockHostUrlWithHost({
+            appUrl: options.appUrl,
+            host: LOCAL_DEV_URL_HOST$1,
+            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 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 serializeMockHostBootstrap(bootstrap) {
+    const serialized = JSON.stringify(bootstrap);
+    if (serialized === undefined) {
+        throw new TypeError('Mock host bootstrap must be JSON serializable');
+    }
+    const serializedBootstrap = JSON.parse(serialized);
+    if (bootstrap.runtimePermissions !== undefined && !Object.prototype.hasOwnProperty.call(serializedBootstrap, 'runtimePermissions')) {
+        throw new TypeError('Runtime permission snapshot must be JSON serializable');
+    }
+    return serialized;
+}
+function createMiniProgramMockHostServer(root, runtime) {
+    const devSessionRoutes = createDevSessionRoutes({
+        allowedMiniUrlOrigins: runtime.allowedMiniUrlOrigins,
+        fetchImpl: runtime.fetchImpl,
+        lookupHostname: runtime.lookupHostname,
+        now: runtime.now,
+    });
+    return node_http.createServer(async (request, response) => {
+        const requestUrl = new URL(request.url, 'http://localhost');
+        const pathname = decodeURIComponent(requestUrl.pathname);
+        const devSessionRoute = devSessionRoutes.match(pathname);
+        const loopbackPeer = runtime.isLoopbackPeer(request.socket.remoteAddress);
+        if (!loopbackPeer && !devSessionRoute) {
+            writeForbidden(response);
+            return;
+        }
+        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 === MOCK_HOST_BOOTSTRAP_PATH) {
+            if (!loopbackPeer || !hasNumericLoopbackHost(request)) {
+                writeForbidden(response);
+                return;
+            }
+            if (request.method !== 'GET') {
+                writeMethodNotAllowed(response, 'GET');
+                return;
+            }
+            writeSerializedJsonResponse(response, 200, runtime.bootstrapJson);
+            return;
+        }
+        if (pathname === DEV_PERMISSIONS_PATH && runtime.permissionController) {
+            if (!loopbackPeer || !hasNumericLoopbackHost(request)) {
+                writeForbidden(response);
+                return;
+            }
+            if (request.method === 'GET') {
+                writeJsonResponse(response, 200, await runtime.permissionController.get());
+                return;
+            }
+            if ((request.method !== 'PUT' && request.method !== 'DELETE') || !hasValidMutationOrigin(request)) {
+                if (request.method !== 'PUT' && request.method !== 'DELETE') {
+                    writeMethodNotAllowed(response, 'GET, PUT, DELETE');
+                }
+                else {
+                    writeForbidden(response);
+                }
+                return;
+            }
+            await handleDevPermissionMutation(request, response, runtime.permissionController);
+            return;
+        }
+        if (pathname === MINI_PROGRAM_DEV_CONTEXT_PATH) {
+            if (!loopbackPeer || !hasNumericLoopbackHost(request) || !hasValidMutationOrigin(request)) {
+                writeForbidden(response);
+                return;
+            }
+            if (request.method !== 'POST') {
+                writeMethodNotAllowed(response, 'POST');
+                return;
+            }
+            await devSessionRoutes.create(request, response);
+            return;
+        }
+        if (devSessionRoute) {
+            await devSessionRoutes.handle(devSessionRoute, request, response);
+            return;
+        }
+        if (pathname === MOCK_NETWORK_PROXY_PATH) {
+            if (!loopbackPeer || !hasNumericLoopbackHost(request) || !hasValidMutationOrigin(request)) {
+                writeForbidden(response);
+                return;
+            }
+            await handleMockNetworkProxy(request, response, runtime.fetchImpl, runtime.lookupHostname);
+            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');
+        }
+    });
+}
+async function handleDevPermissionMutation(request, response, controller) {
+    try {
+        if (request.method === 'DELETE') {
+            if (hasRequestBody(request)) {
+                if (!request.headers['content-type']?.toLowerCase().startsWith('application/json')) {
+                    throw createMockHostError(400, 'INVALID_DEV_PERMISSIONS', 'Dev permissions body must be JSON');
+                }
+                const payload = await readJsonRequestBody(request);
+                if (!isRecord$1(payload) || Object.keys(payload).length > 0) {
+                    throw createMockHostError(400, 'INVALID_DEV_PERMISSIONS', 'Dev permissions reset body is invalid');
+                }
+            }
+            writeJsonResponse(response, 200, await controller.reset());
+            return;
+        }
+        if (!request.headers['content-type']?.toLowerCase().startsWith('application/json')) {
+            throw createMockHostError(400, 'INVALID_DEV_PERMISSIONS', 'Dev permissions body must be JSON');
+        }
+        const payload = await readJsonRequestBody(request);
+        if (!isRecord$1(payload) || Object.keys(payload).length !== 1 || !Object.hasOwn(payload, 'runtime_permissions')) {
+            throw createMockHostError(400, 'INVALID_DEV_PERMISSIONS', 'Dev permissions update body is invalid');
+        }
+        const parsed = parseMiniProgramRuntimePermissions(payload.runtime_permissions);
+        if (!parsed.valid) {
+            throw createMockHostError(400, 'INVALID_DEV_PERMISSIONS', 'runtime_permissions is invalid');
+        }
+        const runtimePermissions = JSON.parse(JSON.stringify(payload.runtime_permissions));
+        writeJsonResponse(response, 200, await controller.save(runtimePermissions));
+    }
+    catch (error) {
+        const errorStatus = readMockHostErrorStatus(error);
+        const status = request.method === 'DELETE' && errorStatus === 500 ? 502 : errorStatus;
+        writeJsonResponse(response, status, {
+            code: request.method === 'DELETE' ? 'DEV_PERMISSIONS_RESET_FAILED' : 'DEV_PERMISSIONS_UPDATE_FAILED',
+            message: readErrorMessage(error),
+        });
+    }
+}
+function hasRequestBody(request) {
+    return request.headers['transfer-encoding'] !== undefined || Number(request.headers['content-length'] ?? 0) > 0;
+}
+function writeMethodNotAllowed(response, allowedMethod) {
+    response.writeHead(405, {
+        allow: allowedMethod,
+        'cache-control': 'no-store',
+    });
+    response.end();
+}
+function writeForbidden(response) {
+    response.writeHead(403, { 'cache-control': 'no-store' });
+    response.end();
+}
+function hasValidMutationOrigin(request) {
+    const origin = request.headers.origin;
+    const host = request.headers.host;
+    if (!host || !origin || origin === 'null') {
+        return false;
+    }
+    try {
+        return new URL(origin).origin === `http://${host}`;
+    }
+    catch {
+        return false;
+    }
+}
+function hasNumericLoopbackHost(request) {
+    const host = request.headers.host;
+    if (!host) {
+        return false;
+    }
+    try {
+        const hostname = new URL(`http://${host}`).hostname;
+        const normalized = hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+        return net.isIP(normalized) !== 0 && isLoopbackAddress(normalized);
+    }
+    catch {
+        return false;
+    }
+}
+function isLoopbackAddress(address) {
+    return address === '::1' || address === '127.0.0.1' || address?.startsWith('127.') === true || address?.startsWith('::ffff:127.') === true;
+}
+function isMockHostDocumentPath(pathname) {
+    return pathname === '/' || pathname === '/index.html';
+}
+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 port = await selectAvailablePort({
+        getPort: getPortImpl,
+        host: DEV_LISTEN_HOST$1,
+        label: 'mock host',
+        startPort: 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;
+}
+
+const MINI_PROGRAM_URL_QUERY_PARAM = 'mini_url';
+const MINI_PROGRAM_RUNTIME_URL_QUERY_PARAM = 'runtime_url';
+const MINI_PROGRAM_SDK_VERSION_QUERY_PARAM = 'sdk_version';
+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)
+        : createEncodedMiniProgramDevShellUrl(appUrl, options);
+    const miniProgramId = options.miniProgramId?.trim();
+    return {
+        protocol_type: 'openWindow',
+        full_screen: true,
+        mini_program: '1',
+        ...(miniProgramId ? { mini_program_id: miniProgramId } : {}),
+        navigation_bar: {
+            title: '',
+        },
+        webview: {
+            url: devShellUrl,
+            pull: false,
+            refresh: false,
+        },
+    };
+}
+function createPartiallyEncodedMiniProgramDevShellUrl(appUrl, options) {
+    let devShellUrl = `${MINI_PROGRAM_DEV_SHELL_URL}?${MINI_PROGRAM_URL_QUERY_PARAM}=${appUrl}`;
+    const miniProgramId = options.miniProgramId?.trim();
+    if (miniProgramId) {
+        devShellUrl += `&mini_program_id=${encodeURIComponent(miniProgramId)}`;
+    }
+    if (hasRuntimeUrl(options.runtimeUrl)) {
+        devShellUrl += `&${MINI_PROGRAM_RUNTIME_URL_QUERY_PARAM}=${encodeURIComponent(options.runtimeUrl)}`;
+    }
+    const sdkVersion = options.sdkVersion?.trim();
+    if (sdkVersion) {
+        devShellUrl += `&${MINI_PROGRAM_SDK_VERSION_QUERY_PARAM}=${encodeURIComponent(sdkVersion)}`;
+    }
+    return devShellUrl;
+}
+function createEncodedMiniProgramDevShellUrl(appUrl, options) {
+    const devShellUrl = new URL(MINI_PROGRAM_DEV_SHELL_URL);
+    devShellUrl.searchParams.set(MINI_PROGRAM_URL_QUERY_PARAM, appUrl);
+    const miniProgramId = options.miniProgramId?.trim();
+    if (miniProgramId) {
+        devShellUrl.searchParams.set('mini_program_id', miniProgramId);
+    }
+    if (hasRuntimeUrl(options.runtimeUrl)) {
+        devShellUrl.searchParams.set(MINI_PROGRAM_RUNTIME_URL_QUERY_PARAM, options.runtimeUrl);
+    }
+    const sdkVersion = options.sdkVersion?.trim();
+    if (sdkVersion) {
+        devShellUrl.searchParams.set(MINI_PROGRAM_SDK_VERSION_QUERY_PARAM, sdkVersion);
+    }
+    return devShellUrl.toString();
+}
+function hasRuntimeUrl(runtimeUrl) {
+    return runtimeUrl !== undefined && runtimeUrl !== '';
+}
+function createHeyboxProtocol(payload) {
+    return `heybox://${encodeURIComponent(JSON.stringify(payload))}`;
+}
+
+const DEFAULT_PERMISSION_STATE = {
+    networkRequest: {
+        status: 'disabled',
+        useOfficialDomain: false,
+    },
+};
+function createMiniProgramMockPermissionState(context) {
+    const parsed = parseMiniProgramRuntimePermissions(context.runtimePermissions);
+    const networkRequest = parsed.permissions['network.request'];
+    return parsed.valid && networkRequest
+        ? {
+            networkRequest: {
+                status: networkRequest.status,
+                useOfficialDomain: networkRequest.config.useOfficialDomain === true,
+            },
+        }
+        : cloneDefaultPermissionState();
+}
+function createMiniProgramMockRuntimePermissions(state) {
+    return {
+        schema_version: 1,
+        entries: [
+            {
+                key: 'network.request',
+                status: state.networkRequest.status,
+                config: {
+                    useOfficialDomain: state.networkRequest.useOfficialDomain,
+                },
+            },
+        ],
+    };
+}
+function cloneDefaultPermissionState() {
+    return {
+        networkRequest: { ...DEFAULT_PERMISSION_STATE.networkRequest },
+    };
+}
+
+/** 构建时替换为当前发布包的实际版本。 */
+const HB_SDK_VERSION = typeof undefined === 'string'
+    ? undefined
+    : '0.6.6-alpha.0';
+
+class DevPermissionOverrideStoreError extends Error {
+    code;
+    constructor(message, code, options = {}) {
+        super(message, { cause: options.cause });
+        this.code = code;
+        this.name = 'DevPermissionOverrideStoreError';
+    }
+}
+const CACHE_VERSION = 1;
+const CACHE_DIRECTORY_NAME = 'dev-permission-overrides';
+const defaultPaths = index.envPaths('hb-sdk', { suffix: '' });
+function createDevPermissionOverrideStore(options = {}) {
+    const cacheDirectory = path.join(options.cacheRoot ?? defaultPaths.cache, CACHE_DIRECTORY_NAME);
+    return {
+        async read(scope) {
+            return readScopeFile(await getScopeFile(cacheDirectory, scope));
+        },
+        async remove(scope) {
+            const scopeFile = await getScopeFile(cacheDirectory, scope);
+            try {
+                await fs$1.unlink(scopeFile);
+            }
+            catch (error) {
+                if (isNodeError(error) && error.code === 'ENOENT') {
+                    return;
+                }
+                throw createWriteError(error);
+            }
+        },
+        async set(scope, overrides) {
+            const scopeFile = await getScopeFile(cacheDirectory, scope);
+            try {
+                await fs$1.mkdir(cacheDirectory, { recursive: true, mode: 0o700 });
+                await fs$1.chmod(cacheDirectory, 0o700);
+                await readScopeFile(scopeFile);
+                await writeScopeFileAtomically(scopeFile, {
+                    version: CACHE_VERSION,
+                    overrides: cloneOverrides(overrides),
+                });
+            }
+            catch (error) {
+                if (error instanceof DevPermissionOverrideStoreError) {
+                    throw error;
+                }
+                throw createWriteError(error);
+            }
+        },
+    };
+}
+async function getScopeFile(cacheDirectory, scope) {
+    const projectRoot = await fs$1.realpath(scope.projectRoot);
+    const miniProgramId = scope.miniProgramId ?? 'anonymous';
+    const scopeHash = node_crypto.createHash('sha256').update(`${projectRoot}\0${miniProgramId}`).digest('hex');
+    return path.join(cacheDirectory, `${scopeHash}.json`);
+}
+async function readScopeFile(scopeFile) {
+    let contents;
+    try {
+        contents = await fs$1.readFile(scopeFile, 'utf8');
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(contents);
+        if (!isPersistedOverride(parsed)) {
+            throw new TypeError('invalid cache schema');
+        }
+        return cloneOverrides(parsed.overrides);
+    }
+    catch (error) {
+        throw new DevPermissionOverrideStoreError('hb-sdk 本地权限覆盖缓存已损坏', 'DEV_PERMISSION_OVERRIDE_CACHE_CORRUPT', {
+            cause: error,
+        });
+    }
+}
+async function writeScopeFileAtomically(scopeFile, value) {
+    const tempFile = `${scopeFile}.${process.pid}.${node_crypto.randomBytes(8).toString('hex')}.tmp`;
+    let handle;
+    try {
+        handle = await fs$1.open(tempFile, 'wx', 0o600);
+        await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await fs$1.rename(tempFile, scopeFile);
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await fs$1.unlink(tempFile).catch(() => undefined);
+    }
+}
+function createWriteError(cause) {
+    return new DevPermissionOverrideStoreError('无法写入 hb-sdk 本地权限覆盖缓存', 'DEV_PERMISSION_OVERRIDE_WRITE_FAILED', { cause });
+}
+function cloneOverrides(overrides) {
+    return {
+        networkRequest: { ...overrides.networkRequest },
+    };
+}
+function isPersistedOverride(value) {
+    return isRecord(value) && value.version === CACHE_VERSION && Object.keys(value).length === 2 && isPermissionState(value.overrides);
+}
+function isPermissionState(value) {
+    return (isRecord(value) &&
+        Object.keys(value).length === 1 &&
+        isRecord(value.networkRequest) &&
+        (value.networkRequest.status === 'enabled' || value.networkRequest.status === 'disabled') &&
+        typeof value.networkRequest.useOfficialDomain === 'boolean');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+
+const DEFAULT_APP_PORT = 5173;
+const DEFAULT_MOCK_PORT = 5174;
+const DEFAULT_DEV_CONTEXT_TIMEOUT_MS = 3000;
+const DEV_LISTEN_HOST = '0.0.0.0';
+const LOCAL_DEV_URL_HOST = '127.0.0.1';
+const DEV_CONTEXT_UNAVAILABLE_WARNING = '远端 dev context 不可用，已继续匿名调试。';
+// 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 networkInterfaceSnapshot = (runtime.networkInterfaces ?? os.networkInterfaces)();
+    const getPortImpl = runtime.getPort ?? getPorts;
+    const appPort = await selectAvailablePort({
+        getPort: getPortImpl,
+        host: DEV_LISTEN_HOST,
+        label: 'Vite dev server',
+        startPort: options.port ?? DEFAULT_APP_PORT,
+    });
+    const resolvedOptions = {
+        ...options,
+        hmrHost: createLanInterfaceCandidates(networkInterfaceSnapshot)[0]?.address,
+        port: appPort,
+    };
+    const projectRoot = findProjectRoot(runtime.cwd ?? process.cwd());
+    const devLaunchContext = await loadDevLaunchContext({
+        env: runtime.env,
+        fetchImpl,
+        logger,
+        projectRoot,
+        timeoutMs: runtime.devContextTimeoutMs ?? DEFAULT_DEV_CONTEXT_TIMEOUT_MS,
+    });
+    const permissionController = createDevPermissionController({
+        boundMiniProgramId: await context.readBoundMiniProgramId(projectRoot),
+        cacheRoot: runtime.devPermissionCacheRoot,
+        devContext: devLaunchContext,
+        loadRemoteContext: () => loadDevLaunchContext({
+            env: runtime.env,
+            fetchImpl,
+            logger,
+            projectRoot,
+            requireRemote: true,
+            timeoutMs: runtime.devContextTimeoutMs ?? DEFAULT_DEV_CONTEXT_TIMEOUT_MS,
+        }),
+        projectRoot,
+    });
+    const vite = await logger.task('正在加载项目 Vite', () => loadProjectVite(projectRoot), { successText: '已加载项目 Vite' });
+    const appServer = await logger.task('正在创建 Vite dev server', () => withManagedDevOutputEnv(() => vite.createServer(createViteServerOptions(projectRoot, resolvedOptions)), runtime.env), { successText: '已创建 Vite dev server' });
+    await logger.task('正在启动 Vite dev server', () => appServer.listen(appPort), {
+        successText: 'Vite dev server 已启动',
+    });
+    const appUrl = await logger.task('正在探测小程序入口', () => resolveViteAppUrl(appServer, resolvedOptions, fetchImpl), {
+        successText: '已确定小程序入口',
+    });
+    const lanAddresses = createLanAddressCandidates({
+        appUrl,
+        hmrHost: resolvedOptions.hmrHost,
+        interfaces: networkInterfaceSnapshot,
+        miniProgramId: devLaunchContext.miniProgramId,
+        runtimeUrl: options.runtimeUrl,
+        sdkVersion: HB_SDK_VERSION,
+        viteNetworkUrls: appServer.resolvedUrls?.network ?? [],
+    });
+    const closers = [() => appServer.close()];
+    let mockHost;
+    try {
+        mockHost = await logger.task('正在启动 Mock runtime host', () => startMiniProgramMockHostServer({
+            appUrl,
+            devContext: devLaunchContext,
+            fetchImpl,
+            getPort: getPortImpl,
+            defaultLanAddressId: lanAddresses[0]?.id,
+            lanAddresses,
+            lookupHostname: runtime.lookupHostname,
+            macAppProtocol: createMacAppProtocol(appUrl, {
+                miniProgramId: devLaunchContext.miniProgramId,
+                runtimeUrl: options.runtimeUrl,
+                sdkVersion: HB_SDK_VERSION,
+            }),
+            permissionController,
+            port: options.mockPort ?? DEFAULT_MOCK_PORT,
+            root: runtime.mockHostRoot,
+            rootCandidates: runtime.mockHostRootCandidates,
+            runtimePermissions: devLaunchContext.runtimePermissions,
+        }), { 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 (devLaunchContext.source === 'anonymous') {
+        logger.warn('当前使用匿名本地沙箱；真机调试可用，但不会携带远端小程序身份或权限。');
+    }
+    if (options.open !== false) {
+        logger.debug('正在打开浏览器调试页');
+        void openUrl(mockHost.url);
+    }
+    installShutdownHandlers(closers, runtime.process ?? process);
+}
+async function loadDevLaunchContext(options) {
+    const miniProgramId = await context.readBoundMiniProgramId(options.projectRoot);
+    if (!miniProgramId) {
+        const anonymousReason = '当前项目未绑定小程序。请先运行 hb-sdk remote create 或 hb-sdk remote bind <mini-program-id>。';
+        if (options.requireRemote) {
+            throw new Error(anonymousReason);
+        }
+        options.logger.warn(`未读取到远端 Runtime 权限，Mock runtime 将默认拒绝受管能力：${anonymousReason}`);
+        return {
+            source: 'anonymous',
+            warning: anonymousReason,
+        };
+    }
+    try {
+        const { detail, miniProgramId: verifiedMiniProgramId } = await options.logger.task('正在读取远端小程序权限', () => loadRemoteDevContextWithTimeout({
+            fetchImpl: options.fetchImpl,
+            load: (fetchImpl) => context.getBoundMiniProgram({
+                cwd: options.projectRoot,
+                env: options.env,
+                fetchImpl,
+            }),
+            timeoutMs: options.timeoutMs,
+        }), { successText: '已读取远端小程序权限' });
+        return {
+            source: 'remote',
+            miniProgramId: verifiedMiniProgramId,
+            runtimePermissions: detail.runtime_permissions,
+        };
+    }
+    catch (error) {
+        if (error instanceof context.MiniProgramProjectBindingError && error.code !== 'MINI_PROGRAM_UNBOUND') {
+            throw error;
+        }
+        if (options.requireRemote) {
+            throw error;
+        }
+        options.logger.debug(`远端 dev context 失败详情：${index.readRedactedErrorMessage(error, { verbose: true })}`);
+        options.logger.warn(`未读取到远端 Runtime 权限，Mock runtime 将默认拒绝受管能力：${DEV_CONTEXT_UNAVAILABLE_WARNING}`);
+        return {
+            source: 'anonymous',
+            warning: DEV_CONTEXT_UNAVAILABLE_WARNING,
+        };
+    }
+}
+function createDevPermissionController(options) {
+    const store = createDevPermissionOverrideStore({ cacheRoot: options.cacheRoot });
+    let devContext = options.devContext;
+    let ephemeralOverride;
+    let persistenceError;
+    const readScope = () => ({
+        projectRoot: options.projectRoot,
+        ...(options.boundMiniProgramId ? { miniProgramId: options.boundMiniProgramId } : {}),
+    });
+    const createConfiguration = (overrides, error = persistenceError) => {
+        const miniProgramId = options.boundMiniProgramId ?? devContext.miniProgramId;
+        return {
+            source: devContext.source,
+            ...(miniProgramId ? { mini_program_id: miniProgramId } : {}),
+            ...(isRuntimePermissionsSnapshot(devContext.runtimePermissions) ? { remote_permissions: devContext.runtimePermissions } : {}),
+            ...(overrides ? { override_permissions: createMiniProgramMockRuntimePermissions(overrides) } : {}),
+            ...(error ? { persistence_error: error } : {}),
+        };
+    };
+    const get = async () => {
+        try {
+            const persistedOverride = await store.read(readScope());
+            return createConfiguration(ephemeralOverride ?? persistedOverride);
+        }
+        catch (error) {
+            persistenceError = index.readErrorMessage(error);
+            return createConfiguration(ephemeralOverride, persistenceError);
+        }
+    };
+    return {
+        get,
+        async reset() {
+            if (devContext.source === 'anonymous' && !options.boundMiniProgramId) {
+                await store.remove(readScope());
+                ephemeralOverride = undefined;
+                persistenceError = undefined;
+                return createConfiguration(undefined);
+            }
+            let refreshedContext;
+            try {
+                refreshedContext = await options.loadRemoteContext();
+            }
+            catch (error) {
+                throw new Error('远端权限读取失败，请检查 CLI 登录状态和网络后重试。', { cause: error });
+            }
+            await store.remove(readScope());
+            devContext = refreshedContext;
+            ephemeralOverride = undefined;
+            persistenceError = undefined;
+            return createConfiguration(undefined);
+        },
+        async save(runtimePermissions) {
+            const overrides = createMiniProgramMockPermissionState({
+                runtimePermissions,
+            });
+            try {
+                await store.set(readScope(), overrides);
+                ephemeralOverride = undefined;
+                persistenceError = undefined;
+                return createConfiguration(overrides);
+            }
+            catch {
+                ephemeralOverride = overrides;
+                persistenceError = '保存失败，当前页面仍会应用该权限，但刷新或重启后会丢失。';
+                return createConfiguration(overrides, persistenceError);
+            }
+        },
+    };
+}
+function isRuntimePermissionsSnapshot(value) {
+    return parseMiniProgramRuntimePermissions(value).valid;
+}
+async function loadRemoteDevContextWithTimeout(options) {
+    const controller = new AbortController();
+    const fetchImpl = ((input, init) => options.fetchImpl(input, { ...init, signal: controller.signal }));
+    let timeout;
+    try {
+        return await Promise.race([
+            options.load(fetchImpl),
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error('dev context timeout'));
+                }, Math.max(1, options.timeoutMs));
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
+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,
+        hmr: {
+            clientPort: options.port ?? DEFAULT_APP_PORT,
+            ...(options.hmrHost ? { host: options.hmrHost } : {}),
+        },
+        host: DEV_LISTEN_HOST,
+        port: options.port ?? DEFAULT_APP_PORT,
+        strictPort: true,
+    };
+    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 = createLanInterfaceCandidates(options.interfaces)
+        .filter(({ address }) => address === options.hmrHost)
+        .map(({ address, id, name }) => {
+        const appUrl = viteNetworkUrlByHost.get(address) ?? replaceUrlHost(options.appUrl, address);
+        if (!appUrl) {
+            return undefined;
+        }
+        const candidate = {
+            address,
+            appUrl,
+            id,
+            name,
+        };
+        const runtimeUrl = rewriteLoopbackUrlHost(options.runtimeUrl, address);
+        if (runtimeUrl !== undefined) {
+            candidate.mobileAppQrPayload = createMobileAppQrPayload(appUrl, {
+                miniProgramId: options.miniProgramId,
+                runtimeUrl,
+                sdkVersion: options.sdkVersion,
+            });
+        }
+        else {
+            candidate.mobileAppQrPayload = createMobileAppQrPayload(appUrl, {
+                miniProgramId: options.miniProgramId,
+                sdkVersion: options.sdkVersion,
+            });
+        }
+        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 createLanInterfaceCandidates(interfaces) {
+    return Object.entries(interfaces)
+        .flatMap(([name, infos]) => (infos ?? []).map((info) => ({
+        info,
+        name,
+    })))
+        .filter(({ info }) => info.family === 'IPv4' && !info.internal && isPrivateIPv4(info.address))
+        .map(({ info, name }) => ({
+        address: info.address,
+        id: `${name}-${info.address}`,
+        name,
+    }))
+        .sort((left, right) => {
+        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;