@pixelzx/genesis 2026.5.10-2 → 2026.5.10-3

package/dist/channel.runtime-Ccnjrmpx.js

@@ -0,0 +1,109 @@
+import { u as normalizeSecretInputString } from "./types.secrets-ews2W8BF.js";
+import { t as createAccountStatusSink } from "./channel-lifecycle.core-kAT8FKLv.js";
+import { t as PAIRING_APPROVED_MESSAGE } from "./pairing-message-DuN8JQxM.js";
+import "./channel-lifecycle-DCFyHvPV.js";
+import "./accounts-CBI-56kp.js";
+import "./runtime-api-BJ2r-OR5.js";
+import { i as getMe, n as ZaloApiError, t as resolveZaloProxyFetch } from "./proxy-4EAwkNli.js";
+import { t as sendMessageZalo } from "./send-CSAuufSI.js";
+//#region extensions/zalo/src/probe.ts
+async function probeZalo(token, timeoutMs = 5e3, fetcher) {
+	if (!token?.trim()) return {
+		ok: false,
+		error: "No token provided",
+		elapsedMs: 0
+	};
+	const startTime = Date.now();
+	try {
+		const response = await getMe(token.trim(), timeoutMs, fetcher);
+		const elapsedMs = Date.now() - startTime;
+		if (response.ok && response.result) return {
+			ok: true,
+			bot: response.result,
+			elapsedMs
+		};
+		return {
+			ok: false,
+			error: "Invalid response from Zalo API",
+			elapsedMs
+		};
+	} catch (err) {
+		const elapsedMs = Date.now() - startTime;
+		if (err instanceof ZaloApiError) return {
+			ok: false,
+			error: err.description ?? err.message,
+			elapsedMs
+		};
+		if (err instanceof Error) {
+			if (err.name === "AbortError") return {
+				ok: false,
+				error: `Request timed out after ${timeoutMs}ms`,
+				elapsedMs
+			};
+			return {
+				ok: false,
+				error: err.message,
+				elapsedMs
+			};
+		}
+		return {
+			ok: false,
+			error: String(err),
+			elapsedMs
+		};
+	}
+}
+//#endregion
+//#region extensions/zalo/src/channel.runtime.ts
+async function notifyZaloPairingApproval(params) {
+	const { resolveZaloAccount } = await import("./accounts-m2xbhdqn.js");
+	const account = resolveZaloAccount({ cfg: params.cfg });
+	if (!account.token) throw new Error("Zalo token not configured");
+	await sendMessageZalo(params.id, PAIRING_APPROVED_MESSAGE, { token: account.token });
+}
+async function sendZaloText(params) {
+	return await sendMessageZalo(params.to, params.text, params);
+}
+async function probeZaloAccount(params) {
+	return await probeZalo(params.account.token, params.timeoutMs, resolveZaloProxyFetch(params.account.config.proxy));
+}
+async function startZaloGatewayAccount(ctx) {
+	const account = ctx.account;
+	const token = account.token.trim();
+	const mode = account.config.webhookUrl ? "webhook" : "polling";
+	let zaloBotLabel = "";
+	const fetcher = resolveZaloProxyFetch(account.config.proxy);
+	try {
+		const probe = await probeZalo(token, 2500, fetcher);
+		const name = probe.ok ? probe.bot?.name?.trim() : null;
+		if (name) zaloBotLabel = ` (${name})`;
+		if (!probe.ok) ctx.log?.warn?.(`[${account.accountId}] Zalo probe failed before provider start (${String(probe.elapsedMs)}ms): ${probe.error}`);
+		ctx.setStatus({
+			accountId: account.accountId,
+			bot: probe.bot
+		});
+	} catch (err) {
+		ctx.log?.warn?.(`[${account.accountId}] Zalo probe threw before provider start: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+	}
+	const statusSink = createAccountStatusSink({
+		accountId: ctx.accountId,
+		setStatus: ctx.setStatus
+	});
+	ctx.log?.info(`[${account.accountId}] starting provider${zaloBotLabel} mode=${mode}`);
+	const { monitorZaloProvider } = await import("./monitor-G_A80TYD.js");
+	return monitorZaloProvider({
+		token,
+		account,
+		config: ctx.cfg,
+		runtime: ctx.runtime,
+		abortSignal: ctx.abortSignal,
+		useWebhook: Boolean(account.config.webhookUrl),
+		webhookUrl: account.config.webhookUrl,
+		webhookSecret: normalizeSecretInputString(account.config.webhookSecret),
+		webhookPath: account.config.webhookPath,
+		fetcher,
+		statusSink
+	});
+}
+//#endregion
+export { notifyZaloPairingApproval, probeZaloAccount, sendZaloText, startZaloGatewayAccount };

package/dist/channel.runtime-CerUOlEZ.js

@@ -0,0 +1,430 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-C1IzJjqi.js";
+import { t as safeEqualSecret } from "./secret-equal-BBFaVgZ-.js";
+import { _ as resolveRequestClientIp } from "./net-AycWGi8-.js";
+import "./error-runtime-DkAvS9GZ.js";
+import { a as createFixedWindowRateLimiter, r as WEBHOOK_RATE_LIMIT_DEFAULTS } from "./webhook-memory-guards-4Ld6_Poz.js";
+import { a as createWebhookInFlightLimiter, c as readWebhookBodyOrReject } from "./webhook-request-guards--TTJN6hj.js";
+import { t as normalizeWebhookPath } from "./webhook-path-ByVz095n.js";
+import { l as withResolvedWebhookRequestPipeline, n as registerWebhookTargetWithPluginRoute, s as resolveWebhookTargetWithAuthOrRejectSync } from "./webhook-targets-BYzxAp1z.js";
+import "./webhook-ingress-CkKgqbEo.js";
+import "./browser-security-runtime-B69CgcsZ.js";
+import "./string-coerce-runtime-BQR_gdBT.js";
+import { P as resolveBlueBubblesEffectiveAllowPrivateNetwork, _ as normalizeWebhookReaction, g as normalizeWebhookMessage, o as probeBlueBubbles, t as fetchBlueBubblesServerInfo, u as asRecord } from "./probe-BxfJkCo7.js";
+import { t as getBlueBubblesRuntime } from "./runtime-megxqm7R.js";
+import { n as resolveWebhookPathFromConfig } from "./webhook-shared-7kIniMSI.js";
+import { a as resolveBlueBubblesMessageId, b as sendMessageBlueBubbles } from "./reactions-m2szYDeb.js";
+import { i as sendBlueBubblesMedia, n as processMessage, r as processReaction, t as logVerbose } from "./monitor-processing-Du6MiEEU.js";
+//#region extensions/bluebubbles/src/monitor-debounce.ts
+function normalizeDebounceMessageText(text) {
+	return typeof text === "string" ? text : "";
+}
+function sanitizeDebounceEntry(entry) {
+	if (typeof entry.message.text === "string") return entry;
+	return {
+		...entry,
+		message: {
+			...entry.message,
+			text: ""
+		}
+	};
+}
+/**
+* Default debounce window for inbound message coalescing (ms).
+* This helps combine URL text + link preview balloon messages that BlueBubbles
+* sends as separate webhook events when no explicit inbound debounce config exists.
+*/
+const DEFAULT_INBOUND_DEBOUNCE_MS = 500;
+/**
+* Default debounce window when `coalesceSameSenderDms` is enabled.
+*
+* The legacy 500 ms default is tuned for BlueBubbles's own text+balloon
+* pairing, which is typically linked by `associatedMessageGuid` and arrives
+* within ~100-300 ms. The new split-send case this flag targets has a wider
+* cadence — live traces show Apple delivers `Dump` and its pasted-URL
+* balloon ~0.8-2.0 s apart — so 500 ms would flush the text alone before the
+* balloon webhook ever reaches the debouncer. 2500 ms comfortably covers the
+* observed range while keeping agent-reply latency acceptable for DMs. Users
+* who want tighter turnaround can still set `messages.inbound.byChannel.bluebubbles`
+* explicitly.
+*/
+const DEFAULT_COALESCE_INBOUND_DEBOUNCE_MS = 2500;
+/**
+* Bounds on the combined output when multiple inbound events are merged into
+* one agent turn. Guards against amplification from a sender who rapid-fires
+* many small DMs inside the debounce window (concern raised on #69258): the
+* merged text, attachment list, and source-message count are each capped so
+* a flood cannot balloon a single agent prompt beyond a safe ceiling.
+* Callers still see every messageId via inbound-dedupe.
+*/
+const MAX_COALESCED_TEXT_CHARS = 4e3;
+const MAX_COALESCED_ATTACHMENTS = 20;
+const MAX_COALESCED_ENTRIES = 10;
+/**
+* Combines multiple debounced messages into a single message for processing.
+* Used when multiple webhook events arrive within the debounce window.
+*/
+function combineDebounceEntries(entries) {
+	if (entries.length === 0) throw new Error("Cannot combine empty entries");
+	if (entries.length === 1) return entries[0].message;
+	const first = entries[0].message;
+	const boundedEntries = entries.length > MAX_COALESCED_ENTRIES ? [...entries.slice(0, MAX_COALESCED_ENTRIES - 1), entries[entries.length - 1]] : entries;
+	const seenTexts = /* @__PURE__ */ new Set();
+	const textParts = [];
+	for (const entry of boundedEntries) {
+		const text = normalizeDebounceMessageText(entry.message.text).trim();
+		if (!text) continue;
+		const normalizedText = normalizeLowercaseStringOrEmpty(text);
+		if (seenTexts.has(normalizedText)) continue;
+		seenTexts.add(normalizedText);
+		textParts.push(text);
+	}
+	let combinedText = textParts.join(" ");
+	if (combinedText.length > MAX_COALESCED_TEXT_CHARS) combinedText = `${combinedText.slice(0, MAX_COALESCED_TEXT_CHARS)}…[truncated]`;
+	const allAttachments = boundedEntries.flatMap((e) => e.message.attachments ?? []).slice(0, MAX_COALESCED_ATTACHMENTS);
+	const timestamps = entries.map((e) => e.message.timestamp).filter((t) => typeof t === "number");
+	const latestTimestamp = timestamps.length > 0 ? Math.max(...timestamps) : first.timestamp;
+	const messageId = entries.map((e) => e.message.messageId).find((id) => Boolean(id));
+	const seenIds = /* @__PURE__ */ new Set();
+	const coalescedMessageIds = [];
+	for (const entry of entries) {
+		const id = entry.message.messageId?.trim();
+		if (!id || seenIds.has(id)) continue;
+		seenIds.add(id);
+		coalescedMessageIds.push(id);
+	}
+	const entryWithReply = entries.find((e) => e.message.replyToId);
+	return {
+		...first,
+		text: combinedText,
+		attachments: allAttachments.length > 0 ? allAttachments : first.attachments,
+		timestamp: latestTimestamp,
+		messageId: messageId ?? first.messageId,
+		coalescedMessageIds: coalescedMessageIds.length > 0 ? coalescedMessageIds : void 0,
+		replyToId: entryWithReply?.message.replyToId ?? first.replyToId,
+		replyToBody: entryWithReply?.message.replyToBody ?? first.replyToBody,
+		replyToSender: entryWithReply?.message.replyToSender ?? first.replyToSender,
+		balloonBundleId: void 0
+	};
+}
+function resolveBlueBubblesDebounceMs(config, core, accountConfig) {
+	const inbound = config.messages?.inbound;
+	if (!(typeof inbound?.debounceMs === "number" || typeof inbound?.byChannel?.bluebubbles === "number")) return accountConfig.coalesceSameSenderDms ? DEFAULT_COALESCE_INBOUND_DEBOUNCE_MS : DEFAULT_INBOUND_DEBOUNCE_MS;
+	return core.channel.debounce.resolveInboundDebounceMs({
+		cfg: config,
+		channel: "bluebubbles"
+	});
+}
+function createBlueBubblesDebounceRegistry(params) {
+	const targetDebouncers = /* @__PURE__ */ new Map();
+	return {
+		getOrCreateDebouncer: (target) => {
+			const existing = targetDebouncers.get(target);
+			if (existing) return existing;
+			const { account, config, runtime, core } = target;
+			const baseDebouncer = core.channel.debounce.createInboundDebouncer({
+				debounceMs: resolveBlueBubblesDebounceMs(config, core, account.config),
+				buildKey: (entry) => {
+					const msg = entry.message;
+					const balloonBundleId = msg.balloonBundleId?.trim();
+					const associatedMessageGuid = msg.associatedMessageGuid?.trim();
+					if (balloonBundleId && associatedMessageGuid) return `bluebubbles:${account.accountId}:msg:${associatedMessageGuid}`;
+					const chatKey = msg.chatGuid?.trim() ?? msg.chatIdentifier?.trim() ?? (msg.chatId ? String(msg.chatId) : "dm");
+					if (account.config.coalesceSameSenderDms && !msg.isGroup && !associatedMessageGuid) return `bluebubbles:${account.accountId}:dm:${chatKey}:${msg.senderId}`;
+					const messageId = msg.messageId?.trim();
+					if (messageId) return `bluebubbles:${account.accountId}:msg:${messageId}`;
+					return `bluebubbles:${account.accountId}:${chatKey}:${msg.senderId}`;
+				},
+				shouldDebounce: (entry) => {
+					const msg = entry.message;
+					if (msg.fromMe) return false;
+					if (core.channel.text.hasControlCommand(msg.text, config)) {
+						const associatedMessageGuid = msg.associatedMessageGuid?.trim();
+						if (account.config.coalesceSameSenderDms && !msg.isGroup && !associatedMessageGuid) return true;
+						return false;
+					}
+					return true;
+				},
+				onFlush: async (entries) => {
+					if (entries.length === 0) return;
+					const flushTarget = entries[0].target;
+					if (entries.length === 1) {
+						await params.processMessage(entries[0].message, flushTarget);
+						return;
+					}
+					const combined = combineDebounceEntries(entries);
+					if (core.logging.shouldLogVerbose()) {
+						const count = entries.length;
+						const preview = combined.text.slice(0, 50);
+						runtime.log?.(`[bluebubbles] coalesced ${count} messages: "${preview}${combined.text.length > 50 ? "..." : ""}"`);
+					}
+					await params.processMessage(combined, flushTarget);
+				},
+				onError: (err) => {
+					runtime.error?.(`[${account.accountId}] [bluebubbles] debounce flush failed: ${String(err)}`);
+				}
+			});
+			const debouncer = {
+				enqueue: async (item) => {
+					await baseDebouncer.enqueue(sanitizeDebounceEntry(item));
+				},
+				flushKey: (key) => baseDebouncer.flushKey(key)
+			};
+			targetDebouncers.set(target, debouncer);
+			return debouncer;
+		},
+		removeDebouncer: (target) => {
+			targetDebouncers.delete(target);
+		}
+	};
+}
+//#endregion
+//#region extensions/bluebubbles/src/monitor.ts
+const webhookTargets = /* @__PURE__ */ new Map();
+const webhookRateLimiter = createFixedWindowRateLimiter({
+	windowMs: WEBHOOK_RATE_LIMIT_DEFAULTS.windowMs,
+	maxRequests: WEBHOOK_RATE_LIMIT_DEFAULTS.maxRequests,
+	maxTrackedKeys: WEBHOOK_RATE_LIMIT_DEFAULTS.maxTrackedKeys
+});
+const webhookInFlightLimiter = createWebhookInFlightLimiter();
+const debounceRegistry = createBlueBubblesDebounceRegistry({ processMessage });
+function registerBlueBubblesWebhookTarget(target) {
+	const registered = registerWebhookTargetWithPluginRoute({
+		targetsByPath: webhookTargets,
+		target,
+		route: {
+			auth: "plugin",
+			match: "exact",
+			pluginId: "bluebubbles",
+			source: "bluebubbles-webhook",
+			accountId: target.account.accountId,
+			log: target.runtime.log,
+			handler: async (req, res) => {
+				if (!await handleBlueBubblesWebhookRequest(req, res) && !res.headersSent) {
+					res.statusCode = 404;
+					res.setHeader("Content-Type", "text/plain; charset=utf-8");
+					res.end("Not Found");
+				}
+			}
+		}
+	});
+	return () => {
+		registered.unregister();
+		debounceRegistry.removeDebouncer(registered.target);
+	};
+}
+function parseBlueBubblesWebhookPayload(rawBody) {
+	const trimmed = rawBody.trim();
+	if (!trimmed) return {
+		ok: false,
+		error: "empty payload"
+	};
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(trimmed)
+		};
+	} catch {
+		const params = new URLSearchParams(rawBody);
+		const payload = params.get("payload") ?? params.get("data") ?? params.get("message");
+		if (!payload) return {
+			ok: false,
+			error: "invalid json"
+		};
+		try {
+			return {
+				ok: true,
+				value: JSON.parse(payload)
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: formatErrorMessage(error)
+			};
+		}
+	}
+}
+function maskSecret(value) {
+	if (value.length <= 6) return "***";
+	return `${value.slice(0, 2)}***${value.slice(-2)}`;
+}
+function normalizeAuthToken(raw) {
+	const value = raw.trim();
+	if (!value) return "";
+	if (normalizeLowercaseStringOrEmpty(value).startsWith("bearer ")) return value.slice(7).trim();
+	return value;
+}
+function safeEqualAuthToken(aRaw, bRaw) {
+	const a = normalizeAuthToken(aRaw);
+	const b = normalizeAuthToken(bRaw);
+	if (!a || !b) return false;
+	return safeEqualSecret(a, b);
+}
+function collectTrustedProxies(targets) {
+	const proxies = /* @__PURE__ */ new Set();
+	for (const target of targets) for (const proxy of target.config.gateway?.trustedProxies ?? []) {
+		const normalized = proxy.trim();
+		if (normalized) proxies.add(normalized);
+	}
+	return [...proxies];
+}
+function resolveWebhookAllowRealIpFallback(targets) {
+	return targets.some((target) => target.config.gateway?.allowRealIpFallback === true);
+}
+function resolveWebhookClientIp(req, trustedProxies, allowRealIpFallback) {
+	if (!req.headers["x-forwarded-for"] && !(allowRealIpFallback && req.headers["x-real-ip"])) return req.socket.remoteAddress ?? "unknown";
+	return resolveRequestClientIp(req, [...trustedProxies], allowRealIpFallback) ?? req.socket.remoteAddress ?? "unknown";
+}
+async function handleBlueBubblesWebhookRequest(req, res) {
+	const requestUrl = new URL(req.url ?? "/", "http://localhost");
+	const normalizedPath = normalizeWebhookPath(requestUrl.pathname);
+	const pathTargets = webhookTargets.get(normalizedPath) ?? [];
+	const clientIp = resolveWebhookClientIp(req, collectTrustedProxies(pathTargets), resolveWebhookAllowRealIpFallback(pathTargets));
+	return await withResolvedWebhookRequestPipeline({
+		req,
+		res,
+		targetsByPath: webhookTargets,
+		allowMethods: ["POST"],
+		rateLimiter: webhookRateLimiter,
+		rateLimitKey: `${normalizedPath}:${clientIp}`,
+		inFlightLimiter: webhookInFlightLimiter,
+		inFlightKey: `${normalizedPath}:${clientIp}`,
+		handle: async ({ path, targets }) => {
+			const url = requestUrl;
+			const guidParam = url.searchParams.get("guid") ?? url.searchParams.get("password");
+			const headerToken = req.headers["x-guid"] ?? req.headers["x-password"] ?? req.headers["x-bluebubbles-guid"] ?? req.headers["authorization"];
+			const guid = (Array.isArray(headerToken) ? headerToken[0] : headerToken) ?? guidParam ?? "";
+			const target = resolveWebhookTargetWithAuthOrRejectSync({
+				targets,
+				res,
+				isMatch: (target) => {
+					return safeEqualAuthToken(guid, target.account.config.password?.trim() ?? "");
+				}
+			});
+			if (!target) {
+				console.warn(`[bluebubbles] webhook rejected: status=${res.statusCode} path=${path} guid=${maskSecret(url.searchParams.get("guid") ?? url.searchParams.get("password") ?? "")}`);
+				return true;
+			}
+			const body = await readWebhookBodyOrReject({
+				req,
+				res,
+				profile: "post-auth",
+				invalidBodyMessage: "invalid payload"
+			});
+			if (!body.ok) {
+				console.warn(`[bluebubbles] webhook rejected: status=${res.statusCode}`);
+				return true;
+			}
+			const parsed = parseBlueBubblesWebhookPayload(body.value);
+			if (!parsed.ok) {
+				res.statusCode = 400;
+				res.end(parsed.error);
+				console.warn(`[bluebubbles] webhook rejected: ${parsed.error}`);
+				return true;
+			}
+			const payload = asRecord(parsed.value) ?? {};
+			const firstTarget = targets[0];
+			if (firstTarget) logVerbose(firstTarget.core, firstTarget.runtime, `webhook received path=${path} keys=${Object.keys(payload).join(",") || "none"}`);
+			const eventTypeRaw = payload.type;
+			const eventType = typeof eventTypeRaw === "string" ? eventTypeRaw.trim() : "";
+			if (eventType && !new Set([
+				"new-message",
+				"updated-message",
+				"message-reaction",
+				"reaction"
+			]).has(eventType)) {
+				res.statusCode = 200;
+				res.end("ok");
+				if (firstTarget) logVerbose(firstTarget.core, firstTarget.runtime, `webhook ignored type=${eventType}`);
+				return true;
+			}
+			const reaction = normalizeWebhookReaction(payload);
+			const message = reaction ? null : normalizeWebhookMessage(payload, { eventType });
+			const isAttachmentUpdate = eventType === "updated-message" && (message?.attachments?.length ?? 0) > 0;
+			if ((eventType === "updated-message" || eventType === "message-reaction" || eventType === "reaction") && !reaction && !isAttachmentUpdate) {
+				res.statusCode = 200;
+				res.end("ok");
+				if (firstTarget) logVerbose(firstTarget.core, firstTarget.runtime, `webhook ignored ${eventType || "event"} (no reaction or attachment update)`);
+				return true;
+			}
+			if (!message && !reaction) {
+				res.statusCode = 400;
+				res.end("invalid payload");
+				console.warn("[bluebubbles] webhook rejected: unable to parse message payload");
+				return true;
+			}
+			target.statusSink?.({ lastInboundAt: Date.now() });
+			if (reaction) processReaction(reaction, target).catch((err) => {
+				target.runtime.error?.(`[${target.account.accountId}] BlueBubbles reaction failed: ${String(err)}`);
+			});
+			else if (message) debounceRegistry.getOrCreateDebouncer(target).enqueue({
+				message,
+				target
+			}).catch((err) => {
+				target.runtime.error?.(`[${target.account.accountId}] BlueBubbles webhook failed: ${String(err)}`);
+			});
+			res.statusCode = 200;
+			res.end("ok");
+			if (reaction) {
+				if (firstTarget) logVerbose(firstTarget.core, firstTarget.runtime, `webhook accepted reaction sender=${reaction.senderId} msg=${reaction.messageId} action=${reaction.action}`);
+			} else if (message) {
+				if (firstTarget) logVerbose(firstTarget.core, firstTarget.runtime, `webhook accepted sender=${message.senderId} group=${message.isGroup} chatGuid=${message.chatGuid ?? ""} chatId=${message.chatId ?? ""}`);
+			}
+			return true;
+		}
+	});
+}
+async function monitorBlueBubblesProvider(options) {
+	const { account, config, runtime, abortSignal, statusSink } = options;
+	const core = getBlueBubblesRuntime();
+	const path = options.webhookPath?.trim() || "/bluebubbles-webhook";
+	const allowPrivateNetwork = resolveBlueBubblesEffectiveAllowPrivateNetwork({
+		baseUrl: account.baseUrl,
+		config: account.config
+	});
+	const serverInfo = await fetchBlueBubblesServerInfo({
+		baseUrl: account.baseUrl,
+		password: account.config.password,
+		accountId: account.accountId,
+		timeoutMs: 5e3,
+		allowPrivateNetwork
+	}).catch(() => null);
+	if (serverInfo?.os_version) runtime.log?.(`[${account.accountId}] BlueBubbles server macOS ${serverInfo.os_version}`);
+	if (typeof serverInfo?.private_api === "boolean") runtime.log?.(`[${account.accountId}] BlueBubbles Private API ${serverInfo.private_api ? "enabled" : "disabled"}`);
+	const target = {
+		account,
+		config,
+		runtime,
+		core,
+		path,
+		statusSink
+	};
+	const unregister = registerBlueBubblesWebhookTarget(target);
+	return await new Promise((resolve) => {
+		const stop = () => {
+			unregister();
+			resolve();
+		};
+		if (abortSignal?.aborted) {
+			stop();
+			return;
+		}
+		abortSignal?.addEventListener("abort", stop, { once: true });
+		runtime.log?.(`[${account.accountId}] BlueBubbles webhook listening on ${normalizeWebhookPath(path)}`);
+		import("./catchup-CXQzIWv3.js").then(({ runBlueBubblesCatchup }) => runBlueBubblesCatchup(target)).catch((err) => {
+			runtime.error?.(`[${account.accountId}] BlueBubbles catchup: unexpected failure: ${String(err)}`);
+		});
+	});
+}
+//#endregion
+//#region extensions/bluebubbles/src/channel.runtime.ts
+const blueBubblesChannelRuntime = {
+	sendBlueBubblesMedia,
+	resolveBlueBubblesMessageId,
+	monitorBlueBubblesProvider,
+	resolveWebhookPathFromConfig,
+	probeBlueBubbles,
+	sendMessageBlueBubbles
+};
+//#endregion
+export { blueBubblesChannelRuntime };

package/dist/channel.runtime-Du87a5jR.js

@@ -0,0 +1,89 @@
+import { n as resolveOutboundSendDep } from "./send-deps-Bf7BFa1s.js";
+import { t as resolveChannelMediaMaxBytes } from "./media-limits-B_vUv30m.js";
+import { J as setSetupChannelEnabled } from "./setup-wizard-helpers-CRXRiHac.js";
+import { t as PAIRING_APPROVED_MESSAGE } from "./pairing-message-DuN8JQxM.js";
+import { t as detectBinary } from "./detect-binary-Dp1j8RBD.js";
+import { l as createDetectedBinaryStatus } from "./setup-wizard-proxy-bdD9ER_4.js";
+import "./setup-DEuIenMF.js";
+import "./setup-tools-rBFs666g.js";
+import "./outbound-runtime-BQ6OcmS9.js";
+import { s as resolveIMessageAccount } from "./media-contract-3fYuhjdX.js";
+import "./conversation-id-C1ZMSaUv.js";
+import { i as imessageDmPolicy, o as imessageSetupStatusBase, r as imessageCompletionNote, t as createIMessageCliPathTextInput } from "./setup-core-CgIvNnqV.js";
+import { t as IMESSAGE_LEGACY_OUTBOUND_SEND_DEP_KEYS } from "./outbound-send-deps-Z9nOB1wt.js";
+import { t as probeIMessage } from "./probe-CuYUIyNI.js";
+import { n as sendMessageIMessage, t as monitorIMessageProvider } from "./monitor-C2nxTIum.js";
+//#region extensions/imessage/src/setup-surface.ts
+const channel = "imessage";
+const imessageSetupWizard = {
+	channel,
+	status: createDetectedBinaryStatus({
+		channelLabel: "iMessage",
+		binaryLabel: "imsg",
+		configuredLabel: imessageSetupStatusBase.configuredLabel,
+		unconfiguredLabel: imessageSetupStatusBase.unconfiguredLabel,
+		configuredHint: imessageSetupStatusBase.configuredHint,
+		unconfiguredHint: imessageSetupStatusBase.unconfiguredHint,
+		configuredScore: imessageSetupStatusBase.configuredScore,
+		unconfiguredScore: imessageSetupStatusBase.unconfiguredScore,
+		resolveConfigured: imessageSetupStatusBase.resolveConfigured,
+		resolveBinaryPath: ({ cfg, accountId }) => resolveIMessageAccount({
+			cfg,
+			accountId
+		}).config.cliPath ?? "imsg",
+		detectBinary
+	}),
+	credentials: [],
+	textInputs: [createIMessageCliPathTextInput(async ({ currentValue }) => {
+		return !await detectBinary(currentValue ?? "imsg");
+	})],
+	completionNote: imessageCompletionNote,
+	dmPolicy: imessageDmPolicy,
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+//#region extensions/imessage/src/channel.runtime.ts
+async function sendIMessageOutbound(params) {
+	const send = resolveOutboundSendDep(params.deps, "imessage", { legacyKeys: IMESSAGE_LEGACY_OUTBOUND_SEND_DEP_KEYS }) ?? sendMessageIMessage;
+	const maxBytes = resolveChannelMediaMaxBytes({
+		cfg: params.cfg,
+		resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.imessage?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.imessage?.mediaMaxMb,
+		accountId: params.accountId
+	});
+	return await send(params.to, params.text, {
+		config: params.cfg,
+		...params.mediaUrl ? { mediaUrl: params.mediaUrl } : {},
+		...params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {},
+		maxBytes,
+		accountId: params.accountId ?? void 0,
+		replyToId: params.replyToId ?? void 0
+	});
+}
+async function notifyIMessageApproval(params) {
+	await sendMessageIMessage(params.id, PAIRING_APPROVED_MESSAGE, { config: params.cfg });
+}
+async function probeIMessageAccount(params) {
+	return await probeIMessage(params?.timeoutMs, {
+		cliPath: params?.cliPath,
+		dbPath: params?.dbPath
+	});
+}
+async function startIMessageGatewayAccount(ctx) {
+	const account = ctx.account;
+	const cliPath = account.config.cliPath?.trim() || "imsg";
+	const dbPath = account.config.dbPath?.trim();
+	ctx.setStatus({
+		accountId: account.accountId,
+		cliPath,
+		dbPath: dbPath ?? null
+	});
+	ctx.log?.info?.(`[${account.accountId}] starting provider (${cliPath}${dbPath ? ` db=${dbPath}` : ""})`);
+	return await monitorIMessageProvider({
+		accountId: account.accountId,
+		config: ctx.cfg,
+		runtime: ctx.runtime,
+		abortSignal: ctx.abortSignal
+	});
+}
+//#endregion
+export { imessageSetupWizard, notifyIMessageApproval, probeIMessageAccount, sendIMessageOutbound, startIMessageGatewayAccount };

package/dist/channel.runtime-FklQos16.js

@@ -0,0 +1,4 @@
+import { x as pushMessageLine } from "./markdown-to-line-B8FYeJdD.js";
+import { t as monitorLineProvider } from "./monitor-C_5rnpcO.js";
+import { t as probeLineBot } from "./probe-BqvDBaFN.js";
+export { monitorLineProvider, probeLineBot, pushMessageLine };