happy-imou-cloud 1.1.7 → 2.0.0

package/dist/registerKillSessionHandler-CLREXN11.cjs

@@ -0,0 +1,433 @@
+'use strict';
+
+var api = require('./api-D7OK-mML.cjs');
+var crypto = require('crypto');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('node:crypto');
+require('tweetnacl');
+require('expo-server-sdk');
+require('chalk');
+require('./types-DVk3crez.cjs');
+
+class MessageBuffer {
+  messages = [];
+  listeners = [];
+  nextId = 1;
+  addMessage(content, type = "assistant") {
+    const message = {
+      id: `msg-${this.nextId++}`,
+      timestamp: /* @__PURE__ */ new Date(),
+      content,
+      type
+    };
+    this.messages.push(message);
+    this.notifyListeners();
+  }
+  /**
+   * Update the last message of a specific type by appending content to it
+   * Useful for streaming responses where deltas should accumulate in one message
+   */
+  updateLastMessage(contentDelta, type = "assistant") {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        const oldMessage = this.messages[i];
+        const updatedMessage = {
+          ...oldMessage,
+          content: oldMessage.content + contentDelta
+        };
+        this.messages[i] = updatedMessage;
+        this.notifyListeners();
+        return;
+      }
+    }
+    this.addMessage(contentDelta, type);
+  }
+  /**
+   * Remove the last message of a specific type
+   * Useful for removing placeholder messages like "Thinking..." when actual response starts
+   */
+  removeLastMessage(type) {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        this.messages.splice(i, 1);
+        this.notifyListeners();
+        return true;
+      }
+    }
+    return false;
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  clear() {
+    this.messages = [];
+    this.nextId = 1;
+    this.notifyListeners();
+  }
+  onUpdate(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  notifyListeners() {
+    const messages = this.getMessages();
+    this.listeners.forEach((listener) => listener(messages));
+  }
+}
+
+class MessageQueue2 {
+  queue = [];
+  // Made public for testing
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  modeHasher;
+  constructor(modeHasher, onMessageHandler = null) {
+    this.modeHasher = modeHasher;
+    this.onMessageHandler = onMessageHandler;
+    api.logger.debug(`[MessageQueue2] Initialized`);
+  }
+  /**
+   * Set a handler that will be called when a message arrives
+   */
+  setOnMessage(handler) {
+    this.onMessageHandler = handler;
+  }
+  /**
+   * Push a message to the queue with a mode.
+   */
+  push(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    api.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      api.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    api.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message immediately without batching delay.
+   * Does not clear the queue or enforce isolation.
+   */
+  pushImmediate(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    api.logger.debug(`[MessageQueue2] pushImmediate() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      api.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    api.logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message that must be processed in complete isolation.
+   * Clears any pending messages and ensures this message is never batched with others.
+   * Used for special commands that require dedicated processing.
+   */
+  pushIsolateAndClear(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    api.logger.debug(`[MessageQueue2] pushIsolateAndClear() called with mode hash: ${modeHash} - clearing ${this.queue.length} pending messages`);
+    this.queue = [];
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: true
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      api.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    api.logger.debug(`[MessageQueue2] pushIsolateAndClear() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message to the beginning of the queue with a mode.
+   */
+  unshift(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot unshift to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    api.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    this.queue.unshift({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      api.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    api.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Reset the queue - clears all messages and resets to empty state
+   */
+  reset() {
+    api.logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
+    this.queue = [];
+    this.closed = false;
+    this.waiter = null;
+  }
+  /**
+   * Close the queue - no more messages can be pushed
+   */
+  close() {
+    api.logger.debug(`[MessageQueue2] close() called`);
+    this.closed = true;
+    if (this.waiter) {
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(false);
+    }
+  }
+  /**
+   * Check if the queue is closed
+   */
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * Get the current queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Wait for messages and return all messages with the same mode as a single string
+   * Returns { message: string, mode: T } or null if aborted/closed
+   */
+  async waitForMessagesAndGetAsString(abortSignal) {
+    if (this.queue.length > 0) {
+      return this.collectBatch();
+    }
+    if (this.closed || abortSignal?.aborted) {
+      return null;
+    }
+    const hasMessages = await this.waitForMessages(abortSignal);
+    if (!hasMessages) {
+      return null;
+    }
+    return this.collectBatch();
+  }
+  /**
+   * Collect a batch of messages with the same mode, respecting isolation requirements
+   */
+  collectBatch() {
+    if (this.queue.length === 0) {
+      return null;
+    }
+    const firstItem = this.queue[0];
+    const sameModeMessages = [];
+    let mode = firstItem.mode;
+    let isolate = firstItem.isolate ?? false;
+    const targetModeHash = firstItem.modeHash;
+    if (firstItem.isolate) {
+      const item = this.queue.shift();
+      sameModeMessages.push(item.message);
+      api.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
+    } else {
+      while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash && !this.queue[0].isolate) {
+        const item = this.queue.shift();
+        sameModeMessages.push(item.message);
+      }
+      api.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+    }
+    const combinedMessage = sameModeMessages.join("\n");
+    return {
+      message: combinedMessage,
+      mode,
+      hash: targetModeHash,
+      isolate
+    };
+  }
+  /**
+   * Wait for messages to arrive
+   */
+  waitForMessages(abortSignal) {
+    return new Promise((resolve) => {
+      let abortHandler = null;
+      if (abortSignal) {
+        abortHandler = () => {
+          api.logger.debug("[MessageQueue2] Wait aborted");
+          if (this.waiter === waiterFunc) {
+            this.waiter = null;
+          }
+          resolve(false);
+        };
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      const waiterFunc = (hasMessages) => {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(hasMessages);
+      };
+      if (this.queue.length > 0) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(true);
+        return;
+      }
+      if (this.closed || abortSignal?.aborted) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(false);
+        return;
+      }
+      this.waiter = waiterFunc;
+      api.logger.debug("[MessageQueue2] Waiting for messages...");
+    });
+  }
+}
+
+function deterministicStringify(obj, options = {}) {
+  const {
+    undefinedBehavior = "omit",
+    sortArrays = false,
+    replacer,
+    includeSymbols = false
+  } = options;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function processValue(value, key) {
+    if (replacer && key !== void 0) {
+      value = replacer(key, value);
+    }
+    if (value === null) return null;
+    if (value === void 0) {
+      switch (undefinedBehavior) {
+        case "omit":
+          return void 0;
+        case "null":
+          return null;
+        case "throw":
+          throw new Error(`Undefined value at key: ${key}`);
+      }
+    }
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (typeof value === "function") {
+      return void 0;
+    }
+    if (typeof value === "symbol") {
+      return includeSymbols ? value.toString() : void 0;
+    }
+    if (typeof value === "bigint") {
+      return value.toString() + "n";
+    }
+    if (seen.has(value)) {
+      throw new Error("Circular reference detected");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const processed2 = value.map((item, index) => processValue(item, String(index))).filter((item) => item !== void 0);
+      if (sortArrays) {
+        processed2.sort((a, b) => {
+          const aStr = JSON.stringify(processValue(a));
+          const bStr = JSON.stringify(processValue(b));
+          return aStr.localeCompare(bStr);
+        });
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    if (value.constructor === Object || value.constructor === void 0) {
+      const processed2 = {};
+      const keys = Object.keys(value).sort();
+      for (const k of keys) {
+        const processedValue = processValue(value[k], k);
+        if (processedValue !== void 0) {
+          processed2[k] = processedValue;
+        }
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    try {
+      const plain = { ...value };
+      seen.delete(value);
+      return processValue(plain, key);
+    } catch {
+      seen.delete(value);
+      return String(value);
+    }
+  }
+  const processed = processValue(obj);
+  return JSON.stringify(processed);
+}
+function hashObject(obj, options, encoding = "hex") {
+  const jsonString = deterministicStringify(obj, options);
+  return crypto.createHash("sha256").update(jsonString).digest(encoding);
+}
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    api.logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
+exports.MessageBuffer = MessageBuffer;
+exports.MessageQueue2 = MessageQueue2;
+exports.hashObject = hashObject;
+exports.registerKillSessionHandler = registerKillSessionHandler;