clawdbot 2026.1.4-1

package/dist/provider-web.js

@@ -0,0 +1,8 @@
+// Barrel exports for the web provider pieces. Splitting the original 900+ line
+// module keeps responsibilities small and testable without changing the public API.
+export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, monitorWebProvider, resolveHeartbeatRecipients, runWebHeartbeatOnce, } from "./web/auto-reply.js";
+export { extractMediaPlaceholder, extractText, monitorWebInbox, } from "./web/inbound.js";
+export { loginWeb } from "./web/login.js";
+export { loadWebMedia, optimizeImageToJpeg } from "./web/media.js";
+export { sendMessageWhatsApp } from "./web/outbound.js";
+export { createWaSocket, formatError, getStatusCode, logoutWeb, logWebSelfId, pickProvider, WA_WEB_AUTH_DIR, waitForWaConnection, webAuthExists, } from "./web/session.js";

package/dist/providers/web/index.js

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+export { createWaSocket, loginWeb, logWebSelfId, monitorWebInbox, monitorWebProvider, pickProvider, sendMessageWhatsApp, WA_WEB_AUTH_DIR, waitForWaConnection, webAuthExists, } from "../../provider-web.js";

package/dist/runtime.js

@@ -0,0 +1,8 @@
+export const defaultRuntime = {
+    log: console.log,
+    error: console.error,
+    exit: (code) => {
+        process.exit(code);
+        throw new Error("unreachable"); // satisfies tests when mocked
+    },
+};

package/dist/sessions/send-policy.js

@@ -0,0 +1,68 @@
+export function normalizeSendPolicy(raw) {
+    const value = raw?.trim().toLowerCase();
+    if (value === "allow")
+        return "allow";
+    if (value === "deny")
+        return "deny";
+    return undefined;
+}
+function normalizeMatchValue(raw) {
+    const value = raw?.trim().toLowerCase();
+    return value ? value : undefined;
+}
+function deriveSurfaceFromKey(key) {
+    if (!key)
+        return undefined;
+    const parts = key.split(":").filter(Boolean);
+    if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) {
+        return normalizeMatchValue(parts[0]);
+    }
+    return undefined;
+}
+function deriveChatTypeFromKey(key) {
+    if (!key)
+        return undefined;
+    if (key.startsWith("group:") || key.includes(":group:"))
+        return "group";
+    if (key.includes(":channel:"))
+        return "room";
+    return undefined;
+}
+export function resolveSendPolicy(params) {
+    const override = normalizeSendPolicy(params.entry?.sendPolicy);
+    if (override)
+        return override;
+    const policy = params.cfg.session?.sendPolicy;
+    if (!policy)
+        return "allow";
+    const surface = normalizeMatchValue(params.surface) ??
+        normalizeMatchValue(params.entry?.surface) ??
+        normalizeMatchValue(params.entry?.lastChannel) ??
+        deriveSurfaceFromKey(params.sessionKey);
+    const chatType = normalizeMatchValue(params.chatType ?? params.entry?.chatType) ??
+        normalizeMatchValue(deriveChatTypeFromKey(params.sessionKey));
+    const sessionKey = params.sessionKey ?? "";
+    let allowedMatch = false;
+    for (const rule of policy.rules ?? []) {
+        if (!rule)
+            continue;
+        const action = normalizeSendPolicy(rule.action) ?? "allow";
+        const match = rule.match ?? {};
+        const matchSurface = normalizeMatchValue(match.surface);
+        const matchChatType = normalizeMatchValue(match.chatType);
+        const matchPrefix = normalizeMatchValue(match.keyPrefix);
+        if (matchSurface && matchSurface !== surface)
+            continue;
+        if (matchChatType && matchChatType !== chatType)
+            continue;
+        if (matchPrefix && !sessionKey.startsWith(matchPrefix))
+            continue;
+        if (action === "deny")
+            return "deny";
+        allowedMatch = true;
+    }
+    if (allowedMatch)
+        return "allow";
+    const fallback = normalizeSendPolicy(policy.default);
+    return fallback ?? "allow";
+}

package/dist/signal/client.js

@@ -0,0 +1,134 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_TIMEOUT_MS = 10_000;
+function normalizeBaseUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        throw new Error("Signal base URL is required");
+    }
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed.replace(/\/+$/, "");
+    return `http://${trimmed}`.replace(/\/+$/, "");
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function signalRpcRequest(method, params, opts) {
+    const baseUrl = normalizeBaseUrl(opts.baseUrl);
+    const id = randomUUID();
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        method,
+        params,
+        id,
+    });
+    const res = await fetchWithTimeout(`${baseUrl}/api/v1/rpc`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    if (res.status === 201) {
+        return undefined;
+    }
+    const text = await res.text();
+    if (!text) {
+        throw new Error(`Signal RPC empty response (status ${res.status})`);
+    }
+    const parsed = JSON.parse(text);
+    if (parsed.error) {
+        const code = parsed.error.code ?? "unknown";
+        const msg = parsed.error.message ?? "Signal RPC error";
+        throw new Error(`Signal RPC ${code}: ${msg}`);
+    }
+    return parsed.result;
+}
+export async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    try {
+        const res = await fetchWithTimeout(`${normalized}/api/v1/check`, { method: "GET" }, timeoutMs);
+        if (!res.ok) {
+            return { ok: false, status: res.status, error: `HTTP ${res.status}` };
+        }
+        return { ok: true, status: res.status, error: null };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: null,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function streamSignalEvents(params) {
+    const baseUrl = normalizeBaseUrl(params.baseUrl);
+    const url = new URL(`${baseUrl}/api/v1/events`);
+    if (params.account)
+        url.searchParams.set("account", params.account);
+    const res = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "text/event-stream" },
+        signal: params.abortSignal,
+    });
+    if (!res.ok || !res.body) {
+        throw new Error(`Signal SSE failed (${res.status} ${res.statusText || "error"})`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = {};
+    const flushEvent = () => {
+        if (!currentEvent.data && !currentEvent.event && !currentEvent.id)
+            return;
+        params.onEvent({
+            event: currentEvent.event,
+            data: currentEvent.data,
+            id: currentEvent.id,
+        });
+        currentEvent = {};
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        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);
+            if (line === "") {
+                flushEvent();
+                lineEnd = buffer.indexOf("\n");
+                continue;
+            }
+            if (line.startsWith(":")) {
+                lineEnd = buffer.indexOf("\n");
+                continue;
+            }
+            const [rawField, ...rest] = line.split(":");
+            const field = rawField.trim();
+            const rawValue = rest.join(":");
+            const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+            if (field === "event") {
+                currentEvent.event = value;
+            }
+            else if (field === "data") {
+                currentEvent.data = currentEvent.data
+                    ? `${currentEvent.data}\n${value}`
+                    : value;
+            }
+            else if (field === "id") {
+                currentEvent.id = value;
+            }
+            lineEnd = buffer.indexOf("\n");
+        }
+    }
+    flushEvent();
+}

package/dist/signal/daemon.js

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+export function classifySignalCliLogLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    // signal-cli commonly writes all logs to stderr; treat severity explicitly.
+    if (/\b(ERROR|WARN|WARNING)\b/.test(trimmed))
+        return "error";
+    // Some signal-cli failures are not tagged with WARN/ERROR but should still be surfaced loudly.
+    if (/\b(FAILED|SEVERE|EXCEPTION)\b/i.test(trimmed))
+        return "error";
+    return "log";
+}
+function buildDaemonArgs(opts) {
+    const args = [];
+    if (opts.account) {
+        args.push("-a", opts.account);
+    }
+    args.push("daemon");
+    args.push("--http", `${opts.httpHost}:${opts.httpPort}`);
+    args.push("--no-receive-stdout");
+    if (opts.receiveMode) {
+        args.push("--receive-mode", opts.receiveMode);
+    }
+    if (opts.ignoreAttachments)
+        args.push("--ignore-attachments");
+    if (opts.ignoreStories)
+        args.push("--ignore-stories");
+    if (opts.sendReadReceipts)
+        args.push("--send-read-receipts");
+    return args;
+}
+export function spawnSignalDaemon(opts) {
+    const args = buildDaemonArgs(opts);
+    const child = spawn(opts.cliPath, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const log = opts.runtime?.log ?? (() => { });
+    const error = opts.runtime?.error ?? (() => { });
+    child.stdout?.on("data", (data) => {
+        for (const line of data.toString().split(/\r?\n/)) {
+            const kind = classifySignalCliLogLine(line);
+            if (kind === "log")
+                log(`signal-cli: ${line.trim()}`);
+            else if (kind === "error")
+                error(`signal-cli: ${line.trim()}`);
+        }
+    });
+    child.stderr?.on("data", (data) => {
+        for (const line of data.toString().split(/\r?\n/)) {
+            const kind = classifySignalCliLogLine(line);
+            if (kind === "log")
+                log(`signal-cli: ${line.trim()}`);
+            else if (kind === "error")
+                error(`signal-cli: ${line.trim()}`);
+        }
+    });
+    child.on("error", (err) => {
+        error(`signal-cli spawn error: ${String(err)}`);
+    });
+    return {
+        pid: child.pid ?? undefined,
+        stop: () => {
+            if (!child.killed) {
+                child.kill("SIGTERM");
+            }
+        },
+    };
+}

package/dist/signal/index.js

@@ -0,0 +1,3 @@
+export { monitorSignalProvider } from "./monitor.js";
+export { probeSignal } from "./probe.js";
+export { sendMessageSignal } from "./send.js";

package/dist/signal/monitor.js

@@ -0,0 +1,336 @@
+import { chunkText, resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { formatAgentEnvelope } from "../auto-reply/envelope.js";
+import { getReplyFromConfig } from "../auto-reply/reply.js";
+import { loadConfig } from "../config/config.js";
+import { resolveStorePath, updateLastRoute } from "../config/sessions.js";
+import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { saveMediaBuffer } from "../media/store.js";
+import { normalizeE164 } from "../utils.js";
+import { signalCheck, signalRpcRequest, streamSignalEvents } from "./client.js";
+import { spawnSignalDaemon } from "./daemon.js";
+import { sendMessageSignal } from "./send.js";
+function resolveRuntime(opts) {
+    return (opts.runtime ?? {
+        log: console.log,
+        error: console.error,
+        exit: (code) => {
+            throw new Error(`exit ${code}`);
+        },
+    });
+}
+function resolveBaseUrl(opts) {
+    const cfg = loadConfig();
+    const signalCfg = cfg.signal;
+    if (opts.baseUrl?.trim())
+        return opts.baseUrl.trim();
+    if (signalCfg?.httpUrl?.trim())
+        return signalCfg.httpUrl.trim();
+    const host = opts.httpHost ?? signalCfg?.httpHost ?? "127.0.0.1";
+    const port = opts.httpPort ?? signalCfg?.httpPort ?? 8080;
+    return `http://${host}:${port}`;
+}
+function resolveAccount(opts) {
+    const cfg = loadConfig();
+    return opts.account?.trim() || cfg.signal?.account?.trim() || undefined;
+}
+function resolveAllowFrom(opts) {
+    const cfg = loadConfig();
+    const raw = opts.allowFrom ?? cfg.signal?.allowFrom ?? [];
+    return raw.map((entry) => String(entry).trim()).filter(Boolean);
+}
+function isAllowedSender(sender, allowFrom) {
+    if (allowFrom.length === 0)
+        return true;
+    if (allowFrom.includes("*"))
+        return true;
+    const normalizedAllow = allowFrom
+        .map((entry) => entry.replace(/^signal:/i, ""))
+        .map((entry) => normalizeE164(entry));
+    const normalizedSender = normalizeE164(sender);
+    return normalizedAllow.includes(normalizedSender);
+}
+async function waitForSignalDaemonReady(params) {
+    const started = Date.now();
+    let lastError = null;
+    while (Date.now() - started < params.timeoutMs) {
+        if (params.abortSignal?.aborted)
+            return;
+        const res = await signalCheck(params.baseUrl, 1000);
+        if (res.ok)
+            return;
+        lastError =
+            res.error ?? (res.status ? `HTTP ${res.status}` : "unreachable");
+        await new Promise((r) => setTimeout(r, 150));
+    }
+    params.runtime.error?.(danger(`daemon not ready after ${params.timeoutMs}ms (${lastError ?? "unknown error"})`));
+    throw new Error(`signal daemon not ready (${lastError ?? "unknown error"})`);
+}
+async function fetchAttachment(params) {
+    const { attachment } = params;
+    if (!attachment?.id)
+        return null;
+    if (attachment.size && attachment.size > params.maxBytes) {
+        throw new Error(`Signal attachment ${attachment.id} exceeds ${(params.maxBytes / (1024 * 1024)).toFixed(0)}MB limit`);
+    }
+    const rpcParams = {
+        id: attachment.id,
+    };
+    if (params.account)
+        rpcParams.account = params.account;
+    if (params.groupId)
+        rpcParams.groupId = params.groupId;
+    else if (params.sender)
+        rpcParams.recipient = params.sender;
+    else
+        return null;
+    const result = await signalRpcRequest("getAttachment", rpcParams, { baseUrl: params.baseUrl });
+    if (!result?.data)
+        return null;
+    const buffer = Buffer.from(result.data, "base64");
+    const saved = await saveMediaBuffer(buffer, attachment.contentType ?? undefined, "inbound", params.maxBytes);
+    return { path: saved.path, contentType: saved.contentType };
+}
+async function deliverReplies(params) {
+    const { replies, target, baseUrl, account, runtime, maxBytes, textLimit } = params;
+    for (const payload of replies) {
+        const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+        const text = payload.text ?? "";
+        if (!text && mediaList.length === 0)
+            continue;
+        if (mediaList.length === 0) {
+            for (const chunk of chunkText(text, textLimit)) {
+                await sendMessageSignal(target, chunk, {
+                    baseUrl,
+                    account,
+                    maxBytes,
+                });
+            }
+        }
+        else {
+            let first = true;
+            for (const url of mediaList) {
+                const caption = first ? text : "";
+                first = false;
+                await sendMessageSignal(target, caption, {
+                    baseUrl,
+                    account,
+                    mediaUrl: url,
+                    maxBytes,
+                });
+            }
+        }
+        runtime.log?.(`delivered reply to ${target}`);
+    }
+}
+export async function monitorSignalProvider(opts = {}) {
+    const runtime = resolveRuntime(opts);
+    const cfg = loadConfig();
+    const textLimit = resolveTextChunkLimit(cfg, "signal");
+    const baseUrl = resolveBaseUrl(opts);
+    const account = resolveAccount(opts);
+    const allowFrom = resolveAllowFrom(opts);
+    const mediaMaxBytes = (opts.mediaMaxMb ?? cfg.signal?.mediaMaxMb ?? 8) * 1024 * 1024;
+    const ignoreAttachments = opts.ignoreAttachments ?? cfg.signal?.ignoreAttachments ?? false;
+    const autoStart = opts.autoStart ?? cfg.signal?.autoStart ?? !cfg.signal?.httpUrl;
+    let daemonHandle = null;
+    if (autoStart) {
+        const cliPath = opts.cliPath ?? cfg.signal?.cliPath ?? "signal-cli";
+        const httpHost = opts.httpHost ?? cfg.signal?.httpHost ?? "127.0.0.1";
+        const httpPort = opts.httpPort ?? cfg.signal?.httpPort ?? 8080;
+        daemonHandle = spawnSignalDaemon({
+            cliPath,
+            account,
+            httpHost,
+            httpPort,
+            receiveMode: opts.receiveMode ?? cfg.signal?.receiveMode,
+            ignoreAttachments: opts.ignoreAttachments ?? cfg.signal?.ignoreAttachments,
+            ignoreStories: opts.ignoreStories ?? cfg.signal?.ignoreStories,
+            sendReadReceipts: opts.sendReadReceipts ?? cfg.signal?.sendReadReceipts,
+            runtime,
+        });
+    }
+    const onAbort = () => {
+        daemonHandle?.stop();
+    };
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        if (daemonHandle) {
+            await waitForSignalDaemonReady({
+                baseUrl,
+                abortSignal: opts.abortSignal,
+                timeoutMs: 10_000,
+                runtime,
+            });
+        }
+        const handleEvent = async (event) => {
+            if (event.event !== "receive" || !event.data)
+                return;
+            let payload = null;
+            try {
+                payload = JSON.parse(event.data);
+            }
+            catch (err) {
+                runtime.error?.(`failed to parse event: ${String(err)}`);
+                return;
+            }
+            if (payload?.exception?.message) {
+                runtime.error?.(`receive exception: ${payload.exception.message}`);
+            }
+            const envelope = payload?.envelope;
+            if (!envelope)
+                return;
+            if (envelope.syncMessage)
+                return;
+            const dataMessage = envelope.dataMessage ?? envelope.editMessage?.dataMessage;
+            if (!dataMessage)
+                return;
+            const sender = envelope.sourceNumber?.trim();
+            if (!sender)
+                return;
+            if (account && normalizeE164(sender) === normalizeE164(account)) {
+                return;
+            }
+            if (!isAllowedSender(sender, allowFrom)) {
+                logVerbose(`Blocked signal sender ${sender} (not in allowFrom)`);
+                return;
+            }
+            const groupId = dataMessage.groupInfo?.groupId ?? undefined;
+            const groupName = dataMessage.groupInfo?.groupName ?? undefined;
+            const isGroup = Boolean(groupId);
+            const messageText = (dataMessage.message ?? "").trim();
+            let mediaPath;
+            let mediaType;
+            let placeholder = "";
+            const firstAttachment = dataMessage.attachments?.[0];
+            if (firstAttachment?.id && !ignoreAttachments) {
+                try {
+                    const fetched = await fetchAttachment({
+                        baseUrl,
+                        account,
+                        attachment: firstAttachment,
+                        sender,
+                        groupId,
+                        maxBytes: mediaMaxBytes,
+                    });
+                    if (fetched) {
+                        mediaPath = fetched.path;
+                        mediaType =
+                            fetched.contentType ?? firstAttachment.contentType ?? undefined;
+                    }
+                }
+                catch (err) {
+                    runtime.error?.(danger(`attachment fetch failed: ${String(err)}`));
+                }
+            }
+            const kind = mediaKindFromMime(mediaType ?? undefined);
+            if (kind) {
+                placeholder = `<media:${kind}>`;
+            }
+            else if (dataMessage.attachments?.length) {
+                placeholder = "<media:attachment>";
+            }
+            const bodyText = messageText || placeholder || dataMessage.quote?.text?.trim() || "";
+            if (!bodyText)
+                return;
+            const fromLabel = isGroup
+                ? `${groupName ?? "Signal Group"} id:${groupId}`
+                : `${envelope.sourceName ?? sender} id:${sender}`;
+            const body = formatAgentEnvelope({
+                surface: "Signal",
+                from: fromLabel,
+                timestamp: envelope.timestamp ?? undefined,
+                body: bodyText,
+            });
+            const ctxPayload = {
+                Body: body,
+                From: isGroup ? `group:${groupId}` : `signal:${sender}`,
+                To: isGroup ? `group:${groupId}` : `signal:${sender}`,
+                ChatType: isGroup ? "group" : "direct",
+                GroupSubject: isGroup ? (groupName ?? undefined) : undefined,
+                SenderName: envelope.sourceName ?? sender,
+                Surface: "signal",
+                MessageSid: envelope.timestamp ? String(envelope.timestamp) : undefined,
+                Timestamp: envelope.timestamp ?? undefined,
+                MediaPath: mediaPath,
+                MediaType: mediaType,
+                MediaUrl: mediaPath,
+            };
+            if (!isGroup) {
+                const sessionCfg = cfg.session;
+                const mainKey = (sessionCfg?.mainKey ?? "main").trim() || "main";
+                const storePath = resolveStorePath(sessionCfg?.store);
+                await updateLastRoute({
+                    storePath,
+                    sessionKey: mainKey,
+                    channel: "signal",
+                    to: normalizeE164(sender),
+                });
+            }
+            if (shouldLogVerbose()) {
+                const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+                logVerbose(`signal inbound: from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
+            }
+            let blockSendChain = Promise.resolve();
+            const sendBlockReply = (payload) => {
+                if (!payload?.text &&
+                    !payload?.mediaUrl &&
+                    !(payload?.mediaUrls?.length ?? 0)) {
+                    return;
+                }
+                blockSendChain = blockSendChain
+                    .then(async () => {
+                    await deliverReplies({
+                        replies: [payload],
+                        target: ctxPayload.To,
+                        baseUrl,
+                        account,
+                        runtime,
+                        maxBytes: mediaMaxBytes,
+                        textLimit,
+                    });
+                })
+                    .catch((err) => {
+                    runtime.error?.(danger(`signal block reply failed: ${String(err)}`));
+                });
+            };
+            const replyResult = await getReplyFromConfig(ctxPayload, { onBlockReply: sendBlockReply }, cfg);
+            const replies = replyResult
+                ? Array.isArray(replyResult)
+                    ? replyResult
+                    : [replyResult]
+                : [];
+            await blockSendChain;
+            if (replies.length === 0)
+                return;
+            await deliverReplies({
+                replies,
+                target: ctxPayload.To,
+                baseUrl,
+                account,
+                runtime,
+                maxBytes: mediaMaxBytes,
+                textLimit,
+            });
+        };
+        await streamSignalEvents({
+            baseUrl,
+            account,
+            abortSignal: opts.abortSignal,
+            onEvent: (event) => {
+                void handleEvent(event).catch((err) => {
+                    runtime.error?.(`event handler failed: ${String(err)}`);
+                });
+            },
+        });
+    }
+    catch (err) {
+        if (opts.abortSignal?.aborted)
+            return;
+        throw err;
+    }
+    finally {
+        opts.abortSignal?.removeEventListener("abort", onAbort);
+        daemonHandle?.stop();
+    }
+}

package/dist/signal/probe.js

@@ -0,0 +1,46 @@
+import { signalCheck, signalRpcRequest } from "./client.js";
+function parseSignalVersion(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (typeof value === "object" && value !== null) {
+        const version = value.version;
+        if (typeof version === "string" && version.trim())
+            return version.trim();
+    }
+    return null;
+}
+export async function probeSignal(baseUrl, timeoutMs) {
+    const started = Date.now();
+    const result = {
+        ok: false,
+        status: null,
+        error: null,
+        elapsedMs: 0,
+        version: null,
+    };
+    const check = await signalCheck(baseUrl, timeoutMs);
+    if (!check.ok) {
+        return {
+            ...result,
+            status: check.status ?? null,
+            error: check.error ?? "unreachable",
+            elapsedMs: Date.now() - started,
+        };
+    }
+    try {
+        const version = await signalRpcRequest("version", undefined, {
+            baseUrl,
+            timeoutMs,
+        });
+        result.version = parseSignalVersion(version);
+    }
+    catch (err) {
+        result.error = err instanceof Error ? err.message : String(err);
+    }
+    return {
+        ...result,
+        ok: true,
+        status: check.status ?? null,
+        elapsedMs: Date.now() - started,
+    };
+}