miladyai 2.0.0-alpha.27

package/dist/services/stream-manager.js

@@ -0,0 +1,236 @@
+import { logger } from "@elizaos/core";
+import { spawn } from "node:child_process";
+
+//#region src/services/stream-manager.ts
+/**
+* Stream Manager — macOS-compatible RTMP streaming via FFmpeg.
+*
+* Supports three input modes:
+* - "pipe": Receives JPEG frames via writeFrame() → FFmpeg stdin (image2pipe).
+*   Used for streaming Electron window contents captured with capturePage().
+* - "avfoundation": macOS screen capture via avfoundation device.
+* - "testsrc": Solid color test pattern (default fallback).
+*
+* Usage:
+*   import { streamManager } from "./services/stream-manager";
+*   await streamManager.start({ rtmpUrl, rtmpKey, inputMode: "pipe" });
+*   streamManager.writeFrame(jpegBuffer); // called from frame capture
+*   await streamManager.stop();
+*
+* @module services/stream-manager
+*/
+const TAG = "[StreamManager]";
+var StreamManager = class {
+	constructor() {
+		this.ffmpeg = null;
+		this._running = false;
+		this.startedAt = null;
+		this._frameCount = 0;
+	}
+	isRunning() {
+		return this._running;
+	}
+	getUptime() {
+		if (!this.startedAt) return 0;
+		return Math.floor((Date.now() - this.startedAt) / 1e3);
+	}
+	getHealth() {
+		return {
+			running: this._running,
+			ffmpegAlive: this.ffmpeg !== null && this.ffmpeg.exitCode === null && !this.ffmpeg.killed,
+			uptime: this.getUptime(),
+			frameCount: this._frameCount
+		};
+	}
+	/**
+	* Write a JPEG frame to FFmpeg's stdin (only works in "pipe" mode).
+	* Returns true if the frame was accepted.
+	*/
+	writeFrame(jpegData) {
+		if (!this._running || !this.ffmpeg || !this.ffmpeg.stdin) return false;
+		if (this.ffmpeg.killed || this.ffmpeg.exitCode !== null) return false;
+		try {
+			this.ffmpeg.stdin.write(jpegData);
+			this._frameCount++;
+			if (this._frameCount % 150 === 0) logger.info(`${TAG} Piped ${this._frameCount} frames to FFmpeg`);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async start(config) {
+		if (this._running) {
+			logger.warn(`${TAG} Already running — stop first`);
+			return;
+		}
+		this._frameCount = 0;
+		const resolution = config.resolution || "1280x720";
+		const bitrate = config.bitrate || "2500k";
+		const framerate = config.framerate || 15;
+		const rtmpTarget = `${config.rtmpUrl}/${config.rtmpKey}`;
+		const bufsize = `${parseInt(bitrate, 10) * 2}k`;
+		const mode = config.inputMode || "testsrc";
+		const inputArgs = this.buildInputArgs(config, resolution, framerate);
+		const isPipe = mode === "pipe";
+		const isScreenCapture = mode === "avfoundation" || mode === "screen";
+		const ffmpegArgs = [
+			"-thread_queue_size",
+			"512",
+			...inputArgs,
+			"-f",
+			"lavfi",
+			"-i",
+			"anullsrc=channel_layout=stereo:sample_rate=44100",
+			...isScreenCapture ? ["-vf", `scale=${resolution.replace("x", ":")}:flags=fast_bilinear`] : [],
+			...process.platform === "darwin" ? [
+				"-c:v",
+				"h264_videotoolbox",
+				"-realtime",
+				"1",
+				"-b:v",
+				bitrate,
+				"-maxrate",
+				bitrate,
+				"-bufsize",
+				bufsize
+			] : [
+				"-c:v",
+				"libx264",
+				"-preset",
+				"veryfast",
+				"-tune",
+				"zerolatency",
+				"-b:v",
+				bitrate,
+				"-maxrate",
+				bitrate,
+				"-bufsize",
+				bufsize
+			],
+			"-s",
+			resolution,
+			"-pix_fmt",
+			"yuv420p",
+			"-g",
+			"60",
+			"-c:a",
+			"aac",
+			"-b:a",
+			"128k",
+			"-f",
+			"flv",
+			rtmpTarget
+		];
+		logger.info(`${TAG} Starting FFmpeg RTMP stream (mode=${mode}) to ${config.rtmpUrl}`);
+		logger.info(`${TAG} Resolution: ${resolution}, Bitrate: ${bitrate}, FPS: ${framerate}`);
+		this.ffmpeg = spawn("ffmpeg", ["-y", ...ffmpegArgs], { stdio: [
+			isPipe ? "pipe" : "ignore",
+			"pipe",
+			"pipe"
+		] });
+		this.ffmpeg.stderr?.on("data", (chunk) => {
+			const line = chunk.toString().trim();
+			if (line) console.log(`[FFmpeg] ${line}`);
+		});
+		this.ffmpeg.on("exit", (code, signal) => {
+			if (this._running) {
+				logger.warn(`${TAG} FFmpeg exited unexpectedly (code=${code}, signal=${signal})`);
+				this._running = false;
+				this.startedAt = null;
+			}
+		});
+		if (isPipe && this.ffmpeg.stdin) this.ffmpeg.stdin.on("error", (err) => {
+			logger.warn(`${TAG} FFmpeg stdin error: ${err.message}`);
+		});
+		await new Promise((r) => setTimeout(r, 1500));
+		if (this.ffmpeg.exitCode !== null) {
+			const exitCode = this.ffmpeg.exitCode;
+			this.ffmpeg = null;
+			throw new Error(`${TAG} FFmpeg exited immediately with code ${exitCode}`);
+		}
+		this._running = true;
+		this.startedAt = Date.now();
+		logger.info(`${TAG} FFmpeg streaming to RTMP — stream should be live`);
+	}
+	async stop() {
+		const uptime = this.getUptime();
+		if (this.ffmpeg && !this.ffmpeg.killed && this.ffmpeg.exitCode === null) {
+			const ffmpegProc = this.ffmpeg;
+			if (ffmpegProc.stdin) try {
+				ffmpegProc.stdin.end();
+			} catch {}
+			ffmpegProc.kill("SIGTERM");
+			await Promise.race([new Promise((resolve) => ffmpegProc.on("exit", resolve)), new Promise((resolve) => setTimeout(resolve, 3e3))]);
+			if (ffmpegProc.exitCode === null) ffmpegProc.kill("SIGKILL");
+		}
+		this.ffmpeg = null;
+		this._running = false;
+		this.startedAt = null;
+		this._frameCount = 0;
+		logger.info(`${TAG} Stream stopped (uptime: ${uptime}s, frames: ${this._frameCount})`);
+		return { uptime };
+	}
+	buildInputArgs(config, resolution, framerate) {
+		switch (config.inputMode || "testsrc") {
+			case "pipe": return [
+				"-probesize",
+				"32",
+				"-analyzeduration",
+				"0",
+				"-f",
+				"image2pipe",
+				"-c:v",
+				"mjpeg",
+				"-framerate",
+				String(framerate),
+				"-i",
+				"pipe:0"
+			];
+			case "avfoundation":
+			case "screen": {
+				const videoDevice = config.videoDevice || "3";
+				return [
+					"-f",
+					"avfoundation",
+					"-framerate",
+					String(framerate),
+					"-pixel_format",
+					"nv12",
+					"-capture_cursor",
+					"1",
+					"-i",
+					`${videoDevice}:none`
+				];
+			}
+			case "file": {
+				const framePath = config.frameFile || "/tmp/milady-stream-frame.jpg";
+				return [
+					"-probesize",
+					"32",
+					"-analyzeduration",
+					"0",
+					"-loop",
+					"1",
+					"-f",
+					"image2",
+					"-c:v",
+					"mjpeg",
+					"-framerate",
+					String(framerate),
+					"-i",
+					framePath
+				];
+			}
+			default: return [
+				"-f",
+				"lavfi",
+				"-i",
+				`color=c=0x1a1a2e:s=${resolution}:r=${framerate}`
+			];
+		}
+	}
+};
+const streamManager = new StreamManager();
+
+//#endregion
+export { streamManager };

package/dist/services/update-checker.js

@@ -0,0 +1,121 @@
+import { loadMiladyConfig, saveMiladyConfig } from "../config/config.js";
+import { VERSION } from "../runtime/version.js";
+import { compareSemver } from "./version-compat.js";
+
+//#region src/services/update-checker.ts
+/**
+* Queries the npm registry for new miladyai versions on the user's
+* configured release channel (stable/beta/nightly).
+*/
+const CHECK_INTERVAL_SECONDS = 14400;
+const REGISTRY_TIMEOUT_MS = 8e3;
+const NPM_REGISTRY_PACKUMENT_URL = "https://registry.npmjs.org/miladyai";
+/** npm dist-tag corresponding to each release channel. */
+const CHANNEL_DIST_TAGS = {
+	stable: "latest",
+	beta: "beta",
+	nightly: "nightly"
+};
+/** Fetch dist-tags from the npm registry. Returns null on any failure. */
+async function fetchDistTags() {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+	try {
+		const res = await fetch(NPM_REGISTRY_PACKUMENT_URL, {
+			headers: { Accept: "application/vnd.npm.install-v1+json" },
+			signal: controller.signal
+		});
+		if (!res.ok) return null;
+		return (await res.json())["dist-tags"] ?? null;
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function shouldSkipCheck(cfg) {
+	if (!cfg?.lastCheckAt) return false;
+	const interval = cfg.checkIntervalSeconds ?? CHECK_INTERVAL_SECONDS;
+	return (Date.now() - new Date(cfg.lastCheckAt).getTime()) / 1e3 < interval;
+}
+/** Resolve the effective release channel from config, env, or default. */
+function resolveChannel(cfg) {
+	const env = process.env.MILADY_UPDATE_CHANNEL?.trim().toLowerCase();
+	if (env === "stable" || env === "beta" || env === "nightly") return env;
+	return cfg?.channel ?? "stable";
+}
+/**
+* Check whether a newer version is available.
+* Respects the check interval; pass `force: true` to bypass.
+*/
+async function checkForUpdate(options) {
+	const config = loadMiladyConfig();
+	const updateCfg = config.update;
+	const channel = resolveChannel(updateCfg);
+	const distTag = CHANNEL_DIST_TAGS[channel];
+	if (!options?.force && shouldSkipCheck(updateCfg)) return {
+		updateAvailable: updateCfg?.lastCheckVersion ? (compareSemver(VERSION, updateCfg.lastCheckVersion) ?? 0) < 0 : false,
+		currentVersion: VERSION,
+		latestVersion: updateCfg?.lastCheckVersion ?? null,
+		channel,
+		distTag,
+		cached: true,
+		error: null
+	};
+	const distTags = await fetchDistTags();
+	if (!distTags) return {
+		updateAvailable: false,
+		currentVersion: VERSION,
+		latestVersion: null,
+		channel,
+		distTag,
+		cached: false,
+		error: "Unable to reach the npm registry. Check your network connection."
+	};
+	const latestVersion = distTags[distTag] ?? null;
+	if (!latestVersion) return {
+		updateAvailable: false,
+		currentVersion: VERSION,
+		latestVersion: null,
+		channel,
+		distTag,
+		cached: false,
+		error: `No version found for dist-tag "${distTag}". The "${channel}" channel may not have any published releases yet.`
+	};
+	const cmp = compareSemver(VERSION, latestVersion);
+	const updateAvailable = cmp !== null && cmp < 0;
+	try {
+		saveMiladyConfig({
+			...config,
+			update: {
+				...config.update,
+				lastCheckAt: (/* @__PURE__ */ new Date()).toISOString(),
+				lastCheckVersion: latestVersion
+			}
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`[milady] Warning: could not save update-check metadata: ${msg}\n`);
+	}
+	return {
+		updateAvailable,
+		currentVersion: VERSION,
+		latestVersion,
+		channel,
+		distTag,
+		cached: false,
+		error: null
+	};
+}
+/** Returns the latest published version for each channel. */
+async function fetchAllChannelVersions() {
+	const distTags = await fetchDistTags();
+	return {
+		stable: distTags?.latest ?? null,
+		beta: distTags?.beta ?? null,
+		nightly: distTags?.nightly ?? null
+	};
+}
+
+//#endregion
+export { CHANNEL_DIST_TAGS, checkForUpdate, fetchAllChannelVersions, resolveChannel };

package/dist/services/update-notifier.js

@@ -0,0 +1,29 @@
+import { loadMiladyConfig } from "../config/config.js";
+import { theme } from "../terminal/theme.js";
+import { checkForUpdate, resolveChannel } from "./update-checker.js";
+
+//#region src/services/update-notifier.ts
+/**
+* Fire-and-forget background update check. Prints a one-line notice
+* to stderr if a newer version is available (like npm's update-notifier).
+*/
+let notified = false;
+function scheduleUpdateNotification() {
+	if (notified) return;
+	notified = true;
+	let config = {};
+	try {
+		config = loadMiladyConfig();
+	} catch {}
+	if (config.update?.checkOnStart === false) return;
+	if (process.env.CI || !process.stderr.isTTY) return;
+	checkForUpdate().then((result) => {
+		if (!result.updateAvailable || !result.latestVersion) return;
+		const channel = resolveChannel(config.update);
+		const suffix = channel !== "stable" ? ` (${channel})` : "";
+		process.stderr.write(`\n${theme.accent("Update available:")} ${theme.muted(result.currentVersion)} -> ${theme.success(result.latestVersion)}${theme.muted(suffix)}\n${theme.muted("Run")} ${theme.command("milady update")} ${theme.muted("to install")}\n\n`);
+	}).catch(() => {});
+}
+
+//#endregion
+export { scheduleUpdateNotification };

package/dist/services/version-compat.js

@@ -0,0 +1,78 @@
+//#region src/services/version-compat.ts
+/**
+* Plugins that provide AI model capabilities. If ALL of these fail to load
+* the agent is completely non-functional — no responses can be generated.
+*/
+const AI_PROVIDER_PLUGINS = [
+	"@elizaos/plugin-anthropic",
+	"@elizaos/plugin-openai",
+	"@elizaos/plugin-openrouter",
+	"@elizaos/plugin-ollama",
+	"@elizaos/plugin-google-genai",
+	"@elizaos/plugin-groq",
+	"@elizaos/plugin-xai",
+	"@homunculuslabs/plugin-zai",
+	"@elizaos/plugin-pi-ai",
+	"@elizaos/plugin-elizacloud"
+];
+/**
+* Parse a semver string (including pre-release tags) into a comparable tuple.
+* Returns null for unparseable versions.
+*
+* Examples:
+*   "2.0.0-alpha.3"          → [2, 0, 0, 3]
+*   "2.0.0-alpha.4"          → [2, 0, 0, 4]
+*   "2.0.0-nightly.20260208" → [2, 0, 0, 20260208]
+*   "2.0.0"                  → [2, 0, 0, Infinity]  (release beats any pre-release)
+*
+* Note: comparisons are only meaningful within the same pre-release tag type
+* (alpha vs alpha, nightly vs nightly). Cross-tag comparisons (alpha.7 vs beta.1)
+* compare only the numeric suffix, which may not reflect the intended ordering.
+* The update checker always compares within the same channel, so this is safe.
+*/
+function parseSemver(version) {
+	const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(?:alpha|beta|rc|nightly)\.(\d+))?$/);
+	if (!match) return null;
+	return [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3]),
+		match[4] !== void 0 ? Number(match[4]) : Number.POSITIVE_INFINITY
+	];
+}
+/**
+* Compare two semver strings. Returns:
+*   -1 if a < b
+*    0 if a === b
+*    1 if a > b
+*   null if either version is unparseable.
+*/
+function compareSemver(a, b) {
+	const pa = parseSemver(a);
+	const pb = parseSemver(b);
+	if (!pa || !pb) return null;
+	for (let i = 0; i < 4; i++) {
+		if (pa[i] < pb[i]) return -1;
+		if (pa[i] > pb[i]) return 1;
+	}
+	return 0;
+}
+/**
+* After plugin resolution, check whether at least one AI provider plugin
+* loaded successfully. If none loaded, return a diagnostic message explaining
+* whether this is a version-skew issue or a configuration issue.
+*
+* @param loadedPluginNames - Names of plugins that loaded successfully.
+* @param failedPlugins - Names + error strings of plugins that failed to load.
+*/
+function diagnoseNoAIProvider(loadedPluginNames, failedPlugins) {
+	if (loadedPluginNames.filter((n) => AI_PROVIDER_PLUGINS.includes(n)).length > 0) return null;
+	const failedProviders = failedPlugins.filter((f) => AI_PROVIDER_PLUGINS.includes(f.name));
+	if (failedProviders.length === 0) return "No AI provider plugin was loaded. Set an API key environment variable (e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY) or log in to Eliza Cloud (ELIZAOS_CLOUD_API_KEY) to enable at least one model provider.";
+	const versionSkewPlugins = failedProviders.filter((f) => f.error.includes("not found in module") || f.error.includes("Export named") || f.error.includes("does not provide an export named"));
+	if (versionSkewPlugins.length > 0) return `Version skew detected: ${versionSkewPlugins.map((f) => f.name).join(", ")} failed to import required symbols from @elizaos/core. This usually means the plugin version is ahead of the installed core version. Pin the affected plugins to a version compatible with your installed @elizaos/core, or upgrade core. See: https://github.com/milady-ai/milady/issues/10`;
+	return `All AI provider plugins failed to load:\n${failedProviders.map((f) => `  ${f.name}: ${f.error}`).join("\n")}`;
+}
+
+//#endregion
+export { compareSemver, diagnoseNoAIProvider };

package/dist/services/whatsapp-pairing.js

@@ -0,0 +1,196 @@
+import path from "node:path";
+import fs from "node:fs";
+
+//#region src/services/whatsapp-pairing.ts
+/**
+* WhatsApp pairing service — manages Baileys sessions for QR code authentication.
+*
+* This service is separate from `@elizaos/plugin-whatsapp` because the plugin
+* initializes during runtime startup (too late for interactive QR flow).
+* Once pairing succeeds, the auth state is persisted to disk so the plugin
+* can reconnect automatically on subsequent startups.
+*/
+const LOG_PREFIX = "[whatsapp-pairing]";
+/** Validate accountId to prevent path traversal. Only allows alphanumeric, dash, underscore. */
+function sanitizeAccountId(raw) {
+	const cleaned = raw.replace(/[^a-zA-Z0-9_-]/g, "");
+	if (!cleaned || cleaned !== raw) throw new Error(`Invalid accountId: must only contain alphanumeric characters, dashes, and underscores`);
+	return cleaned;
+}
+var WhatsAppPairingSession = class {
+	constructor(options) {
+		this.socket = null;
+		this.status = "idle";
+		this.qrAttempts = 0;
+		this.MAX_QR_ATTEMPTS = 5;
+		this.restartTimer = null;
+		this.options = options;
+	}
+	async start() {
+		this.setStatus("initializing");
+		const baileys = await import("@whiskeysockets/baileys");
+		const makeWASocket = baileys.default;
+		const { useMultiFileAuthState, fetchLatestBaileysVersion, DisconnectReason } = baileys;
+		const QRCode = (await import("qrcode")).default;
+		const { Boom } = await import("@hapi/boom");
+		fs.mkdirSync(this.options.authDir, { recursive: true });
+		const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir);
+		const { version } = await fetchLatestBaileysVersion();
+		const pino = (await import("pino")).default;
+		this.socket = makeWASocket({
+			version,
+			auth: state,
+			logger: pino({ level: "silent" }),
+			printQRInTerminal: false,
+			browser: [
+				"Milady AI",
+				"Desktop",
+				"1.0.0"
+			]
+		});
+		this.socket.ev.on("creds.update", saveCreds);
+		this.socket.ev.on("connection.update", async (update) => {
+			const { connection, lastDisconnect, qr } = update;
+			if (qr) {
+				this.qrAttempts++;
+				console.info(`${LOG_PREFIX} QR code received (attempt ${this.qrAttempts}/${this.MAX_QR_ATTEMPTS})`);
+				if (this.qrAttempts > this.MAX_QR_ATTEMPTS) {
+					this.setStatus("timeout");
+					this.stop();
+					return;
+				}
+				try {
+					const qrDataUrl = await QRCode.toDataURL(qr, {
+						width: 256,
+						margin: 2,
+						color: {
+							dark: "#000000",
+							light: "#ffffff"
+						}
+					});
+					this.setStatus("waiting_for_qr");
+					this.options.onEvent({
+						type: "whatsapp-qr",
+						accountId: this.options.accountId,
+						qrDataUrl,
+						expiresInMs: 2e4
+					});
+				} catch {}
+			}
+			if (connection === "close") {
+				const statusCode = (lastDisconnect?.error)?.output?.statusCode;
+				console.info(`${LOG_PREFIX} Connection closed, statusCode=${statusCode}, status=${this.status}`);
+				if (statusCode === DisconnectReason.loggedOut) this.setStatus("disconnected");
+				else if (statusCode === DisconnectReason.restartRequired || statusCode === DisconnectReason.timedOut || statusCode === DisconnectReason.connectionClosed || statusCode === DisconnectReason.connectionReplaced) {
+					console.info(`${LOG_PREFIX} Restarting pairing after transient close...`);
+					this.socket = null;
+					this.qrAttempts = 0;
+					this.restartTimer = setTimeout(() => {
+						this.restartTimer = null;
+						this.start().catch((err) => {
+							console.error(`${LOG_PREFIX} Restart failed:`, err);
+							this.setStatus("error");
+							this.options.onEvent({
+								type: "whatsapp-status",
+								accountId: this.options.accountId,
+								status: "error",
+								error: err instanceof Error ? err.message : String(err)
+							});
+						});
+					}, 3e3);
+				}
+			} else if (connection === "open") {
+				const phoneNumber = this.socket?.user?.id?.split(":")[0] ?? "";
+				this.setStatus("connected");
+				this.options.onEvent({
+					type: "whatsapp-status",
+					accountId: this.options.accountId,
+					status: "connected",
+					phoneNumber
+				});
+			}
+		});
+	}
+	stop() {
+		if (this.restartTimer) {
+			clearTimeout(this.restartTimer);
+			this.restartTimer = null;
+		}
+		try {
+			this.socket?.end(void 0);
+		} catch {}
+		this.socket = null;
+	}
+	getStatus() {
+		return this.status;
+	}
+	setStatus(status) {
+		this.status = status;
+		this.options.onEvent({
+			type: "whatsapp-status",
+			accountId: this.options.accountId,
+			status
+		});
+	}
+};
+/**
+* Check if WhatsApp auth credentials exist on disk for an account.
+*/
+function whatsappAuthExists(workspaceDir, accountId = "default") {
+	const credsPath = path.join(workspaceDir, "whatsapp-auth", accountId, "creds.json");
+	return fs.existsSync(credsPath);
+}
+/**
+* Properly logout from WhatsApp (unlinks the device on WhatsApp servers)
+* then delete auth files from disk.
+*/
+async function whatsappLogout(workspaceDir, accountId = "default") {
+	const authDir = path.join(workspaceDir, "whatsapp-auth", accountId);
+	const credsPath = path.join(authDir, "creds.json");
+	if (fs.existsSync(credsPath)) try {
+		const baileys = await import("@whiskeysockets/baileys");
+		const makeWASocket = baileys.default;
+		const { useMultiFileAuthState, fetchLatestBaileysVersion } = baileys;
+		const pino = (await import("pino")).default;
+		const logger = pino({ level: "silent" });
+		const { state } = await useMultiFileAuthState(authDir);
+		const { version } = await fetchLatestBaileysVersion();
+		const sock = makeWASocket({
+			version,
+			auth: state,
+			logger,
+			printQRInTerminal: false
+		});
+		await new Promise((resolve) => {
+			let settled = false;
+			const finish = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timeout);
+				try {
+					sock.ev.removeAllListeners("connection.update");
+				} catch {}
+				try {
+					sock.end(void 0);
+				} catch {}
+				resolve();
+			};
+			const timeout = setTimeout(finish, 1e4);
+			sock.ev.on("connection.update", async (update) => {
+				if (update.connection === "open") {
+					try {
+						await sock.logout();
+					} catch {}
+					finish();
+				} else if (update.connection === "close") finish();
+			});
+		});
+	} catch {}
+	fs.rmSync(authDir, {
+		recursive: true,
+		force: true
+	});
+}
+
+//#endregion
+export { WhatsAppPairingSession, sanitizeAccountId, whatsappAuthExists, whatsappLogout };