openclaw-quiubo 2.6.13 → 2.6.16

package/dist/index.js

@@ -8952,7 +8952,7 @@ function getQuiuboRuntime() {
 }
 
 // src/channel.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { basename } from "path";
 
 // src/api.ts
@@ -9228,6 +9228,8 @@ var QuiuboApiClient = class {
 
 // src/realtime-gateway.ts
 var import_pusher_js = __toESM(require_pusher(), 1);
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
 import * as nc from "node:crypto";
@@ -12448,6 +12450,7 @@ function signChallenge(challengeBase64, signingPrivateKey) {
 }
 
 // src/realtime-gateway.ts
+var CURSORS_DIR = join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".openclaw", "cron");
 var consoleLogger = {
   debug: (...args) => console.debug("[Quiubo]", ...args),
   info: (...args) => console.log("[Quiubo]", ...args),
@@ -12470,8 +12473,16 @@ var RealtimeGateway = class {
   pollTimer = null;
   polling = false;
   cursors = /* @__PURE__ */ new Map();
-  /** Message IDs already dispatched (Pusher + poll dedup). Capped to prevent unbounded growth. */
+  /** Message IDs already dispatched (Pusher + poll dedup). FIFO-capped to prevent unbounded growth. */
   dispatched = /* @__PURE__ */ new Set();
+  dispatchedOrder = [];
+  DISPATCHED_MAX = 500;
+  DISPATCHED_EVICT = 100;
+  // Backoff state for poll failures
+  consecutivePollErrors = 0;
+  POLL_CONCURRENCY = 5;
+  MAX_BACKOFF_MS = 6e4;
+  // cap at 60s
   // Cached directory group IDs from listAgentGroups (refreshed every 60s)
   agentGroupsCache = null;
   AGENT_GROUPS_TTL = 6e4;
@@ -12482,6 +12493,11 @@ var RealtimeGateway = class {
   // Heartbeat state
   agentId;
   heartbeatTimer = null;
+  // Cursor save debounce (avoids disk thrash on rapid Pusher events)
+  cursorSaveTimer = null;
+  cursorsFile;
+  // Pusher connection timeout (cancelled on stop to prevent stale firing)
+  pusherConnectTimeout = null;
   // E2EE state
   keyManager;
   e2eeGrantedGroups;
@@ -12492,6 +12508,7 @@ var RealtimeGateway = class {
   constructor(opts) {
     this.client = opts.client;
     this.botIdentityId = opts.botIdentityId;
+    this.cursorsFile = join(CURSORS_DIR, `quiubo-cursors-${opts.accountId}.json`);
     this.pusherConfig = opts.pusher ?? null;
     this.pollIntervalMs = opts.pollIntervalMs ?? 5e3;
     this.onMessage = opts.onMessage;
@@ -12504,15 +12521,64 @@ var RealtimeGateway = class {
     this.agentName = opts.agentName ?? null;
     this.agentDisplayName = opts.agentDisplayName ?? null;
   }
+  /**
+   * Load persisted cursors from disk. Called once before start().
+   * Non-fatal: if file doesn't exist or is corrupt, starts fresh.
+   */
+  async loadCursors() {
+    try {
+      const raw = await readFile(this.cursorsFile, "utf-8");
+      const data = JSON.parse(raw);
+      let count = 0;
+      for (const [groupId, cursor] of Object.entries(data)) {
+        if (typeof cursor === "string" && cursor) {
+          this.cursors.set(groupId, cursor);
+          count++;
+        }
+      }
+      this.log.info?.(`Loaded ${count} persisted cursor(s) from disk`);
+    } catch {
+      this.log.debug?.("No persisted cursors found (first run or corrupt file)");
+    }
+  }
+  /**
+   * Save cursors to disk. Called after each poll cycle and on cursor updates.
+   * Non-fatal: logs warning on failure.
+   */
+  async saveCursors() {
+    try {
+      const data = {};
+      for (const [groupId, cursor] of this.cursors) {
+        data[groupId] = cursor;
+      }
+      await mkdir(CURSORS_DIR, { recursive: true });
+      await writeFile(this.cursorsFile, JSON.stringify(data, null, 2), "utf-8");
+    } catch (err) {
+      this.log.warn?.(`Failed to persist cursors: ${err}`);
+    }
+  }
+  /** Debounced cursor save — batches rapid Pusher updates into one write per 2s */
+  debouncedSaveCursors() {
+    if (this.cursorSaveTimer) return;
+    this.cursorSaveTimer = setTimeout(() => {
+      this.cursorSaveTimer = null;
+      this.saveCursors();
+    }, 2e3);
+  }
   /** Set bot config for a group */
   setBotConfig(groupId, config) {
     this.botConfigCache.set(groupId, config);
   }
-  /** Track a dispatched message ID (capped at 500 to prevent unbounded growth) */
+  /** Track a dispatched message ID (FIFO-capped to prevent unbounded growth) */
   markDispatched(messageId) {
+    if (this.dispatched.has(messageId)) return;
     this.dispatched.add(messageId);
-    if (this.dispatched.size > 500) {
-      this.dispatched.clear();
+    this.dispatchedOrder.push(messageId);
+    if (this.dispatched.size > this.DISPATCHED_MAX) {
+      const toEvict = this.dispatchedOrder.splice(0, this.DISPATCHED_EVICT);
+      for (const id of toEvict) {
+        this.dispatched.delete(id);
+      }
     }
   }
   /** Get bot config for a group (for outbound scope checks) */
@@ -12628,6 +12694,11 @@ var RealtimeGateway = class {
     this.stopHeartbeat();
     this.stopPolling();
     this.stopPusher();
+    if (this.cursorSaveTimer) {
+      clearTimeout(this.cursorSaveTimer);
+      this.cursorSaveTimer = null;
+    }
+    this.saveCursors();
     this.log.info?.("Gateway stopped");
   }
   // ── Heartbeat ────────────────────────────────────────────────────
@@ -12703,7 +12774,8 @@ var RealtimeGateway = class {
       log.error?.(`Failed to subscribe to ${channelName}:`, error);
       if (!this.stopped) this.startPolling();
     });
-    setTimeout(() => {
+    this.pusherConnectTimeout = setTimeout(() => {
+      this.pusherConnectTimeout = null;
       if (!this.pusherConnected && !this.stopped) {
         log.warn?.("Pusher connection timeout (15s) \u2014 starting polling as fallback");
         this.startPolling();
@@ -12791,7 +12863,9 @@ var RealtimeGateway = class {
       }).then((shouldProcess) => {
         if (!shouldProcess) return;
         if (data.plaintext) {
+          if (this.dispatched.has(data.messageId)) return;
           this.cursors.set(data.groupId, data.messageId);
+          this.debouncedSaveCursors();
           this.markDispatched(data.messageId);
           Promise.resolve(this.onMessage({
             messageId: data.messageId,
@@ -12816,10 +12890,12 @@ var RealtimeGateway = class {
                 return;
               }
               log.info?.(`[e2ee:pusher] group=${data.groupId} got epoch key, decrypting...`);
+              if (this.dispatched.has(data.messageId)) return;
               try {
                 const plaintext = decryptGroupMessage(data.ciphertext, cached.key);
                 log.info?.(`[e2ee:pusher] group=${data.groupId} decrypted OK: ${plaintext?.length} chars \u2014 routing to onMessage`);
                 this.cursors.set(data.groupId, data.messageId);
+                this.debouncedSaveCursors();
                 this.markDispatched(data.messageId);
                 return Promise.resolve(this.onMessage({
                   messageId: data.messageId,
@@ -12857,10 +12933,14 @@ var RealtimeGateway = class {
    */
   async fetchAndRouteMessage(groupId, messageId) {
     try {
+      if (!this.cursors.has(groupId)) {
+        await this.seekToLatest(groupId);
+      }
       const cursor = this.cursors.get(groupId);
       const { messages } = await this.client.listMessages(groupId, cursor, 100);
       if (messages.length > 0) {
         this.cursors.set(groupId, messages[messages.length - 1].id);
+        this.debouncedSaveCursors();
       }
       const msg = messages.find((m) => m.id === messageId);
       if (!msg) {
@@ -12886,6 +12966,10 @@ var RealtimeGateway = class {
     }
   }
   stopPusher() {
+    if (this.pusherConnectTimeout) {
+      clearTimeout(this.pusherConnectTimeout);
+      this.pusherConnectTimeout = null;
+    }
     if (this.pusherClient) {
       this.pusherClient.disconnect();
       this.pusherClient = null;
@@ -12896,12 +12980,27 @@ var RealtimeGateway = class {
   startPolling() {
     if (this.pollTimer) return;
     this.log.info?.(`Polling started: interval=${this.pollIntervalMs}ms`);
-    this.poll();
-    this.pollTimer = setInterval(() => this.poll(), this.pollIntervalMs);
+    this.schedulePoll();
+  }
+  /** Schedule the next poll with backoff-aware delay */
+  schedulePoll() {
+    if (this.stopped || this.pollTimer) return;
+    const delay = this.getBackoffDelay();
+    this.pollTimer = setTimeout(async () => {
+      this.pollTimer = null;
+      await this.poll();
+      if (!this.stopped) this.schedulePoll();
+    }, delay);
+  }
+  /** Get poll delay: base interval * 2^errors, capped at MAX_BACKOFF_MS */
+  getBackoffDelay() {
+    if (this.consecutivePollErrors === 0) return this.pollIntervalMs;
+    const backoff = this.pollIntervalMs * Math.pow(2, Math.min(this.consecutivePollErrors, 6));
+    return Math.min(backoff, this.MAX_BACKOFF_MS);
   }
   stopPolling() {
     if (this.pollTimer) {
-      clearInterval(this.pollTimer);
+      clearTimeout(this.pollTimer);
       this.pollTimer = null;
     }
   }
@@ -12976,23 +13075,51 @@ var RealtimeGateway = class {
       const directoryIds = await this.getDirectoryGroupIds();
       for (const gid of directoryIds) groupIds.add(gid);
       this.log.debug?.(`Poll cycle: partner=${groups.length} directory=${directoryIds.size} total=${groupIds.size}`);
-      await Promise.allSettled(
-        [...groupIds].map((gid) => this.pollGroup(gid))
-      );
+      const allGroupIds = [...groupIds];
+      for (let i = 0; i < allGroupIds.length; i += this.POLL_CONCURRENCY) {
+        const batch = allGroupIds.slice(i, i + this.POLL_CONCURRENCY);
+        await Promise.allSettled(batch.map((gid) => this.pollGroup(gid)));
+      }
+      await this.saveCursors();
+      this.consecutivePollErrors = 0;
     } catch (error) {
-      this.log.error?.("Poll cycle failed:", error);
+      this.consecutivePollErrors++;
+      const nextDelay = this.getBackoffDelay();
+      this.log.error?.(`Poll cycle failed (${this.consecutivePollErrors} consecutive, next in ${nextDelay}ms):`, error);
     } finally {
       this.polling = false;
     }
   }
+  /**
+   * Seek cursor to the latest message without processing anything.
+   * Called on cold start (no cursor for a group) to avoid replaying history.
+   * Paginates forward until there are no more messages.
+   */
+  async seekToLatest(groupId) {
+    let cursor;
+    let hasMore = true;
+    while (hasMore) {
+      const result = await this.client.listMessages(groupId, cursor, 100);
+      if (result.messages.length === 0) break;
+      cursor = result.messages[result.messages.length - 1].id;
+      hasMore = result.hasMore;
+    }
+    if (cursor) {
+      this.cursors.set(groupId, cursor);
+      this.log.info?.(`Seeked to latest in group ${groupId}: cursor=${cursor}`);
+    }
+  }
   async pollGroup(groupId) {
     try {
       const cursor = this.cursors.get(groupId);
+      if (!cursor) {
+        await this.seekToLatest(groupId);
+        return;
+      }
       const { messages } = await this.client.listMessages(groupId, cursor);
       if (messages.length === 0) return;
       const lastMessage = messages[messages.length - 1];
       this.cursors.set(groupId, lastMessage.id);
-      if (!cursor) return;
       for (const msg of messages) {
         if (msg.senderIdentityId === this.botIdentityId) continue;
         let plaintext = msg.plaintext;
@@ -13147,7 +13274,7 @@ async function readMdAttachments(mediaUrls, source, log, accountId) {
     const filename = basename(url);
     if (!filename.endsWith(".md")) continue;
     try {
-      const content = await readFile(url, "utf-8");
+      const content = await readFile2(url, "utf-8");
       if (content.length > 1024 * 1024) {
         log?.warn?.(`[${accountId}] Quiubo: skipping ${filename} \u2014 exceeds 1MB`);
         continue;
@@ -13554,6 +13681,12 @@ var quiuboPlugin = {
         log?.info?.(`[${accountId}] Quiubo: disabled, skipping`);
         return;
       }
+      const existingGateway = gateways.get(accountId);
+      if (existingGateway) {
+        log?.warn?.(`[${accountId}] Quiubo: stopping existing gateway before restart`);
+        existingGateway.stop();
+        gateways.delete(accountId);
+      }
       const apiUrl = quiuboConfig.apiUrl ?? DEFAULT_API_URL;
       const { apiKey, botIdentityId, pollIntervalMs } = quiuboConfig;
       const runtime2 = getQuiuboRuntime();
@@ -13696,6 +13829,7 @@ var quiuboPlugin = {
       const gateway = new RealtimeGateway({
         client,
         botIdentityId,
+        accountId,
         pusher: pusherConfig,
         pollIntervalMs: pollIntervalMs ?? 5e3,
         log: gatewayLog,
@@ -13880,6 +14014,7 @@ var quiuboPlugin = {
       } catch (err) {
         log?.warn?.(`[${accountId}] Quiubo: failed to hydrate bot config (non-fatal): ${err}`);
       }
+      await gateway.loadCursors();
       await gateway.start();
       log?.info?.(`[${accountId}] Quiubo: gateway started`);
       return new Promise((resolve) => {
@@ -13916,12 +14051,12 @@ function resolveOutboundGroupId(ctx) {
 }
 async function getActivityData(runtime2, log, agentId) {
   try {
-    const { readFile: readFile2 } = await import("node:fs/promises");
-    const { join } = await import("node:path");
+    const { readFile: readFile3 } = await import("node:fs/promises");
+    const { join: join2 } = await import("node:path");
     const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const cronPath = join(homeDir, ".openclaw", "cron", "jobs.json");
+    const cronPath = join2(homeDir, ".openclaw", "cron", "jobs.json");
     log?.info?.(`getActivityData: reading ${cronPath} (agentId=${agentId})`);
-    const raw = await readFile2(cronPath, "utf-8");
+    const raw = await readFile3(cronPath, "utf-8");
     const parsed = JSON.parse(raw);
     const jobs = parsed?.jobs ?? [];
     const items = jobs.filter((j) => j.enabled !== false && (!agentId || j.agentId === agentId)).map((job) => ({