@efengx/openclaw-channel-dragon 0.4.8 → 0.5.0

package/dist/components/bridge/BridgeComponent.d.ts

@@ -4,6 +4,7 @@ export declare class BridgeComponent implements IComponent {
     private options;
     client: DragonBridgeClient | undefined;
     constructor(options: {
+        host?: string;
         port: number;
         token: string;
         agentId: string;

package/dist/components/bridge/BridgeComponent.js

@@ -6,8 +6,9 @@ export class BridgeComponent {
         this.options = options;
     }
     async start() {
-        const { port, token, agentId, gatewayPort, gatewayToken, logger } = this.options;
+        const { host, port, token, agentId, gatewayPort, gatewayToken, logger } = this.options;
         this.client = connectToDragonBridge({
+            host,
             port,
             token,
             onConnected: () => {

package/dist/components/http/HttpComponent.d.ts

@@ -5,7 +5,7 @@ export interface HttpOptions {
     logger?: any;
 }
 export declare class HttpComponent implements IComponent {
-    private options;
+    options: HttpOptions;
     constructor(options: HttpOptions);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/components/sync/PollingComponent.d.ts

@@ -6,16 +6,16 @@ export declare class PollingComponent implements IComponent {
     private channel;
     private options;
     private pollInterval;
+    private heartbeatInterval;
     constructor(http: HttpComponent, channel: ChannelComponent, options: {
         agentId: string;
         accountId: string;
+        channelRuntime?: any;
         abortSignal: AbortSignal;
         logger?: any;
     });
     start(): Promise<void>;
     stop(): Promise<void>;
     private consumePendingMessages;
-    private startLoop;
-    private connectOnce;
-    private connectHttp2;
+    private sendHeartbeat;
 }

package/dist/components/sync/PollingComponent.js

@@ -1,26 +1,31 @@
-import * as http2 from "node:http2";
 export class PollingComponent {
     http;
     channel;
     options;
     pollInterval = null;
+    heartbeatInterval = null;
     constructor(http, channel, options) {
         this.http = http;
         this.channel = channel;
         this.options = options;
     }
     async start() {
-        this.startLoop();
-        // Safety: Periodic polling fallback every 60 seconds
+        // 1. Initial consume
+        void this.consumePendingMessages();
+        // 2. Periodic recovery polling (every 60s)
         this.pollInterval = setInterval(() => {
             void this.consumePendingMessages();
         }, 60_000);
+        // 3. Heartbeat for OpenClaw keep-alive (every 30s)
+        this.heartbeatInterval = setInterval(() => {
+            void this.sendHeartbeat();
+        }, 30_000);
     }
     async stop() {
-        if (this.pollInterval) {
+        if (this.pollInterval)
             clearInterval(this.pollInterval);
-            this.pollInterval = null;
-        }
+        if (this.heartbeatInterval)
+            clearInterval(this.heartbeatInterval);
     }
     async consumePendingMessages() {
         const { agentId, logger } = this.options;
@@ -30,7 +35,7 @@ export class PollingComponent {
                 const data = (await res.json());
                 const messages = data.messages || [];
                 if (messages.length > 0) {
-                    logger?.info?.(`dragon channel: [RECOVERY] Consuming ${messages.length} pending messages via polling.`);
+                    logger?.debug?.(`[Dragon Plugin] [Recovery] Polled ${messages.length} pending messages.`);
                     for (const m of messages) {
                         await this.channel.deliverToOpenClaw(String(m.content || ''), String(m.sessionId || 'default'), m.modelId, m.attachments, m.id);
                     }
@@ -38,104 +43,26 @@ export class PollingComponent {
             }
         }
         catch (e) {
-            logger?.error?.(`dragon channel: [RECOVERY] Polling failed: ${e.message}`);
+            // Quiet fail for recovery polling
         }
     }
-    async startLoop() {
-        const { logger, abortSignal } = this.options;
-        let attempt = 0;
-        while (!abortSignal.aborted) {
-            try {
-                attempt += 1;
-                logger?.debug?.(`dragon channel: SSE connecting (attempt ${attempt})`);
-                await this.connectOnce();
-            }
-            catch (e) {
-                if (e?.name === 'AbortError')
-                    break;
-                logger?.error?.(`dragon channel: SSE loop error: ${e?.message || e}`);
-                const delayMs = Math.min(10_000, 500 + attempt * 500);
-                await new Promise((r) => setTimeout(r, delayMs));
-            }
-        }
-    }
-    async connectOnce() {
-        const { agentId, logger, abortSignal } = this.options;
-        const ssePath = `/api/agents/events`;
-        void this.consumePendingMessages();
-        const handleSseText = async (chunkText, bufRef) => {
-            bufRef.buf += chunkText;
-            let idx;
-            while ((idx = bufRef.buf.indexOf('\n\n')) >= 0) {
-                const raw = bufRef.buf.slice(0, idx);
-                bufRef.buf = bufRef.buf.slice(idx + 2);
-                if (!raw.trim() || raw.trim().startsWith(':'))
-                    continue;
-                const dataLines = raw
-                    .split('\n')
-                    .filter((l) => l.startsWith('data:'))
-                    .map((l) => l.slice('data:'.length).trim());
-                if (!dataLines.length)
-                    continue;
-                const dataStr = dataLines.join('\n');
-                try {
-                    const evt = JSON.parse(dataStr);
-                    if (evt?.type === 'WORKBENCH_MESSAGE' && evt.agentId === agentId) {
-                        await this.channel.deliverToOpenClaw(String(evt?.payload?.content || ''), String(evt?.payload?.sessionId || 'default'), evt?.payload?.modelId, evt?.payload?.attachments, evt?.payload?.id);
-                    }
-                }
-                catch (e) { }
+    async sendHeartbeat() {
+        const { agentId, logger, channelRuntime } = this.options;
+        try {
+            // Orchestrator Heartbeat
+            await this.http.fetch(`/api/agents/${agentId}/telemetry`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ type: "plugin_heartbeat", value: { timestamp: Date.now() } }),
+            });
+            // OpenClaw Runtime Activity Report (if supported by SDK)
+            if (typeof channelRuntime?.reportActivity === 'function') {
+                channelRuntime.reportActivity();
             }
-        };
-        const res = await this.http.fetch(ssePath, {
-            signal: abortSignal,
-            headers: { Accept: 'text/event-stream' },
-        });
-        if (res.status === 404) {
-            return;
+            logger?.debug?.(`[Dragon Plugin] Heartbeat sent for ${agentId}`);
         }
-        if (!res.ok)
-            throw new Error(`Orchestrator SSE failed: ${res.status}`);
-        const body = res.body;
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        const bufRef = { buf: '' };
-        while (!abortSignal.aborted) {
-            const { value, done } = await reader.read();
-            if (done)
-                break;
-            await handleSseText(decoder.decode(value, { stream: true }), bufRef);
+        catch (e) {
+            logger?.warn?.(`[Dragon Plugin] Heartbeat failed: ${e.message}`);
         }
     }
-    async connectHttp2(sseUrl, handleSseText) {
-        const { logger, abortSignal } = this.options;
-        const u = new URL(sseUrl);
-        const origin = `${u.protocol}//${u.host}`;
-        const pathWithQuery = `${u.pathname}${u.search || ''}`;
-        const bufRef = { buf: '' };
-        return new Promise((resolve, reject) => {
-            const session = http2.connect(origin);
-            let done = false;
-            const finish = (err) => {
-                if (done)
-                    return;
-                done = true;
-                try {
-                    session.close();
-                }
-                catch { }
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            };
-            abortSignal?.addEventListener?.('abort', () => finish({ name: 'AbortError' }));
-            session.on('error', (err) => finish(err));
-            const req = session.request({ ':method': 'GET', ':path': pathWithQuery, accept: 'text/event-stream' });
-            req.setEncoding('utf8');
-            req.on('data', (chunk) => handleSseText(chunk, bufRef));
-            req.on('end', () => finish());
-            req.end();
-        });
-    }
 }

package/dist/components/sync/SseComponent.d.ts

@@ -0,0 +1,21 @@
+import { IComponent } from "../../core/IComponent.js";
+import { HttpComponent } from "../http/HttpComponent.js";
+import { ChannelComponent } from "../channel/ChannelComponent.js";
+export declare class SseComponent implements IComponent {
+    private http;
+    private channel;
+    private options;
+    private eventSource;
+    private shouldReconnect;
+    private reconnectTimer;
+    constructor(http: HttpComponent, channel: ChannelComponent, options: {
+        agentId: string;
+        logger?: any;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private connect;
+    private startSseReader;
+    private handleEvent;
+    private scheduleReconnect;
+}

package/dist/components/sync/SseComponent.js

@@ -0,0 +1,104 @@
+export class SseComponent {
+    http;
+    channel;
+    options;
+    eventSource;
+    shouldReconnect = true;
+    reconnectTimer;
+    constructor(http, channel, options) {
+        this.http = http;
+        this.channel = channel;
+        this.options = options;
+    }
+    async start() {
+        this.connect();
+    }
+    async stop() {
+        this.shouldReconnect = false;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.eventSource?.close();
+    }
+    connect() {
+        if (!this.shouldReconnect)
+            return;
+        const { agentId, logger } = this.options;
+        const url = `${this.http.options.baseURL}/api/agents/events`;
+        logger?.info?.(`[Dragon Plugin] Connecting to Orchestrator SSE: ${url}`);
+        try {
+            // In Node 22, we might need a fetch-based SSE or a library, 
+            // but for simplicity we'll use the same pattern as Bridge if possible.
+            // Actually, standard EventSource is not in Node globals yet.
+            // We'll use a simple fetch-based stream reader.
+            this.startSseReader(url);
+        }
+        catch (err) {
+            logger?.error?.(`[Dragon Plugin] SSE Init Failed: ${err.message}`);
+            this.scheduleReconnect();
+        }
+    }
+    async startSseReader(url) {
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'Accept': 'text/event-stream',
+                    'Authorization': `Bearer ${this.http.options.authToken || ''}`
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed with status ${response.status}`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error("Response body is null");
+            this.options.logger?.debug?.(`[Dragon Plugin] SSE Stream Established.`);
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (this.shouldReconnect) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        try {
+                            const data = JSON.parse(line.slice(6));
+                            this.handleEvent(data);
+                        }
+                        catch (e) { }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (this.shouldReconnect) {
+                this.options.logger?.warn?.(`[Dragon Plugin] SSE Stream Disconnected: ${err.message}`);
+                this.scheduleReconnect();
+            }
+        }
+    }
+    handleEvent(data) {
+        const { agentId, logger } = this.options;
+        // 1. Filter for events belonging to this agent
+        if (data.agentId && data.agentId !== agentId)
+            return;
+        // 2. Handle specific types
+        if (data.type === 'WORKBENCH_MESSAGE') {
+            const { content, sessionId, attachments, id } = data.payload || {};
+            logger?.info?.(`[Dragon Plugin] Received Workbench Message (via SSE): ${content?.substring(0, 20)}...`);
+            this.channel.deliverToOpenClaw(content, sessionId, undefined, attachments, id);
+        }
+        else if (data.type === 'FETCH_HISTORY') {
+            const { sessionId } = data.payload || {};
+            logger?.info?.(`[Dragon Plugin] Triggering history sync for session: ${sessionId}`);
+            // Handle history sync if needed, but deliverToOpenClaw usually handles normal chat
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = setTimeout(() => this.connect(), 5000);
+    }
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import { PollingComponent } from "./components/sync/PollingComponent.js";
 import { TelemetryComponent } from "./components/telemetry/TelemetryComponent.js";
 import { HttpComponent } from "./components/http/HttpComponent.js";
 import { ChannelComponent } from "./components/channel/ChannelComponent.js";
+import { SseComponent } from "./components/sync/SseComponent.js";
 const channelId = "dragon";
 let cachedRuntime;
 const containers = new Map();
@@ -24,6 +25,7 @@ async function getOrCreateContainer(account, ctx) {
     }));
     const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
     const bridge = container.register('bridge', new BridgeComponent({
+        host: account.bridgeHost,
         port: parseInt(account.bridgePort || "18799", 10),
         token: account.bridgeToken || "",
         agentId: account.agentId,
@@ -39,10 +41,15 @@ async function getOrCreateContainer(account, ctx) {
         cfg: ctx.cfg,
         logger
     }, bridge, telemetry));
-    // 3. Polling Infrastructure
+    // 3. Sync Infrastructure (SSE + Polling)
+    container.register('sse', new SseComponent(http, channel, {
+        agentId: account.agentId,
+        logger
+    }));
     container.register('polling', new PollingComponent(http, channel, {
         agentId: account.agentId,
         accountId: account.accountId,
+        channelRuntime: ctx.channelRuntime,
         abortSignal: ctx.abortSignal,
         logger
     }));
@@ -59,13 +66,18 @@ const base = createChannelPluginBase({
         finalize: async () => ({ ok: true })
     },
     config: {
+        listAccountIds: (cfg) => {
+            return Object.keys(cfg.channels?.[channelId]?.accounts || { "default": {} });
+        },
         resolveAccount: (cfg, accountId = "default") => {
             const accountConfig = cfg.channels?.[channelId]?.accounts?.[accountId] || {};
+            const host = accountConfig.bridgeHost || accountConfig.host;
             return {
                 accountId,
                 agentId: accountConfig.agentId || accountId,
                 orchestratorUrl: accountConfig.orchestratorUrl || "http://127.0.0.1:4000",
                 orchestratorAuthToken: accountConfig.orchestratorAuthToken || accountConfig.authToken,
+                bridgeHost: host,
                 bridgePort: accountConfig.bridgePort,
                 bridgeToken: accountConfig.bridgeToken,
                 gatewayPort: accountConfig.gatewayPort,
@@ -96,33 +108,12 @@ const plugin = createChatChannelPlugin({
             },
         }),
     },
-    config: {
-        get: (cfg) => cfg.channels?.[channelId] || {},
-        set: (cfg, value) => {
-            cfg.channels = cfg.channels || {};
-            cfg.channels[channelId] = value;
-        }
-    }
 });
 const entry = defineChannelPluginEntry({
     id: channelId,
     name: "Dragon Workbench Channel",
     description: "Connect OpenClaw to the Dragon agent-client workbench chat.",
     plugin,
-    config: {
-        get: (cfg) => cfg.channels?.[channelId] || {},
-        set: (cfg, value) => {
-            cfg.channels = cfg.channels || {};
-            cfg.channels[channelId] = value;
-        }
-    },
-    configHelpers: {
-        get: (cfg) => cfg.channels?.[channelId] || {},
-        set: (cfg, value) => {
-            cfg.channels = cfg.channels || {};
-            cfg.channels[channelId] = value;
-        }
-    },
     registerFull(api) {
         cachedRuntime = api.runtime;
         const agentEventHandler = api.runtime?.events?.onAgentEvent || InfraRuntime.onAgentEvent;

package/dist/ws.d.ts

@@ -7,6 +7,7 @@ export type DragonBridgeClient = {
     close: () => Promise<void>;
 };
 export declare function connectToDragonBridge(params: {
+    host?: string;
     port: number;
     token?: string;
     onConnected?: () => void;

package/dist/ws.js

@@ -6,7 +6,8 @@ export function connectToDragonBridge(params) {
         if (!shouldReconnect)
             return;
         // Node 22 global WebSocket
-        const url = `ws://127.0.0.1:${params.port}/__dragon/ws?token=${params.token || ""}`;
+        const host = params.host || '127.0.0.1';
+        const url = `ws://${host}:${params.port}/__dragon/ws?token=${params.token || ""}`;
         console.log(`[Dragon Plugin] Connecting to bridge at ${url}...`);
         try {
             ws = new global.WebSocket(url);

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "dragon",
   "name": "Dragon Workbench Channel",
   "description": "Connect OpenClaw to the Dragon agent-client workbench chat.",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "enabledByDefault": true,
   "activation": {
     "onCapabilities": ["hook"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efengx/openclaw-channel-dragon",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "Dragon workbench channel for OpenClaw",
   "author": "feng xiang <ofengx@gmail.com>",
   "type": "module",
@@ -11,6 +11,10 @@
     "openclaw.plugin.json",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "echo \"(skip)\""
+  },
   "dependencies": {
     "openclaw": "^2026.4.12"
   },
@@ -32,9 +36,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "lint": "echo \"(skip)\""
   }
-}
+}