@eclaw/openclaw-channel 1.0.9 → 1.0.11

package/dist/gateway.d.ts

@@ -2,7 +2,8 @@
  * Gateway lifecycle: start an E-Claw account.
  *
  * 1. Resolve credentials from ctx.account or disk
- * 2. Start a local HTTP server to receive webhook callbacks
+ * 2. Register a per-session handler in the webhook-registry (served by the
+ *    main OpenClaw gateway HTTP server at /eclaw-webhook — no separate port)
  * 3. Register callback URL with E-Claw backend
  * 4. Auto-bind entity if not already bound
  * 5. Keep the promise alive until abort signal fires

package/dist/gateway.js

@@ -1,4 +1,3 @@
-import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -7,12 +6,14 @@ import { resolveAccount } from './config.js';
 import { EClawClient } from './client.js';
 import { setClient } from './outbound.js';
 import { createWebhookHandler } from './webhook-handler.js';
+import { registerWebhookToken, unregisterWebhookToken } from './webhook-registry.js';
 /**
  * Resolve account from ctx.
  *
  * OpenClaw may pass a pre-resolved account object in ctx.account,
  * or an empty config. Fall back to reading openclaw.json from disk.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function resolveAccountFromCtx(ctx) {
     // Preferred: OpenClaw passes the resolved account in ctx.account
     if (ctx.account?.apiKey) {
@@ -40,7 +41,8 @@ function resolveAccountFromCtx(ctx) {
  * Gateway lifecycle: start an E-Claw account.
  *
  * 1. Resolve credentials from ctx.account or disk
- * 2. Start a local HTTP server to receive webhook callbacks
+ * 2. Register a per-session handler in the webhook-registry (served by the
+ *    main OpenClaw gateway HTTP server at /eclaw-webhook — no separate port)
  * 3. Register callback URL with E-Claw backend
  * 4. Auto-bind entity if not already bound
  * 5. Keep the promise alive until abort signal fires
@@ -59,7 +61,6 @@ export async function startAccount(ctx) {
     // Generate per-session callback token
     const callbackToken = randomBytes(32).toString('hex');
     // Webhook URL: account config > env var > warn
-    const webhookPort = parseInt(process.env.ECLAW_WEBHOOK_PORT || '0') || 0;
     const publicUrl = account.webhookUrl?.replace(/\/$/, '')
         || process.env.ECLAW_WEBHOOK_URL?.replace(/\/$/, '');
     if (!publicUrl) {
@@ -68,72 +69,50 @@ export async function startAccount(ctx) {
             'or set ECLAW_WEBHOOK_URL env var. ' +
             'Example: https://your-openclaw-domain.com');
     }
-    // Create webhook handler
-    const handler = createWebhookHandler(callbackToken, accountId);
-    // Parse JSON body for incoming requests
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const requestHandler = (req, res) => {
-        if (req.method === 'POST' && req.url?.startsWith('/eclaw-webhook')) {
-            let body = '';
-            req.on('data', (chunk) => { body += chunk.toString(); });
-            req.on('end', () => {
-                try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    req.body = JSON.parse(body);
-                }
-                catch {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    req.body = {};
-                }
-                handler(req, res);
-            });
+    // The callback URL points to /eclaw-webhook on the main gateway HTTP server
+    const callbackUrl = `${publicUrl || 'http://localhost'}/eclaw-webhook`;
+    // Register handler in the per-token registry
+    // Pass ctx.cfg so the handler can dispatch to the correct OpenClaw agent
+    const handler = createWebhookHandler(callbackToken, accountId, ctx.cfg);
+    registerWebhookToken(callbackToken, accountId, handler);
+    console.log(`[E-Claw] Webhook registered at: ${callbackUrl}`);
+    try {
+        // Register callback with E-Claw backend
+        const regData = await client.registerCallback(callbackUrl, callbackToken);
+        console.log(`[E-Claw] Registered with E-Claw. Device: ${regData.deviceId}, Entities: ${regData.entities.length}`);
+        // Auto-bind entity if not already bound
+        const entity = regData.entities.find(e => e.entityId === account.entityId);
+        if (!entity?.isBound) {
+            console.log(`[E-Claw] Entity ${account.entityId} not bound, binding...`);
+            const bindData = await client.bindEntity(account.entityId, account.botName);
+            console.log(`[E-Claw] Bound entity ${account.entityId}, publicCode: ${bindData.publicCode}`);
         }
         else {
-            res.writeHead(404);
-            res.end('Not Found');
+            console.log(`[E-Claw] Entity ${account.entityId} already bound`);
+            const bindData = await client.bindEntity(account.entityId, account.botName);
+            console.log(`[E-Claw] Retrieved credentials for entity ${account.entityId}`);
+            void bindData;
         }
-    };
-    const server = createServer(requestHandler);
+        console.log(`[E-Claw] Account ${accountId} ready!`);
+    }
+    catch (err) {
+        console.error(`[E-Claw] Setup failed for account ${accountId}:`, err);
+        unregisterWebhookToken(callbackToken);
+        return;
+    }
+    // Keep the promise alive until abort signal fires
     return new Promise((resolve) => {
-        server.listen(webhookPort, async () => {
-            const addr = server.address();
-            const actualPort = typeof addr === 'object' && addr ? addr.port : webhookPort;
-            const baseUrl = publicUrl || `http://localhost:${actualPort}`;
-            const callbackUrl = `${baseUrl}/eclaw-webhook`;
-            console.log(`[E-Claw] Webhook server listening on port ${actualPort}`);
-            console.log(`[E-Claw] Callback URL: ${callbackUrl}`);
-            try {
-                // Register callback with E-Claw backend
-                const regData = await client.registerCallback(callbackUrl, callbackToken);
-                console.log(`[E-Claw] Registered with E-Claw. Device: ${regData.deviceId}, Entities: ${regData.entities.length}`);
-                // Auto-bind entity if not already bound
-                const entity = regData.entities.find(e => e.entityId === account.entityId);
-                if (!entity?.isBound) {
-                    console.log(`[E-Claw] Entity ${account.entityId} not bound, binding...`);
-                    const bindData = await client.bindEntity(account.entityId, account.botName);
-                    console.log(`[E-Claw] Bound entity ${account.entityId}, publicCode: ${bindData.publicCode}`);
-                }
-                else {
-                    console.log(`[E-Claw] Entity ${account.entityId} already bound`);
-                    const bindData = await client.bindEntity(account.entityId, account.botName);
-                    console.log(`[E-Claw] Retrieved credentials for entity ${account.entityId}`);
-                    void bindData;
-                }
-                console.log(`[E-Claw] Account ${accountId} ready!`);
-            }
-            catch (err) {
-                console.error(`[E-Claw] Setup failed for account ${accountId}:`, err);
-            }
-        });
-        // Cleanup on abort
         const signal = ctx.abortSignal;
         if (signal) {
             signal.addEventListener('abort', () => {
                 console.log(`[E-Claw] Shutting down account ${accountId}`);
                 client.unregisterCallback().catch(() => { });
-                server.close();
+                unregisterWebhookToken(callbackToken);
                 resolve();
             });
         }
+        else {
+            resolve();
+        }
     });
 }

package/dist/index.d.ts

@@ -1,24 +1,3 @@
-/**
- * E-Claw Channel Plugin for OpenClaw.
- *
- * Installation:
- *   npm install @eclaw/openclaw-channel
- *
- * Configuration (config.yaml):
- *   channels:
- *     eclaw:
- *       accounts:
- *         default:
- *           apiKey: "eck_..."
- *           apiSecret: "ecs_..."
- *           apiBase: "https://eclawbot.com"
- *           entityId: 0
- *           botName: "My Bot"
- *
- * Environment variables:
- *   ECLAW_WEBHOOK_URL  - Public URL for receiving callbacks (required for production)
- *   ECLAW_WEBHOOK_PORT - Port for webhook server (default: random)
- */
 declare const plugin: {
     id: string;
     name: string;

package/dist/index.js

@@ -1,5 +1,6 @@
 import { setPluginRuntime } from './runtime.js';
 import { eclawChannel } from './channel.js';
+import { dispatchWebhook } from './webhook-registry.js';
 /**
  * E-Claw Channel Plugin for OpenClaw.
  *
@@ -12,15 +13,32 @@ import { eclawChannel } from './channel.js';
  *       accounts:
  *         default:
  *           apiKey: "eck_..."
- *           apiSecret: "ecs_..."
  *           apiBase: "https://eclawbot.com"
  *           entityId: 0
  *           botName: "My Bot"
+ *           webhookUrl: "https://your-openclaw-domain.com"
  *
- * Environment variables:
- *   ECLAW_WEBHOOK_URL  - Public URL for receiving callbacks (required for production)
- *   ECLAW_WEBHOOK_PORT - Port for webhook server (default: random)
+ * The plugin registers /eclaw-webhook on the main OpenClaw gateway HTTP server,
+ * so no separate port is needed. Set webhookUrl to your OpenClaw public URL
+ * (e.g. https://eclaw2.zeabur.app) so E-Claw knows where to push messages.
  */
+/** Parse JSON body from a raw incoming request */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseBody(req) {
+    return new Promise((resolve) => {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk.toString(); });
+        req.on('end', () => {
+            try {
+                req.body = JSON.parse(body);
+            }
+            catch {
+                req.body = {};
+            }
+            resolve();
+        });
+    });
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const plugin = {
     id: 'eclaw',
@@ -30,6 +48,17 @@ const plugin = {
     register(api) {
         console.log('[E-Claw] Plugin loaded');
         setPluginRuntime(api.runtime);
+        // Register /eclaw-webhook on the main OpenClaw gateway HTTP server.
+        // Token-based routing is handled in dispatchWebhook() — each account
+        // registers its own handler keyed by a random per-session Bearer token.
+        api.registerHttpRoute({
+            path: '/eclaw-webhook',
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            handler: async (req, res) => {
+                await parseBody(req);
+                await dispatchWebhook(req, res);
+            },
+        });
         api.registerChannel({ plugin: eclawChannel });
     },
 };

package/dist/webhook-handler.d.ts

@@ -2,6 +2,9 @@
  * Create an HTTP request handler for inbound messages from E-Claw.
  *
  * When a user sends a message on E-Claw, the backend POSTs structured JSON
- * to this webhook. We normalize it and dispatch to the OpenClaw agent.
+ * to this webhook. We normalize it into OpenClaw's native PascalCase context
+ * format and dispatch to the agent via dispatchReplyWithBufferedBlockDispatcher.
+ *
+ * The `deliver` callback sends the AI reply back to E-Claw via the API client.
  */
-export declare function createWebhookHandler(expectedToken: string, accountId: string): (req: any, res: any) => Promise<void>;
+export declare function createWebhookHandler(expectedToken: string, accountId: string, cfg: any): (req: any, res: any) => Promise<void>;

package/dist/webhook-handler.js

@@ -1,11 +1,18 @@
 import { getPluginRuntime } from './runtime.js';
+import { getClient } from './outbound.js';
 /**
  * Create an HTTP request handler for inbound messages from E-Claw.
  *
  * When a user sends a message on E-Claw, the backend POSTs structured JSON
- * to this webhook. We normalize it and dispatch to the OpenClaw agent.
+ * to this webhook. We normalize it into OpenClaw's native PascalCase context
+ * format and dispatch to the agent via dispatchReplyWithBufferedBlockDispatcher.
+ *
+ * The `deliver` callback sends the AI reply back to E-Claw via the API client.
  */
-export function createWebhookHandler(expectedToken, accountId) {
+export function createWebhookHandler(expectedToken, accountId, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+cfg // full openclaw config (ctx.cfg from startAccount)
+) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return async (req, res) => {
         // Verify callback token
@@ -22,36 +29,62 @@ export function createWebhookHandler(expectedToken, accountId) {
         // Dispatch to OpenClaw agent
         try {
             const rt = getPluginRuntime();
+            const client = getClient(accountId);
             const conversationId = msg.conversationId || `${msg.deviceId}:${msg.entityId}`;
-            // Map E-Claw media types to OpenClaw types
-            let media;
-            if (msg.mediaType && msg.mediaUrl) {
-                const type = msg.mediaType === 'photo' ? 'image'
-                    : msg.mediaType === 'voice' ? 'audio'
-                        : msg.mediaType === 'video' ? 'video'
-                            : 'file';
-                media = { type, url: msg.mediaUrl };
-            }
+            // Map E-Claw media type to OpenClaw media type
+            const ocMediaType = msg.mediaType === 'photo' ? 'image'
+                : msg.mediaType === 'voice' ? 'audio'
+                    : msg.mediaType === 'video' ? 'video'
+                        : msg.mediaType ? 'file'
+                            : undefined;
+            // Build context in OpenClaw's native PascalCase format
+            // (same convention as Telegram/LINE/WhatsApp channels)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const inboundCtx = {
-                channelId: 'eclaw',
-                accountId,
-                conversationId,
-                senderId: msg.from,
-                text: msg.text || '',
-                ...(media ? { media } : {}),
-                metadata: {
-                    deviceId: msg.deviceId,
-                    entityId: msg.entityId,
-                    event: msg.event,
-                    fromEntityId: msg.fromEntityId,
-                    fromCharacter: msg.fromCharacter,
-                    isBroadcast: msg.isBroadcast,
-                    timestamp: msg.timestamp,
-                },
+                Surface: 'eclaw',
+                Provider: 'eclaw',
+                OriginatingChannel: 'eclaw',
+                AccountId: accountId,
+                From: msg.from,
+                To: conversationId,
+                OriginatingTo: msg.from,
+                SessionKey: conversationId,
+                Body: msg.text || '',
+                RawBody: msg.text || '',
+                CommandBody: msg.text || '',
+                ChatType: 'direct',
+                ...(ocMediaType && msg.mediaUrl ? {
+                    MediaType: ocMediaType,
+                    MediaUrl: msg.mediaUrl,
+                } : {}),
             };
-            // OpenClaw inbound dispatch pipeline
-            const ctx = await rt.channel.reply.finalizeInboundContext(inboundCtx);
-            await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher(ctx);
+            const ctxPayload = rt.channel.reply.finalizeInboundContext(inboundCtx);
+            await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                ctx: ctxPayload,
+                cfg,
+                dispatcherOptions: {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    deliver: async (payload) => {
+                        if (!client)
+                            return;
+                        const text = typeof payload.text === 'string' ? payload.text.trim() : '';
+                        if (text) {
+                            await client.sendMessage(text, 'IDLE');
+                        }
+                        else if (payload.mediaUrl) {
+                            const rawType = typeof payload.mediaType === 'string' ? payload.mediaType : '';
+                            const mediaType = rawType === 'image' ? 'photo'
+                                : rawType === 'audio' ? 'voice'
+                                    : rawType === 'video' ? 'video'
+                                        : 'file';
+                            await client.sendMessage('', 'IDLE', mediaType, payload.mediaUrl);
+                        }
+                    },
+                    onError: (err) => {
+                        console.error('[E-Claw] Reply delivery error:', err);
+                    },
+                },
+            });
         }
         catch (err) {
             console.error('[E-Claw] Webhook dispatch error:', err);

package/dist/webhook-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Per-session webhook token registry.
+ *
+ * Each account generates a random callbackToken when it starts.
+ * The token is sent to E-Claw as part of the callback URL registration,
+ * and E-Claw echoes it back as `Authorization: Bearer <token>` on every push.
+ *
+ * The main route handler (registered on the gateway HTTP server) looks up
+ * the correct per-account handler by matching the Bearer token.
+ */
+type WebhookHandler = (req: any, res: any) => Promise<void>;
+export declare function registerWebhookToken(callbackToken: string, accountId: string, handler: WebhookHandler): void;
+export declare function unregisterWebhookToken(callbackToken: string): void;
+/**
+ * Dispatch an incoming webhook request to the correct account handler.
+ * Verifies the Bearer token and routes to the matching handler.
+ */
+export declare function dispatchWebhook(req: any, res: any): Promise<void>;
+export {};

package/dist/webhook-registry.js

@@ -0,0 +1,39 @@
+/**
+ * Per-session webhook token registry.
+ *
+ * Each account generates a random callbackToken when it starts.
+ * The token is sent to E-Claw as part of the callback URL registration,
+ * and E-Claw echoes it back as `Authorization: Bearer <token>` on every push.
+ *
+ * The main route handler (registered on the gateway HTTP server) looks up
+ * the correct per-account handler by matching the Bearer token.
+ */
+const registry = new Map();
+export function registerWebhookToken(callbackToken, accountId, handler) {
+    registry.set(callbackToken, { accountId, handler });
+}
+export function unregisterWebhookToken(callbackToken) {
+    registry.delete(callbackToken);
+}
+/**
+ * Dispatch an incoming webhook request to the correct account handler.
+ * Verifies the Bearer token and routes to the matching handler.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function dispatchWebhook(req, res) {
+    const authHeader = req.headers?.authorization;
+    if (!authHeader?.startsWith('Bearer ')) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Unauthorized' }));
+        return;
+    }
+    const token = authHeader.slice(7);
+    const entry = registry.get(token);
+    if (!entry) {
+        // Unknown token — likely a stale push after a server restart
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Unknown token' }));
+        return;
+    }
+    await entry.handler(req, res);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclaw/openclaw-channel",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "E-Claw channel plugin for OpenClaw — AI chat platform for live wallpaper entities",
   "type": "module",
   "main": "./dist/index.js",