@openclaw/signal 2026.6.11 → 2026.7.1-beta.2

package/dist/{accounts-hOCHbEhX.js → accounts-B7Rz3_xV.js}

@@ -8,7 +8,8 @@ function mergeSignalAccountConfig(cfg, accountId) {
 	return resolveMergedAccountConfig({
 		channelConfig: cfg.channels?.signal,
 		accounts: cfg.channels?.signal?.accounts,
-		accountId
+		accountId,
+		nestedObjectKeys: ["aliases"]
 	});
 }
 function resolveSignalAccount(params) {

package/dist/api.js

@@ -1,12 +1,12 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-hOCHbEhX.js";
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-B7Rz3_xV.js";
 import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
-import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, r as markdownToSignalText, t as signalMessageActions } from "./message-actions-Bue0g2Kc.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-C_PQ45D9.js";
-import { a as normalizeSignalAccountInput, l as signalSetupAdapter, n as createSignalPluginBase, r as signalSetupWizard, t as signalPlugin, u as resolveSignalOutboundTarget } from "./channel-LmY2UpOt.js";
-import { a as looksLikeArchive, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli } from "./install-signal-cli-CXgTF3de.js";
-import { t as monitorSignalProvider } from "./monitor-CUhIKHJo.js";
-import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CBlFUkY_.js";
-import { t as probeSignal } from "./probe-BQ_Izoya.js";
+import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, r as markdownToSignalText, t as signalMessageActions } from "./message-actions-Cs9XckSd.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BkAxQPGs.js";
+import { a as normalizeSignalAccountInput, l as signalSetupAdapter, n as createSignalPluginBase, r as signalSetupWizard, t as signalPlugin, u as resolveSignalOutboundTarget } from "./channel-BfWp-F-r.js";
+import { a as looksLikeArchive, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli } from "./install-signal-cli-TwhJ0DGy.js";
+import { t as monitorSignalProvider } from "./monitor-C9SiyrFt.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CLzc3RUg.js";
+import { t as probeSignal } from "./probe-BL2BqTbG.js";
 //#region extensions/signal/src/channel.setup.ts
 const signalSetupPlugin = { ...createSignalPluginBase({
 	setupWizard: signalSetupWizard,

package/dist/approval-auth-DPVK9A_l.js

@@ -0,0 +1,151 @@
+import { i as resolveSignalAccount } from "./accounts-B7Rz3_xV.js";
+import { d as normalizeSignalMessagingTarget, l as looksLikeUuid, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/signal/src/aliases.ts
+function normalizeAliasKey(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	return normalizeLowercaseStringOrEmpty(/^signal:/i.test(trimmed) ? trimmed.slice(7).trim() : trimmed) || void 0;
+}
+function resolveAliasMap(params) {
+	const account = resolveSignalAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const aliases = /* @__PURE__ */ new Map();
+	for (const [rawKey, rawValue] of Object.entries(account.config.aliases ?? {})) {
+		const key = normalizeAliasKey(rawKey);
+		if (!key) continue;
+		aliases.set(key, rawValue);
+	}
+	return aliases;
+}
+function resolveTargetKind(target) {
+	return normalizeLowercaseStringOrEmpty(target).startsWith("group:") ? "group" : "user";
+}
+function resolveRawSignalTarget(input) {
+	const normalized = normalizeSignalMessagingTarget(input);
+	if (!normalized || !looksLikeSignalTargetId(input, normalized)) return null;
+	return {
+		to: normalized,
+		kind: resolveTargetKind(normalized)
+	};
+}
+function resolveSignalAliasTargetFromMap(params) {
+	const initialAlias = normalizeAliasKey(params.input);
+	if (!initialAlias || !params.aliases.has(initialAlias)) return null;
+	const visited = /* @__PURE__ */ new Set();
+	let alias = initialAlias;
+	for (;;) {
+		if (visited.has(alias)) throw new Error(`Signal alias "${initialAlias}" resolves recursively through "${alias}".`);
+		visited.add(alias);
+		const rawValue = params.aliases.get(alias);
+		if (typeof rawValue !== "string" || !rawValue.trim()) throw new Error(`Signal alias "${alias}" must point to a non-empty Signal target.`);
+		const rawTarget = resolveRawSignalTarget(rawValue);
+		if (rawTarget) return {
+			...rawTarget,
+			alias: initialAlias
+		};
+		const nextAlias = normalizeAliasKey(rawValue);
+		if (nextAlias && params.aliases.has(nextAlias)) {
+			alias = nextAlias;
+			continue;
+		}
+		throw new Error(`Signal alias "${initialAlias}" must point to an E.164 number, uuid:<id>, username:<name>, or group:<id>.`);
+	}
+}
+function resolveSignalAliasTarget(params) {
+	return resolveSignalAliasTargetFromMap({
+		aliases: resolveAliasMap(params),
+		input: params.input
+	});
+}
+function resolveSignalTarget(params) {
+	const rawTarget = resolveRawSignalTarget(params.input);
+	if (rawTarget) return {
+		...rawTarget,
+		source: "raw"
+	};
+	const aliasTarget = resolveSignalAliasTarget(params);
+	if (aliasTarget) return {
+		...aliasTarget,
+		source: "alias"
+	};
+	return null;
+}
+function listSignalAliasDirectoryEntries(params) {
+	const aliases = resolveAliasMap(params);
+	const query = normalizeLowercaseStringOrEmpty(params.query);
+	const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : void 0;
+	const exactAlias = params.query ? normalizeAliasKey(params.query) : void 0;
+	if (exactAlias && aliases.has(exactAlias)) {
+		const target = resolveSignalAliasTargetFromMap({
+			aliases,
+			input: exactAlias
+		});
+		if (target?.kind === params.kind) return [{
+			kind: params.kind,
+			id: target.to,
+			name: target.alias
+		}];
+		if (target) return [];
+	}
+	const entries = [];
+	for (const alias of aliases.keys()) {
+		let target;
+		try {
+			target = resolveSignalAliasTargetFromMap({
+				aliases,
+				input: alias
+			});
+		} catch {
+			continue;
+		}
+		if (!target) continue;
+		if (target.kind !== params.kind) continue;
+		if (query && !alias.includes(query) && !normalizeLowercaseStringOrEmpty(target.to).includes(query)) continue;
+		entries.push({
+			kind: params.kind,
+			id: target.to,
+			name: alias
+		});
+		if (typeof limit === "number" && entries.length >= limit) break;
+	}
+	return entries;
+}
+//#endregion
+//#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;
+	let defaultTo = account.defaultTo;
+	if (typeof account.defaultTo === "string") try {
+		defaultTo = resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: account.defaultTo
+		})?.to ?? account.defaultTo;
+	} catch {
+		defaultTo = account.defaultTo;
+	}
+	return resolveApprovalApprovers({
+		allowFrom: account.allowFrom,
+		defaultTo,
+		normalizeApprover: normalizeSignalApproverId
+	});
+}
+const signalApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Signal",
+	resolveApprovers: getSignalApprovalApprovers,
+	normalizeSenderId: (value) => normalizeSignalApproverId(value)
+});
+//#endregion
+export { resolveSignalTarget as i, signalApprovalAuth as n, listSignalAliasDirectoryEntries as r, getSignalApprovalApprovers as t };

package/dist/{approval-handler.runtime-CeJI1wow.js → approval-handler.runtime-BZLgs7EM.js}

@@ -1,5 +1,8 @@
+import { r as resolveDefaultSignalAccountId } from "./accounts-B7Rz3_xV.js";
 import { d as normalizeSignalMessagingTarget } from "./identity-B6O4k8xg.js";
-import { c as resolveSignalApprovalTargetAuthorKeys, i as hasSignalApprovalReactionApprovers, l as unregisterSignalApprovalReactionTarget, o as registerSignalApprovalReactionTarget, r as sendTypingSignal, s as resolveSignalApprovalConversationKey, t as sendMessageSignal } from "./send-CBlFUkY_.js";
+import { i as resolveSignalTarget } from "./approval-auth-DPVK9A_l.js";
+import { a as registerSignalApprovalReactionTarget, c as resolveSignalApprovalTargetAuthorKeys, l as unregisterSignalApprovalReactionTarget, r as hasSignalApprovalReactionApprovers, s as resolveSignalApprovalConversationKey } from "./approval-reactions-5x1kmQEq.js";
+import { r as sendTypingSignal, t as sendMessageSignal } from "./send-CLzc3RUg.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
@@ -48,8 +51,28 @@ const signalApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 		})
 	},
 	transport: {
-		prepareTarget: ({ plannedTarget, accountId, context }) => {
-			const to = normalizeSignalMessagingTarget(plannedTarget.target.to);
+		prepareTarget: ({ cfg, plannedTarget, accountId, context }) => {
+			const plannedAccountId = plannedTarget.target.accountId;
+			const explicitAccountId = resolvePreparedApprovalAccountId({
+				plannedAccountId,
+				contextAccountId: accountId
+			});
+			const preparedAccountId = resolvePreparedApprovalAccountId({
+				plannedAccountId,
+				contextAccountId: accountId,
+				fallbackAccountId: cfg ? resolveDefaultSignalAccountId(cfg) : DEFAULT_ACCOUNT_ID
+			});
+			const rawTo = plannedTarget.target.to;
+			let to = normalizeSignalMessagingTarget(rawTo);
+			if (cfg) try {
+				to = resolveSignalTarget({
+					cfg,
+					accountId: explicitAccountId,
+					input: rawTo
+				})?.to ?? to;
+			} catch {
+				return null;
+			}
 			if (!to) return null;
 			const runtimeContext = readSignalApprovalRuntimeContext(context);
 			const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys({
@@ -58,11 +81,7 @@ const signalApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 			});
 			const prepared = {
 				to,
-				accountId: resolvePreparedApprovalAccountId({
-					plannedAccountId: plannedTarget.target.accountId,
-					contextAccountId: accountId,
-					fallbackAccountId: DEFAULT_ACCOUNT_ID
-				}),
+				accountId: preparedAccountId,
 				...runtimeContext.baseUrl ? { baseUrl: runtimeContext.baseUrl } : {},
 				...runtimeContext.account ? { account: runtimeContext.account } : {},
 				...runtimeContext.accountUuid ? { accountUuid: runtimeContext.accountUuid } : {},
@@ -124,6 +143,7 @@ const signalApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 				conversationKey: entry.conversationKey,
 				messageId: entry.messageId,
 				approvalId: request.id,
+				approvalKind: view.approvalKind,
 				allowedDecisions: pendingPayload.reactionPayload.allowedDecisions,
 				targetAuthorKeys: entry.targetAuthorKeys,
 				route: {