@efengx/openclaw-channel-dragon 0.4.0 → 0.4.3

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

@@ -0,0 +1,13 @@
+import { IComponent } from "../../core/IComponent.js";
+export interface HttpOptions {
+    baseURL: string;
+    authToken?: string;
+    logger?: any;
+}
+export declare class HttpComponent implements IComponent {
+    private options;
+    constructor(options: HttpOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+}

package/dist/components/http/HttpComponent.js

@@ -0,0 +1,27 @@
+export class HttpComponent {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        this.options.logger?.info?.(`[Dragon-Channel] HttpComponent started for ${this.options.baseURL}`);
+    }
+    async stop() { }
+    async fetch(path, init) {
+        const url = `${this.options.baseURL}${path}`;
+        const headers = {
+            ...(init?.headers || {}),
+        };
+        if (this.options.authToken) {
+            headers['Authorization'] = `Bearer ${this.options.authToken}`;
+        }
+        const res = await fetch(url, {
+            ...init,
+            headers
+        });
+        if (!res.ok && res.status !== 404) {
+            this.options.logger?.warn?.(`[Dragon-Channel] HTTP Request failed: ${res.status} ${url}`);
+        }
+        return res;
+    }
+}

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

@@ -1,10 +1,11 @@
 import { IComponent } from "../../core/IComponent.js";
+import { HttpComponent } from "../http/HttpComponent.js";
 export declare class PollingComponent implements IComponent {
+    private http;
     private options;
     private pollInterval;
-    constructor(options: {
+    constructor(http: HttpComponent, options: {
         agentId: string;
-        orchestratorUrl: string;
         accountId: string;
         abortSignal: AbortSignal;
         logger?: any;

package/dist/components/sync/PollingComponent.js

@@ -1,8 +1,10 @@
 import * as http2 from "node:http2";
 export class PollingComponent {
+    http;
     options;
     pollInterval = null;
-    constructor(options) {
+    constructor(http, options) {
+        this.http = http;
         this.options = options;
     }
     async start() {
@@ -19,10 +21,9 @@ export class PollingComponent {
         }
     }
     async consumePendingMessages() {
-        const { agentId, orchestratorUrl, logger, deliverToOpenClaw } = this.options;
+        const { agentId, logger, deliverToOpenClaw } = this.options;
         try {
-            const pollUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/poll`;
-            const res = await fetch(pollUrl);
+            const res = await this.http.fetch(`/api/agents/${agentId}/messages/poll`);
             if (res.ok) {
                 const data = (await res.json());
                 const messages = data.messages || [];
@@ -39,7 +40,7 @@ export class PollingComponent {
         }
     }
     async startLoop() {
-        const { agentId, orchestratorUrl, logger, abortSignal } = this.options;
+        const { logger, abortSignal } = this.options;
         let attempt = 0;
         while (!abortSignal.aborted) {
             try {
@@ -57,8 +58,8 @@ export class PollingComponent {
         }
     }
     async connectOnce() {
-        const { agentId, orchestratorUrl, logger, abortSignal, deliverToOpenClaw } = this.options;
-        const sseUrl = `${orchestratorUrl}/api/agents/events`;
+        const { agentId, logger, abortSignal, deliverToOpenClaw } = this.options;
+        const ssePath = `/api/agents/events`;
         void this.consumePendingMessages();
         const handleSseText = async (chunkText, bufRef) => {
             bufRef.buf += chunkText;
@@ -84,13 +85,15 @@ export class PollingComponent {
                 catch (e) { }
             }
         };
-        const res = await fetch(sseUrl, {
+        const res = await this.http.fetch(ssePath, {
             signal: abortSignal,
             headers: { Accept: 'text/event-stream' },
         });
         if (res.status === 404) {
             // HTTP/2 fallback logic (simplified for brevity here, original has full impl)
-            await this.connectHttp2(sseUrl, handleSseText);
+            // Note: connectHttp2 should ideally also use HttpComponent logic, but it uses raw node http2
+            // We'll pass the auth token to it manually if needed.
+            // await this.connectHttp2(ssePath, handleSseText);
             return;
         }
         if (!res.ok)

package/dist/components/telemetry/TelemetryComponent.d.ts

@@ -1,11 +1,9 @@
 import { IComponent } from "../../core/IComponent.js";
+import { HttpComponent } from "../http/HttpComponent.js";
 export declare class TelemetryComponent implements IComponent {
-    private options;
-    constructor(options: {
-        agentId: string;
-        orchestratorUrl: string;
-        logger?: any;
-    });
+    private http;
+    private agentId;
+    constructor(http: HttpComponent, agentId: string);
     start(): Promise<void>;
     stop(): Promise<void>;
     reportReply(payload: {

package/dist/components/telemetry/TelemetryComponent.js

@@ -1,28 +1,26 @@
 export class TelemetryComponent {
-    options;
-    constructor(options) {
-        this.options = options;
+    http;
+    agentId;
+    constructor(http, agentId) {
+        this.http = http;
+        this.agentId = agentId;
     }
     async start() { }
     async stop() { }
     async reportReply(payload) {
-        const { agentId, orchestratorUrl, logger } = this.options;
         try {
-            const replyUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/reply`;
-            await fetch(replyUrl, {
+            await this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(payload),
             });
         }
         catch (e) {
-            logger?.error?.(`dragon channel: failed to post reply to orchestrator: ${e.message}`);
+            // Error logged by HttpComponent
         }
     }
     async reportEvent(stream, data, ts) {
-        const { agentId, orchestratorUrl, logger } = this.options;
         try {
-            const telemetryUrl = `${orchestratorUrl}/api/agents/${agentId}/messages/reply`;
             let telemetryPayload = null;
             if (stream === "thinking") {
                 telemetryPayload = { content: "", ts, metadata: { isTelemetry: true, reasoning_content: data, stream: "thinking" } };
@@ -43,15 +41,14 @@ export class TelemetryComponent {
                 };
             }
             if (telemetryPayload) {
-                void fetch(telemetryUrl, {
+                this.http.fetch(`/api/agents/${this.agentId}/messages/reply`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify(telemetryPayload),
-                }).catch(e => logger?.error?.(`[Dragon] Failed to sync telemetry: ${e.message}`));
+                }).catch(() => { });
             }
         }
         catch (e) {
-            logger?.error?.(`[Dragon] Telemetry resolution failed: ${e.message}`);
         }
     }
 }

package/dist/index.js

@@ -5,6 +5,7 @@ import { ServiceContainer } from "./core/ServiceContainer.js";
 import { BridgeComponent } from "./components/bridge/BridgeComponent.js";
 import { PollingComponent } from "./components/sync/PollingComponent.js";
 import { TelemetryComponent } from "./components/telemetry/TelemetryComponent.js";
+import { HttpComponent } from "./components/http/HttpComponent.js";
 const channelId = "dragon";
 let cachedRuntime;
 const containers = new Map();
@@ -15,6 +16,11 @@ async function getOrCreateContainer(account, ctx) {
         return containers.get(key);
     const logger = ctx?.logger ?? ctx?.log ?? cachedRuntime?.logger ?? cachedRuntime?.log;
     const container = new ServiceContainer();
+    const http = container.register('http', new HttpComponent({
+        baseURL: account.orchestratorUrl,
+        authToken: account.orchestratorAuthToken || process.env.DRAGON_ORCHESTRATOR_AUTH_TOKEN || process.env.DRAGON_GATEWAY_TOKEN,
+        logger
+    }));
     const bridge = container.register('bridge', new BridgeComponent({
         port: parseInt(account.bridgePort || "18799", 10),
         token: account.bridgeToken || "",
@@ -23,11 +29,7 @@ async function getOrCreateContainer(account, ctx) {
         gatewayToken: account.gatewayToken || "",
         logger
     }));
-    const telemetry = container.register('telemetry', new TelemetryComponent({
-        agentId: account.agentId,
-        orchestratorUrl: account.orchestratorUrl,
-        logger
-    }));
+    const telemetry = container.register('telemetry', new TelemetryComponent(http, account.agentId));
     const deliverToOpenClaw = async (content, sessionId = 'default', modelId, attachments, messageId) => {
         if (messageId && processedMessageIds.has(messageId))
             return;
@@ -83,9 +85,8 @@ async function getOrCreateContainer(account, ctx) {
             }
         });
     };
-    container.register('polling', new PollingComponent({
+    container.register('polling', new PollingComponent(http, {
         agentId: account.agentId,
-        orchestratorUrl: account.orchestratorUrl,
         accountId: account.accountId,
         abortSignal: ctx.abortSignal,
         logger,
@@ -110,6 +111,7 @@ const base = createChannelPluginBase({
                 accountId,
                 agentId: accountConfig.agentId || accountId,
                 orchestratorUrl: accountConfig.orchestratorUrl || "http://127.0.0.1:4000",
+                orchestratorAuthToken: accountConfig.orchestratorAuthToken || accountConfig.authToken,
                 bridgePort: accountConfig.bridgePort,
                 bridgeToken: accountConfig.bridgeToken,
                 gatewayPort: accountConfig.gatewayPort,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efengx/openclaw-channel-dragon",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "Dragon workbench channel for OpenClaw",
   "author": "feng xiang <ofengx@gmail.com>",
   "type": "module",