r2-relay-channel 0.3.5

package/dist/setup-entry.d.ts

@@ -0,0 +1,6 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+import { type ResolvedR2RelayAccount } from "./config.js";
+declare const _default: {
+    plugin: ChannelPlugin<ResolvedR2RelayAccount>;
+};
+export default _default;

package/dist/setup-entry.js

@@ -0,0 +1,49 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
+import { r2RelayChannelConfigSchema, resolveR2RelayAccount, listR2RelayAccountIds, } from "./config.js";
+import { r2RelaySetupAdapter, r2RelaySetupWizard } from "./setup.js";
+const r2RelaySetupPlugin = {
+    id: "r2-relay-channel",
+    meta: {
+        id: "r2-relay-channel",
+        label: "R2 Relay",
+        selectionLabel: "R2 Relay",
+        docsPath: "/channels/r2-relay-channel",
+        docsLabel: "r2-relay-channel",
+        blurb: "Cloudflare R2-backed relay channel for direct text messaging.",
+        order: 120,
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+        reactions: true,
+        media: false,
+    },
+    reload: { configPrefixes: ["channels.r2-relay-channel"] },
+    configSchema: r2RelayChannelConfigSchema,
+    setupWizard: r2RelaySetupWizard,
+    setup: r2RelaySetupAdapter,
+    config: {
+        listAccountIds: (cfg) => listR2RelayAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveR2RelayAccount({ cfg, accountId }),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            serverId: account.serverId,
+            bucket: account.bucket,
+            endpoint: redactEndpoint(account.endpoint),
+        }),
+    },
+};
+function redactEndpoint(endpoint) {
+    try {
+        const url = new URL(endpoint);
+        return `${url.protocol}//${url.host}`;
+    }
+    catch {
+        return endpoint;
+    }
+}
+export default defineSetupPluginEntry(r2RelaySetupPlugin);

package/dist/setup.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelSetupAdapter, ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
+export declare const r2RelaySetupAdapter: ChannelSetupAdapter;
+export declare const r2RelaySetupWizard: ChannelSetupWizard;

package/dist/setup.js

@@ -0,0 +1,291 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { readConfigFileSnapshotForWrite, writeConfigFile } from "openclaw/plugin-sdk/config-runtime";
+import { CHANNEL_ID, DEFAULT_BACKOFF_MAX_MS, DEFAULT_FORCE_PATH_STYLE, DEFAULT_HEAD_TTL_DAYS, DEFAULT_IDENTITY_TTL_DAYS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_REGION, DEFAULT_TTL_DAYS, loadR2RelaySidecarConfig, normalizeServerId, resolveRelayConfigFilePath, } from "./config.js";
+function getChannelSection(cfg) {
+    return cfg.channels?.[CHANNEL_ID] ?? {};
+}
+function withChannelSection(cfg, patch) {
+    const currentChannels = cfg.channels ?? {};
+    const nextSection = {
+        enabled: true,
+        ...getChannelSection(cfg),
+        ...patch,
+    };
+    return {
+        ...cfg,
+        channels: {
+            ...currentChannels,
+            [CHANNEL_ID]: nextSection,
+        },
+        plugins: {
+            ...(cfg.plugins ?? {}),
+            entries: {
+                ...(cfg.plugins?.entries ?? {}),
+                [CHANNEL_ID]: {
+                    enabled: true,
+                },
+            },
+        },
+    };
+}
+function currentString(cfg, key) {
+    const sidecar = getSidecarSection(cfg);
+    const value = sidecar[key];
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function normalizeEndpoint(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+function validateUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            return "Use an http:// or https:// endpoint URL.";
+        }
+        return undefined;
+    }
+    catch {
+        return "Enter a valid endpoint URL.";
+    }
+}
+function randomServerIdCandidate() {
+    const nouns = ["otter", "harbor", "pine", "comet", "rook", "fern"];
+    const noun = nouns[Math.floor(Math.random() * nouns.length)];
+    const suffix = Math.floor(Math.random() * 900 + 100);
+    return `gw-${noun}-${suffix}`;
+}
+function suggestedServerId(cfg) {
+    return currentString(cfg, "serverId") ?? randomServerIdCandidate();
+}
+function getConfiguredConfigFileValue(cfg) {
+    const configured = getChannelSection(cfg).configFile?.trim();
+    return configured || undefined;
+}
+function getConfigFilePath(cfg) {
+    return resolveRelayConfigFilePath(getConfiguredConfigFileValue(cfg));
+}
+function getSidecarSection(cfg) {
+    return loadR2RelaySidecarConfig(getConfigFilePath(cfg));
+}
+function configPointerPatch(cfg) {
+    const configured = getConfiguredConfigFileValue(cfg);
+    return configured ? { enabled: true, configFile: configured } : { enabled: true, configFile: getConfigFilePath(cfg) };
+}
+function buildExpandedSidecarSection(cfg, patch) {
+    const current = getSidecarSection(cfg);
+    const merged = {
+        ...current,
+        ...patch,
+    };
+    const defaultTtlDays = merged.defaultTtlDays ?? DEFAULT_TTL_DAYS;
+    return {
+        enabled: merged.enabled ?? true,
+        endpoint: merged.endpoint,
+        bucket: merged.bucket,
+        accessKeyId: merged.accessKeyId,
+        secretAccessKey: merged.secretAccessKey,
+        serverId: merged.serverId,
+        region: merged.region ?? DEFAULT_REGION,
+        forcePathStyle: merged.forcePathStyle ?? DEFAULT_FORCE_PATH_STYLE,
+        pollIntervalMs: merged.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+        backoffMaxMs: merged.backoffMaxMs ?? DEFAULT_BACKOFF_MAX_MS,
+        defaultTtlDays,
+        ttl: {
+            msg: merged.ttl?.msg ?? defaultTtlDays,
+            att: merged.ttl?.att ?? defaultTtlDays,
+            identity: merged.ttl?.identity ?? DEFAULT_IDENTITY_TTL_DAYS,
+            head: merged.ttl?.head ?? DEFAULT_HEAD_TTL_DAYS,
+        },
+    };
+}
+function writeSidecarSection(cfg, patch) {
+    const filePath = getConfigFilePath(cfg);
+    const next = buildExpandedSidecarSection(cfg, patch);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}
+async function persistOpenClawConfig(cfg) {
+    const { writeOptions } = await readConfigFileSnapshotForWrite();
+    await writeConfigFile(cfg, writeOptions);
+}
+async function writeSidecarAndPersistChannelPointer(cfg, patch) {
+    writeSidecarSection(cfg, patch);
+    const nextCfg = withChannelSection(cfg, configPointerPatch(cfg));
+    await persistOpenClawConfig(nextCfg);
+    return nextCfg;
+}
+function applyInputToConfig(cfg, input) {
+    const patch = {
+        enabled: true,
+        region: DEFAULT_REGION,
+        forcePathStyle: DEFAULT_FORCE_PATH_STYLE,
+        pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+        backoffMaxMs: DEFAULT_BACKOFF_MAX_MS,
+        defaultTtlDays: DEFAULT_TTL_DAYS,
+        ttl: {
+            msg: DEFAULT_TTL_DAYS,
+            att: DEFAULT_TTL_DAYS,
+            identity: DEFAULT_IDENTITY_TTL_DAYS,
+            head: DEFAULT_HEAD_TTL_DAYS,
+        },
+    };
+    if (typeof input.url === "string" && input.url.trim()) {
+        patch.endpoint = normalizeEndpoint(input.url);
+    }
+    if (typeof input.name === "string" && input.name.trim()) {
+        patch.bucket = input.name.trim();
+    }
+    if (typeof input.userId === "string" && input.userId.trim()) {
+        patch.accessKeyId = input.userId.trim();
+    }
+    if (typeof input.password === "string" && input.password.trim()) {
+        patch.secretAccessKey = input.password.trim();
+    }
+    if (typeof input.deviceName === "string") {
+        const trimmed = input.deviceName.trim();
+        patch.serverId = trimmed ? normalizeServerId(trimmed) ?? trimmed : undefined;
+    }
+    writeSidecarSection(cfg, patch);
+    return withChannelSection(cfg, configPointerPatch(cfg));
+}
+export const r2RelaySetupAdapter = {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    applyAccountConfig: ({ cfg, input }) => applyInputToConfig(cfg, input),
+    validateInput: ({ input }) => {
+        const url = input.url?.trim() ?? "";
+        const bucket = input.name?.trim() ?? "";
+        const accessKeyId = input.userId?.trim() ?? "";
+        const secretAccessKey = input.password?.trim() ?? "";
+        if (!url || !bucket || !accessKeyId || !secretAccessKey) {
+            return "R2 endpoint, bucket, access key ID, and secret access key are required.";
+        }
+        return validateUrl(url) ?? null;
+    },
+};
+export const r2RelaySetupWizard = {
+    channel: CHANNEL_ID,
+    resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
+    resolveShouldPromptAccountIds: () => false,
+    status: {
+        configuredLabel: "Configured",
+        unconfiguredLabel: "Not configured",
+        configuredHint: "R2 endpoint, bucket, and credentials are present.",
+        unconfiguredHint: "Add your R2 bucket details to enable the dedicated OpenClaw app flow.",
+        resolveConfigured: ({ cfg }) => {
+            const section = getSidecarSection(cfg);
+            return Boolean(section.endpoint?.trim() &&
+                section.bucket?.trim() &&
+                section.accessKeyId?.trim() &&
+                section.secretAccessKey?.trim());
+        },
+        resolveStatusLines: ({ cfg, configured }) => {
+            const section = getSidecarSection(cfg);
+            const lines = [
+                configured
+                    ? "AgentDeck and other dedicated clients can use this channel once the gateway is running."
+                    : "This channel is intended for AgentDeck-style dedicated app onboarding.",
+            ];
+            if (section.bucket?.trim()) {
+                lines.push(`Bucket: ${section.bucket.trim()}`);
+            }
+            if (section.serverId?.trim()) {
+                lines.push(`Server ID: ${section.serverId.trim()}`);
+            }
+            lines.push(`Config file: ${getConfigFilePath(cfg)}`);
+            return lines;
+        },
+    },
+    introNote: {
+        title: "R2 Relay by AgentDeck App",
+        lines: [
+            "This setup connects OpenClaw to Cloudflare R2 so a dedicated app can discover your gateway and chat through your own bucket.",
+            "You will need your R2 endpoint URL, bucket name, access key ID, and secret access key.",
+        ],
+    },
+    stepOrder: "text-first",
+    credentials: [],
+    textInputs: [
+        {
+            inputKey: "url",
+            message: "R2 endpoint URL",
+            placeholder: "https://<account>.r2.cloudflarestorage.com",
+            required: true,
+            helpTitle: "Endpoint URL",
+            helpLines: ["Use the Cloudflare R2 S3-compatible endpoint for your account."],
+            currentValue: ({ cfg }) => currentString(cfg, "endpoint"),
+            applyCurrentValue: true,
+            validate: ({ value }) => validateUrl(value.trim()),
+            normalizeValue: ({ value }) => normalizeEndpoint(value),
+            applySet: async ({ cfg, value }) => await writeSidecarAndPersistChannelPointer(cfg, { endpoint: normalizeEndpoint(value) }),
+        },
+        {
+            inputKey: "name",
+            message: "R2 bucket name",
+            placeholder: "Bucket name",
+            required: true,
+            currentValue: ({ cfg }) => currentString(cfg, "bucket"),
+            applyCurrentValue: true,
+            validate: ({ value }) => (value.trim() ? undefined : "Bucket name is required."),
+            normalizeValue: ({ value }) => value.trim(),
+            applySet: async ({ cfg, value }) => await writeSidecarAndPersistChannelPointer(cfg, { bucket: value.trim() }),
+        },
+        {
+            inputKey: "userId",
+            message: "R2 access key ID",
+            placeholder: "Access key ID",
+            required: true,
+            currentValue: ({ cfg }) => currentString(cfg, "accessKeyId"),
+            applyCurrentValue: true,
+            validate: ({ value }) => (value.trim() ? undefined : "Access key ID is required."),
+            normalizeValue: ({ value }) => value.trim(),
+            applySet: async ({ cfg, value }) => await writeSidecarAndPersistChannelPointer(cfg, { accessKeyId: value.trim() }),
+        },
+        {
+            inputKey: "password",
+            message: "R2 secret access key",
+            placeholder: "Secret access key",
+            required: true,
+            currentValue: ({ cfg }) => currentString(cfg, "secretAccessKey"),
+            applyCurrentValue: true,
+            validate: ({ value }) => (value.trim() ? undefined : "Secret access key is required."),
+            normalizeValue: ({ value }) => value.trim(),
+            applySet: async ({ cfg, value }) => await writeSidecarAndPersistChannelPointer(cfg, { secretAccessKey: value.trim() }),
+        },
+        {
+            inputKey: "deviceName",
+            message: "Gateway server ID",
+            placeholder: "gateway-home",
+            required: false,
+            helpTitle: "Server ID",
+            helpLines: [
+                "This becomes the peer id published to the relay and seen by dedicated clients.",
+                "A random candidate name is suggested; you can keep it or edit it.",
+            ],
+            currentValue: ({ cfg }) => currentString(cfg, "serverId"),
+            applyCurrentValue: true,
+            initialValue: ({ cfg }) => suggestedServerId(cfg),
+            normalizeValue: ({ value }) => value.trim(),
+            validate: ({ value }) => {
+                const trimmed = value.trim();
+                if (!trimmed)
+                    return undefined;
+                return normalizeServerId(trimmed) ? undefined : "Enter a valid server id.";
+            },
+            applySet: async ({ cfg, value }) => {
+                const trimmed = value.trim();
+                return await writeSidecarAndPersistChannelPointer(cfg, {
+                    serverId: trimmed ? normalizeServerId(trimmed) ?? trimmed : undefined,
+                });
+            },
+        },
+    ],
+    completionNote: {
+        title: "Next step",
+        lines: [
+            "Restart the gateway after setup so the full plugin runtime loads with your new channel config.",
+            "Then use AgentDeck or another dedicated OpenClaw app with the same R2 connection details.",
+        ],
+    },
+};

package/dist/target.d.ts

@@ -0,0 +1,6 @@
+export interface RelayTarget {
+    peer: string;
+    conversationId: string | null;
+}
+export declare function parseRelayTarget(raw: string): RelayTarget;
+export declare function formatRelayTargetHint(): string;

package/dist/target.js

@@ -0,0 +1,53 @@
+const RESERVED_VALUE_CHARS = /[=,]/;
+export function parseRelayTarget(raw) {
+    const input = raw.trim();
+    if (!input) {
+        throw new Error("Missing relay target");
+    }
+    if (!input.includes("=")) {
+        return {
+            peer: input,
+            conversationId: null,
+        };
+    }
+    const pairs = input.split(",");
+    let peer = null;
+    let conversationId = null;
+    for (const pair of pairs) {
+        const trimmed = pair.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex <= 0) {
+            throw new Error(`Invalid relay target segment: ${trimmed}`);
+        }
+        const key = trimmed.slice(0, eqIndex).trim().toLowerCase();
+        const value = trimmed.slice(eqIndex + 1).trim();
+        if (!value) {
+            throw new Error(`Missing relay target value for ${key}`);
+        }
+        if (RESERVED_VALUE_CHARS.test(value)) {
+            throw new Error(`Relay target values cannot contain ',' or '=' (${key})`);
+        }
+        if (key === "peer") {
+            peer = value;
+            continue;
+        }
+        if (key === "conversation") {
+            conversationId = value;
+            continue;
+        }
+        throw new Error(`Unsupported relay target key: ${key}`);
+    }
+    if (!peer) {
+        throw new Error("Relay target must include peer=<peer>");
+    }
+    if (!conversationId) {
+        throw new Error("Relay target must include conversation=<conversationId>");
+    }
+    return { peer, conversationId };
+}
+export function formatRelayTargetHint() {
+    return "peer=<peer>,conversation=<conversationId>";
+}

package/dist/webhook.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+declare const WEBHOOK_BASE_PATH = "/r2-relay-channel/webhook";
+export declare function registerRelayWebhookRoute(api: {
+    config: OpenClawConfig;
+    logger?: {
+        info?: (message: string, meta?: Record<string, unknown>) => void;
+        warn?: (message: string, meta?: Record<string, unknown>) => void;
+        error?: (message: string, meta?: Record<string, unknown>) => void;
+    };
+    registerHttpRoute: (route: {
+        path: string;
+        auth: "plugin" | "gateway";
+        match?: "exact" | "prefix";
+        handler: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+    }) => void;
+}): void;
+export { WEBHOOK_BASE_PATH };

package/dist/webhook.js

@@ -0,0 +1,225 @@
+import crypto from "node:crypto";
+import { resolveR2RelayAccount } from "./config.js";
+import { emitRelayDebug, getOrCreateService } from "./lifecycle.js";
+import { sendRelayPayloadMessage } from "./outbound.js";
+const WEBHOOK_BASE_PATH = "/r2-relay-channel/webhook";
+export function registerRelayWebhookRoute(api) {
+    api.registerHttpRoute({
+        path: WEBHOOK_BASE_PATH,
+        auth: "plugin",
+        match: "prefix",
+        handler: async (req, res) => {
+            if ((req.method ?? "GET").toUpperCase() !== "POST") {
+                respondJson(res, 405, { ok: false, error: "method_not_allowed" });
+                return true;
+            }
+            const expectedToken = readCronWebhookToken(api.config);
+            if (!expectedToken) {
+                respondJson(res, 503, { ok: false, error: "cron_webhook_token_not_configured" });
+                return true;
+            }
+            const providedToken = readBearerToken(req);
+            if (!providedToken || !safeEqual(providedToken, expectedToken)) {
+                respondJson(res, 401, { ok: false, error: "unauthorized" });
+                return true;
+            }
+            const target = resolveWebhookTarget(req.url);
+            if (!target) {
+                respondJson(res, 400, {
+                    ok: false,
+                    error: "invalid_target",
+                    hint: `${WEBHOOK_BASE_PATH}/<peer>/<encoded-conversation-id>`,
+                });
+                return true;
+            }
+            let payload;
+            try {
+                payload = parseJsonBody(await readRequestBody(req));
+            }
+            catch (err) {
+                respondJson(res, 400, {
+                    ok: false,
+                    error: "invalid_json",
+                    detail: err instanceof Error ? err.message : String(err),
+                });
+                return true;
+            }
+            const text = extractRelayText(payload);
+            const mediaUrls = extractRelayMediaUrls(payload);
+            if (!text && mediaUrls.length === 0) {
+                respondJson(res, 204, null);
+                return true;
+            }
+            try {
+                const account = resolveR2RelayAccount({ cfg: api.config });
+                if (!account.enabled || !account.configured) {
+                    respondJson(res, 503, { ok: false, error: "relay_not_configured" });
+                    return true;
+                }
+                const route = {
+                    agent_id: agentIdFromConversationId(target.conversationId) ?? "main",
+                    conversation_id: target.conversationId ?? null,
+                    instance_id: null,
+                };
+                let result;
+                if (mediaUrls.length > 0) {
+                    emitRelayDebug(api.logger, `[${account.accountId}] webhook relay send starting`, {
+                        to: target.to,
+                        conversationId: target.conversationId,
+                        mediaCount: mediaUrls.length,
+                        hasText: Boolean(text),
+                    });
+                    result = await sendRelayPayloadMessage({
+                        cfg: api.config,
+                        to: `peer=${target.to},conversation=${target.conversationId}`,
+                        payload: {
+                            text,
+                            mediaUrls,
+                            mediaUrl: mediaUrls[0],
+                        },
+                        accountId: account.accountId,
+                        log: api.logger,
+                        source: "webhook",
+                        meta: {
+                            route,
+                        },
+                    });
+                }
+                else {
+                    const service = getOrCreateService(account);
+                    result = await service.sendMessage(target.to, {
+                        route,
+                        content: {
+                            type: "text",
+                            text: text ?? "",
+                        },
+                    });
+                }
+                api.logger?.info?.("r2-relay-channel: delivered cron webhook to relay session", {
+                    to: target.to,
+                    conversationId: target.conversationId,
+                    jobId: typeof payload.jobId === "string" ? payload.jobId : undefined,
+                    status: typeof payload.status === "string" ? payload.status : undefined,
+                    messageId: result.messageId,
+                });
+                respondJson(res, 200, {
+                    ok: true,
+                    to: target.to,
+                    conversationId: target.conversationId,
+                    messageId: result.messageId,
+                });
+                return true;
+            }
+            catch (err) {
+                api.logger?.error?.("r2-relay-channel: cron webhook delivery failed", {
+                    to: target.to,
+                    conversationId: target.conversationId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                respondJson(res, 500, {
+                    ok: false,
+                    error: "delivery_failed",
+                    detail: err instanceof Error ? err.message : String(err),
+                });
+                return true;
+            }
+        },
+    });
+}
+function readCronWebhookToken(cfg) {
+    const token = cfg.cron?.webhookToken;
+    return typeof token === "string" && token.trim() ? token.trim() : null;
+}
+function readBearerToken(req) {
+    const header = req.headers.authorization;
+    if (typeof header !== "string") {
+        return null;
+    }
+    const match = header.match(/^Bearer\s+(.+)$/i);
+    const token = match?.[1]?.trim();
+    return token || null;
+}
+function safeEqual(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    if (left.length !== right.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(left, right);
+}
+function resolveWebhookTarget(rawUrl) {
+    const url = new URL(rawUrl || WEBHOOK_BASE_PATH, "http://localhost");
+    const parts = url.pathname
+        .split("/")
+        .filter(Boolean)
+        .map((part) => decodeURIComponent(part));
+    if (parts.length < 4 || parts[0] !== "r2-relay-channel" || parts[1] !== "webhook") {
+        return null;
+    }
+    const to = parts[2]?.trim() ?? "";
+    const conversationId = parts.slice(3).join("/").trim();
+    if (!to || !conversationId) {
+        return null;
+    }
+    return { to, conversationId };
+}
+function agentIdFromConversationId(conversationId) {
+    const parts = conversationId.split(":");
+    if (parts.length >= 2 && parts[0] === "agent" && parts[1]?.trim()) {
+        return parts[1].trim();
+    }
+    return null;
+}
+async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function parseJsonBody(raw) {
+    const text = raw.trim();
+    if (!text) {
+        throw new Error("request body is empty");
+    }
+    return JSON.parse(text);
+}
+function extractRelayText(payload) {
+    const directText = typeof payload.text === "string" ? payload.text.trim() : "";
+    if (directText) {
+        return directText;
+    }
+    const summary = typeof payload.summary === "string" ? payload.summary.trim() : "";
+    if (summary) {
+        return summary;
+    }
+    const error = typeof payload.error === "string" ? payload.error.trim() : "";
+    if (error) {
+        return error;
+    }
+    return null;
+}
+function extractRelayMediaUrls(payload) {
+    const values = [];
+    if (typeof payload.mediaUrl === "string" && payload.mediaUrl.trim()) {
+        values.push(payload.mediaUrl.trim());
+    }
+    if (Array.isArray(payload.mediaUrls)) {
+        for (const value of payload.mediaUrls) {
+            if (typeof value === "string" && value.trim()) {
+                values.push(value.trim());
+            }
+        }
+    }
+    return values;
+}
+function respondJson(res, statusCode, body) {
+    res.statusCode = statusCode;
+    if (statusCode === 204) {
+        res.end();
+        return;
+    }
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+export { WEBHOOK_BASE_PATH };