@zonease/happy 0.6.41 → 0.6.43

package/dist/downloadImage-3A6zY5AX.cjs

@@ -0,0 +1,492 @@
+'use strict';
+
+var logger = require('./persistence-D7zNFI-d.cjs');
+var crypto = require('crypto');
+var axios = require('axios');
+
+function parseCompact(message) {
+  const trimmed = message.trim();
+  if (trimmed === "/compact") {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  if (trimmed.startsWith("/compact ")) {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  return {
+    isCompact: false,
+    originalMessage: message
+  };
+}
+function parseClear(message) {
+  const trimmed = message.trim();
+  return {
+    isClear: trimmed === "/clear"
+  };
+}
+function parseSpecialCommand(message) {
+  const compactResult = parseCompact(message);
+  if (compactResult.isCompact) {
+    return {
+      type: "compact",
+      originalMessage: compactResult.originalMessage
+    };
+  }
+  const clearResult = parseClear(message);
+  if (clearResult.isClear) {
+    return {
+      type: "clear"
+    };
+  }
+  return {
+    type: null
+  };
+}
+
+class MessageQueue2 {
+  queue = [];
+  // Made public for testing
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  modeHasher;
+  constructor(modeHasher, onMessageHandler = null) {
+    this.modeHasher = modeHasher;
+    this.onMessageHandler = onMessageHandler;
+    logger.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);
+    logger.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) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.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);
+    logger.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) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.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);
+    logger.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) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.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);
+    logger.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) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Reset the queue - clears all messages and resets to empty state
+   */
+  reset() {
+    logger.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() {
+    logger.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.
+   * For string messages, multiple messages are joined with newlines.
+   * For object messages (e.g., mixed content with images), returns them one at a time.
+   * Returns { message: M, 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.
+   * For string messages, joins them with newlines.
+   * For object messages (like mixed content with images), returns one at a time.
+   */
+  collectBatch() {
+    if (this.queue.length === 0) {
+      return null;
+    }
+    const firstItem = this.queue[0];
+    let mode = firstItem.mode;
+    let isolate = firstItem.isolate ?? false;
+    const targetModeHash = firstItem.modeHash;
+    if (firstItem.isolate) {
+      const item = this.queue.shift();
+      logger.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
+      return {
+        message: item.message,
+        mode,
+        hash: targetModeHash,
+        isolate
+      };
+    }
+    if (typeof firstItem.message !== "string") {
+      const item = this.queue.shift();
+      logger.logger.debug(`[MessageQueue2] Collected single object message with mode hash: ${targetModeHash}`);
+      return {
+        message: item.message,
+        mode,
+        hash: targetModeHash,
+        isolate
+      };
+    }
+    const sameModeMessages = [];
+    while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash && !this.queue[0].isolate && typeof this.queue[0].message === "string") {
+      const item = this.queue.shift();
+      sameModeMessages.push(item.message);
+    }
+    logger.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 = () => {
+          logger.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;
+      logger.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);
+}
+
+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));
+  }
+}
+
+async function downloadImage(url) {
+  const response = await axios.get(url, {
+    responseType: "arraybuffer"
+  });
+  const buffer = Buffer.from(response.data);
+  const base64 = buffer.toString("base64");
+  let mimeType = response.headers["content-type"] || "image/jpeg";
+  if (mimeType.includes(";")) {
+    mimeType = mimeType.split(";")[0].trim();
+  }
+  return { base64, mimeType };
+}
+
+exports.MessageBuffer = MessageBuffer;
+exports.MessageQueue2 = MessageQueue2;
+exports.downloadImage = downloadImage;
+exports.hashObject = hashObject;
+exports.parseClear = parseClear;
+exports.parseSpecialCommand = parseSpecialCommand;