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

package/dist/doctor-contract-api-DbUCknbC.js

@@ -0,0 +1,492 @@
+import { a as isSignalManagedNativeConnectionUrlForBind, c as buildSignalTransportHttpUrl, i as assignSignalManagedNativePort, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort, s as resolveLocalSignalTransportPort, u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/signal/src/config-compat.ts
+const LEGACY_TRANSPORT_FIELDS = [
+	"configPath",
+	"httpUrl",
+	"httpHost",
+	"httpPort",
+	"cliPath",
+	"autoStart",
+	"startupTimeoutMs",
+	"receiveMode",
+	"ignoreStories"
+];
+const PENDING_LEGACY_TRANSPORT_WARNING = "- channels.signal: legacy auto transport is ambiguous while its endpoint is unavailable; bring the endpoint online and rerun openclaw doctor --fix, or replace the retired fields with an explicit account-owned transport in openclaw.json.";
+const PENDING_LEGACY_INVALID_URL_WARNING = "- channels.signal: legacy httpUrl is invalid; keep the current config, correct httpUrl, then run openclaw doctor --fix.";
+const PENDING_LEGACY_INVALID_HOST_WARNING = "- channels.signal: legacy httpHost is invalid; keep the current config, correct httpHost, then run openclaw doctor --fix.";
+const PENDING_LEGACY_INVALID_PORT_WARNING = "- channels.signal: legacy httpPort must be an integer between 1 and 65535; correct httpPort, then run openclaw doctor --fix.";
+const PENDING_LEGACY_CONTAINER_ACCOUNT_WARNING = "- channels.signal: legacy container transport requires an account number; add channels.signal.account (or the relevant channels.signal.accounts.*.account) and rerun openclaw doctor --fix.";
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSignalTransportConfig(value) {
+	if (!isRecord$1(value)) return false;
+	if (value.kind === "managed-native") {
+		if (value.httpPort !== void 0 && !isValidSignalManagedNativePort(value.httpPort)) return false;
+		if (value.url === void 0) return true;
+		if (typeof value.url !== "string") return false;
+		try {
+			normalizeSignalTransportUrl(value.url);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	if (value.kind !== "external-native" && value.kind !== "container" || typeof value.url !== "string") return false;
+	try {
+		normalizeSignalTransportUrl(value.url);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function inherited(entry, parent, key) {
+	return Object.hasOwn(entry, key) ? entry[key] : parent[key];
+}
+function legacyBaseUrl(entry, parent) {
+	const url = optionalString(inherited(entry, parent, "httpUrl"));
+	if (url) return normalizeSignalTransportUrl(url);
+	const host = optionalString(inherited(entry, parent, "httpHost")) ?? "127.0.0.1";
+	const rawPort = inherited(entry, parent, "httpPort");
+	return buildSignalTransportHttpUrl(host, typeof rawPort === "number" ? rawPort : 8080);
+}
+function hasLegacyFields(entry) {
+	return LEGACY_TRANSPORT_FIELDS.some((field) => Object.hasOwn(entry, field));
+}
+function wasLegacySignalAccountConfigured(entry, parent) {
+	return Boolean(optionalString(inherited(entry, parent, "account")) || optionalString(inherited(entry, parent, "configPath")) || optionalString(inherited(entry, parent, "httpUrl")) || optionalString(inherited(entry, parent, "httpHost")) || optionalString(inherited(entry, parent, "cliPath")) || typeof inherited(entry, parent, "httpPort") === "number" || typeof inherited(entry, parent, "autoStart") === "boolean");
+}
+function hasInvalidLegacyHttpUrl(entries, parent) {
+	return entries.some((entry) => {
+		const httpUrl = optionalString(inherited(entry, parent, "httpUrl"));
+		if (!httpUrl) return false;
+		try {
+			normalizeSignalTransportUrl(httpUrl);
+			return false;
+		} catch {
+			return true;
+		}
+	});
+}
+function findInvalidLegacyDerivedEndpoint(entries, parent) {
+	for (const entry of entries) {
+		if (optionalString(inherited(entry, parent, "httpUrl"))) continue;
+		const rawPort = inherited(entry, parent, "httpPort");
+		if (rawPort !== void 0 && !isValidSignalManagedNativePort(rawPort)) return "port";
+		const host = optionalString(inherited(entry, parent, "httpHost")) ?? "127.0.0.1";
+		try {
+			buildSignalTransportHttpUrl(host, typeof rawPort === "number" ? rawPort : 8080);
+		} catch {
+			return "host";
+		}
+	}
+}
+function hasInvalidManagedTransportPort(transports) {
+	return transports.some((transport) => transport?.kind === "managed-native" && transport.httpPort !== void 0 && !isValidSignalManagedNativePort(transport.httpPort));
+}
+function requiresDetection(entry, parent, apiMode) {
+	if (apiMode !== void 0 && apiMode !== "auto") return false;
+	return Boolean(optionalString(inherited(entry, parent, "httpUrl"))) || !resolveLegacyAutoStart(entry, parent);
+}
+function resolveLegacyAutoStart(entry, parent) {
+	const autoStart = inherited(entry, parent, "autoStart");
+	if (typeof autoStart === "boolean") return autoStart;
+	return !optionalString(inherited(entry, parent, "httpUrl"));
+}
+function resolveManagedConnectionUrl(entry, parent) {
+	const httpUrl = optionalString(inherited(entry, parent, "httpUrl"));
+	if (!httpUrl) return;
+	const normalizedUrl = normalizeSignalTransportUrl(httpUrl);
+	const endpoint = new URL(normalizedUrl);
+	const bindHost = (optionalString(inherited(entry, parent, "httpHost")) ?? "127.0.0.1").replace(/^\[|\]$/g, "").toLowerCase();
+	const rawBindPort = inherited(entry, parent, "httpPort");
+	const bindPort = typeof rawBindPort === "number" ? rawBindPort : 8080;
+	const endpointHost = endpoint.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+	const endpointPort = endpoint.port ? Number.parseInt(endpoint.port, 10) : endpoint.protocol === "https:" ? 443 : 80;
+	return endpoint.protocol === "http:" && endpointHost === bindHost && endpointPort === bindPort ? void 0 : normalizedUrl;
+}
+function buildManagedNativeTransport(entry, parent) {
+	const value = (key) => inherited(entry, parent, key);
+	const configPath = optionalString(value("configPath"));
+	const cliPath = optionalString(value("cliPath"));
+	const url = resolveManagedConnectionUrl(entry, parent);
+	const httpHost = optionalString(value("httpHost"));
+	const httpPort = value("httpPort");
+	const startupTimeoutMs = value("startupTimeoutMs");
+	const receiveMode = value("receiveMode");
+	const ignoreStories = value("ignoreStories");
+	return {
+		kind: "managed-native",
+		...configPath ? { configPath } : {},
+		...cliPath ? { cliPath } : {},
+		...url ? { url } : {},
+		...httpHost ? { httpHost } : {},
+		...typeof httpPort === "number" ? { httpPort } : {},
+		...typeof startupTimeoutMs === "number" ? { startupTimeoutMs } : {},
+		...receiveMode === "on-start" || receiveMode === "manual" ? { receiveMode } : {},
+		...typeof ignoreStories === "boolean" ? { ignoreStories } : {}
+	};
+}
+function resolveLegacyTransportWithoutDetection(params) {
+	if (isSignalTransportConfig(params.entry.transport)) return params.entry.transport;
+	const baseUrl = legacyBaseUrl(params.entry, params.parent);
+	const autoStart = inherited(params.entry, params.parent, "autoStart");
+	if (params.apiMode === "container") return {
+		kind: "container",
+		url: baseUrl
+	};
+	if (params.apiMode === "native") return resolveLegacyAutoStart(params.entry, params.parent) ? buildManagedNativeTransport(params.entry, params.parent) : {
+		kind: "external-native",
+		url: baseUrl
+	};
+	if (requiresDetection(params.entry, params.parent, params.apiMode)) return;
+	if (autoStart === false) return {
+		kind: "external-native",
+		url: baseUrl
+	};
+	return buildManagedNativeTransport(params.entry, params.parent);
+}
+async function resolveLegacyTransport(params) {
+	const resolved = resolveLegacyTransportWithoutDetection(params);
+	if (resolved) return resolved;
+	const account = optionalString(inherited(params.entry, params.parent, "account"));
+	try {
+		const detected = await params.detect?.({
+			url: legacyBaseUrl(params.entry, params.parent),
+			...account ? { account } : {}
+		});
+		if (detected?.kind === "external-native" && resolveLegacyAutoStart(params.entry, params.parent)) return buildManagedNativeTransport(params.entry, params.parent);
+		return detected;
+	} catch {
+		if (resolveLegacyAutoStart(params.entry, params.parent)) return buildManagedNativeTransport(params.entry, params.parent);
+		return;
+	}
+}
+function clearLegacyTransportFields(entry) {
+	for (const field of LEGACY_TRANSPORT_FIELDS) delete entry[field];
+}
+function hasRootSignalAccount(entries) {
+	const root = entries[0];
+	return entries.length === 1 || Boolean(optionalString(root?.account)) || isSignalTransportConfig(root?.transport);
+}
+function signalAccountIds(entries) {
+	const accounts = isRecord$1(entries[0]?.accounts) ? entries[0].accounts : {};
+	return Object.entries(accounts).filter(([, entry]) => isRecord$1(entry)).map(([accountId]) => accountId);
+}
+function isDefaultSignalAccountId(accountId) {
+	return Boolean(accountId?.trim()) && normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID;
+}
+function resolveSignalAccountKey(accounts, accountId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	return Object.keys(accounts).find((key) => Boolean(key.trim()) && normalizeAccountId(key) === normalizedAccountId);
+}
+function nestedDefaultOwnsEffectiveTransport(entries) {
+	const accounts = isRecord$1(entries[0]?.accounts) ? entries[0].accounts : {};
+	const nestedDefaultKey = resolveSignalAccountKey(accounts, DEFAULT_ACCOUNT_ID);
+	const nestedDefault = nestedDefaultKey ? accounts[nestedDefaultKey] : void 0;
+	return isRecord$1(nestedDefault) && (isSignalTransportConfig(nestedDefault.transport) || hasLegacyFields(nestedDefault));
+}
+function isDiscardedTransportEntry(entries, index) {
+	if (index === 0) return !hasRootSignalAccount(entries) || nestedDefaultOwnsEffectiveTransport(entries);
+	return isDefaultSignalAccountId(signalAccountIds(entries)[index - 1]) && isSignalTransportConfig(entries[0]?.transport);
+}
+function shouldMaterializeTransport(entries, index) {
+	if (isDiscardedTransportEntry(entries, index)) return false;
+	const entry = entries[index];
+	const parent = entries[0];
+	return Boolean(entry && parent && (isSignalTransportConfig(entry.transport) || wasLegacySignalAccountConfigured(entry, parent)));
+}
+function clearLegacySignalTransportFieldsForAccount(params) {
+	const next = structuredClone(params.cfg);
+	const signal = next.channels?.signal;
+	if (!isRecord$1(signal)) return next;
+	if (isDefaultSignalAccountId(params.accountId)) {
+		clearLegacyTransportFields(signal);
+		delete signal.apiMode;
+		const accounts = isRecord$1(signal.accounts) ? signal.accounts : void 0;
+		const nestedDefaultKey = accounts ? resolveSignalAccountKey(accounts, DEFAULT_ACCOUNT_ID) : void 0;
+		const nestedDefault = nestedDefaultKey ? accounts?.[nestedDefaultKey] : void 0;
+		if (isRecord$1(nestedDefault)) {
+			clearLegacyTransportFields(nestedDefault);
+			delete nestedDefault.transport;
+		}
+		return next;
+	}
+	const accounts = isRecord$1(signal.accounts) ? signal.accounts : void 0;
+	const accountKey = accounts ? resolveSignalAccountKey(accounts, params.accountId) : void 0;
+	const account = accountKey ? accounts?.[accountKey] : void 0;
+	if (isRecord$1(account)) clearLegacyTransportFields(account);
+	return next;
+}
+function allocateMigratedManagedPorts(params) {
+	const reservedPorts = /* @__PURE__ */ new Set();
+	const rootIsAccount = hasRootSignalAccount(params.entries);
+	const nestedDefaultOffset = signalAccountIds(params.entries).findIndex((accountId) => isDefaultSignalAccountId(accountId));
+	const canonicalDefaultIndex = isSignalTransportConfig(params.entries[0]?.transport) ? 0 : nestedDefaultOffset >= 0 ? nestedDefaultOffset + 1 : rootIsAccount ? 0 : void 0;
+	for (const [index, transport] of params.transports.entries()) {
+		if (!transport || index === 0 && canonicalDefaultIndex !== 0) continue;
+		if (transport.kind !== "managed-native") {
+			const localPort = resolveLocalSignalTransportPort(transport.url);
+			if (localPort !== void 0) reservedPorts.add(localPort);
+			continue;
+		}
+		if (transport.url && !isSignalManagedNativeConnectionUrlForBind(transport)) {
+			const localConnectionPort = resolveLocalSignalTransportPort(transport.url);
+			if (localConnectionPort !== void 0) reservedPorts.add(localConnectionPort);
+		}
+		if (index === canonicalDefaultIndex || isRecord$1(params.entries[index]?.transport)) reservedPorts.add(transport.httpPort ?? 8080);
+	}
+	return params.transports.map((transport, index) => {
+		if (!transport || index === 0 && canonicalDefaultIndex !== 0) return transport;
+		if (transport.kind !== "managed-native") return transport;
+		if (isRecord$1(params.entries[index]?.transport) || index === canonicalDefaultIndex) return transport;
+		const rawPreferredPort = params.entries[index]?.httpPort;
+		const preferredPort = typeof rawPreferredPort === "number" ? rawPreferredPort : transport.httpPort;
+		const httpPort = allocateSignalManagedNativePort({
+			reservedPorts,
+			...typeof preferredPort === "number" ? { preferredPort } : {}
+		});
+		reservedPorts.add(httpPort);
+		return assignSignalManagedNativePort(transport, httpPort);
+	});
+}
+function applyMigratedSignalTransports(params) {
+	const next = structuredClone(params.cfg);
+	const nextSignal = next.channels?.signal;
+	if (!isRecord$1(nextSignal)) return;
+	const accountIds = signalAccountIds(params.entries);
+	const nextAccounts = isRecord$1(nextSignal.accounts) ? nextSignal.accounts : {};
+	const nextEntries = [nextSignal, ...Object.values(nextAccounts).filter(isRecord$1)];
+	const rootIsAccount = hasRootSignalAccount(params.entries);
+	const canonicalRootTransport = isSignalTransportConfig(params.entries[0]?.transport) ? params.entries[0].transport : void 0;
+	for (const [index, entry] of nextEntries.entries()) {
+		if (isDefaultSignalAccountId(index === 0 ? void 0 : accountIds[index - 1])) {
+			const defaultTransport = canonicalRootTransport ?? params.transports[index];
+			if (defaultTransport) nextSignal.transport = defaultTransport;
+			else delete nextSignal.transport;
+			delete entry.transport;
+		} else if (index === 0 && !rootIsAccount) delete entry.transport;
+		else if (params.transports[index]) entry.transport = params.transports[index];
+		else delete entry.transport;
+		clearLegacyTransportFields(entry);
+	}
+	delete nextSignal.apiMode;
+	return next;
+}
+function hasContainerTransportWithoutEffectiveAccount(cfg) {
+	const signal = cfg.channels?.signal;
+	if (!isRecord$1(signal)) return false;
+	const accounts = isRecord$1(signal.accounts) ? signal.accounts : {};
+	const rootTransport = isSignalTransportConfig(signal.transport) ? signal.transport : void 0;
+	const defaultKey = resolveSignalAccountKey(accounts, DEFAULT_ACCOUNT_ID);
+	const defaultEntry = defaultKey ? accounts[defaultKey] : void 0;
+	const defaultAccount = isRecord$1(defaultEntry) && defaultEntry.account !== void 0 ? optionalString(defaultEntry.account) : optionalString(signal.account);
+	const channelEnabled = signal.enabled !== false;
+	const defaultEnabled = !isRecord$1(defaultEntry) || defaultEntry.enabled !== false;
+	if (rootTransport?.kind === "container" && channelEnabled && defaultEnabled && !defaultAccount) return true;
+	for (const [accountId, entry] of Object.entries(accounts)) {
+		if (!isRecord$1(entry)) continue;
+		if (!channelEnabled || entry.enabled === false) continue;
+		const isDefaultAccount = isDefaultSignalAccountId(accountId);
+		if ((isDefaultAccount && rootTransport ? rootTransport : isSignalTransportConfig(entry.transport) ? entry.transport : void 0)?.kind !== "container" || isDefaultAccount && rootTransport) continue;
+		if (!(entry.account === void 0 ? optionalString(signal.account) : optionalString(entry.account))) return true;
+	}
+	return false;
+}
+async function migrateLegacySignalTransportConfig(params) {
+	const signal = params.cfg.channels?.signal;
+	if (!isRecord$1(signal)) return {
+		config: params.cfg,
+		changes: []
+	};
+	const accounts = isRecord$1(signal.accounts) ? signal.accounts : {};
+	if (!(Object.hasOwn(signal, "apiMode") || hasLegacyFields(signal) || Object.values(accounts).some((entry) => isRecord$1(entry) && hasLegacyFields(entry)))) return {
+		config: params.cfg,
+		changes: []
+	};
+	const apiMode = signal.apiMode;
+	const entries = [signal, ...Object.values(accounts).filter(isRecord$1)];
+	const legacyResolutionEntries = entries.filter((_, index) => shouldMaterializeTransport(entries, index)).filter((entry) => !isSignalTransportConfig(entry.transport));
+	const invalidDerivedEndpoint = findInvalidLegacyDerivedEndpoint(legacyResolutionEntries, signal);
+	if (invalidDerivedEndpoint) return {
+		config: params.cfg,
+		changes: [],
+		warnings: [invalidDerivedEndpoint === "port" ? PENDING_LEGACY_INVALID_PORT_WARNING : PENDING_LEGACY_INVALID_HOST_WARNING]
+	};
+	if (hasInvalidLegacyHttpUrl(legacyResolutionEntries, signal)) return {
+		config: params.cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_INVALID_URL_WARNING]
+	};
+	if (!params.detect && legacyResolutionEntries.some((entry) => requiresDetection(entry, signal, apiMode))) return {
+		config: params.cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_TRANSPORT_WARNING]
+	};
+	const resolvedTransports = await Promise.all(entries.map(async (entry, index) => !shouldMaterializeTransport(entries, index) ? void 0 : await resolveLegacyTransport({
+		entry,
+		parent: signal,
+		apiMode,
+		detect: params.detect
+	})));
+	if (hasInvalidManagedTransportPort(resolvedTransports)) return {
+		config: params.cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_INVALID_PORT_WARNING]
+	};
+	const transports = allocateMigratedManagedPorts({
+		entries,
+		transports: resolvedTransports
+	});
+	if (transports.some((transport, index) => shouldMaterializeTransport(entries, index) && !transport)) return {
+		config: params.cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_TRANSPORT_WARNING]
+	};
+	const next = applyMigratedSignalTransports({
+		cfg: params.cfg,
+		entries,
+		transports
+	});
+	if (!next) return {
+		config: params.cfg,
+		changes: []
+	};
+	if (hasContainerTransportWithoutEffectiveAccount(next)) return {
+		config: params.cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_CONTAINER_ACCOUNT_WARNING]
+	};
+	return {
+		config: next,
+		changes: ["Migrated channels.signal transport settings to concrete account-owned transport objects."]
+	};
+}
+function migrateLegacySignalTransportConfigSync(cfg) {
+	const signal = cfg.channels?.signal;
+	if (!isRecord$1(signal)) return {
+		config: cfg,
+		changes: []
+	};
+	const accounts = isRecord$1(signal.accounts) ? signal.accounts : {};
+	if (!(Object.hasOwn(signal, "apiMode") || hasLegacyFields(signal) || Object.values(accounts).some((entry) => isRecord$1(entry) && hasLegacyFields(entry)))) return {
+		config: cfg,
+		changes: []
+	};
+	const entries = [signal, ...Object.values(accounts).filter(isRecord$1)];
+	const legacyResolutionEntries = entries.filter((_, index) => shouldMaterializeTransport(entries, index)).filter((entry) => !isSignalTransportConfig(entry.transport));
+	const invalidDerivedEndpoint = findInvalidLegacyDerivedEndpoint(legacyResolutionEntries, signal);
+	if (invalidDerivedEndpoint) return {
+		config: cfg,
+		changes: [],
+		warnings: [invalidDerivedEndpoint === "port" ? PENDING_LEGACY_INVALID_PORT_WARNING : PENDING_LEGACY_INVALID_HOST_WARNING]
+	};
+	if (hasInvalidLegacyHttpUrl(legacyResolutionEntries, signal)) return {
+		config: cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_INVALID_URL_WARNING]
+	};
+	const resolvedTransports = entries.map((entry, index) => {
+		if (!shouldMaterializeTransport(entries, index)) return;
+		return resolveLegacyTransportWithoutDetection({
+			entry,
+			parent: signal,
+			apiMode: signal.apiMode
+		});
+	});
+	if (hasInvalidManagedTransportPort(resolvedTransports)) return {
+		config: cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_INVALID_PORT_WARNING]
+	};
+	const transports = allocateMigratedManagedPorts({
+		entries,
+		transports: resolvedTransports
+	});
+	if (transports.some((transport, index) => shouldMaterializeTransport(entries, index) && !transport)) return {
+		config: cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_TRANSPORT_WARNING]
+	};
+	const next = applyMigratedSignalTransports({
+		cfg,
+		entries,
+		transports
+	});
+	if (!next) return {
+		config: cfg,
+		changes: []
+	};
+	if (hasContainerTransportWithoutEffectiveAccount(next)) return {
+		config: cfg,
+		changes: [],
+		warnings: [PENDING_LEGACY_CONTAINER_ACCOUNT_WARNING]
+	};
+	return {
+		config: next,
+		changes: ["Migrated channels.signal transport settings to concrete account-owned transport objects."]
+	};
+}
+//#endregion
+//#region extensions/signal/doctor-contract-api.ts
+const RETIRED_SIGNAL_ACCOUNT_TRANSPORT_FIELDS = [
+	"configPath",
+	"httpUrl",
+	"httpHost",
+	"httpPort",
+	"cliPath",
+	"autoStart",
+	"startupTimeoutMs",
+	"receiveMode",
+	"ignoreStories"
+];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasRetiredSignalAccountTransportFields(value) {
+	return isRecord(value) && RETIRED_SIGNAL_ACCOUNT_TRANSPORT_FIELDS.some((field) => Object.hasOwn(value, field));
+}
+function hasRetiredSignalAccountMapTransportFields(value) {
+	return isRecord(value) && Object.values(value).some(hasRetiredSignalAccountTransportFields);
+}
+const streamingAliasMigration = defineChannelAliasMigration({
+	channelId: "signal",
+	streaming: {
+		defaultMode: "partial",
+		deliveryOnly: true
+	},
+	accountStreamingReplacesRoot: true
+});
+const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	{
+		path: ["channels", "signal"],
+		message: "Signal transport config is now account-owned; run \"openclaw doctor --fix\" to migrate retired channels.signal transport fields.",
+		match: (value) => isRecord(value) && (Object.hasOwn(value, "apiMode") || hasRetiredSignalAccountTransportFields(value))
+	},
+	{
+		path: [
+			"channels",
+			"signal",
+			"accounts"
+		],
+		message: "Signal transport config is now account-owned; run \"openclaw doctor --fix\" to migrate retired per-account transport fields.",
+		match: hasRetiredSignalAccountMapTransportFields
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const streaming = streamingAliasMigration.normalizeChannelConfig({ cfg });
+	const transport = migrateLegacySignalTransportConfigSync(streaming.config);
+	return {
+		config: transport.config,
+		changes: [...streaming.changes, ...transport.changes],
+		...transport.warnings?.length ? { warnings: transport.warnings } : {}
+	};
+}
+//#endregion
+export { migrateLegacySignalTransportConfig as i, normalizeCompatibilityConfig as n, clearLegacySignalTransportFieldsForAccount as r, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -1,16 +1,2 @@
-import { defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor";
-//#region extensions/signal/doctor-contract-api.ts
-const streamingAliasMigration = defineChannelAliasMigration({
-	channelId: "signal",
-	streaming: {
-		defaultMode: "partial",
-		deliveryOnly: true
-	},
-	accountStreamingReplacesRoot: true
-});
-const legacyConfigRules = streamingAliasMigration.legacyConfigRules;
-function normalizeCompatibilityConfig({ cfg }) {
-	return streamingAliasMigration.normalizeChannelConfig({ cfg });
-}
-//#endregion
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-api-DbUCknbC.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/{identity-BF8taj7g.js → identity-BQ4OzXXk.js}

@@ -1,5 +1,6 @@
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 //#region extensions/signal/src/normalize.ts
 function normalizeSignalMessagingTarget(raw) {
 	const trimmed = raw.trim();
@@ -122,16 +123,24 @@ function normalizeSignalAllowRecipient(entry) {
 	return parsed.kind === "phone" ? parsed.e164 : parsed.raw;
 }
 function isSignalSenderAllowed(sender, allowFrom) {
-	if (allowFrom.length === 0) return false;
-	const parsed = allowFrom.map(parseSignalAllowEntry).filter((entry) => entry !== null);
-	if (parsed.some((entry) => entry.kind === "any")) return true;
+	const normalizedAllowFrom = allowFrom.flatMap((entry) => {
+		const parsed = parseSignalAllowEntry(entry);
+		if (!parsed) return [];
+		if (parsed.kind === "any") return ["*"];
+		return [parsed.kind === "phone" ? `phone:${parsed.e164}` : `uuid:${parsed.raw}`];
+	});
 	const senderE164 = sender.kind === "phone" ? sender.e164 : sender.aliases?.e164;
 	const senderUuid = sender.kind === "uuid" ? sender.raw : sender.aliases?.uuid;
-	return parsed.some((entry) => {
-		if (entry.kind === "phone") return senderE164 !== void 0 && entry.e164 === senderE164;
-		if (entry.kind === "uuid") return senderUuid !== void 0 && entry.raw === senderUuid;
-		return false;
-	});
+	return resolveAllowlistMatchByCandidates({
+		allowList: normalizedAllowFrom,
+		candidates: [{
+			value: senderE164 ? `phone:${senderE164}` : void 0,
+			source: "phone"
+		}, {
+			value: senderUuid ? `uuid:${senderUuid}` : void 0,
+			source: "uuid"
+		}]
+	}).allowed;
 }
 //#endregion
 export { normalizeSignalAllowRecipient as a, resolveSignalSender as c, normalizeSignalMessagingTarget as d, isSignalSenderAllowed as i, looksLikeUuid as l, formatSignalSenderDisplay as n, resolveSignalPeerId as o, formatSignalSenderId as r, resolveSignalRecipient as s, formatSignalPairingIdLine as t, looksLikeSignalTargetId as u };

package/dist/{install-signal-cli-CtusY3tN.js → install-signal-cli-qJF7iC4h.js}

@@ -1,4 +1,4 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import nodePath from "node:path";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
@@ -7,7 +7,7 @@ import { createWriteStream } from "node:fs";
 import fs from "node:fs/promises";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
+import { readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
 import { runPluginCommandWithTimeout } from "openclaw/plugin-sdk/run-command";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
 import { withTempDownloadPath } from "openclaw/plugin-sdk/temp-path";
@@ -44,6 +44,29 @@ function chunkByteLength(chunk) {
 	if (chunk instanceof Uint8Array) return chunk.byteLength;
 	return Buffer.byteLength(String(chunk));
 }
+async function cancelUnusedResponseBody(response) {
+	await response.body?.cancel().catch(() => void 0);
+}
+function normalizeReleaseAsset(value) {
+	if (!isRecord(value)) return;
+	const name = normalizeOptionalString(value.name);
+	const browserDownloadUrl = normalizeOptionalString(value.browser_download_url);
+	return name && browserDownloadUrl ? {
+		name,
+		browser_download_url: browserDownloadUrl
+	} : void 0;
+}
+function normalizeSignalCliRelease(value) {
+	const version = normalizeOptionalString(normalizeOptionalString(value.tag_name)?.replace(/^v/, ""));
+	if (!version || !Array.isArray(value.assets)) return;
+	return {
+		version,
+		assets: value.assets.flatMap((asset) => {
+			const normalized = normalizeReleaseAsset(asset);
+			return normalized ? [normalized] : [];
+		})
+	};
+}
 /**
 * Pick a native release asset from the official GitHub releases.
 *
@@ -76,7 +99,10 @@ async function downloadToFile(url, dest, maxRedirects = 5, maxBytes = MAX_SIGNAL
 		auditContext: "signal-cli-install-archive"
 	});
 	try {
-		if (!response.ok || !response.body) throw new Error(`HTTP ${response.status || "?"} downloading file`);
+		if (!response.ok || !response.body) {
+			await cancelUnusedResponseBody(response);
+			throw new Error(`HTTP ${response.status || "?"} downloading file`);
+		}
 		const rawLength = response.headers.get("content-length");
 		if (rawLength !== null) {
 			const trimmedLength = rawLength.trim();
@@ -187,14 +213,19 @@ async function installSignalCliFromRelease(runtime) {
 			Accept: "application/vnd.github+json"
 		} }
 	});
-	let payload;
+	let releaseInfo;
 	try {
-		if (!response.ok) return {
-			ok: false,
-			error: `Failed to fetch release info (${response.status})`
-		};
+		if (!response.ok) {
+			await cancelUnusedResponseBody(response);
+			return {
+				ok: false,
+				error: `Failed to fetch release info (${response.status})`
+			};
+		}
 		try {
-			payload = await readProviderJsonResponse(response, "signal.release-info");
+			const normalized = normalizeSignalCliRelease(await readProviderJsonObjectResponse(response, "signal.release-info"));
+			if (!normalized) throw new Error("Unexpected signal-cli release info");
+			releaseInfo = normalized;
 		} catch {
 			return {
 				ok: false,
@@ -204,8 +235,7 @@ async function installSignalCliFromRelease(runtime) {
 	} finally {
 		await release();
 	}
-	const version = payload.tag_name?.replace(/^v/, "") ?? "unknown";
-	const asset = pickAsset(payload.assets ?? [], process.platform, process.arch);
+	const asset = pickAsset(releaseInfo.assets, process.platform, process.arch);
 	if (!asset) return {
 		ok: false,
 		error: "No compatible release asset found for this platform."
@@ -214,9 +244,9 @@ async function installSignalCliFromRelease(runtime) {
 		prefix: "openclaw-signal",
 		fileName: asset.name
 	}, async (archivePath) => {
-		runtime.log(`Downloading signal-cli ${version} (${asset.name})…`);
+		runtime.log(`Downloading signal-cli ${releaseInfo.version} (${asset.name})…`);
 		await downloadToFile(asset.browser_download_url, archivePath);
-		const installRoot = nodePath.join(CONFIG_DIR, "tools", "signal-cli", version);
+		const installRoot = nodePath.join(CONFIG_DIR, "tools", "signal-cli", releaseInfo.version);
 		await fs.mkdir(installRoot, { recursive: true });
 		if (!looksLikeArchive(normalizeLowercaseStringOrEmpty(asset.name))) return {
 			ok: false,
@@ -240,7 +270,7 @@ async function installSignalCliFromRelease(runtime) {
 		return {
 			ok: true,
 			cliPath,
-			version
+			version: releaseInfo.version
 		};
 	});
 }