@openclaw/signal 2026.11.3 → 2026.11.5-beta.2

package/dist/.setup/{client-Duwqbgqi.mjs → client-CesmEjRc.mjs}

@@ -1,29 +1,25 @@
-import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { isRecord, normalizeLowercaseStringOrEmpty } 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 { asNonNegativeFiniteNumber, asPositiveFiniteNumber, parseStrictNonNegativeInteger, resolvePositiveTimerTimeoutMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { asNonNegativeFiniteNumber, asPositiveFiniteNumber, floorPositiveFiniteNumber, parseStrictNonNegativeInteger, resolvePositiveTimerTimeoutMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { coerceErrorMessage, formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { captureEffectAuthority, 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 { WebSocket, startWebSocketKeepalive } from "openclaw/plugin-sdk/websocket-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
+import { randomUUID } from "node:crypto";
 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"));
-//#endregion
 //#region extensions/signal/src/client-container.ts
-const DEFAULT_TIMEOUT_MS$2 = 1e4;
+const DEFAULT_TIMEOUT_MS$1 = 1e4;
 const DEFAULT_ATTACHMENT_RESPONSE_MAX_BYTES = 1048576;
 const SIGNAL_REST_ERROR_RESPONSE_MAX_BYTES = 16384;
 const SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES = 16777216;
@@ -59,7 +55,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$2);
+	const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
 	const deadlineAtMs = Date.now() + safeTimeoutMs;
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(signalRestRequestTimeoutError()), safeTimeoutMs);
@@ -83,7 +79,7 @@ function signalRestIdleTimeoutError({ chunkTimeoutMs }) {
 function releaseUnreadResponseBody(res) {
 	if (res?.bodyUsed !== true) res?.body?.cancel().catch(() => void 0);
 }
-async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$2, account) {
+async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1, account) {
 	const normalized = normalizeBaseUrl$1(baseUrl);
 	let res;
 	try {
@@ -118,7 +114,7 @@ async function containerCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$2, 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$2);
+		const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
 		let settled = false;
 		let ws;
 		const timer = setTimeout(() => {
@@ -187,8 +183,8 @@ 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$2;
-	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
 	const fetchImpl = resolveFetch();
 	if (!fetchImpl) throw new Error("fetch is not available");
 	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
@@ -232,8 +228,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$2;
-	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
 	const fetchImpl = resolveFetch();
 	if (!fetchImpl) throw new Error("fetch is not available");
 	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
@@ -312,6 +308,11 @@ async function streamContainerEvents(params) {
 		}
 		ws.on("open", () => {
 			log("[signal-ws] connected");
+			startWebSocketKeepalive(ws, () => {
+				if (ws.isPaused) return;
+				logError("[signal-ws] heartbeat timed out; reconnecting");
+				ws.terminate();
+			});
 			params.onStreamOpen?.();
 		});
 		ws.on("message", (data) => {
@@ -329,8 +330,8 @@ async function streamContainerEvents(params) {
 						ws.close();
 					});
 				}
-			} catch (err) {
-				logError(`[signal-ws] parse error: ${coerceErrorMessage(err)}`);
+			} catch {
+				logError("[signal-ws] parse error: invalid JSON frame");
 			}
 		});
 		ws.on("error", (err) => {
@@ -344,9 +345,6 @@ async function streamContainerEvents(params) {
 		ws.on("ping", () => {
 			log("[signal-ws] ping received");
 		});
-		ws.on("pong", () => {
-			log("[signal-ws] pong received");
-		});
 		if (params.abortSignal) {
 			abortHandler = () => {
 				log("[signal-ws] aborted, closing connection");
@@ -660,142 +658,6 @@ async function prepareSignalSocketPath(socketPath, abortSignal) {
 	}
 }
 //#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");
-}
-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" && isSignalQuoteMetadataRejection(`Signal RPC ${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 effect = captureEffectAuthority();
-	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`;
-		await effect.initiate(() => {
-			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 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;
-				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 (subscription === void 0) 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 {
@@ -844,9 +706,6 @@ function parseSignalRpcResponse(text, status) {
 	if (!rpc.error && !hasResult) throw new Error(`Signal RPC returned invalid response envelope (status ${status})`);
 	return rpc;
 }
-function assertSignalHttpProtocol(url, label) {
-	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`Signal ${label} unsupported protocol: ${url.protocol}`);
-}
 function normalizeSignalSseTimeoutMs(timeoutMs) {
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
 	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS);
@@ -855,7 +714,6 @@ function requestSignalHttp(url, options) {
 	return captureEffectAuthority().initiate(() => initiateSignalHttp(url, options));
 }
 function initiateSignalHttp(url, options) {
-	assertSignalHttpProtocol(url, "HTTP");
 	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
 	const client = url.protocol === "https:" ? https : http;
 	options.assertDirectAdapterHandoff?.();
@@ -864,13 +722,9 @@ function initiateSignalHttp(url, options) {
 			request?.destroy(/* @__PURE__ */ new Error(`Signal HTTP exceeded deadline after ${timeoutMs}ms`));
 		}, timeoutMs);
 		deadline.unref?.();
-		const cleanup = () => {
-			clearTimeout(deadline);
-			request?.setTimeout(0);
-		};
 		const rejectResponse = (error) => {
-			cleanup();
-			reject(toErrorObject(error, "Non-Error rejection"));
+			clearTimeout(deadline);
+			reject(error);
 		};
 		const maxResponseBytes = Math.floor(asPositiveFiniteNumber(options.maxResponseBytes) ?? DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES);
 		const request = client.request(url, {
@@ -893,21 +747,110 @@ function initiateSignalHttp(url, options) {
 			});
 			res.on("error", rejectResponse);
 			res.on("end", () => {
-				cleanup();
+				clearTimeout(deadline);
 				resolve({
 					status: res.statusCode ?? 0,
 					body: Buffer$1.concat(chunks)
 				});
 			});
 		});
-		request.setTimeout(timeoutMs, () => {
-			request?.destroy(/* @__PURE__ */ new Error(`Signal HTTP timed out after ${timeoutMs}ms`));
-		});
 		request.on("error", rejectResponse);
 		if (options.body !== void 0) request.write(options.body);
 		request.end();
 	});
 }
+const MAX_FRAME_BYTES = 1048576;
+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, DEFAULT_TIMEOUT_MS);
+	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");
+}
+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" && isSignalQuoteMetadataRejection(`Signal RPC ${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 effect = captureEffectAuthority();
+	const connection = await openSocket(options);
+	const id = randomUUID();
+	const maxBytes = floorPositiveFiniteNumber(options.maxResponseBytes) || MAX_FRAME_BYTES;
+	try {
+		const frame = `${JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		})}\n`;
+		await effect.initiate(() => {
+			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 signalRpcRequest(method, params, opts) {
 	if (opts.baseUrl.trim().startsWith("unix:")) return signalUnixRpcRequest(method, params, opts);
 	const id = generateSecureUuid();
@@ -974,11 +917,56 @@ async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
 		};
 	}
 }
-function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS) {
-	assertSignalHttpProtocol(url, "SSE");
+async function streamSignalEvents(params) {
+	if (params.baseUrl.trim().startsWith("unix:")) {
+		const connection = await openSocket({
+			...params,
+			timeoutMs: params.timeoutMs === 0 ? DEFAULT_TIMEOUT_MS : params.timeoutMs
+		}, params.abortSignal);
+		const id = randomUUID();
+		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;
+					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 (subscription === void 0) throw new Error("Signal UNIX RPC closed before receive subscription");
+		} finally {
+			connection.close();
+		}
+		return;
+	}
+	const url = resolveSignalEndpointUrl(params.baseUrl, "/api/v1/events");
+	if (params.account) url.searchParams.set("account", params.account);
+	const abortSignal = params.abortSignal;
+	const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 	if (abortSignal?.aborted) throw createSignalSseAbortError();
 	const client = url.protocol === "https:" ? https : http;
-	return new Promise((resolve, reject) => {
+	const { response: streamResponse, cleanup: cleanupStream } = await new Promise((resolve, reject) => {
 		let settled = false;
 		let response;
 		let onAbort = () => {};
@@ -998,11 +986,14 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS)
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(toErrorObject(error, "Non-Error rejection"));
+			reject(error);
 		};
 		const request = client.request(url, {
 			method: "GET",
-			headers: { Accept: "text/event-stream" }
+			headers: {
+				Accept: "text/event-stream",
+				...params.lastEventId ? { "Last-Event-ID": params.lastEventId } : {}
+			}
 		}, (res) => {
 			const status = res.statusCode ?? 0;
 			if (status < 200 || status >= 300) {
@@ -1032,12 +1023,6 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS)
 		request.on("error", rejectOnce);
 		request.end();
 	});
-}
-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);
 	params.onStreamOpen?.();
 	const decoder = new TextDecoder();
 	let buffer = "";
@@ -1045,7 +1030,7 @@ async function streamSignalEvents(params) {
 	let currentEvent = {};
 	let currentEventDataBytes = 0;
 	const flushEvent = async () => {
-		if (!currentEvent.data && !currentEvent.event && !currentEvent.id) return;
+		if (!currentEvent.data && !currentEvent.event && currentEvent.id === void 0) return;
 		await params.onEvent({
 			event: currentEvent.event,
 			data: currentEvent.data,
@@ -1071,7 +1056,7 @@ async function streamSignalEvents(params) {
 			currentEventDataBytes += Buffer$1.byteLength(segment, "utf8");
 			if (currentEventDataBytes > MAX_SIGNAL_SSE_EVENT_DATA_BYTES) throw new Error("Signal SSE event data exceeded size limit");
 			currentEvent.data = currentEvent.data ? `${currentEvent.data}${segment}` : segment;
-		} else if (field === "id") currentEvent.id = value;
+		} else if (field === "id" && !value.includes("\0")) currentEvent.id = value;
 	};
 	const drainCompleteLines = async () => {
 		let lineEnd = buffer.indexOf("\n");
@@ -1085,7 +1070,7 @@ async function streamSignalEvents(params) {
 		bufferedBytes = Buffer$1.byteLength(buffer, "utf8");
 	};
 	try {
-		for await (const chunk of response) {
+		for await (const chunk of streamResponse) {
 			const value = typeof chunk === "string" ? Buffer$1.from(chunk) : chunk;
 			bufferedBytes += value.byteLength;
 			if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) throw new Error("Signal SSE buffer exceeded size limit");
@@ -1100,9 +1085,8 @@ async function streamSignalEvents(params) {
 		if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) throw new Error("Signal SSE buffer exceeded size limit");
 		await drainCompleteLines();
 	} finally {
-		cleanup();
+		cleanupStream();
 	}
-	await flushEvent();
 }
 //#endregion
 export { prepareSignalSocketPath as a, containerRpcRequest as c, streamSignalEvents as i, streamContainerEvents as l, signalCheck as n, isSignalQuoteMetadataRejection as o, signalRpcRequest as r, containerCheck as s, SignalSseRejectionError as t };

package/dist/.setup/{config-schema-DvxZ18SD.mjs → config-schema-BCmW0BLB.mjs}

@@ -1,11 +1,10 @@
-import { o as resolveSignalAccountEntry, t as assertSignalSocketTransport } from "./transport-url-CAC0JcuI.mjs";
-import { t as LEGACY_SIGNAL_TRANSPORT_FIELDS } from "./legacy-transport-QIpaMNST.mjs";
+import { c as resolveSignalAccountEntry, r as assertSignalSocketTransport, t as LEGACY_SIGNAL_TRANSPORT_FIELDS } from "./legacy-transport-D_cZC3bS.mjs";
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 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
+//#region extensions/signal/src/config-schema.ts
 const signalChannelConfigUiHints = {
 	"": {
 		label: "Signal",
@@ -51,8 +50,6 @@ const signalChannelConfigUiHints = {
 		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."
 	}
 };
-//#endregion
-//#region extensions/signal/src/config-schema.ts
 const SIGNAL_RETIRED_TRANSPORT_KEYS = ["apiMode", ...LEGACY_SIGNAL_TRANSPORT_FIELDS];
 const SignalTransportUrlSchema = z.string().url().regex(/^[Hh][Tt][Tt][Pp][Ss]?:\/\/(?![^/?#]*@)/, "Expected http:// or https:// URL without embedded credentials");
 function projectSignalConfigForUpdateValidation(value) {