openclaw-app 1.1.8 → 1.2.0

package/index.ts

@@ -1,3 +1,5 @@
+import * as fs from "fs";
+import * as path from "path";
 /**
  * OpenClaw App Channel Plugin
  *
@@ -58,39 +60,124 @@ async function e2eInit(state: E2EState): Promise<string> {
     state.localKeyPair = await crypto.subtle.generateKey(
         algo.gen,
         true,
-        ["deriveKey"]
+        ["deriveKey", "deriveBits"]
     );
     const pubKeyRaw = await crypto.subtle.exportKey("raw", state.localKeyPair.publicKey);
     return bufToBase64Url(pubKeyRaw);
 }
 
-async function e2eHandleHandshake(state: E2EState, peerPubKeyB64: string): Promise<void> {
-    if (!state.localKeyPair) throw new Error("[E2E] Must call e2eInit first");
+// ── Persistent E2E Store (Per Account) ──────────────────────────────────────
+
+interface PersistedE2E {
+    pluginPrivB64: string;
+    pluginPubB64: string;
+    // Map of app device public keys to their derived SharedSecret
+    sharedSecrets: Record<string, string>;
+    // The active target device key
+    activeDevicePubKey: string | null;
+}
+
+function getCryptoStorePath() {
+    const workDir = pluginRuntime?.config?.workspaceDir || process.cwd();
+    return path.join(workDir, "openclaw_mobile_keys.json");
+}
+
+let _persistedStore: Record<string, PersistedE2E> | null = null;
+
+function loadE2EStore(): Record<string, PersistedE2E> {
+    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: string): Promise<PersistedE2E> {
+    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: string, devicePubKeyB64: string): Promise<E2EState | null> {
+    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: string, peerPubKeyB64: string): Promise<E2EState> {
+    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.buffer as ArrayBuffer,
+        peerPubKeyBytes,
         algo.imp,
         false,
         []
     );
 
-    const ecdhRawKey = await crypto.subtle.deriveKey(
+    // 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 },
-        state.localKeyPair.privateKey,
-        { name: "AES-GCM", length: 256 },
-        true,
-        ["encrypt", "decrypt"]
+        privateKey,
+        256
     );
-    const ecdhRawBytes = await crypto.subtle.exportKey("raw", ecdhRawKey);
 
     // HKDF-SHA256: salt=empty, info="openclaw-e2e-v1" → AES-256-GCM key
     const hkdfKey = await crypto.subtle.importKey(
-        "raw", ecdhRawBytes as ArrayBuffer, { name: "HKDF" }, false, ["deriveKey"]
+        "raw", ecdhRawBytes, { name: "HKDF" }, false, ["deriveKey"]
     );
-    state.sharedKey = await crypto.subtle.deriveKey(
+    const sharedKey = await crypto.subtle.deriveKey(
         {
             name: "HKDF",
             hash: "SHA-256",
@@ -99,11 +186,19 @@ async function e2eHandleHandshake(state: E2EState, peerPubKeyB64: string): Promi
         },
         hkdfKey,
         { name: "AES-GCM", length: 256 },
-        false,
+        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: E2EState, plaintext: string): Promise<string> {
@@ -126,27 +221,24 @@ async function e2eDecrypt(state: E2EState, nonceB64: string, ctB64: string): Pro
     const nonce = base64UrlToBuf(nonceB64);
     const ct = base64UrlToBuf(ctB64);
     const plain = await crypto.subtle.decrypt(
-        { name: "AES-GCM", iv: nonce.buffer as ArrayBuffer },
+        { name: "AES-GCM", iv: nonce },
         state.sharedKey,
-        ct.buffer as ArrayBuffer
+        ct
     );
     return new TextDecoder().decode(plain);
 }
 
 function bufToBase64Url(buf: ArrayBuffer | Uint8Array): string {
-    const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
-    let binary = "";
-    for (const b of bytes) binary += String.fromCharCode(b);
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    const buffer = Buffer.from(buf);
+    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
 
 function base64UrlToBuf(b64: string): Uint8Array {
     const padded = b64.replace(/-/g, "+").replace(/_/g, "/");
-    const pad = (4 - padded.length % 4) % 4;
-    const binary = atob(padded + "=".repeat(pad));
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    return bytes;
+    const buffer = Buffer.from(padded, "base64");
+    const cleanBytes = new Uint8Array(buffer.length);
+    cleanBytes.set(buffer);
+    return cleanBytes;
 }
 
 const HANDSHAKE_AUTH_VERSION = "v1";
@@ -235,18 +327,8 @@ interface RelayState {
     pingTimer: ReturnType<typeof setInterval> | null;
     statusSink: ((patch: Record<string, unknown>) => void) | null;
     gatewayCtx: any;
-    /**
-     * Per-session E2E state keyed by the app's session UUID.
-     * Each app connection gets its own X25519 keypair + AES-256-GCM shared key
-     * so multiple users can be active simultaneously without key collisions.
-     */
-    e2eSessions: Map<string, E2EState>;
-    /** Previous E2E states kept for decrypting offline-buffered messages
-     *  that were encrypted with the old key before the app reconnected. */
-    prevE2eSessions: Map<string, E2EState>;
-    /** Buffered pending_flush payloads waiting for the new E2E handshake to complete. */
-    pendingFlushQueue: Map<string, string[]>;
     relayToken: string;
+    lastActiveSessionKey?: string;
 }
 
 const relayStates = new Map<string, RelayState>();
@@ -255,6 +337,9 @@ const RECONNECT_DELAY = 5000;
 const PING_INTERVAL = 30_000; // 30s keepalive — prevents DO hibernation
 const DEFAULT_ACCOUNT_ID = "default";
 const CHANNEL_ID = "openclaw-app";
+const PLUGIN_VERSION = "1.1.9";
+/** Fixed chatSessionKey that routes cron messages to the App inbox UI */
+const INBOX_CHAT_SESSION_KEY = "inbox";
 
 function getRelayState(accountId: string): RelayState {
     let state = relayStates.get(accountId);
@@ -265,9 +350,6 @@ function getRelayState(accountId: string): RelayState {
             pingTimer: null,
             statusSink: null,
             gatewayCtx: null,
-            e2eSessions: new Map(),
-            prevE2eSessions: new Map(),
-            pendingFlushQueue: new Map(),
             relayToken: "",
         };
         relayStates.set(accountId, state);
@@ -415,52 +497,124 @@ const channel = {
             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" as const,
 
-        sendText: async ({ text, to, accountId, session }: any) => {
-            const aid = accountId ?? session?.accountId ?? DEFAULT_ACCOUNT_ID;
-            const state = getRelayState(aid);
+        // OpenClaw's ChannelOutboundAdapter.resolveTarget
+        // Called by resolveOutboundTarget() in src/infra/outbound/targets.ts
+        // to validate/normalize the delivery target address.
+        resolveTarget: ({ to }: { to?: string; allowFrom?: string[]; accountId?: string | null; mode?: string }) => {
+            const target = to?.trim() || "openclaw-app-user";
+            return { ok: true as const, to: target };
+        },
+
+        // OpenClaw's ChannelOutboundAdapter.sendText
+        // Called by createPluginHandler() in src/infra/outbound/deliver.ts
+        // ctx: ChannelOutboundContext = { cfg, to, text, accountId, ... }
+        sendText: async (ctx: any) => {
+            const text = ctx.text ?? "";
+            const accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
+            const state = getRelayState(accountId);
             if (!state.ws || state.ws.readyState !== WebSocket.OPEN) {
-                return { ok: false, error: "relay not connected" };
+                throw new Error("relay not connected");
             }
 
             const runtime = pluginRuntime;
-            let outText = text ?? "";
+            let outText = text;
             if (runtime) {
                 const cfg = runtime.config.loadConfig();
                 const tableMode = runtime.channel.text.resolveMarkdownTableMode({
                     cfg,
                     channel: CHANNEL_ID,
-                    accountId: aid,
+                    accountId,
                 });
                 outText = runtime.channel.text.convertMarkdownTables(outText, tableMode);
             }
 
-            const replySessionKey = session?.key ?? null;
-            if (!replySessionKey) {
-                return { ok: false, error: "missing session key" };
+            // 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 = state.e2eSessions.get(replySessionKey);
+            const sessionE2E = await loadE2EStateFromPersisted(accountId, accountE2E.activeDevicePubKey);
             if (!sessionE2E?.ready) {
-                return { ok: false, error: `e2e not ready for session ${replySessionKey}` };
+                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,
-                to: to ?? "mobile-user",
-                messageId: `mobile-${Date.now()}`,
+                messageId,
+            };
+        },
+
+        // OpenClaw's ChannelOutboundAdapter.sendMedia (required alongside sendText)
+        sendMedia: async (ctx: any) => {
+            // 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()}`,
             };
         },
     },
@@ -559,13 +713,9 @@ function cleanupRelay(state: RelayState) {
         state.reconnectTimer = null;
     }
     if (state.ws) {
-        try { state.ws.close(); } catch {}
+        try { state.ws.close(); } catch { }
         state.ws = null;
     }
-    state.e2eSessions.clear();
-    // prevE2eSessions is intentionally kept across reconnects so that
-    // offline-buffered messages can still be re-encrypted after a plugin
-    // reconnect. pendingFlushQueue is also kept for the same reason.
 }
 
 function connectRelay(ctx: any, account: ResolvedAccount) {
@@ -624,9 +774,10 @@ function connectRelay(ctx: any, account: ResolvedAccount) {
         });
     });
 
-    state.ws.addEventListener("close", () => {
+    state.ws.addEventListener("close", (event: any) => {
+        if (state.ws !== null && state.ws !== event.target) return; // Ignore stale connections
         ctx.log?.info?.(
-            `[${CHANNEL_ID}] [${accountId}] Relay disconnected, reconnecting...`
+            `[${CHANNEL_ID}] [${accountId}] Relay disconnected, reconnecting... (code: ${event.code}, reason: ${event.reason})`
         );
         state.ws = null;
         if (state.pingTimer) {
@@ -640,9 +791,10 @@ function connectRelay(ctx: any, account: ResolvedAccount) {
         scheduleReconnect(ctx, account);
     });
 
-    state.ws.addEventListener("error", () => {
-        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Relay WebSocket error`);
-        state.statusSink?.({ lastError: "WebSocket error" });
+    state.ws.addEventListener("error", (event: any) => {
+        const errMsg = event?.message || String(event);
+        ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] Relay WebSocket error: ${errMsg}`);
+        state.statusSink?.({ lastError: `WebSocket error: ${errMsg}` });
     });
 }
 
@@ -655,41 +807,6 @@ function scheduleReconnect(ctx: any, account: ResolvedAccount) {
     }, RECONNECT_DELAY);
 }
 
-async function processPendingFlush(
-    ctx: any, accountId: string, state: RelayState, sessionKey: string, messages: string[]
-): Promise<void> {
-    const oldE2E = state.prevE2eSessions.get(sessionKey);
-    const newE2E = state.e2eSessions.get(sessionKey);
-    if (!oldE2E?.ready) {
-        ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] pending_flush: no old key for session ${sessionKey}, dropping ${messages.length} message(s)`);
-        return;
-    }
-    if (!newE2E?.ready) {
-        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] pending_flush: new E2E not ready, queueing for session ${sessionKey}`);
-        state.pendingFlushQueue.set(sessionKey, messages);
-        return;
-    }
-    ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] pending_flush: re-encrypting ${messages.length} message(s) for session ${sessionKey}`);
-    for (const raw of messages) {
-        try {
-            const parsed = JSON.parse(raw);
-            if (parsed.type !== "encrypted" || !parsed.nonce || !parsed.ct) {
-                if (!parsed.sessionKey) parsed.sessionKey = sessionKey;
-                state.ws?.send(JSON.stringify(parsed));
-                continue;
-            }
-            const plaintext = await e2eDecrypt(oldE2E, parsed.nonce, parsed.ct);
-            const reEncrypted = JSON.parse(await e2eEncrypt(newE2E, plaintext));
-            reEncrypted.sessionKey = sessionKey;
-            state.ws?.send(JSON.stringify(reEncrypted));
-        } catch (e) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] pending_flush: failed to re-encrypt: ${e}`);
-        }
-    }
-    state.prevE2eSessions.delete(sessionKey);
-    state.pendingFlushQueue.delete(sessionKey);
-}
-
 async function handleRelayMessage(ctx: any, accountId: string, state: RelayState, raw: string): Promise<void> {
     // Skip ping/pong
     if (raw === "ping" || raw === "pong") return;
@@ -698,77 +815,22 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
 
     const msg = JSON.parse(raw);
 
-    // App session joined — initiate per-session E2E handshake
-    // 프로토콜: plugin이 먼저 handshake를 보내고, app이 자신의 pubkey로 응답.
-    // peer_joined가 중복으로 올 수 있으므로 이미 진행 중인 세션은 재시작하지 않음.
-    if (msg.type === "peer_joined") {
+    // App's handshake request (V2: App initiates with its persistent PubKey)
+    if (msg.type === "handshake") {
+        const peerPubKey = msg.pubkey as string | undefined;
         const sessionKey = msg.sessionKey as string | undefined;
-        if (!sessionKey) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] peer_joined missing sessionKey, ignoring`);
-            return;
-        }
-        // Preserve old E2E state for decrypting offline-buffered messages,
-        // then create a fresh state for the new handshake.
-        const oldE2E = state.e2eSessions.get(sessionKey);
-        if (oldE2E?.ready) {
-            state.prevE2eSessions.set(sessionKey, oldE2E);
-            ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} reconnected, old key preserved for pending_flush`);
-        }
-        state.e2eSessions.delete(sessionKey);
-        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] App session joined (${sessionKey}), sending handshake`);
-        const sessionE2E = makeE2EState();
-        state.e2eSessions.set(sessionKey, sessionE2E);
-        const pubkey = await e2eInit(sessionE2E);
-        const handshakePayload: Record<string, unknown> = {
-            type: "handshake",
-            sessionKey,
-            pubkey,
-        };
-        if (state.relayToken) {
-            const ts = Date.now();
-            const mac = await buildHandshakeMac(
-                state.relayToken,
-                "plugin",
-                sessionKey,
-                pubkey,
-                ts,
-                HANDSHAKE_AUTH_VERSION
-            );
-            handshakePayload.v = HANDSHAKE_AUTH_VERSION;
-            handshakePayload.ts = ts;
-            handshakePayload.mac = mac;
-        }
-        const handshakeWithSession = JSON.stringify(handshakePayload);
-        if (state.ws?.readyState === WebSocket.OPEN) {
-            state.ws.send(handshakeWithSession);
-        }
-        return;
-    }
+        const msgTs = msg.ts as number | undefined;
 
-    // Relay forwards buffered offline messages for re-encryption.
-    if (msg.type === "pending_flush") {
-        const sessionKey = msg.sessionKey as string | undefined;
-        const messages = msg.messages as string[] | undefined;
-        if (!sessionKey || !messages || messages.length === 0) {
-            ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] pending_flush: nothing to flush`);
+        if (!peerPubKey) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] handshake missing pubkey, ignoring`);
             return;
         }
-        await processPendingFlush(ctx, accountId, state, sessionKey, messages);
-        return;
-    }
 
-    // App의 handshake 응답 수신 — ECDH 완성
-    if (msg.type === "handshake") {
-        const sessionKey = msg.sessionKey as string | undefined;
-        const peerPubKey = msg.pubkey as string | undefined;
-        const peerMac = msg.mac as string | undefined;
-        const version = (msg.v as string | undefined) ?? HANDSHAKE_AUTH_VERSION;
-        const peerTs = parseHandshakeTs(msg.ts);
-        if (!sessionKey || !peerPubKey) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake missing sessionKey or pubkey`);
-            return;
-        }
         if (state.relayToken) {
+            const peerMac = msg.mac as string | undefined;
+            const peerTs = msg.ts as number | undefined;
+            const version = msg.v as string | undefined;
+
             if (!peerMac || peerTs == null) {
                 ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake missing auth fields`);
                 return;
@@ -781,104 +843,88 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
                 ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake timestamp out of window, dropping`);
                 return;
             }
-            const verified = await verifyHandshakeMac(
-                state.relayToken,
-                "app",
-                sessionKey,
-                peerPubKey,
-                peerTs,
-                peerMac,
-                version
-            );
-            if (!verified) {
-                ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake MAC verification failed, dropping`);
-                return;
-            }
         }
-        let sessionE2E = state.e2eSessions.get(sessionKey);
-        if (!sessionE2E) {
-            // peer_joined 없이 app이 먼저 handshake를 보낸 경우 (예: plugin 재연결)
-            // 새 세션을 만들고 plugin의 pubkey를 먼저 전송한 후 ECDH 완성
-            sessionE2E = makeE2EState();
-            state.e2eSessions.set(sessionKey, sessionE2E);
-            const pubkey = await e2eInit(sessionE2E);
-            const handshakePayload: Record<string, unknown> = {
-                type: "handshake",
-                sessionKey,
-                pubkey,
-            };
-            if (state.relayToken) {
-                const ts = Date.now();
-                const mac = await buildHandshakeMac(
-                    state.relayToken,
-                    "plugin",
-                    sessionKey,
-                    pubkey,
-                    ts,
-                    HANDSHAKE_AUTH_VERSION
-                );
-                handshakePayload.v = HANDSHAKE_AUTH_VERSION;
-                handshakePayload.ts = ts;
-                handshakePayload.mac = mac;
-            }
-            const handshakeWithSession = JSON.stringify(handshakePayload);
-            if (state.ws?.readyState === WebSocket.OPEN) {
-                state.ws.send(handshakeWithSession);
-                ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} — sent handshake (reactive, no prior peer_joined)`);
-            }
-        }
-        if (sessionE2E.ready) {
-            ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} already ready, ignoring duplicate handshake`);
-            return;
+
+        // V2: Derive persistent shared secret and store it
+        await e2eHandleHandshake(accountId, peerPubKey);
+
+        if (sessionKey) {
+            state.lastActiveSessionKey = sessionKey;
         }
-        if (!sessionE2E.localKeyPair) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} has no local keypair yet, dropping handshake`);
-            return;
+
+        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: Record<string, unknown> = {
+            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;
         }
-        await e2eHandleHandshake(sessionE2E, peerPubKey);
-        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} handshake complete`);
-
-        // Process any queued pending_flush that arrived before this handshake completed
-        const queued = state.pendingFlushQueue.get(sessionKey);
-        if (queued && queued.length > 0) {
-            ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Processing queued pending_flush for session ${sessionKey}`);
-            await processPendingFlush(ctx, accountId, state, sessionKey, queued);
+
+        if (state.ws?.readyState === WebSocket.OPEN) {
+            state.ws.send(JSON.stringify(replyPayload));
         }
         return;
     }
-
-    // E2E encrypted message — decrypt using the per-session key
+    // Process E2E encrypted messages from the App
     if (msg.type === "encrypted") {
-        const sessionKey = msg.sessionKey as string | undefined;
-        if (!sessionKey) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Encrypted msg missing sessionKey, dropping`);
+        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 = state.e2eSessions.get(sessionKey);
+
+        const sessionE2E = await loadE2EStateFromPersisted(accountId, devicePubKey);
         if (!sessionE2E?.ready) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} not ready, dropping`);
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Failed to load SharedSecret for active device, dropping`);
             return;
         }
-        const plaintext = await e2eDecrypt(sessionE2E, msg.nonce, msg.ct);
-        ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} decrypted: ${plaintext.slice(0, 200)}`);
-        const innerMsg = JSON.parse(plaintext);
-        // Preserve sessionKey through decryption so handleInbound can use it
-        if (!innerMsg.sessionKey) innerMsg.sessionKey = sessionKey;
-        await handleInbound(ctx, accountId, innerMsg);
+
+        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;
     }
 
-    // Plaintext message (no E2E or during handshake)
+    // 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") {
-        const sessionKey = msg.sessionKey as string | undefined;
-        const sessionE2E = sessionKey ? state.e2eSessions.get(sessionKey) : undefined;
-        if (!sessionE2E?.ready) {
-            ctx.log?.warn?.(
-                `[${CHANNEL_ID}] [${accountId}] [E2E] Dropping plaintext ${msg.type} (session not encrypted yet)`
-            );
-            return;
-        }
+        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);
 }
 
@@ -902,12 +948,22 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
     const sendRpcReply = async (data: unknown, error?: string) => {
         if (!relayState.ws || relayState.ws.readyState !== WebSocket.OPEN) return;
         if (!replySessionKey) return;
-        const sessionE2E = relayState.e2eSessions.get(replySessionKey);
-        if (!sessionE2E?.ready) return;
-        const inner = JSON.stringify({ type: "rpc-response", id: reqId, data, error: error ?? null, sessionKey: replySessionKey });
-        const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, inner));
-        encrypted.sessionKey = replySessionKey;
-        relayState.ws.send(JSON.stringify(encrypted));
+
+        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 {
@@ -972,7 +1028,7 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                     entriesSample: Object.entries(cfg?.skills?.entries ?? {}).slice(0, 5)
                         .map(([k, v]: [string, any]) => ({ name: k, enabled: v?.enabled })),
                 };
-            } catch (_) {}
+            } catch (_) { }
 
             await sendRpcReply({ runtimeShape, skillsProbe, cfgSkills });
         } else if (method === "agents.list") {
@@ -1039,11 +1095,11 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                         10000
                     );
                 }
-                if (cliResult.exitCode === 0 && cliResult.stdout?.trim()) {
+                if (cliResult && cliResult.exitCode === 0 && cliResult.stdout?.trim()) {
                     const parsed = JSON.parse(cliResult.stdout.trim());
                     const raw: any[] = Array.isArray(parsed) ? parsed
                         : Array.isArray(parsed?.skills) ? parsed.skills
-                        : parsed?.data ?? [];
+                            : parsed?.data ?? [];
                     tools = raw
                         .filter((s: any) => s['user-invocable'] !== false && s['user-invocable'] !== 'false')
                         .map((s: any) => ({
@@ -1054,7 +1110,7 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                         }))
                         .filter((t: any) => t.name);
                 }
-            } catch (_) {}
+            } catch (_) { }
 
             // Fallback: scan ~/.openclaw for all skills/ subdirs, deduplicated
             if (tools.length === 0) {
@@ -1073,7 +1129,7 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                     const addSkillsDir = (dir: string) => {
                         try {
                             if (fs.existsSync(dir)) skillDirs.push(dir);
-                        } catch (_) {}
+                        } catch (_) { }
                     };
 
                     // ~/.openclaw/skills
@@ -1085,7 +1141,7 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                             const sub = path.join(ocRoot, entry, 'skills');
                             addSkillsDir(sub);
                         }
-                    } catch (_) {}
+                    } catch (_) { }
 
                     // Extra dirs from config
                     for (const d of (cfg?.skills?.load?.extraDirs ?? [])) addSkillsDir(d);
@@ -1107,10 +1163,20 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                             tools.push({ name, description: fm.description ?? '', category: '', userInvocable: true });
                         }
                     }
-                } catch (_) {}
+                } catch (_) { }
             }
 
             await sendRpcReply({ tools });
+        } else if (method === "plugin.version") {
+            await sendRpcReply({
+                pluginVersion: PLUGIN_VERSION,
+                channelId: CHANNEL_ID,
+            });
+        } else if (method === "inbox.test") {
+            // Debug/test: send a test message to the App inbox
+            const testText = (params.text as string) || "🔔 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 as string | undefined;
@@ -1133,6 +1199,25 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                     await sendRpcReply(null, `tools.invoke '${toolName}' error: ${e}`);
                 }
             }
+        } else if (method === "chat.abort") {
+            const abortSessionKey = (params.sessionKey as string) || replySessionKey;
+            const runId = params.runId as string | undefined;
+            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: any) {
+                    await sendRpcReply(null, `chat.abort error: ${e}`);
+                }
+            }
         } else {
             await sendRpcReply(null, `Unknown RPC method: ${method}`);
         }
@@ -1163,8 +1248,8 @@ async function handleInbound(ctx: any, accountId: string, msg: any) {
         return;
     }
 
-    const senderId = msg.senderId ?? "mobile-user";
-    const senderName = msg.senderName ?? "Mobile User";
+    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;
 
@@ -1246,38 +1331,90 @@ async function handleInbound(ctx: any, accountId: string, msg: any) {
         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: Record<string, unknown> = {
+                        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: any) => {
                     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: Record<string, unknown> = {
+                            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);
-                    // The relay routes plugin→app by sessionKey in the JSON payload
-                    const replySessionKey = appSessionKey ?? sessionKey;
-                    const sessionE2E = relayState.e2eSessions.get(replySessionKey);
-                    if (!sessionE2E?.ready) {
-                        ctx.log?.warn?.(
-                            `[${CHANNEL_ID}] [${accountId}] [E2E] Reply blocked: session ${replySessionKey} not ready`
-                        );
-                        return;
-                    }
+
                     for (const chunk of chunks.length > 0 ? chunks : [replyText]) {
                         if (!chunk) continue;
+                        const messageId = crypto.randomUUID();
                         const innerPayload: Record<string, unknown> = {
                             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);
                     }
@@ -1316,6 +1453,52 @@ async function handleInbound(ctx: any, accountId: string, msg: any) {
     }
 }
 
+// ── 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: string, text: string, api: any): Promise<boolean> {
+    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: any) {
@@ -1330,10 +1513,28 @@ export default function register(api: any) {
             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 as any).__patched) {
+                const originalCronAdd = runtime.cron.add.bind(runtime.cron);
+                runtime.cron.add = async (jobCreate: any) => {
+                    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 as any).__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;
+            if (existing !== undefined) {
+                return;
+            }
 
             const patched = {
                 ...cfg,
@@ -1360,6 +1561,8 @@ export default function register(api: any) {
         }
     });
 
+
+
     api.logger?.info?.("[openclaw-app] Plugin registered");
 }
 
@@ -1386,4 +1589,4 @@ function _parseSkillFrontmatter(content: string): Record<string, any> {
         else result[key] = val;
     }
     return result;
-}
+}