openclaw-app 1.1.9 → 1.2.0

package/index.js

@@ -0,0 +1,1377 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * OpenClaw App Channel Plugin
+ *
+ * Registers "openclaw-app" channel that bridges Gateway <-> CF Worker relay <-> Mobile App.
+ * Plugin runs inside the Gateway process, connects outbound to the relay.
+ * No external dependencies — uses Node.js built-in WebSocket.
+ *
+ * Config (in ~/.openclaw/openclaw.json):
+ *   {
+ *     "channels": {
+ *       "openclaw-app": {
+ *         "accounts": {
+ *           "default": {
+ *             "enabled": true,
+ *             "relayUrl": "wss://openclaw-relay.xxx.workers.dev",
+ *             "relayToken": "your-secret",
+ *             "roomId": "default"
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ */
+// ── Plugin runtime (set during register) ────────────────────────────────────
+let pluginRuntime = null;
+// ── E2E Encryption (X25519 ECDH + AES-256-GCM) ──────────────────────────────
+// Uses Web Crypto API. Node 18+ uses standalone "X25519" algorithm name,
+// while browsers use { name: "ECDH", namedCurve: "X25519" }.
+// Runtime detection — resolved once on first use
+let _x25519Algo = null;
+async function getX25519Algo() {
+    if (_x25519Algo)
+        return _x25519Algo;
+    try {
+        await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "X25519" }, true, ["deriveKey"]);
+        _x25519Algo = { gen: { name: "ECDH", namedCurve: "X25519" }, imp: { name: "ECDH", namedCurve: "X25519" }, derive: "ECDH" };
+    }
+    catch {
+        _x25519Algo = { gen: { name: "X25519" }, imp: { name: "X25519" }, derive: "X25519" };
+    }
+    return _x25519Algo;
+}
+function makeE2EState() {
+    return { localKeyPair: null, sharedKey: null, ready: false };
+}
+async function e2eInit(state) {
+    const algo = await getX25519Algo();
+    state.localKeyPair = await crypto.subtle.generateKey(algo.gen, true, ["deriveKey", "deriveBits"]);
+    const pubKeyRaw = await crypto.subtle.exportKey("raw", state.localKeyPair.publicKey);
+    return bufToBase64Url(pubKeyRaw);
+}
+function getCryptoStorePath() {
+    const workDir = pluginRuntime?.config?.workspaceDir || process.cwd();
+    return path.join(workDir, "openclaw_mobile_keys.json");
+}
+let _persistedStore = null;
+function loadE2EStore() {
+    if (_persistedStore)
+        return _persistedStore;
+    try {
+        const p = getCryptoStorePath();
+        if (fs.existsSync(p)) {
+            _persistedStore = JSON.parse(fs.readFileSync(p, "utf-8"));
+        }
+        else {
+            _persistedStore = {};
+        }
+    }
+    catch {
+        _persistedStore = {};
+    }
+    return _persistedStore;
+}
+function saveE2EStore() {
+    try {
+        fs.writeFileSync(getCryptoStorePath(), JSON.stringify(_persistedStore, null, 2), "utf-8");
+    }
+    catch (e) {
+        console.error("[openclaw-app] Failed to save mobile keys", e);
+    }
+}
+async function getOrInitAccountE2E(accountId) {
+    const store = loadE2EStore();
+    if (!store[accountId]) {
+        const algo = await getX25519Algo();
+        const kp = await crypto.subtle.generateKey(algo.gen, true, ["deriveKey", "deriveBits"]);
+        const privRaw = await crypto.subtle.exportKey("pkcs8", kp.privateKey);
+        const pubRaw = await crypto.subtle.exportKey("raw", kp.publicKey);
+        store[accountId] = {
+            pluginPrivB64: bufToBase64Url(privRaw),
+            pluginPubB64: bufToBase64Url(pubRaw),
+            sharedSecrets: {},
+            activeDevicePubKey: null
+        };
+        saveE2EStore();
+    }
+    return store[accountId];
+}
+async function loadE2EStateFromPersisted(accountId, devicePubKeyB64) {
+    const accountE2E = await getOrInitAccountE2E(accountId);
+    const sharedSecretB64 = accountE2E.sharedSecrets[devicePubKeyB64];
+    if (!sharedSecretB64)
+        return null;
+    const state = makeE2EState();
+    const rawShared = base64UrlToBuf(sharedSecretB64);
+    state.sharedKey = await crypto.subtle.importKey("raw", rawShared, { name: "AES-GCM" }, false, // Not extractable anymore since it's already in memory/disk
+        ["encrypt", "decrypt"]);
+    state.ready = true;
+    return state;
+}
+async function e2eHandleHandshake(accountId, peerPubKeyB64) {
+    const accountE2E = await getOrInitAccountE2E(accountId);
+    const algo = await getX25519Algo();
+    const privBytes = base64UrlToBuf(accountE2E.pluginPrivB64);
+    const privateKey = await crypto.subtle.importKey("pkcs8", privBytes, algo.imp, false, ["deriveKey", "deriveBits"]);
+    const peerPubKeyBytes = base64UrlToBuf(peerPubKeyB64);
+    const peerPublicKey = await crypto.subtle.importKey("raw", peerPubKeyBytes, algo.imp, false, []);
+    // Dart cryptography's sharedSecretKey returns the raw X-coordinate (32 bytes).
+    // Using deriveKey into AES-GCM directly may truncate or alter the raw bits depending on the engine.
+    const ecdhRawBytes = await crypto.subtle.deriveBits({ name: algo.derive, public: peerPublicKey }, privateKey, 256);
+    // HKDF-SHA256: salt=empty, info="openclaw-e2e-v1" → AES-256-GCM key
+    const hkdfKey = await crypto.subtle.importKey("raw", ecdhRawBytes, { name: "HKDF" }, false, ["deriveKey"]);
+    const sharedKey = await crypto.subtle.deriveKey({
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: new Uint8Array(0),
+        info: new TextEncoder().encode("openclaw-e2e-v1"),
+    }, hkdfKey, { name: "AES-GCM", length: 256 }, true, // EXPORTABLE so we can save it!
+        ["encrypt", "decrypt"]);
+    const rawShared = await crypto.subtle.exportKey("raw", sharedKey);
+    accountE2E.sharedSecrets[peerPubKeyB64] = bufToBase64Url(rawShared);
+    accountE2E.activeDevicePubKey = peerPubKeyB64;
+    saveE2EStore();
+    const state = makeE2EState();
+    state.sharedKey = sharedKey;
+    state.ready = true;
+    return state;
+}
+async function e2eEncrypt(state, plaintext) {
+    if (!state.sharedKey)
+        throw new Error("[E2E] Not ready");
+    const nonce = crypto.getRandomValues(new Uint8Array(12));
+    const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, state.sharedKey, new TextEncoder().encode(plaintext));
+    return JSON.stringify({
+        type: "encrypted",
+        nonce: bufToBase64Url(nonce),
+        ct: bufToBase64Url(ct),
+    });
+}
+async function e2eDecrypt(state, nonceB64, ctB64) {
+    if (!state.sharedKey)
+        throw new Error("[E2E] Not ready");
+    const nonce = base64UrlToBuf(nonceB64);
+    const ct = base64UrlToBuf(ctB64);
+    const plain = await crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce }, state.sharedKey, ct);
+    return new TextDecoder().decode(plain);
+}
+function bufToBase64Url(buf) {
+    const buffer = Buffer.from(buf);
+    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlToBuf(b64) {
+    const padded = b64.replace(/-/g, "+").replace(/_/g, "/");
+    const buffer = Buffer.from(padded, "base64");
+    const cleanBytes = new Uint8Array(buffer.length);
+    cleanBytes.set(buffer);
+    return cleanBytes;
+}
+const HANDSHAKE_AUTH_VERSION = "v1";
+const HANDSHAKE_AUTH_CONTEXT = "openclaw-hs-auth-v1";
+const HANDSHAKE_MAX_SKEW_MS = 2 * 60 * 1000;
+function canonicalHandshakePayload(version, role, sessionKey, pubkey, ts) {
+    return [HANDSHAKE_AUTH_CONTEXT, version, role, sessionKey, String(ts), pubkey].join("|");
+}
+async function buildHandshakeMac(token, role, sessionKey, pubkey, ts, version = HANDSHAKE_AUTH_VERSION) {
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(token), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const payload = new TextEncoder().encode(canonicalHandshakePayload(version, role, sessionKey, pubkey, ts));
+    const mac = await crypto.subtle.sign("HMAC", key, payload);
+    return bufToBase64Url(mac);
+}
+function constantTimeEquals(a, b) {
+    const aa = new TextEncoder().encode(a);
+    const bb = new TextEncoder().encode(b);
+    if (aa.length !== bb.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < aa.length; i++)
+        diff |= aa[i] ^ bb[i];
+    return diff === 0;
+}
+function parseHandshakeTs(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw))
+        return Math.trunc(raw);
+    if (typeof raw === "string") {
+        const n = Number(raw);
+        if (Number.isFinite(n))
+            return Math.trunc(n);
+    }
+    return null;
+}
+function isHandshakeTsFresh(ts) {
+    return Math.abs(Date.now() - ts) <= HANDSHAKE_MAX_SKEW_MS;
+}
+async function verifyHandshakeMac(token, role, sessionKey, pubkey, ts, mac, version) {
+    const expected = await buildHandshakeMac(token, role, sessionKey, pubkey, ts, version);
+    return constantTimeEquals(mac, expected);
+}
+const relayStates = new Map();
+const RECONNECT_DELAY = 5000;
+const PING_INTERVAL = 30_000; // 30s keepalive — prevents DO hibernation
+const DEFAULT_ACCOUNT_ID = "default";
+const CHANNEL_ID = "openclaw-app";
+/** Fixed chatSessionKey that routes cron messages to the App inbox UI */
+const INBOX_CHAT_SESSION_KEY = "inbox";
+function getRelayState(accountId) {
+    let state = relayStates.get(accountId);
+    if (!state) {
+        state = {
+            ws: null,
+            reconnectTimer: null,
+            pingTimer: null,
+            statusSink: null,
+            gatewayCtx: null,
+            relayToken: "",
+        };
+        relayStates.set(accountId, state);
+    }
+    return state;
+}
+// ── Account resolution ───────────────────────────────────────────────────────
+/** Default relay deployed at https://github.com/openclaw/openclaw-app */
+const DEFAULT_RELAY_URL = "wss://openclaw-relay.eldermoo8718.workers.dev";
+const DEFAULT_ROOM_ID = "default";
+function listAccountIds(cfg) {
+    const ids = Object.keys(cfg.channels?.[CHANNEL_ID]?.accounts ?? {});
+    // Always expose at least the default account so the Control UI
+    // shows a pre-filled entry without the user having to click "Add Entry".
+    if (!ids.includes(DEFAULT_ACCOUNT_ID))
+        ids.unshift(DEFAULT_ACCOUNT_ID);
+    return ids;
+}
+function resolveAccount(cfg, accountId) {
+    const id = accountId ?? DEFAULT_ACCOUNT_ID;
+    const acct = cfg.channels?.[CHANNEL_ID]?.accounts?.[id] ?? {};
+    const relayUrl = acct.relayUrl || DEFAULT_RELAY_URL;
+    const roomId = acct.roomId || DEFAULT_ROOM_ID;
+    return {
+        accountId: id,
+        enabled: acct.enabled !== false,
+        relayUrl,
+        relayToken: acct.relayToken ?? "",
+        roomId,
+        configured: true, // always ready out of the box with the default relay
+    };
+}
+// ── Channel config schema (JSON Schema for Control UI) ───────────────────────
+const mobileConfigSchema = {
+    schema: {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        type: "object",
+        properties: {
+            accounts: {
+                type: "object",
+                additionalProperties: {
+                    type: "object",
+                    properties: {
+                        enabled: { type: "boolean" },
+                        relayUrl: {
+                            type: "string",
+                            description: "CF Worker relay WebSocket URL",
+                        },
+                        relayToken: {
+                            type: "string",
+                            description: "Shared secret for relay authentication",
+                        },
+                        roomId: {
+                            type: "string",
+                            description: "Room ID for relay routing",
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+        },
+        additionalProperties: false,
+    },
+    uiHints: {
+        relayUrl: {
+            label: "Relay URL",
+            placeholder: DEFAULT_RELAY_URL,
+        },
+        relayToken: {
+            label: "Relay Token",
+            sensitive: true,
+        },
+        roomId: {
+            label: "Room ID",
+            placeholder: DEFAULT_ROOM_ID,
+        },
+    },
+};
+// ── Channel plugin ───────────────────────────────────────────────────────────
+const channel = {
+    id: CHANNEL_ID,
+    meta: {
+        id: CHANNEL_ID,
+        label: "OpenClaw App",
+        selectionLabel: "OpenClaw App App",
+        blurb: "Chat via the OpenClaw App app through a relay.",
+        detailLabel: "Mobile App",
+        aliases: ["mobile"],
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+    },
+    reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
+    configSchema: mobileConfigSchema,
+    config: {
+        listAccountIds: (cfg) => listAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        setAccountEnabled: ({ cfg, accountId, enabled }) => {
+            const key = accountId || DEFAULT_ACCOUNT_ID;
+            const base = cfg.channels?.[CHANNEL_ID] ?? {};
+            const accounts = base.accounts ?? {};
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    [CHANNEL_ID]: {
+                        ...base,
+                        accounts: {
+                            ...accounts,
+                            [key]: {
+                                ...accounts[key],
+                                enabled,
+                            },
+                        },
+                    },
+                },
+            };
+        },
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            relayUrl: account.relayUrl,
+            roomId: account.roomId,
+        }),
+        // OpenClaw's resolveOutboundTarget() falls back to this when no explicit
+        // `to` is provided in delivery config. Our channel always targets the
+        // single connected mobile user.
+        resolveDefaultTo: () => "openclaw-app-user",
+    },
+    outbound: {
+        deliveryMode: "direct",
+        // OpenClaw's ChannelOutboundAdapter.resolveTarget
+        // Called by resolveOutboundTarget() in src/infra/outbound/targets.ts
+        // to validate/normalize the delivery target address.
+        resolveTarget: ({ to }) => {
+            const target = to?.trim() || "openclaw-app-user";
+            return { ok: true, to: target };
+        },
+        // OpenClaw's ChannelOutboundAdapter.sendText
+        // Called by createPluginHandler() in src/infra/outbound/deliver.ts
+        // ctx: ChannelOutboundContext = { cfg, to, text, accountId, ... }
+        sendText: async (ctx) => {
+            const text = ctx.text ?? "";
+            const accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
+            const state = getRelayState(accountId);
+            if (!state.ws || state.ws.readyState !== WebSocket.OPEN) {
+                throw new Error("relay not connected");
+            }
+            const runtime = pluginRuntime;
+            let outText = text;
+            if (runtime) {
+                const cfg = runtime.config.loadConfig();
+                const tableMode = runtime.channel.text.resolveMarkdownTableMode({
+                    cfg,
+                    channel: CHANNEL_ID,
+                    accountId,
+                });
+                outText = runtime.channel.text.convertMarkdownTables(outText, tableMode);
+            }
+            // Prefer the App's current active session for delivery
+            const accountE2E = await getOrInitAccountE2E(accountId);
+            if (!accountE2E.activeDevicePubKey) {
+                throw new Error("no active E2E session available");
+            }
+            const sessionE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
+            if (!sessionE2E?.ready) {
+                throw new Error("persistent E2E session not ready");
+            }
+            const replySessionKey = state.lastActiveSessionKey || "inbox-worker";
+            const chatKey = INBOX_CHAT_SESSION_KEY;
+            const messageId = `mobile-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
+            const plainMsg = JSON.stringify({
+                type: "message",
+                role: "assistant",
+                content: outText,
+                sessionKey: replySessionKey,
+                chatSessionKey: chatKey,
+                messageId,
+            });
+            const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+            encrypted.sessionKey = replySessionKey;
+            encrypted.chatSessionKey = chatKey;
+            encrypted.messageId = messageId;
+            const outMsg = JSON.stringify(encrypted);
+            const logger = pluginRuntime?.logger ?? console;
+            logger.info?.(`[${CHANNEL_ID}] sendText: targetSessionKey=${replySessionKey} chatKey=${chatKey} wsState=${state.ws?.readyState} msgLen=${outMsg.length}`);
+            state.ws.send(outMsg);
+            return {
+                channel: CHANNEL_ID,
+                messageId,
+            };
+        },
+        // OpenClaw's ChannelOutboundAdapter.sendMedia (required alongside sendText)
+        sendMedia: async (ctx) => {
+            // Media not supported over E2E relay — send caption text only
+            const text = ctx.text ?? "";
+            const accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
+            const state = getRelayState(accountId);
+            if (!state.ws || state.ws.readyState !== WebSocket.OPEN) {
+                throw new Error("relay not connected");
+            }
+            const accountE2E = await getOrInitAccountE2E(accountId);
+            if (!accountE2E.activeDevicePubKey) {
+                throw new Error("no active E2E session available");
+            }
+            const sessionE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
+            if (!sessionE2E?.ready) {
+                throw new Error("persistent E2E session not ready");
+            }
+            const replySessionKey = state.lastActiveSessionKey || "inbox-worker";
+            const chatKey = INBOX_CHAT_SESSION_KEY;
+            const messageId = `mobile-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
+            const plainMsg = JSON.stringify({
+                type: "message",
+                role: "assistant",
+                content: text || "[media]",
+                sessionKey: replySessionKey,
+                chatSessionKey: chatKey,
+                messageId,
+            });
+            const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+            encrypted.sessionKey = replySessionKey;
+            encrypted.chatSessionKey = chatKey;
+            encrypted.messageId = messageId;
+            state.ws.send(JSON.stringify(encrypted));
+            return {
+                channel: CHANNEL_ID,
+                messageId: `mobile-media-${Date.now()}`,
+            };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            connected: false,
+            lastConnectedAt: null,
+            lastDisconnect: null,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+            lastInboundAt: null,
+        },
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            connected: snapshot.connected ?? false,
+            lastInboundAt: snapshot.lastInboundAt ?? null,
+        }),
+        buildAccountSnapshot: ({ account, runtime }) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            relayUrl: account.relayUrl || "(not set)",
+            running: runtime?.running ?? false,
+            connected: runtime?.connected ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            lastInboundAt: runtime?.lastInboundAt ?? null,
+            lastConnectedAt: runtime?.lastConnectedAt ?? null,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const accountId = account.accountId;
+            const state = getRelayState(accountId);
+            cleanupRelay(state);
+            state.gatewayCtx = ctx;
+            state.statusSink = (patch) => ctx.setStatus({ accountId, ...patch });
+            ctx.setStatus({ accountId, running: true, lastStartAt: new Date().toISOString() });
+            if (!account.configured) {
+                const msg = "relayUrl not configured";
+                ctx.setStatus({ accountId, lastError: msg });
+                ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] ${msg}`);
+                return;
+            }
+            connectRelay(ctx, account);
+            const signal = ctx.abortSignal;
+            if (signal) {
+                await new Promise((resolve) => {
+                    if (signal.aborted) {
+                        resolve();
+                        return;
+                    }
+                    signal.addEventListener("abort", () => resolve(), { once: true });
+                });
+                cleanupRelay(state);
+                ctx.setStatus({ accountId, running: false, connected: false });
+            }
+        },
+        stopAccount: async (ctx) => {
+            const accountId = ctx.account?.accountId ?? DEFAULT_ACCOUNT_ID;
+            const state = getRelayState(accountId);
+            cleanupRelay(state);
+            ctx.setStatus?.({
+                accountId,
+                running: false,
+                connected: false,
+                lastStopAt: new Date().toISOString(),
+            });
+            ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] stopped`);
+        },
+    },
+};
+// ── Relay bridge ─────────────────────────────────────────────────────────────
+function cleanupRelay(state) {
+    if (state.pingTimer) {
+        clearInterval(state.pingTimer);
+        state.pingTimer = null;
+    }
+    if (state.reconnectTimer) {
+        clearTimeout(state.reconnectTimer);
+        state.reconnectTimer = null;
+    }
+    if (state.ws) {
+        try {
+            state.ws.close();
+        }
+        catch { }
+        state.ws = null;
+    }
+}
+function connectRelay(ctx, account) {
+    const accountId = account.accountId;
+    const state = getRelayState(accountId);
+    state.relayToken = account.relayToken ?? "";
+    const base = account.relayUrl.replace(/\/$/, "");
+    const params = new URLSearchParams({
+        role: "plugin",
+        room: account.roomId,
+    });
+    if (account.relayToken)
+        params.set("token", account.relayToken);
+    const url = `${base}/ws?${params.toString()}`;
+    ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Connecting to relay: ${url}`);
+    try {
+        state.ws = new WebSocket(url);
+    }
+    catch (err) {
+        const msg = `WebSocket create failed: ${err}`;
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] ${msg}`);
+        state.statusSink?.({ lastError: msg });
+        scheduleReconnect(ctx, account);
+        return;
+    }
+    state.ws.addEventListener("open", () => {
+        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Relay connected`);
+        if (state.reconnectTimer) {
+            clearTimeout(state.reconnectTimer);
+            state.reconnectTimer = null;
+        }
+        if (state.pingTimer)
+            clearInterval(state.pingTimer);
+        state.pingTimer = setInterval(() => {
+            if (state.ws?.readyState === WebSocket.OPEN) {
+                state.ws.send("ping");
+            }
+        }, PING_INTERVAL);
+        state.statusSink?.({
+            connected: true,
+            lastConnectedAt: new Date().toISOString(),
+            lastError: null,
+        });
+        // E2E handshakes are initiated per-session when `peer_joined` arrives
+        // (each app connection carries its own sessionKey UUID).
+    });
+    state.ws.addEventListener("message", (event) => {
+        handleRelayMessage(ctx, accountId, state, String(event.data)).catch((e) => {
+            ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Failed to handle relay message: ${e}`);
+        });
+    });
+    state.ws.addEventListener("close", (event) => {
+        if (state.ws !== null && state.ws !== event.target)
+            return; // Ignore stale connections
+        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Relay disconnected, reconnecting... (code: ${event.code}, reason: ${event.reason})`);
+        state.ws = null;
+        if (state.pingTimer) {
+            clearInterval(state.pingTimer);
+            state.pingTimer = null;
+        }
+        state.statusSink?.({
+            connected: false,
+            lastDisconnect: new Date().toISOString(),
+        });
+        scheduleReconnect(ctx, account);
+    });
+    state.ws.addEventListener("error", (event) => {
+        const errMsg = event?.message || String(event);
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Relay WebSocket error: ${errMsg}`);
+        state.statusSink?.({ lastError: `WebSocket error: ${errMsg}` });
+    });
+}
+function scheduleReconnect(ctx, account) {
+    const state = getRelayState(account.accountId);
+    if (state.reconnectTimer)
+        return;
+    state.reconnectTimer = setTimeout(() => {
+        state.reconnectTimer = null;
+        connectRelay(ctx, account);
+    }, RECONNECT_DELAY);
+}
+async function handleRelayMessage(ctx, accountId, state, raw) {
+    // Skip ping/pong
+    if (raw === "ping" || raw === "pong")
+        return;
+    ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Relay message: ${raw.slice(0, 200)}`);
+    const msg = JSON.parse(raw);
+    // App's handshake request (V2: App initiates with its persistent PubKey)
+    if (msg.type === "handshake") {
+        const peerPubKey = msg.pubkey;
+        const sessionKey = msg.sessionKey;
+        const msgTs = msg.ts;
+        if (!peerPubKey) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] handshake missing pubkey, ignoring`);
+            return;
+        }
+        if (state.relayToken) {
+            const peerMac = msg.mac;
+            const peerTs = msg.ts;
+            const version = msg.v;
+            if (!peerMac || peerTs == null) {
+                ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake missing auth fields`);
+                return;
+            }
+            if (version !== HANDSHAKE_AUTH_VERSION) {
+                ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Unsupported handshake version: ${version}`);
+                return;
+            }
+            if (!isHandshakeTsFresh(peerTs)) {
+                ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake timestamp out of window, dropping`);
+                return;
+            }
+        }
+        // V2: Derive persistent shared secret and store it
+        await e2eHandleHandshake(accountId, peerPubKey);
+        if (sessionKey) {
+            state.lastActiveSessionKey = sessionKey;
+        }
+        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake handled for app pubkey ${peerPubKey.slice(0, 8)}...`);
+        // Reply with our persistent pubkey (Plugin PubKey) so App knows it
+        const accountE2E = await getOrInitAccountE2E(accountId);
+        const replyPayload = {
+            type: "handshake",
+            sessionKey: sessionKey || "",
+            pubkey: accountE2E.pluginPubB64,
+        };
+        if (state.relayToken) {
+            const ts = Date.now();
+            const mac = await buildHandshakeMac(state.relayToken, "plugin", sessionKey || "", accountE2E.pluginPubB64, ts, HANDSHAKE_AUTH_VERSION);
+            replyPayload.v = HANDSHAKE_AUTH_VERSION;
+            replyPayload.ts = ts;
+            replyPayload.mac = mac;
+        }
+        if (state.ws?.readyState === WebSocket.OPEN) {
+            state.ws.send(JSON.stringify(replyPayload));
+        }
+        return;
+    }
+    // Process E2E encrypted messages from the App
+    if (msg.type === "encrypted") {
+        const accountE2E = await getOrInitAccountE2E(accountId);
+        // V2.1: Use the explicit explicit device pubkey embedded in the envelope, otherwise
+        // fallback to the connection activeDevicePubKey handling (V2/legacy)
+        const devicePubKey = msg.pubkey || accountE2E.activeDevicePubKey;
+        if (!devicePubKey) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] No active device key, dropping encrypted message`);
+            return;
+        }
+        const sessionE2E = await loadE2EStateFromPersisted(accountId, devicePubKey);
+        if (!sessionE2E?.ready) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Failed to load SharedSecret for active device, dropping`);
+            return;
+        }
+        try {
+            const plaintext = await e2eDecrypt(sessionE2E, msg.nonce, msg.ct);
+            ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Decrypted message: ${plaintext.slice(0, 200)}`);
+            const innerMsg = JSON.parse(plaintext);
+            await handleInbound(ctx, accountId, innerMsg);
+        }
+        catch (e) {
+            ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Decryption failed: ${e}`);
+        }
+        return;
+    }
+    // Drop any plaintext message that sneaks through (only handshake/encrypted should be processed)
+    if (msg.type === "message" || msg.type === "delta" || msg.type === "final" || msg.type === "abort") {
+        ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Dropping plaintext ${msg.type} message for security`);
+        return;
+    }
+    // Silently ignore relay system events that don't need action on the plugin side
+    if (msg.type === "peer_joined" || msg.type === "peer_left") {
+        ctx.log?.debug?.(`[${CHANNEL_ID}] [${accountId}] Relay system event ignored: ${msg.type}`);
+        return;
+    }
+    // Fallback for any other system message
+    await handleInbound(ctx, accountId, msg);
+}
+async function handleRpc(ctx, accountId, msg) {
+    if (msg.type !== "rpc")
+        return false;
+    const reqId = msg.id;
+    const method = msg.method;
+    const params = msg.params ?? {};
+    const replySessionKey = msg.sessionKey;
+    ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] handleRpc: method=${method} id=${reqId}`);
+    const runtime = pluginRuntime;
+    if (!runtime) {
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] RPC: no runtime`);
+        return true;
+    }
+    const relayState = getRelayState(accountId);
+    const sendRpcReply = async (data, error) => {
+        if (!relayState.ws || relayState.ws.readyState !== WebSocket.OPEN)
+            return;
+        if (!replySessionKey)
+            return;
+        try {
+            const accountE2E = await getOrInitAccountE2E(accountId);
+            if (!accountE2E.activeDevicePubKey)
+                return;
+            const sessionE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
+            if (!sessionE2E?.ready)
+                return;
+            const msgId = crypto.randomUUID();
+            const inner = JSON.stringify({ type: "rpc-response", id: reqId, data, error: error ?? null, sessionKey: replySessionKey, messageId: msgId });
+            const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, inner));
+            encrypted.sessionKey = replySessionKey;
+            encrypted.messageId = msgId;
+            relayState.ws.send(JSON.stringify(encrypted));
+        }
+        catch (e) {
+            ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] sendRpcReply fail: ${e}`);
+        }
+    };
+    try {
+        if (method === "runtime.inspect") {
+            // Debug: return top-level keys of runtime object
+            const keys = Object.keys(runtime ?? {});
+            const cfgKeys = runtime?.config ? Object.keys(runtime.config) : [];
+            const cfg = runtime?.config?.loadConfig?.() ?? {};
+            const cfgTopKeys = Object.keys(cfg);
+            // Try to find agents in config
+            const agentsCfg = cfg.agents ?? cfg.agent ?? {};
+            const agentsListKeys = Object.keys(agentsCfg);
+            const agentsList = agentsCfg.list ?? agentsCfg.agents ?? agentsCfg ?? [];
+            await sendRpcReply({
+                runtimeKeys: keys,
+                configKeys: cfgKeys,
+                cfgTopKeys,
+                agentsCfgKeys: agentsListKeys,
+                agentsListType: Array.isArray(agentsList) ? `array[${agentsList.length}]` : typeof agentsList,
+                agentsSample: Array.isArray(agentsList) ? agentsList.slice(0, 3) : agentsList,
+            });
+        }
+        else if (method === "runtime.inspect.deep") {
+            // Deep inspection to discover skills API surface
+            const allRuntimeKeys = runtime ? Object.keys(runtime) : [];
+            // Walk every top-level key and record its type + sub-keys (if object/function)
+            const runtimeShape = {};
+            for (const k of allRuntimeKeys) {
+                try {
+                    const v = runtime[k];
+                    const t = typeof v;
+                    if (t === 'function') {
+                        runtimeShape[k] = 'function';
+                    }
+                    else if (v && t === 'object') {
+                        runtimeShape[k] = Object.keys(v).slice(0, 20);
+                    }
+                    else {
+                        runtimeShape[k] = t;
+                    }
+                }
+                catch (_) {
+                    runtimeShape[k] = 'error';
+                }
+            }
+            // Specifically probe skills-related paths
+            const skillsProbe = {};
+            const candidates = ['skills', 'skillManager', 'skillLoader', 'skillRegistry', 'pluginSkills'];
+            for (const c of candidates) {
+                if (runtime?.[c]) {
+                    skillsProbe[c] = typeof runtime[c] === 'object'
+                        ? Object.keys(runtime[c])
+                        : typeof runtime[c];
+                }
+            }
+            // Also probe config.skills
+            let cfgSkills = null;
+            try {
+                const cfg = runtime.config.loadConfig();
+                cfgSkills = {
+                    topKeys: Object.keys(cfg?.skills ?? {}),
+                    entriesKeys: Object.keys(cfg?.skills?.entries ?? {}),
+                    entriesSample: Object.entries(cfg?.skills?.entries ?? {}).slice(0, 5)
+                        .map(([k, v]) => ({ name: k, enabled: v?.enabled })),
+                };
+            }
+            catch (_) { }
+            await sendRpcReply({ runtimeShape, skillsProbe, cfgSkills });
+        }
+        else if (method === "agents.list") {
+            const cfg = runtime.config.loadConfig();
+            // cfg.agents structure: { defaults: {...}, list: [{id, name, workspace, ...}], ... }
+            const agentsCfg = cfg.agents ?? {};
+            let raw = [];
+            if (Array.isArray(agentsCfg.list)) {
+                raw = agentsCfg.list;
+            }
+            else if (Array.isArray(agentsCfg.agents)) {
+                raw = agentsCfg.agents;
+            }
+            else if (Array.isArray(agentsCfg)) {
+                raw = agentsCfg;
+            }
+            ctx.log?.info?.(`[${CHANNEL_ID}] agents raw count: ${raw.length}`);
+            const list = raw.map((a) => ({
+                id: a.id ?? a.agentId ?? '',
+                name: a.name ?? a.id ?? '',
+                emoji: a.emoji ?? null,
+                workspace: a.workspace ?? null,
+                createdAt: a.createdAt ?? null,
+            })).filter((a) => a.id);
+            await sendRpcReply({ agents: list });
+        }
+        else if (method === "sessions.list") {
+            // Sessions are stored locally in the mobile app's Drift DB.
+            // The Gateway/CLI has no sessions API we can call reliably.
+            // Return empty — session_provider.dart falls back to local DB which is the source of truth.
+            await sendRpcReply({ sessions: [] });
+        }
+        else if (method === "agents.create") {
+            // Use CLI: openclaw agents add <name> --workspace <path> [--model <model>]
+            const name = params.name;
+            const workspace = params.workspace ?? `~/.openclaw/agents/${name}`;
+            const model = params.model;
+            if (!name) {
+                await sendRpcReply(null, "agents.create: missing required param 'name'");
+            }
+            else {
+                let cmd = `openclaw agents add ${name} --workspace ${workspace}`;
+                if (model)
+                    cmd += ` --model ${model}`;
+                ctx.log?.info?.(`[${CHANNEL_ID}] agents.create cmd: ${cmd}`);
+                const result = await runtime.system.runCommandWithTimeout(cmd, 15000);
+                ctx.log?.info?.(`[${CHANNEL_ID}] agents.create result: ${JSON.stringify(result)}`);
+                if (result.exitCode !== 0) {
+                    await sendRpcReply(null, `Command failed (exit ${result.exitCode}): ${result.stderr ?? result.stdout ?? ''}`);
+                }
+                else {
+                    await sendRpcReply({ name, workspace, output: result.stdout ?? '' });
+                }
+            }
+        }
+        else if (method === "tools.list") {
+            // Use `openclaw skills list --json` CLI — most reliable source for loaded skills.
+            // Falls back to fs scan of ~/.openclaw/skills if CLI is unavailable.
+            let tools = [];
+            try {
+                // Try object form first; fall back to string form (same as agents.create)
+                let cliResult;
+                try {
+                    cliResult = await runtime.system.runCommandWithTimeout({ cmd: 'openclaw', args: ['skills', 'list', '--json'] }, 10000);
+                }
+                catch (_) {
+                    cliResult = await runtime.system.runCommandWithTimeout('openclaw skills list --json', 10000);
+                }
+                if (cliResult && cliResult.exitCode === 0 && cliResult.stdout?.trim()) {
+                    const parsed = JSON.parse(cliResult.stdout.trim());
+                    const raw = Array.isArray(parsed) ? parsed
+                        : Array.isArray(parsed?.skills) ? parsed.skills
+                            : parsed?.data ?? [];
+                    tools = raw
+                        .filter((s) => s['user-invocable'] !== false && s['user-invocable'] !== 'false')
+                        .map((s) => ({
+                            name: s.name ?? s.id ?? '',
+                            description: s.description ?? s.desc ?? '',
+                            category: s.category ?? '',
+                            userInvocable: true,
+                        }))
+                        .filter((t) => t.name);
+                }
+            }
+            catch (_) { }
+            // Fallback: scan ~/.openclaw for all skills/ subdirs, deduplicated
+            if (tools.length === 0) {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const fs = globalThis.require?.('fs') ?? require('fs');
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const path = globalThis.require?.('path') ?? require('path');
+                    const cfg = runtime.config.loadConfig();
+                    const proc = globalThis.process;
+                    const home = proc?.env?.HOME ?? proc?.env?.USERPROFILE ?? '~';
+                    const ocRoot = `${home}/.openclaw`;
+                    // Collect all skills/ directories under ~/.openclaw recursively (depth 2)
+                    const skillDirs = [];
+                    const addSkillsDir = (dir) => {
+                        try {
+                            if (fs.existsSync(dir))
+                                skillDirs.push(dir);
+                        }
+                        catch (_) { }
+                    };
+                    // ~/.openclaw/skills
+                    addSkillsDir(`${ocRoot}/skills`);
+                    // ~/.openclaw/*/skills  (workspace dirs one level deep)
+                    try {
+                        for (const entry of fs.readdirSync(ocRoot)) {
+                            const sub = path.join(ocRoot, entry, 'skills');
+                            addSkillsDir(sub);
+                        }
+                    }
+                    catch (_) { }
+                    // Extra dirs from config
+                    for (const d of (cfg?.skills?.load?.extraDirs ?? []))
+                        addSkillsDir(d);
+                    const seen = new Set();
+                    for (const dir of skillDirs) {
+                        let entries;
+                        try {
+                            entries = fs.readdirSync(dir);
+                        }
+                        catch (_) {
+                            continue;
+                        }
+                        for (const entry of entries) {
+                            const skillFile = path.join(dir, entry, 'SKILL.md');
+                            let content;
+                            try {
+                                content = fs.readFileSync(skillFile, 'utf8');
+                            }
+                            catch (_) {
+                                continue;
+                            }
+                            const fm = _parseSkillFrontmatter(content);
+                            const name = fm.name ?? entry;
+                            if (!name || seen.has(name))
+                                continue;
+                            seen.add(name);
+                            if (fm['user-invocable'] === false || fm['user-invocable'] === 'false')
+                                continue;
+                            if (cfg?.skills?.entries?.[name]?.enabled === false)
+                                continue;
+                            tools.push({ name, description: fm.description ?? '', category: '', userInvocable: true });
+                        }
+                    }
+                }
+                catch (_) { }
+            }
+            await sendRpcReply({ tools });
+        }
+        else if (method === "inbox.test") {
+            // Debug/test: send a test message to the App inbox
+            const testText = params.text || "🔔 Inbox test — if you see this, the pipeline works!";
+            const sent = await _sendToInbox(accountId, testText, { logger: ctx.log });
+            await sendRpcReply({ sent, message: sent ? "delivered" : "no active E2E session" });
+        }
+        else if (method === "tools.invoke") {
+            // Invoke a skill by injecting a /skill <name> command into the chat session
+            const toolName = params.name;
+            const input = (params.params?.input ?? params.input ?? '');
+            if (!toolName) {
+                await sendRpcReply(null, "tools.invoke: missing required param 'name'");
+            }
+            else {
+                try {
+                    // Send /skill <name> [input] as a chat message to the current session
+                    const cmd = input ? `/skill ${toolName} ${input}` : `/skill ${toolName}`;
+                    const wireSessionKey = replySessionKey ?? 'rpc';
+                    await handleInbound(ctx, accountId, {
+                        type: 'message',
+                        content: cmd,
+                        sessionKey: wireSessionKey,
+                        chatSessionKey: wireSessionKey,
+                    });
+                    await sendRpcReply({ dispatched: true, command: cmd });
+                }
+                catch (e) {
+                    await sendRpcReply(null, `tools.invoke '${toolName}' error: ${e}`);
+                }
+            }
+        }
+        else if (method === "chat.abort") {
+            const abortSessionKey = params.sessionKey || replySessionKey;
+            const runId = params.runId;
+            if (!abortSessionKey) {
+                await sendRpcReply(null, "chat.abort: missing required param 'sessionKey'");
+            }
+            else {
+                try {
+                    // Signal the reply engine to abort any active generation for this session/runId
+                    if (typeof runtime.channel.reply.abortDispatch === "function") {
+                        await runtime.channel.reply.abortDispatch(abortSessionKey, runId);
+                        await sendRpcReply({ aborted: true, sessionKey: abortSessionKey, runId });
+                        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Aborted chat dispatch for session ${abortSessionKey} (runId: ${runId})`);
+                    }
+                    else {
+                        await sendRpcReply(null, "chat.abort is not supported by this OpenClaw version");
+                    }
+                }
+                catch (e) {
+                    await sendRpcReply(null, `chat.abort error: ${e}`);
+                }
+            }
+        }
+        else {
+            await sendRpcReply(null, `Unknown RPC method: ${method}`);
+        }
+    }
+    catch (e) {
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] RPC error: ${e}`);
+        await sendRpcReply(null, String(e));
+    }
+    return true;
+}
+async function handleInbound(ctx, accountId, msg) {
+    ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] handleInbound: type=${msg.type} content=${String(msg.content ?? "").slice(0, 100)}`);
+    // Handle RPC requests (agents.list, sessions.list, etc.) without AI involvement
+    if (await handleRpc(ctx, accountId, msg))
+        return;
+    if (msg.type !== "message" || !msg.content) {
+        ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] Skipping non-message: type=${msg.type}`);
+        return;
+    }
+    const state = getRelayState(accountId);
+    state.statusSink?.({ lastInboundAt: new Date().toISOString() });
+    const runtime = pluginRuntime;
+    if (!runtime) {
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Plugin runtime not available, cannot dispatch inbound message`);
+        return;
+    }
+    const senderId = msg.senderId ?? "openclaw-app-user";
+    const senderName = msg.senderName ?? "openclaw-app-user";
+    const text = String(msg.content);
+    const chatSessionKey = msg.chatSessionKey ? String(msg.chatSessionKey) : null;
+    try {
+        const cfg = runtime.config.loadConfig();
+        const route = runtime.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: CHANNEL_ID,
+            accountId,
+            peer: { kind: "direct", id: senderId },
+        });
+        // Derive an isolated Gateway session for each mobile conversation.
+        //
+        // chatSessionKey format from app: "agent:<agentId>:<uuid1>-<uuid2>"
+        // We use this as the stable per-conversation identity on the Gateway side.
+        // appSessionKey is the wire-level connection ID — used for E2E reply routing.
+        const appSessionKey = msg.sessionKey ? String(msg.sessionKey) : null;
+        const msgAgentId = msg.agentId ? String(msg.agentId) : null;
+        let sessionKey;
+        if (chatSessionKey) {
+            // chatSessionKey from app: "agent:<agentId>:<uuid>" — use as-is for Gateway routing
+            sessionKey = chatSessionKey;
+        }
+        else if (appSessionKey) {
+            const agentId = msgAgentId || 'main';
+            sessionKey = `agent:${agentId}:mobile-${appSessionKey}`;
+        }
+        else {
+            sessionKey = route.mainSessionKey;
+        }
+        const from = `${CHANNEL_ID}:${senderId}`;
+        const to = `user:${senderId}`;
+        runtime.channel.activity.record({
+            channel: CHANNEL_ID,
+            accountId,
+            direction: "inbound",
+        });
+        runtime.system.enqueueSystemEvent(`Mobile message from ${senderName}: ${text.slice(0, 160)}`, { sessionKey, contextKey: `${CHANNEL_ID}:message:${Date.now()}` });
+        const body = runtime.channel.reply.formatInboundEnvelope({
+            channel: "OpenClaw App",
+            from: `${senderName} (mobile)`,
+            body: text,
+            chatType: "direct",
+            sender: { name: senderName, id: senderId },
+        });
+        const ctxPayload = runtime.channel.reply.finalizeInboundContext({
+            Body: body,
+            BodyForAgent: text,
+            RawBody: text,
+            CommandBody: text,
+            From: from,
+            To: to,
+            SessionKey: sessionKey,
+            AccountId: accountId,
+            ChatType: "direct",
+            ConversationLabel: `Mobile DM from ${senderName}`,
+            SenderName: senderName,
+            SenderId: senderId,
+            Provider: CHANNEL_ID,
+            Surface: CHANNEL_ID,
+            OriginatingChannel: CHANNEL_ID,
+            OriginatingTo: to,
+        });
+        const textLimit = runtime.channel.text.resolveTextChunkLimit(cfg, CHANNEL_ID, accountId, { fallbackLimit: 4000 });
+        const tableMode = runtime.channel.text.resolveMarkdownTableMode({
+            cfg, channel: CHANNEL_ID, accountId,
+        });
+        const { dispatcher, replyOptions, markDispatchIdle } = runtime.channel.reply.createReplyDispatcherWithTyping({
+            humanDelay: runtime.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
+            onTyping: async () => {
+                const relayState = getRelayState(accountId);
+                if (!relayState.ws || relayState.ws.readyState !== WebSocket.OPEN)
+                    return;
+                const accountE2E = await getOrInitAccountE2E(accountId);
+                if (!accountE2E.activeDevicePubKey)
+                    return;
+                const sessionE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
+                if (!sessionE2E?.ready)
+                    return;
+                const replySessionKey = appSessionKey ?? sessionKey;
+                const innerPayload = {
+                    type: "typing",
+                    sessionKey: replySessionKey,
+                };
+                if (chatSessionKey)
+                    innerPayload.chatSessionKey = chatSessionKey;
+                try {
+                    const plainMsg = JSON.stringify(innerPayload);
+                    const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+                    encrypted.sessionKey = replySessionKey;
+                    if (chatSessionKey)
+                        encrypted.chatSessionKey = chatSessionKey;
+                    relayState.ws.send(JSON.stringify(encrypted));
+                }
+                catch (e) {
+                    ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Failed to send typing: ${e}`);
+                }
+            },
+            deliver: async (payload) => {
+                const relayState = getRelayState(accountId);
+                if (!relayState.ws || relayState.ws.readyState !== WebSocket.OPEN) {
+                    ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Cannot deliver reply: relay not connected`);
+                    return;
+                }
+                const accountE2E = await getOrInitAccountE2E(accountId);
+                if (!accountE2E.activeDevicePubKey) {
+                    ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Reply blocked: no active device key for account`);
+                    return;
+                }
+                const sessionE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
+                if (!sessionE2E?.ready) {
+                    ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Reply blocked: persistent session not ready`);
+                    return;
+                }
+                const replySessionKey = appSessionKey ?? sessionKey;
+                if (payload.type === "typing") {
+                    const innerPayload = {
+                        type: "typing",
+                        sessionKey: replySessionKey,
+                    };
+                    if (chatSessionKey)
+                        innerPayload.chatSessionKey = chatSessionKey;
+                    const plainMsg = JSON.stringify(innerPayload);
+                    const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+                    encrypted.sessionKey = replySessionKey;
+                    if (chatSessionKey)
+                        encrypted.chatSessionKey = chatSessionKey;
+                    relayState.ws.send(JSON.stringify(encrypted));
+                    return;
+                }
+                const replyText = runtime.channel.text.convertMarkdownTables(payload.text ?? "", tableMode);
+                const chunkMode = runtime.channel.text.resolveChunkMode(cfg, CHANNEL_ID, accountId);
+                const chunks = runtime.channel.text.chunkMarkdownTextWithMode(replyText, textLimit, chunkMode);
+                for (const chunk of chunks.length > 0 ? chunks : [replyText]) {
+                    if (!chunk)
+                        continue;
+                    const messageId = crypto.randomUUID();
+                    const innerPayload = {
+                        type: "message",
+                        role: "assistant",
+                        content: chunk,
+                        sessionKey: replySessionKey,
+                        messageId,
+                    };
+                    if (chatSessionKey)
+                        innerPayload.chatSessionKey = chatSessionKey;
+                    const plainMsg = JSON.stringify(innerPayload);
+                    const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+                    encrypted.sessionKey = replySessionKey;
+                    encrypted.messageId = messageId;
+                    if (chatSessionKey)
+                        encrypted.chatSessionKey = chatSessionKey;
+                    const outMsg = JSON.stringify(encrypted);
+                    relayState.ws.send(outMsg);
+                }
+                ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Reply delivered (${replyText.length} chars) to sessionKey=${replySessionKey}`);
+            },
+            onError: (err, info) => {
+                ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Reply dispatch error (${info?.kind}): ${err}`);
+            },
+        });
+        await runtime.channel.reply.dispatchReplyFromConfig({
+            ctx: ctxPayload,
+            cfg,
+            dispatcher,
+            replyOptions,
+        });
+        markDispatchIdle();
+        const sessionCfg = cfg.session;
+        const storePath = runtime.channel.session.resolveStorePath(sessionCfg?.store, {
+            agentId: route.agentId,
+        });
+        await runtime.channel.session.updateLastRoute({
+            storePath,
+            sessionKey,
+            deliveryContext: {
+                channel: CHANNEL_ID,
+                to,
+                accountId,
+            },
+        });
+        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Inbound message processed for session ${sessionKey}`);
+    }
+    catch (e) {
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Error processing inbound message: ${e}`);
+    }
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Send a message directly to the App inbox via existing Relay/E2E.
+ * Bypasses OpenClaw's channel outbound pipeline entirely — fully self-contained.
+ * Returns true on success, false if no active E2E session is available.
+ */
+async function _sendToInbox(accountId, text, api) {
+    const state = getRelayState(accountId);
+    if (!state.ws || state.ws.readyState !== WebSocket.OPEN) {
+        api.logger?.warn?.(`[${CHANNEL_ID}] _sendToInbox: relay not connected`);
+        return false;
+    }
+    const accountE2E = await getOrInitAccountE2E(accountId);
+    if (!accountE2E.activeDevicePubKey) {
+        api.logger?.warn?.(`[${CHANNEL_ID}] _sendToInbox: no active device key`);
+        return false;
+    }
+    const targetE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
+    if (!targetE2E?.ready) {
+        api.logger?.warn?.(`[${CHANNEL_ID}] _sendToInbox: persistent e2e session not ready`);
+        return false;
+    }
+    const targetSessionKey = state.lastActiveSessionKey || "inbox-worker";
+    const messageId = crypto.randomUUID();
+    const plainMsg = JSON.stringify({
+        type: "message",
+        role: "assistant",
+        content: text,
+        sessionKey: targetSessionKey,
+        chatSessionKey: INBOX_CHAT_SESSION_KEY,
+        messageId,
+    });
+    const encrypted = JSON.parse(await e2eEncrypt(targetE2E, plainMsg));
+    encrypted.sessionKey = targetSessionKey;
+    encrypted.chatSessionKey = INBOX_CHAT_SESSION_KEY;
+    encrypted.messageId = messageId;
+    state.ws.send(JSON.stringify(encrypted));
+    api.logger?.info?.(`[${CHANNEL_ID}] _sendToInbox: targetSessionKey=${targetSessionKey} msgLen=${text.length} messageId=${messageId}`);
+    return true;
+}
+// ── Plugin entry ─────────────────────────────────────────────────────────────
+export default function register(api) {
+    pluginRuntime = api.runtime;
+    api.registerChannel({ plugin: channel });
+    // On gateway start, ensure the default account config exists so the
+    // Control UI shows pre-filled values without any manual JSON editing.
+    api.on("gateway_start", async () => {
+        try {
+            const runtime = pluginRuntime;
+            if (!runtime)
+                return;
+            const cfg = runtime.config.loadConfig();
+            // --- Monkey patch cron.add to auto-fill delivery.to ---
+            if (runtime.cron && typeof runtime.cron.add === "function" && !runtime.cron.add.__patched) {
+                const originalCronAdd = runtime.cron.add.bind(runtime.cron);
+                runtime.cron.add = async (jobCreate) => {
+                    if (jobCreate && jobCreate.delivery && jobCreate.delivery.channel === CHANNEL_ID) {
+                        if (!jobCreate.delivery.to) {
+                            jobCreate.delivery.to = "openclaw-app-user";
+                            api.logger?.info?.(`[openclaw-app] Auto-filled delivery.to=openclaw-app-user for new cron job`);
+                        }
+                    }
+                    return await originalCronAdd(jobCreate);
+                };
+                runtime.cron.add.__patched = true;
+            }
+            const existing = cfg.channels?.[CHANNEL_ID]?.accounts?.[DEFAULT_ACCOUNT_ID];
+            // Only write defaults if the account entry is completely absent
+            if (existing !== undefined) {
+                return;
+            }
+            const patched = {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    [CHANNEL_ID]: {
+                        ...(cfg.channels?.[CHANNEL_ID] ?? {}),
+                        accounts: {
+                            ...(cfg.channels?.[CHANNEL_ID]?.accounts ?? {}),
+                            [DEFAULT_ACCOUNT_ID]: {
+                                enabled: true,
+                                relayUrl: DEFAULT_RELAY_URL,
+                                roomId: DEFAULT_ROOM_ID,
+                            },
+                        },
+                    },
+                },
+            };
+            await runtime.config.writeConfigFile(patched);
+            api.logger?.info?.(`[openclaw-app] Wrote default account config (relayUrl=${DEFAULT_RELAY_URL}, roomId=${DEFAULT_ROOM_ID})`);
+        }
+        catch (err) {
+            api.logger?.warn?.(`[openclaw-app] Could not write default config: ${err}`);
+        }
+    });
+    api.logger?.info?.("[openclaw-app] Plugin registered");
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Parse YAML frontmatter from a SKILL.md string.
+ * Returns a flat key→value map for simple scalar fields.
+ * Handles: name, description, user-invocable, disable-model-invocation, command-dispatch.
+ */
+function _parseSkillFrontmatter(content) {
+    const result = {};
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return result;
+    for (const line of match[1].split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const val = line.slice(colon + 1).trim();
+        if (!key)
+            continue;
+        // Parse booleans
+        if (val === 'true')
+            result[key] = true;
+        else if (val === 'false')
+            result[key] = false;
+        else
+            result[key] = val;
+    }
+    return result;
+}
+//# sourceMappingURL=index.js.map