@zonease/happy 0.6.41 → 0.6.43

package/dist/{downloadImage-ia5SzlCV.mjs → registerKillSessionHandler-DmfnJ0zq.mjs}

@@ -1,5 +1,3 @@
-import { l as logger, r as readCredentials } from './persistence-CIUFyOwz.mjs';
-import { createHash } from 'crypto';
 import { join, resolve, dirname } from 'node:path';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -7,18 +5,20 @@ import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { l as listDevices, d as deviceExec } from './deviceKeys-CejCdWpw.mjs';
+import { l as logger, r as readCredentials } from './persistence-DbLMvLvk.mjs';
+import { l as listDevices, d as deviceExec } from './deviceKeys-CQyFFPtt.mjs';
 import { randomUUID } from 'node:crypto';
 import { s as shouldEnableOrchestratorTools } from './prompt-BsAZsPbo.mjs';
 import './mcpToolSchemas-CjeTfrAs.mjs';
-import './index-CPKdvi7J.mjs';
+import './index-DTV7drqs.mjs';
 import { execSync } from 'node:child_process';
-import axios from 'axios';
+import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import './api-K2-jr9ar.mjs';
+import './api-BUCtd3cB.mjs';
 import 'tweetnacl';
 import 'ws';
+import 'crypto';
 import '@stablelib/base64';
 import 'node:os';
 import 'node:fs/promises';
@@ -28,403 +28,6 @@ import 'expo-server-sdk';
 import 'chalk';
 import './types-BoJh4Qfv.mjs';
 
-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.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.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.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    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.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.debug(`[MessageQueue2] Notifying waiter for immediate message`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    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.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.debug(`[MessageQueue2] Notifying waiter for isolated message`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    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.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.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
-  }
-  /**
-   * Reset the queue - clears all messages and resets to empty state
-   */
-  reset() {
-    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.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.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.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.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.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.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 createHash("sha256").update(jsonString).digest(encoding);
-}
-
 function createMcpServer(client, options) {
   const mcp = new McpServer({
     name: "Happy MCP",
@@ -790,76 +393,6 @@ function detectGitWorktree(cwd) {
   }
 }
 
-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));
-  }
-}
-
 function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   rpcHandlerManager.registerHandler("killSession", async () => {
     logger.debug("Kill session request received");
@@ -871,17 +404,4 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   });
 }
 
-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 };
-}
-
-export { MessageQueue2 as M, detectGitWorktree as a, MessageBuffer as b, createMcpContext as c, downloadImage as d, parseSpecialCommand as e, hashObject as h, parseClear as p, registerKillSessionHandler as r };
+export { createMcpContext as c, detectGitWorktree as d, registerKillSessionHandler as r };