vibelet 1.2.197 → 1.2.199

package/dist/vibelet.mjs

@@ -11263,6 +11263,13 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs");
 
 /***/ }),
 
+/***/ 1455:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs/promises");
+
+/***/ }),
+
 /***/ 8995:
 /***/ ((module) => {
 
@@ -11291,6 +11298,13 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:url");
 
 /***/ }),
 
+/***/ 7975:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:util");
+
+/***/ }),
+
 /***/ 2203:
 /***/ ((module) => {
 
@@ -11326,7 +11340,7 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("zlib");
 
 /***/ }),
 
-/***/ 2755:
+/***/ 6895:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
 
 
@@ -11348,10 +11362,10 @@ var external_node_fs_ = __nccwpck_require__(3024);
 var external_node_module_ = __nccwpck_require__(8995);
 // EXTERNAL MODULE: external "node:path"
 var external_node_path_ = __nccwpck_require__(6760);
-;// CONCATENATED MODULE: external "node:fs/promises"
-const promises_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs/promises");
-;// CONCATENATED MODULE: external "node:util"
-const external_node_util_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:util");
+// EXTERNAL MODULE: external "node:fs/promises"
+var promises_ = __nccwpck_require__(1455);
+// EXTERNAL MODULE: external "node:util"
+var external_node_util_ = __nccwpck_require__(7975);
 ;// CONCATENATED MODULE: ../../packages/cloudflared-tunnel/managed-binary.mjs
 
 
@@ -11359,7 +11373,7 @@ const external_node_util_namespaceObject = __WEBPACK_EXTERNAL_createRequire(impo
 
 
 
-const execFileAsync = (0,external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
+const execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
 const DEFAULT_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_UPDATE_TIMEOUT_MS = 30_000;
 
@@ -11369,7 +11383,7 @@ function parseCloudflaredVersion(output) {
 
 async function readUpdateState(updateStatePath) {
   try {
-    const state = JSON.parse(await (0,promises_namespaceObject.readFile)(updateStatePath, 'utf8'));
+    const state = JSON.parse(await (0,promises_.readFile)(updateStatePath, 'utf8'));
     return state && typeof state === 'object' ? state : null;
   } catch {
     return null;
@@ -11377,10 +11391,10 @@ async function readUpdateState(updateStatePath) {
 }
 
 async function writeUpdateState(updateStatePath, state) {
-  await (0,promises_namespaceObject.mkdir)((0,external_node_path_.dirname)(updateStatePath), { recursive: true });
+  await (0,promises_.mkdir)((0,external_node_path_.dirname)(updateStatePath), { recursive: true });
   const temporaryPath = `${updateStatePath}.tmp-${process.pid}-${Date.now()}`;
-  await (0,promises_namespaceObject.writeFile)(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
-  await (0,promises_namespaceObject.rename)(temporaryPath, updateStatePath);
+  await (0,promises_.writeFile)(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  await (0,promises_.rename)(temporaryPath, updateStatePath);
 }
 
 async function runVersion(binaryPath, timeoutMs, runCommand) {
@@ -11417,7 +11431,7 @@ async function probeCloudflaredLaunchSpecVersion(
 async function installLatestToTemporaryPath({ launchSpec, binaryPath, timeoutMs, platform, runCommand }) {
   const temporaryDir = (0,external_node_path_.join)((0,external_node_path_.dirname)(binaryPath), `.cloudflared-update-${process.pid}-${Date.now()}`);
   const temporaryBinaryPath = (0,external_node_path_.join)(temporaryDir, (0,external_node_path_.basename)(binaryPath));
-  await (0,promises_namespaceObject.mkdir)(temporaryDir, { recursive: true });
+  await (0,promises_.mkdir)(temporaryDir, { recursive: true });
   try {
     await runCommand(launchSpec.command, [...launchSpec.args, 'bin', 'install', 'latest'], {
       encoding: 'utf8',
@@ -11431,20 +11445,20 @@ async function installLatestToTemporaryPath({ launchSpec, binaryPath, timeoutMs,
 
     if (platform === 'win32' && (0,external_node_fs_.existsSync)(binaryPath)) {
       const backupPath = `${binaryPath}.previous-${process.pid}`;
-      await (0,promises_namespaceObject.rename)(binaryPath, backupPath);
+      await (0,promises_.rename)(binaryPath, backupPath);
       try {
-        await (0,promises_namespaceObject.rename)(temporaryBinaryPath, binaryPath);
-        await (0,promises_namespaceObject.rm)(backupPath, { force: true });
+        await (0,promises_.rename)(temporaryBinaryPath, binaryPath);
+        await (0,promises_.rm)(backupPath, { force: true });
       } catch (error) {
-        await (0,promises_namespaceObject.rename)(backupPath, binaryPath).catch(() => undefined);
+        await (0,promises_.rename)(backupPath, binaryPath).catch(() => undefined);
         throw error;
       }
     } else {
-      await (0,promises_namespaceObject.rename)(temporaryBinaryPath, binaryPath);
+      await (0,promises_.rename)(temporaryBinaryPath, binaryPath);
     }
     return version;
   } finally {
-    await (0,promises_namespaceObject.rm)(temporaryDir, { recursive: true, force: true });
+    await (0,promises_.rm)(temporaryDir, { recursive: true, force: true });
   }
 }
 
@@ -14027,7 +14041,7 @@ function parseAccessTargetArg(argv, fail, env = process.env) {
 /* harmony export */ });
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(3024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(6760);
-/* harmony import */ var _cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(2755);
+/* harmony import */ var _cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(6895);
 
 
 
@@ -14607,7 +14621,6 @@ function createScannablePairingPayload(pairingPayload) {
   const compactPayload = {
     t: 'vp',
     d: pairingPayload.daemonId,
-    n: pairingPayload.displayName,
     h: pairingPayload.canonicalHost,
     p: pairingPayload.port,
     c: pairingPayload.pairNonce,
@@ -14722,38 +14735,964 @@ function buildWebUiUrl(target, pairingPayload) {
 
 /***/ }),
 
-/***/ 4021:
+/***/ 9485:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
 
-/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
-/* harmony export */   p: () => (/* binding */ writePairingOutput)
-/* harmony export */ });
-/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(3024);
-/* harmony import */ var qrcode__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(7514);
-/* harmony import */ var _vibelet_pairing_connections_mjs__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(7721);
 
+// EXPORTS
+__nccwpck_require__.d(__webpack_exports__, {
+  pO: () => (/* binding */ writePairingOutput)
+});
+
+// UNUSED EXPORTS: detectTerminalImageProtocol, presentPairingQr, renderSixelQr, renderTerminalQr, tryOpenPairingImage, tryWriteTerminalQrImage
+
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __nccwpck_require__(3024);
+;// CONCATENATED MODULE: external "node:process"
+const external_node_process_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:process");
+;// CONCATENATED MODULE: external "node:buffer"
+const external_node_buffer_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:buffer");
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __nccwpck_require__(6760);
+// EXTERNAL MODULE: external "node:url"
+var external_node_url_ = __nccwpck_require__(3136);
+// EXTERNAL MODULE: external "node:util"
+var external_node_util_ = __nccwpck_require__(7975);
+// EXTERNAL MODULE: external "node:child_process"
+var external_node_child_process_ = __nccwpck_require__(1421);
+// EXTERNAL MODULE: external "node:fs/promises"
+var promises_ = __nccwpck_require__(1455);
+// EXTERNAL MODULE: external "node:os"
+var external_node_os_ = __nccwpck_require__(8161);
+;// CONCATENATED MODULE: ../../node_modules/is-inside-container/node_modules/is-docker/index.js
+
+
+let isDockerCached;
+
+function hasDockerEnv() {
+	try {
+		external_node_fs_.statSync('/.dockerenv');
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function hasDockerCGroup() {
+	try {
+		return external_node_fs_.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+	} catch {
+		return false;
+	}
+}
+
+function isDocker() {
+	// TODO: Use `??=` when targeting Node.js 16.
+	if (isDockerCached === undefined) {
+		isDockerCached = hasDockerEnv() || hasDockerCGroup();
+	}
+
+	return isDockerCached;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/is-inside-container/index.js
+
+
+
+let cachedResult;
+
+// Podman detection
+const hasContainerEnv = () => {
+	try {
+		external_node_fs_.statSync('/run/.containerenv');
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+function isInsideContainer() {
+	// TODO: Use `??=` when targeting Node.js 16.
+	if (cachedResult === undefined) {
+		cachedResult = hasContainerEnv() || isDocker();
+	}
+
+	return cachedResult;
+}
+
+;// CONCATENATED MODULE: ./node_modules/is-wsl/index.js
+
+
+
+
+
+const isWsl = () => {
+	if (external_node_process_namespaceObject.platform !== 'linux') {
+		return false;
+	}
+
+	if (external_node_os_.release().toLowerCase().includes('microsoft')) {
+		if (isInsideContainer()) {
+			return false;
+		}
+
+		return true;
+	}
+
+	try {
+		if (external_node_fs_.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft')) {
+			return !isInsideContainer();
+		}
+	} catch {}
+
+	// Fallback for custom kernels: check WSL-specific paths.
+	if (
+		external_node_fs_.existsSync('/proc/sys/fs/binfmt_misc/WSLInterop')
+		|| external_node_fs_.existsSync('/run/WSL')
+	) {
+		return !isInsideContainer();
+	}
+
+	return false;
+};
+
+/* harmony default export */ const is_wsl = (external_node_process_namespaceObject.env.__IS_WSL_TEST__ ? isWsl : isWsl());
+
+;// CONCATENATED MODULE: ./node_modules/wsl-utils/index.js
+
+
+
+
+const wslDrivesMountPoint = (() => {
+	// Default value for "root" param
+	// according to https://docs.microsoft.com/en-us/windows/wsl/wsl-config
+	const defaultMountPoint = '/mnt/';
+
+	let mountPoint;
+
+	return async function () {
+		if (mountPoint) {
+			// Return memoized mount point value
+			return mountPoint;
+		}
+
+		const configFilePath = '/etc/wsl.conf';
+
+		let isConfigFileExists = false;
+		try {
+			await promises_.access(configFilePath, promises_.constants.F_OK);
+			isConfigFileExists = true;
+		} catch {}
+
+		if (!isConfigFileExists) {
+			return defaultMountPoint;
+		}
+
+		const configContent = await promises_.readFile(configFilePath, {encoding: 'utf8'});
+		const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+
+		if (!configMountPoint) {
+			return defaultMountPoint;
+		}
+
+		mountPoint = configMountPoint.groups.mountPoint.trim();
+		mountPoint = mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`;
+
+		return mountPoint;
+	};
+})();
+
+const powerShellPathFromWsl = async () => {
+	const mountPoint = await wslDrivesMountPoint();
+	return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+
+const powerShellPath = async () => {
+	if (is_wsl) {
+		return powerShellPathFromWsl();
+	}
+
+	return `${external_node_process_namespaceObject.env.SYSTEMROOT || external_node_process_namespaceObject.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+};
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+	const define = value => Object.defineProperty(object, propertyName, {value, enumerable: true, writable: true});
+
+	Object.defineProperty(object, propertyName, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const result = valueGetter();
+			define(result);
+			return result;
+		},
+		set(value) {
+			define(value);
+		}
+	});
+
+	return object;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/default-browser-id/index.js
+
+
+
+
+const execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
+
+async function defaultBrowserId() {
+	if (external_node_process_namespaceObject.platform !== 'darwin') {
+		throw new Error('macOS only');
+	}
+
+	const {stdout} = await execFileAsync('defaults', ['read', 'com.apple.LaunchServices/com.apple.launchservices.secure', 'LSHandlers']);
+
+	// `(?!-)` is to prevent matching `LSHandlerRoleAll = "-";`.
+	const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+
+	const browserId = match?.groups.id ?? 'com.apple.Safari';
+
+	// Correct the case for Safari's bundle identifier
+	if (browserId === 'com.apple.safari') {
+		return 'com.apple.Safari';
+	}
+
+	return browserId;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/run-applescript/index.js
+
+
+
+
+const run_applescript_execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
+
+async function runAppleScript(script, {humanReadableOutput = true, signal} = {}) {
+	if (external_node_process_namespaceObject.platform !== 'darwin') {
+		throw new Error('macOS only');
+	}
+
+	const outputArguments = humanReadableOutput ? [] : ['-ss'];
+
+	const execOptions = {};
+	if (signal) {
+		execOptions.signal = signal;
+	}
+
+	const {stdout} = await run_applescript_execFileAsync('osascript', ['-e', script, outputArguments], execOptions);
+	return stdout.trim();
+}
+
+function runAppleScriptSync(script, {humanReadableOutput = true} = {}) {
+	if (process.platform !== 'darwin') {
+		throw new Error('macOS only');
+	}
+
+	const outputArguments = humanReadableOutput ? [] : ['-ss'];
+
+	const stdout = execFileSync('osascript', ['-e', script, ...outputArguments], {
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'ignore'],
+		timeout: 500,
+	});
+
+	return stdout.trim();
+}
+
+;// CONCATENATED MODULE: ../../node_modules/bundle-name/index.js
+
+
+async function bundleName(bundleId) {
+	return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/default-browser/windows.js
+
+
+
+const windows_execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
+
+// TODO: Fix the casing of bundle identifiers in the next major version.
+
+// Windows doesn't have browser IDs in the same way macOS/Linux does so we give fake
+// ones that look real and match the macOS/Linux versions for cross-platform apps.
+const windowsBrowserProgIds = {
+	MSEdgeHTM: {name: 'Edge', id: 'com.microsoft.edge'}, // The missing `L` is correct.
+	MSEdgeBHTML: {name: 'Edge Beta', id: 'com.microsoft.edge.beta'},
+	MSEdgeDHTML: {name: 'Edge Dev', id: 'com.microsoft.edge.dev'},
+	AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {name: 'Edge', id: 'com.microsoft.edge.old'},
+	ChromeHTML: {name: 'Chrome', id: 'com.google.chrome'},
+	ChromeBHTML: {name: 'Chrome Beta', id: 'com.google.chrome.beta'},
+	ChromeDHTML: {name: 'Chrome Dev', id: 'com.google.chrome.dev'},
+	ChromiumHTM: {name: 'Chromium', id: 'org.chromium.Chromium'},
+	BraveHTML: {name: 'Brave', id: 'com.brave.Browser'},
+	BraveBHTML: {name: 'Brave Beta', id: 'com.brave.Browser.beta'},
+	BraveDHTML: {name: 'Brave Dev', id: 'com.brave.Browser.dev'},
+	BraveSSHTM: {name: 'Brave Nightly', id: 'com.brave.Browser.nightly'},
+	FirefoxURL: {name: 'Firefox', id: 'org.mozilla.firefox'},
+	OperaStable: {name: 'Opera', id: 'com.operasoftware.Opera'},
+	VivaldiHTM: {name: 'Vivaldi', id: 'com.vivaldi.Vivaldi'},
+	'IE.HTTP': {name: 'Internet Explorer', id: 'com.microsoft.ie'},
+};
+
+const _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+
+class UnknownBrowserError extends Error {}
+
+async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
+	const {stdout} = await _execFileAsync('reg', [
+		'QUERY',
+		' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
+		'/v',
+		'ProgId',
+	]);
+
+	const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+	if (!match) {
+		throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+	}
 
+	const {id} = match.groups;
 
+	// Windows can append a hash suffix to ProgIds using a dot or hyphen
+	// (e.g., `ChromeHTML.ABC123`, `FirefoxURL-6F193CCC56814779`).
+	// Try exact match first, then try without the suffix.
+	const dotIndex = id.lastIndexOf('.');
+	const hyphenIndex = id.lastIndexOf('-');
+	const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+	const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+
+	return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? {name: id, id};
+}
+
+;// CONCATENATED MODULE: ../../node_modules/default-browser/index.js
+
+
+
+
+
+
+
+
+
+const default_browser_execFileAsync = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
+
+// Inlined: https://github.com/sindresorhus/titleize/blob/main/index.js
+const titleize = string => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, x => x.toUpperCase());
+
+async function default_browser_defaultBrowser() {
+	if (external_node_process_namespaceObject.platform === 'darwin') {
+		const id = await defaultBrowserId();
+		const name = await bundleName(id);
+		return {name, id};
+	}
+
+	if (external_node_process_namespaceObject.platform === 'linux') {
+		const {stdout} = await default_browser_execFileAsync('xdg-mime', ['query', 'default', 'x-scheme-handler/http']);
+		const id = stdout.trim();
+		const name = titleize(id.replace(/.desktop$/, '').replace('-', ' '));
+		return {name, id};
+	}
+
+	if (external_node_process_namespaceObject.platform === 'win32') {
+		return defaultBrowser();
+	}
+
+	throw new Error('Only macOS, Linux, and Windows are supported');
+}
+
+;// CONCATENATED MODULE: ./node_modules/open/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+const execFile = (0,external_node_util_.promisify)(external_node_child_process_.execFile);
+
+// Path to included `xdg-open`.
+const open_dirname = external_node_path_.dirname((0,external_node_url_.fileURLToPath)(import.meta.url));
+const localXdgOpenPath = external_node_path_.join(open_dirname, 'xdg-open');
+
+const {platform, arch} = external_node_process_namespaceObject;
+
+/**
+Get the default browser name in Windows from WSL.
+
+@returns {Promise<string>} Browser name.
+*/
+async function getWindowsDefaultBrowserFromWsl() {
+	const powershellPath = await powerShellPath();
+	const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+	const encodedCommand = external_node_buffer_namespaceObject.Buffer.from(rawCommand, 'utf16le').toString('base64');
+
+	const {stdout} = await execFile(
+		powershellPath,
+		[
+			'-NoProfile',
+			'-NonInteractive',
+			'-ExecutionPolicy',
+			'Bypass',
+			'-EncodedCommand',
+			encodedCommand,
+		],
+		{encoding: 'utf8'},
+	);
+
+	const progId = stdout.trim();
+
+	// Map ProgId to browser IDs
+	const browserMap = {
+		ChromeHTML: 'com.google.chrome',
+		BraveHTML: 'com.brave.Browser',
+		MSEdgeHTM: 'com.microsoft.edge',
+		FirefoxURL: 'org.mozilla.firefox',
+	};
+
+	return browserMap[progId] ? {id: browserMap[progId]} : {};
+}
+
+const pTryEach = async (array, mapper) => {
+	let latestError;
+
+	for (const item of array) {
+		try {
+			return await mapper(item); // eslint-disable-line no-await-in-loop
+		} catch (error) {
+			latestError = error;
+		}
+	}
+
+	throw latestError;
+};
+
+// eslint-disable-next-line complexity
+const baseOpen = async options => {
+	options = {
+		wait: false,
+		background: false,
+		newInstance: false,
+		allowNonzeroExitCode: false,
+		...options,
+	};
+
+	if (Array.isArray(options.app)) {
+		return pTryEach(options.app, singleApp => baseOpen({
+			...options,
+			app: singleApp,
+		}));
+	}
+
+	let {name: app, arguments: appArguments = []} = options.app ?? {};
+	appArguments = [...appArguments];
+
+	if (Array.isArray(app)) {
+		return pTryEach(app, appName => baseOpen({
+			...options,
+			app: {
+				name: appName,
+				arguments: appArguments,
+			},
+		}));
+	}
+
+	if (app === 'browser' || app === 'browserPrivate') {
+		// IDs from default-browser for macOS and windows are the same
+		const ids = {
+			'com.google.chrome': 'chrome',
+			'google-chrome.desktop': 'chrome',
+			'com.brave.Browser': 'brave',
+			'org.mozilla.firefox': 'firefox',
+			'firefox.desktop': 'firefox',
+			'com.microsoft.msedge': 'edge',
+			'com.microsoft.edge': 'edge',
+			'com.microsoft.edgemac': 'edge',
+			'microsoft-edge.desktop': 'edge',
+		};
+
+		// Incognito flags for each browser in `apps`.
+		const flags = {
+			chrome: '--incognito',
+			brave: '--incognito',
+			firefox: '--private-window',
+			edge: '--inPrivate',
+		};
+
+		const browser = is_wsl ? await getWindowsDefaultBrowserFromWsl() : await default_browser_defaultBrowser();
+		if (browser.id in ids) {
+			const browserName = ids[browser.id];
+
+			if (app === 'browserPrivate') {
+				appArguments.push(flags[browserName]);
+			}
+
+			return baseOpen({
+				...options,
+				app: {
+					name: apps[browserName],
+					arguments: appArguments,
+				},
+			});
+		}
+
+		throw new Error(`${browser.name} is not supported as a default browser`);
+	}
+
+	let command;
+	const cliArguments = [];
+	const childProcessOptions = {};
+
+	if (platform === 'darwin') {
+		command = 'open';
+
+		if (options.wait) {
+			cliArguments.push('--wait-apps');
+		}
+
+		if (options.background) {
+			cliArguments.push('--background');
+		}
+
+		if (options.newInstance) {
+			cliArguments.push('--new');
+		}
+
+		if (app) {
+			cliArguments.push('-a', app);
+		}
+	} else if (platform === 'win32' || (is_wsl && !isInsideContainer() && !app)) {
+		command = await powerShellPath();
+
+		cliArguments.push(
+			'-NoProfile',
+			'-NonInteractive',
+			'-ExecutionPolicy',
+			'Bypass',
+			'-EncodedCommand',
+		);
+
+		if (!is_wsl) {
+			childProcessOptions.windowsVerbatimArguments = true;
+		}
+
+		const encodedArguments = ['Start'];
+
+		if (options.wait) {
+			encodedArguments.push('-Wait');
+		}
+
+		if (app) {
+			// Double quote with double quotes to ensure the inner quotes are passed through.
+			// Inner quotes are delimited for PowerShell interpretation with backticks.
+			encodedArguments.push(`"\`"${app}\`""`);
+			if (options.target) {
+				appArguments.push(options.target);
+			}
+		} else if (options.target) {
+			encodedArguments.push(`"${options.target}"`);
+		}
+
+		if (appArguments.length > 0) {
+			appArguments = appArguments.map(argument => `"\`"${argument}\`""`);
+			encodedArguments.push('-ArgumentList', appArguments.join(','));
+		}
+
+		// Using Base64-encoded command, accepted by PowerShell, to allow special characters.
+		options.target = external_node_buffer_namespaceObject.Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+	} else {
+		if (app) {
+			command = app;
+		} else {
+			// When bundled by Webpack, there's no actual package file path and no local `xdg-open`.
+			const isBundled = !open_dirname || open_dirname === '/';
+
+			// Check if local `xdg-open` exists and is executable.
+			let exeLocalXdgOpen = false;
+			try {
+				await promises_.access(localXdgOpenPath, promises_.constants.X_OK);
+				exeLocalXdgOpen = true;
+			} catch {}
+
+			const useSystemXdgOpen = external_node_process_namespaceObject.versions.electron
+				?? (platform === 'android' || isBundled || !exeLocalXdgOpen);
+			command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
+		}
+
+		if (appArguments.length > 0) {
+			cliArguments.push(...appArguments);
+		}
+
+		if (!options.wait) {
+			// `xdg-open` will block the process unless stdio is ignored
+			// and it's detached from the parent even if it's unref'd.
+			childProcessOptions.stdio = 'ignore';
+			childProcessOptions.detached = true;
+		}
+	}
+
+	if (platform === 'darwin' && appArguments.length > 0) {
+		cliArguments.push('--args', ...appArguments);
+	}
+
+	// This has to come after `--args`.
+	if (options.target) {
+		cliArguments.push(options.target);
+	}
+
+	const subprocess = external_node_child_process_.spawn(command, cliArguments, childProcessOptions);
+
+	if (options.wait) {
+		return new Promise((resolve, reject) => {
+			subprocess.once('error', reject);
+
+			subprocess.once('close', exitCode => {
+				if (!options.allowNonzeroExitCode && exitCode > 0) {
+					reject(new Error(`Exited with code ${exitCode}`));
+					return;
+				}
+
+				resolve(subprocess);
+			});
+		});
+	}
+
+	subprocess.unref();
+
+	return subprocess;
+};
+
+const open_open = (target, options) => {
+	if (typeof target !== 'string') {
+		throw new TypeError('Expected a `target`');
+	}
+
+	return baseOpen({
+		...options,
+		target,
+	});
+};
+
+const openApp = (name, options) => {
+	if (typeof name !== 'string' && !Array.isArray(name)) {
+		throw new TypeError('Expected a valid `name`');
+	}
+
+	const {arguments: appArguments = []} = options ?? {};
+	if (appArguments !== undefined && appArguments !== null && !Array.isArray(appArguments)) {
+		throw new TypeError('Expected `appArguments` as Array type');
+	}
+
+	return baseOpen({
+		...options,
+		app: {
+			name,
+			arguments: appArguments,
+		},
+	});
+};
+
+function detectArchBinary(binary) {
+	if (typeof binary === 'string' || Array.isArray(binary)) {
+		return binary;
+	}
+
+	const {[arch]: archBinary} = binary;
+
+	if (!archBinary) {
+		throw new Error(`${arch} is not supported`);
+	}
+
+	return archBinary;
+}
+
+function detectPlatformBinary({[platform]: platformBinary}, {wsl}) {
+	if (wsl && is_wsl) {
+		return detectArchBinary(wsl);
+	}
+
+	if (!platformBinary) {
+		throw new Error(`${platform} is not supported`);
+	}
+
+	return detectArchBinary(platformBinary);
+}
+
+const apps = {};
+
+defineLazyProperty(apps, 'chrome', () => detectPlatformBinary({
+	darwin: 'google chrome',
+	win32: 'chrome',
+	linux: ['google-chrome', 'google-chrome-stable', 'chromium'],
+}, {
+	wsl: {
+		ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+		x64: ['/mnt/c/Program Files/Google/Chrome/Application/chrome.exe', '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe'],
+	},
+}));
+
+defineLazyProperty(apps, 'brave', () => detectPlatformBinary({
+	darwin: 'brave browser',
+	win32: 'brave',
+	linux: ['brave-browser', 'brave'],
+}, {
+	wsl: {
+		ia32: '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe',
+		x64: ['/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe', '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe'],
+	},
+}));
+
+defineLazyProperty(apps, 'firefox', () => detectPlatformBinary({
+	darwin: 'firefox',
+	win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+	linux: 'firefox',
+}, {
+	wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe',
+}));
+
+defineLazyProperty(apps, 'edge', () => detectPlatformBinary({
+	darwin: 'microsoft edge',
+	win32: 'msedge',
+	linux: ['microsoft-edge', 'microsoft-edge-dev'],
+}, {
+	wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
+}));
+
+defineLazyProperty(apps, 'browser', () => 'browser');
+
+defineLazyProperty(apps, 'browserPrivate', () => 'browserPrivate');
+
+/* harmony default export */ const node_modules_open = (open_open);
+
+// EXTERNAL MODULE: ../../node_modules/qrcode/lib/index.js
+var lib = __nccwpck_require__(7514);
+// EXTERNAL MODULE: ./bin/vibelet-pairing-connections.mjs
+var vibelet_pairing_connections = __nccwpck_require__(7721);
+;// CONCATENATED MODULE: ./bin/vibelet-pairing-output.mjs
+
+
+
+
+
+const TERMINAL_QR_MARGIN = 4;
+const SIXEL_TERMS = /^(?:mlterm|yaft|xterm-sixel)(?:-|$)/i;
+
+function renderWideTerminalQr(qr) {
+  const { data, size } = qr.modules;
+  const white = '\x1b[47m  ';
+  const black = '\x1b[40m  ';
+  const reset = '\x1b[0m';
+  const rows = [];
+
+  for (let y = -TERMINAL_QR_MARGIN; y < size + TERMINAL_QR_MARGIN; y += 1) {
+    let row = '';
+    for (let x = -TERMINAL_QR_MARGIN; x < size + TERMINAL_QR_MARGIN; x += 1) {
+      const dark = x >= 0 && x < size && y >= 0 && y < size && data[y * size + x];
+      row += dark ? black : white;
+    }
+    rows.push(`${row}${reset}`);
+  }
+
+  return `${rows.join('\n')}\n`;
+}
+
+async function renderTerminalQr(payload, columns = 0) {
+  // Terminal capture benefits more from larger modules than from extra error
+  // correction. The PNG keeps level M for printing and image import.
+  const qr = lib.create(payload, { errorCorrectionLevel: 'L' });
+  const wideColumns = (qr.modules.size + TERMINAL_QR_MARGIN * 2) * 2;
+  if (columns >= wideColumns) {
+    return renderWideTerminalQr(qr);
+  }
+
+  const compactQr = await lib.toString(payload, {
+    type: 'utf8',
+    errorCorrectionLevel: 'L',
+    margin: TERMINAL_QR_MARGIN,
+  });
+  return `\x1b[47m\x1b[30m${compactQr}\x1b[0m`;
+}
+
+function detectTerminalImageProtocol(stdout, env = process.env) {
+  if (!stdout.isTTY) return null;
+
+  const term = (env.TERM ?? '').toLowerCase();
+  const termProgram = (env.TERM_PROGRAM ?? '').toLowerCase();
+  if (
+    env.KITTY_WINDOW_ID ||
+    env.KITTY_PID ||
+    env.GHOSTTY_RESOURCES_DIR ||
+    env.WEZTERM_PANE ||
+    ['kitty', 'ghostty', 'warpterminal', 'wezterm', 'rio'].includes(termProgram) ||
+    /kitty|ghostty/.test(term)
+  ) {
+    return 'kitty';
+  }
+  if (termProgram === 'iterm.app' || env.LC_TERMINAL?.toLowerCase() === 'iterm2') {
+    return 'iterm2';
+  }
+  if (
+    SIXEL_TERMS.test(term) ||
+    ['mintty', 'vscode'].includes(termProgram) ||
+    termProgram === 'konsole' ||
+    Boolean(env.KONSOLE_VERSION)
+  ) {
+    return 'sixel';
+  }
+  return null;
+}
+
+function renderKittyPng(png) {
+  const encoded = png.toString('base64');
+  const chunks = encoded.match(/.{1,4096}/g) ?? [];
+  return chunks
+    .map((chunk, index) => {
+      const more = index < chunks.length - 1 ? 1 : 0;
+      const header = index === 0 ? `a=T,f=100,m=${more}` : `m=${more}`;
+      return `\x1b_G${header};${chunk}\x1b\\`;
+    })
+    .join('');
+}
+
+function renderIterm2Png(png) {
+  return `\x1b]1337;File=inline=1;preserveAspectRatio=1:${png.toString('base64')}\x07`;
+}
+
+function encodeSixelRuns(values) {
+  let output = '';
+  for (let index = 0; index < values.length; ) {
+    let end = index + 1;
+    while (end < values.length && values[end] === values[index]) end += 1;
+    const count = end - index;
+    const char = String.fromCharCode(63 + values[index]);
+    output += count >= 4 ? `!${count}${char}` : char.repeat(count);
+    index = end;
+  }
+  return output;
+}
+
+function renderSixelQr(payload, scale = 6) {
+  const qr = lib.create(payload, { errorCorrectionLevel: 'M' });
+  const moduleSize = qr.modules.size;
+  const rasterModules = moduleSize + TERMINAL_QR_MARGIN * 2;
+  const width = rasterModules * scale;
+  const height = rasterModules * scale;
+  let output = `\x1bPq"1;1;${width};${height}#0;2;100;100;100#1;2;0;0;0`;
+
+  for (let bandY = 0; bandY < height; bandY += 6) {
+    output += `#0!${width}~$#1`;
+    const columns = [];
+    for (let x = 0; x < width; x += 1) {
+      let sixel = 0;
+      const moduleX = Math.floor(x / scale) - TERMINAL_QR_MARGIN;
+      for (let bit = 0; bit < 6; bit += 1) {
+        const y = bandY + bit;
+        const moduleY = Math.floor(y / scale) - TERMINAL_QR_MARGIN;
+        const dark =
+          moduleX >= 0 &&
+          moduleX < moduleSize &&
+          moduleY >= 0 &&
+          moduleY < moduleSize &&
+          qr.modules.data[moduleY * moduleSize + moduleX];
+        if (dark) sixel |= 1 << bit;
+      }
+      columns.push(sixel);
+    }
+    output += encodeSixelRuns(columns);
+    if (bandY + 6 < height) output += '-';
+  }
+  return `${output}\x1b\\`;
+}
+
+function tryWriteTerminalQrImage(
+  pairingQrPngPath,
+  qrPayload,
+  { stdout, env = process.env, readFileSyncImpl = external_node_fs_.readFileSync },
+) {
+  const protocol = detectTerminalImageProtocol(stdout, env);
+  if (!protocol) return false;
+
+  try {
+    const rendered =
+      protocol === 'sixel'
+        ? renderSixelQr(qrPayload)
+        : protocol === 'kitty'
+          ? renderKittyPng(readFileSyncImpl(pairingQrPngPath))
+          : renderIterm2Png(readFileSyncImpl(pairingQrPngPath));
+    stdout.write(rendered);
+    stdout.write('\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function tryOpenPairingImage(
+  pairingQrPngPath,
+  { stdout, env = process.env, platform = process.platform, openImpl = node_modules_open },
+) {
+  const hasDesktopSession = platform === 'darwin' || platform === 'win32' || env.DISPLAY || env.WAYLAND_DISPLAY;
+  if (!stdout.isTTY || !hasDesktopSession) return false;
+
+  try {
+    await openImpl(pairingQrPngPath, { wait: false });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function presentPairingQr(
+  pairingQrPngPath,
+  qrPayload,
+  { stdout, env = process.env, platform = process.platform, openImpl = node_modules_open, readFileSyncImpl = external_node_fs_.readFileSync },
+) {
+  const openedImage = await tryOpenPairingImage(pairingQrPngPath, {
+    stdout,
+    env,
+    platform,
+    openImpl,
+  });
+  if (openedImage) return 'opened';
+
+  const renderedInline = tryWriteTerminalQrImage(pairingQrPngPath, qrPayload, {
+    stdout,
+    env,
+    readFileSyncImpl,
+  });
+  return renderedInline ? 'inline' : 'fallback';
+}
 
 async function writePairingOutput(pairingPayload, { directory, pairingCodePath, pairingQrPngPath, stdout }) {
-  const payload = JSON.stringify((0,_vibelet_pairing_connections_mjs__WEBPACK_IMPORTED_MODULE_2__/* .createCompactPairingPayload */ .YP)(pairingPayload));
-  const qrPayload = JSON.stringify((0,_vibelet_pairing_connections_mjs__WEBPACK_IMPORTED_MODULE_2__/* .createScannablePairingPayload */ .u_)(pairingPayload));
-  const deepLink = (0,_vibelet_pairing_connections_mjs__WEBPACK_IMPORTED_MODULE_2__/* .buildPairingDeepLink */ .N7)(payload);
-  (0,node_fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync)(directory, { recursive: true });
-  await qrcode__WEBPACK_IMPORTED_MODULE_1__.toFile(pairingQrPngPath, qrPayload, {
+  const payload = JSON.stringify((0,vibelet_pairing_connections/* createCompactPairingPayload */.YP)(pairingPayload));
+  const qrPayload = JSON.stringify((0,vibelet_pairing_connections/* createScannablePairingPayload */.u_)(pairingPayload));
+  const deepLink = (0,vibelet_pairing_connections/* buildPairingDeepLink */.N7)(payload);
+  (0,external_node_fs_.mkdirSync)(directory, { recursive: true });
+  await lib.toFile(pairingQrPngPath, qrPayload, {
     type: 'png',
     errorCorrectionLevel: 'M',
     margin: 4,
     scale: 8,
   });
-  const qr = await qrcode__WEBPACK_IMPORTED_MODULE_1__.toString(qrPayload, {
-    type: 'utf8',
-    errorCorrectionLevel: 'M',
-    margin: 4,
-  });
-  (0,node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync)(pairingCodePath, `${payload}\n`, 'utf8');
-  stdout.write(`\nScan this QR code with the Vibelet app:\n\n\x1b[47m\x1b[30m${qr}\x1b[0m\n`);
-  stdout.write(`If Vibelet app can't scan the terminal QR, open this PNG instead:\n${pairingQrPngPath}\n`);
+  const qr = await renderTerminalQr(qrPayload, stdout.columns);
+  (0,external_node_fs_.writeFileSync)(pairingCodePath, `${payload}\n`, 'utf8');
+  stdout.write('\nScan this QR code with the Vibelet app:\n\n');
+  const presentation = await presentPairingQr(pairingQrPngPath, qrPayload, { stdout });
+  if (presentation === 'opened') {
+    stdout.write('Opened the pairing QR image in your default viewer.\n\n');
+  } else if (presentation === 'fallback') {
+    stdout.write(`${qr}\n`);
+  }
+  stdout.write(`Pairing QR image saved to:\n${pairingQrPngPath}\n`);
   stdout.write(`This pairing QR expires at: ${pairingPayload.expiresAt}\n`);
   stdout.write(`If this device can't scan, paste this pairing code in Vibelet:\n${payload}\n`);
   stdout.write(`Pairing code saved to:\n${pairingCodePath}\n`);
@@ -15032,7 +15971,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(6760);
 /* harmony import */ var node_url__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(3136);
 /* harmony import */ var _vibelet_cli_args_mjs__WEBPACK_IMPORTED_MODULE_17__ = __nccwpck_require__(6927);
-/* harmony import */ var _cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_6__ = __nccwpck_require__(2755);
+/* harmony import */ var _cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_6__ = __nccwpck_require__(6895);
 /* harmony import */ var _vibelet_cloudflare_runtime_mjs__WEBPACK_IMPORTED_MODULE_7__ = __nccwpck_require__(3869);
 /* harmony import */ var _vibelet_launchd_mjs__WEBPACK_IMPORTED_MODULE_13__ = __nccwpck_require__(1010);
 /* harmony import */ var _linux_systemd_mjs__WEBPACK_IMPORTED_MODULE_8__ = __nccwpck_require__(4217);
@@ -15042,7 +15981,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var _vibelet_runtime_policy_mjs__WEBPACK_IMPORTED_MODULE_12__ = __nccwpck_require__(4);
 /* harmony import */ var _terminal_wrapper_mjs__WEBPACK_IMPORTED_MODULE_10__ = __nccwpck_require__(877);
 /* harmony import */ var _vibelet_pairing_connections_mjs__WEBPACK_IMPORTED_MODULE_15__ = __nccwpck_require__(7721);
-/* harmony import */ var _vibelet_pairing_output_mjs__WEBPACK_IMPORTED_MODULE_11__ = __nccwpck_require__(4021);
+/* harmony import */ var _vibelet_pairing_output_mjs__WEBPACK_IMPORTED_MODULE_11__ = __nccwpck_require__(9485);
 
 
 
@@ -15925,7 +16864,7 @@ function validateExplicitCleartextHosts({ hostArg, fallbackHostsArg }) {
 }
 
 async function printPairingQr(pairingPayload) {
-  await (0,_vibelet_pairing_output_mjs__WEBPACK_IMPORTED_MODULE_11__/* .writePairingOutput */ .p)(pairingPayload, {
+  await (0,_vibelet_pairing_output_mjs__WEBPACK_IMPORTED_MODULE_11__/* .writePairingOutput */ .pO)(pairingPayload, {
     directory: vibeletDir,
     pairingCodePath,
     pairingQrPngPath,