@clawhive/openclaw-plugin 0.2.2 → 0.2.4

package/dist/src/authorization.js

@@ -94,7 +94,8 @@ export async function authorizeClawHivePlugin(api, deps = {}) {
     const { account, cloudApi } = (deps.createCloudApi ?? createClawHiveCloudApi)(api);
     if (cloudApi.pluginToken) {
         try {
-            await cloudApi.registerPluginNode();
+            const registration = await cloudApi.registerPluginNode();
+            await syncRegistrationIdentity(api, { account, registration });
             api.logger.info("ClawHive is already authorized. Restart the gateway if you are waiting for it to connect.");
             return;
         }
@@ -118,13 +119,19 @@ export async function authorizeClawHivePlugin(api, deps = {}) {
             start,
             logger: api.logger,
         });
+        cloudApi.setAuthorizationIdentity({
+            pluginToken: approval.plugin_token,
+            userId: approval.user_id,
+        });
+        const registration = await cloudApi.registerPluginNode();
         const latestCfg = api.runtime.config.loadConfig();
         await api.runtime.config.writeConfigFile(writeRegistrationIdentity(latestCfg, {
             anonKey: account.anonKey,
             pluginToken: approval.plugin_token,
-            userId: approval.user_id,
+            userId: registration.user_id,
+            pluginNodeId: registration.plugin_node.id,
         }));
-        api.logger.info("ClawHive authorization completed. Restart the gateway to finish plugin registration.");
+        api.logger.info("ClawHive authorization completed and plugin node registered. Restart the gateway if you are waiting for it to connect.");
     }
     catch (error) {
         if (error instanceof DeviceCodeDeniedError) {

package/dist/src/client.d.ts

@@ -47,6 +47,7 @@ export type PluginNode = {
     node_name?: string | null;
     plugin_version?: string | null;
     plugin_status: "online" | "offline" | "degraded";
+    runtime_type?: "openclaw" | "hermes";
     last_heartbeat_at?: string | null;
 };
 export type PluginRegisterResult = {
@@ -77,11 +78,13 @@ export type SyncAgentInput = {
 export type SyncedAgent = {
     id: string;
     user_id: string;
+    plugin_node_id?: string | null;
+    runtime_type: "openclaw" | "hermes";
+    runtime_agent_id: string;
     openclaw_agent_id: string;
     name: string;
     description: string | null;
     avatar_url: string | null;
-    source_type: string;
     config: Record<string, unknown>;
     created_at: string;
 };
@@ -179,6 +182,10 @@ export declare class ClawHiveCloudApi {
     get baseUrl(): string;
     get userId(): string | null;
     get pluginToken(): string | null;
+    setAuthorizationIdentity(identity: {
+        pluginToken: string;
+        userId: string;
+    }): void;
     private requireUserId;
     private requirePluginToken;
     startDeviceCode(opts?: {

package/dist/src/client.js

@@ -68,6 +68,10 @@ export class ClawHiveCloudApi {
     get pluginToken() {
         return this.config.pluginToken ?? null;
     }
+    setAuthorizationIdentity(identity) {
+        this.config.pluginToken = identity.pluginToken;
+        this.config.userId = identity.userId;
+    }
     requireUserId() {
         if (!this.config.userId) {
             throw new Error("ClawHiveCloudApi: userId is not set. Call registerPluginNode() before making user-scoped calls.");
@@ -86,6 +90,7 @@ export class ClawHiveCloudApi {
             method: "POST",
             auth: "none",
             body: {
+                runtime_type: "openclaw",
                 node_name: opts?.nodeName ?? this.config.nodeName ?? "OpenClaw Desktop",
                 plugin_version: opts?.pluginVersion ?? this.config.pluginVersion ?? "0.2.0",
                 description: opts?.description,
@@ -128,6 +133,7 @@ export class ClawHiveCloudApi {
             plugin_node_id: this.config.pluginNodeId ?? null,
             node_name: this.config.nodeName ?? "OpenClaw Desktop",
             plugin_version: this.config.pluginVersion ?? "0.2.0",
+            runtime_type: "openclaw",
         };
         if (this.config.userId) {
             body.user_id = this.config.userId;
@@ -139,6 +145,7 @@ export class ClawHiveCloudApi {
             body,
         });
         this.config.userId = result.user_id;
+        this.config.pluginNodeId = result.plugin_node.id;
         return result;
     }
     async createPairingCode(pluginNodeId, ttlSeconds) {
@@ -172,6 +179,7 @@ export class ClawHiveCloudApi {
             auth: "plugin",
             body: {
                 plugin_node_id: params.pluginNodeId,
+                runtime_type: "openclaw",
                 session_id: params.sessionId,
                 agent_id: params.agentId,
                 user_id: this.requireUserId(),
@@ -190,7 +198,10 @@ export class ClawHiveCloudApi {
             auth: "plugin",
             body: {
                 user_id: this.requireUserId(),
+                plugin_node_id: this.config.pluginNodeId,
+                runtime_type: "openclaw",
                 agents: agents.map((agent) => ({
+                    runtime_agent_id: agent.openclawAgentId,
                     openclaw_agent_id: agent.openclawAgentId,
                     name: agent.name,
                     description: agent.description ?? null,

package/dist/src/deviceCode.d.ts

@@ -7,6 +7,7 @@ export type DeviceCodeAwaitResult = {
     user_id: string;
     plugin_token: string;
 };
+export declare function normalizeDeviceCodeUrl(url: string): string;
 export declare function printDeviceCodePrompt(start: DeviceCodeStartResult, logger: DeviceCodeLogger): Promise<void>;
 export declare function awaitDeviceCodeApproval(params: {
     api: ClawHiveCloudApi;

package/dist/src/deviceCode.js

@@ -5,15 +5,24 @@ async function renderQr(text) {
         qrcodeTerminal.generate(text, { small: true }, (qr) => resolve(qr));
     });
 }
+export function normalizeDeviceCodeUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.hostname === "127.0.0.1") {
+        parsed.hostname = "localhost";
+    }
+    return parsed.toString();
+}
 export async function printDeviceCodePrompt(start, logger) {
-    const qr = await renderQr(start.verification_uri_complete);
+    const verificationUri = normalizeDeviceCodeUrl(start.verification_uri);
+    const verificationUriComplete = normalizeDeviceCodeUrl(start.verification_uri_complete);
+    const qr = await renderQr(verificationUriComplete);
     const expiresInMin = Math.floor(start.expires_in / 60);
     const lines = [
         "",
         "════════════════════════════════════════════════════════════",
         "  ClawHive: authorize this OpenClaw install.",
         "",
-        `  Visit: ${start.verification_uri}`,
+        `  Visit: ${verificationUri}`,
         `  Enter the code: ${start.user_code}`,
         "",
         "  Or scan this QR to jump straight to the approval page:",

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;
     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.js

@@ -17,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) => {
@@ -65,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;
         }
@@ -100,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.2",
+  "version": "0.2.4",
   "description": "ClawHive channel plugin for OpenClaw",
   "license": "UNLICENSED",
   "homepage": "https://github.com/optimalAIs/clawhive#readme",