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

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/{install-signal-cli-l35FqIbP.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";
@@ -47,6 +47,26 @@ function chunkByteLength(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.
 *
@@ -193,7 +213,7 @@ async function installSignalCliFromRelease(runtime) {
 			Accept: "application/vnd.github+json"
 		} }
 	});
-	let payload;
+	let releaseInfo;
 	try {
 		if (!response.ok) {
 			await cancelUnusedResponseBody(response);
@@ -203,7 +223,9 @@ async function installSignalCliFromRelease(runtime) {
 			};
 		}
 		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,
@@ -213,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."
@@ -223,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,
@@ -249,7 +270,7 @@ async function installSignalCliFromRelease(runtime) {
 		return {
 			ok: true,
 			cliPath,
-			version
+			version: releaseInfo.version
 		};
 	});
 }