@open-wa/wa-automate 5.4.0 → 5.5.1

package/dist/{cli-runtime-BKwXzp9V.cjs → cli-runtime-DDEl6a1P.cjs}

@@ -26,11 +26,12 @@ qrcode_terminal = __toESM(qrcode_terminal, 1);
 let node_path = require("node:path");
 let _open_wa_core = require("@open-wa/core");
 let _open_wa_client = require("@open-wa/client");
-let _open_wa_driver_lightpanda = require("@open-wa/driver-lightpanda");
-let _open_wa_driver_puppeteer = require("@open-wa/driver-puppeteer");
-let _open_wa_schema = require("@open-wa/schema");
 let _open_wa_config = require("@open-wa/config");
 let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let _open_wa_driver_interface = require("@open-wa/driver-interface");
+let _open_wa_schema = require("@open-wa/schema");
 let node_url = require("node:url");
 let _open_wa_runtime_core = require("@open-wa/runtime-core");
 let _open_wa_runtime_node = require("@open-wa/runtime-node");
@@ -42,6 +43,30 @@ var WAServer = class extends _open_wa_api.ApiServer {
 };
 //#endregion
 //#region src/cli/output-sink.ts
+async function promptChoice(question, choices) {
+	if (!process.stdin.isTTY || !process.stderr.isTTY) throw new Error("No browser is installed. Choose --use-chrome, --use-chromium or --use-lightpanda to download one without a prompt.");
+	const { createInterface } = await import("node:readline/promises");
+	const readline = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	const abort = new AbortController();
+	readline.on("SIGINT", () => abort.abort());
+	readline.on("close", () => abort.abort());
+	try {
+		process.stderr.write(`\n${question}\n${choices.map((choice, index) => `  ${index + 1}. ${choice}`).join("\n")}\n`);
+		while (true) {
+			const answer = (await readline.question("Choose a browser [1]: ", { signal: abort.signal })).trim();
+			const choice = answer === "" ? 0 : Number(answer) - 1;
+			if (Number.isInteger(choice) && choice >= 0 && choice < choices.length) return choice;
+			process.stderr.write(`Enter a number from 1 to ${choices.length}.\n`);
+		}
+	} catch (cause) {
+		throw new Error("Browser selection cancelled.", { cause });
+	} finally {
+		readline.close();
+	}
+}
 function writeToConsole(level, message) {
 	if (level === "warn") {
 		console.warn(message);
@@ -55,6 +80,7 @@ function writeToConsole(level, message) {
 }
 function createConsoleOutputSink() {
 	return {
+		promptChoice,
 		write(entry) {
 			writeToConsole(entry.level, entry.message);
 		},
@@ -77,6 +103,430 @@ function resetCliOutputSink() {
 	activeSink = createConsoleOutputSink();
 }
 //#endregion
+//#region src/browser-choice.ts
+const choiceFile = (0, node_path.join)((0, node_os.homedir)(), ".cache", "open-wa", "browser-choice.json");
+async function findSystemBrowser(kind) {
+	const app = kind === "chrome" ? "Google Chrome" : "Chromium";
+	const names = process.platform === "win32" ? ["chrome.exe"] : kind === "chrome" ? [
+		"google-chrome-stable",
+		"google-chrome",
+		"chrome"
+	] : ["chromium", "chromium-browser"];
+	const candidates = process.platform === "darwin" ? ["/Applications", (0, node_path.join)((0, node_os.homedir)(), "Applications")].map((root) => (0, node_path.join)(root, `${app}.app`, "Contents", "MacOS", app)) : process.platform === "win32" ? [
+		process.env.LOCALAPPDATA,
+		process.env.PROGRAMFILES,
+		process.env["PROGRAMFILES(X86)"]
+	].filter((root) => !!root).map((root) => kind === "chrome" ? (0, node_path.join)(root, "Google", "Chrome", "Application", "chrome.exe") : (0, node_path.join)(root, "Chromium", "Application", "chrome.exe")) : kind === "chrome" ? ["/opt/google/chrome/chrome"] : [];
+	candidates.push(...(process.env.PATH ?? "").split(node_path.delimiter).filter(Boolean).flatMap((root) => names.map((name) => (0, node_path.join)(root, name))));
+	for (const candidate of candidates) try {
+		if (!(await (0, node_fs_promises.stat)(candidate)).isFile()) continue;
+		await (0, node_fs_promises.access)(candidate, node_fs.constants.X_OK);
+		return candidate;
+	} catch {}
+}
+async function readBrowserChoice() {
+	const { Effect, Schema } = await import("effect");
+	const recordSchema = Schema.fromJsonString(Schema.Struct({
+		kind: Schema.Literals([
+			"chrome",
+			"chromium",
+			"lightpanda"
+		]),
+		executablePath: Schema.String
+	}));
+	const io = (operation) => Effect.tryPromise({
+		try: operation,
+		catch: _open_wa_driver_interface.toPublicError
+	});
+	return Effect.runPromise(Effect.gen(function* () {
+		const record = yield* Schema.decodeUnknownEffect(recordSchema)(yield* io(() => (0, node_fs_promises.readFile)(choiceFile, "utf8")));
+		if (!(yield* io(() => (0, node_fs_promises.stat)(record.executablePath))).isFile()) return void 0;
+		yield* io(() => (0, node_fs_promises.access)(record.executablePath, node_fs.constants.X_OK));
+		return record;
+	}).pipe(Effect.catch(() => Effect.succeed(void 0))));
+}
+async function writeBrowserChoice(kind, executablePath) {
+	const { Effect } = await import("effect");
+	const io = (operation) => Effect.tryPromise({
+		try: operation,
+		catch: _open_wa_driver_interface.toPublicError
+	});
+	const program = Effect.gen(function* () {
+		const directory = (0, node_path.dirname)(choiceFile);
+		yield* io(() => (0, node_fs_promises.mkdir)(directory, { recursive: true }));
+		const staging = yield* Effect.acquireRelease(io(() => (0, node_fs_promises.mkdtemp)((0, node_path.join)(directory, ".browser-choice-"))), (path) => io(() => (0, node_fs_promises.rm)(path, {
+			recursive: true,
+			force: true
+		})).pipe(Effect.orDie));
+		const temporary = (0, node_path.join)(staging, "browser-choice.json");
+		yield* io(() => (0, node_fs_promises.writeFile)(temporary, JSON.stringify({
+			kind,
+			executablePath
+		}), {
+			encoding: "utf8",
+			flag: "wx"
+		}));
+		yield* io(() => (0, node_fs_promises.rename)(temporary, choiceFile));
+	});
+	await Effect.runPromise(Effect.scoped(Effect.uninterruptible(program))).catch((cause) => {
+		throw (0, _open_wa_driver_interface.toPublicError)(cause);
+	});
+}
+async function chooseBrowser() {
+	return [
+		"chrome",
+		"chromium",
+		"lightpanda"
+	][await (getCliOutputSink().promptChoice ?? promptChoice)("Google Chrome was not found. Which browser would you like to download?", [
+		"Chrome for Testing — recommended; highest compatibility, including video and media.",
+		"Chromium — middle ground; proprietary video/audio codecs may be unavailable.",
+		"Lightpanda — lightweight basic automation; low compatibility, experimental WhatsApp support, no video or rendering."
+	])];
+}
+//#endregion
+//#region src/runtime-client.ts
+function readChromePathCache(cacheFilePath) {
+	try {
+		if (!(0, node_fs.existsSync)(cacheFilePath)) return;
+		const raw = JSON.parse((0, node_fs.readFileSync)(cacheFilePath, "utf8"));
+		if (!raw || typeof raw !== "object") return;
+		return { executablePath: typeof raw.executablePath === "string" ? raw.executablePath : void 0 };
+	} catch {
+		return;
+	}
+}
+function writeChromePathCache(executablePath, cacheFilePath) {
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(cacheFilePath), { recursive: true });
+	(0, node_fs.writeFileSync)(cacheFilePath, JSON.stringify({
+		executablePath,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2), "utf8");
+}
+function clearChromePathCache(cacheFilePath) {
+	if ((0, node_fs.existsSync)(cacheFilePath)) (0, node_fs.rmSync)(cacheFilePath, { force: true });
+}
+function isUsableExecutablePath(executablePath) {
+	if (!executablePath) return false;
+	try {
+		if (!(0, node_fs.statSync)(executablePath).isFile()) return false;
+		(0, node_fs.accessSync)(executablePath, node_fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getExplicitUseChromePreference(rawConfigs) {
+	const explicitConfigSources = [
+		rawConfigs?.file,
+		rawConfigs?.env,
+		rawConfigs?.cli,
+		rawConfigs?.programmatic
+	];
+	for (let index = explicitConfigSources.length - 1; index >= 0; index -= 1) {
+		const source = explicitConfigSources[index];
+		if (source?.useChrome !== void 0) return source.useChrome;
+	}
+}
+function shouldPreferLocalChrome(config, rawConfigs, defaultPreference = true) {
+	if (config.useLightpanda || config.useChromium || config.browser?.kind === "chromium") return false;
+	if (config.executablePath || process.env.PUPPETEER_EXECUTABLE_PATH !== void 0) return false;
+	const explicitUseChrome = getExplicitUseChromePreference(rawConfigs);
+	if (explicitUseChrome !== void 0) return explicitUseChrome;
+	return defaultPreference;
+}
+async function resolveExecutablePath(config, options) {
+	const configuredPath = config.executablePath ?? process.env.PUPPETEER_EXECUTABLE_PATH;
+	if (configuredPath !== void 0) return {
+		executablePath: configuredPath,
+		source: "config"
+	};
+	if (!(options.preferLocalChrome ?? config.useChrome)) return { source: "driver_default" };
+	const matchesKind = (path) => options.kind === "chromium" ? /chromium/i.test(path) : !/chromium/i.test(path);
+	const cachedPath = readChromePathCache(options.cacheFilePath)?.executablePath;
+	if (isUsableExecutablePath(cachedPath) && matchesKind(cachedPath)) return {
+		executablePath: cachedPath,
+		source: "cache"
+	};
+	if (cachedPath) clearChromePathCache(options.cacheFilePath);
+	const detectedPath = await findSystemBrowser(options.kind ?? "chrome");
+	if (detectedPath) {
+		writeChromePathCache(detectedPath, options.cacheFilePath);
+		return {
+			executablePath: detectedPath,
+			source: "chrome_installation"
+		};
+	}
+	clearChromePathCache(options.cacheFilePath);
+	return { source: "driver_default" };
+}
+function resolveLightpandaExecutablePath(config) {
+	const executablePath = config.lightpanda?.executablePath ?? config.executablePath ?? process.env.LIGHTPANDA_EXECUTABLE_PATH;
+	if (executablePath) return {
+		executablePath,
+		source: "lightpanda_config"
+	};
+	return { source: "lightpanda_managed" };
+}
+async function selectRuntimeDriver$1(config, options) {
+	if ([
+		config.useChrome,
+		config.useChromium,
+		config.useLightpanda
+	].filter(Boolean).length > 1) throw new Error("Choose only one browser: useChrome, useChromium or useLightpanda.");
+	let kind = config.useLightpanda ? "lightpanda" : config.useChromium ? "chromium" : config.useChrome ? "chrome" : config.browser?.kind;
+	const explicitChoice = kind !== void 0 || getExplicitUseChromePreference(options.rawConfigs) !== void 0 || config.browser?.download === "auto";
+	const preferLocalChrome = shouldPreferLocalChrome(config, options.rawConfigs, options.defaultPreferLocalChrome ?? true);
+	let executableResolution = { source: "driver_default" };
+	if (kind !== "lightpanda") executableResolution = await resolveExecutablePath(config, {
+		preferLocalChrome: kind === "chromium" || preferLocalChrome,
+		cacheFilePath: kind === "chromium" ? `${options.cacheFilePath}.chromium` : options.cacheFilePath,
+		kind: kind === "chromium" ? "chromium" : "chrome"
+	});
+	else {
+		executableResolution = resolveLightpandaExecutablePath(config);
+		executableResolution.executablePath ??= config.executablePath;
+	}
+	if (!executableResolution.executablePath && (kind !== void 0 || options.promptForMissingBrowser) && !(kind === "lightpanda" && config.lightpanda?.experimentalWhatsApp !== false)) {
+		const remembered = await readBrowserChoice();
+		if (remembered && (kind === void 0 || remembered.kind === kind)) {
+			kind = remembered.kind;
+			executableResolution = {
+				source: "cache",
+				executablePath: remembered.executablePath
+			};
+		}
+	}
+	if (!kind && executableResolution.executablePath === void 0 && options.promptForMissingBrowser) {
+		const { ensureBrowser } = await import("@open-wa/driver-puppeteer");
+		try {
+			executableResolution = {
+				source: "managed_browser",
+				executablePath: await ensureBrowser({ browser: {
+					...config.browser,
+					kind: "chrome",
+					download: "never"
+				} })
+			};
+		} catch (error) {
+			if (!(error instanceof Error) || !/missing from .* and browser downloads are disabled/.test(error.message)) throw error;
+		}
+	}
+	if (!kind && !executableResolution.executablePath && !explicitChoice && options.promptForMissingBrowser) {
+		if (config.browser?.download === "never") throw new Error("No browser is available and browser downloads are disabled. Configure executablePath or pre-provision a browser cache.");
+		if (options.nonInteractive || process.env.CI || process.env.NONINTERACTIVE) throw new Error("No browser is installed. Choose --use-chrome, --use-chromium or --use-lightpanda to download one without a prompt.");
+		kind = await chooseBrowser();
+	}
+	kind ??= "chrome";
+	const sink = getCliOutputSink();
+	const ctx = { logger: {
+		debug: (message) => sink.write({
+			level: "debug",
+			message
+		}),
+		info: (message) => sink.write({
+			level: "info",
+			message
+		}),
+		warn: (message) => sink.write({
+			level: "warn",
+			message
+		}),
+		error: (message) => sink.write({
+			level: "error",
+			message
+		})
+	} };
+	const browser = {
+		...config.browser,
+		...explicitChoice || options.promptForMissingBrowser ? { download: config.browser?.download ?? "auto" } : {},
+		...kind !== "lightpanda" ? { kind } : {}
+	};
+	if (kind === "lightpanda") {
+		const { LightpandaDriver, ensureLightpanda } = await import("@open-wa/driver-lightpanda");
+		config.lightpanda = _open_wa_config.ConfigSchema.shape.lightpanda.parse({
+			...config.lightpanda,
+			experimentalWhatsApp: config.lightpanda?.experimentalWhatsApp ?? true
+		});
+		config.browser = browser;
+		const executablePath = await ensureLightpanda({
+			executablePath: executableResolution.executablePath,
+			browser,
+			preferPinnedRelease: config.lightpanda?.experimentalWhatsApp ?? true
+		}, ctx);
+		config.useLightpanda = true;
+		config.useChrome = false;
+		config.useChromium = false;
+		sink.write({
+			level: "warn",
+			message: "Lightpanda has low compatibility and experimental WhatsApp support; video, screenshots and rendering are unavailable."
+		});
+		if (options.promptForMissingBrowser) await writeBrowserChoice(kind, executablePath).catch((error) => sink.write({
+			level: "warn",
+			message: `Could not remember the browser choice: ${error instanceof Error ? error.message : String(error)}`
+		}));
+		return {
+			driver: new LightpandaDriver(),
+			engineLabel: "Lightpanda",
+			executableResolution: {
+				source: "lightpanda_managed",
+				executablePath
+			},
+			preferLocalChrome: false
+		};
+	}
+	config.browser = browser;
+	const { PuppeteerDriver, ensureBrowser } = await import("@open-wa/driver-puppeteer");
+	const executablePath = await ensureBrowser({
+		executablePath: executableResolution.executablePath,
+		browser
+	}, ctx);
+	if (!executableResolution.executablePath) executableResolution = {
+		source: "managed_browser",
+		executablePath
+	};
+	if (options.promptForMissingBrowser) await writeBrowserChoice(kind, executablePath).catch((error) => sink.write({
+		level: "warn",
+		message: `Could not remember the browser choice: ${error instanceof Error ? error.message : String(error)}`
+	}));
+	return {
+		driver: new PuppeteerDriver(),
+		engineLabel: "Puppeteer",
+		executableResolution,
+		preferLocalChrome
+	};
+}
+/** Load the Node media runtime only when a call needs a source or sink. */
+function makeDefaultCallMediaHost() {
+	return { async prepare(...args) {
+		const { makeNodeCallMediaHost } = await import("@open-wa/runtime-node");
+		return makeNodeCallMediaHost({ log: (message) => getCliOutputSink().write({
+			level: "info",
+			message
+		}) }).prepare(...args);
+	} };
+}
+function toCreateClientOptions(config, driverSelection, options = {}) {
+	return {
+		sessionId: config.sessionId,
+		eventMode: config.eventMode,
+		driver: driverSelection.driver,
+		deleteSessionDataOnLogout: config.deleteSessionDataOnLogout,
+		killClientOnLogout: config.killClientOnLogout,
+		sessionDataPath: config.sessionDataPath,
+		sessionData: config.sessionData,
+		skipSessionSave: config.skipSessionSave,
+		sessionDataBucketAuth: config.sessionDataBucketAuth,
+		sessionDataEncryptionKey: config.sessionDataEncryptionKey,
+		sessionDataEncryptionKeyFile: config.sessionDataEncryptionKeyFile,
+		s3Sync: config.s3Sync,
+		debug: options.debug ?? (config.logLevel === "debug" || config.logConsole),
+		headless: config.headless,
+		qrTimeoutMs: typeof config.qrTimeout === "number" ? config.qrTimeout * 1e3 : void 0,
+		authTimeoutMs: typeof config.authTimeout === "number" ? config.authTimeout * 1e3 : void 0,
+		executablePath: driverSelection.executableResolution.executablePath,
+		browserArgs: config.chromiumArgs,
+		browser: config.browser,
+		allowDangerousBrowserArgs: config.allowDangerousBrowserArgs,
+		userDataDir: config.userDataDir,
+		ephemeral: config.ephemeral,
+		linkCode: config.linkCode,
+		qrMax: config.qrMax,
+		oorTimeoutMs: config.oorTimeout * 1e3,
+		logConsole: config.logConsole,
+		logConsoleErrors: config.logConsoleErrors,
+		blockCrashLogs: config.blockCrashLogs,
+		blockAssets: config.blockAssets,
+		safeMode: config.safeMode,
+		lightpanda: config.useLightpanda ? {
+			experimentalWhatsApp: true,
+			...config.lightpanda
+		} : void 0,
+		licenseKey: config.licenseKey,
+		calling: config.calling,
+		callMediaHost: makeDefaultCallMediaHost(),
+		licenseConfig: config.licenseConfig,
+		patchConfig: {
+			ghPatch: config.ghPatch,
+			cachedPatch: config.cachedPatch
+		}
+	};
+}
+/** Start WhatsApp, display QR login when needed, and return a ready messaging client. */
+async function create(options = {}) {
+	const { createClient: createCoreClient } = await import("@open-wa/core");
+	const { Client } = await import("@open-wa/client");
+	const { driver, sessionData, sessionDataBucketAuth, s3Sync, calling, sessionDataEncryptionKey, sessionDataEncryptionKeyFile, ...configOverrides } = options;
+	const { config, rawConfigs } = await (0, _open_wa_config.resolveConfig)({
+		programmaticOverrides: {
+			qrTimeout: 0,
+			...configOverrides
+		},
+		skipConfigFile: true,
+		skipEnv: true,
+		includeRawConfigs: true
+	});
+	const coreOptions = toCreateClientOptions(config, driver ? {
+		driver,
+		engineLabel: driver.name === "lightpanda" ? "Lightpanda" : "Puppeteer",
+		executableResolution: {
+			source: "config",
+			executablePath: config.executablePath
+		},
+		preferLocalChrome: false
+	} : await selectRuntimeDriver$1(config, {
+		rawConfigs,
+		cacheFilePath: (0, node_path.resolve)(process.cwd(), ".open-wa", "chrome-executable-path.json"),
+		defaultPreferLocalChrome: false
+	}));
+	if (calling) coreOptions.calling = calling;
+	if (driver) coreOptions.driver = driver;
+	coreOptions.sessionData = sessionData;
+	coreOptions.sessionDataBucketAuth = sessionDataBucketAuth;
+	coreOptions.sessionDataEncryptionKey = sessionDataEncryptionKey;
+	coreOptions.sessionDataEncryptionKeyFile = sessionDataEncryptionKeyFile;
+	coreOptions.s3Sync = s3Sync;
+	const core = await createCoreClient(coreOptions);
+	const sink = getCliOutputSink();
+	const onQr = (event) => {
+		if (config.qrLogSkip || !event.details?.qr) return;
+		sink.write({
+			level: "info",
+			message: "Open WhatsApp on your sending phone: Linked Devices → Link a Device, then scan this QR code."
+		});
+		sink.qr({
+			qr: event.details.qr,
+			sessionId: config.sessionId
+		});
+	};
+	const onLinkCode = (event) => {
+		if (event.details?.linkCode && !config.qrLogSkip) sink.write({
+			level: "info",
+			message: `Enter this link code on your sending phone: ${event.details.linkCode}`
+		});
+	};
+	core.events.on("launch.auth.qr.generated", onQr);
+	core.events.on("launch.auth.linkCode.generated", onLinkCode);
+	let client;
+	try {
+		client = new Client({
+			client: core,
+			transport: core.getTransport()
+		});
+		await client.start();
+		if (core.getState() !== "READY" || !core.getReadiness().exposureSafe) throw new Error("WhatsApp startup finished without a messaging-ready session.");
+		return client;
+	} catch (error) {
+		try {
+			if (client) await client.stop("startup-failure");
+			else await core.stop("startup-failure");
+		} catch {}
+		throw error;
+	} finally {
+		core.events.off("launch.auth.qr.generated", onQr);
+		core.events.off("launch.auth.linkCode.generated", onLinkCode);
+	}
+}
+//#endregion
 //#region src/cli-runtime.ts
 function bridgeRuntimeEvents(openwaClient, publishRuntimeEvent) {
 	if (typeof openwaClient.events.onAny === "function" && typeof openwaClient.events.offAny === "function") {
@@ -84,7 +534,9 @@ function bridgeRuntimeEvents(openwaClient, publishRuntimeEvent) {
 		return () => openwaClient.events.offAny(publishRuntimeEvent);
 	}
 	const unsubscribers = [];
-	new Set(_open_wa_schema.eventRegistry.getAll().map((def) => def.meta.eventName)).forEach((eventName) => {
+	const bridgedEvents = new Set(_open_wa_schema.eventRegistry.getAll().map((def) => def.meta.eventName));
+	bridgedEvents.add("session.refresh.progress");
+	bridgedEvents.forEach((eventName) => {
 		const handler = (payload) => publishRuntimeEvent(eventName, payload);
 		openwaClient.events.on(eventName, handler);
 		unsubscribers.push(() => openwaClient.events.off(eventName, handler));
@@ -271,51 +723,6 @@ const CHROME_CACHE_FILE = (0, node_path.resolve)(process.cwd(), ".open-wa", "chr
 function getChromeCacheFilePath() {
 	return CHROME_CACHE_FILE;
 }
-function readChromePathCache(cacheFilePath = getChromeCacheFilePath()) {
-	if (!(0, node_fs.existsSync)(cacheFilePath)) return;
-	try {
-		const raw = JSON.parse((0, node_fs.readFileSync)(cacheFilePath, "utf8"));
-		if (!raw || typeof raw !== "object") return;
-		return {
-			executablePath: typeof raw.executablePath === "string" ? raw.executablePath : void 0,
-			updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : void 0
-		};
-	} catch {
-		return;
-	}
-}
-function writeChromePathCache(executablePath, cacheFilePath = getChromeCacheFilePath()) {
-	(0, node_fs.mkdirSync)((0, node_path.dirname)(cacheFilePath), { recursive: true });
-	(0, node_fs.writeFileSync)(cacheFilePath, JSON.stringify({
-		executablePath,
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	}, null, 2), "utf8");
-}
-function clearChromePathCache(cacheFilePath = getChromeCacheFilePath()) {
-	if ((0, node_fs.existsSync)(cacheFilePath)) (0, node_fs.rmSync)(cacheFilePath, { force: true });
-}
-function isUsableExecutablePath(executablePath) {
-	return !!executablePath && (0, node_fs.existsSync)(executablePath);
-}
-function getExplicitUseChromePreference(rawConfigs) {
-	const explicitConfigSources = [
-		rawConfigs?.file,
-		rawConfigs?.env,
-		rawConfigs?.cli,
-		rawConfigs?.programmatic
-	];
-	for (let index = explicitConfigSources.length - 1; index >= 0; index -= 1) {
-		const source = explicitConfigSources[index];
-		if (source?.useChrome !== void 0) return source.useChrome;
-	}
-}
-function shouldPreferLocalChrome(config, rawConfigs) {
-	if (config.useLightpanda) return false;
-	if (config.executablePath) return false;
-	const explicitUseChrome = getExplicitUseChromePreference(rawConfigs);
-	if (explicitUseChrome !== void 0) return explicitUseChrome;
-	return true;
-}
 function getVal(argv, flag) {
 	const index = argv.findIndex((arg) => arg === flag);
 	return index !== -1 ? argv[index + 1] : void 0;
@@ -358,8 +765,17 @@ function parseCliArgs(argv = process.argv.slice(2)) {
 	if (argv.includes("--no-ezqr")) cliOverrides.ezqr = false;
 	if (argv.includes("--headful")) cliOverrides.headless = false;
 	if (argv.includes("--headless")) cliOverrides.headless = true;
-	if (argv.includes("--use-chrome")) cliOverrides.useChrome = true;
-	if (argv.includes("--use-lightpanda")) cliOverrides.useLightpanda = true;
+	const browserFlags = [
+		"--use-chrome",
+		"--use-chromium",
+		"--use-lightpanda"
+	].filter((flag) => argv.includes(flag) || flag === "--use-lightpanda" && argv.includes("--lightpanda"));
+	if (browserFlags.length > 1) throw new Error("Choose only one of --use-chrome, --use-chromium or --use-lightpanda.");
+	if (browserFlags.length) {
+		cliOverrides.useChrome = browserFlags[0] === "--use-chrome";
+		cliOverrides.useChromium = browserFlags[0] === "--use-chromium";
+		cliOverrides.useLightpanda = browserFlags[0] === "--use-lightpanda";
+	}
 	if (argv.includes("--log-console")) cliOverrides.logConsole = true;
 	if (argv.includes("--aggressive-garbage-collection")) cliOverrides.aggressiveGarbageCollection = true;
 	if (argv.includes("--no-dashboard")) cliOverrides.dashboard = false;
@@ -412,57 +828,13 @@ function parseCliArgs(argv = process.argv.slice(2)) {
 		unsupportedWarnings
 	};
 }
-async function resolveExecutablePath(config, options = {}) {
-	if (config.executablePath) return {
-		executablePath: config.executablePath,
-		source: "config"
-	};
-	if (!(options.preferLocalChrome ?? config.useChrome)) return { source: "driver_default" };
-	const cacheFilePath = options.cacheFilePath ?? getChromeCacheFilePath();
-	const cachedPath = readChromePathCache(cacheFilePath)?.executablePath;
-	if (isUsableExecutablePath(cachedPath)) return {
-		executablePath: cachedPath,
-		source: "cache"
-	};
-	if (cachedPath) clearChromePathCache(cacheFilePath);
-	const { Launcher } = await import("chrome-launcher");
-	const detectedPath = Launcher.getInstallations().find((installationPath) => isUsableExecutablePath(installationPath));
-	if (detectedPath) {
-		writeChromePathCache(detectedPath, cacheFilePath);
-		return {
-			executablePath: detectedPath,
-			source: "chrome_installation"
-		};
-	}
-	clearChromePathCache(cacheFilePath);
-	return {
-		source: "driver_default",
-		warning: "Chrome resolution warning: no valid local Chrome installation was found. Falling back to Puppeteer/default driver browser resolution."
-	};
-}
-function resolveLightpandaExecutablePath(config) {
-	const executablePath = config.lightpanda?.executablePath;
-	if (executablePath) return {
-		executablePath,
-		source: "lightpanda_config"
-	};
-	return { source: "lightpanda_sdk_default" };
-}
-async function selectRuntimeDriver(config, rawConfigs) {
-	if (config.useLightpanda) return {
-		driver: new _open_wa_driver_lightpanda.LightpandaDriver(),
-		engineLabel: "Lightpanda",
-		executableResolution: resolveLightpandaExecutablePath(config),
-		preferLocalChrome: false
-	};
-	const preferLocalChrome = shouldPreferLocalChrome(config, rawConfigs);
-	const executableResolution = await resolveExecutablePath(config, { preferLocalChrome });
-	return {
-		driver: new _open_wa_driver_puppeteer.PuppeteerDriver(),
-		engineLabel: "Puppeteer",
-		executableResolution,
-		preferLocalChrome
-	};
+async function selectRuntimeDriver(config, rawConfigs, nonInteractive = false) {
+	return selectRuntimeDriver$1(config, {
+		rawConfigs,
+		cacheFilePath: getChromeCacheFilePath(),
+		promptForMissingBrowser: true,
+		nonInteractive
+	});
 }
 function printStartupSummary(config, resolution, preferLocalChrome, engineLabel) {
 	const host = config.host.includes("http") ? config.host : `http://${config.host}`;
@@ -507,9 +879,9 @@ function printStartupSummary(config, resolution, preferLocalChrome, engineLabel)
 		level: "info",
 		message: `Browser executable: explicit Lightpanda override (${resolution.executablePath})`
 	});
-	else if (resolution.source === "lightpanda_sdk_default") sink.write({
+	else if (resolution.source === "lightpanda_managed") sink.write({
 		level: "info",
-		message: "Browser executable: Lightpanda SDK managed executable (shared cache/default resolution)"
+		message: `Browser executable: Lightpanda with experimental WhatsApp setup (${resolution.executablePath})`
 	});
 	else if (resolution.source === "config" && config.executablePath) sink.write({
 		level: "info",
@@ -517,15 +889,15 @@ function printStartupSummary(config, resolution, preferLocalChrome, engineLabel)
 	});
 	else if (resolution.source === "cache") sink.write({
 		level: "info",
-		message: `Browser executable: local Chrome from cache (${resolution.executablePath})`
+		message: `Browser executable: cached browser (${resolution.executablePath})`
 	});
 	else if (resolution.source === "chrome_installation") sink.write({
 		level: "info",
-		message: `Browser executable: local Chrome detected (${resolution.executablePath})`
+		message: `Browser executable: installed ${config.browser?.kind === "chromium" ? "Chromium" : "Chrome"} (${resolution.executablePath})`
 	});
-	else if (preferLocalChrome) sink.write({
+	else if (resolution.source === "managed_browser") sink.write({
 		level: "info",
-		message: "Browser executable: driver default fallback (local Chrome unavailable)"
+		message: `Browser executable: managed ${config.browser?.kind === "chromium" ? "Chromium" : "Chrome"} (${resolution.executablePath})`
 	});
 	if (config.webhook) sink.write({
 		level: "warn",
@@ -564,7 +936,7 @@ async function start(parsedArgs = parseCliArgs()) {
 		level: "warn",
 		message: `Compatibility warning: ${warning}`
 	}));
-	const { driver, engineLabel, executableResolution, preferLocalChrome } = await selectRuntimeDriver(config, rawConfigs);
+	const { driver, engineLabel, executableResolution, preferLocalChrome } = await selectRuntimeDriver(config, rawConfigs, parsedArgs.forwardedArgs.includes("--non-interactive"));
 	if (executableResolution.warning) sink.write({
 		level: "warn",
 		message: executableResolution.warning
@@ -592,6 +964,7 @@ async function start(parsedArgs = parseCliArgs()) {
 	const executionSandbox = sandboxPolicy ? (0, _open_wa_runtime_node.makeNodeExecutionSandbox)({ workspacePath: process.cwd() }) : void 0;
 	const openwaClient = await (0, _open_wa_core.createClient)({
 		sessionId: config.sessionId,
+		eventMode: config.eventMode,
 		driver,
 		deleteSessionDataOnLogout: config.deleteSessionDataOnLogout,
 		killClientOnLogout: config.killClientOnLogout,
@@ -618,7 +991,14 @@ async function start(parsedArgs = parseCliArgs()) {
 		blockCrashLogs: config.blockCrashLogs,
 		blockAssets: config.blockAssets,
 		safeMode: config.safeMode,
+		lightpanda: config.useLightpanda ? {
+			experimentalWhatsApp: true,
+			...config.lightpanda
+		} : void 0,
 		licenseKey: config.licenseKey,
+		licenseConfig: config.licenseConfig,
+		calling: config.calling,
+		callMediaHost: makeDefaultCallMediaHost(),
 		sandboxPolicy,
 		executionSandbox,
 		memoryObservation: (observability, getBrowserProcessId) => (0, _open_wa_runtime_node.observeBrowserProcessMemory)(observability, getBrowserProcessId, { attributes: { session: config.sessionId } })
@@ -628,6 +1008,8 @@ async function start(parsedArgs = parseCliArgs()) {
 		state: openwaClient.getState()
 	}));
 	const detachLaunchNarration = attachLaunchNarration(openwaClient, sink, config.sessionId);
+	openwaClient.events.on("launch.auth.qr.expired", () => server.setQR(null));
+	openwaClient.events.on("launch.auth.qr.scanned", () => server.setQR(null));
 	openwaClient.events.on("launch.auth.qr.generated", (event) => {
 		const qr = event.details?.qr;
 		if (!qr) return;
@@ -709,7 +1091,7 @@ async function start(parsedArgs = parseCliArgs()) {
 		});
 		sink.write({
 			level: "warn",
-			message: "Session kept alive for debugging. Browser page is still open."
+			message: "The API server is still running for inspection; the client failed to start."
 		});
 		sink.write({
 			level: "warn",
@@ -745,7 +1127,7 @@ async function start(parsedArgs = parseCliArgs()) {
 }
 async function main(argv = process.argv.slice(2)) {
 	if (argv[0] === "init") {
-		const { initProject } = await Promise.resolve().then(() => require("./init-k_0bazOu.cjs"));
+		const { initProject } = await Promise.resolve().then(() => require("./init-d6fE8kvv.cjs"));
 		await initProject(argv.slice(1));
 		return;
 	}
@@ -815,6 +1197,12 @@ Object.defineProperty(exports, "WAServer", {
 		return WAServer;
 	}
 });
+Object.defineProperty(exports, "create", {
+	enumerable: true,
+	get: function() {
+		return create;
+	}
+});
 Object.defineProperty(exports, "createConsoleOutputSink", {
 	enumerable: true,
 	get: function() {
@@ -858,4 +1246,4 @@ Object.defineProperty(exports, "start", {
 	}
 });
 
-//# sourceMappingURL=cli-runtime-BKwXzp9V.cjs.map
+//# sourceMappingURL=cli-runtime-DDEl6a1P.cjs.map