happy-imou-cloud 2.1.10 → 2.1.11

package/dist/{BaseReasoningProcessor-DbV-vhFy.mjs → BaseReasoningProcessor-BrQM8i44.mjs}

@@ -1,5 +1,5 @@
-import { a as createSessionMetadata, p as publishSessionRegistration } from './index-C_MTvw5p.mjs';
-import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-Dp5_DJo0.mjs';
+import { a as createSessionMetadata, p as publishSessionRegistration } from './index-Drrrz-Ot.mjs';
+import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-CEUrdZHY.mjs';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
 

package/dist/{BaseReasoningProcessor-8GjgD9Nk.cjs → BaseReasoningProcessor-G3hno_kB.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index = require('./index-Dz1Zo1-d.cjs');
-var api = require('./api-8p1d7M3Z.cjs');
+var index = require('./index-AwnMQcsU.cjs');
+var api = require('./api-CtQFwLUJ.cjs');
 var node_events = require('node:events');
 var node_crypto = require('node:crypto');
 

package/dist/{ProviderSelectionHandler-DWeq9rG2.cjs → ProviderSelectionHandler-B0HZZgMG.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var api = require('./api-8p1d7M3Z.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-DL07DW1o.cjs');
+var api = require('./api-CtQFwLUJ.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-DKWTYJ3L.cjs');
 
 async function runModeLoop(opts) {
   let currentMode = opts.startingMode;

package/dist/{ProviderSelectionHandler-DXgu2zND.mjs → ProviderSelectionHandler-bkna8Dc0.mjs}

@@ -1,5 +1,5 @@
-import { l as logger } from './api-Dp5_DJo0.mjs';
-import { g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, a as INTERACTION_TIMED_OUT_ERROR } from './registerKillSessionHandler-Bqd1W5ZT.mjs';
+import { l as logger } from './api-CEUrdZHY.mjs';
+import { g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, a as INTERACTION_TIMED_OUT_ERROR } from './registerKillSessionHandler-DPh8LfUR.mjs';
 
 async function runModeLoop(opts) {
   let currentMode = opts.startingMode;

package/dist/{api-Dp5_DJo0.mjs → api-CEUrdZHY.mjs}

@@ -16,7 +16,7 @@ import { spawn } from 'node:child_process';
 import { Expo } from 'expo-server-sdk';
 
 var name = "happy-imou-cloud";
-var version = "2.1.10";
+var version = "2.1.11";
 var description = "hicloud - Imou 企业定制版。关键是 happy！移动端远程 AI 编程工具，支持 Claude Code、Codex 和 Gemini CLI";
 var author = "long.zhu";
 var license = "MIT";
@@ -431,7 +431,7 @@ async function listDaemonLogFiles(limit = 50) {
       return { file, path: fullPath, modified: stats.mtime };
     }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
     try {
-      const { readDaemonState } = await import('./persistence-Ds1cKgQ_.mjs');
+      const { readDaemonState } = await import('./persistence-tRrZOs0P.mjs');
       const state = await readDaemonState();
       if (!state) {
         return logs;
@@ -1737,6 +1737,8 @@ const MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES = 512 * 1024;
 const PROTOCOL_V3_INITIAL_SNAPSHOT_LIMIT = 150;
 const PROTOCOL_V3_CHANGES_PAGE_LIMIT = 200;
 const PROTOCOL_V3_CAPABILITIES_WAIT_MS = 250;
+const COMMITTED_SESSION_WRITE_ACK_TIMEOUT_MS = 5e3;
+const RELIABLE_SESSION_MESSAGE_RETRY_DELAY_MS = 250;
 class ApiSessionClient extends EventEmitter {
   credentials;
   sessionId;
@@ -1752,8 +1754,12 @@ class ApiSessionClient extends EventEmitter {
   metadataLock = new AsyncLock();
   encryptionKey;
   encryptionVariant;
-  pendingReliableSessionMessages = [];
-  pendingReliableSessionMessageBytes = 0;
+  queuedReliableSessionMessages = [];
+  queuedReliableSessionMessageBytes = 0;
+  inFlightReliableSessionMessage = null;
+  reliableSessionMessageFlushInProgress = false;
+  reliableSessionMessageDrainWaiters = [];
+  reliableSessionMessageRetryTimer = null;
   reconnectAfterServerDisconnectTimer = null;
   lastSocketServerError = null;
   protocolV3SessionSync = null;
@@ -1765,6 +1771,7 @@ class ApiSessionClient extends EventEmitter {
   protocolV3Descriptor = null;
   protocolV3SocketCapabilities = null;
   protocolV3SessionSyncWaitTimer = null;
+  committedSessionWriteAckMode;
   constructor(credentials, session) {
     super();
     this.credentials = credentials;
@@ -1776,6 +1783,7 @@ class ApiSessionClient extends EventEmitter {
     this.encryptionKey = session.encryptionKey;
     this.encryptionVariant = session.encryptionVariant;
     this.lastChangeSeq = session.seq;
+    this.committedSessionWriteAckMode = this.credentials.signing ? "unknown" : "unsupported";
     this.rpcHandlerManager = new RpcHandlerManager({
       scopePrefix: this.sessionId,
       encryptionKey: this.encryptionKey,
@@ -1808,11 +1816,13 @@ class ApiSessionClient extends EventEmitter {
     this.socket.on("connect", () => {
       logger.debug("Socket connected successfully");
       this.clearReconnectAfterServerDisconnectTimer();
+      this.clearReliableSessionMessageRetryTimer();
       this.lastSocketServerError = null;
       this.rpcHandlerManager.onSocketConnect(this.socket);
-      this.flushReliableSessionMessages();
       this.protocolV3Descriptor = null;
       this.protocolV3SocketCapabilities = null;
+      this.committedSessionWriteAckMode = this.credentials.signing ? "unknown" : "unsupported";
+      this.flushReliableSessionMessages();
       this.scheduleProtocolV3SessionSync();
     });
     this.socket.on("rpc-request", async (data, callback) => {
@@ -1820,8 +1830,10 @@ class ApiSessionClient extends EventEmitter {
     });
     this.socket.on("disconnect", (reason) => {
       logger.debug("[API] Socket disconnected:", reason);
+      this.clearReliableSessionMessageRetryTimer();
       this.rpcHandlerManager.onSocketDisconnect();
       this.invalidateProtocolV3SessionSync();
+      this.resolveReliableSessionMessageDrainWaitersIfIdle();
       this.retryAfterServerDisconnect(reason);
     });
     this.socket.on("connect_error", (error) => {
@@ -1849,8 +1861,10 @@ class ApiSessionClient extends EventEmitter {
           connectionType: data.connectionType,
           capabilities: data.protocol.capabilities
         });
+        this.committedSessionWriteAckMode = this.supportsKnownProtocolCapability("message_ack_v3") ? "supported" : "unsupported";
         this.clearProtocolV3SessionSyncWaitTimer();
         this.scheduleProtocolV3SessionSync({ waitForCapabilities: false });
+        this.flushReliableSessionMessages();
       } catch (error) {
         logger.debug("[SOCKET] [CAPABILITIES] [ERROR] Error handling capabilities event", { error });
       }
@@ -1990,15 +2004,24 @@ class ApiSessionClient extends EventEmitter {
     };
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
     const eventType = typeof body?.type === "string" ? body.type : "unknown";
+    const reliableMessage = {
+      encrypted,
+      type: `codex:${eventType}`,
+      localId: randomUUID()
+    };
     if (!this.socket.connected) {
       if (this.shouldBufferReliableCodexMessage(body)) {
         logger.debug("[API] Socket not connected, buffering reliable Codex message:", { type: eventType });
-        this.bufferReliableSessionMessage({ encrypted, type: `codex:${eventType}` });
+        this.enqueueReliableSessionMessage(reliableMessage);
       } else {
         logger.debug("[API] Socket not connected, dropping non-critical Codex message:", { type: eventType });
       }
       return;
     }
+    if (this.shouldBufferReliableCodexMessage(body) && this.shouldUseCommittedSessionWriteAcks()) {
+      this.enqueueReliableSessionMessage(reliableMessage);
+      return;
+    }
     this.emitEncryptedSessionMessage(encrypted);
   }
   /**
@@ -2023,13 +2046,18 @@ class ApiSessionClient extends EventEmitter {
     logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
     const eventType = typeof body?.type === "string" ? body.type : "unknown";
+    const reliableMessage = {
+      encrypted,
+      type: `acp:${provider}:${eventType}`,
+      localId: randomUUID()
+    };
     if (!this.socket.connected) {
       if (this.shouldBufferReliableAcpMessage(body)) {
         logger.debug("[API] Socket not connected, buffering reliable ACP message:", {
           provider,
           type: eventType
         });
-        this.bufferReliableSessionMessage({ encrypted, type: `acp:${provider}:${eventType}` });
+        this.enqueueReliableSessionMessage(reliableMessage);
       } else {
         logger.debug("[API] Socket not connected, dropping non-critical ACP message:", {
           provider,
@@ -2038,10 +2066,14 @@ class ApiSessionClient extends EventEmitter {
       }
       return;
     }
+    if (this.shouldBufferReliableAcpMessage(body) && this.shouldUseCommittedSessionWriteAcks()) {
+      this.enqueueReliableSessionMessage(reliableMessage);
+      return;
+    }
     this.emitEncryptedSessionMessage(encrypted);
   }
   sendSessionEvent(event, id) {
-    let content = {
+    const content = {
       role: "agent",
       content: {
         id: id ?? randomUUID(),
@@ -2050,15 +2082,24 @@ class ApiSessionClient extends EventEmitter {
       }
     };
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const reliableMessage = {
+      encrypted,
+      type: `event:${event.type}`,
+      localId: content.content.id
+    };
     if (!this.socket.connected) {
       if (this.shouldBufferReliableSessionEvent(event)) {
         logger.debug("[API] Socket not connected, buffering session event:", { type: event.type });
-        this.bufferReliableSessionMessage({ encrypted, type: `event:${event.type}` });
+        this.enqueueReliableSessionMessage(reliableMessage);
       } else {
         logger.debug("[API] Socket not connected, dropping session event:", { type: event.type });
       }
       return;
     }
+    if (this.shouldBufferReliableSessionEvent(event) && this.shouldUseCommittedSessionWriteAcks()) {
+      this.enqueueReliableSessionMessage(reliableMessage);
+      return;
+    }
     this.emitEncryptedSessionMessage(encrypted);
   }
   /**
@@ -2172,6 +2213,10 @@ class ApiSessionClient extends EventEmitter {
    * Wait for socket buffer to flush
    */
   async flush() {
+    if (!this.socket.connected) {
+      return;
+    }
+    await this.waitForReliableSessionMessagesToDrain();
     if (!this.socket.connected) {
       return;
     }
@@ -2461,31 +2506,197 @@ class ApiSessionClient extends EventEmitter {
   supportsKnownProtocolCapability(capability) {
     return Array.isArray(this.protocolV3Descriptor?.capabilities) && this.protocolV3Descriptor.capabilities.includes(capability);
   }
-  emitEncryptedSessionMessage(encrypted) {
+  shouldUseCommittedSessionWriteAcks() {
+    if (!this.credentials.signing) {
+      return false;
+    }
+    return this.committedSessionWriteAckMode !== "unsupported";
+  }
+  emitEncryptedSessionMessage(encrypted, localId) {
     this.socket.emit("message", {
       sid: this.sessionId,
-      message: encrypted
+      message: encrypted,
+      ...typeof localId === "string" ? { localId } : {}
     });
   }
-  bufferReliableSessionMessage(message) {
-    this.pendingReliableSessionMessages.push(message);
-    this.pendingReliableSessionMessageBytes += message.encrypted.length;
+  enqueueReliableSessionMessage(message) {
+    this.queuedReliableSessionMessages.push(message);
+    this.queuedReliableSessionMessageBytes += message.encrypted.length;
     this.trimPendingReliableSessionMessages();
+    this.flushReliableSessionMessages();
+  }
+  dequeueReliableSessionMessage() {
+    const message = this.queuedReliableSessionMessages.shift() ?? null;
+    if (!message) {
+      return null;
+    }
+    this.queuedReliableSessionMessageBytes -= message.encrypted.length;
+    return message;
   }
   flushReliableSessionMessages() {
-    if (!this.socket.connected || this.pendingReliableSessionMessages.length === 0) {
+    this.clearReliableSessionMessageRetryTimer();
+    if (this.reliableSessionMessageFlushInProgress || !this.socket.connected) {
+      this.resolveReliableSessionMessageDrainWaitersIfIdle();
+      return;
+    }
+    this.reliableSessionMessageFlushInProgress = true;
+    void (async () => {
+      try {
+        while (this.socket.connected) {
+          const message = this.inFlightReliableSessionMessage ?? this.dequeueReliableSessionMessage();
+          if (!message) {
+            this.inFlightReliableSessionMessage = null;
+            break;
+          }
+          if (this.inFlightReliableSessionMessage === null) {
+            logger.debug("[API] Flushing buffered session message after reconnect", {
+              type: message.type,
+              localId: message.localId
+            });
+          }
+          this.inFlightReliableSessionMessage = message;
+          if (this.shouldUseCommittedSessionWriteAcks()) {
+            const result = await this.emitEncryptedSessionMessageWithAck(message);
+            if (result === "retry") {
+              this.scheduleReliableSessionMessageRetry();
+              break;
+            }
+          } else {
+            this.emitEncryptedSessionMessage(message.encrypted, message.localId);
+          }
+          this.inFlightReliableSessionMessage = null;
+        }
+      } finally {
+        this.reliableSessionMessageFlushInProgress = false;
+        this.resolveReliableSessionMessageDrainWaitersIfIdle();
+      }
+    })();
+  }
+  async waitForReliableSessionMessagesToDrain() {
+    if (!this.socket.connected) {
+      return;
+    }
+    this.flushReliableSessionMessages();
+    if (!this.reliableSessionMessageFlushInProgress && this.inFlightReliableSessionMessage === null && this.queuedReliableSessionMessages.length === 0) {
       return;
     }
-    const buffered = this.pendingReliableSessionMessages.splice(0, this.pendingReliableSessionMessages.length);
-    this.pendingReliableSessionMessageBytes = 0;
-    logger.debug("[API] Flushing buffered session messages after reconnect", {
-      count: buffered.length,
-      types: buffered.map((message) => message.type)
+    await new Promise((resolve) => {
+      this.reliableSessionMessageDrainWaiters.push(resolve);
     });
-    for (const message of buffered) {
-      this.emitEncryptedSessionMessage(message.encrypted);
+  }
+  resolveReliableSessionMessageDrainWaitersIfIdle() {
+    if (!this.socket.connected) {
+      const disconnectedWaiters = this.reliableSessionMessageDrainWaiters.splice(0, this.reliableSessionMessageDrainWaiters.length);
+      for (const waiter of disconnectedWaiters) {
+        waiter();
+      }
+      return;
+    }
+    if (this.reliableSessionMessageFlushInProgress || this.inFlightReliableSessionMessage !== null || this.queuedReliableSessionMessages.length > 0) {
+      return;
+    }
+    const waiters = this.reliableSessionMessageDrainWaiters.splice(0, this.reliableSessionMessageDrainWaiters.length);
+    for (const waiter of waiters) {
+      waiter();
     }
   }
+  scheduleReliableSessionMessageRetry() {
+    if (this.reliableSessionMessageRetryTimer || !this.socket.connected || this.inFlightReliableSessionMessage === null) {
+      return;
+    }
+    this.reliableSessionMessageRetryTimer = setTimeout(() => {
+      this.reliableSessionMessageRetryTimer = null;
+      if (!this.socket.connected || this.inFlightReliableSessionMessage === null) {
+        this.resolveReliableSessionMessageDrainWaitersIfIdle();
+        return;
+      }
+      this.flushReliableSessionMessages();
+    }, RELIABLE_SESSION_MESSAGE_RETRY_DELAY_MS);
+  }
+  clearReliableSessionMessageRetryTimer() {
+    if (!this.reliableSessionMessageRetryTimer) {
+      return;
+    }
+    clearTimeout(this.reliableSessionMessageRetryTimer);
+    this.reliableSessionMessageRetryTimer = null;
+  }
+  async emitEncryptedSessionMessageWithAck(message) {
+    try {
+      const response = await this.withAckTimeout(
+        Promise.resolve(this.socket.emitWithAck("message", {
+          sid: this.sessionId,
+          message: message.encrypted,
+          localId: message.localId
+        })),
+        COMMITTED_SESSION_WRITE_ACK_TIMEOUT_MS
+      );
+      if (!response || typeof response !== "object" || !("ok" in response)) {
+        if (this.committedSessionWriteAckMode === "unknown") {
+          logger.debug("[API] Falling back to fire-and-forget session writes because websocket write acknowledgements are unavailable", {
+            sessionId: this.sessionId,
+            type: message.type
+          });
+          this.committedSessionWriteAckMode = "unsupported";
+          this.emitEncryptedSessionMessage(message.encrypted, message.localId);
+          return "committed";
+        }
+        logger.debug("[API] Session write acknowledgement payload was invalid, will retry on reconnect", {
+          sessionId: this.sessionId,
+          type: message.type,
+          response
+        });
+        return "retry";
+      }
+      const ackResponse = response;
+      if (!ackResponse.ok) {
+        logger.debug("[API] Session write was rejected by the server", {
+          sessionId: this.sessionId,
+          type: message.type,
+          localId: message.localId,
+          error: ackResponse.error
+        });
+        this.emit("message-ack", ackResponse);
+        return "committed";
+      }
+      this.committedSessionWriteAckMode = "supported";
+      this.emit("message-ack", ackResponse);
+      return "committed";
+    } catch (error) {
+      if (this.committedSessionWriteAckMode === "unknown" && isAckTimeoutError(error)) {
+        logger.debug("[API] Websocket write acknowledgements timed out before protocol capabilities were confirmed, falling back to fire-and-forget writes", {
+          sessionId: this.sessionId,
+          type: message.type
+        });
+        this.committedSessionWriteAckMode = "unsupported";
+        this.emitEncryptedSessionMessage(message.encrypted, message.localId);
+        return "committed";
+      }
+      logger.debug("[API] Reliable session write acknowledgement failed, will retry when the socket reconnects", {
+        sessionId: this.sessionId,
+        type: message.type,
+        localId: message.localId,
+        error
+      });
+      return "retry";
+    }
+  }
+  async withAckTimeout(promise, timeoutMs) {
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(createAckTimeoutError(timeoutMs));
+      }, timeoutMs);
+      promise.then(
+        (value) => {
+          clearTimeout(timeout);
+          resolve(value);
+        },
+        (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      );
+    });
+  }
   shouldBufferReliableCodexMessage(body) {
     switch (body?.type) {
       case "message":
@@ -2532,19 +2743,19 @@ class ApiSessionClient extends EventEmitter {
   }
   trimPendingReliableSessionMessages() {
     let dropped = 0;
-    while (this.pendingReliableSessionMessages.length > MAX_PENDING_RELIABLE_SESSION_MESSAGES || this.pendingReliableSessionMessageBytes > MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES) {
-      const removed = this.pendingReliableSessionMessages.shift();
+    while (this.queuedReliableSessionMessages.length > MAX_PENDING_RELIABLE_SESSION_MESSAGES || this.queuedReliableSessionMessageBytes > MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES) {
+      const removed = this.queuedReliableSessionMessages.shift();
       if (!removed) {
         break;
       }
-      this.pendingReliableSessionMessageBytes -= removed.encrypted.length;
+      this.queuedReliableSessionMessageBytes -= removed.encrypted.length;
       dropped += 1;
     }
     if (dropped > 0) {
       logger.debug("[API] Dropped oldest buffered session messages to cap reconnect memory usage", {
         dropped,
-        remaining: this.pendingReliableSessionMessages.length,
-        bytes: this.pendingReliableSessionMessageBytes
+        remaining: this.queuedReliableSessionMessages.length,
+        bytes: this.queuedReliableSessionMessageBytes
       });
     }
   }
@@ -2601,6 +2812,14 @@ function createAbortError() {
   error.name = "AbortError";
   return error;
 }
+function createAckTimeoutError(timeoutMs) {
+  const error = new Error(`Timed out waiting for websocket message acknowledgement after ${timeoutMs}ms`);
+  error.name = "AckTimeoutError";
+  return error;
+}
+function isAckTimeoutError(error) {
+  return error instanceof Error && error.name === "AckTimeoutError";
+}
 
 class ApiMachineClient {
   constructor(credentials, machine) {