aicq-openclaw-plugin 1.2.1 → 1.3.0

package/dist/index.js

@@ -7212,9 +7212,9 @@ var require_nacl_util = __commonJS({
   }
 });
 
-// node_modules/@aicq/crypto/dist/nacl.js
+// ../shared/crypto/dist/nacl.js
 var require_nacl = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/keygen.js
+// ../shared/crypto/dist/keygen.js
 var require_keygen = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/signer.js
+// ../shared/crypto/dist/signer.js
 var require_signer = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/keyExchange.js
+// ../shared/crypto/dist/keyExchange.js
 var require_keyExchange = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/cipher.js
+// ../shared/crypto/dist/cipher.js
 var require_cipher = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/message.js
+// ../shared/crypto/dist/message.js
 var require_message = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/password.js
+// ../shared/crypto/dist/password.js
 var require_password = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/handshake.js
+// ../shared/crypto/dist/handshake.js
 var require_handshake = __commonJS({
-  "node_modules/@aicq/crypto/dist/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/dist/index.js
+// ../shared/crypto/dist/index.js
 var require_dist = __commonJS({
-  "node_modules/@aicq/crypto/dist/index.js"(exports) {
+  "../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.
    */
@@ -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,15 +8951,6 @@ 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
@@ -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;
   }
 };
 
@@ -12832,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)
@@ -12845,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",
@@ -12997,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.1",
-  "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": [