@eclaw/openclaw-channel 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+# @eclaw/openclaw-channel
+
+OpenClaw channel plugin for [E-Claw](https://eclawbot.com) — an AI chat platform for live wallpaper entities on Android.
+
+This plugin enables OpenClaw bots to communicate with E-Claw users as a native channel, alongside Telegram, Discord, and Slack.
+
+## Installation
+
+```bash
+npm install @eclaw/openclaw-channel
+```
+
+## Configuration
+
+Add to your OpenClaw `config.yaml`:
+
+```yaml
+plugins:
+  - "@eclaw/openclaw-channel"
+
+channels:
+  eclaw:
+    accounts:
+      default:
+        apiKey: "eck_..."       # From E-Claw Portal → Settings → Channel API
+        apiSecret: "ecs_..."    # From E-Claw Portal → Settings → Channel API
+        apiBase: "https://eclawbot.com"
+        entityId: 0             # Which entity slot to use (0-3)
+        botName: "My Bot"
+```
+
+## Getting API Credentials
+
+1. Log in to [E-Claw Portal](https://eclawbot.com/portal)
+2. Go to **Settings → Channel API**
+3. Copy your `API Key` and `API Secret`
+
+## How It Works
+
+```
+User (Android) ──speaks──▶ E-Claw Backend ──webhook──▶ OpenClaw Agent
+OpenClaw Agent ──replies──▶ POST /api/channel/message ──▶ User (Android)
+```
+
+- **Inbound**: E-Claw POSTs structured JSON to a webhook URL registered by this plugin
+- **Outbound**: Plugin calls `POST /api/channel/message` with the bot reply
+- **Auth**: `eck_`/`ecs_` channel credentials for API auth, per-entity `botSecret` for message auth
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ECLAW_WEBHOOK_URL` | Production | Public URL for receiving inbound messages |
+| `ECLAW_WEBHOOK_PORT` | Optional | Webhook server port (default: random) |
+
+## License
+
+MIT

package/dist/channel.d.ts

@@ -0,0 +1,43 @@
+import { listAccountIds, resolveAccount } from './config.js';
+import { sendText, sendMedia } from './outbound.js';
+import { startAccount } from './gateway.js';
+/**
+ * E-Claw ChannelPlugin definition.
+ *
+ * This is the core contract that OpenClaw requires for any channel provider.
+ * It enables E-Claw to appear alongside Telegram, Discord, Slack, etc.
+ * in the OpenClaw channel list.
+ */
+export declare const eclawChannel: {
+    id: string;
+    meta: {
+        id: string;
+        label: string;
+        selectionLabel: string;
+        docsPath: string;
+        blurb: string;
+        aliases: string[];
+    };
+    capabilities: {
+        chatTypes: readonly ["direct"];
+        media: boolean;
+        reactions: boolean;
+        threads: boolean;
+        polls: boolean;
+        nativeCommands: boolean;
+        blockStreaming: boolean;
+    };
+    config: {
+        listAccountIds: typeof listAccountIds;
+        resolveAccount: typeof resolveAccount;
+    };
+    outbound: {
+        deliveryMode: "direct";
+        textChunkLimit: number;
+        sendText: typeof sendText;
+        sendMedia: typeof sendMedia;
+    };
+    gateway: {
+        startAccount: typeof startAccount;
+    };
+};

package/dist/channel.js

@@ -0,0 +1,43 @@
+import { listAccountIds, resolveAccount } from './config.js';
+import { sendText, sendMedia } from './outbound.js';
+import { startAccount } from './gateway.js';
+/**
+ * E-Claw ChannelPlugin definition.
+ *
+ * This is the core contract that OpenClaw requires for any channel provider.
+ * It enables E-Claw to appear alongside Telegram, Discord, Slack, etc.
+ * in the OpenClaw channel list.
+ */
+export const eclawChannel = {
+    id: 'eclaw',
+    meta: {
+        id: 'eclaw',
+        label: 'E-Claw',
+        selectionLabel: 'E-Claw (AI Live Wallpaper Chat)',
+        docsPath: '/channels/eclaw',
+        blurb: 'Connect OpenClaw to E-Claw — an AI chat platform for live wallpaper entities on Android.',
+        aliases: ['eclaw', 'claw', 'e-claw'],
+    },
+    capabilities: {
+        chatTypes: ['direct'],
+        media: true,
+        reactions: false,
+        threads: false,
+        polls: false,
+        nativeCommands: false,
+        blockStreaming: false,
+    },
+    config: {
+        listAccountIds,
+        resolveAccount,
+    },
+    outbound: {
+        deliveryMode: 'direct',
+        textChunkLimit: 4000,
+        sendText,
+        sendMedia,
+    },
+    gateway: {
+        startAccount,
+    },
+};

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+import type { EClawAccountConfig, RegisterResponse, BindResponse, MessageResponse } from './types.js';
+/**
+ * HTTP client for E-Claw Channel API.
+ * Handles all communication between the OpenClaw plugin and the E-Claw backend.
+ */
+export declare class EClawClient {
+    private readonly apiBase;
+    private readonly apiKey;
+    private readonly apiSecret;
+    private deviceId;
+    private botSecret;
+    private entityId;
+    constructor(config: EClawAccountConfig);
+    /** Register callback URL with E-Claw backend */
+    registerCallback(callbackUrl: string, callbackToken: string): Promise<RegisterResponse>;
+    /** Bind an entity via channel API (bypasses 6-digit code) */
+    bindEntity(entityId: number, name?: string): Promise<BindResponse>;
+    /** Send bot message to user */
+    sendMessage(message: string, state?: string, mediaType?: string, mediaUrl?: string): Promise<MessageResponse>;
+    /** Unregister callback on shutdown */
+    unregisterCallback(): Promise<void>;
+    get currentDeviceId(): string | null;
+    get currentBotSecret(): string | null;
+    get currentEntityId(): number;
+}

package/dist/client.js

@@ -0,0 +1,93 @@
+/**
+ * HTTP client for E-Claw Channel API.
+ * Handles all communication between the OpenClaw plugin and the E-Claw backend.
+ */
+export class EClawClient {
+    apiBase;
+    apiKey;
+    apiSecret;
+    deviceId = null;
+    botSecret = null;
+    entityId;
+    constructor(config) {
+        this.apiBase = config.apiBase;
+        this.apiKey = config.apiKey;
+        this.apiSecret = config.apiSecret;
+        this.entityId = config.entityId;
+    }
+    /** Register callback URL with E-Claw backend */
+    async registerCallback(callbackUrl, callbackToken) {
+        const res = await fetch(`${this.apiBase}/api/channel/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                channel_api_key: this.apiKey,
+                channel_api_secret: this.apiSecret,
+                callback_url: callbackUrl,
+                callback_token: callbackToken,
+            }),
+        });
+        const data = await res.json();
+        if (!data.success) {
+            throw new Error(data.message || `Registration failed (HTTP ${res.status})`);
+        }
+        this.deviceId = data.deviceId;
+        return data;
+    }
+    /** Bind an entity via channel API (bypasses 6-digit code) */
+    async bindEntity(entityId, name) {
+        const res = await fetch(`${this.apiBase}/api/channel/bind`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                channel_api_key: this.apiKey,
+                channel_api_secret: this.apiSecret,
+                entityId,
+                name: name || undefined,
+            }),
+        });
+        const data = await res.json();
+        if (!data.success) {
+            throw new Error(data.message || `Bind failed (HTTP ${res.status})`);
+        }
+        this.botSecret = data.botSecret;
+        this.deviceId = data.deviceId;
+        this.entityId = entityId;
+        return data;
+    }
+    /** Send bot message to user */
+    async sendMessage(message, state = 'IDLE', mediaType, mediaUrl) {
+        if (!this.deviceId || !this.botSecret) {
+            throw new Error('Not bound — call bindEntity() first');
+        }
+        const res = await fetch(`${this.apiBase}/api/channel/message`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                channel_api_key: this.apiKey,
+                deviceId: this.deviceId,
+                entityId: this.entityId,
+                botSecret: this.botSecret,
+                message,
+                state,
+                ...(mediaType && { mediaType }),
+                ...(mediaUrl && { mediaUrl }),
+            }),
+        });
+        return await res.json();
+    }
+    /** Unregister callback on shutdown */
+    async unregisterCallback() {
+        await fetch(`${this.apiBase}/api/channel/register`, {
+            method: 'DELETE',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                channel_api_key: this.apiKey,
+                channel_api_secret: this.apiSecret,
+            }),
+        });
+    }
+    get currentDeviceId() { return this.deviceId; }
+    get currentBotSecret() { return this.botSecret; }
+    get currentEntityId() { return this.entityId; }
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { EClawAccountConfig } from './types.js';
+/** List all configured account IDs from OpenClaw config */
+export declare function listAccountIds(cfg: any): string[];
+/** Resolve a specific account's config, with defaults */
+export declare function resolveAccount(cfg: any, accountId?: string): EClawAccountConfig;

package/dist/config.js

@@ -0,0 +1,23 @@
+/** List all configured account IDs from OpenClaw config */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function listAccountIds(cfg) {
+    const accounts = cfg?.channels?.eclaw?.accounts;
+    if (!accounts || typeof accounts !== 'object')
+        return [];
+    return Object.keys(accounts);
+}
+/** Resolve a specific account's config, with defaults */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function resolveAccount(cfg, accountId) {
+    const accounts = cfg?.channels?.eclaw?.accounts ?? {};
+    const id = accountId ?? Object.keys(accounts)[0] ?? 'default';
+    const account = accounts[id];
+    return {
+        enabled: account?.enabled ?? true,
+        apiKey: account?.apiKey ?? '',
+        apiSecret: account?.apiSecret ?? '',
+        apiBase: (account?.apiBase ?? 'https://eclawbot.com').replace(/\/$/, ''),
+        entityId: account?.entityId ?? 0,
+        botName: account?.botName,
+    };
+}

package/dist/gateway.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Gateway lifecycle: start an E-Claw account.
+ *
+ * 1. Initialize HTTP client with channel API credentials
+ * 2. Start a local HTTP server to receive webhook callbacks
+ * 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
+ */
+export declare function startAccount(ctx: any): Promise<void>;

package/dist/gateway.js

@@ -0,0 +1,106 @@
+import { createServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { resolveAccount } from './config.js';
+import { EClawClient } from './client.js';
+import { setClient } from './outbound.js';
+import { createWebhookHandler } from './webhook-handler.js';
+/**
+ * Gateway lifecycle: start an E-Claw account.
+ *
+ * 1. Initialize HTTP client with channel API credentials
+ * 2. Start a local HTTP server to receive webhook callbacks
+ * 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
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function startAccount(ctx) {
+    const { accountId, config } = ctx;
+    const account = resolveAccount(config, accountId);
+    if (!account.enabled || !account.apiKey || !account.apiSecret) {
+        console.log(`[E-Claw] Account ${accountId} disabled or missing credentials, skipping`);
+        return;
+    }
+    // Initialize HTTP client
+    const client = new EClawClient(account);
+    setClient(accountId, client);
+    // Generate per-session callback token
+    const callbackToken = randomBytes(32).toString('hex');
+    // Determine webhook configuration
+    const webhookPort = parseInt(process.env.ECLAW_WEBHOOK_PORT || '0') || 0;
+    const publicUrl = process.env.ECLAW_WEBHOOK_URL;
+    if (!publicUrl) {
+        console.warn('[E-Claw] ECLAW_WEBHOOK_URL not set. Set this to your public-facing URL ' +
+            'so E-Claw can send messages to this plugin. Example: https://my-openclaw.example.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);
+            });
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    };
+    const server = createServer(requestHandler);
+    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`);
+                    // For already-bound entities, we need to get the botSecret
+                    // The bind endpoint returns existing credentials for channel-bound entities
+                    const bindData = await client.bindEntity(account.entityId, account.botName);
+                    console.log(`[E-Claw] Retrieved credentials for entity ${account.entityId}`);
+                    void bindData; // credentials stored in client
+                }
+                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();
+                resolve();
+            });
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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;
+    description: string;
+    register(api: any): void;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,36 @@
+import { setPluginRuntime } from './runtime.js';
+import { eclawChannel } from './channel.js';
+/**
+ * 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)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const plugin = {
+    id: 'eclaw',
+    name: 'E-Claw',
+    description: 'E-Claw AI chat platform channel plugin',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    register(api) {
+        console.log('[E-Claw] Plugin loaded');
+        setPluginRuntime(api.runtime);
+        api.registerChannel({ plugin: eclawChannel });
+    },
+};
+export default plugin;

package/dist/outbound.d.ts

@@ -0,0 +1,7 @@
+import { EClawClient } from './client.js';
+export declare function setClient(accountId: string, client: EClawClient): void;
+export declare function getClient(accountId: string): EClawClient | undefined;
+/** OpenClaw outbound: send text message to E-Claw user */
+export declare function sendText(ctx: any): Promise<any>;
+/** OpenClaw outbound: send media message to E-Claw user */
+export declare function sendMedia(ctx: any): Promise<any>;

package/dist/outbound.js

@@ -0,0 +1,56 @@
+/** Client instances keyed by accountId */
+const clients = new Map();
+export function setClient(accountId, client) {
+    clients.set(accountId, client);
+}
+export function getClient(accountId) {
+    return clients.get(accountId);
+}
+/** OpenClaw outbound: send text message to E-Claw user */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function sendText(ctx) {
+    const accountId = ctx.accountId ?? 'default';
+    const client = clients.get(accountId);
+    if (!client) {
+        return { channel: 'eclaw', messageId: '', chatId: '' };
+    }
+    try {
+        const result = await client.sendMessage(ctx.text, 'IDLE');
+        return {
+            channel: 'eclaw',
+            messageId: `eclaw-${Date.now()}`,
+            chatId: ctx.to ?? ctx.conversationId ?? '',
+            ok: result.success,
+        };
+    }
+    catch (err) {
+        console.error('[E-Claw] sendText failed:', err);
+        return { channel: 'eclaw', messageId: '', chatId: '' };
+    }
+}
+/** OpenClaw outbound: send media message to E-Claw user */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function sendMedia(ctx) {
+    const accountId = ctx.accountId ?? 'default';
+    const client = clients.get(accountId);
+    if (!client) {
+        return { channel: 'eclaw', messageId: '', chatId: '' };
+    }
+    try {
+        // Map OpenClaw media types to E-Claw types
+        const mediaType = ctx.mediaType === 'image' ? 'photo'
+            : ctx.mediaType === 'audio' ? 'voice'
+                : ctx.mediaType ?? 'file';
+        const result = await client.sendMessage(ctx.text || `[${mediaType}]`, 'IDLE', mediaType, ctx.mediaUrl);
+        return {
+            channel: 'eclaw',
+            messageId: `eclaw-${Date.now()}`,
+            chatId: ctx.to ?? ctx.conversationId ?? '',
+            ok: result.success,
+        };
+    }
+    catch (err) {
+        console.error('[E-Claw] sendMedia failed:', err);
+        return { channel: 'eclaw', messageId: '', chatId: '' };
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * PluginRuntime singleton storage.
+ * Every OpenClaw channel plugin follows this pattern — store the runtime
+ * received during register() so other modules can access it.
+ */
+export declare function setPluginRuntime(runtime: any): void;
+export declare function getPluginRuntime(): any;

package/dist/runtime.js

@@ -0,0 +1,20 @@
+/**
+ * PluginRuntime singleton storage.
+ * Every OpenClaw channel plugin follows this pattern — store the runtime
+ * received during register() so other modules can access it.
+ */
+// Using `any` because the PluginRuntime type comes from openclaw/plugin-sdk
+// which is only available when installed as a plugin within OpenClaw.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let pluginRuntime = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function setPluginRuntime(runtime) {
+    pluginRuntime = runtime;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getPluginRuntime() {
+    if (!pluginRuntime) {
+        throw new Error('[E-Claw] Plugin runtime not initialized');
+    }
+    return pluginRuntime;
+}

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/** E-Claw account configuration from OpenClaw config.yaml */
+export interface EClawAccountConfig {
+    enabled: boolean;
+    apiKey: string;
+    apiSecret: string;
+    apiBase: string;
+    entityId: number;
+    botName?: string;
+}
+/** Inbound message from E-Claw callback webhook */
+export interface EClawInboundMessage {
+    event: 'message' | 'entity_message' | 'broadcast' | 'cross_device_message';
+    deviceId: string;
+    entityId: number;
+    conversationId: string;
+    from: string;
+    text: string;
+    mediaType?: 'photo' | 'voice' | 'video' | 'file' | null;
+    mediaUrl?: string | null;
+    backupUrl?: string | null;
+    timestamp: number;
+    isBroadcast: boolean;
+    broadcastRecipients?: number[] | null;
+    fromEntityId?: number;
+    fromCharacter?: string;
+    fromPublicCode?: string;
+}
+/** Entity info returned by channel register */
+export interface EClawEntityInfo {
+    entityId: number;
+    isBound: boolean;
+    name: string | null;
+    character: string;
+    bindingType: string | null;
+}
+/** Response from POST /api/channel/register */
+export interface RegisterResponse {
+    success: boolean;
+    deviceId: string;
+    entities: EClawEntityInfo[];
+    maxEntities: number;
+}
+/** Response from POST /api/channel/bind */
+export interface BindResponse {
+    success: boolean;
+    deviceId: string;
+    entityId: number;
+    botSecret: string;
+    publicCode: string;
+    bindingType: string;
+}
+/** Response from POST /api/channel/message */
+export interface MessageResponse {
+    success: boolean;
+    currentState?: {
+        name: string;
+        state: string;
+        message: string;
+        xp: number;
+        level: number;
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/webhook-handler.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function createWebhookHandler(expectedToken: string, accountId: string): (req: any, res: any) => Promise<void>;

package/dist/webhook-handler.js

@@ -0,0 +1,60 @@
+import { getPluginRuntime } from './runtime.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.
+ */
+export function createWebhookHandler(expectedToken, accountId) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return async (req, res) => {
+        // Verify callback token
+        const authHeader = req.headers?.authorization;
+        if (expectedToken && (!authHeader || authHeader !== `Bearer ${expectedToken}`)) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Unauthorized' }));
+            return;
+        }
+        const msg = req.body;
+        // ACK immediately so E-Claw doesn't time out
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+        // Dispatch to OpenClaw agent
+        try {
+            const rt = getPluginRuntime();
+            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 };
+            }
+            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,
+                },
+            };
+            // OpenClaw inbound dispatch pipeline
+            const ctx = await rt.channel.reply.finalizeInboundContext(inboundCtx);
+            await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher(ctx);
+        }
+        catch (err) {
+            console.error('[E-Claw] Webhook dispatch error:', err);
+        }
+    };
+}

package/openclaw.plugin.json

@@ -0,0 +1,27 @@
+{
+  "id": "eclaw",
+  "name": "E-Claw",
+  "version": "1.0.0",
+  "description": "E-Claw AI chat platform channel for OpenClaw",
+  "channels": ["eclaw"],
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "accounts": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "properties": {
+            "enabled": { "type": "boolean", "default": true },
+            "apiKey": { "type": "string", "description": "Channel API Key (eck_...)" },
+            "apiSecret": { "type": "string", "description": "Channel API Secret (ecs_...)" },
+            "apiBase": { "type": "string", "default": "https://eclawbot.com" },
+            "entityId": { "type": "number", "default": 0, "minimum": 0, "maximum": 7 },
+            "botName": { "type": "string", "maxLength": 20 }
+          },
+          "required": ["apiKey", "apiSecret"]
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@eclaw/openclaw-channel",
+  "version": "1.0.0",
+  "description": "E-Claw channel plugin for OpenClaw — AI chat platform for live wallpaper entities",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "channel": {
+      "id": "eclaw",
+      "label": "E-Claw",
+      "selectionLabel": "E-Claw (AI Live Wallpaper Chat)",
+      "docsPath": "https://github.com/HankHuang0516/openclaw-channel-eclaw#readme",
+      "description": "Connect OpenClaw to E-Claw — an AI chat platform for live wallpaper entities on Android."
+    },
+    "install": {
+      "npmSpec": "@eclaw/openclaw-channel"
+    }
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-channel",
+    "channel",
+    "eclaw",
+    "ai-agent",
+    "live-wallpaper"
+  ],
+  "author": "HankHuang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HankHuang0516/openclaw-channel-eclaw.git"
+  },
+  "devDependencies": {
+    "typescript": "^5.4",
+    "vitest": "^2.0",
+    "@types/node": "^20"
+  }
+}