aicq-openclaw-plugin 1.2.0 → 1.3.0

package/dist/index.js

@@ -4922,9 +4922,9 @@ var require_lib = __commonJS({
   }
 });
 
-// node_modules/tweetnacl/nacl-fast.js
+// ../node_modules/tweetnacl/nacl-fast.js
 var require_nacl_fast = __commonJS({
-  "node_modules/tweetnacl/nacl-fast.js"(exports, module) {
+  "../node_modules/tweetnacl/nacl-fast.js"(exports, module) {
     (function(nacl3) {
       "use strict";
       var gf = function(init) {
@@ -7146,9 +7146,9 @@ var require_nacl_fast = __commonJS({
   }
 });
 
-// node_modules/tweetnacl-util/nacl-util.js
+// ../node_modules/tweetnacl-util/nacl-util.js
 var require_nacl_util = __commonJS({
-  "node_modules/tweetnacl-util/nacl-util.js"(exports, module) {
+  "../node_modules/tweetnacl-util/nacl-util.js"(exports, module) {
     (function(root, f) {
       "use strict";
       if (typeof module !== "undefined" && module.exports) module.exports = f();
@@ -7212,9 +7212,9 @@ var require_nacl_util = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/nacl.js
+// ../shared/crypto/dist/nacl.js
 var require_nacl = __commonJS({
-  "node_modules/@aicq/crypto/nacl.js"(exports) {
+  "../shared/crypto/dist/nacl.js"(exports) {
     "use strict";
     var __importDefault = exports && exports.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -7231,9 +7231,9 @@ var require_nacl = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/keygen.js
+// ../shared/crypto/dist/keygen.js
 var require_keygen = __commonJS({
-  "node_modules/@aicq/crypto/keygen.js"(exports) {
+  "../shared/crypto/dist/keygen.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.generateSigningKeyPair = generateSigningKeyPair2;
@@ -7272,9 +7272,9 @@ var require_keygen = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/signer.js
+// ../shared/crypto/dist/signer.js
 var require_signer = __commonJS({
-  "node_modules/@aicq/crypto/signer.js"(exports) {
+  "../shared/crypto/dist/signer.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.sign = sign;
@@ -7289,9 +7289,9 @@ var require_signer = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/keyExchange.js
+// ../shared/crypto/dist/keyExchange.js
 var require_keyExchange = __commonJS({
-  "node_modules/@aicq/crypto/keyExchange.js"(exports) {
+  "../shared/crypto/dist/keyExchange.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.computeSharedSecret = computeSharedSecret2;
@@ -7342,9 +7342,9 @@ var require_keyExchange = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/cipher.js
+// ../shared/crypto/dist/cipher.js
 var require_cipher = __commonJS({
-  "node_modules/@aicq/crypto/cipher.js"(exports) {
+  "../shared/crypto/dist/cipher.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.generateNonce = generateNonce;
@@ -7368,9 +7368,9 @@ var require_cipher = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/message.js
+// ../shared/crypto/dist/message.js
 var require_message = __commonJS({
-  "node_modules/@aicq/crypto/message.js"(exports) {
+  "../shared/crypto/dist/message.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.createMessage = createMessage;
@@ -7484,9 +7484,9 @@ var require_message = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/password.js
+// ../shared/crypto/dist/password.js
 var require_password = __commonJS({
-  "node_modules/@aicq/crypto/password.js"(exports) {
+  "../shared/crypto/dist/password.js"(exports) {
     "use strict";
     var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
       if (k2 === void 0) k2 = k;
@@ -7564,9 +7564,9 @@ var require_password = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/handshake.js
+// ../shared/crypto/dist/handshake.js
 var require_handshake = __commonJS({
-  "node_modules/@aicq/crypto/handshake.js"(exports) {
+  "../shared/crypto/dist/handshake.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.createHandshakeRequest = createHandshakeRequest2;
@@ -7675,9 +7675,9 @@ var require_handshake = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/index.js
-var require_crypto = __commonJS({
-  "node_modules/@aicq/crypto/index.js"(exports) {
+// ../shared/crypto/dist/index.js
+var require_dist = __commonJS({
+  "../shared/crypto/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.completeHandshake = exports.createHandshakeResponse = exports.createHandshakeRequest = exports.decryptWithPassword = exports.encryptWithPassword = exports.decryptMessage = exports.encryptMessage = exports.parseMessage = exports.createMessage = exports.generateNonce = exports.decrypt = exports.encrypt = exports.deriveSessionKey = exports.computeSharedSecret = exports.verify = exports.sign = exports.getPublicKeyFingerprint = exports.deriveX25519FromEd25519 = exports.generateKeyExchangeKeyPair = exports.generateSigningKeyPair = exports.encodeBase64 = exports.decodeBase64 = exports.encodeUTF8 = exports.decodeUTF8 = exports.nacl = void 0;
@@ -7913,9 +7913,13 @@ var PluginStore = class {
     this.tempNumbers = [];
     this.pendingRequests = [];
     this.pendingHandshakes = /* @__PURE__ */ new Map();
+    this.offlineMessages = [];
     this.dataDir = "";
     this.storePath = "";
     this.encryptionSalt = crypto3.randomBytes(16);
+    this.saveTimer = null;
+    this.saveDebounceMs = 1e3;
+    this.dirty = false;
   }
   /**
    * Set the data directory for persistence.
@@ -7934,12 +7938,38 @@ var PluginStore = class {
     return deriveEncryptionKey(this.agentId || "default-aicq-node", this.encryptionSalt);
   }
   /**
-   * Save the current state to disk.
+   * Mark the store as dirty and schedule a debounced save.
+   * For operations that need immediate persistence (e.g., new keys), use saveNow().
+   */
+  markDirty() {
+    this.dirty = true;
+    if (!this.saveTimer) {
+      this.saveTimer = setTimeout(() => {
+        this.saveTimer = null;
+        this.flushSave();
+      }, this.saveDebounceMs);
+    }
+  }
+  /**
+   * Save the current state to disk immediately (atomic write).
    *
-   * Secret keys are encrypted at rest using AES-256-GCM with a key
-   * derived from the node ID and a stored random salt.
+   * Uses write-to-temp + rename for crash safety. Secret keys are encrypted
+   * at rest using AES-256-GCM with a key derived from the node ID and salt.
    */
-  save() {
+  saveNow() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    this.flushSave();
+  }
+  /**
+   * Internal save implementation — writes atomically via temp file + rename.
+   */
+  flushSave() {
+    if (!this.dirty && this.saveTimer === null)
+      return;
+    this.dirty = false;
     if (!this.storePath)
       return;
     const encKey = this.getEncryptionKey();
@@ -7980,25 +8010,43 @@ var PluginStore = class {
         requesterId: p.requesterId,
         tempNumber: p.tempNumber,
         timestamp: p.timestamp.toISOString()
-      }))
+      })),
+      offlineMessages: this.offlineMessages
     };
     try {
-      fs2.writeFileSync(this.storePath, JSON.stringify(serialized, null, 2), "utf-8");
+      const tmpPath = this.storePath + ".tmp";
+      const jsonStr = JSON.stringify(serialized, null, 2);
+      fs2.writeFileSync(tmpPath, jsonStr, "utf-8");
+      fs2.renameSync(tmpPath, this.storePath);
     } catch (err) {
       console.error("[PluginStore] Failed to save state:", err);
     }
   }
+  /**
+   * @deprecated Use markDirty() or saveNow() for better performance.
+   * Kept for backward compatibility — performs immediate save.
+   */
+  save() {
+    this.saveNow();
+  }
   /**
    * Load state from disk, if available.
    *
    * Decrypts secret keys using AES-256-GCM with the stored salt and
-   * node ID.  Falls back to plaintext if the data was stored before
+   * node ID. Falls back to plaintext if the data was stored before
    * encryption was added (backward compatibility).
    */
   load() {
     if (!this.storePath || !fs2.existsSync(this.storePath)) {
       return false;
     }
+    const tmpPath = this.storePath + ".tmp";
+    if (!fs2.existsSync(this.storePath) && fs2.existsSync(tmpPath)) {
+      try {
+        fs2.renameSync(tmpPath, this.storePath);
+      } catch {
+      }
+    }
     try {
       const raw = fs2.readFileSync(this.storePath, "utf-8");
       const data = JSON.parse(raw);
@@ -8061,18 +8109,101 @@ var PluginStore = class {
         tempNumber: p.tempNumber,
         timestamp: new Date(p.timestamp)
       }));
+      this.offlineMessages = (data.offlineMessages || []).map((m) => ({
+        id: m.id,
+        targetId: m.targetId,
+        encryptedData: m.encryptedData,
+        timestamp: m.timestamp,
+        retryCount: m.retryCount || 0,
+        maxRetries: m.maxRetries || 10
+      }));
+      if (fs2.existsSync(tmpPath)) {
+        try {
+          fs2.unlinkSync(tmpPath);
+        } catch {
+        }
+      }
       return true;
     } catch (err) {
       console.error("[PluginStore] Failed to load state:", err);
+      if (fs2.existsSync(tmpPath)) {
+        console.info("[PluginStore] Attempting recovery from temp file...");
+        try {
+          fs2.renameSync(tmpPath, this.storePath);
+          return this.load();
+        } catch {
+          console.error("[PluginStore] Recovery from temp file failed");
+        }
+      }
       return false;
     }
   }
+  // ----------------------------------------------------------------
+  //  Offline message queue
+  // ----------------------------------------------------------------
+  /**
+   * Add a message to the offline queue for later delivery.
+   */
+  enqueueOfflineMessage(targetId, encryptedData) {
+    const msg = {
+      id: v4_default(),
+      targetId,
+      encryptedData,
+      timestamp: Date.now(),
+      retryCount: 0,
+      maxRetries: 10
+    };
+    this.offlineMessages.push(msg);
+    this.markDirty();
+    return msg;
+  }
+  /**
+   * Dequeue the next pending offline message.
+   */
+  dequeueOfflineMessage() {
+    return this.offlineMessages.shift();
+  }
+  /**
+   * Get the number of pending offline messages.
+   */
+  getOfflineMessageCount() {
+    return this.offlineMessages.length;
+  }
+  /**
+   * Peek at the offline message queue without removing.
+   */
+  peekOfflineMessages() {
+    return [...this.offlineMessages];
+  }
+  /**
+   * Clear all pending offline messages.
+   */
+  clearOfflineMessages() {
+    this.offlineMessages = [];
+    this.markDirty();
+  }
+  /**
+   * Remove expired offline messages (older than 24 hours).
+   */
+  cleanupExpiredOfflineMessages() {
+    const now = Date.now();
+    const threshold = 24 * 60 * 60 * 1e3;
+    const before = this.offlineMessages.length;
+    this.offlineMessages = this.offlineMessages.filter((m) => now - m.timestamp < threshold);
+    if (this.offlineMessages.length !== before) {
+      this.markDirty();
+    }
+    return before - this.offlineMessages.length;
+  }
+  // ----------------------------------------------------------------
+  //  Friend management
+  // ----------------------------------------------------------------
   /**
    * Add a friend record.
    */
   addFriend(friend) {
     this.friends.set(friend.id, friend);
-    this.save();
+    this.markDirty();
   }
   /**
    * Remove a friend by ID and clean up associated session.
@@ -8081,7 +8212,7 @@ var PluginStore = class {
     const removed = this.friends.delete(friendId);
     if (removed) {
       this.sessions.delete(friendId);
-      this.save();
+      this.markDirty();
     }
     return removed;
   }
@@ -8097,6 +8228,9 @@ var PluginStore = class {
   getFriendCount() {
     return this.friends.size;
   }
+  // ----------------------------------------------------------------
+  //  Session management
+  // ----------------------------------------------------------------
   /**
    * Set a session for a peer.
    */
@@ -8106,7 +8240,7 @@ var PluginStore = class {
     if (friend) {
       friend.sessionKey = session.sessionKey;
     }
-    this.save();
+    this.saveNow();
   }
   /**
    * Get a session by peer ID.
@@ -8120,12 +8254,15 @@ var PluginStore = class {
   removeSession(peerId) {
     return this.sessions.delete(peerId);
   }
+  // ----------------------------------------------------------------
+  //  Temp number management
+  // ----------------------------------------------------------------
   /**
    * Add a temp number record.
    */
   addTempNumber(number, expiresAt) {
     this.tempNumbers.push({ number, expiresAt });
-    this.save();
+    this.markDirty();
   }
   /**
    * Revoke (remove) a temp number.
@@ -8134,7 +8271,7 @@ var PluginStore = class {
     const idx = this.tempNumbers.findIndex((t) => t.number === number);
     if (idx !== -1) {
       this.tempNumbers.splice(idx, 1);
-      this.save();
+      this.markDirty();
       return true;
     }
     return false;
@@ -8147,15 +8284,18 @@ var PluginStore = class {
     const before = this.tempNumbers.length;
     this.tempNumbers = this.tempNumbers.filter((t) => t.expiresAt > now);
     if (this.tempNumbers.length !== before) {
-      this.save();
+      this.markDirty();
     }
   }
+  // ----------------------------------------------------------------
+  //  Pending friend requests
+  // ----------------------------------------------------------------
   /**
    * Add a pending friend request.
    */
   addPendingRequest(request) {
     this.pendingRequests.push(request);
-    this.save();
+    this.markDirty();
   }
   /**
    * Remove a pending friend request.
@@ -8164,11 +8304,14 @@ var PluginStore = class {
     const idx = this.pendingRequests.findIndex((p) => p.requesterId === requesterId);
     if (idx !== -1) {
       this.pendingRequests.splice(idx, 1);
-      this.save();
+      this.markDirty();
       return true;
     }
     return false;
   }
+  // ----------------------------------------------------------------
+  //  Handshake state
+  // ----------------------------------------------------------------
   /**
    * Set a pending handshake state.
    */
@@ -8191,7 +8334,7 @@ var PluginStore = class {
 
 // dist/services/identityService.js
 var import_qrcode = __toESM(require_lib(), 1);
-var import_crypto3 = __toESM(require_crypto(), 1);
+var import_crypto3 = __toESM(require_dist(), 1);
 import * as crypto4 from "crypto";
 var IdentityService = class {
   constructor(store, logger) {
@@ -8365,16 +8508,66 @@ var IdentityService = class {
 
 // dist/services/serverClient.js
 import WebSocket from "ws";
+var DEFAULT_CONFIG = {
+  initialReconnectDelay: 1e3,
+  maxReconnectDelay: 6e4,
+  reconnectBackoffFactor: 2,
+  heartbeatIntervalMs: 3e4,
+  requestTimeoutMs: 3e4
+};
 var ServerClient = class {
-  constructor(serverUrl, store, logger) {
+  constructor(serverUrl, store, logger, config2) {
     this.ws = null;
     this.wsReconnectTimer = null;
     this.heartbeatTimer = null;
     this.wsConnected = false;
+    this.connectionState = "offline";
+    this.reconnectDelay = DEFAULT_CONFIG.initialReconnectDelay;
+    this.reconnectAttempts = 0;
+    this.stateChangeCallbacks = [];
     this.wsHandlers = /* @__PURE__ */ new Map();
     this.serverUrl = serverUrl;
     this.store = store;
     this.logger = logger;
+    this.config = { ...DEFAULT_CONFIG, ...config2 };
+  }
+  // ----------------------------------------------------------------
+  //  Connection state management
+  // ----------------------------------------------------------------
+  /**
+   * Get the current connection state.
+   */
+  getConnectionState() {
+    return this.connectionState;
+  }
+  /**
+   * Register a callback for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    this.stateChangeCallbacks.push(callback);
+  }
+  /**
+   * Remove a connection state callback.
+   */
+  offConnectionStateChange(callback) {
+    this.stateChangeCallbacks = this.stateChangeCallbacks.filter((cb) => cb !== callback);
+  }
+  /**
+   * Update connection state and notify listeners.
+   */
+  setConnectionState(newState) {
+    const previousState = this.connectionState;
+    if (previousState === newState)
+      return;
+    this.connectionState = newState;
+    this.logger.info(`[Server] Connection state: ${previousState} \u2192 ${newState}`);
+    for (const callback of this.stateChangeCallbacks) {
+      try {
+        callback(newState, previousState);
+      } catch (err) {
+        this.logger.error("[Server] Connection state callback error:", err);
+      }
+    }
   }
   // ----------------------------------------------------------------
   //  WebSocket connection
@@ -8383,15 +8576,42 @@ var ServerClient = class {
    * Connect to the server via WebSocket and start heartbeat.
    */
   connectWebSocket() {
-    const baseUrl = this.serverUrl.replace(/^http/, "ws");
-    const url = new URL(baseUrl + "/ws");
-    url.port = "443";
-    url.protocol = "wss:";
-    const wsUrl = url.toString();
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      this.logger.debug("[Server] WebSocket already connecting/connected");
+      return;
+    }
+    let wsUrl;
+    try {
+      const baseUrl = this.serverUrl.replace(/^http/, "ws");
+      const url = new URL(baseUrl + "/ws");
+      url.port = "443";
+      url.protocol = "wss:";
+      wsUrl = url.toString();
+    } catch {
+      wsUrl = this.serverUrl.replace(/^https?/, "wss") + "/ws";
+    }
     this.logger.info("[Server] Connecting WebSocket to " + wsUrl);
-    this.ws = new WebSocket(wsUrl);
+    this.setConnectionState("reconnecting");
+    try {
+      this.ws = new WebSocket(wsUrl);
+    } catch (err) {
+      this.logger.error("[Server] Failed to create WebSocket:", err);
+      this.setConnectionState("offline");
+      this.scheduleReconnect();
+      return;
+    }
+    const connectTimeout = setTimeout(() => {
+      if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
+        this.logger.warn("[Server] WebSocket connection timeout");
+        this.ws.terminate();
+      }
+    }, this.config.requestTimeoutMs);
     this.ws.on("open", () => {
+      clearTimeout(connectTimeout);
       this.wsConnected = true;
+      this.reconnectDelay = this.config.initialReconnectDelay;
+      this.reconnectAttempts = 0;
+      this.setConnectionState("online");
       this.logger.info("[Server] WebSocket connected");
       this.wsSend({
         type: "online",
@@ -8409,29 +8629,30 @@ var ServerClient = class {
       }
     });
     this.ws.on("close", (code, reason) => {
+      clearTimeout(connectTimeout);
       this.wsConnected = false;
       this.logger.info("[Server] WebSocket closed:", code, reason.toString());
       this.stopHeartbeat();
+      this.setConnectionState("offline");
       this.scheduleReconnect();
     });
     this.ws.on("error", (err) => {
+      clearTimeout(connectTimeout);
       this.logger.error("[Server] WebSocket error:", err.message);
     });
   }
   /**
-   * Disconnect the WebSocket.
+   * Disconnect the WebSocket and stop reconnection.
    */
   disconnectWebSocket() {
     this.stopHeartbeat();
-    if (this.wsReconnectTimer) {
-      clearTimeout(this.wsReconnectTimer);
-      this.wsReconnectTimer = null;
-    }
+    this.cancelReconnect();
     if (this.ws) {
       this.ws.close();
       this.ws = null;
     }
     this.wsConnected = false;
+    this.setConnectionState("offline");
   }
   /**
    * Check if the WebSocket is connected.
@@ -8449,13 +8670,50 @@ var ServerClient = class {
   }
   /**
    * Send a JSON message over the WebSocket.
+   * Returns true if the message was sent, false if offline.
    */
   wsSend(data) {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(data));
-    } else {
-      this.logger.warn("[Server] Cannot send \u2014 WebSocket not open");
+      return true;
     }
+    this.logger.warn("[Server] Cannot send \u2014 WebSocket not open");
+    return false;
+  }
+  // ----------------------------------------------------------------
+  //  Exponential backoff reconnection
+  // ----------------------------------------------------------------
+  /**
+   * Schedule a reconnection attempt with exponential backoff.
+   *
+   * Delay formula: min(initialDelay * backoffFactor^attempts, maxDelay)
+   * With jitter: delay * (0.75 + Math.random() * 0.5) to avoid thundering herd
+   */
+  scheduleReconnect() {
+    if (this.wsReconnectTimer)
+      return;
+    const jitter = 0.75 + Math.random() * 0.5;
+    const delay = Math.min(this.reconnectDelay * jitter, this.config.maxReconnectDelay);
+    this.reconnectAttempts++;
+    this.logger.info(`[Server] Reconnecting in ${Math.round(delay)}ms (attempt #${this.reconnectAttempts})`);
+    this.setConnectionState("reconnecting");
+    this.wsReconnectTimer = setTimeout(() => {
+      this.wsReconnectTimer = null;
+      this.logger.info("[Server] Attempting WebSocket reconnect...");
+      this.connectWebSocket();
+    }, delay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * this.config.reconnectBackoffFactor, this.config.maxReconnectDelay);
+  }
+  /**
+   * Cancel a pending reconnection.
+   */
+  cancelReconnect() {
+    if (this.wsReconnectTimer) {
+      clearTimeout(this.wsReconnectTimer);
+      this.wsReconnectTimer = null;
+    }
+    this.reconnectDelay = this.config.initialReconnectDelay;
+    this.reconnectAttempts = 0;
   }
   // ----------------------------------------------------------------
   //  REST API methods
@@ -8570,9 +8828,10 @@ var ServerClient = class {
   }
   /**
    * Send a relay message via the server (WebSocket fallback for P2P).
+   * Returns true if sent, false if offline.
    */
   sendRelayMessage(targetId, payload) {
-    this.wsSend({
+    return this.wsSend({
       type: "relay",
       targetId,
       payload,
@@ -8585,11 +8844,15 @@ var ServerClient = class {
   async fetchPost(path7, body) {
     const url = this.serverUrl + path7;
     try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
       const resp = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        signal: controller.signal
       });
+      clearTimeout(timeout);
       if (!resp.ok) {
         const text = await resp.text();
         this.logger.error(`[Server] API error ${resp.status} on ${path7}: ${text}`);
@@ -8597,14 +8860,21 @@ var ServerClient = class {
       }
       return await resp.json();
     } catch (err) {
-      this.logger.error(`[Server] API request failed for ${path7}:`, err);
+      if (err instanceof DOMException && err.name === "AbortError") {
+        this.logger.error(`[Server] API request timeout for ${path7}`);
+      } else {
+        this.logger.error(`[Server] API request failed for ${path7}:`, err);
+      }
       return null;
     }
   }
   async fetchGet(path7) {
     const url = this.serverUrl + path7;
     try {
-      const resp = await fetch(url);
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+      const resp = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeout);
       if (!resp.ok) {
         const text = await resp.text();
         this.logger.error(`[Server] API error ${resp.status} on ${path7}: ${text}`);
@@ -8612,18 +8882,26 @@ var ServerClient = class {
       }
       return await resp.json();
     } catch (err) {
-      this.logger.error(`[Server] GET request failed for ${path7}:`, err);
+      if (err instanceof DOMException && err.name === "AbortError") {
+        this.logger.error(`[Server] GET request timeout for ${path7}`);
+      } else {
+        this.logger.error(`[Server] GET request failed for ${path7}:`, err);
+      }
       return null;
     }
   }
   async del(path7, body) {
     const url = this.serverUrl + path7;
     try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
       const resp = await fetch(url, {
         method: "DELETE",
         headers: { "Content-Type": "application/json" },
-        body: body ? JSON.stringify(body) : void 0
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
       });
+      clearTimeout(timeout);
       return resp.ok;
     } catch (err) {
       this.logger.error(`[Server] DELETE request failed for ${path7}:`, err);
@@ -8633,11 +8911,15 @@ var ServerClient = class {
   async post(path7, body) {
     const url = this.serverUrl + path7;
     try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
       const resp = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        signal: controller.signal
       });
+      clearTimeout(timeout);
       return resp.ok;
     } catch (err) {
       this.logger.error(`[Server] API request failed for ${path7}:`, err);
@@ -8658,9 +8940,10 @@ var ServerClient = class {
     }
   }
   startHeartbeat() {
+    this.stopHeartbeat();
     this.heartbeatTimer = setInterval(() => {
       this.wsSend({ type: "ping", agentId: this.store.agentId, timestamp: Date.now() });
-    }, 3e4);
+    }, this.config.heartbeatIntervalMs);
   }
   stopHeartbeat() {
     if (this.heartbeatTimer) {
@@ -8668,19 +8951,10 @@ var ServerClient = class {
       this.heartbeatTimer = null;
     }
   }
-  scheduleReconnect() {
-    if (this.wsReconnectTimer)
-      return;
-    this.wsReconnectTimer = setTimeout(() => {
-      this.wsReconnectTimer = null;
-      this.logger.info("[Server] Attempting WebSocket reconnect...");
-      this.connectWebSocket();
-    }, 5e3);
-  }
 };
 
 // dist/handshake/handshakeManager.js
-var import_crypto4 = __toESM(require_crypto(), 1);
+var import_crypto4 = __toESM(require_dist(), 1);
 import * as crypto5 from "crypto";
 var HandshakeManager = class {
   constructor(store, serverClient, config2, logger) {
@@ -9096,7 +9370,7 @@ var P2PConnectionManager = class {
 };
 
 // dist/fileTransfer/transferManager.js
-var import_crypto5 = __toESM(require_crypto(), 1);
+var import_crypto5 = __toESM(require_dist(), 1);
 import * as fs3 from "fs";
 import * as path3 from "path";
 var DEFAULT_CHUNK_SIZE = 64 * 1024;
@@ -9319,7 +9593,7 @@ var FileTransferManager = class {
 };
 
 // dist/channels/encryptedChat.js
-var import_crypto6 = __toESM(require_crypto(), 1);
+var import_crypto6 = __toESM(require_dist(), 1);
 import * as fs4 from "fs";
 import * as path4 from "path";
 function safeFilePath(filePath, allowedDir) {
@@ -9335,12 +9609,18 @@ var EncryptedChatChannel = class {
     this.api = null;
     this.dataDir = "";
     this.fileChunkBuffers = /* @__PURE__ */ new Map();
+    this.flushingOffline = false;
     this.store = store;
     this.handshakeManager = handshakeManager;
     this.p2pManager = p2pManager;
     this.serverClient = serverClient;
     this.logger = logger;
     this.dataDir = dataDir;
+    this.serverClient.onConnectionStateChange((newState, _prevState) => {
+      if (newState === "online") {
+        this.onReconnected();
+      }
+    });
   }
   /**
    * Set the OpenClaw API reference (for emitting events).
@@ -9348,6 +9628,17 @@ var EncryptedChatChannel = class {
   setAPI(api) {
     this.api = api;
   }
+  /**
+   * Called when the WebSocket connection is re-established.
+   * Flushes all queued offline messages.
+   */
+  onReconnected() {
+    const pendingCount = this.store.getOfflineMessageCount();
+    if (pendingCount > 0) {
+      this.logger.info(`[Chat] Back online \u2014 flushing ${pendingCount} queued offline messages`);
+      this.flushOfflineMessages();
+    }
+  }
   /**
    * Handle an incoming encrypted message from a peer.
    *
@@ -9382,7 +9673,7 @@ var EncryptedChatChannel = class {
       });
     }
     friend.lastMessageAt = /* @__PURE__ */ new Date();
-    this.store.save();
+    this.store.markDirty();
   }
   /**
    * Send an encrypted message to a peer.
@@ -9390,7 +9681,9 @@ var EncryptedChatChannel = class {
    * Encrypts with the session key, signs with the Ed25519 identity key,
    * and sends via P2P if available, falling back to WebSocket relay.
    *
-   * @returns true if the message was sent successfully
+   * When offline, the message is queued for later delivery.
+   *
+   * @returns true if the message was sent or queued successfully
    */
   send(toId, plaintext) {
     const friend = this.store.getFriend(toId);
@@ -9408,14 +9701,26 @@ var EncryptedChatChannel = class {
     }
     const wireData = (0, import_crypto6.encryptMessage)(plaintext, sessionKey, this.store.identityKeys.secretKey, this.store.identityKeys.publicKey);
     const buf = Buffer.from(wireData);
-    if (this.p2pManager.isConnected(toId) && this.p2pManager.send(toId, buf)) {
-      this.logger.debug("[Chat] Sent message via P2P to " + toId);
+    const encodedData = (0, import_crypto6.encodeBase64)(wireData);
+    const isOnline = this.serverClient.isConnected();
+    if (isOnline) {
+      if (this.p2pManager.isConnected(toId) && this.p2pManager.send(toId, buf)) {
+        this.logger.debug("[Chat] Sent message via P2P to " + toId);
+      } else {
+        const sent = this.serverClient.sendRelayMessage(toId, {
+          channel: "encrypted-chat",
+          data: encodedData
+        });
+        if (!sent) {
+          this.logger.warn("[Chat] WebSocket send failed \u2014 queuing message for offline delivery");
+          this.store.enqueueOfflineMessage(toId, encodedData);
+        } else {
+          this.logger.debug("[Chat] Sent message via relay to " + toId);
+        }
+      }
     } else {
-      this.serverClient.sendRelayMessage(toId, {
-        channel: "encrypted-chat",
-        data: (0, import_crypto6.encodeBase64)(wireData)
-      });
-      this.logger.debug("[Chat] Sent message via relay to " + toId);
+      this.logger.info("[Chat] Offline \u2014 message queued for delivery to " + toId);
+      this.store.enqueueOfflineMessage(toId, encodedData);
     }
     const session = this.store.getSession(toId);
     if (session) {
@@ -9423,10 +9728,71 @@ var EncryptedChatChannel = class {
       if (session.messageCount % 100 === 0 || Date.now() - session.createdAt.getTime() > 36e5) {
         this.handshakeManager.rotateSessionKey(toId);
       }
-      this.store.save();
+      this.store.markDirty();
     }
     return true;
   }
+  /**
+   * Flush all queued offline messages.
+   * Called automatically when connection is re-established.
+   */
+  flushOfflineMessages() {
+    if (this.flushingOffline)
+      return;
+    this.flushingOffline = true;
+    const flushNext = () => {
+      const msg = this.store.dequeueOfflineMessage();
+      if (!msg) {
+        this.flushingOffline = false;
+        const remaining = this.store.getOfflineMessageCount();
+        if (remaining === 0) {
+          this.logger.info("[Chat] All offline messages flushed");
+        }
+        return;
+      }
+      if (!this.serverClient.isConnected()) {
+        this.store.offlineMessages.unshift(msg);
+        this.flushingOffline = false;
+        this.logger.warn("[Chat] Connection lost during offline flush");
+        return;
+      }
+      const friend = this.store.getFriend(msg.targetId);
+      let sessionKey = this.handshakeManager.getSessionKey(msg.targetId);
+      if (!sessionKey && friend?.sessionKey) {
+        sessionKey = friend.sessionKey;
+      }
+      if (!sessionKey) {
+        this.logger.warn("[Chat] Skipping offline message to " + msg.targetId + " (no session key)");
+        this.store.markDirty();
+        setImmediate(flushNext);
+        return;
+      }
+      const sent = this.serverClient.sendRelayMessage(msg.targetId, {
+        channel: "encrypted-chat",
+        data: msg.encryptedData
+      });
+      if (sent) {
+        this.logger.debug("[Chat] Flushed offline message to " + msg.targetId);
+      } else {
+        this.logger.warn("[Chat] Failed to flush offline message to " + msg.targetId);
+        msg.retryCount++;
+        if (msg.retryCount < msg.maxRetries) {
+          this.store.offlineMessages.unshift(msg);
+        } else {
+          this.logger.error("[Chat] Dropped offline message to " + msg.targetId + " (max retries exceeded)");
+        }
+      }
+      this.store.markDirty();
+      setImmediate(flushNext);
+    };
+    flushNext();
+  }
+  /**
+   * Get the count of pending offline messages.
+   */
+  getPendingOfflineCount() {
+    return this.store.getOfflineMessageCount();
+  }
   /**
    * Handle an incoming file chunk from a peer.
    *
@@ -9511,6 +9877,7 @@ var EncryptedChatChannel = class {
    */
   cleanup() {
     this.fileChunkBuffers.clear();
+    this.flushingOffline = false;
   }
 };
 
@@ -9759,7 +10126,7 @@ var BeforeToolCallHook = class {
 };
 
 // dist/hooks/messageSending.js
-var import_crypto7 = __toESM(require_crypto(), 1);
+var import_crypto7 = __toESM(require_dist(), 1);
 var MessageSendingHook = class {
   constructor(store, handshakeManager, logger) {
     this.store = store;
@@ -10090,6 +10457,26 @@ tbody tr:hover { background: var(--bg3); }
 .toggle-label input:checked + .toggle-slider { background: var(--accent); }
 .toggle-label input:checked + .toggle-slider::after { left: 21px; background: #fff; }
 
+/* Offline banner */
+.offline-banner {
+  background: linear-gradient(90deg, #7f1d1d, #991b1b);
+  color: #fca5a5;
+  padding: 10px 24px;
+  font-size: 13px;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  animation: fadeIn .2s ease-out;
+}
+.offline-banner .offline-icon {
+  font-size: 16px;
+  animation: pulse 2s infinite;
+}
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.4; }
+}
+
 /* Responsive */
 @media (max-width: 768px) {
   .sidebar { position: fixed; left: -260px; z-index: 50; height: 100vh; transition: left var(--transition); }
@@ -10106,6 +10493,43 @@ const API = '/api';
 let currentPage = 'dashboard';
 let refreshTimer = null;
 
+// \u2500\u2500 Offline detection \u2500\u2500
+let isOffline = false;
+let offlineBannerEl = null;
+
+function updateOnlineStatus() {
+  const wasOffline = isOffline;
+  isOffline = !navigator.onLine;
+  if (isOffline && !wasOffline) {
+    showOfflineBanner();
+  } else if (!isOffline && wasOffline) {
+    hideOfflineBanner();
+    // Reload current page on reconnection
+    loadPage(currentPage);
+  }
+}
+
+function showOfflineBanner() {
+  if (offlineBannerEl) return;
+  offlineBannerEl = document.createElement('div');
+  offlineBannerEl.className = 'offline-banner';
+  offlineBannerEl.innerHTML = '<span class="offline-icon">\u{1F50C}</span><span>You are offline. Some features may be limited. Data is loaded from local cache.</span>';
+  const mainContent = document.querySelector('.main');
+  if (mainContent) {
+    mainContent.insertBefore(offlineBannerEl, mainContent.firstChild);
+  }
+}
+
+function hideOfflineBanner() {
+  if (offlineBannerEl) {
+    offlineBannerEl.remove();
+    offlineBannerEl = null;
+  }
+}
+
+window.addEventListener('online', updateOnlineStatus);
+window.addEventListener('offline', updateOnlineStatus);
+
 // \u2500\u2500 jQuery-style helpers \u2500\u2500
 const $ = (sel, ctx) => (ctx || document).querySelector(sel);
 const $$ = (sel, ctx) => Array.from((ctx || document).querySelectorAll(sel));
@@ -10192,7 +10616,11 @@ function loadPage(page) {
 async function loadDashboard() {
   const el = $('#dashboard-content');
   html(el, '<div class="loading-mask"><div class="spinner"></div>Loading dashboard...</div>');
-  const [status, friends, identity, mgmtUrl] = await Promise.all([api('/status'), api('/friends'), api('/identity'), api('/mgmt-url')]);
+  const results = await Promise.allSettled([api('/status'), api('/friends'), api('/identity'), api('/mgmt-url')]);
+  const status = results[0].status === 'fulfilled' ? results[0].value : { error: results[0].reason?.message || 'Failed' };
+  const friends = results[1].status === 'fulfilled' ? results[1].value : { friends: [], error: true };
+  const identity = results[2].status === 'fulfilled' ? results[2].value : { agentId: '\u2014', publicKeyFingerprint: '\u2014', serverUrl: '\u2014', connected: false };
+  const mgmtUrl = results[3].status === 'fulfilled' ? results[3].value : { mgmtUrl: window.location.origin };
   if (status.error) { html(el, '<div class="empty"><div class="icon">\u26A0\uFE0F</div><p>Failed to connect to AICQ plugin</p></div>'); return; }
   const connCls = status.connected ? 'dot-ok' : 'dot-err';
   const connText = status.connected ? 'Connected' : 'Disconnected';
@@ -10442,7 +10870,17 @@ let friendsFilter = 'all';
 async function loadFriends() {
   const el = $('#friends-content');
   html(el, '<div class="loading-mask"><div class="spinner"></div>Loading friends...</div>');
-  const [friends, requests, sessions] = await Promise.all([api('/friends'), api('/friends/requests'), api('/sessions')]);
+  const results = await Promise.allSettled([api('/friends'), api('/friends/requests'), api('/sessions')]);
+  const friends = results[0].status === 'fulfilled' ? results[0].value : { friends: [] };
+  const requests = results[1].status === 'fulfilled' ? results[1].value : { requests: [] };
+  const sessions = results[2].status === 'fulfilled' ? results[2].value : { sessions: [] };
+
+  // Show offline banner if friends data came from cache
+  if (friends.offline || friends.error) {
+    showOfflineBanner();
+  } else {
+    hideOfflineBanner();
+  }
 
   // Sub-tabs
   const friendCount = (friends.friends || []).length;
@@ -10494,7 +10932,7 @@ function renderFriendsList(friends) {
         <button class="filter-btn \${friendsFilter==='human'?'active':''}" onclick="friendsFilter='human';filterFriendTable()">Human</button>
       </div>
       <span style="flex:1"></span>
-      <button class="btn btn-sm btn-primary" onclick="showAddFriendModal()">\u2795 Add Friend</button>
+      <button class="btn btn-sm btn-primary" onclick="showAddFriendModal()" \${isOffline ? 'disabled title="Unavailable while offline"' : ''}>\u2795 Add Friend</button>
       <button class="btn btn-sm btn-default" onclick="loadFriends()">\u{1F504}</button>
     </div>
     <div class="card" style="padding:0;overflow:hidden">
@@ -11387,6 +11825,7 @@ document.addEventListener('DOMContentLoaded', () => {
 
   // Auto-refresh status every 30s
   refreshTimer = setInterval(() => {
+    updateOnlineStatus();
     if (currentPage === 'dashboard') loadDashboard();
     // Update status dot
     api('/status').then(s => {
@@ -11395,6 +11834,8 @@ document.addEventListener('DOMContentLoaded', () => {
         if (dot) { dot.className = 'dot ' + (s.connected ? 'dot-ok' : 'dot-err'); }
         const txt = $('#header-status');
         if (txt) txt.textContent = s.connected ? 'Connected' : 'Disconnected';
+        // Auto-remove offline banner when server reconnects
+        if (s.connected) hideOfflineBanner();
       }
     });
   }, 30000);
@@ -11964,8 +12405,16 @@ function createManagementHandler(ctx) {
           });
           return json(res, { friends });
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return json(res, { error: msg }, 500);
+          const friends = Array.from(store.friends.values()).map((f) => ({
+            id: f.id,
+            publicKeyFingerprint: f.publicKeyFingerprint || "",
+            permissions: f.permissions || [],
+            addedAt: f.addedAt?.toISOString() || null,
+            lastMessageAt: f.lastMessageAt?.toISOString() || null,
+            friendType: f.friendType || null,
+            aiName: f.aiName || null
+          }));
+          return json(res, { friends, offline: true });
         }
       }
       if (apiPath === "/friends" && method === "POST") {
@@ -12064,8 +12513,13 @@ function createManagementHandler(ctx) {
           const data = await resp.json();
           return json(res, { requests: data.requests || [] });
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return json(res, { error: msg }, 500);
+          const requests = store.pendingRequests.map((p) => ({
+            id: p.requesterId,
+            fromId: p.requesterId,
+            status: "pending",
+            createdAt: p.timestamp.toISOString()
+          }));
+          return json(res, { requests, offline: true });
         }
       }
       if (apiPath.match(/^\/friends\/requests\/[^/]+\/accept$/) && method === "POST") {
@@ -12745,6 +13199,9 @@ var plugin = definePluginEntry({
     } catch (e) {
       logger.warn("[Init] WS connect failed: " + (e instanceof Error ? e.message : e));
     }
+    serverClient.onConnectionStateChange((newState, prevState) => {
+      logger.info("[Init] Connection state changed: " + prevState + " \u2192 " + newState);
+    });
     serverClient.onWsMessage("relay", (data) => {
       const msg = data;
       if (!msg?.payload)
@@ -12758,14 +13215,9 @@ var plugin = definePluginEntry({
       }
     });
     setInterval(() => {
-      if (!serverClient.isConnected()) {
-        try {
-          serverClient.connectWebSocket();
-        } catch (_e) {
-        }
-      }
+      store.cleanupExpiredTempNumbers();
+      store.cleanupExpiredOfflineMessages();
     }, 6e4);
-    setInterval(() => store.cleanupExpiredTempNumbers(), 6e4);
     api.registerTool({
       label: "AICQ Friend Manager",
       name: "chat-friend",
@@ -12910,10 +13362,12 @@ var plugin = definePluginEntry({
         try {
           return {
             connected: serverClient.isConnected(),
+            connectionState: serverClient.getConnectionState(),
             agentId: aicqAgentId,
             fingerprint: identityService.getPublicKeyFingerprint(),
             friendCount: store.getFriendCount(),
             sessionCount: store.sessions.size,
+            offlineMessageCount: store.getOfflineMessageCount(),
             serverUrl
           };
         } catch (err) {

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "aicq-chat",
   "name": "AICQ Encrypted Chat",
-  "version": "1.2.0",
-  "description": "End-to-end encrypted chat plugin supporting AI-AI, Human-AI communication with P2P messaging via Noise-XK handshake, Ed25519/X25519/AES-256-GCM encryption",
+  "version": "1.3.0",
+  "description": "End-to-end encrypted chat plugin supporting AI-AI, Human-AI communication with P2P messaging, offline queue, and Noise-XK handshake (Ed25519/X25519/AES-256-GCM)",
   "enabledByDefault": false,
   "channels": ["encrypted-chat"],
   "tools": ["chat-friend", "chat-send", "chat-export-key"],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aicq-openclaw-plugin",
-  "version": "1.2.0",
-  "description": "AICQ OpenClaw plugin - end-to-end encrypted P2P chat for AI agents",
+  "version": "1.3.0",
+  "description": "AICQ OpenClaw plugin - end-to-end encrypted P2P chat for AI agents with offline queue support",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -30,24 +30,26 @@
     "openclaw": ">=2026.4.2"
   },
   "peerDependenciesMeta": {
-    "openclaw": { "optional": true }
+    "openclaw": {
+      "optional": true
+    }
   },
   "dependencies": {
     "ws": "^8.16.0"
   },
   "devDependencies": {
     "@aicq/crypto": "file:../shared/crypto",
-    "openclaw": "^2026.4.2",
-    "esbuild": "^0.25.0",
-    "typescript": "^5.3.3",
     "@types/node": "^20.10.0",
-    "@types/ws": "^8.5.10",
-    "@types/uuid": "^9.0.7",
     "@types/qrcode": "^1.5.5",
-    "ts-node-dev": "^2.0.0",
-    "uuid": "^9.0.0",
+    "@types/uuid": "^9.0.7",
+    "@types/ws": "^8.5.10",
+    "dotenv": "^16.3.1",
+    "esbuild": "^0.25.0",
+    "openclaw": "^2026.4.2",
     "qrcode": "^1.5.3",
-    "dotenv": "^16.3.1"
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3",
+    "uuid": "^9.0.0"
   },
   "keywords": [
     "openclaw",