@openclaw/signal 2026.7.2-beta.3 → 2026.7.2-beta.4

package/dist/{channel-ChLRPIuC.js → channel-DQ9i00A8.js}

@@ -1,8 +1,10 @@
-import { a as resolveSignalReplyToMode, i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId } from "./accounts-Bz4HtP0g.js";
+import { a as isSignalManagedNativeConnectionUrlForBind, i as assignSignalManagedNativePort, l as normalizeSignalTransportHost, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort, s as resolveLocalSignalTransportPort, u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js";
+import { a as resolveSignalAccountConfig, i as resolveSignalAccount, n as listSignalAccountIds, o as resolveSignalReplyToMode, r as resolveDefaultSignalAccountId, s as resolveSignalTransport } from "./accounts-DrStJjiK.js";
 import { c as resolveSignalSender, d as normalizeSignalMessagingTarget, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient, u as looksLikeSignalTargetId } from "./identity-BQ4OzXXk.js";
-import { a as listSignalAliasDirectoryEntries, o as resolveSignalTarget } from "./runtime-B900w6lc.js";
-import { a as resolveSignalReactionLevel, i as signalMessageActions, l as shouldSuppressLocalSignalExecApprovalPrompt, n as resolveSignalReplyContextWithPersistence, r as materializeSignalPresentationFallback, s as markdownToSignalTextChunks, u as signalApprovalCapability } from "./reply-authors-DcNqGpX-.js";
-import { t as SignalChannelConfigSchema } from "./config-schema-CfVNH0DB.js";
+import { a as listSignalAliasDirectoryEntries, o as resolveSignalTarget } from "./runtime-JPrGlV7h.js";
+import { a as signalMessageActions, d as shouldSuppressLocalSignalExecApprovalPrompt, f as signalApprovalCapability, i as materializeSignalPresentationFallback, l as markdownToSignalTextChunks, o as resolveSignalReactionLevel, r as resolveSignalReplyContextWithPersistence, s as formatSignalMediaText, t as detectSignalTransport } from "./transport-detection-CiZWiMYa.js";
+import { i as migrateLegacySignalTransportConfig, n as normalizeCompatibilityConfig, r as clearLegacySignalTransportFieldsForAccount } from "./doctor-contract-api-DbUCknbC.js";
+import { t as SignalChannelConfigSchema } from "./config-schema-DLvpQPN5.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";
@@ -19,9 +21,11 @@ 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 { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "openclaw/plugin-sdk/account-resolution";
 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 { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, 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";
@@ -71,9 +75,221 @@ function resolveSignalOutboundTarget(target) {
 	};
 }
 //#endregion
+//#region extensions/signal/src/setup-transport.ts
+function managedTransportOptions(transport) {
+	const { kind: _kind, ...options } = transport;
+	return options;
+}
+function normalizeTransport(transport) {
+	if (transport.kind === "managed-native") return {
+		...transport,
+		...transport.url ? { url: normalizeSignalTransportUrl(transport.url) } : {},
+		...transport.httpHost ? { httpHost: normalizeSignalTransportHost(transport.httpHost) } : {}
+	};
+	return {
+		...transport,
+		url: normalizeSignalTransportUrl(transport.url)
+	};
+}
+function assertSignalContainerTransportHasAccount(params) {
+	if (params.transport.kind !== "container" || params.cfg.channels?.signal?.enabled === false) return;
+	const account = resolveSignalAccountConfig(params.cfg, normalizeAccountId$1(params.accountId));
+	if (account.enabled === false || normalizeOptionalString(account.account)) return;
+	throw new Error("Signal container transport requires an account number for an enabled account.");
+}
+function assertSignalLocalEndpointDoesNotConflictWithManagedSibling(params) {
+	if (params.transport.kind === "managed-native") return;
+	const localPort = resolveLocalSignalTransportPort(params.transport.url);
+	if (localPort === void 0) return;
+	const targetAccountId = normalizeAccountId$1(params.accountId);
+	for (const accountId of listSignalAccountIds(params.cfg)) {
+		if (normalizeAccountId$1(accountId) === targetAccountId) continue;
+		if (resolveAccountEntry(params.cfg.channels?.signal?.accounts, accountId)?.enabled === false) continue;
+		const siblingAccount = resolveSignalAccount({
+			cfg: params.cfg,
+			accountId
+		});
+		if (!siblingAccount.configured) continue;
+		const siblingTransport = siblingAccount.transport;
+		if (siblingTransport?.kind !== "managed-native" || siblingTransport.httpPort !== localPort) continue;
+		throw new Error(`Signal ${params.transport.kind} account "${targetAccountId}" uses local port ${localPort}, which conflicts with managed native account "${accountId}". Choose a distinct transport URL.`);
+	}
+}
+function resolveConfiguredSignalTransport(cfg, accountId) {
+	const signal = cfg.channels?.signal;
+	const normalizedAccountId = normalizeAccountId$1(accountId);
+	return normalizedAccountId === DEFAULT_ACCOUNT_ID$2 ? signal?.transport ?? resolveAccountEntry(signal?.accounts, normalizedAccountId)?.transport : resolveAccountEntry(signal?.accounts, normalizedAccountId)?.transport;
+}
+function alignManagedConnectionUrlAfterBindChange(params) {
+	if (params.hasUrlOverride || !params.existing?.url || !isSignalManagedNativeConnectionUrlForBind(params.existing)) return assignSignalManagedNativePort(params.prepared, params.httpPort);
+	const connectionUrl = new URL(params.existing.url);
+	connectionUrl.port = String(params.httpPort);
+	const alignedPortUrl = normalizeSignalTransportUrl(connectionUrl.toString());
+	const next = {
+		...params.prepared,
+		url: alignedPortUrl,
+		httpPort: params.httpPort
+	};
+	if (isSignalManagedNativeConnectionUrlForBind(next)) return next;
+	const bindHost = params.prepared.httpHost ?? "127.0.0.1";
+	const connectionHost = bindHost === "0.0.0.0" ? "127.0.0.1" : bindHost === "::" ? "::1" : bindHost;
+	connectionUrl.hostname = connectionHost.includes(":") ? `[${connectionHost}]` : connectionHost;
+	return {
+		...next,
+		url: normalizeSignalTransportUrl(connectionUrl.toString())
+	};
+}
+function prepareSignalManagedNativeTransport(params) {
+	const existing = resolveConfiguredSignalTransport(params.cfg, params.accountId);
+	const existingManaged = existing?.kind === "managed-native" ? existing : void 0;
+	const preferredPort = params.overrides?.httpPort ?? existingManaged?.httpPort;
+	const prepared = {
+		kind: "managed-native",
+		...existingManaged,
+		...params.overrides,
+		httpHost: params.overrides?.httpHost ?? existingManaged?.httpHost ?? "127.0.0.1"
+	};
+	const portsByAccountId = /* @__PURE__ */ new Map();
+	const implicitManagedAccountIds = [];
+	for (const accountId of listSignalAccountIds(params.cfg)) {
+		const normalizedAccountId = normalizeAccountId$1(accountId);
+		const accountConfig = resolveSignalAccountConfig(params.cfg, accountId);
+		if (!normalizeOptionalString(accountConfig.account) && !accountConfig.transport) continue;
+		const accountPorts = portsByAccountId.get(normalizedAccountId) ?? /* @__PURE__ */ new Set();
+		portsByAccountId.set(normalizedAccountId, accountPorts);
+		const transport = accountConfig.transport;
+		if (transport?.kind === "managed-native") {
+			if (transport.httpPort !== void 0) accountPorts.add(transport.httpPort);
+			else implicitManagedAccountIds.push(normalizedAccountId);
+			if (transport.url && !isSignalManagedNativeConnectionUrlForBind(transport)) {
+				const localConnectionPort = resolveLocalSignalTransportPort(transport.url);
+				if (localConnectionPort !== void 0) accountPorts.add(localConnectionPort);
+			}
+			continue;
+		}
+		if (transport?.kind === "external-native" || transport?.kind === "container") {
+			const localPort = resolveLocalSignalTransportPort(transport.url);
+			if (localPort !== void 0) accountPorts.add(localPort);
+			continue;
+		}
+		implicitManagedAccountIds.push(normalizedAccountId);
+	}
+	const currentReservedPorts = /* @__PURE__ */ new Set();
+	for (const accountPorts of portsByAccountId.values()) for (const httpPort of accountPorts) currentReservedPorts.add(httpPort);
+	for (const accountId of implicitManagedAccountIds) {
+		const accountPorts = portsByAccountId.get(accountId);
+		if (!accountPorts) continue;
+		const httpPort = allocateSignalManagedNativePort({ reservedPorts: currentReservedPorts });
+		currentReservedPorts.add(httpPort);
+		accountPorts.add(httpPort);
+	}
+	const targetAccountId = normalizeAccountId$1(params.accountId);
+	const reservedPorts = /* @__PURE__ */ new Set();
+	for (const [accountId, accountPorts] of portsByAccountId) {
+		if (accountId === targetAccountId) continue;
+		for (const httpPort of accountPorts) reservedPorts.add(httpPort);
+	}
+	if (prepared.url && (params.overrides?.url !== void 0 ? !isSignalManagedNativeConnectionUrlForBind(prepared) : Boolean(existingManaged?.url && !isSignalManagedNativeConnectionUrlForBind(existingManaged))) && prepared.url) {
+		const localConnectionPort = resolveLocalSignalTransportPort(prepared.url);
+		if (localConnectionPort !== void 0) reservedPorts.add(localConnectionPort);
+	}
+	if (params.overrides?.httpPort !== void 0 && reservedPorts.has(params.overrides.httpPort)) throw new Error(`Signal managed native port ${params.overrides.httpPort} is already reserved by another account or local transport endpoint.`);
+	return alignManagedConnectionUrlAfterBindChange({
+		existing: existingManaged,
+		prepared,
+		httpPort: allocateSignalManagedNativePort({
+			reservedPorts,
+			preferredPort
+		}),
+		hasUrlOverride: params.overrides?.url !== void 0
+	});
+}
+async function probeSignalTransport(params) {
+	const timeoutMs = params.timeoutMs ?? 1e4;
+	const resolved = resolveSignalTransport(params.transport.kind === "managed-native" ? prepareSignalManagedNativeTransport({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		overrides: managedTransportOptions(params.transport)
+	}) : params.transport);
+	if (resolved.kind === "container") return (params.probeContainer ?? (await import("./transport-probes.runtime-CbnZn38-.js")).containerCheck)(resolved.baseUrl, timeoutMs, params.account);
+	return (params.probeNative ?? (await import("./transport-probes.runtime-CbnZn38-.js")).nativeCheck)(resolved.baseUrl, timeoutMs);
+}
+function writeSignalAccountTransport(params) {
+	const transport = normalizeTransport(params.transport);
+	assertSignalContainerTransportHasAccount({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		transport
+	});
+	assertSignalLocalEndpointDoesNotConflictWithManagedSibling({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		transport
+	});
+	const canonical = clearLegacySignalTransportFieldsForAccount({
+		cfg: patchChannelConfigForAccount({
+			cfg: params.cfg,
+			channel: "signal",
+			accountId: params.accountId,
+			patch: { transport }
+		}),
+		accountId: params.accountId
+	});
+	if (transport.kind === "managed-native") resolveSignalAccount({
+		cfg: canonical,
+		accountId: params.accountId
+	});
+	return canonical;
+}
+//#endregion
 //#region extensions/signal/src/setup-core.ts
 const t = createSetupTranslator();
 const channel = "signal";
+const signalSetupFields = {
+	signalNumber: {
+		kind: "string",
+		cli: {
+			flags: "--signal-number <e164>",
+			description: "Signal account number (E.164)"
+		}
+	},
+	signalTransport: {
+		kind: "choice",
+		choices: ["external-native", "container"],
+		cli: {
+			flags: "--signal-transport <kind>",
+			description: "Signal HTTP transport (external-native or container)"
+		}
+	},
+	cliPath: {
+		kind: "string",
+		cli: {
+			flags: "--cli-path <path>",
+			description: "signal-cli executable path"
+		}
+	},
+	httpUrl: {
+		kind: "string",
+		cli: {
+			flags: "--http-url <url>",
+			description: "Signal HTTP service URL"
+		}
+	},
+	httpHost: {
+		kind: "string",
+		cli: {
+			flags: "--http-host <host>",
+			description: "Signal HTTP daemon host"
+		}
+	},
+	httpPort: {
+		kind: "string",
+		cli: {
+			flags: "--http-port <port>",
+			description: "Signal HTTP daemon port"
+		}
+	}
+};
 const MIN_E164_DIGITS = 5;
 const MAX_E164_DIGITS = 15;
 const DIGITS_ONLY = /^\d+$/;
@@ -106,14 +322,53 @@ function parseSignalAllowFromEntries(raw) {
 	});
 }
 function buildSignalSetupPatch(input) {
+	const transport = input.httpUrl ? {
+		kind: input.signalTransport ?? "external-native",
+		url: normalizeSignalTransportUrl(input.httpUrl)
+	} : input.cliPath || input.httpHost || input.httpPort ? {
+		kind: "managed-native",
+		...input.cliPath ? { cliPath: input.cliPath } : {},
+		...input.httpHost ? { httpHost: input.httpHost } : {},
+		...input.httpPort ? { httpPort: Number(input.httpPort) } : {}
+	} : void 0;
 	return {
 		...input.signalNumber ? { account: input.signalNumber } : {},
+		...transport ? { transport } : {}
+	};
+}
+async function prepareSignalSetupInput(params) {
+	if (!params.input.httpUrl || params.input.signalTransport) return params.input;
+	const account = normalizeSignalAccountInput(params.input.signalNumber) ?? normalizeSignalAccountInput(resolveSignalSetupAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	})) ?? void 0;
+	try {
+		const detected = await detectSignalTransport({
+			url: params.input.httpUrl,
+			...account ? { account } : {}
+		});
+		return {
+			...params.input,
+			signalTransport: detected.kind === "container" ? "container" : "external-native"
+		};
+	} catch {
+		const existing = resolveConfiguredSignalTransport(params.cfg, params.accountId);
+		if (existing?.kind === "container" || existing?.kind === "external-native") return params.input;
+		throw new Error("Signal could not detect the HTTP transport; start the endpoint or pass --signal-transport external-native|container.");
+	}
+}
+function managedTransportOverridesFromSetupInput(input) {
+	return {
 		...input.cliPath ? { cliPath: input.cliPath } : {},
-		...input.httpUrl ? { httpUrl: input.httpUrl } : {},
 		...input.httpHost ? { httpHost: input.httpHost } : {},
 		...input.httpPort ? { httpPort: Number(input.httpPort) } : {}
 	};
 }
+function resolveSignalSetupAccount(params) {
+	const accountId = normalizeAccountId$1(params.accountId ?? resolveDefaultSignalAccountId(params.cfg));
+	const signal = params.cfg.channels?.signal;
+	return resolveAccountEntry(signal?.accounts, accountId)?.account ?? signal?.account;
+}
 async function promptSignalAllowFrom(params) {
 	return promptParsedAllowFromForAccount({
 		cfg: params.cfg,
@@ -140,7 +395,8 @@ async function promptSignalAllowFrom(params) {
 			cfg,
 			channel,
 			accountId,
-			allowFrom
+			allowFrom,
+			setupSurface: signalSetupAdapter
 		})
 	});
 }
@@ -149,7 +405,7 @@ const signalDmPolicy = {
 	channel,
 	policyKey: "channels.signal.dmPolicy",
 	allowFromKey: "channels.signal.allowFrom",
-	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultSignalAccountId(cfg)) !== DEFAULT_ACCOUNT_ID$1 ? {
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultSignalAccountId(cfg)) !== DEFAULT_ACCOUNT_ID$2 ? {
 		policyKey: `channels.signal.accounts.${accountId ?? resolveDefaultSignalAccountId(cfg)}.dmPolicy`,
 		allowFromKey: `channels.signal.accounts.${accountId ?? resolveDefaultSignalAccountId(cfg)}.allowFrom`
 	} : {
@@ -170,15 +426,18 @@ const signalDmPolicy = {
 				cfg,
 				accountId: accountId ?? resolveDefaultSignalAccountId(cfg)
 			}).config.allowFrom, ["*"])
-		} : { dmPolicy: policy }
+		} : { dmPolicy: policy },
+		setupSurface: signalSetupAdapter
 	}),
 	promptAllowFrom: promptSignalAllowFrom
 };
 function resolveSignalCliPath(params) {
-	return (typeof params.credentialValues.cliPath === "string" ? params.credentialValues.cliPath : void 0) ?? resolveSignalAccount({
+	const transport = resolveSignalAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
-	}).config.cliPath ?? "signal-cli";
+	}).transport;
+	if (transport.kind !== "managed-native") return;
+	return typeof params.credentialValues.cliPath === "string" ? params.credentialValues.cliPath : transport.cliPath;
 }
 function createSignalCliPathTextInput(shouldPrompt) {
 	return createCliPathTextInput({
@@ -212,14 +471,94 @@ const signalCompletionNote = {
 		`Docs: ${formatDocsLink("/signal", "signal")}`
 	]
 };
-const signalSetupAdapter = createPatchedAccountSetupAdapter({
+const signalSetupAdapterBase = createPatchedAccountSetupAdapter({
 	channelKey: channel,
-	validateInput: createSetupInputPresenceValidator({ validate: ({ input }) => {
+	validateInput: createSetupInputPresenceValidator({ validate: ({ cfg, accountId, input }) => {
+		if (input.signalTransport && input.signalTransport !== "external-native" && input.signalTransport !== "container") return "Signal --signal-transport must be external-native or container.";
+		if (input.signalTransport && !input.httpUrl) return "Signal --signal-transport requires --http-url.";
+		if (input.httpPort !== void 0 && !isValidSignalManagedNativePort(Number(input.httpPort))) return "Signal --http-port must be an integer between 1 and 65535.";
+		if (input.httpHost) try {
+			normalizeSignalTransportHost(input.httpHost);
+		} catch {
+			return "Signal --http-host must be a hostname or IP address.";
+		}
+		if (input.signalTransport === "container" && !normalizeSignalAccountInput(input.signalNumber) && !normalizeSignalAccountInput(resolveSignalSetupAccount({
+			cfg,
+			accountId
+		}))) return "Signal container transport requires --signal-number or an existing account.";
 		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 restorePromotedSignalDefaultAccount(cfg) {
+	const signal = cfg.channels?.signal;
+	const promoted = signal?.accounts?.[DEFAULT_ACCOUNT_ID$2];
+	if (!signal?.transport || signal.account || !promoted?.account) return cfg;
+	const { account, transport: _shadowedTransport, ...remainingDefault } = promoted;
+	const accounts = { ...signal.accounts };
+	if (Object.keys(remainingDefault).length === 0) delete accounts[DEFAULT_ACCOUNT_ID$2];
+	else accounts[DEFAULT_ACCOUNT_ID$2] = remainingDefault;
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			signal: {
+				...signal,
+				account,
+				accounts
+			}
+		}
+	};
+}
+const signalSetupAdapter = {
+	...signalSetupAdapterBase,
+	prepareAccountConfigInput: ({ cfg, accountId, input }) => prepareSignalSetupInput({
+		cfg,
+		accountId,
+		input
+	}),
+	singleAccountKeysToMove: [
+		"signalNumber",
+		"account",
+		"cliPath",
+		"httpUrl",
+		"httpHost",
+		"httpPort"
+	],
+	applyAccountConfig: (params) => {
+		const accountId = normalizeAccountId$1(params.accountId);
+		const cfg = restorePromotedSignalDefaultAccount(params.cfg);
+		const previousTransport = resolveConfiguredSignalTransport(cfg, accountId);
+		const next = signalSetupAdapterBase.applyAccountConfig?.({
+			...params,
+			cfg,
+			accountId
+		}) ?? cfg;
+		const configuredTransport = resolveConfiguredSignalTransport(next, accountId);
+		if (configuredTransport && configuredTransport.kind !== "managed-native") return writeSignalAccountTransport({
+			cfg: next,
+			accountId,
+			transport: params.input.httpUrl && !params.input.signalTransport && (previousTransport?.kind === "container" || previousTransport?.kind === "external-native") ? {
+				...configuredTransport,
+				kind: previousTransport.kind
+			} : configuredTransport
+		});
+		return writeSignalAccountTransport({
+			cfg: next,
+			accountId,
+			transport: prepareSignalManagedNativeTransport({
+				cfg,
+				accountId,
+				overrides: managedTransportOverridesFromSetupInput(params.input)
+			})
+		});
+	}
+};
+const signalSetupContract = defineChannelSetupContract({
+	fields: signalSetupFields,
+	adapter: signalSetupAdapter
+});
 function createSignalSetupWizardProxy(loadWizard) {
 	return createDelegatedSetupWizardProxy({
 		channel,
@@ -244,10 +583,22 @@ function createSignalSetupWizardProxy(loadWizard) {
 	});
 }
 //#endregion
+//#region extensions/signal/src/doctor.ts
+const signalDoctor = {
+	normalizeCompatibilityConfig,
+	cleanStaleConfig: async ({ cfg }) => {
+		const { detectSignalTransport } = await import("./transport-detection.runtime-BgjcIyww.js");
+		return await migrateLegacySignalTransportConfig({
+			cfg,
+			detect: detectSignalTransport
+		});
+	}
+};
+//#endregion
 //#region extensions/signal/src/shared.ts
 const SIGNAL_CHANNEL = "signal";
 async function loadSignalChannelRuntime() {
-	return await import("./channel.runtime-ts_U4_q4.js");
+	return await import("./channel.runtime-DWQdFD2O.js");
 }
 const signalSetupWizard = createSignalSetupWizardProxy(async () => (await loadSignalChannelRuntime()).signalSetupWizard);
 const signalConfigAdapter = {
@@ -258,11 +609,8 @@ const signalConfigAdapter = {
 		defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
 		clearBaseFields: [
 			"account",
-			"configPath",
-			"httpUrl",
-			"httpHost",
-			"httpPort",
-			"cliPath",
+			"accountUuid",
+			"transport",
 			"name"
 		],
 		resolveAllowFrom: (account) => account.config.allowFrom,
@@ -316,6 +664,7 @@ function createSignalPluginBase(params) {
 			} },
 			reload: { configPrefixes: ["channels.signal"] },
 			configSchema: SignalChannelConfigSchema,
+			doctor: signalDoctor,
 			config: {
 				...signalConfigAdapter,
 				isConfigured: (account) => account.configured,
@@ -326,17 +675,17 @@ function createSignalPluginBase(params) {
 				})
 			},
 			security: signalSecurityAdapter,
-			setup: params.setup
+			setupContract: params.setupContract
 		}),
 		messaging: { defaultMarkdownTableMode: "bullets" }
 	};
 }
 //#endregion
 //#region extensions/signal/src/channel.ts
-const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-D2nTNhM2.js").then((n) => n.n));
-const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-sSH6ggyy.js").then((n) => n.n));
-const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-B_UYsXWd.js"));
-const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-DcpZRS5-.js").then((n) => n.r));
+const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-C0aBYlJ0.js").then((n) => n.n));
+const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-2yf2hpcc.js").then((n) => n.n));
+const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-CcA5Qei9.js"));
+const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-5uyOazxW.js").then((n) => n.r));
 async function resolveSignalSendContext(params) {
 	return {
 		send: resolveOutboundSendDep(params.deps, "signal") ?? (await loadSignalSendRuntime()).sendMessageSignal,
@@ -386,10 +735,11 @@ function resolveSignalReplyOptions(params) {
 		replyToId
 	}).then((persistedContext) => {
 		const replyToAuthor = persistedContext?.ambiguous === true ? void 0 : persistedContext?.author;
+		const replyToBody = persistedContext?.ambiguous === true ? "" : [persistedContext?.body, formatSignalMediaText(persistedContext?.media ?? [])].filter(Boolean).join("\n");
 		return {
 			replyToId,
 			...replyToAuthor ? { replyToAuthor } : {},
-			...persistedContext?.body ? { replyToBody: persistedContext.body } : {}
+			...replyToBody ? { replyToBody } : {}
 		};
 	});
 }
@@ -567,7 +917,7 @@ async function registerDeliveredSignalApprovalPayloadForReactions(params) {
 	const targetAuthor = normalizeOptionalString(account.config.account);
 	const targetAuthorUuid = normalizeOptionalString(account.config.accountUuid);
 	if (!targetAuthor && !targetAuthorUuid) return;
-	const { registerSignalQuestionReactionTargetForDeliveredPayload } = await import("./question-reactions-BFFJNQsu.js").then((n) => n.n);
+	const { registerSignalQuestionReactionTargetForDeliveredPayload } = await import("./question-reactions-DJ1xQzVF.js").then((n) => n.n);
 	registerSignalQuestionReactionTargetForDeliveredPayload({
 		cfg: params.cfg,
 		target: {
@@ -620,7 +970,7 @@ const signalPlugin = createChatChannelPlugin({
 	base: {
 		...createSignalPluginBase({
 			setupWizard: signalSetupWizard,
-			setup: signalSetupAdapter
+			setupContract: signalSetupContract
 		}),
 		actions: signalMessageActions,
 		approvalCapability: signalApprovalCapability,
@@ -718,7 +1068,7 @@ const signalPlugin = createChatChannelPlugin({
 			probeAccount: async ({ account, timeoutMs }) => {
 				const baseUrl = account.baseUrl;
 				const { probeSignal } = await loadSignalProbeModule();
-				return await probeSignal(baseUrl, timeoutMs, { apiMode: account.config?.apiMode ?? "auto" });
+				return await probeSignal(baseUrl, timeoutMs, { transportKind: account.transport.kind });
 			},
 			formatCapabilitiesProbe: ({ probe }) => probe?.version ? [{ text: `Signal daemon: ${probe.version}` }] : [],
 			resolveAccountSnapshot: ({ account }) => ({
@@ -874,4 +1224,4 @@ const signalPlugin = createChatChannelPlugin({
 	}
 });
 //#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 };
+export { normalizeSignalAccountInput as a, signalNumberTextInput as c, probeSignalTransport as d, writeSignalAccountTransport as f, createSignalCliPathTextInput as i, signalSetupContract as l, createSignalPluginBase as n, signalCompletionNote as o, resolveSignalOutboundTarget as p, signalSetupWizard as r, signalDmPolicy as s, signalPlugin as t, prepareSignalManagedNativeTransport as u };

package/dist/channel-config-api.js

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

package/dist/channel-plugin-api.js

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

package/dist/channel.runtime-DWQdFD2O.js

@@ -0,0 +1,92 @@
+import { i as resolveSignalAccount, n as listSignalAccountIds } from "./accounts-DrStJjiK.js";
+import { c as signalNumberTextInput, i as createSignalCliPathTextInput, o as signalCompletionNote, s as signalDmPolicy } from "./channel-DQ9i00A8.js";
+import { i as installSignalCli } from "./install-signal-cli-qJF7iC4h.js";
+import { detectBinary } from "openclaw/plugin-sdk/setup-tools";
+import { createDetectedBinaryStatus, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+//#region extensions/signal/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "signal";
+const configuredLabel = t("wizard.channels.statusConfigured");
+const unconfiguredLabel = t("wizard.channels.statusNeedsSetup");
+const managedStatus = createDetectedBinaryStatus({
+	channelLabel: "Signal",
+	binaryLabel: "signal-cli",
+	configuredLabel,
+	unconfiguredLabel,
+	configuredHint: t("wizard.channels.statusSignalCliFound"),
+	unconfiguredHint: t("wizard.channels.statusSignalCliMissing"),
+	configuredScore: 1,
+	unconfiguredScore: 0,
+	resolveConfigured: ({ cfg, accountId }) => accountId ? resolveSignalAccount({
+		cfg,
+		accountId
+	}).configured : listSignalAccountIds(cfg).some((resolvedAccountId) => resolveSignalAccount({
+		cfg,
+		accountId: resolvedAccountId
+	}).configured),
+	resolveBinaryPath: ({ cfg, accountId }) => {
+		const transport = resolveSignalAccount({
+			cfg,
+			accountId
+		}).transport;
+		return transport.kind === "managed-native" ? transport.cliPath : "signal-cli";
+	},
+	detectBinary
+});
+//#endregion
+//#region extensions/signal/src/channel.runtime.ts
+const signalSetupWizard = {
+	channel,
+	status: {
+		...managedStatus,
+		resolveStatusLines: async (params) => {
+			if (resolveSignalAccount(params).transport.kind === "managed-native") return await managedStatus.resolveStatusLines?.(params) ?? [];
+			return [`Signal: ${params.configured ? configuredLabel : unconfiguredLabel}`];
+		},
+		resolveSelectionHint: async (params) => {
+			if (resolveSignalAccount(params).transport.kind === "managed-native") return await managedStatus.resolveSelectionHint?.(params);
+			return params.configured ? configuredLabel : unconfiguredLabel;
+		},
+		resolveQuickstartScore: async (params) => {
+			if (resolveSignalAccount(params).transport.kind === "managed-native") return await managedStatus.resolveQuickstartScore?.(params);
+			return params.configured ? 1 : 0;
+		}
+	},
+	prepare: async ({ cfg, accountId, credentialValues, runtime, prompter, options }) => {
+		if (!options?.allowSignalInstall) return;
+		const transport = resolveSignalAccount({
+			cfg,
+			accountId
+		}).transport;
+		if (transport.kind !== "managed-native") return;
+		const cliDetected = await detectBinary((typeof credentialValues.cliPath === "string" ? credentialValues.cliPath : void 0) ?? (transport.kind === "managed-native" ? transport.cliPath : void 0) ?? "signal-cli");
+		if (!await prompter.confirm({
+			message: cliDetected ? t("wizard.signal.reinstallPrompt") : t("wizard.signal.installPrompt"),
+			initialValue: !cliDetected
+		})) return;
+		try {
+			await options?.beforePersistentEffect?.();
+			const result = await installSignalCli(runtime);
+			if (result.ok && result.cliPath) {
+				await prompter.note(`Installed signal-cli at ${result.cliPath}`, "Signal");
+				return { credentialValues: { cliPath: result.cliPath } };
+			}
+			if (!result.ok) await prompter.note(result.error ?? "signal-cli install failed.", "Signal");
+		} catch (error) {
+			await prompter.note(`signal-cli install failed: ${String(error)}`, "Signal");
+		}
+	},
+	credentials: [],
+	textInputs: [createSignalCliPathTextInput(async ({ cfg, accountId, currentValue }) => {
+		if (resolveSignalAccount({
+			cfg,
+			accountId
+		}).transport.kind !== "managed-native") return false;
+		return !await detectBinary(currentValue ?? "signal-cli");
+	}), signalNumberTextInput],
+	completionNote: signalCompletionNote,
+	dmPolicy: signalDmPolicy,
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { signalSetupWizard };