@openclaw/signal 2026.7.2-beta.5 → 2026.7.33

package/dist/{client-BazXTH7O.js → .setup/client-adapter-BiGMiCr4.mjs}

@@ -1,15 +1,16 @@
 import { detectMime, parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
-import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import nodePath from "node:path";
-import { 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 { readProviderTextResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
+import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { readRegularFile } from "openclaw/plugin-sdk/security-runtime";
 import WebSocket from "ws";
 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 { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/client-container.ts
 /**
 * Signal client for bbernhard/signal-cli-rest-api container.
@@ -18,13 +19,10 @@ import { generateSecureUuid } from "openclaw/plugin-sdk/core";
 * 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 = 16 * 1024;
-const SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES = 16 * 1024 * 1024;
-const WS_MAX_PAYLOAD = 1024 * 1024;
-const WS_HANDSHAKE_MS = 3e4;
-const DEFAULT_SIGNAL_CONTAINER_MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+const SIGNAL_CONTAINER_WS_MAX_PAYLOAD_BYTES = 1048576;
+const DEFAULT_SIGNAL_CONTAINER_MAX_ATTACHMENT_BYTES = 8388608;
 const CONTAINER_TEXT_STYLE_MARKERS = {
 	BOLD: "**",
 	ITALIC: "*",
@@ -42,43 +40,21 @@ function normalizeBaseUrl$1(url) {
 	const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
 	return `${parsed.protocol}//${parsed.host}${pathname}`;
 }
-var SignalRestTimeoutError = class extends Error {
-	constructor() {
-		super("Signal REST request timed out");
-		this.name = "SignalRestTimeoutError";
-	}
-};
-function signalRestRequestTimeoutError() {
-	return new SignalRestTimeoutError();
-}
-/** 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 deadlineAtMs = Date.now() + safeTimeoutMs;
+async function fetchWithTimeout(url, init, timeoutMs) {
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	const safeTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
 	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(signalRestRequestTimeoutError()), safeTimeoutMs);
-	timer.unref?.();
+	const timer = setTimeout(() => controller.abort(), safeTimeoutMs);
 	try {
-		return await run({
-			signal: controller.signal,
-			timeoutMs: () => {
-				const remainingMs = deadlineAtMs - Date.now();
-				if (remainingMs <= 0) throw signalRestRequestTimeoutError();
-				return Math.max(1, Math.min(safeTimeoutMs, remainingMs));
-			}
+		return await fetchImpl(url, {
+			...init,
+			signal: controller.signal
 		});
 	} finally {
 		clearTimeout(timer);
 	}
 }
-async function fetchWithTimeout(url, init, timeoutMs) {
-	const fetchImpl = resolveFetch();
-	if (!fetchImpl) throw new Error("fetch is not available");
-	return await withSignalRestDeadline(timeoutMs, async ({ signal }) => fetchImpl(url, {
-		...init,
-		signal
-	}));
-}
 function normalizeMaxResponseBytes(value) {
 	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return DEFAULT_ATTACHMENT_RESPONSE_MAX_BYTES;
 	return Math.floor(value);
@@ -86,40 +62,10 @@ function normalizeMaxResponseBytes(value) {
 function readContentLength(res) {
 	return parseMediaContentLength(res.headers?.get("content-length") ?? null) ?? void 0;
 }
-function signalRestIdleTimeoutError({ chunkTimeoutMs }) {
-	return /* @__PURE__ */ new Error(`Signal REST response body stalled after ${chunkTimeoutMs}ms`);
-}
-function signalAttachmentIdleTimeoutError({ chunkTimeoutMs }) {
-	return /* @__PURE__ */ new Error(`Signal REST attachment response body stalled after ${chunkTimeoutMs}ms`);
-}
-async function readSignalRestText(res, bodyIdleTimeoutMs, bodyTimeoutMs) {
-	const bytes = await readResponseWithLimit(res, SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES, {
-		chunkTimeoutMs: bodyIdleTimeoutMs,
-		onIdleTimeout: signalRestIdleTimeoutError,
-		timeoutMs: bodyTimeoutMs,
-		onTimeout: signalRestRequestTimeoutError,
-		onOverflow: ({ maxBytes }) => /* @__PURE__ */ new Error(`Signal REST: text response exceeds ${maxBytes} bytes`)
-	});
-	return new TextDecoder().decode(bytes);
-}
-async function readSignalRestErrorText(res, bodyIdleTimeoutMs, bodyTimeoutMs) {
-	return (await readResponseTextPrefix(res, SIGNAL_REST_ERROR_RESPONSE_MAX_BYTES, {
-		chunkTimeoutMs: bodyIdleTimeoutMs,
-		onIdleTimeout: signalRestIdleTimeoutError,
-		timeoutMs: bodyTimeoutMs,
-		onTimeout: signalRestRequestTimeoutError
-	})).text;
-}
-async function readCappedResponseBuffer(res, maxResponseBytes, bodyIdleTimeoutMs, bodyTimeoutMs) {
+async function readCappedResponseBuffer(res, maxResponseBytes) {
 	const contentLength = readContentLength(res);
 	if (contentLength !== void 0 && contentLength > maxResponseBytes) throw new Error("Signal REST attachment exceeded size limit");
-	return await readResponseWithLimit(res, maxResponseBytes, {
-		chunkTimeoutMs: bodyIdleTimeoutMs,
-		onIdleTimeout: signalAttachmentIdleTimeoutError,
-		timeoutMs: bodyTimeoutMs,
-		onTimeout: signalRestRequestTimeoutError,
-		onOverflow: () => /* @__PURE__ */ new Error("Signal REST attachment exceeded size limit")
-	});
+	return await readResponseWithLimit(res, maxResponseBytes, { onOverflow: () => /* @__PURE__ */ new Error("Signal REST attachment exceeded size limit") });
 }
 async function releaseUnreadResponseBody(res) {
 	if (res?.bodyUsed !== true) await res?.body?.cancel().catch(() => void 0);
@@ -127,7 +73,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 {
@@ -157,7 +103,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(() => {
@@ -176,7 +122,7 @@ function containerReceiveCheck(normalizedBaseUrl, account, timeoutMs) {
 			resolve(result);
 		};
 		try {
-			ws = new WebSocket(wsUrl, { maxPayload: WS_MAX_PAYLOAD });
+			ws = new WebSocket(wsUrl, { maxPayload: SIGNAL_CONTAINER_WS_MAX_PAYLOAD_BYTES });
 		} catch (err) {
 			settle({
 				ok: false,
@@ -228,57 +174,33 @@ 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 fetchImpl = resolveFetch();
-	if (!fetchImpl) throw new Error("fetch is not available");
-	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
-		const res = await fetchImpl(url, {
-			...init,
-			signal
-		});
-		if (res.status === 204) return;
-		if (!res.ok) {
-			let errorText = "";
-			try {
-				errorText = await readSignalRestErrorText(res, bodyIdleTimeoutMs, bodyTimeoutMs);
-			} catch (error) {
-				if (error instanceof SignalRestTimeoutError) throw error;
-			}
-			throw new Error(`Signal REST ${res.status}: ${errorText || res.statusText}`);
-		}
-		const text = await readSignalRestText(res, bodyIdleTimeoutMs, bodyTimeoutMs);
-		if (!text) return;
-		try {
-			return JSON.parse(text);
-		} catch {
-			throw new Error("Signal REST returned malformed JSON");
-		}
-	});
+	const res = await fetchWithTimeout(url, init, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2);
+	if (res.status === 204) return;
+	if (!res.ok) {
+		const errorText = await readResponseTextLimited(res).catch(() => "");
+		throw new Error(`Signal REST ${res.status}: ${errorText || res.statusText}`);
+	}
+	const text = await readProviderTextResponse(res, "Signal REST");
+	if (!text) return;
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new Error("Signal REST returned malformed JSON");
+	}
 }
 /**
 * Fetch attachment binary from bbernhard container.
 */
 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 fetchImpl = resolveFetch();
-	if (!fetchImpl) throw new Error("fetch is not available");
-	return await withSignalRestDeadline(timeoutMs, async ({ signal, timeoutMs: bodyTimeoutMs }) => {
-		let res;
-		try {
-			const fetched = await fetchImpl(url, {
-				method: "GET",
-				signal
-			});
-			res = fetched;
-			if (!fetched.ok) return null;
-			return await readCappedResponseBuffer(fetched, normalizeMaxResponseBytes(opts.maxResponseBytes), bodyIdleTimeoutMs, bodyTimeoutMs);
-		} finally {
-			await releaseUnreadResponseBody(res);
-		}
-	});
+	let res;
+	try {
+		res = await fetchWithTimeout(url, { method: "GET" }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2);
+		if (!res.ok) return null;
+		return await readCappedResponseBuffer(res, normalizeMaxResponseBytes(opts.maxResponseBytes));
+	} finally {
+		await releaseUnreadResponseBody(res);
+	}
 }
 /**
 * Stream messages using WebSocket from bbernhard container.
@@ -294,55 +216,31 @@ async function streamContainerEvents(params) {
 	log(`[signal-ws] connecting to ${redactedWsUrl}`);
 	return new Promise((resolve, reject) => {
 		let ws;
-		let settled = false;
-		let eventChain = Promise.resolve();
+		let resolved = false;
 		let abortHandler;
 		const cleanup = () => {
+			if (resolved) return;
+			resolved = true;
 			if (abortHandler) {
 				params.abortSignal?.removeEventListener("abort", abortHandler);
 				abortHandler = void 0;
 			}
 		};
-		const resolveOnce = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve();
-		};
-		const rejectOnce = (error) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(toErrorObject(error, "Signal WebSocket receive handler failed"));
-		};
 		try {
-			ws = new WebSocket(wsUrl, {
-				maxPayload: WS_MAX_PAYLOAD,
-				handshakeTimeout: WS_HANDSHAKE_MS
-			});
+			ws = new WebSocket(wsUrl, { maxPayload: SIGNAL_CONTAINER_WS_MAX_PAYLOAD_BYTES });
 		} catch (err) {
 			logError(`[signal-ws] failed to create WebSocket: ${err instanceof Error ? err.message : String(err)}`);
-			reject(toErrorObject(err, "Non-Error rejection"));
+			reject(toLintErrorObject$1(err, "Non-Error rejection"));
 			return;
 		}
 		ws.on("open", () => {
 			log("[signal-ws] connected");
 		});
 		ws.on("message", (data) => {
-			if (settled) return;
 			try {
 				const text = data.toString();
 				const envelope = JSON.parse(text);
-				if (envelope) {
-					eventChain = eventChain.then(async () => {
-						await params.onEvent(envelope);
-					});
-					eventChain.catch((err) => {
-						logError(`[signal-ws] receive handler failed: ${err instanceof Error ? err.message : String(err)}`);
-						rejectOnce(err);
-						ws.close();
-					});
-				}
+				if (envelope) params.onEvent(envelope);
 			} catch (err) {
 				logError(`[signal-ws] parse error: ${err instanceof Error ? err.message : String(err)}`);
 			}
@@ -353,7 +251,8 @@ async function streamContainerEvents(params) {
 		ws.on("close", (code, reason) => {
 			const reasonStr = reason?.toString() || "no reason";
 			log(`[signal-ws] closed (code=${code}, reason=${reasonStr})`);
-			eventChain.then(resolveOnce, rejectOnce);
+			cleanup();
+			resolve();
 		});
 		ws.on("ping", () => {
 			log("[signal-ws] ping received");
@@ -364,8 +263,9 @@ async function streamContainerEvents(params) {
 		if (params.abortSignal) {
 			abortHandler = () => {
 				log("[signal-ws] aborted, closing connection");
+				cleanup();
 				ws.close();
-				resolveOnce();
+				resolve();
 			};
 			params.abortSignal.addEventListener("abort", abortHandler, { once: true });
 		}
@@ -417,10 +317,11 @@ function renderContainerStyledText(text, styles) {
 		...spans.flatMap((span) => [span.start, span.end])
 	])].toSorted((a, b) => a - b);
 	let rendered = "";
-	for (const [index, pos] of positions.entries()) {
+	for (let i = 0; i < positions.length; i += 1) {
+		const pos = positions[i];
 		for (const span of spans.filter((candidate) => candidate.end === pos).toSorted((a, b) => b.start - a.start)) rendered += span.marker;
 		for (const span of spans.filter((candidate) => candidate.start === pos).toSorted((a, b) => b.end - a.end)) rendered += span.marker;
-		const next = positions[index + 1];
+		const next = positions[i + 1];
 		if (next !== void 0 && next > pos) rendered += escapeContainerStyledText(text.slice(pos, next));
 	}
 	return rendered;
@@ -552,14 +453,13 @@ async function containerRpcRequest(method, params, opts) {
 			const groupId = p.groupId;
 			const formattedGroupId = groupId ? formatGroupIdForContainer(groupId) : void 0;
 			const finalRecipients = recipients.length > 0 ? recipients : usernames.length > 0 ? usernames : formattedGroupId ? [formattedGroupId] : [];
-			const textStyles = p["text-style"]?.flatMap((s) => {
+			const textStyles = p["text-style"]?.map((s) => {
 				const [start, length, style] = s.split(":");
-				if (start === void 0 || length === void 0 || style === void 0) return [];
-				return [{
+				return {
 					start: Number(start),
 					length: Number(length),
 					style
-				}];
+				};
 			});
 			const quoteTimestamp = normalizeContainerQuoteTimestamp(p.quoteTimestamp ?? p["quote-timestamp"]);
 			const quoteAuthor = normalizeContainerQuoteText(p.quoteAuthor ?? p["quote-author"]);
@@ -634,9 +534,16 @@ async function containerRpcRequest(method, params, opts) {
 		default: throw new Error(`Unsupported container RPC method: ${method}`);
 	}
 }
+function toLintErrorObject$1(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
 //#endregion
 //#region extensions/signal/src/client.ts
-const DEFAULT_TIMEOUT_MS = 1e4;
+const DEFAULT_TIMEOUT_MS$1 = 1e4;
 const DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES = 1048576;
 const MAX_SIGNAL_SSE_BUFFER_BYTES = 1048576;
 const MAX_SIGNAL_SSE_EVENT_DATA_BYTES = 1048576;
@@ -657,11 +564,7 @@ function parseSignalBaseUrl(url) {
 	return parsed;
 }
 function resolveSignalEndpointUrl(baseUrl, pathname) {
-	const parsed = parseSignalBaseUrl(baseUrl);
-	parsed.pathname = `${parsed.pathname.endsWith("/") ? parsed.pathname : `${parsed.pathname}/`}${pathname.replace(/^\/+/, "")}`;
-	parsed.search = "";
-	parsed.hash = "";
-	return parsed;
+	return new URL(pathname, parseSignalBaseUrl(baseUrl));
 }
 function parseSignalRpcResponse(text, status) {
 	let parsed;
@@ -685,11 +588,11 @@ function normalizeSignalHttpResponseMaxBytes(value) {
 }
 function normalizeSignalSseTimeoutMs(timeoutMs) {
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
-	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS);
+	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
 }
 function requestSignalHttpText(url, options) {
 	assertSignalHttpProtocol(url, "HTTP");
-	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS$1);
 	const client = url.protocol === "https:" ? https : http;
 	return new Promise((resolve, reject) => {
 		let settled = false;
@@ -705,7 +608,7 @@ function requestSignalHttpText(url, options) {
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(toErrorObject(error, "Non-Error rejection"));
+			reject(toLintErrorObject(error, "Non-Error rejection"));
 		};
 		const resolveOnce = (response) => {
 			if (settled) return;
@@ -749,7 +652,7 @@ function requestSignalHttpText(url, options) {
 		request.end();
 	});
 }
-async function signalRpcRequest(method, params, opts) {
+async function signalRpcRequest$1(method, params, opts) {
 	const id = generateSecureUuid();
 	const body = JSON.stringify({
 		jsonrpc: "2.0",
@@ -764,7 +667,7 @@ async function signalRpcRequest(method, params, opts) {
 			"Content-Length": String(Buffer$1.byteLength(body))
 		},
 		body,
-		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1,
 		maxResponseBytes: opts.maxResponseBytes
 	});
 	if (res.status === 201) return;
@@ -777,7 +680,7 @@ async function signalRpcRequest(method, params, opts) {
 	}
 	return parsed.result;
 }
-async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+async function signalCheck$1(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
 	try {
 		const res = await requestSignalHttpText(resolveSignalEndpointUrl(baseUrl, "/api/v1/check"), {
 			method: "GET",
@@ -801,7 +704,7 @@ async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
 		};
 	}
 }
-function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS) {
+function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
 	assertSignalHttpProtocol(url, "SSE");
 	if (abortSignal?.aborted) throw createSignalSseAbortError();
 	const client = url.protocol === "https:" ? https : http;
@@ -825,7 +728,7 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS)
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(toErrorObject(error, "Non-Error rejection"));
+			reject(toLintErrorObject(error, "Non-Error rejection"));
 		};
 		const request = client.request(url, {
 			method: "GET",
@@ -860,18 +763,18 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS)
 		request.end();
 	});
 }
-async function streamSignalEvents(params) {
+async function streamSignalEvents$1(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);
+	const { response, cleanup } = await openSignalEventStream(url, params.abortSignal, params.timeoutMs ?? DEFAULT_TIMEOUT_MS$1);
 	const decoder = new TextDecoder();
 	let buffer = "";
 	let bufferedBytes = 0;
 	let currentEvent = {};
 	let currentEventDataBytes = 0;
-	const flushEvent = async () => {
+	const flushEvent = () => {
 		if (!currentEvent.data && !currentEvent.event && !currentEvent.id) return;
-		await params.onEvent({
+		params.onEvent({
 			event: currentEvent.event,
 			data: currentEvent.data,
 			id: currentEvent.id
@@ -879,14 +782,13 @@ async function streamSignalEvents(params) {
 		currentEvent = {};
 		currentEventDataBytes = 0;
 	};
-	const processLine = async (line) => {
+	const processLine = (line) => {
 		if (line === "") {
-			await flushEvent();
+			flushEvent();
 			return;
 		}
 		if (line.startsWith(":")) return;
 		const [rawField, ...rest] = line.split(":");
-		if (rawField === void 0) return;
 		const field = rawField.trim();
 		const rawValue = rest.join(":");
 		const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
@@ -898,13 +800,13 @@ async function streamSignalEvents(params) {
 			currentEvent.data = currentEvent.data ? `${currentEvent.data}${segment}` : segment;
 		} else if (field === "id") currentEvent.id = value;
 	};
-	const drainCompleteLines = async () => {
+	const drainCompleteLines = () => {
 		let lineEnd = buffer.indexOf("\n");
 		while (lineEnd !== -1) {
 			let line = buffer.slice(0, lineEnd);
 			buffer = buffer.slice(lineEnd + 1);
 			if (line.endsWith("\r")) line = line.slice(0, -1);
-			await processLine(line);
+			processLine(line);
 			lineEnd = buffer.indexOf("\n");
 		}
 		bufferedBytes = Buffer$1.byteLength(buffer, "utf8");
@@ -915,7 +817,7 @@ async function streamSignalEvents(params) {
 			bufferedBytes += value.byteLength;
 			if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) throw new Error("Signal SSE buffer exceeded size limit");
 			buffer += decoder.decode(value, { stream: true });
-			await drainCompleteLines();
+			drainCompleteLines();
 		}
 		const tail = decoder.decode();
 		if (tail) {
@@ -923,11 +825,161 @@ async function streamSignalEvents(params) {
 			bufferedBytes = Buffer$1.byteLength(buffer, "utf8");
 		}
 		if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) throw new Error("Signal SSE buffer exceeded size limit");
-		await drainCompleteLines();
+		drainCompleteLines();
 	} finally {
 		cleanup();
 	}
-	await flushEvent();
+	flushEvent();
+}
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
+//#endregion
+//#region extensions/signal/src/client-adapter.ts
+/**
+* Signal client adapter - unified interface for both native signal-cli and bbernhard container.
+*
+* This adapter provides a single API that routes to the appropriate implementation
+* based on the configured API mode. Exports mirror client.ts names so consumers
+* only need to change their import path.
+*/
+const DEFAULT_TIMEOUT_MS = 1e4;
+const MODE_CACHE_TTL_MS = 3e4;
+const NATIVE_PREFERENCE_GRACE_MS = 50;
+const detectedModeCache = /* @__PURE__ */ new Map();
+function resolveConfiguredApiMode(configured) {
+	if (configured === "native" || configured === "container") return configured;
+	return "auto";
+}
+function formatErrorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function resolveAutoProbeTimeoutMs(timeoutMs) {
+	return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
+}
+function waitForNativePreferenceGrace(nativeResultPromise) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve({ ok: false }), NATIVE_PREFERENCE_GRACE_MS);
+		timer.unref?.();
+		nativeResultPromise.then((result) => {
+			clearTimeout(timer);
+			resolve(result);
+		});
+	});
+}
+async function resolveAutoApiMode(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
+	const rawNow = Date.now();
+	const now = asDateTimestampMs(rawNow);
+	const cached = detectedModeCache.get(baseUrl);
+	if (cached) {
+		if (now !== void 0 && cached.expiresAt > now) {
+			if (cached.mode !== "container" || !options.requireContainerReceive || Boolean(options.account?.trim()) && cached.receiveAccount === options.account?.trim()) return cached.mode;
+		} else detectedModeCache.delete(baseUrl);
+	}
+	const detected = await detectSignalApiMode(baseUrl, timeoutMs, options);
+	const expiresAt = resolveExpiresAtMsFromDurationMs(MODE_CACHE_TTL_MS, { nowMs: rawNow });
+	if (expiresAt !== void 0) detectedModeCache.set(baseUrl, {
+		mode: detected,
+		expiresAt,
+		...detected === "container" && options.requireContainerReceive && options.account ? { receiveAccount: options.account } : {}
+	});
+	return detected;
+}
+async function resolveApiModeForOperation(params) {
+	const configured = resolveConfiguredApiMode(params.apiMode);
+	if (configured === "native" || configured === "container") return configured;
+	return resolveAutoApiMode(params.baseUrl, params.timeoutMs ?? DEFAULT_TIMEOUT_MS, {
+		account: params.account,
+		requireContainerReceive: params.requireContainerReceive
+	});
+}
+/**
+* Detect which Signal API mode is available by probing endpoints.
+* Native wins when both APIs are healthy because it preserves the richer JSON-RPC contract.
+*/
+async function detectSignalApiMode(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
+	const containerAccount = options.requireContainerReceive ? options.account?.trim() : void 0;
+	const nativeResultPromise = signalCheck$1(baseUrl, timeoutMs).catch(() => ({ ok: false }));
+	const containerResultPromise = containerAccount ? containerCheck(baseUrl, timeoutMs, containerAccount).catch(() => ({ ok: false })) : options.requireContainerReceive ? Promise.resolve({ ok: false }) : containerCheck(baseUrl, timeoutMs).catch(() => ({ ok: false }));
+	const nativeHealthyPromise = nativeResultPromise.then((result) => {
+		if (result.ok) return "native";
+		throw new Error("native not ok");
+	});
+	const containerHealthyPromise = containerResultPromise.then((result) => {
+		if (result.ok) return "container";
+		throw new Error("container not ok");
+	});
+	try {
+		if (await Promise.any([nativeHealthyPromise, containerHealthyPromise]) === "native") return "native";
+		return (await waitForNativePreferenceGrace(nativeResultPromise)).ok ? "native" : "container";
+	} catch {
+		throw new Error(`Signal API not reachable at ${baseUrl}`);
+	}
+}
+/**
+* Drop-in replacement for native signalRpcRequest.
+* Routes to native JSON-RPC or container REST based on config.
+*/
+async function signalRpcRequest(method, params, opts) {
+	if (await resolveApiModeForOperation({
+		baseUrl: opts.baseUrl,
+		accountId: opts.accountId,
+		account: typeof params?.account === "string" ? params.account : void 0,
+		timeoutMs: opts.timeoutMs,
+		apiMode: opts.apiMode
+	}) === "native") return signalRpcRequest$1(method, params, opts);
+	return containerRpcRequest(method, params, opts);
+}
+/**
+* Drop-in replacement for native signalCheck.
+*/
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
+	const configured = resolveConfiguredApiMode(options.apiMode);
+	const mode = configured === "auto" ? await resolveAutoApiMode(baseUrl, timeoutMs).catch((error) => {
+		return {
+			ok: false,
+			status: null,
+			error: formatErrorMessage$1(error)
+		};
+	}) : configured;
+	if (typeof mode !== "string") return mode;
+	if (mode === "container") return containerCheck(baseUrl, timeoutMs);
+	return signalCheck$1(baseUrl, timeoutMs);
+}
+/**
+* Drop-in replacement for native streamSignalEvents.
+* Container mode uses WebSocket; native uses SSE.
+*/
+async function streamSignalEvents(params) {
+	if (await resolveApiModeForOperation({
+		baseUrl: params.baseUrl,
+		accountId: params.accountId,
+		account: params.account,
+		requireContainerReceive: true,
+		timeoutMs: resolveAutoProbeTimeoutMs(params.timeoutMs),
+		apiMode: params.apiMode
+	}) === "container") return streamContainerEvents({
+		baseUrl: params.baseUrl,
+		account: params.account,
+		abortSignal: params.abortSignal,
+		timeoutMs: params.timeoutMs,
+		onEvent: (event) => params.onEvent({
+			event: "receive",
+			data: JSON.stringify(event)
+		}),
+		logger: params.logger
+	});
+	return streamSignalEvents$1({
+		baseUrl: params.baseUrl,
+		account: params.account,
+		abortSignal: params.abortSignal,
+		timeoutMs: params.timeoutMs,
+		onEvent: (event) => params.onEvent(event)
+	});
 }
 //#endregion
-export { containerRpcRequest as a, containerCheck as i, signalRpcRequest as n, streamContainerEvents as o, streamSignalEvents as r, signalCheck as t };
+export { signalRpcRequest as n, streamSignalEvents as r, signalCheck as t };

package/dist/.setup/config-api-KS-qhQvD.mjs

@@ -0,0 +1,2 @@
+import { SignalConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
+export { buildChannelConfigSchema as n, SignalConfigSchema as t };