r2-relay-channel 0.3.5

package/dist/relay-core/keyspace.js

@@ -0,0 +1,60 @@
+import { randomBytes } from "node:crypto";
+export const MAX_MS = 9999999999999;
+const SAFE_FRAGMENT_RE = /[^a-zA-Z0-9._-]/g;
+export function sanitizeFragment(value) {
+    return String(value ?? "").replace(SAFE_FRAGMENT_RE, "");
+}
+export function padRevTs(ts) {
+    return String(MAX_MS - Math.trunc(ts)).padStart(13, "0");
+}
+export function extractTimestampFromRelayKey(key) {
+    const name = key.split("/").pop()?.trim() ?? "";
+    const match = name.match(/^(\d{13})-/);
+    if (!match) {
+        return null;
+    }
+    const reversed = Number(match[1]);
+    if (!Number.isFinite(reversed)) {
+        return null;
+    }
+    return MAX_MS - reversed;
+}
+export class RelayKeyspace {
+    bucket;
+    idFactory;
+    nowMsFactory;
+    constructor(options = {}) {
+        this.bucket = options.bucket ?? "";
+        this.idFactory = options.idFactory ?? (() => randomBytes(4).toString("hex"));
+        this.nowMsFactory = options.nowMsFactory ?? (() => Date.now());
+    }
+    padRevTs(ts) {
+        return padRevTs(ts);
+    }
+    shortUuid() {
+        return this.idFactory();
+    }
+    makeMsgKey(recipient, nowMs, suffix) {
+        const ts = nowMs ?? this.nowMsFactory();
+        return `msg/${recipient}/${this.padRevTs(ts)}-${suffix ?? this.shortUuid()}.json`;
+    }
+    makeAttKey(recipient, messageId, index, name, nowMs) {
+        const ts = nowMs ?? this.nowMsFactory();
+        const safeMessageId = sanitizeFragment(messageId);
+        const safeIndex = String(index).padStart(2, "0");
+        const safeName = sanitizeFragment(name);
+        const suffix = safeName ? `-${safeName}` : "";
+        return `att/${recipient}/${this.padRevTs(ts)}-${safeMessageId}-${safeIndex}${suffix}`;
+    }
+    makeHeadKey(recipient) {
+        return `head/${recipient}.json`;
+    }
+    makeIdentityKey(peer) {
+        return `identity/${peer}.json`;
+    }
+    makeIdentifyKey(peer) {
+        return this.makeIdentityKey(peer);
+    }
+}
+export class R2Relay extends RelayKeyspace {
+}

package/dist/relay-core/object-store.d.ts

@@ -0,0 +1,20 @@
+export interface ListPrefixItem {
+    Key?: string;
+    LastModified?: Date | null;
+}
+export interface ListPrefixPageResult {
+    contents: ListPrefixItem[];
+    nextContinuationToken: string | null;
+    isTruncated: boolean;
+}
+export interface ObjectStore {
+    putObject(key: string, body: Buffer | string, contentType?: string, tagging?: string, ifMatch?: string, ifNoneMatch?: string): Promise<unknown>;
+    getObject(key: string): Promise<unknown | null>;
+    getJsonWithEtag(key: string): Promise<{
+        body: unknown;
+        etag: string | null;
+    } | null>;
+    deleteObject(key: string): Promise<unknown>;
+    deleteObjects(keys: string[]): Promise<unknown>;
+    listPrefixPage(prefix: string, continuationToken?: string, maxKeys?: number): Promise<ListPrefixPageResult>;
+}

package/dist/relay-core/object-store.js

@@ -0,0 +1 @@
+export {};

package/dist/relay-core/transport.d.ts

@@ -0,0 +1,48 @@
+import { type CheckpointStore } from "./checkpoint.js";
+import { RelayKeyspace } from "./keyspace.js";
+import { ObjectStore } from "./object-store.js";
+import { HeadDoc, IdentityDoc, InboxBatch, RelayMessage, RelayMessageStatus, RelayTextContent, RelayRetentionConfig, SendMessageOptions, SendMessageResult, SweepRuleSummary } from "./types.js";
+export interface RelayTransportOptions {
+    store: ObjectStore;
+    keyspace?: RelayKeyspace;
+    peerId: string;
+    checkpointStore?: CheckpointStore;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare class R2RelayTransport {
+    readonly store: ObjectStore;
+    readonly keyspace: RelayKeyspace;
+    readonly peerId: string;
+    readonly checkpointStore: CheckpointStore;
+    readonly sleep: (ms: number) => Promise<void>;
+    private readonly sendLanes;
+    constructor(options: RelayTransportOptions);
+    publishIdentity(identity?: Partial<IdentityDoc>): Promise<IdentityDoc>;
+    getHeadState(peer: string): Promise<{
+        doc: HeadDoc;
+        etag: string | null;
+    } | null>;
+    getHead(peer: string): Promise<HeadDoc | null>;
+    readMessage(key: string): Promise<RelayMessage | null>;
+    sendMessage(to: string, options: SendMessageOptions): Promise<SendMessageResult>;
+    private sendMessageUnlocked;
+    sendStreamingSnapshots(to: string, snapshots: string[], options: {
+        route: SendMessageOptions["route"];
+        streamId?: string | null;
+        attachments?: RelayTextContent["attachments"];
+    }): Promise<{
+        streamId: string;
+        results: SendMessageResult[];
+    }>;
+    markMessageProcessed(key: string, patch: {
+        processedAt?: number;
+        processedBy?: string | null;
+        state?: RelayMessageStatus["state"];
+        error?: string | null;
+    }): Promise<RelayMessage | null>;
+    collectInboxMessages(selfId: string, lastSeenKey: string | null): Promise<InboxBatch>;
+    sweepByKeyTimestamp(prefix: string, ttlDays: number, abortSignal?: AbortSignal): Promise<SweepRuleSummary>;
+    sweepByLastModified(prefix: string, ttlDays: number, abortSignal?: AbortSignal): Promise<SweepRuleSummary>;
+    sweepRetention(ttl: RelayRetentionConfig, abortSignal?: AbortSignal): Promise<SweepRuleSummary[]>;
+    pollInbox(selfId: string, handler: (msg: RelayMessage, key: string) => Promise<void>, pollIntervalMs?: number, backoffMax?: number, deleteAfterProcessing?: boolean, abortSignal?: AbortSignal): Promise<void>;
+}

package/dist/relay-core/transport.js

@@ -0,0 +1,326 @@
+import { CASRetryExceededError, PreconditionFailedError } from "./errors.js";
+import { defaultCheckpointState, hasSeenMessage, InMemoryCheckpointStore, rememberMessage } from "./checkpoint.js";
+import { extractTimestampFromRelayKey, RelayKeyspace } from "./keyspace.js";
+async function readBodyAsText(body) {
+    if (typeof body === "string") {
+        return body;
+    }
+    if (!body) {
+        return "";
+    }
+    const value = body;
+    if (typeof value.transformToString === "function") {
+        return await value.transformToString();
+    }
+    if (typeof value[Symbol.asyncIterator] === "function") {
+        const chunks = [];
+        for await (const chunk of value) {
+            chunks.push(Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks).toString("utf8");
+    }
+    return String(body);
+}
+export class R2RelayTransport {
+    store;
+    keyspace;
+    peerId;
+    checkpointStore;
+    sleep;
+    sendLanes = new Map();
+    constructor(options) {
+        this.store = options.store;
+        this.keyspace = options.keyspace ?? new RelayKeyspace();
+        this.peerId = options.peerId;
+        this.checkpointStore = options.checkpointStore ?? new InMemoryCheckpointStore(defaultCheckpointState());
+        this.sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    }
+    async publishIdentity(identity) {
+        const doc = {
+            display_name: this.peerId,
+            role: "server",
+            last_seen: this.keyspace.nowMsFactory(),
+            protocol: { name: "r2-relay", version: 3 },
+            software: { id: "unknown" },
+            capabilities: {
+                messaging: { text: true, streaming: false, reactions: false, system_events: false },
+                conversations: { list: false, create: false, reset: false, archive: false, threading: false },
+                agents: { list: false, multiple: false, switch: false, per_agent_models: false },
+            },
+            limits: null,
+            agents: [],
+            conversations: [],
+            ...(identity ?? {}),
+            peer: identity?.peer ?? this.peerId,
+        };
+        await this.store.putObject(this.keyspace.makeIdentityKey(doc.peer), JSON.stringify(doc), "application/json");
+        return doc;
+    }
+    async getHeadState(peer) {
+        const result = await this.store.getJsonWithEtag(this.keyspace.makeHeadKey(peer));
+        return result ? { doc: result.body, etag: result.etag } : null;
+    }
+    async getHead(peer) {
+        return (await this.getHeadState(peer))?.doc ?? null;
+    }
+    async readMessage(key) {
+        const response = await this.store.getObject(key);
+        if (!response) {
+            return null;
+        }
+        if (typeof response === "object" && response !== null && "payload" in response) {
+            const payload = response.payload;
+            if (typeof payload === "string") {
+                return JSON.parse(payload);
+            }
+            return payload;
+        }
+        if (typeof response === "object" && response !== null && "Body" in response) {
+            return JSON.parse(await readBodyAsText(response.Body));
+        }
+        if (typeof response === "string") {
+            return JSON.parse(response);
+        }
+        return response;
+    }
+    async sendMessage(to, options) {
+        const previous = this.sendLanes.get(to) ?? Promise.resolve({ key: "", messageId: "" });
+        const current = previous.catch(() => ({ key: "", messageId: "" })).then(() => this.sendMessageUnlocked(to, options));
+        this.sendLanes.set(to, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (this.sendLanes.get(to) === current) {
+                this.sendLanes.delete(to);
+            }
+        }
+    }
+    async sendMessageUnlocked(to, options) {
+        const now = this.keyspace.nowMsFactory();
+        const headKey = this.keyspace.makeHeadKey(to);
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const currentHead = await this.getHeadState(to);
+            const prevKey = currentHead?.doc.head_key ?? null;
+            const key = this.keyspace.makeMsgKey(to, now);
+            const msgId = this.keyspace.shortUuid();
+            const msg = {
+                msg_id: msgId,
+                from: this.peerId,
+                to,
+                ts_sent: now,
+                prev_key: prevKey,
+                route: options.route,
+                content: options.content,
+                delivery: options.delivery ?? null,
+                status: null,
+                size: options.content.type === "text"
+                    ? Buffer.byteLength(options.content.text ?? "")
+                    : null,
+            };
+            const newHead = {
+                head_key: key,
+                head_msg_id: msgId,
+                head_ts: now,
+            };
+            await this.store.putObject(key, JSON.stringify(msg), "application/json", undefined, undefined, "*");
+            try {
+                if (!currentHead?.doc) {
+                    await this.store.putObject(headKey, JSON.stringify(newHead), "application/json", undefined, undefined, "*");
+                }
+                else {
+                    if (!currentHead.etag) {
+                        throw new Error("Missing head ETag for CAS update");
+                    }
+                    await this.store.putObject(headKey, JSON.stringify(newHead), "application/json", undefined, currentHead.etag, undefined);
+                }
+                return { key, messageId: msgId };
+            }
+            catch (err) {
+                if (!(err instanceof PreconditionFailedError)) {
+                    throw err;
+                }
+                await this.sleep(20);
+            }
+        }
+        throw new CASRetryExceededError();
+    }
+    async sendStreamingSnapshots(to, snapshots, options) {
+        const streamId = options.streamId ?? this.keyspace.shortUuid();
+        const results = [];
+        const nonEmpty = snapshots.filter((s) => (s ?? "").trim());
+        for (let index = 0; index < nonEmpty.length; index += 1) {
+            const text = nonEmpty[index] ?? "";
+            const result = await this.sendMessage(to, {
+                route: options.route,
+                content: {
+                    type: "text",
+                    text,
+                    ...(options.attachments?.length ? { attachments: options.attachments } : {}),
+                },
+                delivery: {
+                    stream: {
+                        stream_id: streamId,
+                        seq: index + 1,
+                        state: index === nonEmpty.length - 1 ? "final" : "partial",
+                    },
+                },
+            });
+            results.push(result);
+        }
+        return { streamId, results };
+    }
+    async markMessageProcessed(key, patch) {
+        const msg = await this.readMessage(key);
+        if (!msg) {
+            return null;
+        }
+        const updated = {
+            ...msg,
+            status: {
+                state: patch.state ?? "done",
+                processed_at: patch.processedAt ?? this.keyspace.nowMsFactory(),
+                processed_by: patch.processedBy ?? this.peerId,
+                error: patch.error ?? null,
+            },
+        };
+        await this.store.putObject(key, JSON.stringify(updated), "application/json");
+        return updated;
+    }
+    async collectInboxMessages(selfId, lastSeenKey) {
+        const head = await this.getHead(selfId);
+        if (!head?.head_key || head.head_key === lastSeenKey) {
+            return { head, messages: [], checkpointHeadKey: lastSeenKey };
+        }
+        let current = head.head_key;
+        const window = [];
+        const visitedKeys = new Set();
+        while (current && current !== lastSeenKey) {
+            if (visitedKeys.has(current)) {
+                break;
+            }
+            visitedKeys.add(current);
+            const msg = await this.readMessage(current);
+            if (!msg) {
+                break;
+            }
+            window.push({ key: current, message: msg });
+            if (window.length > 500) {
+                window.shift();
+            }
+            current = msg.prev_key ?? null;
+        }
+        window.reverse();
+        return {
+            head,
+            messages: window,
+            checkpointHeadKey: window[window.length - 1]?.key ?? lastSeenKey,
+        };
+    }
+    async sweepByKeyTimestamp(prefix, ttlDays, abortSignal) {
+        const cutoffTs = this.keyspace.nowMsFactory() - ttlDays * 24 * 60 * 60 * 1000;
+        let continuationToken;
+        let scanned = 0;
+        let deleted = 0;
+        while (!abortSignal?.aborted) {
+            const page = await this.store.listPrefixPage(prefix, continuationToken, 1000);
+            const toDelete = [];
+            for (const item of page.contents) {
+                const key = item.Key;
+                if (!key)
+                    continue;
+                scanned += 1;
+                const ts = extractTimestampFromRelayKey(key);
+                if (ts !== null && ts < cutoffTs) {
+                    toDelete.push(key);
+                }
+            }
+            if (toDelete.length > 0) {
+                await this.store.deleteObjects(toDelete);
+                deleted += toDelete.length;
+            }
+            if (!page.isTruncated || !page.nextContinuationToken) {
+                break;
+            }
+            continuationToken = page.nextContinuationToken;
+        }
+        return { prefix, scanned, deleted };
+    }
+    async sweepByLastModified(prefix, ttlDays, abortSignal) {
+        const cutoffTs = this.keyspace.nowMsFactory() - ttlDays * 24 * 60 * 60 * 1000;
+        let continuationToken;
+        let scanned = 0;
+        let deleted = 0;
+        while (!abortSignal?.aborted) {
+            const page = await this.store.listPrefixPage(prefix, continuationToken, 1000);
+            const toDelete = [];
+            for (const item of page.contents) {
+                const key = item.Key;
+                if (!key)
+                    continue;
+                scanned += 1;
+                const lastModified = item.LastModified?.getTime?.() ?? null;
+                if (lastModified !== null && lastModified < cutoffTs) {
+                    toDelete.push(key);
+                }
+            }
+            if (toDelete.length > 0) {
+                await this.store.deleteObjects(toDelete);
+                deleted += toDelete.length;
+            }
+            if (!page.isTruncated || !page.nextContinuationToken) {
+                break;
+            }
+            continuationToken = page.nextContinuationToken;
+        }
+        return { prefix, scanned, deleted };
+    }
+    async sweepRetention(ttl, abortSignal) {
+        const summaries = [];
+        if ((ttl.msg ?? 0) > 0) {
+            summaries.push(await this.sweepByKeyTimestamp("msg/", ttl.msg, abortSignal));
+        }
+        if ((ttl.att ?? 0) > 0) {
+            summaries.push(await this.sweepByKeyTimestamp("att/", ttl.att, abortSignal));
+        }
+        if ((ttl.identity ?? 0) > 0) {
+            summaries.push(await this.sweepByLastModified("identity/", ttl.identity, abortSignal));
+        }
+        if ((ttl.head ?? 0) > 0) {
+            summaries.push(await this.sweepByLastModified("head/", ttl.head, abortSignal));
+        }
+        return summaries;
+    }
+    async pollInbox(selfId, handler, pollIntervalMs = 5000, backoffMax = 40000, deleteAfterProcessing = true, abortSignal) {
+        let interval = pollIntervalMs;
+        let state = await this.checkpointStore.load();
+        while (!abortSignal?.aborted) {
+            const batch = await this.collectInboxMessages(selfId, state.lastHeadKey);
+            if (batch.messages.length > 0) {
+                for (const item of batch.messages) {
+                    if (hasSeenMessage(state, { msgId: item.message.msg_id, objectKey: item.key })) {
+                        state = { ...state, lastHeadKey: item.key };
+                        await this.checkpointStore.save(state);
+                        continue;
+                    }
+                    await handler(item.message, item.key);
+                    state = rememberMessage(state, { msgId: item.message.msg_id, objectKey: item.key, at: item.message.ts_sent });
+                    state = { ...state, lastHeadKey: item.key, lastPollAt: this.keyspace.nowMsFactory() };
+                    await this.checkpointStore.save(state);
+                    if (deleteAfterProcessing) {
+                        await this.store.deleteObject(item.key);
+                    }
+                }
+                interval = pollIntervalMs;
+                await this.sleep(interval);
+                continue;
+            }
+            state = { ...state, lastPollAt: this.keyspace.nowMsFactory() };
+            await this.checkpointStore.save(state);
+            await this.sleep(interval);
+            if (!batch.head?.head_key) {
+                interval = Math.min(interval * 2, backoffMax);
+            }
+        }
+    }
+}

package/dist/relay-core/types.d.ts

@@ -0,0 +1,220 @@
+export type AttachmentKind = "image" | "video" | "audio" | "file" | "unknown";
+export interface AttachmentRef {
+    id: string;
+    key: string;
+    file_name: string | null;
+    content_type: string | null;
+    size: number | null;
+    sha256: string | null;
+    kind: AttachmentKind;
+    width: number | null;
+    height: number | null;
+    duration_ms: number | null;
+    preview_image_key: string | null;
+    preview_image_type: string | null;
+    preview_size: number | null;
+}
+export interface RelayRoute {
+    agent_id: string;
+    conversation_id?: string | null;
+    instance_id?: string | null;
+}
+export interface RelayTextContent {
+    type: "text";
+    text: string;
+    attachments?: AttachmentRef[] | null;
+}
+export interface RelayReactionContent {
+    type: "reaction";
+    target_msg_id: string;
+    emoji: string;
+    remove?: boolean | null;
+}
+export interface RelayApprovalRequestContent {
+    type: "approval_request";
+    approval_id: string;
+    approval_kind: "exec" | "tool" | "custom";
+    title: string;
+    body?: string | null;
+    allowed_decisions: string[];
+    metadata?: Record<string, unknown> | null;
+}
+export interface RelayApprovalResponseContent {
+    type: "approval_response";
+    approval_id: string;
+    decision: string;
+    metadata?: Record<string, unknown> | null;
+}
+export interface RelaySystemContent {
+    type: "system";
+    event: string;
+    data?: Record<string, unknown> | null;
+}
+export type RelayContent = RelayTextContent | RelayReactionContent | RelayApprovalRequestContent | RelayApprovalResponseContent | RelaySystemContent;
+export interface RelayDeliveryStream {
+    stream_id: string;
+    seq: number;
+    state: "partial" | "final";
+}
+export interface RelayDelivery {
+    stream?: RelayDeliveryStream | null;
+}
+export interface RelayMessageStatus {
+    state: "pending" | "processing" | "done" | "error";
+    processed_at?: number | null;
+    processed_by?: string | null;
+    error?: string | null;
+}
+export interface RelayMessage {
+    msg_id: string;
+    from: string;
+    to: string;
+    ts_sent: number;
+    prev_key: string | null;
+    route: RelayRoute;
+    content: RelayContent;
+    delivery?: RelayDelivery | null;
+    status?: RelayMessageStatus | null;
+    size?: number | null;
+}
+export interface HeadDoc {
+    head_key: string;
+    head_msg_id: string;
+    head_ts: number;
+}
+export interface RelayCapabilities {
+    messaging: {
+        text: boolean;
+        streaming: boolean;
+        reactions: boolean;
+        system_events: boolean;
+    };
+    conversations: {
+        list: boolean;
+        create: boolean;
+        reset: boolean;
+        archive: boolean;
+        threading: boolean;
+    };
+    agents: {
+        list: boolean;
+        multiple: boolean;
+        switch: boolean;
+        per_agent_models: boolean;
+    };
+    attachments?: {
+        supported: boolean;
+        kinds: AttachmentKind[];
+        max_bytes_by_kind?: Partial<Record<AttachmentKind, number>>;
+        oversize_behavior?: "reject" | "drop" | "link" | "summarize";
+    } | null;
+    approvals?: {
+        exec: boolean;
+        tool: boolean;
+        custom: boolean;
+    } | null;
+    extensions?: Record<string, unknown> | null;
+}
+export interface ModelDescriptor {
+    id: string;
+    label?: string | null;
+    provider?: string | null;
+}
+export interface AgentDescriptor {
+    id: string;
+    display_name?: string | null;
+    description?: string | null;
+    is_default: boolean;
+    models?: {
+        available: ModelDescriptor[];
+        default?: string | null;
+    } | null;
+    default_route: RelayRoute;
+    capabilities?: Partial<RelayCapabilities> | null;
+}
+export interface ConversationSource {
+    channel: string;
+    chat_kind?: "dm" | "group" | "channel" | "thread" | null;
+    account_id?: string | null;
+    account_display?: string | null;
+    space_id?: string | null;
+    space_display?: string | null;
+    chat_id?: string | null;
+    chat_display?: string | null;
+    participant_id?: string | null;
+    participant_display?: string | null;
+    thread_id?: string | null;
+    thread_display?: string | null;
+    sharing?: "private" | "shared" | "per-user" | null;
+}
+export interface ConversationDescriptor {
+    id: string;
+    display_title?: string | null;
+    route: RelayRoute;
+    source?: ConversationSource | null;
+    updated_at?: number | null;
+}
+export interface ServerLimits {
+    inbound_attachment_max_bytes?: {
+        image: number;
+        video: number;
+        audio: number;
+        file: number;
+    } | null;
+    oversize_attachment_behavior?: string | null;
+}
+export interface IdentityDoc {
+    peer: string;
+    display_name: string;
+    role: "server" | "client";
+    last_seen: number;
+    protocol: {
+        name: "r2-relay";
+        version: number;
+    };
+    software: {
+        id: string;
+        name?: string | null;
+        version?: string | null;
+    };
+    capabilities: RelayCapabilities;
+    limits?: ServerLimits | null;
+    agents: AgentDescriptor[];
+    conversations: ConversationDescriptor[];
+}
+export interface InboxMessage {
+    key: string;
+    message: RelayMessage;
+}
+export interface InboxBatch {
+    head: HeadDoc | null;
+    messages: InboxMessage[];
+    checkpointHeadKey: string | null;
+}
+export interface SendMessageOptions {
+    route: RelayRoute;
+    content: RelayContent;
+    delivery?: RelayDelivery | null;
+}
+export interface SendMessageResult {
+    key: string;
+    messageId: string;
+}
+export interface RelayRetentionConfig {
+    msg?: number;
+    att?: number;
+    identity?: number;
+    head?: number;
+}
+export interface SweepRuleSummary {
+    prefix: string;
+    scanned: number;
+    deleted: number;
+}
+export interface RelayCheckpointState {
+    lastHeadKey: string | null;
+    recentMessageIds: string[];
+    recentObjectKeys: string[];
+    lastPollAt: number | null;
+    lastInboundAt: number | null;
+}

package/dist/relay-core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk/plugin-runtime";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+declare const setRelayRuntime: (next: PluginRuntime) => void, getRelayRuntime: () => PluginRuntime;
+declare function setRelayConfig(cfg: OpenClawConfig): void;
+declare function getRelayConfig(): OpenClawConfig;
+declare function setRelayStateDir(stateDir: string): void;
+declare function resolvePluginStateDir(): string;
+declare function getPersistedRelayServerId(): string;
+export { getPersistedRelayServerId, getRelayConfig, getRelayRuntime, resolvePluginStateDir, setRelayConfig, setRelayRuntime, setRelayStateDir };