@openclaw/signal 0.0.0 → 2026.6.11-beta.2

package/dist/channel-LmY2UpOt.js

@@ -0,0 +1,619 @@
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId } from "./accounts-hOCHbEhX.js";
+import { c as resolveSignalSender, d as normalizeSignalMessagingTarget, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
+import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, o as shouldSuppressLocalSignalExecApprovalPrompt, s as signalApprovalCapability, t as signalMessageActions } from "./message-actions-Bue0g2Kc.js";
+import { t as SignalChannelConfigSchema } from "./config-schema-BiojLEsX.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { defineChannelMessageAdapter, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
+import { attachChannelToResult, attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
+import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
+import { chunkText, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
+import { buildOutboundBaseSessionKey } from "openclaw/plugin-sdk/routing";
+import { buildBaseChannelStatusSummary, collectStatusIssuesFromLastError, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { createChannelPluginBase, getChatChannelMeta } from "openclaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, createCliPathTextInput, createDelegatedSetupWizardProxy, createDelegatedTextInputShouldPrompt, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, createSetupTranslator, mergeAllowFromEntries, parseSetupEntriesAllowingWildcard, patchChannelConfigForAccount, promptParsedAllowFromForAccount, setAccountAllowFromForChannel, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
+import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createRestrictSendersChannelSecurity } from "openclaw/plugin-sdk/channel-policy";
+//#region extensions/signal/src/outbound-session.ts
+function resolveSignalOutboundTarget(target) {
+	const stripped = target.replace(/^signal:/i, "").trim();
+	const lowered = normalizeLowercaseStringOrEmpty(stripped);
+	if (lowered.startsWith("group:")) {
+		const groupId = stripped.slice(6).trim();
+		if (!groupId) return null;
+		return {
+			peer: {
+				kind: "group",
+				id: groupId
+			},
+			chatType: "group",
+			from: `group:${groupId}`,
+			to: `group:${groupId}`
+		};
+	}
+	let recipient = stripped.trim();
+	if (lowered.startsWith("username:")) recipient = stripped.slice(9).trim();
+	else if (lowered.startsWith("u:")) recipient = stripped.slice(2).trim();
+	if (!recipient) return null;
+	const uuidCandidate = normalizeLowercaseStringOrEmpty(recipient).startsWith("uuid:") ? recipient.slice(5) : recipient;
+	const sender = resolveSignalSender({
+		sourceUuid: looksLikeUuid(uuidCandidate) ? uuidCandidate : null,
+		sourceNumber: looksLikeUuid(uuidCandidate) ? null : recipient
+	});
+	const peerId = sender ? resolveSignalPeerId(sender) : recipient;
+	const displayRecipient = sender ? resolveSignalRecipient(sender) : recipient;
+	return {
+		peer: {
+			kind: "direct",
+			id: peerId
+		},
+		chatType: "direct",
+		from: `signal:${displayRecipient}`,
+		to: `signal:${displayRecipient}`
+	};
+}
+//#endregion
+//#region extensions/signal/src/setup-core.ts
+const t = createSetupTranslator();
+const channel = "signal";
+const MIN_E164_DIGITS = 5;
+const MAX_E164_DIGITS = 15;
+const DIGITS_ONLY = /^\d+$/;
+const INVALID_SIGNAL_ACCOUNT_ERROR = "Invalid E.164 phone number (must start with + and country code, e.g. +15555550123)";
+function normalizeSignalAccountInput(value) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return null;
+	const digits = normalizeE164(trimmed).slice(1);
+	if (!DIGITS_ONLY.test(digits)) return null;
+	if (digits.length < MIN_E164_DIGITS || digits.length > MAX_E164_DIGITS) return null;
+	return `+${digits}`;
+}
+function isUuidLike(value) {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function parseSignalAllowFromEntries(raw) {
+	return parseSetupEntriesAllowingWildcard(raw, (entry) => {
+		if (normalizeLowercaseStringOrEmpty(entry).startsWith("uuid:")) {
+			const id = entry.slice(5).trim();
+			if (!id) return { error: "Invalid uuid entry" };
+			return { value: `uuid:${id}` };
+		}
+		if (isUuidLike(entry)) return { value: `uuid:${entry}` };
+		const normalized = normalizeSignalAccountInput(entry);
+		if (!normalized) return { error: `Invalid entry: ${entry}` };
+		return { value: normalized };
+	});
+}
+function buildSignalSetupPatch(input) {
+	return {
+		...input.signalNumber ? { account: input.signalNumber } : {},
+		...input.cliPath ? { cliPath: input.cliPath } : {},
+		...input.httpUrl ? { httpUrl: input.httpUrl } : {},
+		...input.httpHost ? { httpHost: input.httpHost } : {},
+		...input.httpPort ? { httpPort: Number(input.httpPort) } : {}
+	};
+}
+async function promptSignalAllowFrom(params) {
+	return promptParsedAllowFromForAccount({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		defaultAccountId: resolveDefaultSignalAccountId(params.cfg),
+		prompter: params.prompter,
+		noteTitle: t("wizard.signal.allowlistTitle"),
+		noteLines: [
+			t("wizard.signal.allowlistIntro"),
+			t("wizard.signal.examples"),
+			"- +15555550123",
+			"- uuid:123e4567-e89b-12d3-a456-426614174000",
+			t("wizard.signal.multipleEntries"),
+			`Docs: ${formatDocsLink("/signal", "signal")}`
+		],
+		message: t("wizard.signal.allowFromPrompt"),
+		placeholder: "+15555550123, uuid:123e4567-e89b-12d3-a456-426614174000",
+		parseEntries: parseSignalAllowFromEntries,
+		getExistingAllowFrom: ({ cfg, accountId }) => resolveSignalAccount({
+			cfg,
+			accountId
+		}).config.allowFrom ?? [],
+		applyAllowFrom: ({ cfg, accountId, allowFrom }) => setAccountAllowFromForChannel({
+			cfg,
+			channel,
+			accountId,
+			allowFrom
+		})
+	});
+}
+const signalDmPolicy = {
+	label: "Signal",
+	channel,
+	policyKey: "channels.signal.dmPolicy",
+	allowFromKey: "channels.signal.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultSignalAccountId(cfg)) !== DEFAULT_ACCOUNT_ID$1 ? {
+		policyKey: `channels.signal.accounts.${accountId ?? resolveDefaultSignalAccountId(cfg)}.dmPolicy`,
+		allowFromKey: `channels.signal.accounts.${accountId ?? resolveDefaultSignalAccountId(cfg)}.allowFrom`
+	} : {
+		policyKey: "channels.signal.dmPolicy",
+		allowFromKey: "channels.signal.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveSignalAccount({
+		cfg,
+		accountId: accountId ?? resolveDefaultSignalAccountId(cfg)
+	}).config.dmPolicy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => patchChannelConfigForAccount({
+		cfg,
+		channel,
+		accountId: accountId ?? resolveDefaultSignalAccountId(cfg),
+		patch: policy === "open" ? {
+			dmPolicy: "open",
+			allowFrom: mergeAllowFromEntries(resolveSignalAccount({
+				cfg,
+				accountId: accountId ?? resolveDefaultSignalAccountId(cfg)
+			}).config.allowFrom, ["*"])
+		} : { dmPolicy: policy }
+	}),
+	promptAllowFrom: promptSignalAllowFrom
+};
+function resolveSignalCliPath(params) {
+	return (typeof params.credentialValues.cliPath === "string" ? params.credentialValues.cliPath : void 0) ?? resolveSignalAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).config.cliPath ?? "signal-cli";
+}
+function createSignalCliPathTextInput(shouldPrompt) {
+	return createCliPathTextInput({
+		inputKey: "cliPath",
+		message: "signal-cli path",
+		resolvePath: ({ cfg, accountId, credentialValues }) => resolveSignalCliPath({
+			cfg,
+			accountId,
+			credentialValues
+		}),
+		shouldPrompt,
+		helpTitle: "Signal",
+		helpLines: ["signal-cli not found. Install it, then rerun this step or set channels.signal.cliPath."]
+	});
+}
+const signalNumberTextInput = {
+	inputKey: "signalNumber",
+	message: t("wizard.signal.botNumberPrompt"),
+	currentValue: ({ cfg, accountId }) => normalizeSignalAccountInput(resolveSignalAccount({
+		cfg,
+		accountId
+	}).config.account) ?? void 0,
+	keepPrompt: (value) => t("wizard.signal.accountKeep", { value }),
+	validate: ({ value }) => normalizeSignalAccountInput(value) ? void 0 : INVALID_SIGNAL_ACCOUNT_ERROR,
+	normalizeValue: ({ value }) => normalizeSignalAccountInput(value) ?? value
+};
+const signalCompletionNote = {
+	title: t("wizard.signal.nextStepsTitle"),
+	lines: [
+		t("wizard.signal.nextLinkDevice"),
+		t("wizard.signal.nextScanQr"),
+		`Then run: ${formatCliCommand("openclaw gateway call channels.status --params '{\"probe\":true}'")}`,
+		`Docs: ${formatDocsLink("/signal", "signal")}`
+	]
+};
+const signalSetupAdapter = createPatchedAccountSetupAdapter({
+	channelKey: channel,
+	validateInput: createSetupInputPresenceValidator({ validate: ({ input }) => {
+		if (!input.signalNumber && !input.httpUrl && !input.httpHost && !input.httpPort && !input.cliPath) return "Signal requires --signal-number or --http-url/--http-host/--http-port/--cli-path.";
+		return null;
+	} }),
+	buildPatch: (input) => buildSignalSetupPatch(input)
+});
+function createSignalSetupWizardProxy(loadWizard) {
+	return createDelegatedSetupWizardProxy({
+		channel,
+		loadWizard,
+		status: {
+			configuredLabel: t("wizard.channels.statusConfigured"),
+			unconfiguredLabel: t("wizard.channels.statusNeedsSetup"),
+			configuredHint: t("wizard.channels.statusSignalCliFound"),
+			unconfiguredHint: t("wizard.channels.statusSignalCliMissing"),
+			configuredScore: 1,
+			unconfiguredScore: 0
+		},
+		delegatePrepare: true,
+		credentials: [],
+		textInputs: [createSignalCliPathTextInput(createDelegatedTextInputShouldPrompt({
+			loadWizard,
+			inputKey: "cliPath"
+		})), signalNumberTextInput],
+		completionNote: signalCompletionNote,
+		dmPolicy: signalDmPolicy,
+		disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+	});
+}
+//#endregion
+//#region extensions/signal/src/shared.ts
+const SIGNAL_CHANNEL = "signal";
+async function loadSignalChannelRuntime() {
+	return await import("./channel.runtime-B0-YpkC4.js");
+}
+const signalSetupWizard = createSignalSetupWizardProxy(async () => (await loadSignalChannelRuntime()).signalSetupWizard);
+const signalConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: SIGNAL_CHANNEL,
+	listAccountIds: (cfg) => listSignalAccountIds(cfg),
+	resolveAccount: adaptScopedAccountAccessor((params) => resolveSignalAccount(params)),
+	defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
+	clearBaseFields: [
+		"account",
+		"configPath",
+		"httpUrl",
+		"httpHost",
+		"httpPort",
+		"cliPath",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => normalizeStringifiedEntries(allowFrom).map((entry) => entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))).filter(Boolean),
+	resolveDefaultTo: (account) => account.config.defaultTo
+});
+const signalSecurityAdapter = createRestrictSendersChannelSecurity({
+	channelKey: SIGNAL_CHANNEL,
+	resolveDmPolicy: (account) => account.config.dmPolicy,
+	resolveDmAllowFrom: (account) => account.config.allowFrom,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	surface: "Signal groups",
+	openScope: "any member",
+	groupPolicyPath: "channels.signal.groupPolicy",
+	groupAllowFromPath: "channels.signal.groupAllowFrom",
+	mentionGated: false,
+	policyPathSuffix: "dmPolicy",
+	normalizeDmEntry: (raw) => normalizeE164(raw.replace(/^signal:/i, "").trim())
+});
+function createSignalPluginBase(params) {
+	return {
+		...createChannelPluginBase({
+			id: SIGNAL_CHANNEL,
+			meta: { ...getChatChannelMeta(SIGNAL_CHANNEL) },
+			setupWizard: params.setupWizard,
+			capabilities: {
+				chatTypes: ["direct", "group"],
+				media: true,
+				reactions: true
+			},
+			streaming: { blockStreamingCoalesceDefaults: {
+				minChars: 1500,
+				idleMs: 1e3
+			} },
+			reload: { configPrefixes: ["channels.signal"] },
+			configSchema: SignalChannelConfigSchema,
+			config: {
+				...signalConfigAdapter,
+				isConfigured: (account) => account.configured,
+				describeAccount: (account) => describeAccountSnapshot({
+					account,
+					configured: account.configured,
+					extra: { baseUrl: account.baseUrl }
+				})
+			},
+			security: signalSecurityAdapter,
+			setup: params.setup
+		}),
+		messaging: { defaultMarkdownTableMode: "bullets" }
+	};
+}
+//#endregion
+//#region extensions/signal/src/channel.ts
+let signalMonitorModulePromise = null;
+let signalProbeModulePromise = null;
+let signalSendRuntimePromise = null;
+async function loadSignalMonitorModule() {
+	signalMonitorModulePromise ??= import("./monitor-CUhIKHJo.js").then((n) => n.n);
+	return await signalMonitorModulePromise;
+}
+async function loadSignalProbeModule() {
+	signalProbeModulePromise ??= import("./probe-BQ_Izoya.js").then((n) => n.n);
+	return await signalProbeModulePromise;
+}
+async function loadSignalSendRuntime() {
+	signalSendRuntimePromise ??= import("./send.runtime-CfaZd8X4.js");
+	return await signalSendRuntimePromise;
+}
+async function resolveSignalSendContext(params) {
+	return {
+		send: resolveOutboundSendDep(params.deps, "signal") ?? (await loadSignalSendRuntime()).sendMessageSignal,
+		maxBytes: resolveChannelMediaMaxBytes({
+			cfg: params.cfg,
+			resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+			accountId: params.accountId
+		})
+	};
+}
+async function sendSignalOutbound(params) {
+	const { send, maxBytes } = await resolveSignalSendContext(params);
+	return await send(params.to, params.text, {
+		cfg: params.cfg,
+		...params.mediaUrl ? { mediaUrl: params.mediaUrl } : {},
+		...params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {},
+		...params.mediaReadFile ? { mediaReadFile: params.mediaReadFile } : {},
+		maxBytes,
+		accountId: params.accountId ?? void 0
+	});
+}
+const signalMessageAdapter = defineChannelMessageAdapter({
+	id: "signal",
+	durableFinal: { capabilities: {
+		text: true,
+		media: true
+	} },
+	send: {
+		text: async (ctx) => await sendSignalOutbound({
+			cfg: ctx.cfg,
+			to: ctx.to,
+			text: ctx.text,
+			accountId: ctx.accountId ?? void 0,
+			deps: ctx.deps
+		}),
+		media: async (ctx) => await sendSignalOutbound({
+			cfg: ctx.cfg,
+			to: ctx.to,
+			text: ctx.text,
+			mediaUrl: ctx.mediaUrl,
+			mediaLocalRoots: ctx.mediaLocalRoots,
+			mediaReadFile: ctx.mediaReadFile,
+			accountId: ctx.accountId ?? void 0,
+			deps: ctx.deps
+		})
+	}
+});
+function inferSignalTargetChatType(rawTo) {
+	let to = rawTo.trim();
+	if (!to) return;
+	if (/^signal:/i.test(to)) to = to.replace(/^signal:/i, "").trim();
+	if (!to) return;
+	const lower = normalizeLowercaseStringOrEmpty(to);
+	if (lower.startsWith("group:")) return "group";
+	if (lower.startsWith("username:") || lower.startsWith("u:")) return "direct";
+	return "direct";
+}
+function buildSignalBaseSessionKey(params) {
+	return buildOutboundBaseSessionKey({
+		...params,
+		channel: "signal"
+	});
+}
+function resolveSignalOutboundSessionRoute(params) {
+	const resolved = resolveSignalOutboundTarget(params.target);
+	if (!resolved) return null;
+	const baseSessionKey = buildSignalBaseSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		accountId: params.accountId,
+		peer: resolved.peer
+	});
+	return {
+		sessionKey: baseSessionKey,
+		baseSessionKey,
+		...resolved
+	};
+}
+async function sendFormattedSignalText(ctx) {
+	const { send, maxBytes } = await resolveSignalSendContext({
+		cfg: ctx.cfg,
+		accountId: ctx.accountId ?? void 0,
+		deps: ctx.deps
+	});
+	const limit = resolveTextChunkLimit(ctx.cfg, "signal", ctx.accountId ?? void 0, { fallbackLimit: 4e3 });
+	const tableMode = resolveMarkdownTableMode({
+		cfg: ctx.cfg,
+		channel: "signal",
+		accountId: ctx.accountId ?? void 0
+	});
+	let chunks = limit === void 0 ? markdownToSignalTextChunks(ctx.text, Number.POSITIVE_INFINITY, { tableMode }) : markdownToSignalTextChunks(ctx.text, limit, { tableMode });
+	if (chunks.length === 0 && ctx.text) chunks = [{
+		text: ctx.text,
+		styles: []
+	}];
+	const results = [];
+	for (const chunk of chunks) {
+		ctx.abortSignal?.throwIfAborted();
+		const result = await send(ctx.to, chunk.text, {
+			cfg: ctx.cfg,
+			maxBytes,
+			accountId: ctx.accountId ?? void 0,
+			textMode: "plain",
+			textStyles: chunk.styles
+		});
+		results.push(result);
+	}
+	return attachChannelToResults("signal", results);
+}
+async function sendFormattedSignalMedia(ctx) {
+	ctx.abortSignal?.throwIfAborted();
+	const { send, maxBytes } = await resolveSignalSendContext({
+		cfg: ctx.cfg,
+		accountId: ctx.accountId ?? void 0,
+		deps: ctx.deps
+	});
+	const tableMode = resolveMarkdownTableMode({
+		cfg: ctx.cfg,
+		channel: "signal",
+		accountId: ctx.accountId ?? void 0
+	});
+	const formatted = markdownToSignalTextChunks(ctx.text, Number.POSITIVE_INFINITY, { tableMode })[0] ?? {
+		text: ctx.text,
+		styles: []
+	};
+	return attachChannelToResult("signal", await send(ctx.to, formatted.text, {
+		cfg: ctx.cfg,
+		mediaUrl: ctx.mediaUrl,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		...ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {},
+		maxBytes,
+		accountId: ctx.accountId ?? void 0,
+		textMode: "plain",
+		textStyles: formatted.styles
+	}));
+}
+const signalPlugin = createChatChannelPlugin({
+	base: {
+		...createSignalPluginBase({
+			setupWizard: signalSetupWizard,
+			setup: signalSetupAdapter
+		}),
+		actions: signalMessageActions,
+		approvalCapability: signalApprovalCapability,
+		allowlist: buildDmGroupAccountAllowlistAdapter({
+			channelId: "signal",
+			resolveAccount: resolveSignalAccount,
+			normalize: ({ cfg, accountId, values }) => signalConfigAdapter.formatAllowFrom({
+				cfg,
+				accountId,
+				allowFrom: values
+			}),
+			resolveDmAllowFrom: (account) => account.config.allowFrom,
+			resolveGroupAllowFrom: (account) => account.config.groupAllowFrom,
+			resolveDmPolicy: (account) => account.config.dmPolicy,
+			resolveGroupPolicy: (account) => account.config.groupPolicy
+		}),
+		agentPrompt: { reactionGuidance: ({ cfg, accountId }) => {
+			const level = resolveSignalReactionLevel({
+				cfg,
+				accountId: accountId ?? void 0
+			}).agentReactionGuidance;
+			return level ? {
+				level,
+				channelLabel: "Signal"
+			} : void 0;
+		} },
+		messaging: {
+			targetPrefixes: ["signal"],
+			normalizeTarget: normalizeSignalMessagingTarget,
+			inferTargetChatType: ({ to }) => inferSignalTargetChatType(to),
+			resolveOutboundSessionRoute: (params) => resolveSignalOutboundSessionRoute(params),
+			targetResolver: {
+				looksLikeId: looksLikeSignalTargetId,
+				hint: "<E.164|uuid:ID|group:ID|signal:group:ID|signal:+E.164>"
+			}
+		},
+		heartbeat: {
+			sendTyping: async ({ cfg, to, accountId }) => {
+				await (await loadSignalSendRuntime()).sendTypingSignal(to, {
+					cfg,
+					...accountId ? { accountId } : {}
+				});
+			},
+			clearTyping: async ({ cfg, to, accountId }) => {
+				await (await loadSignalSendRuntime()).sendTypingSignal(to, {
+					cfg,
+					...accountId ? { accountId } : {},
+					stop: true
+				});
+			}
+		},
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+			collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("signal", accounts),
+			buildChannelSummary: ({ snapshot }) => buildBaseChannelStatusSummary(snapshot, {
+				baseUrl: snapshot.baseUrl ?? null,
+				probe: snapshot.probe,
+				lastProbeAt: snapshot.lastProbeAt ?? null
+			}),
+			probeAccount: async ({ account, timeoutMs }) => {
+				const baseUrl = account.baseUrl;
+				const { probeSignal } = await loadSignalProbeModule();
+				return await probeSignal(baseUrl, timeoutMs, { apiMode: account.config?.apiMode ?? "auto" });
+			},
+			formatCapabilitiesProbe: ({ probe }) => probe?.version ? [{ text: `Signal daemon: ${probe.version}` }] : [],
+			resolveAccountSnapshot: ({ account }) => ({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: account.configured,
+				extra: { baseUrl: account.baseUrl }
+			})
+		}),
+		gateway: { startAccount: async (ctx) => {
+			const account = ctx.account;
+			ctx.setStatus({
+				accountId: account.accountId,
+				baseUrl: account.baseUrl
+			});
+			ctx.log?.info(`[${account.accountId}] starting provider (${account.baseUrl})`);
+			const { monitorSignalProvider } = await loadSignalMonitorModule();
+			return await monitorSignalProvider({
+				accountId: account.accountId,
+				config: ctx.cfg,
+				runtime: ctx.runtime,
+				channelRuntime: ctx.channelRuntime,
+				abortSignal: ctx.abortSignal,
+				mediaMaxMb: account.config.mediaMaxMb
+			});
+		} },
+		message: signalMessageAdapter
+	},
+	pairing: { text: {
+		idLabel: "signalNumber",
+		message: PAIRING_APPROVED_MESSAGE,
+		normalizeAllowEntry: createPairingPrefixStripper(/^signal:/i),
+		notify: async ({ cfg, id, message }) => {
+			await (await loadSignalSendRuntime()).sendMessageSignal(id, message, { cfg });
+		}
+	} },
+	security: signalSecurityAdapter,
+	outbound: {
+		base: {
+			deliveryMode: "direct",
+			chunker: chunkText,
+			chunkerMode: "text",
+			textChunkLimit: 4e3,
+			shouldSuppressLocalPayloadPrompt: ({ cfg, accountId, payload, hint }) => shouldSuppressLocalSignalExecApprovalPrompt({
+				cfg,
+				accountId,
+				payload,
+				hint
+			}),
+			sendFormattedText: async ({ cfg, to, text, accountId, deps, abortSignal }) => await sendFormattedSignalText({
+				cfg,
+				to,
+				text,
+				accountId,
+				deps,
+				abortSignal
+			}),
+			sendFormattedMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps, abortSignal }) => await sendFormattedSignalMedia({
+				cfg,
+				to,
+				text,
+				mediaUrl,
+				mediaLocalRoots,
+				mediaReadFile,
+				accountId,
+				deps,
+				abortSignal
+			})
+		},
+		attachedResults: {
+			channel: "signal",
+			sendText: async ({ cfg, to, text, accountId, deps }) => await sendSignalOutbound({
+				cfg,
+				to,
+				text,
+				accountId: accountId ?? void 0,
+				deps
+			}),
+			sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps }) => await sendSignalOutbound({
+				cfg,
+				to,
+				text,
+				mediaUrl,
+				mediaLocalRoots,
+				mediaReadFile,
+				accountId: accountId ?? void 0,
+				deps
+			})
+		}
+	}
+});
+//#endregion
+export { normalizeSignalAccountInput as a, signalNumberTextInput as c, createSignalCliPathTextInput as i, signalSetupAdapter as l, createSignalPluginBase as n, signalCompletionNote as o, signalSetupWizard as r, signalDmPolicy as s, signalPlugin as t, resolveSignalOutboundTarget as u };

package/dist/channel-config-api.js

@@ -0,0 +1,2 @@
+import { t as SignalChannelConfigSchema } from "./config-schema-BiojLEsX.js";
+export { SignalChannelConfigSchema };

package/dist/channel-entry.js

@@ -0,0 +1,18 @@
+import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/signal/channel-entry.ts
+var channel_entry_default = defineBundledChannelEntry({
+	id: "signal",
+	name: "Signal",
+	description: "Signal channel plugin",
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./api.js",
+		exportName: "signalPlugin"
+	},
+	runtime: {
+		specifier: "./runtime-api.js",
+		exportName: "setSignalRuntime"
+	}
+});
+//#endregion
+export { channel_entry_default as default };

package/dist/channel-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as signalPlugin } from "./channel-LmY2UpOt.js";
+export { signalPlugin };