@zonease/happy 0.6.41 → 0.6.43

package/dist/downloadImage-BqNp0l7y.mjs

@@ -0,0 +1,485 @@
+import { l as logger } from './persistence-DbLMvLvk.mjs';
+import { createHash } from 'crypto';
+import axios from '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.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);
+}
+
+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 };
+}
+
+export { MessageQueue2 as M, MessageBuffer as a, parseSpecialCommand as b, downloadImage as d, hashObject as h, parseClear as p };

package/dist/{enroll-HjUqyGnD.mjs → enroll-BlZ0giJI.mjs}

@@ -1,8 +1,8 @@
 import axios from 'axios';
 import tweetnacl from 'tweetnacl';
 import { createHmac, randomBytes } from 'node:crypto';
-import { r as readCredentials, c as configuration, h as decodeBase64, u as updateSettings, w as writeCredentialsDataKey, o as libsodiumPublicKeyFromSecretKey } from './persistence-CIUFyOwz.mjs';
-import { decryptWithEphemeralKey } from './auth-DS8fzlin.mjs';
+import { r as readCredentials, c as configuration, h as decodeBase64, u as updateSettings, w as writeCredentialsDataKey, o as libsodiumPublicKeyFromSecretKey } from './persistence-DbLMvLvk.mjs';
+import { decryptWithEphemeralKey } from './auth-qM2eojWx.mjs';
 import 'node:fs/promises';
 import 'node:fs';
 import 'node:os';
@@ -12,7 +12,7 @@ import 'chalk';
 import 'fs';
 import 'qrcode-terminal';
 import './time-DgsBLJA_.mjs';
-import './browser-C05Ak6RL.mjs';
+import './browser-D5RN_Axa.mjs';
 import 'open';
 import 'react';
 import 'ink';

package/dist/{enroll-BvfpRUGJ.cjs → enroll-DeYs89Ic.cjs}

@@ -3,8 +3,8 @@
 var axios = require('axios');
 var tweetnacl = require('tweetnacl');
 var node_crypto = require('node:crypto');
-var logger = require('./persistence-DrfN7TzY.cjs');
-var auth = require('./auth-BQvEuSs5.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var auth = require('./auth-BqGkUXvq.cjs');
 require('node:fs/promises');
 require('node:fs');
 require('node:os');
@@ -14,7 +14,7 @@ require('chalk');
 require('fs');
 require('qrcode-terminal');
 require('./time-Bj2HRkKH.cjs');
-require('./browser-C05SP_Tt.cjs');
+require('./browser-CY7VNU0C.cjs');
 require('open');
 require('react');
 require('ink');

package/dist/{evidence-CVgTjBrq.cjs → evidence-Bn1JXtdz.cjs}

@@ -5,7 +5,7 @@ var fs = require('node:fs');
 var promises = require('node:fs/promises');
 var node_crypto = require('node:crypto');
 var path = require('node:path');
-var logger = require('./persistence-DrfN7TzY.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
 var workflowReports = require('./workflowReports-BEWuQesA.cjs');
 var workflowCommon = require('./workflowCommon-Bl568-rt.cjs');
 require('node:os');

package/dist/{evidence-BEQd1dCh.mjs → evidence-PUnN9yPK.mjs}

@@ -3,7 +3,7 @@ import { constants } from 'node:fs';
 import { mkdir, appendFile, access, readFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { basename, dirname, resolve } from 'node:path';
-import { c as configuration } from './persistence-CIUFyOwz.mjs';
+import { c as configuration } from './persistence-DbLMvLvk.mjs';
 import { r as renderEvidenceReport, i as inferEvidenceKind } from './workflowReports-Dd8-4-8f.mjs';
 import { p as parseWorkflowArgs, s as stringFlag, b as booleanFlag, a as printOrWriteOutput } from './workflowCommon-B0d01Y_a.mjs';
 import 'node:os';

package/dist/{formatImageMessage-DVs57t3x.mjs → formatImageMessage-BRHeLf0-.mjs}

@@ -1,4 +1,4 @@
-import { d as downloadImage } from './downloadImage-ia5SzlCV.mjs';
+import { d as downloadImage } from './downloadImage-BqNp0l7y.mjs';
 
 async function formatMessageForClaude(text, images) {
   const content = [];

package/dist/{formatImageMessage-CmJTP_hU.cjs → formatImageMessage-bVFGFDJl.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var downloadImage = require('./downloadImage-B_ygLAXY.cjs');
+var downloadImage = require('./downloadImage-3A6zY5AX.cjs');
 
 async function formatMessageForClaude(text, images) {
   const content = [];

package/dist/{index-CDTNgfUf.cjs → index-BeKrqPYR.cjs}

@@ -301,7 +301,18 @@ const MODEL_MODES = [
   "gpt-5.1-codex-mini-high",
   "gemini-3-pro-preview",
   "gemini-3-flash-preview",
-  "gemini-2.5-pro"
+  "gemini-2.5-pro",
+  // Cursor resells models from every vendor — `cursor-agent --list-models`
+  // returned 161 ids. Only a curated set lives here: the ids below are the
+  // ones the picker offers. Anything else Cursor supports is still reachable
+  // by passing --model to `happy cursor`, which does not go through this list.
+  "auto",
+  "composer-2.5",
+  "composer-2.5-fast",
+  "cursor-grok-4.6-high",
+  "gemini-3.7-flash-high",
+  "claude-opus-5-thinking-high",
+  "claude-sonnet-5-high"
 ];
 const CLAUDE_MODEL_MODES = [
   MODEL_MODE_DEFAULT,
@@ -370,6 +381,17 @@ const GEMINI_MODEL_MODES = [
   "gemini-3-flash-preview",
   "gemini-2.5-pro"
 ];
+const CURSOR_MODEL_MODES = [
+  MODEL_MODE_DEFAULT,
+  "auto",
+  "composer-2.5",
+  "composer-2.5-fast",
+  "claude-opus-5-thinking-high",
+  "claude-sonnet-5-high",
+  "gpt-5.6-sol-high",
+  "cursor-grok-4.6-high",
+  "gemini-3.7-flash-high"
+];
 const CODEX_MODEL_MODES = [
   MODEL_MODE_DEFAULT,
   "gpt-5.6-sol-low",
@@ -416,6 +438,7 @@ const MODEL_MODE_SET = new Set(MODEL_MODES);
 const CLAUDE_MODEL_MODE_SET = new Set(CLAUDE_MODEL_MODES);
 const GEMINI_MODEL_MODE_SET = new Set(GEMINI_MODEL_MODES);
 const CODEX_MODEL_MODE_SET = new Set(CODEX_MODEL_MODES);
+const CURSOR_MODEL_MODE_SET = new Set(CURSOR_MODEL_MODES);
 function isModelMode(value) {
   return MODEL_MODE_SET.has(value);
 }
@@ -423,6 +446,7 @@ function isModelModeForAgent(agent, mode) {
   if (!isModelMode(mode)) return false;
   if (agent === "claude") return CLAUDE_MODEL_MODE_SET.has(mode);
   if (agent === "gemini") return GEMINI_MODEL_MODE_SET.has(mode);
+  if (agent === "cursor") return CURSOR_MODEL_MODE_SET.has(mode);
   return CODEX_MODEL_MODE_SET.has(mode);
 }
 const CLAUDE_MODE_TO_SELECTION = {

package/dist/{index-CPKdvi7J.mjs → index-DTV7drqs.mjs}

@@ -281,7 +281,18 @@ const MODEL_MODES = [
   "gpt-5.1-codex-mini-high",
   "gemini-3-pro-preview",
   "gemini-3-flash-preview",
-  "gemini-2.5-pro"
+  "gemini-2.5-pro",
+  // Cursor resells models from every vendor — `cursor-agent --list-models`
+  // returned 161 ids. Only a curated set lives here: the ids below are the
+  // ones the picker offers. Anything else Cursor supports is still reachable
+  // by passing --model to `happy cursor`, which does not go through this list.
+  "auto",
+  "composer-2.5",
+  "composer-2.5-fast",
+  "cursor-grok-4.6-high",
+  "gemini-3.7-flash-high",
+  "claude-opus-5-thinking-high",
+  "claude-sonnet-5-high"
 ];
 const CLAUDE_MODEL_MODES = [
   MODEL_MODE_DEFAULT,
@@ -350,6 +361,17 @@ const GEMINI_MODEL_MODES = [
   "gemini-3-flash-preview",
   "gemini-2.5-pro"
 ];
+const CURSOR_MODEL_MODES = [
+  MODEL_MODE_DEFAULT,
+  "auto",
+  "composer-2.5",
+  "composer-2.5-fast",
+  "claude-opus-5-thinking-high",
+  "claude-sonnet-5-high",
+  "gpt-5.6-sol-high",
+  "cursor-grok-4.6-high",
+  "gemini-3.7-flash-high"
+];
 const CODEX_MODEL_MODES = [
   MODEL_MODE_DEFAULT,
   "gpt-5.6-sol-low",
@@ -396,6 +418,7 @@ const MODEL_MODE_SET = new Set(MODEL_MODES);
 const CLAUDE_MODEL_MODE_SET = new Set(CLAUDE_MODEL_MODES);
 const GEMINI_MODEL_MODE_SET = new Set(GEMINI_MODEL_MODES);
 const CODEX_MODEL_MODE_SET = new Set(CODEX_MODEL_MODES);
+const CURSOR_MODEL_MODE_SET = new Set(CURSOR_MODEL_MODES);
 function isModelMode(value) {
   return MODEL_MODE_SET.has(value);
 }
@@ -403,6 +426,7 @@ function isModelModeForAgent(agent, mode) {
   if (!isModelMode(mode)) return false;
   if (agent === "claude") return CLAUDE_MODEL_MODE_SET.has(mode);
   if (agent === "gemini") return GEMINI_MODEL_MODE_SET.has(mode);
+  if (agent === "cursor") return CURSOR_MODEL_MODE_SET.has(mode);
   return CODEX_MODEL_MODE_SET.has(mode);
 }
 const CLAUDE_MODE_TO_SELECTION = {