@openclaw/signal 0.0.0 → 2026.6.11-beta.2

package/dist/message-actions-Bue0g2Kc.js

@@ -0,0 +1,548 @@
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-hOCHbEhX.js";
+import { d as normalizeSignalMessagingTarget, l as looksLikeUuid } from "./identity-B6O4k8xg.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-C_PQ45D9.js";
+import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { resolveReactionLevel } from "openclaw/plugin-sdk/status-helpers";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createChannelApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, createNativeApprovalForwardingFallbackSuppressor, shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalReactionPendingContentForRequest } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { markdownToIR, renderMarkdownIRChunksWithinLimit } from "openclaw/plugin-sdk/text-chunking";
+import { createActionGate, jsonResult, readStringParam, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+//#region extensions/signal/src/approval-auth.ts
+function normalizeSignalApproverId(value) {
+	const normalized = normalizeSignalMessagingTarget(String(value));
+	if (!normalized || normalized.startsWith("group:") || normalized.startsWith("username:")) return;
+	if (looksLikeUuid(normalized)) return `uuid:${normalized}`;
+	const e164 = normalizeE164(normalized);
+	return e164.length > 1 ? e164 : void 0;
+}
+function getSignalApprovalApprovers(params) {
+	const account = resolveSignalAccount(params).config;
+	return resolveApprovalApprovers({
+		allowFrom: account.allowFrom,
+		defaultTo: account.defaultTo,
+		normalizeApprover: normalizeSignalApproverId
+	});
+}
+const signalApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Signal",
+	resolveApprovers: getSignalApprovalApprovers,
+	normalizeSenderId: (value) => normalizeSignalApproverId(value)
+});
+//#endregion
+//#region extensions/signal/src/approval-native.ts
+const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
+function isSignalApprovalTransportEnabled(params) {
+	return resolveSignalAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).enabled;
+}
+function normalizeSignalForwardTarget(target) {
+	if (normalizeLowercaseStringOrEmpty(target.channel) !== "signal") return null;
+	const to = normalizeSignalMessagingTarget(target.to);
+	if (!to) return null;
+	return {
+		to,
+		accountId: normalizeOptionalString(target.accountId),
+		threadId: target.threadId ?? null
+	};
+}
+function resolveTurnSourceSignalOriginTarget(request) {
+	if (normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel) !== "signal") return null;
+	const to = normalizeSignalMessagingTarget(request.request.turnSourceTo ?? "");
+	if (!to) return null;
+	return {
+		to,
+		accountId: normalizeOptionalString(request.request.turnSourceAccountId)
+	};
+}
+function resolveSessionSignalOriginTarget(sessionTarget) {
+	const to = normalizeSignalMessagingTarget(sessionTarget.to);
+	return to ? {
+		to,
+		accountId: normalizeOptionalString(sessionTarget.accountId)
+	} : null;
+}
+const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToSignal, canAnyApprovalPotentiallyRouteToChannel: canAnyApprovalPotentiallyRouteToSignal, isNativeApprovalHandlerConfigured: isSignalNativeApprovalHandlerConfiguredBase, isSessionApprovalEligible: isSignalSessionApprovalEligible, shouldHandleApprovalRequest: shouldHandleSignalApprovalRequest } = createNativeApprovalChannelRouteGates({
+	channel: "signal",
+	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
+	isTransportEnabled: isSignalApprovalTransportEnabled,
+	listAccountIds: listSignalAccountIds,
+	resolveDefaultAccountId: resolveDefaultSignalAccountId,
+	normalizeForwardTarget: normalizeSignalForwardTarget,
+	resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget
+});
+function isSignalNativeApprovalHandlerConfigured(params) {
+	return isSignalNativeApprovalHandlerConfiguredBase(params);
+}
+function resolveSignalSessionTargetFromSessionKey(sessionKey) {
+	const rest = parseAgentSessionKey(sessionKey)?.rest ?? normalizeOptionalString(sessionKey);
+	if (!rest || !normalizeLowercaseStringOrEmpty(rest).startsWith("signal:")) return null;
+	return normalizeSignalMessagingTarget(rest.slice(7)) ?? null;
+}
+function shouldSuppressLocalSignalExecApprovalPrompt(params) {
+	return shouldSuppressLocalNativeExecApprovalPrompt({
+		...params,
+		isTransportEnabled: isSignalApprovalTransportEnabled,
+		isSessionRouteEligible: ({ cfg, accountId, metadata }) => {
+			if (getSignalApprovalApprovers({
+				cfg,
+				accountId
+			}).length > 0) return true;
+			const sessionTarget = resolveSignalSessionTargetFromSessionKey(metadata.sessionKey);
+			return Boolean(sessionTarget && !isSignalGroupTarget(sessionTarget));
+		}
+	});
+}
+const resolveSignalOriginTargetBase = createChannelNativeOriginTargetResolver({
+	channel: "signal",
+	shouldHandleRequest: shouldHandleSignalApprovalRequest,
+	resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget,
+	resolveSessionTarget: resolveSessionSignalOriginTarget,
+	normalizeTarget: (target) => {
+		const to = normalizeSignalMessagingTarget(target.to);
+		return to ? {
+			...target,
+			to
+		} : null;
+	}
+});
+function isSignalGroupTarget(to) {
+	return normalizeLowercaseStringOrEmpty(to).startsWith("group:");
+}
+function resolveSignalOriginTarget(params) {
+	const target = resolveSignalOriginTargetBase(params);
+	if (!target) return null;
+	if (isSignalGroupTarget(target.to) && getSignalApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).length === 0) return null;
+	return target;
+}
+const resolveSignalApproverDmTargets = createChannelApproverDmTargetResolver({
+	shouldHandleRequest: shouldHandleSignalApprovalRequest,
+	resolveApprovers: getSignalApprovalApprovers,
+	mapApprover: (approver, params) => {
+		const to = normalizeSignalMessagingTarget(approver);
+		if (!to) return null;
+		return {
+			to,
+			accountId: normalizeOptionalString(params.accountId)
+		};
+	}
+});
+const shouldSuppressSignalForwardingFallback = createNativeApprovalForwardingFallbackSuppressor({
+	channel: "signal",
+	normalizeForwardTarget: normalizeSignalForwardTarget,
+	resolveAccountId: ({ forwardingTarget, request }) => forwardingTarget.accountId ?? normalizeOptionalString(request.request.turnSourceAccountId),
+	resolveForwardingTargetForMatch: ({ forwardingTarget, accountId }) => ({
+		...forwardingTarget,
+		accountId
+	}),
+	isSessionRouteEligible: isSignalSessionApprovalEligible,
+	resolveOriginTarget: resolveSignalOriginTarget,
+	resolveApproverDmTargets: resolveSignalApproverDmTargets
+});
+function buildSignalExecPendingPayload(params) {
+	return buildApprovalReactionPendingContentForRequest(params).manualFallbackPayload;
+}
+function buildSignalPluginPendingPayload(params) {
+	return buildApprovalReactionPendingContentForRequest(params).manualFallbackPayload;
+}
+const signalApprovalCapability = createChannelApprovalCapability({
+	...signalApprovalAuth,
+	getActionAvailabilityState: ({ cfg, accountId, approvalKind }) => (approvalKind ? canApprovalPotentiallyRouteToSignal({
+		cfg,
+		accountId,
+		approvalKind
+	}) : canAnyApprovalPotentiallyRouteToSignal({
+		cfg,
+		accountId
+	})) ? { kind: "enabled" } : { kind: "disabled" },
+	getExecInitiatingSurfaceState: ({ cfg, accountId }) => canApprovalPotentiallyRouteToSignal({
+		cfg,
+		accountId,
+		approvalKind: "exec"
+	}) ? { kind: "enabled" } : { kind: "disabled" },
+	describeExecApprovalSetup: ({ accountId }) => {
+		return `Signal supports native exec approvals for this account when \`approvals.exec.enabled\` is true and the route allows Signal. Link Signal and keep the gateway running; configure \`${accountId && accountId !== "default" ? `channels.signal.accounts.${accountId}` : "channels.signal"}.allowFrom\` to restrict approvers.`;
+	},
+	delivery: {
+		hasConfiguredDmRoute: ({ cfg }) => listSignalAccountIds(cfg).some((accountId) => {
+			if (!canAnyApprovalPotentiallyRouteToSignal({
+				cfg,
+				accountId,
+				nativeSessionOnly: true
+			})) return false;
+			return getSignalApprovalApprovers({
+				cfg,
+				accountId
+			}).length > 0;
+		}),
+		shouldSuppressForwardingFallback: shouldSuppressSignalForwardingFallback
+	},
+	render: {
+		exec: { buildPendingPayload: ({ request, nowMs }) => buildSignalExecPendingPayload({
+			request,
+			nowMs
+		}) },
+		plugin: { buildPendingPayload: ({ request, nowMs }) => buildSignalPluginPendingPayload({
+			request,
+			nowMs
+		}) }
+	},
+	native: {
+		describeDeliveryCapabilities: ({ cfg, accountId, approvalKind, request }) => {
+			const originTarget = resolveSignalOriginTarget({
+				cfg,
+				accountId,
+				approvalKind,
+				request
+			});
+			const approverTargets = resolveSignalApproverDmTargets({
+				cfg,
+				accountId,
+				approvalKind,
+				request
+			});
+			return {
+				enabled: Boolean(originTarget) || approverTargets.length > 0,
+				preferredSurface: originTarget ? "origin" : "approver-dm",
+				supportsOriginSurface: Boolean(originTarget),
+				supportsApproverDmSurface: approverTargets.length > 0,
+				notifyOriginWhenDmOnly: true
+			};
+		},
+		resolveOriginTarget: resolveSignalOriginTarget,
+		resolveApproverDmTargets: resolveSignalApproverDmTargets
+	},
+	nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
+		eventKinds: ["exec", "plugin"],
+		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && isSignalNativeApprovalHandlerConfigured({
+			cfg,
+			accountId
+		}),
+		shouldHandle: ({ cfg, accountId, context, request }) => Boolean(context) && shouldHandleSignalApprovalRequest({
+			cfg,
+			accountId,
+			request
+		}),
+		load: async () => (await import("./approval-handler.runtime-CeJI1wow.js")).signalApprovalNativeRuntime
+	})
+});
+//#endregion
+//#region extensions/signal/src/format.ts
+function normalizeUrlForComparison(url) {
+	let normalized = normalizeLowercaseStringOrEmpty(url);
+	normalized = normalized.replace(/^https?:\/\//, "");
+	normalized = normalized.replace(/^www\./, "");
+	normalized = normalized.replace(/\/+$/, "");
+	return normalized;
+}
+function mapStyle(style) {
+	switch (style) {
+		case "bold": return "BOLD";
+		case "italic": return "ITALIC";
+		case "strikethrough": return "STRIKETHROUGH";
+		case "code":
+		case "code_block": return "MONOSPACE";
+		case "spoiler": return "SPOILER";
+		default: return null;
+	}
+}
+function mergeStyles(styles) {
+	const sorted = [...styles].toSorted((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		if (a.length !== b.length) return a.length - b.length;
+		return a.style.localeCompare(b.style);
+	});
+	const merged = [];
+	for (const style of sorted) {
+		const prev = merged[merged.length - 1];
+		if (prev && prev.style === style.style && style.start <= prev.start + prev.length) {
+			const prevEnd = prev.start + prev.length;
+			prev.length = Math.max(prevEnd, style.start + style.length) - prev.start;
+			continue;
+		}
+		merged.push({ ...style });
+	}
+	return merged;
+}
+function clampStyles(styles, maxLength) {
+	const clamped = [];
+	for (const style of styles) {
+		const start = Math.max(0, Math.min(style.start, maxLength));
+		const length = Math.min(style.start + style.length, maxLength) - start;
+		if (length > 0) clamped.push({
+			start,
+			length,
+			style: style.style
+		});
+	}
+	return clamped;
+}
+function applyInsertionsToStyles(spans, insertions) {
+	if (insertions.length === 0) return spans;
+	const sortedInsertions = [...insertions].toSorted((a, b) => a.pos - b.pos);
+	let updated = spans;
+	let cumulativeShift = 0;
+	for (const insertion of sortedInsertions) {
+		const insertionPos = insertion.pos + cumulativeShift;
+		const next = [];
+		for (const span of updated) {
+			if (span.end <= insertionPos) {
+				next.push(span);
+				continue;
+			}
+			if (span.start >= insertionPos) {
+				next.push({
+					start: span.start + insertion.length,
+					end: span.end + insertion.length,
+					style: span.style
+				});
+				continue;
+			}
+			if (span.start < insertionPos && span.end > insertionPos) {
+				if (insertionPos > span.start) next.push({
+					start: span.start,
+					end: insertionPos,
+					style: span.style
+				});
+				const shiftedStart = insertionPos + insertion.length;
+				const shiftedEnd = span.end + insertion.length;
+				if (shiftedEnd > shiftedStart) next.push({
+					start: shiftedStart,
+					end: shiftedEnd,
+					style: span.style
+				});
+			}
+		}
+		updated = next;
+		cumulativeShift += insertion.length;
+	}
+	return updated;
+}
+function renderSignalText(ir) {
+	const text = ir.text ?? "";
+	if (!text) return {
+		text: "",
+		styles: []
+	};
+	const sortedLinks = [...ir.links].toSorted((a, b) => a.start - b.start);
+	let out = "";
+	let cursor = 0;
+	const insertions = [];
+	for (const link of sortedLinks) {
+		if (link.start < cursor) continue;
+		out += text.slice(cursor, link.end);
+		const href = link.href.trim();
+		const trimmedLabel = text.slice(link.start, link.end).trim();
+		if (href) if (!trimmedLabel) {
+			out += href;
+			insertions.push({
+				pos: link.end,
+				length: href.length
+			});
+		} else {
+			const normalizedLabel = normalizeUrlForComparison(trimmedLabel);
+			let comparableHref = href;
+			if (href.startsWith("mailto:")) comparableHref = href.slice(7);
+			if (normalizedLabel !== normalizeUrlForComparison(comparableHref)) {
+				const addition = ` (${href})`;
+				out += addition;
+				insertions.push({
+					pos: link.end,
+					length: addition.length
+				});
+			}
+		}
+		cursor = link.end;
+	}
+	out += text.slice(cursor);
+	const adjusted = applyInsertionsToStyles(ir.styles.map((span) => {
+		const mapped = mapStyle(span.style);
+		if (!mapped) return null;
+		return {
+			start: span.start,
+			end: span.end,
+			style: mapped
+		};
+	}).filter((span) => span !== null), insertions);
+	const trimmedText = out.trimEnd();
+	const trimmedLength = trimmedText.length;
+	return {
+		text: trimmedText,
+		styles: mergeStyles(clampStyles(adjusted.map((span) => ({
+			start: span.start,
+			length: span.end - span.start,
+			style: span.style
+		})), trimmedLength))
+	};
+}
+function markdownToSignalText(markdown, options = {}) {
+	return renderSignalText(markdownToIR(markdown ?? "", {
+		linkify: true,
+		enableSpoilers: true,
+		headingStyle: "bold",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	}));
+}
+function markdownToSignalTextChunks(markdown, limit, options = {}) {
+	return renderMarkdownIRChunksWithinLimit({
+		ir: markdownToIR(markdown ?? "", {
+			linkify: true,
+			enableSpoilers: true,
+			headingStyle: "bold",
+			blockquotePrefix: "> ",
+			tableMode: options.tableMode
+		}),
+		limit,
+		renderChunk: renderSignalText,
+		measureRendered: (rendered) => rendered.text.length
+	}).map(({ rendered }) => rendered);
+}
+//#endregion
+//#region extensions/signal/src/reaction-level.ts
+/**
+* Resolve the effective reaction level and its implications for Signal.
+*
+* Levels:
+* - "off": No reactions at all
+* - "ack": Only automatic ack reactions (👀 when processing), no agent reactions
+* - "minimal": Agent can react, but sparingly (default)
+* - "extensive": Agent can react liberally
+*/
+function resolveSignalReactionLevel(params) {
+	return resolveReactionLevel({
+		value: resolveSignalAccount({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}).config.reactionLevel,
+		defaultLevel: "minimal",
+		invalidFallback: "minimal"
+	});
+}
+//#endregion
+//#region extensions/signal/src/message-actions.ts
+const providerId = "signal";
+const GROUP_PREFIX = "group:";
+function normalizeSignalReactionRecipient(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return trimmed;
+	const withoutSignal = trimmed.replace(/^signal:/i, "").trim();
+	if (!withoutSignal) return withoutSignal;
+	if (normalizeLowercaseStringOrEmpty(withoutSignal).startsWith("uuid:")) return withoutSignal.slice(5).trim();
+	return withoutSignal;
+}
+function resolveSignalReactionTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const withoutSignal = trimmed.replace(/^signal:/i, "").trim();
+	if (!withoutSignal) return {};
+	if (normalizeLowercaseStringOrEmpty(withoutSignal).startsWith(GROUP_PREFIX)) {
+		const groupId = withoutSignal.slice(6).trim();
+		return groupId ? { groupId } : {};
+	}
+	return { recipient: normalizeSignalReactionRecipient(withoutSignal) };
+}
+async function mutateSignalReaction(params) {
+	const options = {
+		cfg: params.cfg,
+		accountId: params.accountId,
+		groupId: params.target.groupId,
+		targetAuthor: params.targetAuthor,
+		targetAuthorUuid: params.targetAuthorUuid
+	};
+	if (params.remove) {
+		await removeReactionSignal(params.target.recipient ?? "", params.timestamp, params.emoji, options);
+		return jsonResult({
+			ok: true,
+			removed: params.emoji
+		});
+	}
+	await sendReactionSignal(params.target.recipient ?? "", params.timestamp, params.emoji, options);
+	return jsonResult({
+		ok: true,
+		added: params.emoji
+	});
+}
+const signalMessageActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		const configuredAccounts = accountId ? [resolveSignalAccount({
+			cfg,
+			accountId
+		})].filter((account) => account.enabled && account.configured) : listEnabledSignalAccounts(cfg).filter((account) => account.configured);
+		if (configuredAccounts.length === 0) return null;
+		const actions = new Set(["send"]);
+		if (configuredAccounts.some((account) => createActionGate(account.config.actions)("reactions"))) actions.add("react");
+		return { actions: Array.from(actions) };
+	},
+	supportsAction: ({ action }) => action !== "send",
+	handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
+		if (action === "send") throw new Error("Send should be handled by outbound, not actions handler.");
+		if (action === "react") {
+			const reactionLevelInfo = resolveSignalReactionLevel({
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`Signal agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.signal.reactionLevel to "minimal" or "extensive" to enable.`);
+			const actionConfig = resolveSignalAccount({
+				cfg,
+				accountId
+			}).config.actions;
+			if (!createActionGate(actionConfig)("reactions")) throw new Error("Signal reactions are disabled via actions.reactions.");
+			const target = resolveSignalReactionTarget(readStringParam(params, "recipient") ?? readStringParam(params, "to", {
+				required: true,
+				label: "recipient (UUID, phone number, or group)"
+			}));
+			if (!target.recipient && !target.groupId) throw new Error("recipient or group required");
+			const messageIdRaw = resolveReactionMessageId({
+				args: params,
+				toolContext
+			});
+			const messageId = messageIdRaw != null ? String(messageIdRaw) : void 0;
+			if (!messageId) throw new Error("messageId (timestamp) required. Provide messageId explicitly or react to the current inbound message.");
+			const targetAuthor = readStringParam(params, "targetAuthor");
+			const targetAuthorUuid = readStringParam(params, "targetAuthorUuid");
+			if (target.groupId && !targetAuthor && !targetAuthorUuid) throw new Error("targetAuthor or targetAuthorUuid required for group reactions.");
+			const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+			const remove = typeof params.remove === "boolean" ? params.remove : void 0;
+			const timestamp = parseStrictNonNegativeInteger(messageId);
+			if (timestamp === void 0) throw new Error(`Invalid messageId: ${messageId}. Expected numeric timestamp.`);
+			if (remove) {
+				if (!emoji) throw new Error("Emoji required to remove reaction.");
+				return await mutateSignalReaction({
+					cfg,
+					accountId: accountId ?? void 0,
+					target,
+					timestamp,
+					emoji,
+					remove: true,
+					targetAuthor,
+					targetAuthorUuid
+				});
+			}
+			if (!emoji) throw new Error("Emoji required to add reaction.");
+			return await mutateSignalReaction({
+				cfg,
+				accountId: accountId ?? void 0,
+				target,
+				timestamp,
+				emoji,
+				remove: false,
+				targetAuthor,
+				targetAuthorUuid
+			});
+		}
+		throw new Error(`Action ${action} not supported for ${providerId}.`);
+	}
+};
+//#endregion
+export { isSignalNativeApprovalHandlerConfigured as a, getSignalApprovalApprovers as c, markdownToSignalTextChunks as i, signalApprovalAuth as l, resolveSignalReactionLevel as n, shouldSuppressLocalSignalExecApprovalPrompt as o, markdownToSignalText as r, signalApprovalCapability as s, signalMessageActions as t };