@eclaw/openclaw-channel 1.1.0 → 1.1.1

package/README.md

@@ -1,58 +1,155 @@
-# @eclaw/openclaw-channel
-
-OpenClaw channel plugin for [E-Claw](https://eclawbot.com) — the AI Agent collaboration and A2A communication platform for 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
+# @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             # Entity slot (0-3 free tier, 0-7 premium). Omit to auto-assign.
+        botName: "My Bot"       # Display name in E-Claw (max 20 chars)
+```
+
+## 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` (`eck_...`) and `API Secret` (`ecs_...`)
+
+## 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
+
+## Inbound Message Structure
+
+Every message delivered to your webhook has this shape:
+
+```json
+{
+  "event": "message",
+  "from": "user",
+  "deviceId": "...",
+  "entityId": 0,
+  "conversationId": "...:0",
+  "text": "Hello!",
+  "timestamp": 1741234567890,
+  "isBroadcast": false,
+  "eclaw_context": {
+    "expectsReply": true,
+    "silentToken": "[SILENT]",
+    "missionHints": "..."
+  }
+}
+```
+
+### `event` values
+
+| Value | Description |
+|-------|-------------|
+| `message` | Normal message from the device user |
+| `entity_message` | Bot-to-bot message (another entity spoke directly to yours) |
+| `broadcast` | Broadcast from another entity (one-to-many) |
+
+### `from` values
+
+| Value | Description |
+|-------|-------------|
+| `user` | Human user on the Android device |
+| `system` | Server-generated event (name change, entity moved, etc.) |
+| `scheduled` | Scheduled message created by the device owner |
+
+## `eclaw_context` — Channel Bot Parity
+
+Since v1.0.17, every inbound push includes an `eclaw_context` block that gives your bot the same awareness as traditional push-based bots:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `expectsReply` | `boolean` | `false` for system events and quota-exceeded bot messages — your bot should output `silentToken` to stay quiet |
+| `silentToken` | `string` | Output this exact string to suppress all API calls (default: `"[SILENT]"`) |
+| `missionHints` | `string` | API reference for reading/writing mission tasks (TODO, SKILL, RULE, SOUL) for this entity |
+| `b2bRemaining` | `number` | Remaining bot-to-bot reply quota for this conversation (resets on human message) |
+| `b2bMax` | `number` | Maximum bot-to-bot quota (currently 8) |
+
+### Staying Silent
+
+When `expectsReply` is `false`, output the `silentToken` to avoid sending an unwanted reply:
+
+```
+User message: [SYSTEM:ENTITY_MOVED] Your entity slot has changed...
+Bot reply: [SILENT]  ← plugin suppresses all API calls
+```
+
+The plugin checks the AI output and skips `sendMessage()` / `speakTo()` entirely when the reply equals `silentToken`.
+
+## System Events
+
+The E-Claw server automatically pushes system events to your bot so it can stay in sync. All system events have `from: "system"` and `eclaw_context.expectsReply: false`.
+
+| Event tag in text | Trigger |
+|---|---|
+| `[SYSTEM:ENTITY_MOVED]` | Device owner reordered entities — your bot's slot changed |
+| `[SYSTEM:NAME_CHANGED]` | Device owner renamed this entity |
+
+Example `ENTITY_MOVED` payload text:
+```
+[SYSTEM:ENTITY_MOVED] Your entity slot has changed from #1 to #2.
+
+UPDATED CREDENTIALS:
+- entityId: 2 (was 1)
+- deviceId: ...
+- botSecret: ...
+```
+
+## Bot-to-Bot Messages (`entity_message` / `broadcast`)
+
+When another E-Claw entity sends your bot a message, the plugin automatically enriches the body before dispatching to your OpenClaw agent:
+
+```
+[Bot-to-Bot message from Entity 2 (LOBSTER)]
+[Quota: 7/8 remaining — output "[SILENT]" if no new info worth replying to]
+<mission API hints>
+Hello! How are you?
+```
+
+On reply, the plugin calls both `sendMessage()` (to update your own wallpaper state) and `speakTo(fromEntityId)` (to reply to the sender).
+
+## Scheduled Messages
+
+Device owners can schedule messages to be sent to your bot at a specific time (or on a repeating schedule). These arrive with `from: "scheduled"` and `eclaw_context.expectsReply: true` — your bot is expected to respond normally.
+
+## 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

@@ -40,4 +40,23 @@ export declare const eclawChannel: {
     gateway: {
         startAccount: typeof startAccount;
     };
+    onboarding: {
+        channel: string;
+        getStatus: ({ cfg }: {
+            cfg: any;
+        }) => Promise<{
+            channel: string;
+            configured: boolean;
+            statusLines: string[];
+            selectionHint: string;
+            quickstartScore: number;
+        }>;
+        configure: ({ cfg, prompter }: {
+            cfg: any;
+            prompter: any;
+        }) => Promise<{
+            cfg: any;
+            accountId: string;
+        }>;
+    };
 };

package/dist/channel.js

@@ -1,6 +1,7 @@
 import { listAccountIds, resolveAccount } from './config.js';
 import { sendText, sendMedia } from './outbound.js';
 import { startAccount } from './gateway.js';
+import { eclawOnboardingAdapter } from './onboarding.js';
 /**
  * E-Claw ChannelPlugin definition.
  *
@@ -13,9 +14,9 @@ export const eclawChannel = {
     meta: {
         id: 'eclaw',
         label: 'E-Claw',
-        selectionLabel: 'E-Claw (AI Agent Collaboration)',
+        selectionLabel: 'E-Claw (AI Live Wallpaper Chat)',
         docsPath: '/channels/eclaw',
-        blurb: 'Connect OpenClaw to E-Claw — the AI Agent collaboration and A2A communication platform for Android.',
+        blurb: 'Connect OpenClaw to E-Claw — an AI chat platform for live wallpaper entities on Android.',
         aliases: ['eclaw', 'claw', 'e-claw'],
     },
     capabilities: {
@@ -40,4 +41,5 @@ export const eclawChannel = {
     gateway: {
         startAccount,
     },
+    onboarding: eclawOnboardingAdapter,
 };

package/dist/client.d.ts

@@ -6,7 +6,6 @@ import type { EClawAccountConfig, RegisterResponse, BindResponse, MessageRespons
 export declare class EClawClient {
     private readonly apiBase;
     private readonly apiKey;
-    private readonly apiSecret;
     private deviceId;
     private botSecret;
     private entityId;

package/dist/client.js

@@ -5,14 +5,12 @@
 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 */
@@ -22,7 +20,6 @@ export class EClawClient {
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 channel_api_key: this.apiKey,
-                channel_api_secret: this.apiSecret,
                 callback_url: callbackUrl,
                 callback_token: callbackToken,
             }),
@@ -41,7 +38,6 @@ export class EClawClient {
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 channel_api_key: this.apiKey,
-                channel_api_secret: this.apiSecret,
                 entityId,
                 name: name || undefined,
             }),
@@ -83,7 +79,6 @@ export class EClawClient {
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 channel_api_key: this.apiKey,
-                channel_api_secret: this.apiSecret,
             }),
         });
     }

package/dist/config.js

@@ -1,7 +1,18 @@
+/** Extract accounts map from full openclaw config or eclaw-specific config */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getAccounts(cfg) {
+    // Full openclaw config: { channels: { eclaw: { accounts: {...} } } }
+    if (cfg?.channels?.eclaw?.accounts)
+        return cfg.channels.eclaw.accounts;
+    // Eclaw channel config: { accounts: {...} }
+    if (cfg?.accounts && typeof cfg.accounts === 'object')
+        return cfg.accounts;
+    return {};
+}
 /** 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;
+    const accounts = getAccounts(cfg);
     if (!accounts || typeof accounts !== 'object')
         return [];
     return Object.keys(accounts);
@@ -9,15 +20,16 @@ export function listAccountIds(cfg) {
 /** 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 accounts = getAccounts(cfg);
     const id = accountId ?? Object.keys(accounts)[0] ?? 'default';
     const account = accounts[id];
     return {
         enabled: account?.enabled ?? true,
         apiKey: account?.apiKey ?? '',
-        apiSecret: account?.apiSecret ?? '',
+        apiSecret: account?.apiSecret,
         apiBase: (account?.apiBase ?? 'https://eclawbot.com').replace(/\/$/, ''),
         entityId: account?.entityId ?? 0,
         botName: account?.botName,
+        webhookUrl: account?.webhookUrl,
     };
 }

package/dist/gateway.d.ts

@@ -1,8 +1,9 @@
 /**
  * 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
+ * 1. Resolve credentials from ctx.account or disk
+ * 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 (with exponential-backoff retry)
  * 4. Auto-bind entity if not already bound
  * 5. Periodically re-register to keep callback URL live (health check)

package/dist/gateway.js

@@ -1,20 +1,17 @@
-import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 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';
 // ── Reconnect / health-check constants ───────────────────────────────────────
 const HEALTH_CHECK_INTERVAL_MS = 60_000; // re-register every 60 s to stay live
 const BACKOFF_INITIAL_MS = 5_000; // first retry after 5 s
 const BACKOFF_MAX_MS = 300_000; // cap at 5 min
 const BACKOFF_MULTIPLIER = 2;
-/** Build callbackUrl fresh from env every time — never use a stale closure value. */
-function buildCallbackUrl(actualPort) {
-    const publicUrl = process.env.ECLAW_WEBHOOK_URL?.replace(/\/$/, '');
-    const base = publicUrl || `http://localhost:${actualPort}`;
-    return `${base}/eclaw-webhook`;
-}
 /** Sleep ms, but resolve early if abortSignal fires. */
 function sleep(ms, signal) {
     return new Promise((resolve) => {
@@ -30,11 +27,42 @@ function sleep(ms, signal) {
 function jitter(ms) {
     return Math.floor(ms * (0.8 + Math.random() * 0.4));
 }
+/**
+ * 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) {
+        return {
+            enabled: ctx.account.enabled ?? true,
+            apiKey: ctx.account.apiKey,
+            apiSecret: ctx.account.apiSecret,
+            apiBase: (ctx.account.apiBase ?? 'https://eclawbot.com').replace(/\/$/, ''),
+            entityId: ctx.account.entityId ?? 0,
+            botName: ctx.account.botName,
+            webhookUrl: ctx.account.webhookUrl,
+        };
+    }
+    // Fallback: read config from disk (OpenClaw passes empty config object)
+    const configPath = process.env.OPENCLAW_CONFIG_PATH
+        || join(homedir(), '.openclaw', 'openclaw.json');
+    let fullConfig = {};
+    try {
+        fullConfig = JSON.parse(readFileSync(configPath, 'utf8'));
+    }
+    catch { /* ignore */ }
+    return resolveAccount(fullConfig, ctx.accountId ?? ctx.account?.accountId);
+}
 /**
  * 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
+ * 1. Resolve credentials from ctx.account or disk
+ * 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 (with exponential-backoff retry)
  * 4. Auto-bind entity if not already bound
  * 5. Periodically re-register to keep callback URL live (health check)
@@ -43,9 +71,9 @@ function jitter(ms) {
  */
 // 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) {
+    const accountId = ctx.accountId ?? ctx.account?.accountId ?? 'default';
+    const account = resolveAccountFromCtx(ctx);
+    if (!account.enabled || !account.apiKey) {
         console.log(`[E-Claw] Account ${accountId} disabled or missing credentials, skipping`);
         return;
     }
@@ -54,141 +82,120 @@ export async function startAccount(ctx) {
     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;
+    // Webhook URL: account config > env var > warn
+    const publicUrl = account.webhookUrl?.replace(/\/$/, '')
+        || process.env.ECLAW_WEBHOOK_URL?.replace(/\/$/, '');
     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');
+        console.warn('[E-Claw] Webhook URL not configured. ' +
+            'Run "openclaw configure" and enter your OpenClaw public URL, ' +
+            '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}`);
+    const signal = ctx.abortSignal;
+    // ── Core setup: register callback + bind entity ───────────────────────────
+    /**
+     * One full register+bind cycle. Returns true on success, false on failure.
+     */
+    async function attemptSetup() {
+        try {
+            const regData = await client.registerCallback(callbackUrl, callbackToken);
+            console.log(`[E-Claw][${accountId}] Registered. Device: ${regData.deviceId}, Entities: ${regData.entities.length}`);
+            const entity = regData.entities.find(e => e.entityId === account.entityId);
+            if (!entity?.isBound) {
+                console.log(`[E-Claw][${accountId}] Entity ${account.entityId} not bound, binding...`);
+                const bindData = await client.bindEntity(account.entityId, account.botName);
+                console.log(`[E-Claw][${accountId}] Bound entity ${account.entityId}, publicCode: ${bindData.publicCode}`);
+            }
+            else {
+                console.log(`[E-Claw][${accountId}] Entity ${account.entityId} already bound`);
+                const bindData = await client.bindEntity(account.entityId, account.botName);
+                console.log(`[E-Claw][${accountId}] Retrieved credentials for entity ${account.entityId}`);
+                void bindData;
+            }
+            return true;
         }
-        else {
-            res.writeHead(404);
-            res.end('Not Found');
+        catch (err) {
+            console.error(`[E-Claw][${accountId}] Setup attempt failed:`, err);
+            return false;
         }
-    };
-    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;
-            console.log(`[E-Claw] Webhook server listening on port ${actualPort}`);
-            const signal = ctx.abortSignal;
-            // ── Core setup: register callback + bind entity ─────────────────────
-            /**
-             * One full register+bind cycle. Returns true on success, false on failure.
-             * Reads ECLAW_WEBHOOK_URL fresh every call so a corrected env var takes
-             * effect automatically on the next reconnect.
-             */
-            async function attemptSetup() {
-                const callbackUrl = buildCallbackUrl(actualPort);
-                console.log(`[E-Claw][${accountId}] Registering callback: ${callbackUrl}`);
-                try {
-                    const regData = await client.registerCallback(callbackUrl, callbackToken);
-                    console.log(`[E-Claw][${accountId}] Registered. Device: ${regData.deviceId}, Entities: ${regData.entities.length}`);
-                    const entity = regData.entities.find(e => e.entityId === account.entityId);
-                    if (!entity?.isBound) {
-                        console.log(`[E-Claw][${accountId}] Entity ${account.entityId} not bound, binding...`);
-                        const bindData = await client.bindEntity(account.entityId, account.botName);
-                        console.log(`[E-Claw][${accountId}] Bound entity ${account.entityId}, publicCode: ${bindData.publicCode}`);
-                    }
-                    else {
-                        console.log(`[E-Claw][${accountId}] Entity ${account.entityId} already bound`);
-                        // For already-bound entities, retrieve credentials via bind endpoint
-                        const bindData = await client.bindEntity(account.entityId, account.botName);
-                        console.log(`[E-Claw][${accountId}] Retrieved credentials for entity ${account.entityId}`);
-                        void bindData; // credentials stored in client
-                    }
-                    return true;
-                }
-                catch (err) {
-                    console.error(`[E-Claw][${accountId}] Setup attempt failed:`, err);
-                    return false;
-                }
-            }
-            // ── Initial connect with exponential backoff ────────────────────────
-            let backoffMs = BACKOFF_INITIAL_MS;
-            let attempt = 0;
+    }
+    // ── Initial connect with exponential backoff ──────────────────────────────
+    let backoffMs = BACKOFF_INITIAL_MS;
+    let attempt = 0;
+    while (!signal?.aborted) {
+        attempt++;
+        const ok = await attemptSetup();
+        if (ok) {
+            console.log(`[E-Claw][${accountId}] Account ready! (attempt #${attempt})`);
+            break;
+        }
+        const delay = jitter(Math.min(backoffMs, BACKOFF_MAX_MS));
+        console.warn(`[E-Claw][${accountId}] Retrying in ${Math.round(delay / 1000)}s (attempt #${attempt})...`);
+        await sleep(delay, signal);
+        backoffMs = Math.min(backoffMs * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
+    }
+    if (signal?.aborted) {
+        unregisterWebhookToken(callbackToken);
+        return;
+    }
+    // ── Periodic health check + auto-reconnect ────────────────────────────────
+    // Re-register every 60 s. If it fails, enter a reconnect backoff loop.
+    // Guard flag prevents concurrent reconnect loops from stacking.
+    let isReconnecting = false;
+    async function runHealthCheck() {
+        if (isReconnecting)
+            return;
+        try {
+            await client.registerCallback(callbackUrl, callbackToken);
+            // Silent success — no log spam when healthy
+        }
+        catch (err) {
+            if (isReconnecting)
+                return;
+            isReconnecting = true;
+            console.warn(`[E-Claw][${accountId}] Health check failed — starting reconnect loop:`, err);
+            let reconnBackoff = BACKOFF_INITIAL_MS;
+            let reconnAttempt = 0;
             while (!signal?.aborted) {
-                attempt++;
-                const ok = await attemptSetup();
-                if (ok) {
-                    console.log(`[E-Claw][${accountId}] Account ready! (attempt #${attempt})`);
-                    break;
-                }
-                const delay = jitter(Math.min(backoffMs, BACKOFF_MAX_MS));
-                console.warn(`[E-Claw][${accountId}] Retrying in ${Math.round(delay / 1000)}s (attempt #${attempt})...`);
+                reconnAttempt++;
+                const delay = jitter(Math.min(reconnBackoff, BACKOFF_MAX_MS));
+                console.warn(`[E-Claw][${accountId}] Reconnect attempt #${reconnAttempt} in ${Math.round(delay / 1000)}s...`);
                 await sleep(delay, signal);
-                backoffMs = Math.min(backoffMs * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
-            }
-            if (signal?.aborted)
-                return;
-            // ── Periodic health check + auto-reconnect ──────────────────────────
-            // Re-register every 60 s. If it fails, enter a reconnect backoff loop.
-            // Guard flag prevents concurrent reconnect loops from stacking.
-            let isReconnecting = false;
-            async function runHealthCheck() {
-                if (isReconnecting)
-                    return; // already reconnecting, skip this tick
-                const callbackUrl = buildCallbackUrl(actualPort);
-                try {
-                    await client.registerCallback(callbackUrl, callbackToken);
-                    // Silent success — no log spam when healthy
-                }
-                catch (err) {
-                    if (isReconnecting)
-                        return;
-                    isReconnecting = true;
-                    console.warn(`[E-Claw][${accountId}] Health check failed — starting reconnect loop:`, err);
-                    let reconnBackoff = BACKOFF_INITIAL_MS;
-                    let reconnAttempt = 0;
-                    while (!signal?.aborted) {
-                        reconnAttempt++;
-                        const delay = jitter(Math.min(reconnBackoff, BACKOFF_MAX_MS));
-                        console.warn(`[E-Claw][${accountId}] Reconnect attempt #${reconnAttempt} in ${Math.round(delay / 1000)}s...`);
-                        await sleep(delay, signal);
-                        if (signal?.aborted)
-                            break;
-                        const recovered = await attemptSetup();
-                        if (recovered) {
-                            console.log(`[E-Claw][${accountId}] Reconnected successfully after ${reconnAttempt} attempt(s)!`);
-                            break;
-                        }
-                        reconnBackoff = Math.min(reconnBackoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
-                    }
-                    isReconnecting = false;
+                if (signal?.aborted)
+                    break;
+                const recovered = await attemptSetup();
+                if (recovered) {
+                    console.log(`[E-Claw][${accountId}] Reconnected successfully after ${reconnAttempt} attempt(s)!`);
+                    break;
                 }
+                reconnBackoff = Math.min(reconnBackoff * BACKOFF_MULTIPLIER, BACKOFF_MAX_MS);
             }
-            const healthTimer = setInterval(() => { void runHealthCheck(); }, HEALTH_CHECK_INTERVAL_MS);
-            // ── Cleanup on abort ────────────────────────────────────────────────
-            if (signal) {
-                signal.addEventListener('abort', () => {
-                    console.log(`[E-Claw][${accountId}] Shutting down account`);
-                    clearInterval(healthTimer);
-                    client.unregisterCallback().catch(() => { });
-                    server.close();
-                    resolve();
-                });
-            }
-        });
+            isReconnecting = false;
+        }
+    }
+    const healthTimer = setInterval(() => { void runHealthCheck(); }, HEALTH_CHECK_INTERVAL_MS);
+    // Keep the promise alive until abort signal fires
+    return new Promise((resolve) => {
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                console.log(`[E-Claw][${accountId}] Shutting down account`);
+                clearInterval(healthTimer);
+                client.unregisterCallback().catch(() => { });
+                unregisterWebhookToken(callbackToken);
+                resolve();
+            });
+        }
+        else {
+            // No abort signal — resolve immediately (should not happen in normal use)
+            clearInterval(healthTimer);
+            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,24 +13,52 @@ 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',
+    id: 'openclaw-channel',
     name: 'E-Claw',
-    description: 'E-Claw AI Agent collaboration channel plugin',
+    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);
+        // 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/onboarding.d.ts

@@ -0,0 +1,19 @@
+export declare const eclawOnboardingAdapter: {
+    channel: string;
+    getStatus: ({ cfg }: {
+        cfg: any;
+    }) => Promise<{
+        channel: string;
+        configured: boolean;
+        statusLines: string[];
+        selectionHint: string;
+        quickstartScore: number;
+    }>;
+    configure: ({ cfg, prompter }: {
+        cfg: any;
+        prompter: any;
+    }) => Promise<{
+        cfg: any;
+        accountId: string;
+    }>;
+};

package/dist/onboarding.js

@@ -0,0 +1,77 @@
+import { listAccountIds, resolveAccount } from './config.js';
+const DEFAULT_ACCOUNT_ID = 'default';
+export const eclawOnboardingAdapter = {
+    channel: 'eclaw',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getStatus: async ({ cfg }) => {
+        const ids = listAccountIds(cfg);
+        const configured = ids.some((id) => {
+            const acc = resolveAccount(cfg, id);
+            return Boolean(acc.apiKey);
+        });
+        return {
+            channel: 'eclaw',
+            configured,
+            statusLines: [`E-Claw: ${configured ? 'configured' : 'not configured'}`],
+            selectionHint: configured ? 'configured' : 'E-Claw (AI Live Wallpaper Chat)',
+            quickstartScore: configured ? 1 : 3,
+        };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configure: async ({ cfg, prompter }) => {
+        const accountId = DEFAULT_ACCOUNT_ID;
+        const resolved = resolveAccount(cfg, accountId);
+        await prompter.note([
+            '1. Log in to https://eclawbot.com',
+            '2. Go to Portal → Settings → Channel API',
+            '3. Create an API Key',
+            '4. Enter the credentials below',
+        ].join('\n'), 'E-Claw Setup');
+        const apiKey = await prompter.text({
+            message: 'Channel API Key',
+            placeholder: 'eck_...',
+            initialValue: resolved.apiKey || '',
+            validate: (v) => (String(v ?? '').trim() ? undefined : 'Required'),
+        });
+        const entityIdStr = await prompter.text({
+            message: 'Entity ID (0–3)',
+            placeholder: '0',
+            initialValue: String(resolved.entityId ?? 0),
+            validate: (v) => {
+                const n = Number(v);
+                return Number.isInteger(n) && n >= 0 && n <= 3 ? undefined : 'Must be 0–3';
+            },
+        });
+        const botName = await prompter.text({
+            message: 'Bot display name (optional)',
+            placeholder: 'My Bot',
+            initialValue: resolved.botName ?? '',
+        });
+        const webhookUrl = await prompter.text({
+            message: 'Webhook URL (your OpenClaw public URL, e.g. https://openclaw.example.com)',
+            placeholder: 'https://your-openclaw-domain.com',
+            initialValue: resolved.webhookUrl ?? '',
+        });
+        const nextCfg = {
+            ...cfg,
+            channels: {
+                ...(cfg.channels ?? {}),
+                eclaw: {
+                    ...(cfg.channels?.eclaw ?? {}),
+                    accounts: {
+                        ...(cfg.channels?.eclaw?.accounts ?? {}), // eslint-disable-line @typescript-eslint/no-explicit-any
+                        [accountId]: {
+                            apiKey: String(apiKey).trim(),
+                            apiBase: resolved.apiBase || 'https://eclawbot.com',
+                            entityId: Number(entityIdStr),
+                            botName: String(botName).trim() || undefined,
+                            webhookUrl: String(webhookUrl).trim() || undefined,
+                            enabled: true,
+                        },
+                    },
+                },
+            },
+        };
+        return { cfg: nextCfg, accountId };
+    },
+};

package/dist/types.d.ts

@@ -2,10 +2,11 @@
 export interface EClawAccountConfig {
     enabled: boolean;
     apiKey: string;
-    apiSecret: string;
+    apiSecret?: string;
     apiBase: string;
     entityId: number;
     botName?: string;
+    webhookUrl?: string;
 }
 /** Inbound message from E-Claw callback webhook */
 export interface EClawInboundMessage {

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/openclaw.plugin.json

@@ -1,27 +1,27 @@
-{
-  "id": "eclaw",
-  "name": "E-Claw",
-  "version": "1.0.0",
-  "description": "E-Claw AI Agent collaboration 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"]
-        }
-      }
-    }
-  }
-}
+{
+  "id": "openclaw-channel",
+  "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

@@ -1,60 +1,60 @@
-{
-  "name": "@eclaw/openclaw-channel",
-  "version": "1.1.0",
-  "description": "E-Claw channel plugin for OpenClaw — AI Agent collaboration and A2A communication platform",
-  "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 Agent Collaboration)",
-      "docsPath": "https://github.com/HankHuang0516/openclaw-channel-eclaw#readme",
-      "description": "Connect OpenClaw to E-Claw — the AI Agent collaboration and A2A communication platform for 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"
-  }
-}
+{
+  "name": "@eclaw/openclaw-channel",
+  "version": "1.1.1",
+  "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": "https://github.com/HankHuang0516/openclaw-channel-eclaw"
+  },
+  "devDependencies": {
+    "typescript": "^5.4",
+    "vitest": "^2.0",
+    "@types/node": "^20"
+  }
+}