@open-wa/wa-automate 4.76.0 → 5.0.0-alpha.0

package/dist/cli-runtime-B7_3MM0c.cjs

@@ -0,0 +1,798 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _open_wa_api = require("@open-wa/api");
+let boxen = require("boxen");
+boxen = __toESM(boxen);
+let qrcode_terminal = require("qrcode-terminal");
+qrcode_terminal = __toESM(qrcode_terminal);
+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_path = require("node:path");
+let node_url = require("node:url");
+//#region src/server/hono-server.ts
+var WAServer = class extends _open_wa_api.ApiServer {
+	constructor(config) {
+		super({ config });
+	}
+};
+//#endregion
+//#region src/cli/output-sink.ts
+function writeToConsole(level, message) {
+	if (level === "warn") {
+		console.warn(message);
+		return;
+	}
+	if (level === "error") {
+		console.error(message);
+		return;
+	}
+	console.log(message);
+}
+function createConsoleOutputSink() {
+	return {
+		write(entry) {
+			writeToConsole(entry.level, entry.message);
+		},
+		status() {},
+		qr(payload) {
+			qrcode_terminal.default.generate(payload.qr, { small: true }, (terminalQrCode) => {
+				console.log((0, boxen.default)(terminalQrCode, {
+					title: payload.sessionId,
+					padding: 1,
+					titleAlignment: "center"
+				}));
+			});
+		}
+	};
+}
+let activeSink = createConsoleOutputSink();
+function getCliOutputSink() {
+	return activeSink;
+}
+function setCliOutputSink(sink) {
+	activeSink = sink;
+}
+function resetCliOutputSink() {
+	activeSink = createConsoleOutputSink();
+}
+//#endregion
+//#region src/cli-runtime.ts
+function bridgeRuntimeEvents(openwaClient, publishRuntimeEvent) {
+	if (typeof openwaClient.events.onAny === "function" && typeof openwaClient.events.offAny === "function") {
+		openwaClient.events.onAny(publishRuntimeEvent);
+		return () => openwaClient.events.offAny(publishRuntimeEvent);
+	}
+	const unsubscribers = [];
+	new Set(_open_wa_schema.eventRegistry.getAll().map((def) => def.meta.eventName)).forEach((eventName) => {
+		const handler = (payload) => publishRuntimeEvent(eventName, payload);
+		openwaClient.events.on(eventName, handler);
+		unsubscribers.push(() => openwaClient.events.off(eventName, handler));
+	});
+	return () => {
+		unsubscribers.forEach((unsubscribe) => unsubscribe());
+	};
+}
+function attachLaunchNarration(openwaClient, sink, sessionId) {
+	const unsubscribers = [];
+	const on = (event, handler) => {
+		openwaClient.events.on(event, handler);
+		unsubscribers.push(() => openwaClient.events.off(event, handler));
+	};
+	on("launch.auth.check.before", (event) => {
+		sink.status({
+			phase: "launch.auth",
+			sessionId,
+			detail: `Authenticating (timeout=${event?.details?.timeoutMs ?? "∞"}ms)`
+		});
+	});
+	on("launch.auth.check.after", (event) => {
+		sink.write({
+			level: "info",
+			message: `Auth detected via ${event?.details?.method ?? "unknown"} (${event?.details?.isAuthenticated ? "authenticated" : "not-authenticated"})`
+		});
+	});
+	on("launch.helper.pre_api.before", (event) => {
+		sink.status({
+			phase: "launch.helpers",
+			sessionId,
+			detail: event?.details?.mode === "scripts" ? "Injecting pre-API helper assets..." : "Pre-API helpers already present"
+		});
+	});
+	on("launch.helper.pre_api.after", (event) => {
+		sink.write({
+			level: "info",
+			message: `Pre-API helper phase complete (${event?.details?.mode ?? "unknown"})`
+		});
+	});
+	on("internal_launch_progress", (event) => {
+		const prefix = event?.value || event?.value === 0 ? `${event.value}% ` : "";
+		if (event?.text) sink.write({
+			level: "info",
+			message: `${prefix}${event.text}`.trim()
+		});
+	});
+	on("critical_internal_message", (event) => {
+		sink.write({
+			level: "warn",
+			message: `Internal launch message: ${event?.text ?? event?.value ?? "unknown"}`
+		});
+	});
+	on("launch.patch.init.before", (event) => {
+		if (event?.details?.phase === "preload") sink.status({
+			phase: "launch.patch",
+			sessionId,
+			detail: "Downloading patches from CDN..."
+		});
+	});
+	on("launch.patch.init.after", (event) => {
+		if (event?.details?.phase === "preload") {
+			const source = event?.details?.source ?? "unknown";
+			const tag = event?.details?.tag ? ` tag=${event.details.tag}` : "";
+			const available = Array.isArray(event?.details?.available) ? event.details.available.length : 0;
+			const durationMs = event?.durationMs;
+			const durationStr = durationMs ? ` in ${(durationMs / 1e3).toFixed(2)}s` : "";
+			sink.write({
+				level: "info",
+				message: `Downloaded patches${durationStr} (source=${source}, available=${available}${tag})`
+			});
+		}
+	});
+	on("patch.init.before", (event) => {
+		if (event?.details?.phase === "apply") {
+			const count = Array.isArray(event?.details?.patchIds) ? event.details.patchIds.length : 0;
+			sink.status({
+				phase: "launch.patch",
+				sessionId,
+				detail: `Installing patches (${count} queued)`
+			});
+		}
+	});
+	on("patch.apply.before", (event) => {
+		sink.status({
+			phase: "launch.patch",
+			sessionId,
+			detail: `Applying patch: ${event?.details?.patchId ?? "unknown"}`
+		});
+	});
+	on("patch.apply.after", (event) => {
+		sink.write({
+			level: event?.details?.outcome === "failed" ? "warn" : "info",
+			message: `Patch ${event?.details?.patchId ?? "unknown"}: ${event?.details?.outcome ?? (event?.details?.applied ? "applied" : "unknown")}${event?.details?.detail ? ` — ${event.details.detail}` : ""}`
+		});
+	});
+	on("patch.init.after", (event) => {
+		if (event?.details?.phase === "apply") {
+			const applied = Array.isArray(event?.details?.applied) ? event.details.applied : [];
+			const outcome = event?.details?.outcome ?? "unknown";
+			const tag = applied.length > 0 ? applied.join(", ") : outcome;
+			const durationMs = event?.durationMs;
+			const durationStr = durationMs ? ` in ${(durationMs / 1e3).toFixed(2)}s` : "";
+			sink.write({
+				level: event?.details?.blockingFailure ? "warn" : "info",
+				message: `Patches Installed${durationStr}: ${tag}`
+			});
+		}
+	});
+	on("launch.patch.integrity.before", () => {
+		sink.status({
+			phase: "launch.patch",
+			sessionId,
+			detail: "Validating patched runtime..."
+		});
+	});
+	on("launch.patch.integrity.after", (event) => {
+		sink.write({
+			level: event?.details?.usable ? "info" : "warn",
+			message: `Patched runtime validation: ${event?.details?.usable ? "usable" : "failed"}${event?.details?.failureReason ? ` (${event.details.failureReason})` : ""}`
+		});
+	});
+	on("launch.license.check.before", (event) => {
+		sink.status({
+			phase: "launch.license",
+			sessionId,
+			detail: `Checking license (${event?.details?.source ?? "local"})`
+		});
+	});
+	on("launch.license.check.after", (event) => {
+		sink.write({
+			level: event?.details?.blockingFailure ? "warn" : "info",
+			message: `License check: ${event?.details?.status ?? "unknown"}${event?.details?.detail ? ` — ${event.details.detail}` : ""}`
+		});
+	});
+	on("license.inject.before", () => {
+		sink.status({
+			phase: "launch.license",
+			sessionId,
+			detail: "Injecting license payload..."
+		});
+	});
+	on("license.inject.after", (event) => {
+		sink.write({
+			level: event?.details?.success ? "info" : "warn",
+			message: `License inject: ${event?.details?.success ? "success" : "failed"}${event?.details?.status ? ` (${event.details.status})` : ""}${event?.details?.detail ? ` — ${event.details.detail}` : ""}`
+		});
+	});
+	on("launch.auth.qr.generated", (event) => {
+		const qrIndex = event?.details?.qrIndex ?? "?";
+		sink.status({
+			phase: "launch.auth",
+			sessionId,
+			detail: `QR code generated (#${qrIndex})`
+		});
+	});
+	on("launch.client.finalize.before", (event) => {
+		sink.status({
+			phase: "launch.finalize",
+			sessionId,
+			detail: `Finalizing session (${event?.details?.validationStage ?? "unknown"})`
+		});
+	});
+	on("launch.client.finalize.after", (event) => {
+		sink.write({
+			level: event?.details?.success ? "info" : "warn",
+			message: `Finalize: ${event?.details?.outcome ?? "unknown"}${event?.details?.detail ? ` — ${event.details.detail}` : ""}`
+		});
+	});
+	on("error", (event) => {
+		const scope = event?.scope ?? "unknown";
+		const msg = event?.error?.message ?? String(event?.error ?? "unknown error");
+		const fatal = event?.fatal ? " [FATAL]" : "";
+		sink.write({
+			level: "error",
+			message: `${fatal} ${scope}: ${msg}`.trim()
+		});
+	});
+	return () => {
+		unsubscribers.forEach((unsubscribe) => unsubscribe());
+	};
+}
+const CHROME_CACHE_FILE = (0, node_path.resolve)(process.cwd(), ".open-wa", "chrome-executable-path.json");
+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;
+}
+function parseCliArgs(argv = process.argv.slice(2)) {
+	const cliOverrides = {};
+	const unsupportedWarnings = [];
+	let verbose = false;
+	let configPath;
+	const sessionId = getVal(argv, "--session-id") || "session";
+	cliOverrides.sessionId = sessionId;
+	const portValue = getVal(argv, "--port") || getVal(argv, "-p");
+	if (portValue) cliOverrides.port = parseInt(portValue, 10);
+	const host = getVal(argv, "--host") || getVal(argv, "-h");
+	if (host) cliOverrides.host = host;
+	const apiKey = getVal(argv, "--api-key") || getVal(argv, "--key") || getVal(argv, "-k");
+	if (apiKey) cliOverrides.apiKey = apiKey;
+	const logLevel = getVal(argv, "--log-level");
+	if (logLevel) cliOverrides.logLevel = logLevel;
+	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;
+	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;
+	if (argv.includes("--ephemeral")) cliOverrides.ephemeral = true;
+	const qrTimeout = getVal(argv, "--qr-timeout");
+	if (qrTimeout) cliOverrides.qrTimeout = parseInt(qrTimeout, 10);
+	const dashboardPort = getVal(argv, "--dashboard-port");
+	if (dashboardPort) cliOverrides.dashboardPort = parseInt(dashboardPort, 10);
+	const licenseKey = getVal(argv, "--license-key") || getVal(argv, "-l");
+	if (licenseKey) cliOverrides.licenseKey = licenseKey;
+	const webhook = getVal(argv, "--webhook") || getVal(argv, "-w");
+	if (webhook) cliOverrides.webhook = webhook;
+	const proxyHost = getVal(argv, "--proxy-host");
+	if (proxyHost) cliOverrides.proxyHost = proxyHost;
+	const proxyToken = getVal(argv, "--proxy-token");
+	if (proxyToken) cliOverrides.proxyToken = proxyToken;
+	const readyWebhook = getVal(argv, "--ready-webhook");
+	if (readyWebhook) unsupportedWarnings.push(`--ready-webhook was provided (${readyWebhook}) but ready-webhook delivery is not yet wired in v5 CLI.`);
+	if (argv.includes("-v") || argv.includes("--verbose")) {
+		verbose = true;
+		cliOverrides.disableSpins = true;
+		cliOverrides.logConsole = true;
+		cliOverrides.logLevel = cliOverrides.logLevel || "debug";
+	}
+	if (argv.includes("--stats")) unsupportedWarnings.push("--stats was provided but swagger-stats parity is not restored; v5 only exposes the compatibility redirect/deprecation route.");
+	if (argv.includes("--generate-api-docs")) unsupportedWarnings.push("--generate-api-docs was provided; runtime docs are always served from the shared API layer and no separate collection generation step currently runs at CLI boot.");
+	if (argv.includes("--tunnel")) unsupportedWarnings.push("--tunnel was provided but tunnel setup parity is not yet restored in the v5 CLI.");
+	if (argv.includes("--chatwoot-url") || argv.includes("--twilio-webhook") || argv.includes("--bot-press-url")) unsupportedWarnings.push("Legacy integration flags (Chatwoot/Twilio/BotPress) were provided but are not yet wired into the v5 CLI boot path.");
+	if (argv.includes("--use-session-id-in-path")) cliOverrides.sessionId = sessionId;
+	configPath = getVal(argv, "--config") || getVal(argv, "-c");
+	return {
+		procName: getVal(argv, "--name") || sessionId || "@OPEN-WA EASY API",
+		pm2: argv.includes("--pm2"),
+		forwardedArgs: argv,
+		configPath,
+		cliOverrides,
+		verbose,
+		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
+	};
+}
+function printStartupSummary(config, resolution, preferLocalChrome, engineLabel) {
+	const host = config.host.includes("http") ? config.host : `http://${config.host}`;
+	const sink = getCliOutputSink();
+	sink.write({
+		level: "info",
+		message: `Easy API session: ${config.sessionId}`
+	});
+	sink.write({
+		level: "info",
+		message: `Health: ${host}:${config.port}/health`
+	});
+	sink.write({
+		level: "info",
+		message: `API Explorer: ${host}:${config.port}/api-docs/`
+	});
+	sink.write({
+		level: "info",
+		message: `Swagger JSON: ${host}:${config.port}/meta/swagger.json`
+	});
+	sink.write({
+		level: "info",
+		message: `Postman JSON: ${host}:${config.port}/meta/postman.json`
+	});
+	sink.write({
+		level: "info",
+		message: `Browser mode: ${config.headless ? "headless" : "headful"}`
+	});
+	sink.write({
+		level: "info",
+		message: `Browser engine: ${engineLabel}`
+	});
+	if (config.dashboard) sink.write({
+		level: "info",
+		message: `Dashboard: ${host}:${config.port}/dashboard/`
+	});
+	else sink.write({
+		level: "info",
+		message: "Dashboard: disabled (--no-dashboard)"
+	});
+	if (resolution.source === "lightpanda_config" && resolution.executablePath) sink.write({
+		level: "info",
+		message: `Browser executable: explicit Lightpanda override (${resolution.executablePath})`
+	});
+	else if (resolution.source === "lightpanda_sdk_default") sink.write({
+		level: "info",
+		message: "Browser executable: Lightpanda SDK managed executable (shared cache/default resolution)"
+	});
+	else if (resolution.source === "config" && config.executablePath) sink.write({
+		level: "info",
+		message: `Browser executable: explicit override (${config.executablePath})`
+	});
+	else if (resolution.source === "cache") sink.write({
+		level: "info",
+		message: `Browser executable: local Chrome from cache (${resolution.executablePath})`
+	});
+	else if (resolution.source === "chrome_installation") sink.write({
+		level: "info",
+		message: `Browser executable: local Chrome detected (${resolution.executablePath})`
+	});
+	else if (preferLocalChrome) sink.write({
+		level: "info",
+		message: "Browser executable: driver default fallback (local Chrome unavailable)"
+	});
+	if (config.webhook) sink.write({
+		level: "warn",
+		message: `Webhook configured (${config.webhook}) but v5 CLI webhook registration parity is not yet restored.`
+	});
+}
+async function start(parsedArgs = parseCliArgs()) {
+	const { configPath, cliOverrides, verbose, unsupportedWarnings } = parsedArgs;
+	const sink = getCliOutputSink();
+	sink.status({ phase: "boot" });
+	const { config, sources, configFilePath, rawConfigs } = await (0, _open_wa_config.resolveConfig)({
+		configPath,
+		cliOverrides: {
+			disableSpins: true,
+			apiLifecycle: "hybrid",
+			host: "0.0.0.0",
+			port: 8002,
+			...cliOverrides
+		},
+		includeRawConfigs: true,
+		verbose
+	});
+	if (verbose) {
+		sink.write({
+			level: "info",
+			message: `Config sources: ${sources.join(", ")}`
+		});
+		if (configFilePath) sink.write({
+			level: "info",
+			message: `Config file: ${configFilePath}`
+		});
+	}
+	sink.status({
+		phase: "config.resolved",
+		sessionId: config.sessionId
+	});
+	unsupportedWarnings.forEach((warning) => sink.write({
+		level: "warn",
+		message: `Compatibility warning: ${warning}`
+	}));
+	const { driver, engineLabel, executableResolution, preferLocalChrome } = await selectRuntimeDriver(config, rawConfigs);
+	if (executableResolution.warning) sink.write({
+		level: "warn",
+		message: executableResolution.warning
+	});
+	const server = new WAServer(config);
+	sink.status({
+		phase: "server.starting",
+		sessionId: config.sessionId
+	});
+	await server.start();
+	sink.status({
+		phase: "server.started",
+		sessionId: config.sessionId
+	});
+	printStartupSummary(config, executableResolution, preferLocalChrome, engineLabel);
+	sink.status({
+		phase: "client.starting",
+		sessionId: config.sessionId
+	});
+	sink.write({
+		level: "info",
+		message: "Starting WhatsApp Client..."
+	});
+	const openwaClient = await (0, _open_wa_core.createClient)({
+		sessionId: config.sessionId,
+		driver,
+		deleteSessionDataOnLogout: config.deleteSessionDataOnLogout,
+		killClientOnLogout: config.killClientOnLogout,
+		sessionDataPath: config.sessionDataPath,
+		debug: config.logLevel === "debug" || verbose || 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: executableResolution.executablePath,
+		browserArgs: config.chromiumArgs,
+		userDataDir: config.userDataDir,
+		ephemeral: config.ephemeral,
+		logConsole: config.logConsole,
+		logConsoleErrors: config.logConsoleErrors,
+		blockCrashLogs: config.blockCrashLogs,
+		blockAssets: config.blockAssets,
+		safeMode: config.safeMode,
+		licenseKey: config.licenseKey
+	});
+	server.setReadinessProvider(() => ({
+		...openwaClient.getReadiness(),
+		state: openwaClient.getState()
+	}));
+	const detachLaunchNarration = attachLaunchNarration(openwaClient, sink, config.sessionId);
+	openwaClient.events.on("launch.auth.qr.generated", (event) => {
+		const qr = event.details?.qr;
+		if (!qr) return;
+		if (config.qrLogSkip) sink.write({
+			level: "info",
+			message: "New QR Code generated. Not printing in console because qrLogSkip is set to true"
+		});
+		else {
+			sink.status({
+				phase: "auth.qr",
+				sessionId: config.sessionId,
+				detail: "QR code generated"
+			});
+			sink.qr({
+				qr,
+				sessionId: config.sessionId
+			});
+		}
+		server.setQR(qr);
+	});
+	const client = new _open_wa_client.Client({
+		client: openwaClient,
+		transport: openwaClient.getTransport()
+	});
+	server.setClient(client);
+	const runtimeBridgeListeners = /* @__PURE__ */ new Set();
+	const runtimeEventPublishers = [{ publish: (eventName, payload) => {
+		runtimeBridgeListeners.forEach((listener) => {
+			listener(eventName, payload);
+		});
+	} }];
+	const publishRuntimeEvent = (eventName, payload) => {
+		runtimeEventPublishers.forEach((publisher) => {
+			publisher.publish(eventName, payload);
+		});
+	};
+	bridgeRuntimeEvents(openwaClient, publishRuntimeEvent);
+	if (typeof server.setEventBridge === "function") server.setEventBridge({
+		onAny: (listener) => {
+			runtimeBridgeListeners.add(listener);
+		},
+		offAny: (listener) => {
+			runtimeBridgeListeners.delete(listener);
+		}
+	});
+	openwaClient.events.on("launch.browser.init.after", async () => {
+		const page = openwaClient.getTransport().getPage();
+		if (page) await server.setPage(page).catch(() => {});
+	});
+	try {
+		await client.start();
+	} catch (startError) {
+		const msg = startError instanceof Error ? startError.message : String(startError);
+		sink.write({
+			level: "error",
+			message: `Bootstrap failed: ${msg}`
+		});
+		sink.write({
+			level: "warn",
+			message: "Session kept alive for debugging. Browser page is still open."
+		});
+		sink.write({
+			level: "warn",
+			message: "The server is running — use /health and /api-docs to inspect state."
+		});
+		detachLaunchNarration();
+		return {
+			server,
+			client,
+			config,
+			events: openwaClient.events
+		};
+	}
+	const readiness = openwaClient.getReadiness();
+	sink.status({
+		phase: "client.ready",
+		sessionId: config.sessionId,
+		detail: `status=${readiness.status}, exposureSafe=${readiness.exposureSafe}`
+	});
+	sink.write({
+		level: "info",
+		message: `WhatsApp Client ready with state: ${client.getState()} (status=${readiness.status}, exposureSafe=${readiness.exposureSafe})`
+	});
+	detachLaunchNarration();
+	return {
+		server,
+		client,
+		config,
+		events: openwaClient.events
+	};
+}
+async function main(argv = process.argv.slice(2)) {
+	const parsedArgs = parseCliArgs(argv);
+	if (parsedArgs.pm2) {
+		const { spawn } = require("child_process");
+		const sink = getCliOutputSink();
+		const pm2Command = getPm2Command();
+		const pm2SpawnOptions = getPm2SpawnOptions();
+		try {
+			const pm2 = spawn(pm2Command, ["--version"], pm2SpawnOptions);
+			await new Promise((resolve, reject) => {
+				pm2.on("error", reject);
+				pm2.on("exit", (code) => {
+					if (code === 0) {
+						resolve();
+						return;
+					}
+					reject(/* @__PURE__ */ new Error(`pm2 probe exited with code ${code ?? "unknown"}`));
+				});
+				pm2.stdout.on("data", () => resolve());
+			});
+			const pm2Flags = parsedArgs.forwardedArgs.filter((flag) => flag !== "--pm2");
+			spawn(pm2Command, [
+				"start",
+				(0, node_url.fileURLToPath)(new URL("../dist/cli.cjs", require("url").pathToFileURL(__filename).href)),
+				"--name",
+				parsedArgs.procName,
+				"--stop-exit-codes",
+				"88",
+				"--",
+				...pm2Flags
+			], {
+				...pm2SpawnOptions,
+				stdio: "inherit",
+				detached: true
+			});
+			return;
+		} catch (error) {
+			if (isCommandNotFoundError(error)) {
+				sink.write({
+					level: "error",
+					message: "pm2 not found. Please install with: npm install -g pm2"
+				});
+				return;
+			}
+			throw error;
+		}
+	}
+	return await start(parsedArgs);
+}
+function getPm2Command() {
+	return process.platform === "win32" ? "pm2.cmd" : "pm2";
+}
+function getPm2SpawnOptions() {
+	return { shell: process.platform === "win32" };
+}
+function isCommandNotFoundError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const systemError = error;
+	return systemError.code === "ENOENT" || systemError.errno === -2;
+}
+//#endregion
+Object.defineProperty(exports, "WAServer", {
+	enumerable: true,
+	get: function() {
+		return WAServer;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "createConsoleOutputSink", {
+	enumerable: true,
+	get: function() {
+		return createConsoleOutputSink;
+	}
+});
+Object.defineProperty(exports, "getCliOutputSink", {
+	enumerable: true,
+	get: function() {
+		return getCliOutputSink;
+	}
+});
+Object.defineProperty(exports, "main", {
+	enumerable: true,
+	get: function() {
+		return main;
+	}
+});
+Object.defineProperty(exports, "parseCliArgs", {
+	enumerable: true,
+	get: function() {
+		return parseCliArgs;
+	}
+});
+Object.defineProperty(exports, "resetCliOutputSink", {
+	enumerable: true,
+	get: function() {
+		return resetCliOutputSink;
+	}
+});
+Object.defineProperty(exports, "setCliOutputSink", {
+	enumerable: true,
+	get: function() {
+		return setCliOutputSink;
+	}
+});
+Object.defineProperty(exports, "start", {
+	enumerable: true,
+	get: function() {
+		return start;
+	}
+});
+
+//# sourceMappingURL=cli-runtime-B7_3MM0c.cjs.map