very-happy-cli 0.2.159 → 0.2.160

package/dist/registerKillSessionHandler-DZeLXWcB.cjs

@@ -0,0 +1,361 @@
+'use strict';
+
+var logger = require('./logger-CS0mw3fa.cjs');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('./attachmentLimits-CzVrqgLR.cjs');
+require('node:crypto');
+require('tweetnacl');
+require('./configuration-BSYpcPwE.cjs');
+require('./index-DA7yINuk.cjs');
+require('./registerCommonHandlers-DskirN-_.cjs');
+require('os');
+require('child_process');
+require('@paralleldrive/cuid2');
+require('./persistence-yKTH3-5X.cjs');
+require('chalk');
+require('./types-CRS-srZK.cjs');
+
+class MessageQueue2 {
+  queue = [];
+  // Made public for testing
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  /**
+   * B-332: fired for every item the queue itself destroys before it was ever
+   * handed to the runner. The runner wires this to a queue-cancel tombstone
+   * so the web stops painting a silently-lost message as "queued".
+   */
+  onDiscardHandler = null;
+  /**
+   * B-509: fired when a consumer starts waiting on an EMPTY queue — the
+   * runner has finished its turn and has nothing to run. The server-side
+   * prompt queue drain uses it as its "idle" edge (utils/promptQueueDrain.ts).
+   */
+  onWaitHandler = null;
+  modeHasher;
+  constructor(modeHasher, onMessageHandler = null, onDiscardHandler = null) {
+    this.modeHasher = modeHasher;
+    this.onMessageHandler = onMessageHandler;
+    this.onDiscardHandler = onDiscardHandler;
+    logger.logger.debug(`[MessageQueue2] Initialized`);
+  }
+  /**
+   * Set a handler that will be called when a message arrives
+   */
+  setOnMessage(handler) {
+    this.onMessageHandler = handler;
+  }
+  /**
+   * Set a handler that will be called when messages are discarded without ever
+   * being processed (B-332).
+   */
+  setOnDiscard(handler) {
+    this.onDiscardHandler = handler;
+  }
+  /** B-509: observe the consumer blocking on an empty queue. */
+  setOnWait(handler) {
+    this.onWaitHandler = handler;
+  }
+  /** B-509: true while a consumer is blocked waiting for the next message. */
+  isWaiting() {
+    return this.waiter !== null;
+  }
+  /** Report the current items as destroyed for `reason` (caller clears next). */
+  notifyDiscard(reason) {
+    if (this.queue.length === 0) return;
+    const entries = this.queue.map((item) => ({ sourceId: item.sourceId, reason }));
+    this.onDiscardHandler?.(entries);
+  }
+  /**
+   * Push a message to the queue with a mode and an optional list of
+   * attachments that travel with this message.
+   */
+  push(message, mode, attachments, sourceId) {
+    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,
+      attachments,
+      sourceId
+    });
+    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, attachments, sourceId) {
+    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.notifyDiscard("cleared");
+    this.queue = [];
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: true,
+      attachments,
+      sourceId
+    });
+    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.notifyDiscard("aborted");
+    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;
+  }
+  /**
+   * Remove one message that has not yet been collected by the agent loop.
+   * Source id is authoritative. Exact-text fallback only covers items that
+   * entered this live process before transport ids were introduced.
+   */
+  cancelPending(sourceId, exactText) {
+    let index = sourceId ? this.queue.findIndex((item) => item.sourceId === sourceId) : -1;
+    if (index < 0 && exactText !== void 0) {
+      index = this.queue.findIndex((item) => item.sourceId === void 0 && item.message === exactText);
+    }
+    if (index < 0) return false;
+    this.queue.splice(index, 1);
+    logger.logger.debug(`[MessageQueue2] Cancelled pending item. Queue size: ${this.queue.length}`);
+    return true;
+  }
+  /**
+   * 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 = [];
+    const collectedAttachments = [];
+    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);
+      if (item.attachments) collectedAttachments.push(...item.attachments);
+      logger.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);
+        mode = item.mode;
+        if (item.attachments) collectedAttachments.push(...item.attachments);
+      }
+      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,
+      attachments: collectedAttachments.length > 0 ? collectedAttachments : void 0
+    };
+  }
+  /**
+   * 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...");
+      this.onWaitHandler?.();
+    });
+  }
+}
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEvents, options) {
+  let terminationStarted = false;
+  const terminateOnce = () => {
+    if (terminationStarted) return;
+    terminationStarted = true;
+    void killThisHappy();
+  };
+  archiveEvents.on("archived", terminateOnce);
+  if (options?.processSignals) {
+    process.on("SIGTERM", terminateOnce);
+    process.on("SIGINT", terminateOnce);
+  }
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.logger.debug("Kill session request received");
+    terminateOnce();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+  return () => {
+    archiveEvents.off?.("archived", terminateOnce);
+    if (options?.processSignals) {
+      process.off("SIGTERM", terminateOnce);
+      process.off("SIGINT", terminateOnce);
+    }
+  };
+}
+
+exports.MessageQueue2 = MessageQueue2;
+exports.registerKillSessionHandler = registerKillSessionHandler;

package/dist/registerKillSessionHandler-GYvHdipX.mjs

@@ -0,0 +1,358 @@
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import 'axios';
+import 'node:events';
+import 'socket.io-client';
+import './attachmentLimits-yba1uHFO.mjs';
+import 'node:crypto';
+import 'tweetnacl';
+import './configuration-RfeNjFmd.mjs';
+import './index-qdS1friN.mjs';
+import './registerCommonHandlers-Ccvsz7Ou.mjs';
+import 'os';
+import 'child_process';
+import '@paralleldrive/cuid2';
+import './persistence-HGW_ZVs9.mjs';
+import 'chalk';
+import './types-CkqAACXx.mjs';
+
+class MessageQueue2 {
+  queue = [];
+  // Made public for testing
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  /**
+   * B-332: fired for every item the queue itself destroys before it was ever
+   * handed to the runner. The runner wires this to a queue-cancel tombstone
+   * so the web stops painting a silently-lost message as "queued".
+   */
+  onDiscardHandler = null;
+  /**
+   * B-509: fired when a consumer starts waiting on an EMPTY queue — the
+   * runner has finished its turn and has nothing to run. The server-side
+   * prompt queue drain uses it as its "idle" edge (utils/promptQueueDrain.ts).
+   */
+  onWaitHandler = null;
+  modeHasher;
+  constructor(modeHasher, onMessageHandler = null, onDiscardHandler = null) {
+    this.modeHasher = modeHasher;
+    this.onMessageHandler = onMessageHandler;
+    this.onDiscardHandler = onDiscardHandler;
+    logger.debug(`[MessageQueue2] Initialized`);
+  }
+  /**
+   * Set a handler that will be called when a message arrives
+   */
+  setOnMessage(handler) {
+    this.onMessageHandler = handler;
+  }
+  /**
+   * Set a handler that will be called when messages are discarded without ever
+   * being processed (B-332).
+   */
+  setOnDiscard(handler) {
+    this.onDiscardHandler = handler;
+  }
+  /** B-509: observe the consumer blocking on an empty queue. */
+  setOnWait(handler) {
+    this.onWaitHandler = handler;
+  }
+  /** B-509: true while a consumer is blocked waiting for the next message. */
+  isWaiting() {
+    return this.waiter !== null;
+  }
+  /** Report the current items as destroyed for `reason` (caller clears next). */
+  notifyDiscard(reason) {
+    if (this.queue.length === 0) return;
+    const entries = this.queue.map((item) => ({ sourceId: item.sourceId, reason }));
+    this.onDiscardHandler?.(entries);
+  }
+  /**
+   * Push a message to the queue with a mode and an optional list of
+   * attachments that travel with this message.
+   */
+  push(message, mode, attachments, sourceId) {
+    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,
+      attachments,
+      sourceId
+    });
+    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, attachments, sourceId) {
+    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.notifyDiscard("cleared");
+    this.queue = [];
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: true,
+      attachments,
+      sourceId
+    });
+    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.notifyDiscard("aborted");
+    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;
+  }
+  /**
+   * Remove one message that has not yet been collected by the agent loop.
+   * Source id is authoritative. Exact-text fallback only covers items that
+   * entered this live process before transport ids were introduced.
+   */
+  cancelPending(sourceId, exactText) {
+    let index = sourceId ? this.queue.findIndex((item) => item.sourceId === sourceId) : -1;
+    if (index < 0 && exactText !== void 0) {
+      index = this.queue.findIndex((item) => item.sourceId === void 0 && item.message === exactText);
+    }
+    if (index < 0) return false;
+    this.queue.splice(index, 1);
+    logger.debug(`[MessageQueue2] Cancelled pending item. Queue size: ${this.queue.length}`);
+    return true;
+  }
+  /**
+   * 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 = [];
+    const collectedAttachments = [];
+    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);
+      if (item.attachments) collectedAttachments.push(...item.attachments);
+      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);
+        mode = item.mode;
+        if (item.attachments) collectedAttachments.push(...item.attachments);
+      }
+      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,
+      attachments: collectedAttachments.length > 0 ? collectedAttachments : void 0
+    };
+  }
+  /**
+   * 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...");
+      this.onWaitHandler?.();
+    });
+  }
+}
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEvents, options) {
+  let terminationStarted = false;
+  const terminateOnce = () => {
+    if (terminationStarted) return;
+    terminationStarted = true;
+    void killThisHappy();
+  };
+  archiveEvents.on("archived", terminateOnce);
+  if (options?.processSignals) {
+    process.on("SIGTERM", terminateOnce);
+    process.on("SIGINT", terminateOnce);
+  }
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.debug("Kill session request received");
+    terminateOnce();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+  return () => {
+    archiveEvents.off?.("archived", terminateOnce);
+    if (options?.processSignals) {
+      process.off("SIGTERM", terminateOnce);
+      process.off("SIGINT", terminateOnce);
+    }
+  };
+}
+
+export { MessageQueue2 as M, registerKillSessionHandler as r };