@openclaw/buzz 2026.9.6 → 2026.9.8

package/dist/.setup/room-membership-7of91SyC.mjs

@@ -0,0 +1,537 @@
+import { l as BUZZ_CHANNEL_ID_PATTERN, m as parseBuzzTarget, u as buildBuzzTarget } from "./types-DRUZMyTx.mjs";
+import { t as applyBuzzDirectoryQueryAndLimit } from "./directory-query-D1BNu8nO.mjs";
+import { Relay, finalizeEvent } from "nostr-tools";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
+import { fetchWithSsrFGuard, ssrfPolicyFromHttpBaseUrlAllowedOrigin } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/buzz/src/event-order.ts
+function isNewerBuzzRevision(candidate, current) {
+	return !current || candidate.createdAt > current.createdAt || candidate.createdAt === current.createdAt && candidate.eventId < current.eventId;
+}
+const BUZZ_ROOM_METADATA_KIND = 39e3;
+const DEFAULT_BUZZ_DIRECTORY_PROFILE_LIMIT = 2e3;
+const HEX_PUBLIC_KEY_PATTERN$2 = /^[0-9a-f]{64}$/u;
+const MAX_DIRECTORY_NAME_CHARS = 512;
+const MAX_DIRECTORY_HANDLE_CHARS = 320;
+const MAX_DIRECTORY_URL_CHARS = 4096;
+function normalizeBoundedString(value, maxChars) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	return truncateUtf16Safe(trimmed, maxChars);
+}
+function readPreferredString(params) {
+	if (Object.hasOwn(params.content, params.primary)) return normalizeBoundedString(params.content[params.primary], params.maxChars);
+	return normalizeBoundedString(params.content[params.fallback], params.maxChars);
+}
+function fallbackPublicKeyLabel(publicKey) {
+	return `${publicKey.slice(0, 8)}...${publicKey.slice(-6)}`;
+}
+function parseBuzzDirectoryProfileEvent(event) {
+	const publicKey = event.pubkey.trim().toLowerCase();
+	if (event.kind !== 0 || !HEX_PUBLIC_KEY_PATTERN$2.test(publicKey)) return;
+	let content;
+	try {
+		const parsed = JSON.parse(event.content);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+		content = parsed;
+	} catch {
+		return;
+	}
+	return {
+		publicKey,
+		displayName: readPreferredString({
+			content,
+			primary: "display_name",
+			fallback: "name",
+			maxChars: MAX_DIRECTORY_NAME_CHARS
+		}),
+		handle: normalizeBoundedString(content.nip05, MAX_DIRECTORY_HANDLE_CHARS),
+		avatarUrl: readPreferredString({
+			content,
+			primary: "picture",
+			fallback: "image",
+			maxChars: MAX_DIRECTORY_URL_CHARS
+		}),
+		createdAt: event.created_at,
+		eventId: event.id
+	};
+}
+function parseBuzzDirectoryRoomEvent(event) {
+	if (event.kind !== 39e3) return;
+	const roomId = event.tags.find((tag) => tag[0] === "d")?.[1]?.trim().toLowerCase();
+	if (!roomId) return;
+	try {
+		parseBuzzTarget(roomId);
+	} catch {
+		return;
+	}
+	return {
+		roomId,
+		name: normalizeBoundedString(event.tags.find((tag) => tag[0] === "name")?.[1], MAX_DIRECTORY_NAME_CHARS),
+		archived: event.tags.some((tag) => tag[0] === "archived" && tag[1] === "true"),
+		createdAt: event.created_at,
+		eventId: event.id
+	};
+}
+var BuzzDirectoryState = class {
+	#publicKey;
+	#fallbackProfileName;
+	#configuredRoomIds;
+	#profileLimit;
+	#memberships = /* @__PURE__ */ new Map();
+	#profilePublicKeys = /* @__PURE__ */ new Set();
+	#profiles = /* @__PURE__ */ new Map();
+	#rooms = /* @__PURE__ */ new Map();
+	constructor(params) {
+		this.#publicKey = params.publicKey.trim().toLowerCase();
+		this.#fallbackProfileName = params.fallbackProfileName.trim() || "OpenClaw";
+		this.#configuredRoomIds = new Set(params.channelIds.map(parseBuzzTarget));
+		const requestedProfileLimit = params.profileLimit ?? DEFAULT_BUZZ_DIRECTORY_PROFILE_LIMIT;
+		this.#profileLimit = Number.isFinite(requestedProfileLimit) && requestedProfileLimit >= 0 ? Math.floor(requestedProfileLimit) : DEFAULT_BUZZ_DIRECTORY_PROFILE_LIMIT;
+		if (this.#profileLimit > 0) this.#profilePublicKeys.add(this.#publicKey);
+	}
+	replaceMemberships(memberships) {
+		const nextMemberships = /* @__PURE__ */ new Map();
+		const memberPublicKeys = /* @__PURE__ */ new Set();
+		for (const roomId of this.#configuredRoomIds) {
+			const membership = memberships.get(roomId);
+			if (!membership) continue;
+			nextMemberships.set(roomId, membership);
+			for (const publicKey of membership.members) memberPublicKeys.add(publicKey);
+		}
+		memberPublicKeys.delete(this.#publicKey);
+		const nextProfilePublicKeys = this.#profileLimit === 0 ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([this.#publicKey, ...[...memberPublicKeys].toSorted().slice(0, this.#profileLimit - 1)]);
+		const profileSelectionChanged = nextProfilePublicKeys.size !== this.#profilePublicKeys.size || [...nextProfilePublicKeys].some((publicKey) => !this.#profilePublicKeys.has(publicKey));
+		this.#memberships = nextMemberships;
+		this.#profilePublicKeys = nextProfilePublicKeys;
+		for (const publicKey of this.#profiles.keys()) if (!nextProfilePublicKeys.has(publicKey)) this.#profiles.delete(publicKey);
+		return profileSelectionChanged;
+	}
+	profilePublicKeys() {
+		return [...this.#profilePublicKeys];
+	}
+	activeRoomIds() {
+		return [...this.#configuredRoomIds].filter((roomId) => !this.#rooms.get(roomId)?.archived);
+	}
+	isRoomArchived(roomId) {
+		return this.#rooms.get(parseBuzzTarget(roomId))?.archived === true;
+	}
+	isBotMember(roomId, publicKey) {
+		return this.isMember(roomId, publicKey) && this.#memberships.get(parseBuzzTarget(roomId))?.roles.get(publicKey) === "bot";
+	}
+	isMember(roomId, publicKey) {
+		const normalizedRoomId = parseBuzzTarget(roomId);
+		return !this.#rooms.get(normalizedRoomId)?.archived && this.#memberships.get(normalizedRoomId)?.members.has(publicKey) === true;
+	}
+	applyProfileEvent(event) {
+		const profile = parseBuzzDirectoryProfileEvent(event);
+		if (!profile || !this.#profilePublicKeys.has(profile.publicKey) || !isNewerBuzzRevision(profile, this.#profiles.get(profile.publicKey))) return false;
+		this.#profiles.set(profile.publicKey, profile);
+		return true;
+	}
+	applyRoomEvent(event) {
+		const room = parseBuzzDirectoryRoomEvent(event);
+		if (!room || !this.#configuredRoomIds.has(room.roomId) || !isNewerBuzzRevision(room, this.#rooms.get(room.roomId))) return false;
+		this.#rooms.set(room.roomId, room);
+		return true;
+	}
+	resolveSenderName(publicKey) {
+		const normalized = publicKey.trim().toLowerCase();
+		return this.#profiles.get(normalized)?.displayName ?? fallbackPublicKeyLabel(normalized);
+	}
+	resolveRoomName(roomId) {
+		const normalized = parseBuzzTarget(roomId);
+		return this.#rooms.get(normalized)?.name ?? normalized;
+	}
+	self() {
+		return this.#buildUserEntry(this.#publicKey);
+	}
+	listPeers(params) {
+		const peers = /* @__PURE__ */ new Set();
+		for (const roomId of this.activeRoomIds()) {
+			const membership = this.#memberships.get(roomId);
+			if (!membership) continue;
+			for (const publicKey of membership.members) if (publicKey !== this.#publicKey) peers.add(publicKey);
+		}
+		const entries = [...peers].map((publicKey) => this.#buildUserEntry(publicKey)).toSorted(compareDirectoryEntries);
+		return applyBuzzDirectoryQueryAndLimit(entries, params);
+	}
+	listGroups(params) {
+		const entries = this.activeRoomIds().map((roomId) => this.#buildRoomEntry(roomId)).toSorted(compareDirectoryEntries);
+		return applyBuzzDirectoryQueryAndLimit(entries, params);
+	}
+	listGroupMembers(params) {
+		let roomId;
+		try {
+			roomId = parseBuzzTarget(params.groupId);
+		} catch {
+			return [];
+		}
+		if (this.#rooms.get(roomId)?.archived) return [];
+		const membership = this.#memberships.get(roomId);
+		if (!membership) return [];
+		const entries = [...membership.members].map((publicKey) => {
+			const entry = this.#buildUserEntry(publicKey);
+			entry.raw = {
+				publicKey,
+				role: membership.roles.get(publicKey),
+				roomId
+			};
+			return entry;
+		}).toSorted(compareDirectoryEntries);
+		return applyBuzzDirectoryQueryAndLimit(entries, { limit: params.limit });
+	}
+	mentionMembers(roomId) {
+		const normalized = parseBuzzTarget(roomId);
+		if (this.#rooms.get(normalized)?.archived) return;
+		const membership = this.#memberships.get(normalized);
+		if (!membership) return;
+		return [...membership.members].map((publicKey) => ({
+			publicKey,
+			displayName: this.#profiles.get(publicKey)?.displayName
+		})).toSorted((left, right) => left.publicKey.localeCompare(right.publicKey));
+	}
+	#buildUserEntry(publicKey) {
+		const profile = this.#profiles.get(publicKey);
+		return {
+			kind: "user",
+			id: publicKey,
+			name: profile?.displayName ?? (publicKey === this.#publicKey ? this.#fallbackProfileName : fallbackPublicKeyLabel(publicKey)),
+			handle: profile?.handle,
+			avatarUrl: profile?.avatarUrl,
+			raw: { publicKey }
+		};
+	}
+	#buildRoomEntry(roomId) {
+		const room = this.#rooms.get(roomId);
+		return {
+			kind: "group",
+			id: buildBuzzTarget(roomId),
+			name: room?.name ?? roomId,
+			handle: room?.name ? `#${room.name}` : void 0,
+			raw: { roomId }
+		};
+	}
+};
+function compareDirectoryEntries(a, b) {
+	const aLabel = a.name ?? a.handle ?? a.id;
+	const bLabel = b.name ?? b.handle ?? b.id;
+	return aLabel.localeCompare(bLabel) || a.id.localeCompare(b.id);
+}
+//#endregion
+//#region extensions/buzz/src/subscription-budget.ts
+const BUZZ_DIRECTORY_MAX_PROFILE_SUBSCRIPTIONS = 10;
+const BUZZ_MAX_CONFIGURED_ROOMS = 1020;
+function resolveBuzzSubscriptionBudget(roomCount) {
+	if (!Number.isSafeInteger(roomCount) || roomCount < 0) throw new Error("Buzz configured room count must be a non-negative integer");
+	const availableProfileSubscriptions = 1020 - roomCount;
+	if (availableProfileSubscriptions < 0) throw new Error(`Buzz supports at most ${BUZZ_MAX_CONFIGURED_ROOMS} configured rooms per account`);
+	return { profileLimit: Math.min(BUZZ_DIRECTORY_MAX_PROFILE_SUBSCRIPTIONS, availableProfileSubscriptions) * 200 };
+}
+//#endregion
+//#region extensions/buzz/src/relay-subscription.ts
+const snapshotQueries = /* @__PURE__ */ new WeakMap();
+function openBuzzRelaySubscription(relay, filters, params, requestFilters = filters) {
+	relay.idleSince = void 0;
+	relay.ongoingOperations += 1;
+	let subscription;
+	try {
+		subscription = relay.prepareSubscription(filters, params);
+	} catch (error) {
+		relay.ongoingOperations -= 1;
+		if (relay.ongoingOperations === 0) {
+			relay.idleSince = Date.now();
+			relay.scheduleIdleClose();
+		}
+		throw error;
+	}
+	const frame = JSON.stringify([
+		"REQ",
+		subscription.id,
+		...requestFilters
+	]);
+	relay.send(frame).catch((error) => {
+		if (subscription.closed || relay.openSubs.get(subscription.id) !== subscription) return;
+		const message = error instanceof Error ? error.message : String(error);
+		subscription.close(`Buzz relay subscription request failed: ${message}`);
+	});
+	return subscription;
+}
+async function queryBuzzRelaySnapshot(params) {
+	params.signal?.throwIfAborted();
+	const queries = snapshotQueries.get(params.relay) ?? {
+		active: 0,
+		waiting: []
+	};
+	snapshotQueries.set(params.relay, queries);
+	if (queries.active >= 3) await new Promise((resolve, reject) => {
+		const grant = () => {
+			params.signal?.removeEventListener("abort", onAbort);
+			resolve();
+		};
+		const onAbort = () => {
+			const index = queries.waiting.indexOf(grant);
+			if (index < 0) return;
+			queries.waiting.splice(index, 1);
+			params.signal?.removeEventListener("abort", onAbort);
+			const reason = params.signal?.reason ?? new Error(params.abortMessage);
+			reject(reason instanceof Error ? reason : new Error(params.failureMessage, { cause: reason }));
+		};
+		queries.waiting.push(grant);
+		params.signal?.addEventListener("abort", onAbort, { once: true });
+		if (params.signal?.aborted) onAbort();
+	});
+	else queries.active += 1;
+	try {
+		params.signal?.throwIfAborted();
+		return await queryBuzzRelaySnapshotNow(params);
+	} finally {
+		const next = queries.waiting.shift();
+		if (next) next();
+		else {
+			queries.active -= 1;
+			if (queries.active === 0) snapshotQueries.delete(params.relay);
+		}
+	}
+}
+async function queryBuzzRelaySnapshotNow(params) {
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let receivedEose = false;
+		let subscriptionClosed = false;
+		let subscription;
+		const timeout = setTimeout(() => {
+			const error = new Error(params.timeoutMessage);
+			finish(error);
+			params.onTimeout?.(error);
+			if (params.closeRelayOnTimeout !== false) params.relay.close();
+		}, params.timeoutMs ?? 1e4);
+		const closeAfterRealEose = () => {
+			if (receivedEose && subscription && !subscriptionClosed) {
+				subscriptionClosed = true;
+				subscription.close(params.closeReason);
+			}
+		};
+		const finish = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			params.signal?.removeEventListener("abort", onAbort);
+			closeAfterRealEose();
+			if (error === void 0) resolve(params.result());
+			else reject(error instanceof Error ? error : new Error(params.failureMessage, { cause: error }));
+		};
+		const onAbort = () => finish(params.signal?.reason ?? new Error(params.abortMessage));
+		params.signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			subscription = openBuzzRelaySubscription(params.relay, params.filters, {
+				onevent: params.onEvent,
+				oneose: () => {
+					receivedEose = true;
+					if (settled) closeAfterRealEose();
+					else finish();
+				},
+				onclose: (reason) => {
+					if (reason !== params.closeReason) finish(new Error(params.closeMessage(reason)));
+				}
+			});
+		} catch (error) {
+			finish(error);
+			return;
+		}
+		closeAfterRealEose();
+		if (params.checkAbortAfterSubscribe && params.signal?.aborted) onAbort();
+	});
+}
+//#endregion
+//#region extensions/buzz/src/relay-auth.ts
+const AUTH_CHALLENGE_TIMEOUT_MS = 2e4;
+const AUTH_CHALLENGE_POLL_MS = 25;
+const RELAY_SESSION_SETUP_TIMEOUT_MS = 2e4;
+const HEX_PUBLIC_KEY_PATTERN$1 = /^[0-9a-f]{64}$/u;
+const BUZZ_RELAY_SOFTWARE = "https://github.com/block/buzz";
+const BUZZ_LOCAL_DEV_RELAY_PUBLIC_KEY = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
+function parseBuzzAuthTag(raw) {
+	if (!raw.trim()) return;
+	const parsed = JSON.parse(raw);
+	if (!Array.isArray(parsed) || parsed.length !== 4 || parsed[0] !== "auth" || parsed.some((value) => typeof value !== "string")) throw new Error("Buzz authTag must be [\"auth\",\"<pubkey>\",\"<conditions>\",\"<signature>\"]");
+	return parsed;
+}
+async function waitWithSignal(promise, signal) {
+	signal.throwIfAborted();
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			const reason = signal.reason;
+			reject(reason instanceof Error ? reason : new Error("Buzz relay authentication aborted", { cause: reason }));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+function createBuzzAuthSigner(params) {
+	return async (template) => finalizeEvent({
+		...template,
+		tags: params.authTag ? [...template.tags, params.authTag] : template.tags
+	}, params.secretKey);
+}
+function isLoopbackRelayUrl(relayUrl) {
+	const hostname = new URL(relayUrl).hostname.toLowerCase();
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+async function resolveBuzzRelayPublicKey(params) {
+	const infoUrl = new URL(params.relayUrl);
+	infoUrl.protocol = infoUrl.protocol === "wss:" ? "https:" : "http:";
+	const url = infoUrl.toString();
+	const { response, release } = await fetchWithSsrFGuard({
+		url,
+		init: { headers: { Accept: "application/nostr+json" } },
+		signal: params.signal,
+		policy: ssrfPolicyFromHttpBaseUrlAllowedOrigin(url),
+		auditContext: "buzz.relay_info"
+	});
+	try {
+		if (!response.ok) {
+			await response.body?.cancel().catch(() => void 0);
+			throw new Error(`Buzz relay information request failed with HTTP ${response.status}`);
+		}
+		const document = await readProviderJsonObjectResponse(response, "Buzz relay information");
+		const relayPublicKey = typeof document.self === "string" ? document.self.trim().toLowerCase() : "";
+		if (HEX_PUBLIC_KEY_PATTERN$1.test(relayPublicKey)) return relayPublicKey;
+		if (document.software === BUZZ_RELAY_SOFTWARE && isLoopbackRelayUrl(params.relayUrl)) return BUZZ_LOCAL_DEV_RELAY_PUBLIC_KEY;
+		throw new Error("Buzz relay information document is missing a valid NIP-11 self public key");
+	} finally {
+		await release();
+	}
+}
+async function connectAndAuthenticateBuzzRelay(params) {
+	const signAuth = createBuzzAuthSigner({
+		secretKey: params.secretKey,
+		authTag: params.authTag
+	});
+	await params.relay.connect({ abort: params.signal });
+	await authenticateBuzzRelay({
+		relay: params.relay,
+		signAuth,
+		signal: params.signal
+	});
+	params.relay.onauth = signAuth;
+}
+async function connectAuthenticatedBuzzRelay(params) {
+	const relay = new Relay(params.relayUrl, { enableReconnect: false });
+	try {
+		await connectAndAuthenticateBuzzRelay({
+			...params,
+			relay
+		});
+		return relay;
+	} catch (error) {
+		relay.close();
+		throw error;
+	}
+}
+async function connectAuthenticatedBuzzRelaySession(params) {
+	const relay = new Relay(params.relayUrl, { enableReconnect: false });
+	const setupAbort = new AbortController();
+	const signal = params.signal ? AbortSignal.any([params.signal, setupAbort.signal]) : setupAbort.signal;
+	let setupTimedOut = false;
+	const setupTimeout = setTimeout(() => {
+		setupTimedOut = true;
+		setupAbort.abort(/* @__PURE__ */ new Error("Timed out setting up Buzz relay session"));
+	}, RELAY_SESSION_SETUP_TIMEOUT_MS);
+	const authPromise = connectAndAuthenticateBuzzRelay({
+		...params,
+		relay,
+		signal
+	});
+	const relayIdentityPromise = resolveBuzzRelayPublicKey({
+		relayUrl: params.relayUrl,
+		signal
+	});
+	try {
+		const [, relayPublicKey] = await Promise.all([authPromise, relayIdentityPromise]);
+		return {
+			relay,
+			relayPublicKey
+		};
+	} catch (error) {
+		setupAbort.abort(error);
+		relay.close();
+		await Promise.allSettled([authPromise, relayIdentityPromise]);
+		if (setupTimedOut && !params.signal?.aborted) throw new Error("Timed out setting up Buzz relay session", { cause: error });
+		throw error;
+	} finally {
+		clearTimeout(setupTimeout);
+	}
+}
+async function authenticateBuzzRelay(params) {
+	const challengeTimeout = AbortSignal.timeout(AUTH_CHALLENGE_TIMEOUT_MS);
+	const signal = params.signal ? AbortSignal.any([params.signal, challengeTimeout]) : challengeTimeout;
+	try {
+		while (true) {
+			signal.throwIfAborted();
+			try {
+				await waitWithSignal(params.relay.auth(params.signAuth), signal);
+				return;
+			} catch (error) {
+				if (!(error instanceof Error && error.message === "can't perform auth, no challenge was received")) throw error;
+				await waitWithSignal(new Promise((resolve) => {
+					setTimeout(resolve, AUTH_CHALLENGE_POLL_MS);
+				}), signal);
+			}
+		}
+	} catch (error) {
+		if (challengeTimeout.aborted && !params.signal?.aborted) throw new Error("Timed out waiting for Buzz NIP-42 authentication challenge", { cause: error });
+		throw error;
+	}
+}
+//#endregion
+//#region extensions/buzz/src/room-membership.ts
+const BUZZ_ROOM_MEMBERSHIP_KIND = 39002;
+const BUZZ_ROOM_SYSTEM_KIND = 40099;
+const HEX_PUBLIC_KEY_PATTERN = /^[0-9a-f]{64}$/u;
+const MEMBERSHIP_CHANGE_TYPES = /* @__PURE__ */ new Set([
+	"member_joined",
+	"member_left",
+	"member_removed"
+]);
+function parseBuzzRoomMembershipEvent(event, relayPublicKey) {
+	if (event.kind !== 39002 || event.pubkey.toLowerCase() !== relayPublicKey) return;
+	const roomId = event.tags.find((tag) => tag[0] === "d")?.[1]?.trim().toLowerCase();
+	if (!roomId || !BUZZ_CHANNEL_ID_PATTERN.test(roomId)) return;
+	const members = /* @__PURE__ */ new Set();
+	const roles = /* @__PURE__ */ new Map();
+	for (const tag of event.tags) {
+		if (tag[0] !== "p") continue;
+		const publicKey = tag[1]?.trim().toLowerCase();
+		if (!publicKey || !HEX_PUBLIC_KEY_PATTERN.test(publicKey)) continue;
+		members.add(publicKey);
+		const role = tag[3]?.trim().toLowerCase();
+		if (role) roles.set(publicKey, role);
+	}
+	return {
+		roomId,
+		createdAt: event.created_at,
+		eventId: event.id,
+		publisherPublicKey: event.pubkey.toLowerCase(),
+		members,
+		roles
+	};
+}
+function parseBuzzRoomMembershipChangeEvent(event, membership) {
+	if (event.kind !== 40099 || event.pubkey.toLowerCase() !== membership.publisherPublicKey || !event.tags.some((tag) => tag[0] === "h" && tag[1]?.toLowerCase() === membership.roomId)) return;
+	try {
+		const content = JSON.parse(event.content);
+		if (typeof content.type !== "string" || !MEMBERSHIP_CHANGE_TYPES.has(content.type)) return;
+		const target = typeof content.target === "string" ? content.target.trim().toLowerCase() : content.type === "member_left" && typeof content.actor === "string" ? content.actor.trim().toLowerCase() : "";
+		if (!HEX_PUBLIC_KEY_PATTERN.test(target)) return;
+		return {
+			type: content.type,
+			targetPublicKey: target
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { connectAuthenticatedBuzzRelay as a, openBuzzRelaySubscription as c, resolveBuzzSubscriptionBudget as d, BUZZ_ROOM_METADATA_KIND as f, parseBuzzRoomMembershipEvent as i, queryBuzzRelaySnapshot as l, isNewerBuzzRevision as m, BUZZ_ROOM_SYSTEM_KIND as n, connectAuthenticatedBuzzRelaySession as o, BuzzDirectoryState as p, parseBuzzRoomMembershipChangeEvent as r, parseBuzzAuthTag as s, BUZZ_ROOM_MEMBERSHIP_KIND as t, BUZZ_MAX_CONFIGURED_ROOMS as u };

package/dist/.setup/{secret-contract-DjibkTDL.mjs → secret-contract-B2-Mrm4v.mjs}

@@ -1,4 +1,4 @@
-import { a as resolveBuzzAccountConfig } from "./types-CeupBG0P.mjs";
+import { a as resolveBuzzAccountConfig } from "./types-DRUZMyTx.mjs";
 import { collectSecretInputAssignment, createChannelSecretTargetRegistryEntries, getChannelRecord, isRecord } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
 //#region extensions/buzz/src/secret-contract.ts
 const fields = ["privateKey", "authTag"];

package/dist/.setup/{secret-contract-api-DcFDI-eR.mjs → secret-contract-api-CfJYRXZf.mjs}

@@ -1,3 +1,3 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DjibkTDL.mjs";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-B2-Mrm4v.mjs";
 import "../secret-contract-api.js";
 export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/.setup/setup-plugin-api-CtM1M1Oa.mjs

@@ -0,0 +1,2 @@
+import { t as buzzSetupPlugin } from "./setup-plugin-api-m1pk2Cow.mjs";
+export { buzzSetupPlugin };

package/dist/.setup/{setup-plugin-api-DI8WfvKQ.mjs → setup-plugin-api-m1pk2Cow.mjs}

@@ -1,5 +1,5 @@
-import { c as BuzzConfigSchema, i as resolveBuzzAccount, r as listBuzzAccountIds, s as resolveDefaultBuzzAccountId } from "./types-CeupBG0P.mjs";
-import { n as buzzSetupContract, t as buzzSetupWizard } from "./setup-surface-DOHxdPor.mjs";
+import { c as BuzzConfigSchema, i as resolveBuzzAccount, r as listBuzzAccountIds, s as resolveDefaultBuzzAccountId } from "./types-DRUZMyTx.mjs";
+import { n as buzzSetupContract, t as buzzSetupWizard } from "./setup-surface-CVXY6_50.mjs";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 //#region extensions/buzz/src/channel.setup.ts
 const buzzSetupPlugin = {

package/dist/.setup/{setup-surface-DOHxdPor.mjs → setup-surface-CVXY6_50.mjs}

@@ -1,5 +1,5 @@
-import { a as resolveBuzzAccountConfig, i as resolveBuzzAccount, l as BUZZ_CHANNEL_ID_PATTERN, m as parseBuzzTarget, n as decodeBuzzPrivateKey, o as resolveBuzzPublicKey, r as listBuzzAccountIds } from "./types-CeupBG0P.mjs";
-import { c as openBuzzRelaySubscription, i as parseBuzzRoomMembershipEvent, l as queryBuzzRelaySnapshot, o as connectAuthenticatedBuzzRelaySession, s as parseBuzzAuthTag, t as BUZZ_ROOM_MEMBERSHIP_KIND, u as isNewerBuzzRevision } from "./room-membership-tqLQznFE.mjs";
+import { a as resolveBuzzAccountConfig, i as resolveBuzzAccount, l as BUZZ_CHANNEL_ID_PATTERN, m as parseBuzzTarget, n as decodeBuzzPrivateKey, o as resolveBuzzPublicKey, r as listBuzzAccountIds } from "./types-DRUZMyTx.mjs";
+import { c as openBuzzRelaySubscription, i as parseBuzzRoomMembershipEvent, l as queryBuzzRelaySnapshot, m as isNewerBuzzRevision, o as connectAuthenticatedBuzzRelaySession, s as parseBuzzAuthTag, t as BUZZ_ROOM_MEMBERSHIP_KIND } from "./room-membership-7of91SyC.mjs";
 import { generateSecretKey, nip19 } from "nostr-tools";
 import { sleep } from "openclaw/plugin-sdk/runtime-env";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
@@ -393,9 +393,7 @@ function hasSuccessfulBuzzProbe(payload, accountId, target) {
 }
 function isGatewayNotRunningError(error) {
 	const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-	const identifiesMissingListener = message.includes("econnrefused") || message.includes("connection refused") || message.includes("no listener");
-	if (identifiesMissingListener && typeof error === "object" && error !== null && "name" in error && "kind" in error && "code" in error && error.name === "GatewayTransportError" && error.kind === "closed" && error.code === 1006) return true;
-	return identifiesMissingListener;
+	return message.includes("econnrefused") || message.includes("connection refused") || message.includes("no listener");
 }
 async function verifyBuzzAfterSetup(params) {
 	try {
@@ -466,35 +464,23 @@ function isRemoteInsecureRelayUrl(value) {
 	const isLoopback = hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1" || isIpv4Loopback;
 	return url.protocol === "ws:" && !isLoopback;
 }
-async function promptRelayUrl(params) {
+async function resolveRelayUrl(params) {
+	const configuredValue = params.configuredValue?.trim();
+	let relayUrl = configuredValue && validateRelayUrl(configuredValue) === void 0 ? configuredValue : void 0;
 	while (true) {
-		const relayUrl = (await params.prompter.text({
+		relayUrl ??= (await params.prompter.text({
 			message: "Buzz relay WebSocket URL",
 			placeholder: "wss://buzz.example.com",
-			initialValue: params.initialValue,
+			initialValue: configuredValue || void 0,
 			validate: validateRelayUrl
 		})).trim();
-		if (!isRemoteInsecureRelayUrl(relayUrl)) return relayUrl;
-		if (await params.prompter.confirm({
+		if (!isRemoteInsecureRelayUrl(relayUrl) || await params.prompter.confirm({
 			message: "This remote ws:// relay is unencrypted. Continue anyway?",
 			initialValue: false
 		})) return relayUrl;
+		relayUrl = void 0;
 	}
 }
-async function resolveRelayUrl(params) {
-	const configuredValue = params.configuredValue?.trim();
-	if (configuredValue && validateRelayUrl(configuredValue) === void 0) {
-		if (!isRemoteInsecureRelayUrl(configuredValue)) return configuredValue;
-		if (await params.prompter.confirm({
-			message: "This remote ws:// relay is unencrypted. Continue anyway?",
-			initialValue: false
-		})) return configuredValue;
-	}
-	return await promptRelayUrl({
-		...configuredValue ? { initialValue: configuredValue } : {},
-		prompter: params.prompter
-	});
-}
 async function resolveSetupCredential(params) {
 	const { config, configPath, allowEnv } = resolveBuzzAccountConfig(params);
 	const { resolveConfiguredSecretInputWithFallback } = await import("openclaw/plugin-sdk/secret-input-runtime");

package/dist/.setup/{types-CeupBG0P.mjs → types-DRUZMyTx.mjs}

@@ -39,6 +39,7 @@ function looksLikeBuzzTarget(target) {
 const BuzzGroupConfigSchema = z.object({
 	enabled: z.boolean().optional(),
 	requireMention: z.boolean().optional(),
+	requireMentionInBotThreads: z.boolean().optional(),
 	groupPolicy: GroupPolicySchema.optional(),
 	groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional()
 }).strict();
@@ -50,7 +51,7 @@ const BuzzAccountConfigSchema = z.object({
 	responsePrefix: z.string().optional(),
 	replyToMode: z.enum(["off", "all"]).optional(),
 	markdown: MarkdownConfigSchema,
-	relayUrl: z.string().url().and(z.string().regex(/^[wW][sS][sS]?:\/\//, "Buzz relay URL must use ws:// or wss://")).optional(),
+	relayUrl: z.string().url().and(z.string().regex(/^[wW][sS][sS]?:\/\/.+/, "Buzz relay URL must use ws:// or wss://")).optional(),
 	privateKey: buildSecretInputSchema().optional(),
 	authTag: buildSecretInputSchema().optional(),
 	groupPolicy: GroupPolicySchema.optional(),
@@ -64,7 +65,14 @@ const RawBuzzConfigSchema = BuzzAccountConfigSchema.extend({
 	accounts: z.record(BuzzAccountIdSchema, BuzzAccountConfigSchema).optional(),
 	defaultAccount: BuzzAccountIdSchema.optional()
 });
-const BuzzConfigSchema = buildChannelConfigSchema(RawBuzzConfigSchema);
+const botThreadMentionHint = {
+	label: "Require Mention in Bot Threads",
+	help: "Override mention gating in threads whose root message was signed by this bot in the same room. False allows unmentioned replies; true requires a mention. Omit to preserve the room's mention policy. Sender restrictions still apply."
+};
+const BuzzConfigSchema = buildChannelConfigSchema(RawBuzzConfigSchema, { uiHints: {
+	"groups.*.requireMentionInBotThreads": botThreadMentionHint,
+	"accounts.*.groups.*.requireMentionInBotThreads": botThreadMentionHint
+} });
 //#endregion
 //#region extensions/buzz/src/types.ts
 function resolveChannelConfig(cfg) {

package/dist/api.js

@@ -1,3 +1,3 @@
-import { i as resolveBuzzAccount, r as listBuzzAccountIds, s as resolveDefaultBuzzAccountId } from "./.setup/types-CeupBG0P.mjs";
-import { n as getBuzzRuntime, r as setBuzzRuntime, t as buzzPlugin } from "./.setup/channel-qV8kQiPi.mjs";
+import { i as resolveBuzzAccount, r as listBuzzAccountIds, s as resolveDefaultBuzzAccountId } from "./.setup/types-DRUZMyTx.mjs";
+import { n as getBuzzRuntime, r as setBuzzRuntime, t as buzzPlugin } from "./.setup/channel-B7r1381j.mjs";
 export { buzzPlugin, getBuzzRuntime, listBuzzAccountIds, resolveBuzzAccount, resolveDefaultBuzzAccountId, setBuzzRuntime };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as buzzPlugin } from "./.setup/channel-qV8kQiPi.mjs";
+import { t as buzzPlugin } from "./.setup/channel-B7r1381j.mjs";
 export { buzzPlugin };

package/dist/directory-contract-api.js

@@ -1,4 +1,4 @@
-import { n as listBuzzDirectoryPeersFromConfig, t as listBuzzDirectoryGroupsFromConfig } from "./.setup/directory-config-CzHz6fzo.mjs";
+import { n as listBuzzDirectoryPeersFromConfig, t as listBuzzDirectoryGroupsFromConfig } from "./.setup/directory-config-M9KSexdh.mjs";
 //#region extensions/buzz/directory-contract-api.ts
 const buzzDirectoryContractPlugin = {
 	id: "buzz",