@clawhive/openclaw-plugin 0.2.1 → 0.2.3

package/dist/index.js

@@ -151,6 +151,18 @@ async function startRuntime(api) {
         pluginNodeId,
         userId: resolvedUserId,
         onWake: (event) => {
+            if (event.taskType === "single_agent_message") {
+                const sessionId = typeof event.payload.sessionId === "string"
+                    ? event.payload.sessionId
+                    : null;
+                if (sessionId) {
+                    const sequence = typeof event.payload.sequence === "number"
+                        ? event.payload.sequence
+                        : 1;
+                    void transport.catchUpSession(sessionId, Math.max(sequence - 1, 0));
+                }
+                return;
+            }
             if (event.taskType === "agent_panel_turn") {
                 agentPanelLoop.wake();
                 return;
@@ -304,8 +316,10 @@ const clawhiveEntry = defineChannelPluginEntry({
     name: "ClawHive",
     description: "ClawHive channel plugin",
     plugin: clawhiveChannelPlugin,
-    registerFull(api) {
+    registerCliMetadata(api) {
         registerClawHiveCli(api);
+    },
+    registerFull(api) {
         api.on("gateway_start", async () => {
             try {
                 await startRuntime(api);

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

@@ -28,15 +28,19 @@ export declare class RealtimeTransport implements TransportAdapter {
     private reconnectTimer;
     private session;
     private readonly sessionHighWaterMark;
+    private readonly inFlightMessageSequences;
     constructor(options: RealtimeTransportOptions);
     getStatus(): TransportStatus;
     getClient(): SupabaseClient;
     start(handlers: TransportHandlers): Promise<void>;
     stop(): Promise<void>;
     private connect;
-    private handleRow;
+    private handleMessageBroadcast;
     private dispatchInbound;
-    private catchUpSession;
+    catchUpSession(sessionId: string, afterSequence: number, beforeSequence?: number): Promise<void>;
+    recoverPendingUserMessages(): Promise<void>;
+    private recoverPendingSessionMessages;
+    private dispatchUserMessageOnce;
     private ensureFreshSession;
     /**
      * Recover from an invalidated refresh token by re-registering the plugin node.

package/dist/src/transport/realtime.js

@@ -3,6 +3,8 @@ import WebSocket from "ws";
 import { inboundMessageFromRow, } from "../transport.js";
 import { addPluginBreadcrumb, capturePluginError } from "../telemetry.js";
 const DEFAULT_MAX_BACKOFF_MS = 30_000;
+const PENDING_SESSION_RECOVERY_LIMIT = 25;
+const PENDING_MESSAGE_LOOKBACK_LIMIT = 50;
 const NodeWebSocketTransport = WebSocket;
 export class RealtimeTransport {
     id = "clawhive-realtime";
@@ -16,6 +18,7 @@ export class RealtimeTransport {
     reconnectTimer = null;
     session;
     sessionHighWaterMark = new Map();
+    inFlightMessageSequences = new Set();
     constructor(options) {
         this.options = options;
         this.session = options.userSession;
@@ -79,14 +82,11 @@ export class RealtimeTransport {
         });
         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);
+            .channel(`user:${this.options.userId}`, {
+            config: { private: true },
+        })
+            .on("broadcast", { event: "message_insert" }, (payload) => {
+            void this.handleMessageBroadcast(payload);
         });
         this.channel = channel;
         await new Promise((resolve, reject) => {
@@ -98,6 +98,7 @@ export class RealtimeTransport {
                     void (async () => {
                         try {
                             await this.options.onClientReady?.(this.getClient());
+                            await this.recoverPendingUserMessages();
                         }
                         catch (error) {
                             reject(error);
@@ -138,20 +139,23 @@ export class RealtimeTransport {
             });
         });
     }
-    async handleRow(row) {
+    async handleMessageBroadcast(envelope) {
         if (!this.handlers)
             return;
-        if (row.role !== "user")
+        const messageRef = parseMessageBroadcastPayload(envelope);
+        if (!messageRef)
             return;
-        const previousSequence = this.sessionHighWaterMark.get(row.session_id) ?? 0;
-        if (row.sequence <= previousSequence)
+        if (messageRef.userId !== this.options.userId)
             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);
+        if (messageRef.role !== "user")
+            return;
+        const previousSequence = this.sessionHighWaterMark.get(messageRef.sessionId) ?? 0;
+        if (messageRef.sequence <= previousSequence)
+            return;
+        const afterSequence = previousSequence > 0
+            ? previousSequence
+            : Math.max(0, messageRef.sequence - 1);
+        await this.catchUpSession(messageRef.sessionId, afterSequence);
     }
     async dispatchInbound(message) {
         try {
@@ -178,8 +182,7 @@ export class RealtimeTransport {
                     continue;
                 if (item.role !== "user")
                     continue;
-                await this.dispatchInbound(inboundMessageFromRow(item));
-                this.sessionHighWaterMark.set(item.session_id, item.sequence);
+                await this.dispatchUserMessageOnce(item);
             }
         }
         catch (error) {
@@ -188,6 +191,73 @@ export class RealtimeTransport {
             capturePluginError(error, "realtime-catch-up");
         }
     }
+    async recoverPendingUserMessages() {
+        if (!this.client || !this.handlers)
+            return;
+        try {
+            const { data: sessions, error } = await this.client
+                .from("sessions")
+                .select("id")
+                .eq("user_id", this.options.userId)
+                .eq("session_type", "single_agent")
+                .is("archived_at", null)
+                .order("last_message_at", { ascending: false, nullsFirst: false })
+                .limit(PENDING_SESSION_RECOVERY_LIMIT);
+            if (error) {
+                throw error;
+            }
+            for (const session of sessions ?? []) {
+                if (!isRecord(session) || typeof session.id !== "string") {
+                    continue;
+                }
+                await this.recoverPendingSessionMessages(session.id);
+            }
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.options.logger?.warn(`ClawHive realtime pending-message recovery failed: ${reason}`);
+            capturePluginError(error, "realtime-pending-message-recovery");
+        }
+    }
+    async recoverPendingSessionMessages(sessionId) {
+        if (!this.client || !this.handlers)
+            return;
+        const { data, error } = await this.client
+            .from("messages")
+            .select("id, session_id, agent_id, user_id, sequence, client_message_id, role, type, content, metadata, created_at")
+            .eq("session_id", sessionId)
+            .order("sequence", { ascending: false })
+            .limit(PENDING_MESSAGE_LOOKBACK_LIMIT);
+        if (error) {
+            throw error;
+        }
+        const rows = (data ?? [])
+            .filter(isAppendedMessage)
+            .reverse();
+        let lastNonUserIndex = -1;
+        for (let index = 0; index < rows.length; index += 1) {
+            if (rows[index].role !== "user") {
+                lastNonUserIndex = index;
+            }
+        }
+        const pendingUserMessages = rows.slice(lastNonUserIndex + 1)
+            .filter((row) => row.role === "user");
+        for (const item of pendingUserMessages) {
+            await this.dispatchUserMessageOnce(item);
+        }
+    }
+    async dispatchUserMessageOnce(item) {
+        const currentHighWater = this.sessionHighWaterMark.get(item.session_id) ?? 0;
+        if (item.sequence <= currentHighWater)
+            return;
+        const inFlightKey = `${item.session_id}:${item.sequence}`;
+        if (this.inFlightMessageSequences.has(inFlightKey))
+            return;
+        this.inFlightMessageSequences.add(inFlightKey);
+        await this.dispatchInbound(inboundMessageFromRow(item));
+        this.inFlightMessageSequences.delete(inFlightKey);
+        this.sessionHighWaterMark.set(item.session_id, Math.max(this.sessionHighWaterMark.get(item.session_id) ?? 0, item.sequence));
+    }
     async ensureFreshSession() {
         const expiresAt = this.session.expires_at;
         const nowSec = Math.floor(Date.now() / 1000);
@@ -271,3 +341,43 @@ export class RealtimeTransport {
         this.handlers?.onStatusChange?.(status);
     }
 }
+function parseMessageBroadcastPayload(envelope) {
+    if (!isRecord(envelope)) {
+        return null;
+    }
+    const payload = envelope.payload;
+    if (!isRecord(payload)) {
+        return null;
+    }
+    const { messageId, sessionId, userId, sequence, role, createdAt } = payload;
+    if (typeof messageId !== "string" ||
+        typeof sessionId !== "string" ||
+        typeof userId !== "string" ||
+        typeof sequence !== "number" ||
+        typeof role !== "string" ||
+        typeof createdAt !== "string" ||
+        !isMessageRole(role)) {
+        return null;
+    }
+    return { messageId, sessionId, userId, sequence, role, createdAt };
+}
+function isMessageRole(role) {
+    return role === "user" || role === "agent" || role === "system";
+}
+function isAppendedMessage(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (typeof value.id === "string" &&
+        typeof value.session_id === "string" &&
+        typeof value.agent_id === "string" &&
+        typeof value.user_id === "string" &&
+        typeof value.sequence === "number" &&
+        typeof value.role === "string" &&
+        typeof value.type === "string" &&
+        typeof value.content === "string" &&
+        typeof value.created_at === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/src/wake.d.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-export type PluginWakeTaskType = "agent_panel_turn" | "market_install" | "agency_install";
+export type PluginWakeTaskType = "single_agent_message" | "agent_panel_turn" | "market_install" | "agency_install";
 export type PluginWakeEvent = {
     id: string;
     payload: Record<string, unknown>;

package/dist/src/wake.js

@@ -1,4 +1,5 @@
 const VALID_TASK_TYPES = new Set([
+    "single_agent_message",
     "agent_panel_turn",
     "market_install",
     "agency_install",
@@ -16,14 +17,11 @@ export class PluginWakeSubscription {
             return this.startPromise;
         }
         const channel = this.options.client
-            .channel(`plugin-wake:${this.options.pluginNodeId}`)
-            .on("postgres_changes", {
-            event: "INSERT",
-            schema: "public",
-            table: "plugin_wake_events",
-            filter: `plugin_node_id=eq.${this.options.pluginNodeId}`,
-        }, (payload) => {
-            this.handleWakeRow(payload.new);
+            .channel(`plugin-wake:${this.options.pluginNodeId}`, {
+            config: { private: true },
+        })
+            .on("broadcast", { event: "wake" }, (payload) => {
+            this.handleWakeRow(payload.payload);
         });
         this.channel = channel;
         this.startPromise = new Promise((resolve) => {
@@ -64,13 +62,13 @@ export class PluginWakeSubscription {
         if (!isRecord(row)) {
             return;
         }
-        const taskType = row.task_type;
+        const taskType = readString(row, "taskType", "task_type");
         if (typeof taskType !== "string" || !VALID_TASK_TYPES.has(taskType)) {
             return;
         }
-        const taskId = row.task_id;
-        const pluginNodeId = row.plugin_node_id;
-        const userId = row.user_id;
+        const taskId = readString(row, "taskId", "task_id");
+        const pluginNodeId = readString(row, "pluginNodeId", "plugin_node_id");
+        const userId = readString(row, "userId", "user_id");
         if (!isNonEmptyString(taskId) || !isNonEmptyString(pluginNodeId) || !isNonEmptyString(userId)) {
             return;
         }
@@ -99,3 +97,6 @@ function isPlainObject(value) {
 function isNonEmptyString(value) {
     return typeof value === "string" && value.length > 0;
 }
+function readString(row, camelCaseKey, snakeCaseKey) {
+    return row[camelCaseKey] ?? row[snakeCaseKey];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawhive/openclaw-plugin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "ClawHive channel plugin for OpenClaw",
   "license": "UNLICENSED",
   "homepage": "https://github.com/optimalAIs/clawhive#readme",