@openclaw/signal 0.0.0 → 2026.6.11

package/README.md

@@ -1,3 +1,13 @@
-# @openclaw/signal
+# Signal OpenClaw channel
 
-Bootstrap reservation for the OpenClaw Signal channel package.
+Official OpenClaw channel plugin for Signal.
+
+## Install
+
+```sh
+openclaw plugins install @openclaw/signal
+```
+
+## Docs
+
+See `docs/channels/signal.md` in the OpenClaw repository, or the published docs at `https://docs.openclaw.ai/channels/signal`.

package/dist/accounts-hOCHbEhX.js

@@ -0,0 +1,40 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createAccountListHelpers, normalizeAccountId, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+//#region extensions/signal/src/accounts.ts
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("signal", { implicitDefaultAccount: { channelKeys: ["account"] } });
+const listSignalAccountIds = listAccountIds;
+const resolveDefaultSignalAccountId = resolveDefaultAccountId;
+function mergeSignalAccountConfig(cfg, accountId) {
+	return resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.signal,
+		accounts: cfg.channels?.signal?.accounts,
+		accountId
+	});
+}
+function resolveSignalAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSignalAccountId(params.cfg));
+	const baseEnabled = params.cfg.channels?.signal?.enabled !== false;
+	const merged = mergeSignalAccountConfig(params.cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const host = normalizeOptionalString(merged.httpHost) ?? "127.0.0.1";
+	const port = merged.httpPort ?? 8080;
+	const baseUrl = normalizeOptionalString(merged.httpUrl) ?? `http://${host}:${port}`;
+	const configured = Boolean(normalizeOptionalString(merged.account) || normalizeOptionalString(merged.configPath) || normalizeOptionalString(merged.httpUrl) || normalizeOptionalString(merged.cliPath) || normalizeOptionalString(merged.httpHost) || typeof merged.httpPort === "number" || typeof merged.autoStart === "boolean");
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		baseUrl,
+		configured,
+		config: merged
+	};
+}
+function listEnabledSignalAccounts(cfg) {
+	return listSignalAccountIds(cfg).map((accountId) => resolveSignalAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resolveSignalAccount as i, listSignalAccountIds as n, resolveDefaultSignalAccountId as r, listEnabledSignalAccounts as t };

package/dist/api.js

@@ -0,0 +1,16 @@
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-hOCHbEhX.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";
+//#region extensions/signal/src/channel.setup.ts
+const signalSetupPlugin = { ...createSignalPluginBase({
+	setupWizard: signalSetupWizard,
+	setup: signalSetupAdapter
+}) };
+//#endregion
+export { extractSignalCliArchive, formatSignalPairingIdLine, formatSignalSenderDisplay, formatSignalSenderId, installSignalCli, isSignalSenderAllowed, listEnabledSignalAccounts, listSignalAccountIds, looksLikeArchive, looksLikeSignalTargetId, looksLikeUuid, markdownToSignalText, markdownToSignalTextChunks, monitorSignalProvider, normalizeSignalAccountInput, normalizeSignalAllowRecipient, normalizeSignalMessagingTarget, pickAsset, probeSignal, removeReactionSignal, resolveDefaultSignalAccountId, resolveSignalAccount, resolveSignalOutboundTarget, resolveSignalPeerId, resolveSignalReactionLevel, resolveSignalRecipient, resolveSignalSender, sendMessageSignal, sendReactionSignal, sendReadReceiptSignal, sendTypingSignal, signalMessageActions, signalPlugin, signalSetupPlugin };

package/dist/approval-handler.runtime-CeJI1wow.js

@@ -0,0 +1,158 @@
+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 { 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";
+import { buildApprovalReactionPendingContent } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { buildChannelApprovalExpiredText, buildChannelApprovalResolvedText, createChannelApprovalNativeRuntimeAdapter, resolvePreparedApprovalAccountId } from "openclaw/plugin-sdk/approval-handler-runtime";
+//#region extensions/signal/src/approval-handler.runtime.ts
+const log = createSubsystemLogger("signal/approvals");
+function readSignalApprovalRuntimeContext(context) {
+	const value = context;
+	return {
+		baseUrl: typeof value?.baseUrl === "string" && value.baseUrl.trim() ? value.baseUrl.trim() : void 0,
+		account: typeof value?.account === "string" && value.account.trim() ? value.account.trim() : void 0,
+		accountUuid: typeof value?.accountUuid === "string" && value.accountUuid.trim() ? value.accountUuid.trim() : void 0
+	};
+}
+function buildPendingPayload(params) {
+	return buildApprovalReactionPendingContent(params);
+}
+const signalApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: ({ context }) => Boolean(context),
+		shouldHandle: ({ context }) => Boolean(context)
+	},
+	presentation: {
+		buildPendingPayload: ({ request, nowMs, view }) => buildPendingPayload({
+			request,
+			nowMs,
+			view
+		}),
+		buildResolvedResult: ({ request, resolved, view }) => ({
+			kind: "update",
+			payload: { text: buildChannelApprovalResolvedText({
+				request,
+				resolved,
+				view
+			}) }
+		}),
+		buildExpiredResult: ({ request, view }) => ({
+			kind: "update",
+			payload: { text: buildChannelApprovalExpiredText({
+				request,
+				view
+			}) }
+		})
+	},
+	transport: {
+		prepareTarget: ({ plannedTarget, accountId, context }) => {
+			const to = normalizeSignalMessagingTarget(plannedTarget.target.to);
+			if (!to) return null;
+			const runtimeContext = readSignalApprovalRuntimeContext(context);
+			const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys({
+				targetAuthor: runtimeContext.account,
+				targetAuthorUuid: runtimeContext.accountUuid
+			});
+			const prepared = {
+				to,
+				accountId: resolvePreparedApprovalAccountId({
+					plannedAccountId: plannedTarget.target.accountId,
+					contextAccountId: accountId,
+					fallbackAccountId: DEFAULT_ACCOUNT_ID
+				}),
+				...runtimeContext.baseUrl ? { baseUrl: runtimeContext.baseUrl } : {},
+				...runtimeContext.account ? { account: runtimeContext.account } : {},
+				...runtimeContext.accountUuid ? { accountUuid: runtimeContext.accountUuid } : {},
+				targetAuthorKeys
+			};
+			return {
+				dedupeKey: `${prepared.accountId}:${buildChannelApprovalNativeTargetKey({ to: prepared.to })}`,
+				target: prepared
+			};
+		},
+		deliverPending: async ({ cfg, preparedTarget, pendingPayload }) => {
+			await sendTypingSignal(preparedTarget.to, {
+				cfg,
+				accountId: preparedTarget.accountId,
+				...preparedTarget.baseUrl ? { baseUrl: preparedTarget.baseUrl } : {},
+				...preparedTarget.account ? { account: preparedTarget.account } : {}
+			}).catch(() => {});
+			const reactionsActive = preparedTarget.targetAuthorKeys.length > 0 && hasSignalApprovalReactionApprovers({
+				cfg,
+				accountId: preparedTarget.accountId
+			});
+			const payload = reactionsActive ? pendingPayload.reactionPayload : pendingPayload.manualFallbackPayload;
+			const result = await sendMessageSignal(preparedTarget.to, payload.text ?? "", {
+				cfg,
+				accountId: preparedTarget.accountId,
+				...preparedTarget.baseUrl ? { baseUrl: preparedTarget.baseUrl } : {},
+				...preparedTarget.account ? { account: preparedTarget.account } : {},
+				textMode: "plain"
+			});
+			if (!result.messageId || result.messageId === "unknown") return null;
+			const conversationKey = resolveSignalApprovalConversationKey(preparedTarget.to);
+			if (!conversationKey) return null;
+			return {
+				accountId: preparedTarget.accountId,
+				to: preparedTarget.to,
+				conversationKey,
+				messageId: result.messageId,
+				targetAuthorKeys: preparedTarget.targetAuthorKeys,
+				reactionsActive,
+				...preparedTarget.baseUrl ? { baseUrl: preparedTarget.baseUrl } : {},
+				...preparedTarget.account ? { account: preparedTarget.account } : {}
+			};
+		},
+		updateEntry: async ({ cfg, entry, payload }) => {
+			await sendMessageSignal(entry.to, payload.text, {
+				cfg,
+				accountId: entry.accountId,
+				...entry.baseUrl ? { baseUrl: entry.baseUrl } : {},
+				...entry.account ? { account: entry.account } : {},
+				textMode: "plain"
+			});
+		}
+	},
+	interactions: {
+		bindPending: ({ entry, request, view, pendingPayload }) => {
+			if (!entry.reactionsActive) return null;
+			return registerSignalApprovalReactionTarget({
+				accountId: entry.accountId,
+				conversationKey: entry.conversationKey,
+				messageId: entry.messageId,
+				approvalId: request.id,
+				allowedDecisions: pendingPayload.reactionPayload.allowedDecisions,
+				targetAuthorKeys: entry.targetAuthorKeys,
+				route: {
+					deliveryMode: "session",
+					...normalizeOptionalString(request.request.agentId) ? { agentId: normalizeOptionalString(request.request.agentId) } : {},
+					...normalizeOptionalString(request.request.sessionKey) ? { sessionKey: normalizeOptionalString(request.request.sessionKey) } : {}
+				},
+				routeAllowed: true,
+				ttlMs: Math.max(1, view.expiresAtMs - Date.now())
+			}) ? true : null;
+		},
+		unbindPending: ({ entry }) => {
+			unregisterSignalApprovalReactionTarget({
+				accountId: entry.accountId,
+				conversationKey: entry.conversationKey,
+				messageId: entry.messageId
+			});
+		},
+		cancelDelivered: ({ entry }) => {
+			unregisterSignalApprovalReactionTarget({
+				accountId: entry.accountId,
+				conversationKey: entry.conversationKey,
+				messageId: entry.messageId
+			});
+		}
+	},
+	observe: { onDeliveryError: ({ error, request }) => {
+		log.error(`signal approvals: failed to send request ${request.id}: ${String(error)}`);
+	} }
+});
+//#endregion
+export { signalApprovalNativeRuntime };

package/dist/approval-resolver-BR0MioAA.js

@@ -0,0 +1,15 @@
+import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
+import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
+//#region extensions/signal/src/approval-resolver.ts
+async function resolveSignalApproval(params) {
+	await resolveApprovalOverGateway({
+		cfg: params.cfg,
+		approvalId: params.approvalId,
+		decision: params.decision,
+		senderId: params.senderId,
+		gatewayUrl: params.gatewayUrl,
+		clientDisplayName: `Signal approval (${params.senderId?.trim() || "unknown"})`
+	});
+}
+//#endregion
+export { isApprovalNotFoundError, resolveSignalApproval };