happy-imou-cloud 2.1.7 → 2.1.9

package/dist/{BaseReasoningProcessor-C0A6Jr8V.mjs → BaseReasoningProcessor-CgEO6Vh-.mjs}

@@ -1,5 +1,5 @@
-import { a as createSessionMetadata, p as publishSessionRegistration } from './index-BAhlFq45.mjs';
-import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-BYKV7vX6.mjs';
+import { a as createSessionMetadata, p as publishSessionRegistration } from './index-BKjWLXkN.mjs';
+import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-CfHYTLZX.mjs';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
 
@@ -103,7 +103,8 @@ async function bootstrapManagedProviderSession(opts) {
     response = await opts.api.getOrCreateSession({
       tag: opts.sessionTag,
       metadata,
-      state
+      state,
+      stableDataKeyPath: ["managed-session-tag", opts.sessionTag]
     });
   } catch (error) {
     if (!isAuthenticationRequiredError(error)) {

package/dist/{BaseReasoningProcessor-iSuaFeZH.cjs → BaseReasoningProcessor-DV6TAtd7.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index = require('./index-D_S_7bqK.cjs');
-var api = require('./api-CdGT5hsH.cjs');
+var index = require('./index-C3bSe5_d.cjs');
+var api = require('./api-CfmTDha2.cjs');
 var node_events = require('node:events');
 var node_crypto = require('node:crypto');
 
@@ -105,7 +105,8 @@ async function bootstrapManagedProviderSession(opts) {
     response = await opts.api.getOrCreateSession({
       tag: opts.sessionTag,
       metadata,
-      state
+      state,
+      stableDataKeyPath: ["managed-session-tag", opts.sessionTag]
     });
   } catch (error) {
     if (!api.isAuthenticationRequiredError(error)) {

package/dist/{ProviderSelectionHandler-DI9QK1iY.cjs → ProviderSelectionHandler-C6ILAmE3.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var api = require('./api-CdGT5hsH.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-DjxtkGMv.cjs');
+var api = require('./api-CfmTDha2.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-FIQEW2Rx.cjs');
 
 async function runModeLoop(opts) {
   let currentMode = opts.startingMode;

package/dist/{ProviderSelectionHandler-WT-tvePy.mjs → ProviderSelectionHandler-dczuX21U.mjs}

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

package/dist/{api-BYKV7vX6.mjs → api-CfHYTLZX.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.7";
+var version = "2.1.9";
 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-B8Wgn6aN.mjs');
+      const { readDaemonState } = await import('./persistence-Nun5c360.mjs');
       const state = await readDaemonState();
       if (!state) {
         return logs;
@@ -1732,8 +1732,8 @@ function buildSocketAuth(opts) {
   return auth;
 }
 
-const MAX_PENDING_RELIABLE_CODEX_MESSAGES = 200;
-const MAX_PENDING_RELIABLE_CODEX_MESSAGE_BYTES = 512 * 1024;
+const MAX_PENDING_RELIABLE_SESSION_MESSAGES = 200;
+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;
@@ -1752,8 +1752,8 @@ class ApiSessionClient extends EventEmitter {
   metadataLock = new AsyncLock();
   encryptionKey;
   encryptionVariant;
-  pendingReliableCodexMessages = [];
-  pendingReliableCodexMessageBytes = 0;
+  pendingReliableSessionMessages = [];
+  pendingReliableSessionMessageBytes = 0;
   reconnectAfterServerDisconnectTimer = null;
   lastSocketServerError = null;
   protocolV3SessionSync = null;
@@ -1782,7 +1782,14 @@ class ApiSessionClient extends EventEmitter {
       encryptionVariant: this.encryptionVariant,
       logger: (msg, data) => logger.debug(msg, data)
     });
-    registerCommonHandlers(this.rpcHandlerManager, this.metadata.path);
+    const workingDirectory = this.metadata?.path ?? process.cwd();
+    if (!this.metadata?.path) {
+      logger.debug("[API] Session metadata missing path during client initialization, falling back to process.cwd()", {
+        sessionId: this.sessionId,
+        workingDirectory
+      });
+    }
+    registerCommonHandlers(this.rpcHandlerManager, workingDirectory);
     this.socket = io(configuration.serverUrl, {
       auth: (cb) => cb(buildSocketAuth({
         credentials: this.credentials,
@@ -1803,7 +1810,7 @@ class ApiSessionClient extends EventEmitter {
       this.clearReconnectAfterServerDisconnectTimer();
       this.lastSocketServerError = null;
       this.rpcHandlerManager.onSocketConnect(this.socket);
-      this.flushReliableCodexMessages();
+      this.flushReliableSessionMessages();
       this.protocolV3Descriptor = null;
       this.protocolV3SocketCapabilities = null;
       this.scheduleProtocolV3SessionSync();
@@ -1986,9 +1993,7 @@ class ApiSessionClient extends EventEmitter {
     if (!this.socket.connected) {
       if (this.shouldBufferReliableCodexMessage(body)) {
         logger.debug("[API] Socket not connected, buffering reliable Codex message:", { type: eventType });
-        this.pendingReliableCodexMessages.push({ encrypted, type: eventType });
-        this.pendingReliableCodexMessageBytes += encrypted.length;
-        this.trimPendingReliableCodexMessages();
+        this.bufferReliableSessionMessage({ encrypted, type: `codex:${eventType}` });
       } else {
         logger.debug("[API] Socket not connected, dropping non-critical Codex message:", { type: eventType });
       }
@@ -2017,10 +2022,23 @@ 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));
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
+    const eventType = typeof body?.type === "string" ? body.type : "unknown";
+    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}` });
+      } else {
+        logger.debug("[API] Socket not connected, dropping non-critical ACP message:", {
+          provider,
+          type: eventType
+        });
+      }
+      return;
+    }
+    this.emitEncryptedSessionMessage(encrypted);
   }
   sendSessionEvent(event, id) {
     let content = {
@@ -2032,10 +2050,16 @@ class ApiSessionClient extends EventEmitter {
       }
     };
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
-    this.socket.emit("message", {
-      sid: this.sessionId,
-      message: encrypted
-    });
+    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}` });
+      } else {
+        logger.debug("[API] Socket not connected, dropping session event:", { type: event.type });
+      }
+      return;
+    }
+    this.emitEncryptedSessionMessage(encrypted);
   }
   /**
    * Send a ping message to keep the connection alive
@@ -2089,7 +2113,7 @@ class ApiSessionClient extends EventEmitter {
    * @param handler - Handler function that returns the updated metadata
    */
   updateMetadata(handler) {
-    this.metadataLock.inLock(async () => {
+    void this.metadataLock.inLock(async () => {
       await backoff(async () => {
         let updated = handler(this.metadata);
         const sessionIndex = buildSessionRuntimeIndex(updated);
@@ -2112,6 +2136,8 @@ class ApiSessionClient extends EventEmitter {
           throw new Error("Metadata version mismatch");
         } else if (answer.result === "error") ;
       });
+    }).catch((error) => {
+      logger.debug("[API] Metadata update failed unexpectedly", error);
     });
   }
   /**
@@ -2120,7 +2146,7 @@ class ApiSessionClient extends EventEmitter {
    */
   updateAgentState(handler) {
     logger.debugLargeJson("Updating agent state", this.agentState);
-    this.agentStateLock.inLock(async () => {
+    void this.agentStateLock.inLock(async () => {
       await backoff(async () => {
         let updated = handler(this.agentState || {});
         const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) : null });
@@ -2138,6 +2164,8 @@ class ApiSessionClient extends EventEmitter {
           throw new Error("Agent state version mismatch");
         } else if (answer.result === "error") ;
       });
+    }).catch((error) => {
+      logger.debug("[API] Agent state update failed unexpectedly", error);
     });
   }
   /**
@@ -2439,13 +2467,18 @@ class ApiSessionClient extends EventEmitter {
       message: encrypted
     });
   }
-  flushReliableCodexMessages() {
-    if (!this.socket.connected || this.pendingReliableCodexMessages.length === 0) {
+  bufferReliableSessionMessage(message) {
+    this.pendingReliableSessionMessages.push(message);
+    this.pendingReliableSessionMessageBytes += message.encrypted.length;
+    this.trimPendingReliableSessionMessages();
+  }
+  flushReliableSessionMessages() {
+    if (!this.socket.connected || this.pendingReliableSessionMessages.length === 0) {
       return;
     }
-    const buffered = this.pendingReliableCodexMessages.splice(0, this.pendingReliableCodexMessages.length);
-    this.pendingReliableCodexMessageBytes = 0;
-    logger.debug("[API] Flushing buffered Codex messages after reconnect", {
+    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)
     });
@@ -2469,21 +2502,49 @@ class ApiSessionClient extends EventEmitter {
         return false;
     }
   }
-  trimPendingReliableCodexMessages() {
+  shouldBufferReliableAcpMessage(body) {
+    switch (body?.type) {
+      case "message":
+      case "tool-call":
+      case "tool-result":
+      case "file-edit":
+      case "terminal-output":
+      case "task_started":
+      case "task_complete":
+      case "turn_aborted":
+      case "turn-report":
+      case "permission-request":
+        return true;
+      default:
+        return false;
+    }
+  }
+  shouldBufferReliableSessionEvent(event) {
+    switch (event.type) {
+      case "switch":
+      case "message":
+      case "permission-mode-changed":
+      case "ready":
+        return true;
+      default:
+        return false;
+    }
+  }
+  trimPendingReliableSessionMessages() {
     let dropped = 0;
-    while (this.pendingReliableCodexMessages.length > MAX_PENDING_RELIABLE_CODEX_MESSAGES || this.pendingReliableCodexMessageBytes > MAX_PENDING_RELIABLE_CODEX_MESSAGE_BYTES) {
-      const removed = this.pendingReliableCodexMessages.shift();
+    while (this.pendingReliableSessionMessages.length > MAX_PENDING_RELIABLE_SESSION_MESSAGES || this.pendingReliableSessionMessageBytes > MAX_PENDING_RELIABLE_SESSION_MESSAGE_BYTES) {
+      const removed = this.pendingReliableSessionMessages.shift();
       if (!removed) {
         break;
       }
-      this.pendingReliableCodexMessageBytes -= removed.encrypted.length;
+      this.pendingReliableSessionMessageBytes -= removed.encrypted.length;
       dropped += 1;
     }
     if (dropped > 0) {
-      logger.debug("[API] Dropped oldest buffered Codex messages to cap reconnect memory usage", {
+      logger.debug("[API] Dropped oldest buffered session messages to cap reconnect memory usage", {
         dropped,
-        remaining: this.pendingReliableCodexMessages.length,
-        bytes: this.pendingReliableCodexMessageBytes
+        remaining: this.pendingReliableSessionMessages.length,
+        bytes: this.pendingReliableSessionMessageBytes
       });
     }
   }
@@ -3203,6 +3264,39 @@ class OfflineState {
 }
 const connectionState = new OfflineState();
 
+async function hmac_sha512(key, data) {
+  const hmac = createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+
+async function deriveSecretKeyTreeRoot(seed, usage) {
+  const I = await hmac_sha512(new TextEncoder().encode(usage + " Master Seed"), seed);
+  return {
+    key: I.slice(0, 32),
+    chainCode: I.slice(32)
+  };
+}
+async function deriveSecretKeyTreeChild(chainCode, index) {
+  const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+  const I = await hmac_sha512(chainCode, data);
+  return {
+    key: I.subarray(0, 32),
+    chainCode: I.subarray(32)
+  };
+}
+async function deriveKey(master, usage, path) {
+  let state = await deriveSecretKeyTreeRoot(master, usage);
+  let remaining = [...path];
+  while (remaining.length > 0) {
+    let index = remaining[0];
+    remaining = remaining.slice(1);
+    state = await deriveSecretKeyTreeChild(state.chainCode, index);
+  }
+  return state.key;
+}
+
+const SESSION_DATA_KEY_USAGE = "Happy Session Data Key";
 class ApiClient {
   static async create(credential) {
     return new ApiClient(credential);
@@ -3344,7 +3438,15 @@ class ApiClient {
     let encryptionKey;
     let encryptionVariant;
     if (this.credential.encryption.type === "dataKey") {
-      encryptionKey = getRandomBytes(32);
+      if (opts.stableDataKeyPath && opts.stableDataKeyPath.length > 0) {
+        encryptionKey = await deriveKey(
+          this.credential.encryption.machineKey,
+          SESSION_DATA_KEY_USAGE,
+          opts.stableDataKeyPath
+        );
+      } else {
+        encryptionKey = getRandomBytes(32);
+      }
       encryptionVariant = "dataKey";
       let encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
       dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
@@ -3370,10 +3472,14 @@ class ApiClient {
       });
       logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
       let raw = response.data.session;
+      const metadata = decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata));
+      if (metadata === null) {
+        throw new Error(`Failed to decrypt session metadata for tag ${opts.tag}`);
+      }
       let session = {
         id: raw.id,
         seq: raw.seq,
-        metadata: decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata)),
+        metadata,
         metadataVersion: raw.metadataVersion,
         agentState: raw.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.agentState)) : null,
         agentStateVersion: raw.agentStateVersion,