@openclaw/signal 2026.9.4 → 2026.9.5

package/dist/{client-B3C0ciqU.js → .setup/client-BseAt7F7.mjs}

@@ -1,15 +1,23 @@
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import net, { createConnection } from "node:net";
+import path from "node:path";
 import { detectMime, extractOriginalFilename, parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
-import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { parseStrictNonNegativeInteger, resolvePositiveTimerTimeoutMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { coerceErrorMessage, formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readResponseTextPrefix, readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { readRegularFile } from "openclaw/plugin-sdk/security-runtime";
-import path from "node:path";
 import { Buffer as Buffer$1 } from "node:buffer";
 import http from "node:http";
 import https from "node:https";
 import { generateSecureUuid } from "openclaw/plugin-sdk/core";
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { lstat, mkdir, rmdir, unlink } from "node:fs/promises";
+import os from "node:os";
+import { promisify } from "node:util";
 //#region extensions/signal/src/ws-runtime.ts
 const require = createRequire(import.meta.url);
 const WebSocket = require(path.join(path.dirname(require.resolve("ws/package.json")), "index.js"));
@@ -22,7 +30,7 @@ const WebSocket = require(path.join(path.dirname(require.resolve("ws/package.jso
 * This is a separate implementation from client.ts (native signal-cli)
 * to keep the two modes cleanly isolated.
 */
-const DEFAULT_TIMEOUT_MS$1 = 1e4;
+const DEFAULT_TIMEOUT_MS$2 = 1e4;
 const DEFAULT_ATTACHMENT_RESPONSE_MAX_BYTES = 1048576;
 const SIGNAL_REST_ERROR_RESPONSE_MAX_BYTES = 16384;
 const SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES = 16777216;
@@ -58,7 +66,7 @@ function signalRestRequestTimeoutError() {
 }
 /** Keep one absolute deadline across headers and every bounded body reader. */
 async function withSignalRestDeadline(timeoutMs, run) {
-	const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
 	const deadlineAtMs = Date.now() + safeTimeoutMs;
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(signalRestRequestTimeoutError()), safeTimeoutMs);
@@ -132,7 +140,7 @@ async function releaseUnreadResponseBody(res) {
 /**
 * Check if bbernhard container REST API is available.
 */
-async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1, account) {
+async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$2, account) {
 	const normalized = normalizeBaseUrl$1(baseUrl);
 	let res;
 	try {
@@ -162,7 +170,7 @@ async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1, account
 function containerReceiveCheck(normalizedBaseUrl, account, timeoutMs) {
 	const wsUrl = `${normalizedBaseUrl.replace(/^http/, "ws")}/v1/receive/${encodeURIComponent(account)}`;
 	return new Promise((resolve) => {
-		const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+		const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
 		let settled = false;
 		let ws;
 		const timer = setTimeout(() => {
@@ -233,11 +241,12 @@ async function containerRestRequest(endpoint, opts, method = "GET", body) {
 		headers: { "Content-Type": "application/json" }
 	};
 	if (body) init.body = JSON.stringify(body);
-	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
-	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2;
+	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
 	const fetchImpl = resolveFetch();
 	if (!fetchImpl) throw new Error("fetch is not available");
 	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
+		opts.assertDirectAdapterHandoff?.();
 		const res = await fetchImpl(url, {
 			...init,
 			signal
@@ -266,8 +275,8 @@ async function containerRestRequest(endpoint, opts, method = "GET", body) {
 */
 async function containerFetchAttachment(attachmentId, opts) {
 	const url = `${normalizeBaseUrl$1(opts.baseUrl)}/v1/attachments/${encodeURIComponent(attachmentId)}`;
-	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
-	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2;
+	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
 	const fetchImpl = resolveFetch();
 	if (!fetchImpl) throw new Error("fetch is not available");
 	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
@@ -328,7 +337,7 @@ async function streamContainerEvents(params) {
 		try {
 			ws = new WebSocket(wsUrl, {
 				maxPayload: WS_MAX_PAYLOAD,
-				handshakeTimeout: WS_HANDSHAKE_MS
+				handshakeTimeout: resolvePositiveTimerTimeoutMs(params.timeoutMs, WS_HANDSHAKE_MS)
 			});
 		} catch (err) {
 			logError(`[signal-ws] failed to create WebSocket: ${coerceErrorMessage(err)}`);
@@ -477,10 +486,7 @@ async function containerSendMessage(params) {
 		payload.quote_author = params.quoteAuthor;
 		payload.quote_message = params.quoteMessage ?? "";
 	}
-	const timestamp = parseContainerSendTimestamp((await containerRestRequest("/v2/send", {
-		baseUrl: params.baseUrl,
-		timeoutMs: params.timeoutMs
-	}, "POST", payload))?.timestamp);
+	const timestamp = parseContainerSendTimestamp((await containerRestRequest("/v2/send", params, "POST", payload))?.timestamp);
 	return timestamp === void 0 ? {} : { timestamp };
 }
 /**
@@ -488,20 +494,14 @@ async function containerSendMessage(params) {
 */
 async function containerSendTyping(params) {
 	const method = params.stop ? "DELETE" : "PUT";
-	await containerRestRequest(`/v1/typing-indicator/${encodeURIComponent(params.account)}`, {
-		baseUrl: params.baseUrl,
-		timeoutMs: params.timeoutMs
-	}, method, { recipient: params.recipient });
+	await containerRestRequest(`/v1/typing-indicator/${encodeURIComponent(params.account)}`, params, method, { recipient: params.recipient });
 	return true;
 }
 /**
 * Send read receipt via bbernhard container REST API.
 */
 async function containerSendReceipt(params) {
-	await containerRestRequest(`/v1/receipts/${encodeURIComponent(params.account)}`, {
-		baseUrl: params.baseUrl,
-		timeoutMs: params.timeoutMs
-	}, "POST", {
+	await containerRestRequest(`/v1/receipts/${encodeURIComponent(params.account)}`, params, "POST", {
 		recipient: params.recipient,
 		timestamp: params.timestamp,
 		receipt_type: params.type ?? "read"
@@ -519,10 +519,7 @@ async function containerSendReaction(params) {
 		timestamp: params.targetTimestamp
 	};
 	if (params.groupId) payload.group_id = params.groupId;
-	return await containerRestRequest(`/v1/reactions/${encodeURIComponent(params.account)}`, {
-		baseUrl: params.baseUrl,
-		timeoutMs: params.timeoutMs
-	}, params.remove ? "DELETE" : "POST", payload) ?? {};
+	return await containerRestRequest(`/v1/reactions/${encodeURIComponent(params.account)}`, params, params.remove ? "DELETE" : "POST", payload) ?? {};
 }
 /**
 * Strip the "uuid:" prefix that native signal-cli accepts but the container API rejects.
@@ -565,39 +562,35 @@ async function containerRpcRequest(method, params, opts) {
 			const quoteTimestamp = normalizeContainerQuoteTimestamp(p.quoteTimestamp ?? p["quote-timestamp"]);
 			const quoteAuthor = normalizeContainerQuoteText(p.quoteAuthor ?? p["quote-author"]);
 			return await containerSendMessage({
-				baseUrl: opts.baseUrl,
+				...opts,
 				account: p.account ?? "",
 				recipients: finalRecipients,
 				message: p.message ?? "",
 				textStyles,
 				attachments: p.attachments,
-				maxAttachmentBytes: opts.maxAttachmentBytes,
 				quoteTimestamp,
 				quoteAuthor: quoteAuthor ? stripUuidPrefix(quoteAuthor) : void 0,
-				quoteMessage: normalizeContainerQuoteText(p.quoteMessage ?? p["quote-message"]),
-				timeoutMs: opts.timeoutMs
+				quoteMessage: normalizeContainerQuoteText(p.quoteMessage ?? p["quote-message"])
 			});
 		}
 		case "sendTyping": {
 			const recipient = stripUuidPrefix(p.recipient?.[0] ?? (p.groupId ? formatGroupIdForContainer(p.groupId) : ""));
 			await containerSendTyping({
-				baseUrl: opts.baseUrl,
+				...opts,
 				account: p.account ?? "",
 				recipient,
-				stop: p.stop,
-				timeoutMs: opts.timeoutMs
+				stop: p.stop
 			});
 			return;
 		}
 		case "sendReceipt": {
 			const recipient = stripUuidPrefix(p.recipient?.[0] ?? "");
 			await containerSendReceipt({
-				baseUrl: opts.baseUrl,
+				...opts,
 				account: p.account ?? "",
 				recipient,
 				timestamp: p.targetTimestamp,
-				type: p.type,
-				timeoutMs: opts.timeoutMs
+				type: p.type
 			});
 			return;
 		}
@@ -607,14 +600,13 @@ async function containerRpcRequest(method, params, opts) {
 			const formattedGroupId = groupId ? formatGroupIdForContainer(groupId) : void 0;
 			const effectiveRecipient = formattedGroupId || recipient || "";
 			return await containerSendReaction({
-				baseUrl: opts.baseUrl,
+				...opts,
 				account: p.account ?? "",
 				recipient: effectiveRecipient,
 				emoji: p.emoji ?? "",
 				targetAuthor: stripUuidPrefix(p.targetAuthor ?? recipient),
 				targetTimestamp: p.targetTimestamp,
 				groupId: formattedGroupId,
-				timeoutMs: opts.timeoutMs,
 				remove: Boolean(p.remove)
 			});
 		}
@@ -636,6 +628,269 @@ async function containerRpcRequest(method, params, opts) {
 	}
 }
 //#endregion
+//#region extensions/signal/src/socket-path.ts
+const execFileAsync = promisify(execFile);
+function socketOwner(socketPath) {
+	if (process.platform === "win32" || !process.getuid) throw new Error("Signal UNIX socket transport requires a POSIX host");
+	if (!path.isAbsolute(socketPath) || path.normalize(socketPath) !== socketPath || socketPath.includes("\0")) throw new Error("Signal socketPath must be a normalized absolute path without NUL bytes");
+	if (Buffer.byteLength(socketPath) > 103) throw new Error("Signal socketPath must be at most 103 UTF-8 bytes");
+	return process.getuid();
+}
+async function assertDarwinAclSafe(entryPath, ownerUid, rejectInheritedAllow) {
+	if (process.platform !== "darwin") return;
+	let stdout;
+	try {
+		({stdout} = await execFileAsync("/bin/ls", ["-lde", entryPath], { encoding: "utf8" }));
+	} catch {
+		throw new Error("Signal socketPath ACLs could not be inspected safely");
+	}
+	const ownerName = ownerUid === 0 ? "root" : os.userInfo().username;
+	for (const line of stdout.split("\n").slice(1)) {
+		if (!/^\s*\d+:\s+/.test(line) || !/\ballow\b/.test(line)) continue;
+		const ownerAllow = line.includes(`user:${ownerName} `);
+		const inheritable = /\b(file_inherit|directory_inherit|limit_inherit|only_inherit)\b/.test(line);
+		if (!ownerAllow || rejectInheritedAllow && inheritable) throw new Error("Signal socketPath must not grant ACL access to other users");
+	}
+}
+async function validateDirectories(directory, uid, privateParent, inspectAcl) {
+	const parts = path.resolve(directory).split(path.sep).filter(Boolean);
+	let current = path.parse(directory).root;
+	for (const part of parts) {
+		current = path.join(current, part);
+		const stat = await lstat(current);
+		if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Signal socketPath must not traverse symlinks or non-directories");
+		if (stat.uid !== uid && stat.uid !== 0) throw new Error("Signal socketPath ancestors must belong to the current user or root");
+		if ((stat.mode & 18) !== 0 && !(stat.uid === 0 && (stat.mode & 512) !== 0)) throw new Error("Signal socketPath ancestors must not be writable by other users");
+		if (privateParent && current === path.resolve(directory)) {
+			if (stat.uid !== uid || (stat.mode & 511) !== 448) throw new Error("Signal socketPath parent must belong to the current user with mode 0700");
+		}
+		if (inspectAcl) await assertDarwinAclSafe(current, stat.uid, true);
+	}
+	if (privateParent && parts.length === 0) throw new Error("Signal socketPath requires a private parent directory");
+}
+/** Validate the OS-user boundary before every connection, not only at startup. */
+async function validateSignalSocketPath(socketPath) {
+	const uid = socketOwner(socketPath);
+	await validateDirectories(path.dirname(socketPath), uid, true, true);
+}
+async function assertSignalSocketEndpoint(socketPath) {
+	await validateSignalSocketPath(socketPath);
+	const stat = await lstat(socketPath);
+	if (!stat.isSocket() || stat.uid !== socketOwner(socketPath)) throw new Error("Signal socketPath must name a socket owned by the current user");
+	await assertDarwinAclSafe(socketPath, stat.uid, false);
+}
+async function isStaleSocket(socketPath, abortSignal) {
+	abortSignal?.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		const timer = setTimeout(() => finish(/* @__PURE__ */ new Error("Signal socket ownership probe timed out")), 1e3);
+		const onAbort = () => finish(/* @__PURE__ */ new Error("Signal socket ownership probe aborted"));
+		function finish(error, stale = false) {
+			clearTimeout(timer);
+			abortSignal?.removeEventListener("abort", onAbort);
+			socket.destroy();
+			if (error) reject(error);
+			else resolve(stale);
+		}
+		socket.once("connect", () => finish());
+		socket.once("error", (error) => {
+			if ("code" in error && error.code === "ECONNREFUSED") finish(void 0, true);
+			else finish(error);
+		});
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** Recover crash leftovers without unlinking a live or replaced endpoint. */
+async function prepareSignalSocketPath(socketPath, abortSignal) {
+	const uid = socketOwner(socketPath);
+	abortSignal?.throwIfAborted();
+	const parent = path.dirname(socketPath);
+	await validateDirectories(path.dirname(parent), uid, false, false);
+	let createdParent = false;
+	try {
+		await mkdir(parent, { mode: 448 });
+		createdParent = true;
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+	}
+	try {
+		await validateSignalSocketPath(socketPath);
+		let existing;
+		try {
+			existing = await lstat(socketPath);
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+			throw error;
+		}
+		if (existing.isSocket() && existing.uid === uid && await isStaleSocket(socketPath, abortSignal)) {
+			await validateSignalSocketPath(socketPath);
+			const current = await lstat(socketPath);
+			abortSignal?.throwIfAborted();
+			if (current.isSocket() && current.uid === uid && current.dev === existing.dev && current.ino === existing.ino) {
+				await unlink(socketPath);
+				return;
+			}
+			throw new Error("Signal socketPath changed during its ownership probe; retry startup");
+		}
+		throw new Error("Signal socketPath already exists; stop its owner or choose a different socket path before starting");
+	} catch (error) {
+		if (createdParent) try {
+			const stat = await lstat(parent);
+			if (stat.isDirectory() && !stat.isSymbolicLink() && stat.uid === uid) await rmdir(parent);
+		} catch {}
+		throw error;
+	}
+}
+//#endregion
+//#region extensions/signal/src/client-unix.ts
+const MAX_FRAME_BYTES = 1048576;
+const DEFAULT_TIMEOUT_MS$1 = 1e4;
+function socketPath(baseUrl) {
+	const url = new URL(baseUrl.trim());
+	if (url.protocol !== "unix:" || url.host || url.username || url.password || url.search || url.hash) throw new Error("Signal UNIX URL must contain only an absolute socket path");
+	return fileURLToPath(`file://${url.pathname}`);
+}
+function abortError() {
+	return Object.assign(/* @__PURE__ */ new Error("Signal UNIX stream aborted"), { name: "AbortError" });
+}
+async function openSocket(options, abortSignal) {
+	if (abortSignal?.aborted) throw abortError();
+	const path = socketPath(options.baseUrl);
+	await assertSignalSocketEndpoint(path);
+	if (abortSignal?.aborted) throw abortError();
+	const socket = net.createConnection({ path });
+	socket.on("error", () => {});
+	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs ?? DEFAULT_TIMEOUT_MS$1, DEFAULT_TIMEOUT_MS$1);
+	const deadline = setTimeout(() => {
+		socket.destroy(/* @__PURE__ */ new Error(`Signal UNIX RPC exceeded deadline after ${timeoutMs}ms`));
+	}, timeoutMs);
+	deadline.unref();
+	const onAbort = () => socket.destroy(abortError());
+	abortSignal?.addEventListener("abort", onAbort, { once: true });
+	return {
+		socket,
+		ready: () => clearTimeout(deadline),
+		close: () => {
+			clearTimeout(deadline);
+			abortSignal?.removeEventListener("abort", onAbort);
+			socket.destroy();
+		}
+	};
+}
+async function* messages(socket, maxBytes = MAX_FRAME_BYTES) {
+	let pending = Buffer$1.alloc(0);
+	for await (const chunk of socket) {
+		if (!Buffer$1.isBuffer(chunk)) throw new Error("Signal UNIX RPC expected a byte stream");
+		let offset = 0;
+		while (offset < chunk.length) {
+			const newline = chunk.indexOf(10, offset);
+			const end = newline < 0 ? chunk.length : newline;
+			const fragment = chunk.subarray(offset, end);
+			if (pending.length + fragment.length > maxBytes) throw new Error("Signal UNIX RPC frame exceeded size limit");
+			pending = Buffer$1.concat([pending, fragment]);
+			if (newline < 0) break;
+			const text = new TextDecoder("utf-8", { fatal: true }).decode(pending);
+			pending = Buffer$1.alloc(0);
+			offset = newline + 1;
+			let parsed;
+			try {
+				parsed = JSON.parse(text);
+			} catch {
+				throw new Error("Signal UNIX RPC returned malformed JSON");
+			}
+			if (!isRecord(parsed)) throw new Error("Signal UNIX RPC returned invalid response envelope");
+			yield parsed;
+		}
+	}
+	if (pending.length) throw new Error("Signal UNIX RPC closed with an incomplete frame");
+}
+const QUOTE_REJECTION_WORDS = [
+	"reject",
+	"invalid",
+	"unrecognized",
+	"unsupported",
+	"not found",
+	"no such",
+	"unknown"
+];
+function isQuoteMetadataRejection(code, rawMessage) {
+	if (code !== -32602) return false;
+	const normalized = rawMessage.toLowerCase();
+	return normalized.includes("quote") && QUOTE_REJECTION_WORDS.some((word) => normalized.includes(word));
+}
+function result(message) {
+	if (message.jsonrpc !== "2.0" || !Object.hasOwn(message, "result") && !message.error) throw new Error("Signal UNIX RPC returned invalid response envelope");
+	if (message.error) {
+		const error = isRecord(message.error) ? message.error : {};
+		const code = typeof error.code === "number" ? error.code : "unknown";
+		if (typeof error.message === "string" && isQuoteMetadataRejection(code, error.message)) throw new Error(`Signal RPC ${code}: quote metadata rejected (redacted)`);
+		throw new Error(`Signal RPC ${code}: remote error`);
+	}
+	return message.result;
+}
+async function signalUnixRpcRequest(method, params, options) {
+	const connection = await openSocket(options);
+	const id = randomUUID();
+	const maxBytes = typeof options.maxResponseBytes === "number" && Number.isFinite(options.maxResponseBytes) && options.maxResponseBytes >= 1 ? Math.floor(options.maxResponseBytes) : MAX_FRAME_BYTES;
+	try {
+		const frame = `${JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		})}\n`;
+		options.assertDirectAdapterHandoff?.();
+		connection.socket.write(frame);
+		for await (const message of messages(connection.socket, maxBytes)) if (message.id === id) return result(message);
+		throw new Error("Signal UNIX RPC closed before response");
+	} finally {
+		connection.close();
+	}
+}
+async function streamSignalUnixEvents(params) {
+	const connection = await openSocket({
+		...params,
+		timeoutMs: params.timeoutMs === 0 ? DEFAULT_TIMEOUT_MS$1 : params.timeoutMs
+	}, params.abortSignal);
+	const id = randomUUID();
+	let subscribed = false;
+	let subscription;
+	try {
+		connection.socket.write(`${JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method: "subscribeReceive",
+			params: params.account ? { account: params.account } : void 0
+		})}\n`);
+		for await (const message of messages(connection.socket)) {
+			if (params.abortSignal?.aborted) throw abortError();
+			if (message.id === id) {
+				const value = result(message);
+				if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new Error("Signal UNIX RPC returned invalid receive subscription");
+				subscription = value;
+				subscribed = true;
+				connection.ready();
+				params.onStreamOpen?.();
+				continue;
+			}
+			if (message.jsonrpc !== "2.0" || message.method !== "receive" || !isRecord(message.params)) continue;
+			const notification = message.params;
+			if (subscription !== void 0 && notification.subscription !== subscription) continue;
+			const payload = notification.result;
+			if (!isRecord(payload)) continue;
+			const account = payload.account;
+			if (params.account && typeof account === "string" && account !== params.account) continue;
+			await params.onEvent({
+				event: "receive",
+				data: JSON.stringify(payload)
+			});
+		}
+		if (!subscribed) throw new Error("Signal UNIX RPC closed before receive subscription");
+	} finally {
+		connection.close();
+	}
+}
+//#endregion
 //#region extensions/signal/src/client.ts
 /** Thrown when the native SSE endpoint rejects the request with a non-2xx HTTP status. */
 var SignalSseRejectionError = class extends Error {
@@ -699,6 +954,7 @@ function requestSignalHttp(url, options) {
 	assertSignalHttpProtocol(url, "HTTP");
 	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
 	const client = url.protocol === "https:" ? https : http;
+	options.assertDirectAdapterHandoff?.();
 	return new Promise((resolve, reject) => {
 		let settled = false;
 		const deadline = setTimeout(() => {
@@ -757,6 +1013,7 @@ function requestSignalHttp(url, options) {
 	});
 }
 async function signalRpcRequest(method, params, opts) {
+	if (opts.baseUrl.trim().startsWith("unix:")) return signalUnixRpcRequest(method, params, opts);
 	const id = generateSecureUuid();
 	const body = JSON.stringify({
 		jsonrpc: "2.0",
@@ -772,7 +1029,8 @@ async function signalRpcRequest(method, params, opts) {
 		},
 		body,
 		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-		maxResponseBytes: opts.maxResponseBytes
+		maxResponseBytes: opts.maxResponseBytes,
+		assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff
 	});
 	if (res.status === 201) return;
 	const text = new TextDecoder("utf-8", { fatal: true }).decode(res.body);
@@ -787,6 +1045,17 @@ async function signalRpcRequest(method, params, opts) {
 }
 async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
 	try {
+		if (baseUrl.trim().startsWith("unix:")) {
+			await signalUnixRpcRequest("version", void 0, {
+				baseUrl,
+				timeoutMs
+			});
+			return {
+				ok: true,
+				status: null,
+				error: null
+			};
+		}
 		const res = await requestSignalHttp(resolveSignalEndpointUrl(baseUrl, "/api/v1/check"), {
 			method: "GET",
 			timeoutMs
@@ -869,6 +1138,7 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS)
 	});
 }
 async function streamSignalEvents(params) {
+	if (params.baseUrl.trim().startsWith("unix:")) return streamSignalUnixEvents(params);
 	const url = resolveSignalEndpointUrl(params.baseUrl, "/api/v1/events");
 	if (params.account) url.searchParams.set("account", params.account);
 	const { response, cleanup } = await openSignalEventStream(url, params.abortSignal, params.timeoutMs ?? DEFAULT_TIMEOUT_MS);
@@ -939,4 +1209,4 @@ async function streamSignalEvents(params) {
 	await flushEvent();
 }
 //#endregion
-export { containerCheck as a, streamSignalEvents as i, signalCheck as n, containerRpcRequest as o, signalRpcRequest as r, streamContainerEvents as s, SignalSseRejectionError as t };
+export { prepareSignalSocketPath as a, streamContainerEvents as c, streamSignalEvents as i, signalCheck as n, containerCheck as o, signalRpcRequest as r, containerRpcRequest as s, SignalSseRejectionError as t };

package/dist/{client-adapter-CNc5wzzs.js → .setup/client-adapter-dvFa47YL.mjs}

@@ -1,4 +1,4 @@
-import { a as containerCheck, i as streamSignalEvents$1, n as signalCheck$1, o as containerRpcRequest, r as signalRpcRequest$1, s as streamContainerEvents } from "./client-B3C0ciqU.js";
+import { c as streamContainerEvents, i as streamSignalEvents$1, n as signalCheck$1, o as containerCheck, r as signalRpcRequest$1, s as containerRpcRequest } from "./client-BseAt7F7.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/client-adapter.ts
 /**

package/dist/{config-schema-DfEbpMVQ.js → .setup/config-schema-aQwwMGUj.mjs}

@@ -1,6 +1,7 @@
+import { o as resolveSignalAccountEntry, t as assertSignalSocketTransport } from "./transport-url-CAC0JcuI.mjs";
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId, resolveAccountEntry } from "openclaw/plugin-sdk/account-resolution";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { ChannelDeliveryStreamingConfigSchema, ChannelSendReadReceiptsSchema, ExecutableTokenSchema, ReplyToModeSchema, buildChannelAccountSchemaParts, buildChannelConfigSchema, buildChannelReactionShape, buildGroupEntrySchema, refineChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
 //#region extensions/signal/src/config-ui-hints.ts
@@ -40,6 +41,10 @@ const signalChannelConfigUiHints = {
 		label: "Signal CLI Config Path",
 		help: "Optional directory passed to signal-cli via --config when the service needs a non-default signal-cli data path."
 	},
+	"transport.socketPath": {
+		label: "Signal UNIX Socket Path",
+		help: "Opt-in managed-native transport on POSIX. Use an absolute socket path in a private directory owned by the Gateway user (mode 0700). Excludes url, httpHost, httpPort, and receiveMode on-start. HTTP remains the default; socket failures never fall back to HTTP."
+	},
 	"transport.url": {
 		label: "Signal Transport URL",
 		help: "Base URL for an external-native or container transport, or the connection endpoint for a managed-native daemon when it differs from the bind address."
@@ -76,6 +81,7 @@ const SignalTransportSchema = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("managed-native"),
 		configPath: z.string().optional(),
+		socketPath: z.string().regex(/^\/(?!\/)[^\0]*[^/\0]$/, "Expected an absolute POSIX socket file path").optional(),
 		url: SignalTransportUrlSchema.optional(),
 		httpHost: z.string().optional(),
 		httpPort: z.number().int().min(1).max(65535).optional(),
@@ -83,7 +89,17 @@ const SignalTransportSchema = z.discriminatedUnion("kind", [
 		startupTimeoutMs: z.number().int().min(1e3).max(12e4).optional(),
 		receiveMode: z.union([z.literal("on-start"), z.literal("manual")]).optional(),
 		ignoreStories: z.boolean().optional()
-	}).strict(),
+	}).strict().superRefine((transport, ctx) => {
+		try {
+			assertSignalSocketTransport(transport);
+		} catch (error) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["socketPath"],
+				message: String(error instanceof Error ? error.message : error)
+			});
+		}
+	}),
 	z.object({
 		kind: z.literal("external-native"),
 		url: SignalTransportUrlSchema
@@ -158,7 +174,7 @@ function validateSignalConfigAllowFrom(value, ctx) {
 	}
 }
 function validateSignalContainerAccounts(value, ctx) {
-	const defaultAccount = resolveAccountEntry(value.accounts, DEFAULT_ACCOUNT_ID);
+	const defaultAccount = resolveSignalAccountEntry(value.accounts, DEFAULT_ACCOUNT_ID);
 	const effectiveDefaultAccount = defaultAccount?.account === void 0 ? value.account : defaultAccount.account;
 	const channelEnabled = value.enabled !== false;
 	const defaultEnabled = defaultAccount?.enabled !== false;