remoteclaw 0.1.0-next.2abd2fa → 0.1.0-next.2b10b69

package/dist/ack-reactions-CLsQr2VU.js

@@ -0,0 +1,446 @@
+import { t as normalizeChatType } from "./chat-type-BKe459rw.js";
+import { t as formatCliCommand } from "./command-format-KkslAzwV.js";
+import { O as CURRENT_MESSAGE_MARKER, a as resolveTimezone, i as formatZonedTimestamp, p as resolveUserTimezone, r as formatUtcTimestamp, u as resolveSenderLabel } from "./reply-BaiBy5TB.js";
+import { n as formatTimeAgo } from "./format-relative-8cNYQsqb.js";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+
+//#region src/infra/backoff.ts
+function computeBackoff(policy, attempt) {
+	const base = policy.initialMs * policy.factor ** Math.max(attempt - 1, 0);
+	const jitter = base * policy.jitter * Math.random();
+	return Math.min(policy.maxMs, Math.round(base + jitter));
+}
+async function sleepWithAbort(ms, abortSignal) {
+	if (ms <= 0) return;
+	try {
+		await setTimeout$1(ms, void 0, { signal: abortSignal });
+	} catch (err) {
+		if (abortSignal?.aborted) throw new Error("aborted", { cause: err });
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/auto-reply/inbound-debounce.ts
+const resolveMs = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return Math.max(0, Math.trunc(value));
+};
+const resolveChannelOverride = (params) => {
+	if (!params.byChannel) return;
+	return resolveMs(params.byChannel[params.channel]);
+};
+function resolveInboundDebounceMs(params) {
+	const inbound = params.cfg.messages?.inbound;
+	const override = resolveMs(params.overrideMs);
+	const byChannel = resolveChannelOverride({
+		byChannel: inbound?.byChannel,
+		channel: params.channel
+	});
+	const base = resolveMs(inbound?.debounceMs);
+	return override ?? byChannel ?? base ?? 0;
+}
+function createInboundDebouncer(params) {
+	const buffers = /* @__PURE__ */ new Map();
+	const defaultDebounceMs = Math.max(0, Math.trunc(params.debounceMs));
+	const resolveDebounceMs = (item) => {
+		const resolved = params.resolveDebounceMs?.(item);
+		if (typeof resolved !== "number" || !Number.isFinite(resolved)) return defaultDebounceMs;
+		return Math.max(0, Math.trunc(resolved));
+	};
+	const flushBuffer = async (key, buffer) => {
+		buffers.delete(key);
+		if (buffer.timeout) {
+			clearTimeout(buffer.timeout);
+			buffer.timeout = null;
+		}
+		if (buffer.items.length === 0) return;
+		try {
+			await params.onFlush(buffer.items);
+		} catch (err) {
+			params.onError?.(err, buffer.items);
+		}
+	};
+	const flushKey = async (key) => {
+		const buffer = buffers.get(key);
+		if (!buffer) return;
+		await flushBuffer(key, buffer);
+	};
+	const scheduleFlush = (key, buffer) => {
+		if (buffer.timeout) clearTimeout(buffer.timeout);
+		buffer.timeout = setTimeout(() => {
+			flushBuffer(key, buffer);
+		}, buffer.debounceMs);
+		buffer.timeout.unref?.();
+	};
+	const enqueue = async (item) => {
+		const key = params.buildKey(item);
+		const debounceMs = resolveDebounceMs(item);
+		if (!(debounceMs > 0 && (params.shouldDebounce?.(item) ?? true)) || !key) {
+			if (key && buffers.has(key)) await flushKey(key);
+			await params.onFlush([item]);
+			return;
+		}
+		const existing = buffers.get(key);
+		if (existing) {
+			existing.items.push(item);
+			existing.debounceMs = debounceMs;
+			scheduleFlush(key, existing);
+			return;
+		}
+		const buffer = {
+			items: [item],
+			timeout: null,
+			debounceMs
+		};
+		buffers.set(key, buffer);
+		scheduleFlush(key, buffer);
+	};
+	return {
+		enqueue,
+		flushKey
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/history.ts
+const HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
+const DEFAULT_GROUP_HISTORY_LIMIT = 50;
+/** Maximum number of group history keys to retain (LRU eviction when exceeded). */
+const MAX_HISTORY_KEYS = 1e3;
+/**
+* Evict oldest keys from a history map when it exceeds MAX_HISTORY_KEYS.
+* Uses Map's insertion order for LRU-like behavior.
+*/
+function evictOldHistoryKeys(historyMap, maxKeys = MAX_HISTORY_KEYS) {
+	if (historyMap.size <= maxKeys) return;
+	const keysToDelete = historyMap.size - maxKeys;
+	const iterator = historyMap.keys();
+	for (let i = 0; i < keysToDelete; i++) {
+		const key = iterator.next().value;
+		if (key !== void 0) historyMap.delete(key);
+	}
+}
+function buildHistoryContext(params) {
+	const { historyText, currentMessage } = params;
+	const lineBreak = params.lineBreak ?? "\n";
+	if (!historyText.trim()) return currentMessage;
+	return [
+		HISTORY_CONTEXT_MARKER,
+		historyText,
+		"",
+		CURRENT_MESSAGE_MARKER,
+		currentMessage
+	].join(lineBreak);
+}
+function appendHistoryEntry(params) {
+	const { historyMap, historyKey, entry } = params;
+	if (params.limit <= 0) return [];
+	const history = historyMap.get(historyKey) ?? [];
+	history.push(entry);
+	while (history.length > params.limit) history.shift();
+	if (historyMap.has(historyKey)) historyMap.delete(historyKey);
+	historyMap.set(historyKey, history);
+	evictOldHistoryKeys(historyMap);
+	return history;
+}
+function recordPendingHistoryEntry(params) {
+	return appendHistoryEntry(params);
+}
+function recordPendingHistoryEntryIfEnabled(params) {
+	if (!params.entry) return [];
+	if (params.limit <= 0) return [];
+	return recordPendingHistoryEntry({
+		historyMap: params.historyMap,
+		historyKey: params.historyKey,
+		entry: params.entry,
+		limit: params.limit
+	});
+}
+function buildPendingHistoryContextFromMap(params) {
+	if (params.limit <= 0) return params.currentMessage;
+	return buildHistoryContextFromEntries({
+		entries: params.historyMap.get(params.historyKey) ?? [],
+		currentMessage: params.currentMessage,
+		formatEntry: params.formatEntry,
+		lineBreak: params.lineBreak,
+		excludeLast: false
+	});
+}
+function clearHistoryEntries(params) {
+	params.historyMap.set(params.historyKey, []);
+}
+function clearHistoryEntriesIfEnabled(params) {
+	if (params.limit <= 0) return;
+	clearHistoryEntries({
+		historyMap: params.historyMap,
+		historyKey: params.historyKey
+	});
+}
+function buildHistoryContextFromEntries(params) {
+	const lineBreak = params.lineBreak ?? "\n";
+	const entries = params.excludeLast === false ? params.entries : params.entries.slice(0, -1);
+	if (entries.length === 0) return params.currentMessage;
+	return buildHistoryContext({
+		historyText: entries.map(params.formatEntry).join(lineBreak),
+		currentMessage: params.currentMessage,
+		lineBreak
+	});
+}
+
+//#endregion
+//#region src/config/runtime-group-policy.ts
+function resolveRuntimeGroupPolicy(params) {
+	const configuredFallbackPolicy = params.configuredFallbackPolicy ?? "open";
+	const missingProviderFallbackPolicy = params.missingProviderFallbackPolicy ?? "allowlist";
+	return {
+		groupPolicy: params.providerConfigPresent ? params.groupPolicy ?? params.defaultGroupPolicy ?? configuredFallbackPolicy : params.groupPolicy ?? missingProviderFallbackPolicy,
+		providerMissingFallbackApplied: !params.providerConfigPresent && params.groupPolicy === void 0
+	};
+}
+function resolveDefaultGroupPolicy(cfg) {
+	return cfg.channels?.defaults?.groupPolicy;
+}
+const GROUP_POLICY_BLOCKED_LABEL = {
+	group: "group messages",
+	guild: "guild messages",
+	room: "room messages",
+	channel: "channel messages",
+	space: "space messages"
+};
+/**
+* Standard provider runtime policy:
+* - configured provider fallback: open
+* - missing provider fallback: allowlist (fail-closed)
+*/
+function resolveOpenProviderRuntimeGroupPolicy(params) {
+	return resolveRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy,
+		configuredFallbackPolicy: "open",
+		missingProviderFallbackPolicy: "allowlist"
+	});
+}
+/**
+* Strict provider runtime policy:
+* - configured provider fallback: allowlist
+* - missing provider fallback: allowlist (fail-closed)
+*/
+function resolveAllowlistProviderRuntimeGroupPolicy(params) {
+	return resolveRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy,
+		configuredFallbackPolicy: "allowlist",
+		missingProviderFallbackPolicy: "allowlist"
+	});
+}
+const warnedMissingProviderGroupPolicy = /* @__PURE__ */ new Set();
+function warnMissingProviderGroupPolicyFallbackOnce(params) {
+	if (!params.providerMissingFallbackApplied) return false;
+	const key = `${params.providerKey}:${params.accountId ?? "*"}`;
+	if (warnedMissingProviderGroupPolicy.has(key)) return false;
+	warnedMissingProviderGroupPolicy.add(key);
+	const blockedLabel = params.blockedLabel?.trim() || "group messages";
+	params.log(`${params.providerKey}: channels.${params.providerKey} is missing; defaulting groupPolicy to "allowlist" (${blockedLabel} blocked until explicitly configured).`);
+	return true;
+}
+
+//#endregion
+//#region src/pairing/pairing-messages.ts
+function buildPairingReply(params) {
+	const { channel, idLine, code } = params;
+	return [
+		"RemoteClaw: access not configured.",
+		"",
+		idLine,
+		"",
+		`Pairing code: ${code}`,
+		"",
+		"Ask the bot owner to approve with:",
+		formatCliCommand(`remoteclaw pairing approve ${channel} ${code}`)
+	].join("\n");
+}
+
+//#endregion
+//#region src/channels/mention-gating.ts
+function resolveMentionGating(params) {
+	const implicit = params.implicitMention === true;
+	const bypass = params.shouldBypassMention === true;
+	const effectiveWasMentioned = params.wasMentioned || implicit || bypass;
+	return {
+		effectiveWasMentioned,
+		shouldSkip: params.requireMention && params.canDetectMention && !effectiveWasMentioned
+	};
+}
+function resolveMentionGatingWithBypass(params) {
+	const shouldBypassMention = params.isGroup && params.requireMention && !params.wasMentioned && !(params.hasAnyMention ?? false) && params.allowTextCommands && params.commandAuthorized && params.hasControlCommand;
+	return {
+		...resolveMentionGating({
+			requireMention: params.requireMention,
+			canDetectMention: params.canDetectMention,
+			wasMentioned: params.wasMentioned,
+			implicitMention: params.implicitMention,
+			shouldBypassMention
+		}),
+		shouldBypassMention
+	};
+}
+
+//#endregion
+//#region src/auto-reply/envelope.ts
+function sanitizeEnvelopeHeaderPart(value) {
+	return value.replace(/\r\n|\r|\n/g, " ").replaceAll("[", "(").replaceAll("]", ")").replace(/\s+/g, " ").trim();
+}
+function resolveEnvelopeFormatOptions(cfg) {
+	const defaults = cfg?.agents?.defaults;
+	return {
+		timezone: defaults?.envelopeTimezone,
+		includeTimestamp: defaults?.envelopeTimestamp !== "off",
+		includeElapsed: defaults?.envelopeElapsed !== "off",
+		userTimezone: defaults?.userTimezone
+	};
+}
+function normalizeEnvelopeOptions(options) {
+	const includeTimestamp = options?.includeTimestamp !== false;
+	const includeElapsed = options?.includeElapsed !== false;
+	return {
+		timezone: options?.timezone?.trim() || "local",
+		includeTimestamp,
+		includeElapsed,
+		userTimezone: options?.userTimezone
+	};
+}
+function resolveEnvelopeTimezone(options) {
+	const trimmed = options.timezone?.trim();
+	if (!trimmed) return { mode: "local" };
+	const lowered = trimmed.toLowerCase();
+	if (lowered === "utc" || lowered === "gmt") return { mode: "utc" };
+	if (lowered === "local" || lowered === "host") return { mode: "local" };
+	if (lowered === "user") return {
+		mode: "iana",
+		timeZone: resolveUserTimezone(options.userTimezone)
+	};
+	const explicit = resolveTimezone(trimmed);
+	return explicit ? {
+		mode: "iana",
+		timeZone: explicit
+	} : { mode: "utc" };
+}
+function formatTimestamp(ts, options) {
+	if (!ts) return;
+	const resolved = normalizeEnvelopeOptions(options);
+	if (!resolved.includeTimestamp) return;
+	const date = ts instanceof Date ? ts : new Date(ts);
+	if (Number.isNaN(date.getTime())) return;
+	const zone = resolveEnvelopeTimezone(resolved);
+	const weekday = (() => {
+		try {
+			if (zone.mode === "utc") return new Intl.DateTimeFormat("en-US", {
+				timeZone: "UTC",
+				weekday: "short"
+			}).format(date);
+			if (zone.mode === "local") return new Intl.DateTimeFormat("en-US", { weekday: "short" }).format(date);
+			return new Intl.DateTimeFormat("en-US", {
+				timeZone: zone.timeZone,
+				weekday: "short"
+			}).format(date);
+		} catch {
+			return;
+		}
+	})();
+	const formatted = zone.mode === "utc" ? formatUtcTimestamp(date) : zone.mode === "local" ? formatZonedTimestamp(date) : formatZonedTimestamp(date, { timeZone: zone.timeZone });
+	if (!formatted) return;
+	return weekday ? `${weekday} ${formatted}` : formatted;
+}
+function formatAgentEnvelope(params) {
+	const parts = [sanitizeEnvelopeHeaderPart(params.channel?.trim() || "Channel")];
+	const resolved = normalizeEnvelopeOptions(params.envelope);
+	let elapsed;
+	if (resolved.includeElapsed && params.timestamp && params.previousTimestamp) {
+		const elapsedMs = (params.timestamp instanceof Date ? params.timestamp.getTime() : params.timestamp) - (params.previousTimestamp instanceof Date ? params.previousTimestamp.getTime() : params.previousTimestamp);
+		elapsed = Number.isFinite(elapsedMs) && elapsedMs >= 0 ? formatTimeAgo(elapsedMs, { suffix: false }) : void 0;
+	}
+	if (params.from?.trim()) {
+		const from = sanitizeEnvelopeHeaderPart(params.from.trim());
+		parts.push(elapsed ? `${from} +${elapsed}` : from);
+	} else if (elapsed) parts.push(`+${elapsed}`);
+	if (params.host?.trim()) parts.push(sanitizeEnvelopeHeaderPart(params.host.trim()));
+	if (params.ip?.trim()) parts.push(sanitizeEnvelopeHeaderPart(params.ip.trim()));
+	const ts = formatTimestamp(params.timestamp, resolved);
+	if (ts) parts.push(ts);
+	return `${`[${parts.join(" ")}]`} ${params.body}`;
+}
+function formatInboundEnvelope(params) {
+	const chatType = normalizeChatType(params.chatType);
+	const isDirect = !chatType || chatType === "direct";
+	const resolvedSenderRaw = params.senderLabel?.trim() || resolveSenderLabel(params.sender ?? {});
+	const resolvedSender = resolvedSenderRaw ? sanitizeEnvelopeHeaderPart(resolvedSenderRaw) : "";
+	const body = !isDirect && resolvedSender ? `${resolvedSender}: ${params.body}` : params.body;
+	return formatAgentEnvelope({
+		channel: params.channel,
+		from: params.from,
+		timestamp: params.timestamp,
+		previousTimestamp: params.previousTimestamp,
+		envelope: params.envelope,
+		body
+	});
+}
+function formatInboundFromLabel(params) {
+	if (params.isGroup) {
+		const label = params.groupLabel?.trim() || params.groupFallback || "Group";
+		const id = params.groupId?.trim();
+		return id ? `${label} id:${id}` : label;
+	}
+	const directLabel = params.directLabel.trim();
+	const directId = params.directId?.trim();
+	if (!directId || directId === directLabel) return directLabel;
+	return `${directLabel} id:${directId}`;
+}
+
+//#endregion
+//#region src/channels/ack-reactions.ts
+function shouldAckReaction(params) {
+	const scope = params.scope ?? "group-mentions";
+	if (scope === "off" || scope === "none") return false;
+	if (scope === "all") return true;
+	if (scope === "direct") return params.isDirect;
+	if (scope === "group-all") return params.isGroup;
+	if (scope === "group-mentions") {
+		if (!params.isMentionableGroup) return false;
+		if (!params.requireMention) return false;
+		if (!params.canDetectMention) return false;
+		return params.effectiveWasMentioned || params.shouldBypassMention === true;
+	}
+	return false;
+}
+function shouldAckReactionForWhatsApp(params) {
+	if (!params.emoji) return false;
+	if (params.isDirect) return params.directEnabled;
+	if (!params.isGroup) return false;
+	if (params.groupMode === "never") return false;
+	if (params.groupMode === "always") return true;
+	return shouldAckReaction({
+		scope: "group-mentions",
+		isDirect: false,
+		isGroup: true,
+		isMentionableGroup: true,
+		requireMention: true,
+		canDetectMention: true,
+		effectiveWasMentioned: params.wasMentioned,
+		shouldBypassMention: params.groupActivated
+	});
+}
+function removeAckReactionAfterReply(params) {
+	if (!params.removeAfterReply) return;
+	if (!params.ackReactionPromise) return;
+	if (!params.ackReactionValue) return;
+	params.ackReactionPromise.then((didAck) => {
+		if (!didAck) return;
+		params.remove().catch((err) => params.onError?.(err));
+	});
+}
+
+//#endregion
+export { computeBackoff as C, resolveInboundDebounceMs as S, buildHistoryContextFromEntries as _, formatInboundEnvelope as a, recordPendingHistoryEntryIfEnabled as b, resolveMentionGating as c, GROUP_POLICY_BLOCKED_LABEL as d, resolveAllowlistProviderRuntimeGroupPolicy as f, DEFAULT_GROUP_HISTORY_LIMIT as g, warnMissingProviderGroupPolicyFallbackOnce as h, formatAgentEnvelope as i, resolveMentionGatingWithBypass as l, resolveOpenProviderRuntimeGroupPolicy as m, shouldAckReaction as n, formatInboundFromLabel as o, resolveDefaultGroupPolicy as p, shouldAckReactionForWhatsApp as r, resolveEnvelopeFormatOptions as s, removeAckReactionAfterReply as t, buildPairingReply as u, buildPendingHistoryContextFromMap as v, sleepWithAbort as w, createInboundDebouncer as x, clearHistoryEntriesIfEnabled as y };