@openclaw/signal 2026.11.3 → 2026.11.5-beta.2

package/dist/.setup/{doctor-contract-api-BIdVW0PF.mjs → doctor-contract-api-CcLwIhsD.mjs}

@@ -1,7 +1,5 @@
-import { a as normalizeSignalTransportUrl, r as buildSignalTransportHttpUrl, s as resolveSignalAccountKey, t as assertSignalSocketTransport } from "./transport-url-CAC0JcuI.mjs";
-import { a as isSignalManagedNativeConnectionUrlForBind, c as resolveLocalSignalTransportPort, i as assignSignalManagedNativePort, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort } from "./transport-policy-B6C_LogW.mjs";
-import { n as hasLegacySignalTransportFields, t as LEGACY_SIGNAL_TRANSPORT_FIELDS } from "./legacy-transport-QIpaMNST.mjs";
-import "node:module";
+import { a as buildSignalTransportHttpUrl, l as resolveSignalAccountKey, n as hasLegacySignalTransportFields, r as assertSignalSocketTransport, s as normalizeSignalTransportUrl, t as LEGACY_SIGNAL_TRANSPORT_FIELDS } from "./legacy-transport-D_cZC3bS.mjs";
+import { a as isSignalManagedNativeConnectionUrlForBind, c as resolveLocalSignalTransportPort, i as assignSignalManagedNativePort, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort } from "./transport-policy-zIR3lRUj.mjs";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 //#region \0rolldown/runtime.js
@@ -154,22 +152,6 @@ function resolveLegacyTransportWithoutDetection(params) {
 	};
 	return buildManagedNativeTransport(params.entry, params.parent);
 }
-async function resolveLegacyTransport(params) {
-	const resolved = resolveLegacyTransportWithoutDetection(params);
-	if (resolved) return resolved;
-	const account = normalizeOptionalString(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_SIGNAL_TRANSPORT_FIELDS) delete entry[field];
 }
@@ -228,62 +210,6 @@ function clearLegacySignalTransportFieldsForAccount(params) {
 	if (isRecord(account)) clearLegacyTransportFields(account);
 	return next;
 }
-function allocateMigratedManagedPorts(params) {
-	const reservedPorts = /* @__PURE__ */ new Set();
-	const rootIsAccount = hasRootSignalAccount(params.entries);
-	const nestedDefaultIndex = resolveNestedDefaultEntryIndex(params.entries);
-	const canonicalDefaultIndex = isSignalTransportConfig(params.entries[0]?.transport) ? 0 : nestedDefaultIndex !== void 0 ? nestedDefaultIndex : rootIsAccount ? 0 : void 0;
-	for (const [index, transport] of params.transports.entries()) {
-		if (!transport || index === 0 && canonicalDefaultIndex !== 0) continue;
-		if (transport.kind === "managed-native" && transport.socketPath !== void 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(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" || transport.socketPath !== void 0) return transport;
-		if (isRecord(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(nextSignal)) return;
-	const nestedDefaultIndex = resolveNestedDefaultEntryIndex(params.entries);
-	const nextAccounts = isRecord(nextSignal.accounts) ? nextSignal.accounts : {};
-	const nextEntries = [nextSignal, ...Object.values(nextAccounts).filter(isRecord)];
-	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 (index === nestedDefaultIndex) {
-			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(signal)) return false;
@@ -338,20 +264,64 @@ function prepareLegacySignalTransportMigration(cfg) {
 }
 function finishLegacySignalTransportMigration(cfg, entries, resolvedTransports) {
 	if (hasInvalidManagedTransportPort(resolvedTransports)) return pendingSignalTransportMigration(cfg, PENDING_LEGACY_INVALID_PORT_WARNING);
-	const transports = allocateMigratedManagedPorts({
-		entries,
-		transports: resolvedTransports
-	});
+	function allocateMigratedManagedPorts() {
+		const reservedPorts = /* @__PURE__ */ new Set();
+		const rootIsAccount = hasRootSignalAccount(entries);
+		const nestedDefaultIndex = resolveNestedDefaultEntryIndex(entries);
+		const canonicalDefaultIndex = isSignalTransportConfig(entries[0]?.transport) ? 0 : nestedDefaultIndex !== void 0 ? nestedDefaultIndex : rootIsAccount ? 0 : void 0;
+		for (const [index, transport] of resolvedTransports.entries()) {
+			if (!transport || index === 0 && canonicalDefaultIndex !== 0) continue;
+			if (transport.kind === "managed-native" && transport.socketPath !== void 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(entries[index]?.transport)) reservedPorts.add(transport.httpPort ?? 8080);
+		}
+		return resolvedTransports.map((transport, index) => {
+			if (!transport || index === 0 && canonicalDefaultIndex !== 0) return transport;
+			if (transport.kind !== "managed-native" || transport.socketPath !== void 0) return transport;
+			if (isRecord(entries[index]?.transport) || index === canonicalDefaultIndex) return transport;
+			const rawPreferredPort = 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);
+		});
+	}
+	const transports = allocateMigratedManagedPorts();
 	if (transports.some((transport, index) => shouldMaterializeTransport(entries, index) && !transport)) return pendingSignalTransportMigration(cfg, PENDING_LEGACY_TRANSPORT_WARNING);
-	const next = applyMigratedSignalTransports({
-		cfg,
-		entries,
-		transports
-	});
-	if (!next) return {
+	const next = structuredClone(cfg);
+	const nextSignal = next.channels?.signal;
+	if (!isRecord(nextSignal)) return {
 		config: cfg,
 		changes: []
 	};
+	const nestedDefaultIndex = resolveNestedDefaultEntryIndex(entries);
+	const nextAccounts = isRecord(nextSignal.accounts) ? nextSignal.accounts : {};
+	const nextEntries = [nextSignal, ...Object.values(nextAccounts).filter(isRecord)];
+	const rootIsAccount = hasRootSignalAccount(entries);
+	const canonicalRootTransport = isSignalTransportConfig(entries[0]?.transport) ? entries[0].transport : void 0;
+	for (const [index, entry] of nextEntries.entries()) {
+		if (index === nestedDefaultIndex) {
+			const defaultTransport = canonicalRootTransport ?? transports[index];
+			if (defaultTransport) nextSignal.transport = defaultTransport;
+			else delete nextSignal.transport;
+			delete entry.transport;
+		} else if (index === 0 && !rootIsAccount) delete entry.transport;
+		else if (transports[index]) entry.transport = transports[index];
+		else delete entry.transport;
+		clearLegacyTransportFields(entry);
+	}
+	delete nextSignal.apiMode;
 	if (hasContainerTransportWithoutEffectiveAccount(next)) return pendingSignalTransportMigration(cfg, PENDING_LEGACY_CONTAINER_ACCOUNT_WARNING);
 	return {
 		config: next,
@@ -363,12 +333,28 @@ async function migrateLegacySignalTransportConfig(params) {
 	if ("config" in prepared) return prepared;
 	const { signal, apiMode, entries, legacyResolutionEntries } = prepared;
 	if (!params.detect && legacyResolutionEntries.some((entry) => requiresDetection(entry, signal, apiMode))) return pendingSignalTransportMigration(params.cfg, 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
-	})));
+	const resolvedTransports = await Promise.all(entries.map(async (entry, index) => {
+		if (!shouldMaterializeTransport(entries, index)) return;
+		const detect = params.detect;
+		const resolved = resolveLegacyTransportWithoutDetection({
+			entry,
+			parent: signal,
+			apiMode
+		});
+		if (resolved) return resolved;
+		const account = normalizeOptionalString(inherited(entry, signal, "account"));
+		try {
+			const detected = await detect?.({
+				url: legacyBaseUrl(entry, signal),
+				...account ? { account } : {}
+			});
+			if (detected?.kind === "external-native" && resolveLegacyAutoStart(entry, signal)) return buildManagedNativeTransport(entry, signal);
+			return detected;
+		} catch {
+			if (resolveLegacyAutoStart(entry, signal)) return buildManagedNativeTransport(entry, signal);
+			return;
+		}
+	}));
 	return finishLegacySignalTransportMigration(params.cfg, entries, resolvedTransports);
 }
 function migrateLegacySignalTransportConfigSync(cfg) {
@@ -559,7 +545,9 @@ function repairSignalAccountKeys({ cfg }) {
 	const groups = /* @__PURE__ */ new Map();
 	for (const key of Object.keys(accounts)) if (key) {
 		const id = normalizeAccountId(key);
-		groups.set(id, [...groups.get(id) ?? [], key]);
+		const keys = groups.get(id);
+		if (keys) keys.push(key);
+		else groups.set(id, [key]);
 	}
 	const moves = /* @__PURE__ */ new Map();
 	const warnings = [];
@@ -576,9 +564,14 @@ function repairSignalAccountKeys({ cfg }) {
 			moves.set(key, id);
 		}
 	}
+	if (!moves.size) return {
+		config: cfg,
+		changes: [],
+		warnings
+	};
 	const repaired = Object.fromEntries(Object.entries(accounts).map(([key, entry]) => [moves.get(key) ?? key, entry]));
 	return {
-		config: moves.size ? {
+		config: {
 			...cfg,
 			channels: {
 				...cfg.channels,
@@ -587,7 +580,7 @@ function repairSignalAccountKeys({ cfg }) {
 					accounts: repaired
 				}
 			}
-		} : cfg,
+		},
 		changes: [...moves].map(([from, to]) => `Moved Signal account "${from}" to channels.signal.accounts.${to}.`),
 		warnings
 	};

package/dist/.setup/{identity-B3JyPqGO.mjs → identity-vKtR3DrM.mjs}

@@ -1,6 +1,43 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+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 normalizeSignalReactionRecipient(raw) {
+	const withoutSignal = raw.trim().replace(/^signal:/i, "").trim();
+	return /^uuid:/i.test(withoutSignal) ? withoutSignal.slice(5).trim() : withoutSignal;
+}
+function normalizeSignalMessagingTarget(raw) {
+	const normalized = raw.trim().replace(/^signal:/i, "").trim();
+	const prefix = /^(group|username|u|uuid):/i.exec(normalized)?.[0];
+	if (!prefix) return normalizeLowercaseStringOrEmpty(normalized) || void 0;
+	const id = normalized.slice(prefix.length).trim();
+	if (!id) return;
+	switch (prefix.toLowerCase()) {
+		case "group:": return `group:${id}`;
+		case "username:":
+		case "u:": return normalizeLowercaseStringOrEmpty(`username:${id}`);
+		default: return normalizeLowercaseStringOrEmpty(id);
+	}
+}
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_COMPACT_PATTERN = /^[0-9a-f]{32}$/i;
+function looksLikeSignalTargetId(raw, normalized) {
+	const candidates = normalizeStringEntries([raw, normalized ?? ""]);
+	for (const candidate of candidates) {
+		if (/^(signal:)?(group:|username:|u:)/i.test(candidate)) return true;
+		if (/^(signal:)?uuid:/i.test(candidate)) {
+			const stripped = candidate.replace(/^signal:/i, "").replace(/^uuid:/i, "").trim();
+			if (!stripped) continue;
+			if (UUID_PATTERN.test(stripped) || UUID_COMPACT_PATTERN.test(stripped)) return true;
+			continue;
+		}
+		const withoutSignalPrefix = candidate.replace(/^signal:/i, "").trim();
+		if (UUID_PATTERN.test(withoutSignalPrefix) || UUID_COMPACT_PATTERN.test(withoutSignalPrefix)) return true;
+		if (/^\+?\d{3,}$/.test(withoutSignalPrefix)) return true;
+	}
+	return false;
+}
+//#endregion
 //#region extensions/signal/src/uuid.ts
 const UUID_HYPHENATED_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const UUID_COMPACT_RE = /^[0-9a-f]{32}$/i;
@@ -94,4 +131,4 @@ function isSignalSenderAllowed(sender, allowFrom) {
 	}).allowed;
 }
 //#endregion
-export { normalizeSignalAllowRecipient as a, resolveSignalSender as c, isSignalSenderAllowed as i, looksLikeUuid as l, formatSignalSenderDisplay as n, resolveSignalPeerId as o, formatSignalSenderId as r, resolveSignalRecipient as s, formatSignalPairingIdLine as t };
+export { normalizeSignalAllowRecipient as a, resolveSignalSender as c, normalizeSignalMessagingTarget as d, normalizeSignalReactionRecipient as f, 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/.setup/{install-signal-cli-hYVLYGXe.mjs → install-signal-cli-DvLDZfpP.mjs}

@@ -17,45 +17,10 @@ const SIGNAL_CLI_DOWNLOAD_TIMEOUT_MS = 3e5;
 const SIGNAL_CLI_RELEASE_INFO_TIMEOUT_MS = 3e4;
 const CONTENT_LENGTH_RE = /^\d+$/;
 /** @internal Exported for testing. */
-async function extractSignalCliArchive(archivePath, installRoot, timeoutMs) {
-	await extractArchive({
-		archivePath,
-		destDir: installRoot,
-		timeoutMs,
-		limits: {
-			maxArchiveBytes: MAX_SIGNAL_CLI_ARCHIVE_BYTES,
-			maxEntries: 32,
-			maxEntryBytes: MAX_SIGNAL_CLI_EXTRACTED_BYTES,
-			maxExtractedBytes: MAX_SIGNAL_CLI_EXTRACTED_BYTES
-		}
-	});
-}
-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 tagName = normalizeOptionalString(value.tag_name);
-	const version = normalizeOptionalString(tagName?.replace(/^v/, ""));
-	if (!version || !Array.isArray(value.assets)) return;
-	return {
-		version,
-		assets: value.assets.flatMap((asset) => {
-			const normalized = normalizeReleaseAsset(asset);
-			return normalized ? [normalized] : [];
-		})
-	};
-}
-/** @internal Exported for testing. */
-async function downloadToFile(url, dest, maxRedirects = 5, maxBytes = MAX_SIGNAL_CLI_ARCHIVE_BYTES) {
+async function downloadToFile(url, dest) {
 	const { response, release } = await fetchWithSsrFGuard({
 		url,
-		maxRedirects,
+		maxRedirects: 5,
 		requireHttps: true,
 		timeoutMs: SIGNAL_CLI_DOWNLOAD_TIMEOUT_MS,
 		capture: false,
@@ -67,20 +32,20 @@ async function downloadToFile(url, dest, maxRedirects = 5, maxBytes = MAX_SIGNAL
 		if (rawLength !== null) {
 			const trimmedLength = rawLength.trim();
 			const declaredLength = CONTENT_LENGTH_RE.test(trimmedLength) ? Number(trimmedLength) : NaN;
-			if (Number.isFinite(declaredLength) && declaredLength > maxBytes) throw new Error(`signal-cli archive exceeds the ${maxBytes}-byte download cap (declared ${declaredLength}).`);
+			if (Number.isFinite(declaredLength) && declaredLength > MAX_SIGNAL_CLI_ARCHIVE_BYTES) throw new Error(`signal-cli archive exceeds the ${MAX_SIGNAL_CLI_ARCHIVE_BYTES}-byte download cap (declared ${declaredLength}).`);
 		}
 		const body = response.body;
 		async function* chunks() {
 			yield* body.values({ preventCancel: true });
 		}
 		await (await root(path.dirname(dest))).create(path.basename(dest), chunks(), {
-			maxBytes,
+			maxBytes: MAX_SIGNAL_CLI_ARCHIVE_BYTES,
 			mkdir: false,
 			durable: false,
 			mode: 438 & ~process.umask()
 		});
 	} catch (error) {
-		if (extractErrorCode(error) === "too-large") throw new Error(`signal-cli archive exceeded the ${maxBytes}-byte download cap.`, { cause: error });
+		if (extractErrorCode(error) === "too-large") throw new Error(`signal-cli archive exceeded the ${MAX_SIGNAL_CLI_ARCHIVE_BYTES}-byte download cap.`, { cause: error });
 		throw error;
 	} finally {
 		await release();
@@ -154,83 +119,104 @@ async function installSignalCliViaBrew(runtime) {
 		version
 	};
 }
-/** @internal Exported for testing. */
-async function installSignalCliFromRelease(runtime) {
-	const { response, release } = await fetchWithSsrFGuard({
-		url: "https://api.github.com/repos/AsamK/signal-cli/releases/latest",
-		maxRedirects: 5,
-		requireHttps: true,
-		timeoutMs: SIGNAL_CLI_RELEASE_INFO_TIMEOUT_MS,
-		capture: false,
-		auditContext: "signal-cli-release-info",
-		init: { headers: {
-			"User-Agent": "openclaw",
-			Accept: "application/vnd.github+json"
-		} }
-	});
-	let releaseInfo;
-	try {
-		if (!response.ok) return {
-			ok: false,
-			error: `Failed to fetch release info (${response.status})`
-		};
-		try {
-			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,
-				error: "Failed to parse signal-cli release info."
-			};
-		}
-	} finally {
-		await release();
-	}
-	const archives = releaseInfo.assets.filter((asset) => /\.(?:tar\.gz|tgz|zip)$/.test(normalizeLowercaseStringOrEmpty(asset.name)));
-	const byName = (pattern) => archives.find((asset) => pattern.test(normalizeLowercaseStringOrEmpty(asset.name)));
-	const asset = byName(/linux-native/) || byName(/linux/) || archives[0];
-	if (!asset) return {
+async function installSignalCli(runtime) {
+	if (process.platform === "win32") return {
 		ok: false,
-		error: "No compatible release asset found for this platform."
+		error: "Signal CLI auto-install is not supported on Windows yet."
 	};
-	return await withTempDownloadPath({
-		prefix: "openclaw-signal",
-		fileName: asset.name
-	}, async (archivePath) => {
-		runtime.log(`Downloading signal-cli ${releaseInfo.version} (${asset.name})…`);
-		await downloadToFile(asset.browser_download_url, archivePath);
-		const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", releaseInfo.version);
-		await fs.mkdir(installRoot, { recursive: true });
+	if (process.platform === "linux" && process.arch === "x64") {
+		const { response, release } = await fetchWithSsrFGuard({
+			url: "https://api.github.com/repos/AsamK/signal-cli/releases/latest",
+			maxRedirects: 5,
+			requireHttps: true,
+			timeoutMs: SIGNAL_CLI_RELEASE_INFO_TIMEOUT_MS,
+			capture: false,
+			auditContext: "signal-cli-release-info",
+			init: { headers: {
+				"User-Agent": "openclaw",
+				Accept: "application/vnd.github+json"
+			} }
+		});
+		let releaseInfo;
 		try {
-			await extractSignalCliArchive(archivePath, installRoot, 6e4);
-		} catch (err) {
-			const message = formatErrorMessage(err);
-			return {
+			if (!response.ok) return {
 				ok: false,
-				error: `Failed to extract ${asset.name}: ${message}`
+				error: `Failed to fetch release info (${response.status})`
 			};
+			try {
+				const payload = await readProviderJsonObjectResponse(response, "signal.release-info");
+				const tagName = normalizeOptionalString(payload.tag_name);
+				const version = normalizeOptionalString(tagName?.replace(/^v/, ""));
+				if (!version || !Array.isArray(payload.assets)) throw new Error("Unexpected signal-cli release info");
+				releaseInfo = {
+					version,
+					assets: payload.assets.flatMap((asset) => {
+						if (!isRecord(asset)) return [];
+						const name = normalizeOptionalString(asset.name);
+						const browserDownloadUrl = normalizeOptionalString(asset.browser_download_url);
+						return name && browserDownloadUrl ? [{
+							name,
+							browser_download_url: browserDownloadUrl
+						}] : [];
+					})
+				};
+			} catch {
+				return {
+					ok: false,
+					error: "Failed to parse signal-cli release info."
+				};
+			}
+		} finally {
+			await release();
 		}
-		const cliPath = await findSignalCliBinary(installRoot);
-		if (!cliPath) return {
+		const archives = releaseInfo.assets.filter((asset) => /\.(?:tar\.gz|tgz|zip)$/.test(normalizeLowercaseStringOrEmpty(asset.name)));
+		const byName = (pattern) => archives.find((asset) => pattern.test(normalizeLowercaseStringOrEmpty(asset.name)));
+		const asset = byName(/linux-native/) || byName(/linux/) || archives[0];
+		if (!asset) return {
 			ok: false,
-			error: `signal-cli binary not found after extracting ${asset.name}`
-		};
-		await fs.chmod(cliPath, 493).catch(() => {});
-		return {
-			ok: true,
-			cliPath,
-			version: releaseInfo.version
+			error: "No compatible release asset found for this platform."
 		};
-	});
-}
-async function installSignalCli(runtime) {
-	if (process.platform === "win32") return {
-		ok: false,
-		error: "Signal CLI auto-install is not supported on Windows yet."
-	};
-	if (process.platform === "linux" && process.arch === "x64") return installSignalCliFromRelease(runtime);
+		return await withTempDownloadPath({
+			prefix: "openclaw-signal",
+			fileName: asset.name
+		}, async (archivePath) => {
+			runtime.log(`Downloading signal-cli ${releaseInfo.version} (${asset.name})…`);
+			await downloadToFile(asset.browser_download_url, archivePath);
+			const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", releaseInfo.version);
+			await fs.mkdir(installRoot, { recursive: true });
+			try {
+				await extractArchive({
+					archivePath,
+					destDir: installRoot,
+					timeoutMs: 6e4,
+					limits: {
+						maxArchiveBytes: MAX_SIGNAL_CLI_ARCHIVE_BYTES,
+						maxEntries: 32,
+						maxEntryBytes: MAX_SIGNAL_CLI_EXTRACTED_BYTES,
+						maxExtractedBytes: MAX_SIGNAL_CLI_EXTRACTED_BYTES
+					}
+				});
+			} catch (err) {
+				const message = formatErrorMessage(err);
+				return {
+					ok: false,
+					error: `Failed to extract ${asset.name}: ${message}`
+				};
+			}
+			const cliPath = await findSignalCliBinary(installRoot);
+			if (!cliPath) return {
+				ok: false,
+				error: `signal-cli binary not found after extracting ${asset.name}`
+			};
+			await fs.chmod(cliPath, 493).catch(() => {});
+			return {
+				ok: true,
+				cliPath,
+				version: releaseInfo.version
+			};
+		});
+	}
 	return installSignalCliViaBrew(runtime);
 }
 //#endregion
-export { installSignalCliFromRelease as i, extractSignalCliArchive as n, installSignalCli as r, downloadToFile as t };
+export { installSignalCli as n, downloadToFile as t };

package/dist/.setup/{transport-url-CAC0JcuI.mjs → legacy-transport-D_cZC3bS.mjs}

@@ -1,4 +1,5 @@
 import { pathToFileURL } from "node:url";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, resolveAccountKey } from "openclaw/plugin-sdk/account-resolution";
 import { isIP } from "node:net";
 import path from "node:path";
@@ -52,4 +53,20 @@ function buildSignalSocketUrl(socketPath) {
 	return `unix://${pathToFileURL(socketPath).pathname}`;
 }
 //#endregion
-export { normalizeSignalTransportUrl as a, normalizeSignalTransportHost as i, buildSignalSocketUrl as n, resolveSignalAccountEntry as o, buildSignalTransportHttpUrl as r, resolveSignalAccountKey as s, assertSignalSocketTransport as t };
+//#region extensions/signal/src/legacy-transport.ts
+const LEGACY_SIGNAL_TRANSPORT_FIELDS = [
+	"configPath",
+	"httpUrl",
+	"httpHost",
+	"httpPort",
+	"cliPath",
+	"autoStart",
+	"startupTimeoutMs",
+	"receiveMode",
+	"ignoreStories"
+];
+function hasLegacySignalTransportFields(value) {
+	return isRecord(value) && LEGACY_SIGNAL_TRANSPORT_FIELDS.some((field) => Object.hasOwn(value, field));
+}
+//#endregion
+export { buildSignalTransportHttpUrl as a, resolveSignalAccountEntry as c, buildSignalSocketUrl as i, resolveSignalAccountKey as l, hasLegacySignalTransportFields as n, normalizeSignalTransportHost as o, assertSignalSocketTransport as r, normalizeSignalTransportUrl as s, LEGACY_SIGNAL_TRANSPORT_FIELDS as t };