@clawhive/openclaw-plugin 0.2.0

package/dist/src/pairing.js

@@ -0,0 +1,64 @@
+import qrcodeTerminal from "qrcode-terminal";
+import { createClient } from "@supabase/supabase-js";
+function buildPayloadUrl(projectUrl, pairToken) {
+    const params = new URLSearchParams({
+        token: pairToken,
+        project: projectUrl.replace(/\/$/, ""),
+    });
+    return `clawhive://pair?${params.toString()}`;
+}
+function shortCodeFromToken(token) {
+    // First 8 hex/alphanumeric chars, uppercased — easy to dictate over voice if scanning fails.
+    return token.replace(/[^0-9a-zA-Z]/g, "").slice(0, 8).toUpperCase();
+}
+export async function generatePairingPayload(api, pluginNodeId, ttlSeconds = 300) {
+    const result = await api.createPairingCode(pluginNodeId, ttlSeconds);
+    return {
+        pairToken: result.pair_token,
+        expiresAt: result.expires_at,
+        payloadUrl: buildPayloadUrl(api.baseUrl, result.pair_token),
+    };
+}
+export async function renderQrText(payloadUrl) {
+    return await new Promise((resolve) => {
+        qrcodeTerminal.generate(payloadUrl, { small: true }, (qr) => resolve(qr));
+    });
+}
+export async function printPairingQr(options) {
+    const payload = await generatePairingPayload(options.api, options.pluginNodeId, options.ttlSeconds ?? 300);
+    const qrText = await renderQrText(payload.payloadUrl);
+    const lines = [
+        options.banner ?? "ClawHive: scan this QR with the ClawHive mobile app to pair.",
+        qrText,
+        `URL:        ${payload.payloadUrl}`,
+        `Short code: ${shortCodeFromToken(payload.pairToken)}`,
+        `Expires:    ${payload.expiresAt}`,
+    ];
+    for (const line of lines) {
+        (options.ascii ?? ((text) => process.stdout.write(text + "\n")))(line);
+    }
+    return { ...payload, qrText };
+}
+/**
+ * Return the number of active paired devices for the current user.
+ * Uses the user-scoped session minted by plugin-register so the query
+ * passes RLS without bringing service-role credentials into the plugin.
+ */
+export async function getPairedDeviceCount(params) {
+    const client = createClient(params.projectUrl, params.anonKey, {
+        auth: { autoRefreshToken: false, persistSession: false },
+        global: {
+            headers: {
+                Authorization: `Bearer ${params.registration.user_session.access_token}`,
+            },
+        },
+    });
+    const { count, error } = await client
+        .from("devices")
+        .select("id", { count: "exact", head: true })
+        .eq("is_active", true);
+    if (error) {
+        throw new Error(`Failed to check paired devices: ${error.message}`);
+    }
+    return count ?? 0;
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,52 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { ClawHiveCloudApi } from "./client.js";
+import type { AgentPanelClaimLoop } from "./agent-panel/claimLoop.js";
+import type { AgencyInstallClaimLoop } from "./agency-install/claimLoop.js";
+import type { AgentSyncLoop } from "./agents.js";
+import type { HeartbeatLoop } from "./heartbeat.js";
+import type { InstallClaimLoop } from "./market-install/claimLoop.js";
+import type { ActiveInstallJobState } from "./market-install/types.js";
+import type { TransportAdapter } from "./transport.js";
+import type { PluginWakeSubscription } from "./wake.js";
+export type SessionBinding = {
+    sessionId: string;
+    cloudAgentId: string;
+    localAgentId: string;
+    userId: string;
+    sessionKey: string;
+    lastSeenSequence: number;
+};
+export type ClawHiveRuntime = {
+    api: ClawHiveCloudApi;
+    transport: TransportAdapter;
+    heartbeat: HeartbeatLoop;
+    agentSyncLoop: AgentSyncLoop;
+    agentPanelLoop: AgentPanelClaimLoop;
+    installLoop: InstallClaimLoop;
+    agencyInstallLoop: AgencyInstallClaimLoop;
+    wakeSubscription: PluginWakeSubscription | null;
+    pluginNodeId: string;
+    userId: string;
+    pluginApi: OpenClawPluginApi;
+    sessionIndex: Map<string, SessionBinding>;
+    agentIndex: Map<string, string>;
+    activeInstall: ActiveInstallJobState | null;
+};
+export declare const clawhiveRuntimeStore: {
+    setRuntime: (next: ClawHiveRuntime) => void;
+    clearRuntime: () => void;
+    tryGetRuntime: () => ClawHiveRuntime | null;
+    getRuntime: () => ClawHiveRuntime;
+};
+export declare function indexSession(runtime: ClawHiveRuntime, binding: SessionBinding): void;
+export declare function lookupSession(runtime: ClawHiveRuntime, key: string): SessionBinding | undefined;
+export declare function buildClawHiveSessionKey(sessionId: string): string;
+export declare function indexSyncedAgents(runtime: ClawHiveRuntime, items: Array<{
+    id: string;
+    openclaw_agent_id: string;
+}>): void;
+export declare function resolveLocalAgentId(runtime: ClawHiveRuntime, cloudAgentId: string): string | null;
+/**
+ * Track the currently executing market install job inside the shared runtime store.
+ */
+export declare function setActiveInstall(runtime: ClawHiveRuntime, activeInstall: ActiveInstallJobState | null): void;

package/dist/src/runtime.js

@@ -0,0 +1,26 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+export const clawhiveRuntimeStore = createPluginRuntimeStore("ClawHive plugin runtime has not been initialized.");
+export function indexSession(runtime, binding) {
+    runtime.sessionIndex.set(binding.sessionId, binding);
+    runtime.sessionIndex.set(binding.sessionKey, binding);
+}
+export function lookupSession(runtime, key) {
+    return runtime.sessionIndex.get(key);
+}
+export function buildClawHiveSessionKey(sessionId) {
+    return `clawhive:default:${sessionId}`;
+}
+export function indexSyncedAgents(runtime, items) {
+    for (const item of items) {
+        runtime.agentIndex.set(item.id, item.openclaw_agent_id);
+    }
+}
+export function resolveLocalAgentId(runtime, cloudAgentId) {
+    return runtime.agentIndex.get(cloudAgentId) ?? null;
+}
+/**
+ * Track the currently executing market install job inside the shared runtime store.
+ */
+export function setActiveInstall(runtime, activeInstall) {
+    runtime.activeInstall = activeInstall;
+}

package/dist/src/telemetry.d.ts

@@ -0,0 +1,34 @@
+import type { MarketInstallClaimedJob, MarketInstallReasonKind } from "./market-install/types.js";
+/**
+ * Initialize plugin telemetry from environment variables without breaking local boot.
+ */
+export declare function initPluginTelemetry(): void;
+/**
+ * Add a plugin breadcrumb for runtime and reconnect lifecycle events.
+ */
+export declare function addPluginBreadcrumb(input: {
+    category: string;
+    message: string;
+    data?: Record<string, unknown>;
+}): void;
+/**
+ * Capture plugin exceptions with a stable runtime tag.
+ */
+export declare function capturePluginError(error: unknown, area: string): void;
+/**
+ * Add an install-specific breadcrumb so claim/execution failures are visible in telemetry.
+ */
+export declare function addInstallBreadcrumb(input: {
+    stage: string;
+    job: Pick<MarketInstallClaimedJob, "jobId" | "listingId" | "releaseId" | "targetNodeId" | "version">;
+    reasonKind?: MarketInstallReasonKind;
+    data?: Record<string, unknown>;
+}): void;
+/**
+ * Capture install failures with stable market-install tags for triage.
+ */
+export declare function captureInstallFailure(input: {
+    error: unknown;
+    reasonKind: MarketInstallReasonKind;
+    job: Pick<MarketInstallClaimedJob, "jobId" | "listingId" | "releaseId" | "targetNodeId" | "version">;
+}): void;

package/dist/src/telemetry.js

@@ -0,0 +1,89 @@
+import * as Sentry from "@sentry/node";
+let initialized = false;
+function resolvePluginRelease() {
+    return process.env.SENTRY_RELEASE_PLUGIN ?? process.env.SENTRY_RELEASE;
+}
+/**
+ * Initialize plugin telemetry from environment variables without breaking local boot.
+ */
+export function initPluginTelemetry() {
+    const dsn = process.env.SENTRY_DSN_PLUGIN;
+    if (!dsn || initialized) {
+        return;
+    }
+    Sentry.init({
+        dsn,
+        environment: process.env.SENTRY_ENVIRONMENT ?? "development",
+        release: resolvePluginRelease(),
+        tracesSampleRate: 0,
+    });
+    initialized = true;
+}
+/**
+ * Add a plugin breadcrumb for runtime and reconnect lifecycle events.
+ */
+export function addPluginBreadcrumb(input) {
+    if (!initialized) {
+        return;
+    }
+    Sentry.addBreadcrumb({
+        category: input.category,
+        message: input.message,
+        data: input.data,
+        level: "info",
+    });
+}
+/**
+ * Capture plugin exceptions with a stable runtime tag.
+ */
+export function capturePluginError(error, area) {
+    if (!initialized) {
+        return;
+    }
+    Sentry.captureException(error, {
+        tags: {
+            area,
+            runtime: "plugin",
+        },
+    });
+}
+/**
+ * Add an install-specific breadcrumb so claim/execution failures are visible in telemetry.
+ */
+export function addInstallBreadcrumb(input) {
+    addPluginBreadcrumb({
+        category: "market-install",
+        message: `install.${input.stage}`,
+        data: {
+            jobId: input.job.jobId,
+            listingId: input.job.listingId,
+            releaseId: input.job.releaseId,
+            targetNodeId: input.job.targetNodeId,
+            version: input.job.version,
+            reasonKind: input.reasonKind ?? null,
+            ...(input.data ?? {}),
+        },
+    });
+}
+/**
+ * Capture install failures with stable market-install tags for triage.
+ */
+export function captureInstallFailure(input) {
+    if (!initialized) {
+        return;
+    }
+    Sentry.captureException(input.error, {
+        tags: {
+            area: "market-install",
+            runtime: "plugin",
+            reasonKind: input.reasonKind,
+        },
+        extra: {
+            jobId: input.job.jobId,
+            listingId: input.job.listingId,
+            releaseId: input.job.releaseId,
+            targetNodeId: input.job.targetNodeId,
+            version: input.job.version,
+        },
+    });
+}

package/dist/src/transport/realtime.d.ts

@@ -0,0 +1,49 @@
+import { type SupabaseClient } from "@supabase/supabase-js";
+import type { ClawHiveCloudApi, UserSession } from "../client.js";
+import { type TransportAdapter, type TransportHandlers, type TransportStatus } from "../transport.js";
+export type RealtimeTransportLogger = {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+export type RealtimeTransportOptions = {
+    api: ClawHiveCloudApi;
+    anonKey: string;
+    userSession: UserSession;
+    userId: string;
+    logger?: RealtimeTransportLogger;
+    onClientReady?: (client: SupabaseClient) => Promise<void> | void;
+    /** Max backoff between reconnect attempts. Default 30000ms. */
+    maxBackoffMs?: number;
+};
+export declare class RealtimeTransport implements TransportAdapter {
+    readonly id = "clawhive-realtime";
+    private readonly options;
+    private client;
+    private channel;
+    private handlers;
+    private status;
+    private stopRequested;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private session;
+    private readonly sessionHighWaterMark;
+    constructor(options: RealtimeTransportOptions);
+    getStatus(): TransportStatus;
+    getClient(): SupabaseClient;
+    start(handlers: TransportHandlers): Promise<void>;
+    stop(): Promise<void>;
+    private connect;
+    private handleRow;
+    private dispatchInbound;
+    private catchUpSession;
+    private ensureFreshSession;
+    /**
+     * Recover from an invalidated refresh token by re-registering the plugin node.
+     */
+    private recoverSessionAfterRefreshFailure;
+    private scheduleReconnect;
+    private reconnect;
+    private detachChannel;
+    private setStatus;
+}

package/dist/src/transport/realtime.js

@@ -0,0 +1,273 @@
+import { createClient, } from "@supabase/supabase-js";
+import WebSocket from "ws";
+import { inboundMessageFromRow, } from "../transport.js";
+import { addPluginBreadcrumb, capturePluginError } from "../telemetry.js";
+const DEFAULT_MAX_BACKOFF_MS = 30_000;
+const NodeWebSocketTransport = WebSocket;
+export class RealtimeTransport {
+    id = "clawhive-realtime";
+    options;
+    client = null;
+    channel = null;
+    handlers = null;
+    status = { state: "idle" };
+    stopRequested = false;
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    session;
+    sessionHighWaterMark = new Map();
+    constructor(options) {
+        this.options = options;
+        this.session = options.userSession;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getClient() {
+        if (!this.client) {
+            throw new Error("RealtimeTransport client is not initialized.");
+        }
+        return this.client;
+    }
+    async start(handlers) {
+        if (this.handlers) {
+            throw new Error("RealtimeTransport already started");
+        }
+        this.handlers = handlers;
+        this.stopRequested = false;
+        await this.connect();
+    }
+    async stop() {
+        this.stopRequested = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        await this.detachChannel();
+        this.client?.realtime.disconnect();
+        this.client = null;
+        this.setStatus({ state: "idle" });
+    }
+    async connect() {
+        this.setStatus({ state: "connecting" });
+        // Provide the user session through the official accessToken callback so
+        // Realtime can rehydrate auth consistently across socket reconnects.
+        this.client = createClient(this.options.api.baseUrl, this.options.anonKey, {
+            auth: {
+                persistSession: false,
+                autoRefreshToken: false,
+            },
+            accessToken: async () => this.session.access_token,
+            realtime: {
+                // Force a stable Node WebSocket implementation so hosted wss
+                // connections do not depend on the OpenClaw host runtime globals.
+                transport: NodeWebSocketTransport,
+                params: { eventsPerSecond: 10 },
+                worker: false,
+                logger: (kind, msg, data) => {
+                    if (kind !== "error") {
+                        return;
+                    }
+                    const details = data === undefined
+                        ? ""
+                        : typeof data === "string"
+                            ? data
+                            : JSON.stringify(data);
+                    this.options.logger?.warn(`ClawHive realtime client error msg=${msg}${details ? ` details=${details}` : ""}`);
+                },
+            },
+        });
+        await this.client.realtime.setAuth(this.session.access_token);
+        const channel = this.client
+            .channel(`plugin:clawhive:${this.options.userId}`)
+            .on("postgres_changes", {
+            event: "INSERT",
+            schema: "public",
+            table: "messages",
+            filter: `user_id=eq.${this.options.userId}`,
+        }, (payload) => {
+            void this.handleRow(payload.new);
+        });
+        this.channel = channel;
+        await new Promise((resolve, reject) => {
+            channel.subscribe((status, channelError) => {
+                if (channel !== this.channel) {
+                    return;
+                }
+                if (status === "SUBSCRIBED") {
+                    void (async () => {
+                        try {
+                            await this.options.onClientReady?.(this.getClient());
+                        }
+                        catch (error) {
+                            reject(error);
+                            return;
+                        }
+                        this.reconnectAttempts = 0;
+                        this.setStatus({ state: "ready" });
+                        this.options.logger?.info(`ClawHive realtime subscribed user=${this.options.userId} tokenExpiresAt=${this.session.expires_at ?? "unknown"}`);
+                        addPluginBreadcrumb({
+                            category: "realtime",
+                            message: "subscription.subscribed",
+                            data: { userId: this.options.userId },
+                        });
+                        resolve();
+                    })();
+                }
+                else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
+                    const error = new Error(`Realtime subscription failed: ${status}`);
+                    this.setStatus({ state: "disconnected", reason: status });
+                    const details = channelError && typeof channelError === "object"
+                        ? JSON.stringify(channelError)
+                        : String(channelError ?? "");
+                    this.options.logger?.warn(`ClawHive realtime subscription status=${status} user=${this.options.userId} tokenExpiresAt=${this.session.expires_at ?? "unknown"} details=${details}`);
+                    capturePluginError(error, "realtime-subscribe");
+                    reject(error);
+                    this.scheduleReconnect();
+                }
+                else if (status === "CLOSED" && !this.stopRequested) {
+                    this.setStatus({ state: "disconnected", reason: "CLOSED" });
+                    this.options.logger?.warn(`ClawHive realtime subscription closed user=${this.options.userId} tokenExpiresAt=${this.session.expires_at ?? "unknown"}`);
+                    addPluginBreadcrumb({
+                        category: "realtime",
+                        message: "subscription.closed",
+                        data: { userId: this.options.userId },
+                    });
+                    this.scheduleReconnect();
+                }
+            });
+        });
+    }
+    async handleRow(row) {
+        if (!this.handlers)
+            return;
+        if (row.role !== "user")
+            return;
+        const previousSequence = this.sessionHighWaterMark.get(row.session_id) ?? 0;
+        if (row.sequence <= previousSequence)
+            return;
+        const gap = row.sequence - previousSequence;
+        if (previousSequence > 0 && gap > 1) {
+            await this.catchUpSession(row.session_id, previousSequence, row.sequence);
+        }
+        await this.dispatchInbound(inboundMessageFromRow(row));
+        this.sessionHighWaterMark.set(row.session_id, row.sequence);
+    }
+    async dispatchInbound(message) {
+        try {
+            await this.handlers.onInboundMessage(message);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.options.logger?.error(`ClawHive realtime inbound dispatch failed session=${message.sessionId} msg=${message.id}: ${reason}`);
+        }
+    }
+    async catchUpSession(sessionId, afterSequence, beforeSequence) {
+        try {
+            const session = await this.ensureFreshSession();
+            const result = await this.options.api.syncMessages({
+                accessToken: session.access_token,
+                sessionId,
+                afterSequence,
+                limit: 100,
+            });
+            for (const item of result.items) {
+                // Skip the current realtime row during gap recovery so the plugin
+                // does not dispatch the same inbound user message twice.
+                if (beforeSequence && item.sequence >= beforeSequence)
+                    continue;
+                if (item.role !== "user")
+                    continue;
+                await this.dispatchInbound(inboundMessageFromRow(item));
+                this.sessionHighWaterMark.set(item.session_id, item.sequence);
+            }
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.options.logger?.warn(`ClawHive realtime catch-up failed session=${sessionId}: ${reason}`);
+            capturePluginError(error, "realtime-catch-up");
+        }
+    }
+    async ensureFreshSession() {
+        const expiresAt = this.session.expires_at;
+        const nowSec = Math.floor(Date.now() / 1000);
+        if (expiresAt && expiresAt - nowSec > 30) {
+            return this.session;
+        }
+        try {
+            const refreshed = await this.options.api.refreshUserSession(this.session.refresh_token);
+            this.options.logger?.info(`ClawHive realtime refreshed session oldExpiresAt=${expiresAt ?? "unknown"} newExpiresAt=${refreshed.expires_at ?? "unknown"}`);
+            this.session = refreshed;
+            if (this.client) {
+                await this.client.realtime.setAuth(refreshed.access_token);
+            }
+            return refreshed;
+        }
+        catch (error) {
+            return this.recoverSessionAfterRefreshFailure(error);
+        }
+    }
+    /**
+     * Recover from an invalidated refresh token by re-registering the plugin node.
+     */
+    async recoverSessionAfterRefreshFailure(cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        this.options.logger?.warn(`ClawHive realtime refresh failed; attempting plugin-register recovery: ${reason}`);
+        const registration = await this.options.api.registerPluginNode();
+        const recovered = registration.user_session;
+        this.options.logger?.info(`ClawHive realtime recovered session via plugin-register newExpiresAt=${recovered.expires_at ?? "unknown"}`);
+        this.session = recovered;
+        if (this.client) {
+            await this.client.realtime.setAuth(recovered.access_token);
+        }
+        return recovered;
+    }
+    scheduleReconnect() {
+        if (this.stopRequested)
+            return;
+        if (this.reconnectTimer)
+            return;
+        this.reconnectAttempts += 1;
+        const base = Math.min(1000 * 2 ** (this.reconnectAttempts - 1), this.options.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS);
+        const jitter = Math.floor(Math.random() * 500);
+        const delay = base + jitter;
+        this.options.logger?.info(`ClawHive realtime reconnect scheduled attempt=${this.reconnectAttempts} delay=${delay}ms`);
+        addPluginBreadcrumb({
+            category: "realtime",
+            message: "reconnect.scheduled",
+            data: { attempt: this.reconnectAttempts, delay },
+        });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.reconnect();
+        }, delay);
+    }
+    async reconnect() {
+        if (this.stopRequested)
+            return;
+        await this.detachChannel();
+        this.client?.realtime.disconnect();
+        this.client = null;
+        try {
+            await this.ensureFreshSession();
+            await this.connect();
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.options.logger?.warn(`ClawHive realtime reconnect failed: ${reason}`);
+            capturePluginError(error, "realtime-reconnect");
+            this.scheduleReconnect();
+        }
+    }
+    async detachChannel() {
+        const channel = this.channel;
+        this.channel = null;
+        if (channel && this.client) {
+            await this.client.removeChannel(channel);
+        }
+    }
+    setStatus(status) {
+        this.status = status;
+        this.handlers?.onStatusChange?.(status);
+    }
+}

package/dist/src/transport.d.ts

@@ -0,0 +1,38 @@
+import type { AppendedMessage } from "./client.js";
+export type InboundMessage = {
+    id: string;
+    sessionId: string;
+    agentId: string;
+    userId: string;
+    sequence: number;
+    role: "user" | "agent" | "system";
+    type: string;
+    content: string;
+    clientMessageId?: string | null;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+};
+export declare function inboundMessageFromRow(row: AppendedMessage): InboundMessage;
+export type TransportStatus = {
+    state: "idle";
+} | {
+    state: "connecting";
+} | {
+    state: "ready";
+} | {
+    state: "disconnected";
+    reason?: string;
+} | {
+    state: "error";
+    error: unknown;
+};
+export type TransportHandlers = {
+    onInboundMessage: (message: InboundMessage) => Promise<void> | void;
+    onStatusChange?: (status: TransportStatus) => void;
+};
+export type TransportAdapter = {
+    readonly id: string;
+    start(handlers: TransportHandlers): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): TransportStatus;
+};

package/dist/src/transport.js

@@ -0,0 +1,15 @@
+export function inboundMessageFromRow(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        agentId: row.agent_id,
+        userId: row.user_id,
+        sequence: row.sequence,
+        role: row.role,
+        type: row.type,
+        content: row.content,
+        clientMessageId: row.client_message_id ?? null,
+        createdAt: row.created_at,
+        metadata: row.metadata ?? {},
+    };
+}

package/dist/src/wake.d.ts

@@ -0,0 +1,31 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export type PluginWakeTaskType = "agent_panel_turn" | "market_install" | "agency_install";
+export type PluginWakeEvent = {
+    id: string;
+    payload: Record<string, unknown>;
+    pluginNodeId: string;
+    taskId: string;
+    taskType: PluginWakeTaskType;
+    userId: string;
+};
+export type PluginWakeSubscriptionLogger = {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+};
+export type PluginWakeSubscriptionOptions = {
+    client: Pick<SupabaseClient, "channel" | "removeChannel">;
+    logger?: PluginWakeSubscriptionLogger;
+    pluginNodeId: string;
+    userId: string;
+    onWake: (event: PluginWakeEvent) => void;
+};
+export declare class PluginWakeSubscription {
+    private readonly options;
+    private channel;
+    private startResolve;
+    private startPromise;
+    constructor(options: PluginWakeSubscriptionOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleWakeRow;
+}