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

package/dist/channel.runtime-B8GXmuol.js

@@ -0,0 +1,92 @@
+import { i as resolveSignalAccount, n as listSignalAccountIds } from "./accounts-DrStJjiK.js";
+import { c as signalNumberTextInput, i as createSignalCliPathTextInput, o as signalCompletionNote, s as signalDmPolicy } from "./channel-CBIljGCH.js";
+import { i as installSignalCli } from "./install-signal-cli-qJF7iC4h.js";
+import { detectBinary } from "openclaw/plugin-sdk/setup-tools";
+import { createDetectedBinaryStatus, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+//#region extensions/signal/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "signal";
+const configuredLabel = t("wizard.channels.statusConfigured");
+const unconfiguredLabel = t("wizard.channels.statusNeedsSetup");
+const managedStatus = createDetectedBinaryStatus({
+	channelLabel: "Signal",
+	binaryLabel: "signal-cli",
+	configuredLabel,
+	unconfiguredLabel,
+	configuredHint: t("wizard.channels.statusSignalCliFound"),
+	unconfiguredHint: t("wizard.channels.statusSignalCliMissing"),
+	configuredScore: 1,
+	unconfiguredScore: 0,
+	resolveConfigured: ({ cfg, accountId }) => accountId ? resolveSignalAccount({
+		cfg,
+		accountId
+	}).configured : listSignalAccountIds(cfg).some((resolvedAccountId) => resolveSignalAccount({
+		cfg,
+		accountId: resolvedAccountId
+	}).configured),
+	resolveBinaryPath: ({ cfg, accountId }) => {
+		const transport = resolveSignalAccount({
+			cfg,
+			accountId
+		}).transport;
+		return transport.kind === "managed-native" ? transport.cliPath : "signal-cli";
+	},
+	detectBinary
+});
+//#endregion
+//#region extensions/signal/src/channel.runtime.ts
+const signalSetupWizard = {
+	channel,
+	status: {
+		...managedStatus,
+		resolveStatusLines: async (params) => {
+			if (resolveSignalAccount(params).transport.kind === "managed-native") return await managedStatus.resolveStatusLines?.(params) ?? [];
+			return [`Signal: ${params.configured ? configuredLabel : unconfiguredLabel}`];
+		},
+		resolveSelectionHint: async (params) => {
+			if (resolveSignalAccount(params).transport.kind === "managed-native") return await managedStatus.resolveSelectionHint?.(params);
+			return params.configured ? configuredLabel : unconfiguredLabel;
+		},
+		resolveQuickstartScore: async (params) => {
+			if (resolveSignalAccount(params).transport.kind === "managed-native") return await managedStatus.resolveQuickstartScore?.(params);
+			return params.configured ? 1 : 0;
+		}
+	},
+	prepare: async ({ cfg, accountId, credentialValues, runtime, prompter, options }) => {
+		if (!options?.allowSignalInstall) return;
+		const transport = resolveSignalAccount({
+			cfg,
+			accountId
+		}).transport;
+		if (transport.kind !== "managed-native") return;
+		const cliDetected = await detectBinary((typeof credentialValues.cliPath === "string" ? credentialValues.cliPath : void 0) ?? (transport.kind === "managed-native" ? transport.cliPath : void 0) ?? "signal-cli");
+		if (!await prompter.confirm({
+			message: cliDetected ? t("wizard.signal.reinstallPrompt") : t("wizard.signal.installPrompt"),
+			initialValue: !cliDetected
+		})) return;
+		try {
+			await options?.beforePersistentEffect?.();
+			const result = await installSignalCli(runtime);
+			if (result.ok && result.cliPath) {
+				await prompter.note(`Installed signal-cli at ${result.cliPath}`, "Signal");
+				return { credentialValues: { cliPath: result.cliPath } };
+			}
+			if (!result.ok) await prompter.note(result.error ?? "signal-cli install failed.", "Signal");
+		} catch (error) {
+			await prompter.note(`signal-cli install failed: ${String(error)}`, "Signal");
+		}
+	},
+	credentials: [],
+	textInputs: [createSignalCliPathTextInput(async ({ cfg, accountId, currentValue }) => {
+		if (resolveSignalAccount({
+			cfg,
+			accountId
+		}).transport.kind !== "managed-native") return false;
+		return !await detectBinary(currentValue ?? "signal-cli");
+	}), signalNumberTextInput],
+	completionNote: signalCompletionNote,
+	dmPolicy: signalDmPolicy,
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { signalSetupWizard };

package/dist/{client-adapter-DZD8DCai.js → client-BazXTH7O.js}

@@ -1,6 +1,7 @@
 import { detectMime, parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
-import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { parseStrictNonNegativeInteger, 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 { readRegularFile } from "openclaw/plugin-sdk/security-runtime";
@@ -9,7 +10,6 @@ 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,7 +18,7 @@ import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 * This is a separate implementation from client.ts (native signal-cli)
 * to keep the two modes cleanly isolated.
 */
-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 = 16 * 1024;
 const SIGNAL_REST_SUCCESS_RESPONSE_MAX_BYTES = 16 * 1024 * 1024;
@@ -42,21 +42,43 @@ function normalizeBaseUrl$1(url) {
 	const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
 	return `${parsed.protocol}//${parsed.host}${pathname}`;
 }
-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);
+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;
 	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), safeTimeoutMs);
+	const timer = setTimeout(() => controller.abort(signalRestRequestTimeoutError()), safeTimeoutMs);
+	timer.unref?.();
 	try {
-		return await fetchImpl(url, {
-			...init,
-			signal: controller.signal
+		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));
+			}
 		});
 	} 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);
@@ -70,26 +92,32 @@ function signalRestIdleTimeoutError({ chunkTimeoutMs }) {
 function signalAttachmentIdleTimeoutError({ chunkTimeoutMs }) {
 	return /* @__PURE__ */ new Error(`Signal REST attachment response body stalled after ${chunkTimeoutMs}ms`);
 }
-async function readSignalRestText(res, bodyIdleTimeoutMs) {
+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) {
+async function readSignalRestErrorText(res, bodyIdleTimeoutMs, bodyTimeoutMs) {
 	return (await readResponseTextPrefix(res, SIGNAL_REST_ERROR_RESPONSE_MAX_BYTES, {
 		chunkTimeoutMs: bodyIdleTimeoutMs,
-		onIdleTimeout: signalRestIdleTimeoutError
+		onIdleTimeout: signalRestIdleTimeoutError,
+		timeoutMs: bodyTimeoutMs,
+		onTimeout: signalRestRequestTimeoutError
 	})).text;
 }
-async function readCappedResponseBuffer(res, maxResponseBytes, bodyIdleTimeoutMs) {
+async function readCappedResponseBuffer(res, maxResponseBytes, bodyIdleTimeoutMs, bodyTimeoutMs) {
 	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")
 	});
 }
@@ -99,7 +127,7 @@ async function releaseUnreadResponseBody(res) {
 /**
 * Check if bbernhard container REST API is available.
 */
-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 {
@@ -129,7 +157,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(() => {
@@ -200,37 +228,57 @@ 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 res = await fetchWithTimeout(url, init, timeoutMs);
-	if (res.status === 204) return;
-	if (!res.ok) {
-		const errorText = await readSignalRestErrorText(res, bodyIdleTimeoutMs).catch(() => "");
-		throw new Error(`Signal REST ${res.status}: ${errorText || res.statusText}`);
-	}
-	const text = await readSignalRestText(res, bodyIdleTimeoutMs);
-	if (!text) return;
-	try {
-		return JSON.parse(text);
-	} catch {
-		throw new Error("Signal REST returned malformed JSON");
-	}
+	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");
+		}
+	});
 }
 /**
 * Fetch attachment binary from bbernhard container.
 */
 async function containerFetchAttachment(attachmentId, opts) {
 	const url = `${normalizeBaseUrl$1(opts.baseUrl)}/v1/attachments/${encodeURIComponent(attachmentId)}`;
-	let res;
-	try {
-		const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2;
-		const bodyIdleTimeoutMs = resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$2);
-		res = await fetchWithTimeout(url, { method: "GET" }, timeoutMs);
-		if (!res.ok) return null;
-		return await readCappedResponseBuffer(res, normalizeMaxResponseBytes(opts.maxResponseBytes), bodyIdleTimeoutMs);
-	} finally {
-		await releaseUnreadResponseBody(res);
-	}
+	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);
+		}
+	});
 }
 /**
 * Stream messages using WebSocket from bbernhard container.
@@ -265,7 +313,7 @@ async function streamContainerEvents(params) {
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(toLintErrorObject$1(error, "Signal WebSocket receive handler failed"));
+			reject(toErrorObject(error, "Signal WebSocket receive handler failed"));
 		};
 		try {
 			ws = new WebSocket(wsUrl, {
@@ -274,7 +322,7 @@ async function streamContainerEvents(params) {
 			});
 		} catch (err) {
 			logError(`[signal-ws] failed to create WebSocket: ${err instanceof Error ? err.message : String(err)}`);
-			reject(toLintErrorObject$1(err, "Non-Error rejection"));
+			reject(toErrorObject(err, "Non-Error rejection"));
 			return;
 		}
 		ws.on("open", () => {
@@ -586,16 +634,9 @@ 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$1 = 1e4;
+const DEFAULT_TIMEOUT_MS = 1e4;
 const DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES = 1048576;
 const MAX_SIGNAL_SSE_BUFFER_BYTES = 1048576;
 const MAX_SIGNAL_SSE_EVENT_DATA_BYTES = 1048576;
@@ -616,7 +657,11 @@ function parseSignalBaseUrl(url) {
 	return parsed;
 }
 function resolveSignalEndpointUrl(baseUrl, pathname) {
-	return new URL(pathname, parseSignalBaseUrl(baseUrl));
+	const parsed = parseSignalBaseUrl(baseUrl);
+	parsed.pathname = `${parsed.pathname.endsWith("/") ? parsed.pathname : `${parsed.pathname}/`}${pathname.replace(/^\/+/, "")}`;
+	parsed.search = "";
+	parsed.hash = "";
+	return parsed;
 }
 function parseSignalRpcResponse(text, status) {
 	let parsed;
@@ -640,11 +685,11 @@ function normalizeSignalHttpResponseMaxBytes(value) {
 }
 function normalizeSignalSseTimeoutMs(timeoutMs) {
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
-	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS);
 }
 function requestSignalHttpText(url, options) {
 	assertSignalHttpProtocol(url, "HTTP");
-	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS$1);
+	const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
 	const client = url.protocol === "https:" ? https : http;
 	return new Promise((resolve, reject) => {
 		let settled = false;
@@ -660,7 +705,7 @@ function requestSignalHttpText(url, options) {
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(toLintErrorObject(error, "Non-Error rejection"));
+			reject(toErrorObject(error, "Non-Error rejection"));
 		};
 		const resolveOnce = (response) => {
 			if (settled) return;
@@ -704,7 +749,7 @@ function requestSignalHttpText(url, options) {
 		request.end();
 	});
 }
-async function signalRpcRequest$1(method, params, opts) {
+async function signalRpcRequest(method, params, opts) {
 	const id = generateSecureUuid();
 	const body = JSON.stringify({
 		jsonrpc: "2.0",
@@ -719,7 +764,7 @@ async function signalRpcRequest$1(method, params, opts) {
 			"Content-Length": String(Buffer$1.byteLength(body))
 		},
 		body,
-		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1,
+		timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
 		maxResponseBytes: opts.maxResponseBytes
 	});
 	if (res.status === 201) return;
@@ -732,7 +777,7 @@ async function signalRpcRequest$1(method, params, opts) {
 	}
 	return parsed.result;
 }
-async function signalCheck$1(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
 	try {
 		const res = await requestSignalHttpText(resolveSignalEndpointUrl(baseUrl, "/api/v1/check"), {
 			method: "GET",
@@ -756,7 +801,7 @@ async function signalCheck$1(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
 		};
 	}
 }
-function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS$1) {
+function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS) {
 	assertSignalHttpProtocol(url, "SSE");
 	if (abortSignal?.aborted) throw createSignalSseAbortError();
 	const client = url.protocol === "https:" ? https : http;
@@ -780,7 +825,7 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS$
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(toLintErrorObject(error, "Non-Error rejection"));
+			reject(toErrorObject(error, "Non-Error rejection"));
 		};
 		const request = client.request(url, {
 			method: "GET",
@@ -815,10 +860,10 @@ function openSignalEventStream(url, abortSignal, timeoutMs = DEFAULT_TIMEOUT_MS$
 		request.end();
 	});
 }
-async function streamSignalEvents$1(params) {
+async function streamSignalEvents(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$1);
+	const { response, cleanup } = await openSignalEventStream(url, params.abortSignal, params.timeoutMs ?? DEFAULT_TIMEOUT_MS);
 	const decoder = new TextDecoder();
 	let buffer = "";
 	let bufferedBytes = 0;
@@ -884,153 +929,5 @@ async function streamSignalEvents$1(params) {
 	}
 	await 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 { signalRpcRequest as n, streamSignalEvents as r, signalCheck as t };
+export { containerRpcRequest as a, containerCheck as i, signalRpcRequest as n, streamContainerEvents as o, streamSignalEvents as r, signalCheck as t };

package/dist/client-adapter-mXGeEHQJ.js

@@ -0,0 +1,56 @@
+import { a as containerRpcRequest, i as containerCheck, n as signalRpcRequest$1, o as streamContainerEvents, r as streamSignalEvents$1, t as signalCheck$1 } from "./client-BazXTH7O.js";
+//#region extensions/signal/src/client-adapter.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+function formatErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function usesContainer(kind) {
+	return kind === "container";
+}
+/**
+* Drop-in replacement for native signalRpcRequest.
+* Routes to native JSON-RPC or container REST based on config.
+*/
+async function signalRpcRequest(method, params, opts) {
+	return usesContainer(opts.transportKind) ? containerRpcRequest(method, params, opts) : signalRpcRequest$1(method, params, opts);
+}
+/**
+* Drop-in replacement for native signalCheck.
+*/
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
+	try {
+		return usesContainer(options.transportKind) ? await containerCheck(baseUrl, timeoutMs) : await signalCheck$1(baseUrl, timeoutMs);
+	} catch (error) {
+		return {
+			ok: false,
+			status: null,
+			error: formatErrorMessage(error)
+		};
+	}
+}
+/**
+* Drop-in replacement for native streamSignalEvents.
+* Container mode uses WebSocket; native uses SSE.
+*/
+async function streamSignalEvents(params) {
+	if (usesContainer(params.transportKind)) 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 { signalRpcRequest as n, streamSignalEvents as r, signalCheck as t };