happy-imou-cloud 2.0.10 → 2.0.11

package/dist/registerKillSessionHandler-Dxwg4L4J.mjs

@@ -0,0 +1,1179 @@
+import { i as initialMachineMetadata, e as projectPath, R as RuntimeShell, h as resolveCanonicalToolNameV2, f as formatDisplayMessage } from './index-DnsqY6I_.mjs';
+import { readSettings } from './persistence-BMa6cyw9.mjs';
+import os from 'node:os';
+import { resolve } from 'node:path';
+import { c as configuration, p as packageJson, l as logger } from './api-BcWf5v4i.mjs';
+import { randomUUID } from 'node:crypto';
+import { createHash } from 'crypto';
+import 'axios';
+import 'node:events';
+import 'socket.io-client';
+import 'tweetnacl';
+import 'fs/promises';
+import 'path';
+import 'node:child_process';
+import 'expo-server-sdk';
+import 'chalk';
+import './types-CiliQpqS.mjs';
+
+class MissingMachineIdError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MissingMachineIdError";
+  }
+}
+async function ensureManagedProviderMachine(opts) {
+  const settings = await (opts.loadSettings ?? readSettings)();
+  const machineId = settings?.machineId;
+  if (!machineId) {
+    throw new MissingMachineIdError(opts.missingMachineIdMessage);
+  }
+  await opts.api.getOrCreateMachine({
+    machineId,
+    metadata: opts.machineMetadata ?? initialMachineMetadata
+  });
+  return machineId;
+}
+
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const metadata = {
+    path: process.cwd(),
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyCloudHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: resolve(projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor
+  };
+  return { state, metadata };
+}
+
+async function launchRuntimeHandleWithFactoryResult(opts) {
+  const shell = opts.shell ?? new RuntimeShell();
+  let factoryResult;
+  const session = await shell.launch({
+    provider: opts.provider,
+    cwd: opts.cwd,
+    env: opts.env,
+    createBackend: (factoryOpts) => {
+      factoryResult = opts.createBackendResult(factoryOpts);
+      return factoryResult.backend;
+    }
+  });
+  if (factoryResult === void 0) {
+    throw new Error(`Runtime provider "${opts.provider}" did not create a backend result`);
+  }
+  return {
+    session,
+    factoryResult
+  };
+}
+
+function inferToolResultError(result) {
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const record = result;
+  if (record.isError === true || record.is_error === true) {
+    return true;
+  }
+  if (typeof record.error === "string" && record.error.trim().length > 0) {
+    return true;
+  }
+  if (record.success === false) {
+    return true;
+  }
+  const status = typeof record.status === "string" ? record.status.toLowerCase() : "";
+  return status === "failed" || status === "cancelled" || status === "error" || status === "denied" || status === "aborted";
+}
+
+function buildToolHappierMetaV2(input) {
+  return {
+    ...input,
+    v: 2
+  };
+}
+function attachToolHappierMetaV2(value, meta) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    _happier: buildToolHappierMetaV2(meta)
+  };
+}
+
+function getDefaultExecToolName(provider) {
+  switch (provider) {
+    case "claude":
+      return "ClaudeBash";
+    case "codex":
+      return "CodexBash";
+    case "gemini":
+      return "GeminiBash";
+  }
+}
+function getDefaultPatchToolName(provider) {
+  switch (provider) {
+    case "claude":
+      return "ClaudePatch";
+    case "codex":
+      return "CodexPatch";
+    case "gemini":
+      return "GeminiPatch";
+  }
+}
+function attachToolMeta(provider, rawToolName, value) {
+  const canonicalToolName = resolveCanonicalToolNameV2(rawToolName);
+  return attachToolHappierMetaV2(value, {
+    v: 2,
+    protocol: "acp",
+    provider,
+    rawToolName,
+    canonicalToolName
+  });
+}
+function forwardAgentMessageToProviderSession(msg, options) {
+  const createId = options.createId ?? randomUUID;
+  const toolResultType = options.toolResultType ?? "tool-result";
+  switch (msg.type) {
+    case "tool-call": {
+      options.send({
+        type: "tool-call",
+        name: resolveCanonicalToolNameV2(msg.toolName),
+        callId: msg.callId,
+        input: attachToolMeta(options.provider, msg.toolName, msg.args),
+        id: createId()
+      });
+      return true;
+    }
+    case "tool-result": {
+      options.send({
+        type: toolResultType,
+        callId: msg.callId,
+        output: attachToolMeta(options.provider, msg.toolName, msg.result),
+        id: createId(),
+        isError: inferToolResultError(msg.result)
+      });
+      return true;
+    }
+    case "fs-edit": {
+      options.send({
+        type: "file-edit",
+        description: msg.description,
+        diff: msg.diff,
+        filePath: msg.path || "unknown",
+        id: createId()
+      });
+      return true;
+    }
+    case "terminal-output": {
+      options.send({
+        type: "terminal-output",
+        data: msg.data,
+        callId: msg.callId ?? createId()
+      });
+      return true;
+    }
+    case "permission-request": {
+      const payload = msg.payload && typeof msg.payload === "object" ? msg.payload : {};
+      options.send({
+        type: "permission-request",
+        permissionId: msg.id,
+        toolName: typeof payload.toolName === "string" ? payload.toolName : msg.reason || "unknown",
+        description: msg.reason || (typeof payload.toolName === "string" ? payload.toolName : ""),
+        options: payload
+      });
+      return true;
+    }
+    case "exec-approval-request": {
+      const rawToolName = options.execToolName ?? getDefaultExecToolName(options.provider);
+      const { call_id, type: _type, ...inputs } = msg;
+      options.send({
+        type: "tool-call",
+        name: resolveCanonicalToolNameV2(rawToolName),
+        callId: call_id,
+        input: attachToolMeta(options.provider, rawToolName, inputs),
+        id: createId()
+      });
+      return true;
+    }
+    case "patch-apply-begin": {
+      const rawToolName = options.patchToolName ?? getDefaultPatchToolName(options.provider);
+      options.send({
+        type: "tool-call",
+        name: resolveCanonicalToolNameV2(rawToolName),
+        callId: msg.call_id,
+        input: attachToolMeta(options.provider, rawToolName, {
+          auto_approved: msg.auto_approved,
+          changes: msg.changes
+        }),
+        id: createId()
+      });
+      return true;
+    }
+    case "patch-apply-end": {
+      const rawToolName = options.patchToolName ?? getDefaultPatchToolName(options.provider);
+      options.send({
+        type: toolResultType,
+        callId: msg.call_id,
+        output: attachToolMeta(options.provider, rawToolName, {
+          stdout: msg.stdout,
+          stderr: msg.stderr,
+          success: msg.success
+        }),
+        id: createId(),
+        isError: !msg.success
+      });
+      return true;
+    }
+    case "token-count": {
+      const { type: _type, ...payload } = msg;
+      options.send({
+        type: "token_count",
+        ...payload,
+        id: createId()
+      });
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+async function closeProviderSession(session, opts = {}) {
+  let firstError;
+  const captureError = (error) => {
+    if (firstError === void 0) {
+      firstError = error;
+    }
+  };
+  if (opts.archiveReason) {
+    try {
+      session.updateMetadata((currentMetadata) => ({
+        ...currentMetadata,
+        lifecycleState: "archived",
+        lifecycleStateSince: Date.now(),
+        archivedBy: opts.archivedBy ?? "cli",
+        archiveReason: opts.archiveReason
+      }));
+    } catch (error) {
+      captureError(error);
+    }
+  }
+  try {
+    session.sendSessionDeath();
+  } catch (error) {
+    captureError(error);
+  }
+  try {
+    await session.flush();
+  } catch (error) {
+    captureError(error);
+  }
+  try {
+    await session.close();
+  } catch (error) {
+    captureError(error);
+  }
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+}
+
+function createAbortError() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+}
+async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs = 12e4) {
+  if (!backend.waitForResponseComplete) {
+    return;
+  }
+  if (signal.aborted) {
+    throw createAbortError();
+  }
+  await new Promise((resolve, reject) => {
+    const onAbort = () => reject(createAbortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    backend.waitForResponseComplete(timeoutMs).then(resolve).catch(reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+
+function supportsAgentStateUpdateEvents(sessionClient) {
+  return typeof sessionClient.once === "function" && typeof sessionClient.off === "function";
+}
+async function syncControlledByUserState(sessionClient, controlledByUser) {
+  if (!supportsAgentStateUpdateEvents(sessionClient)) {
+    sessionClient.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser
+    }));
+    return;
+  }
+  await new Promise((resolve) => {
+    let settled = false;
+    const handleUpdated = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      sessionClient.off("agent-state-updated", handleUpdated);
+      resolve();
+    };
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      sessionClient.off("agent-state-updated", handleUpdated);
+      resolve();
+    }, 1500);
+    sessionClient.once("agent-state-updated", handleUpdated);
+    sessionClient.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser
+    }));
+  });
+}
+
+const DEFAULT_MAX_MESSAGES = 200;
+const DEFAULT_MAX_CHARACTERS = 1e5;
+const DEFAULT_MAX_MESSAGE_CHARACTERS = 8e3;
+const TRUNCATION_PREFIX = "...\n";
+class MessageBuffer {
+  messages = [];
+  listeners = [];
+  nextId = 1;
+  enabled;
+  maxMessages;
+  maxCharacters;
+  maxMessageCharacters;
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? true;
+    this.maxMessages = Math.max(1, options.maxMessages ?? DEFAULT_MAX_MESSAGES);
+    this.maxCharacters = Math.max(1, options.maxCharacters ?? DEFAULT_MAX_CHARACTERS);
+    this.maxMessageCharacters = Math.max(1, options.maxMessageCharacters ?? DEFAULT_MAX_MESSAGE_CHARACTERS);
+  }
+  addMessage(content, type = "assistant") {
+    const id = `msg-${this.nextId++}`;
+    if (!this.enabled) {
+      return id;
+    }
+    const message = {
+      id,
+      timestamp: /* @__PURE__ */ new Date(),
+      content: this.normalizeContent(content),
+      type
+    };
+    this.messages.push(message);
+    this.trimMessages();
+    this.notifyListeners();
+    return message.id;
+  }
+  updateMessage(id, content, options = {}) {
+    if (!this.enabled) {
+      return false;
+    }
+    const index = this.messages.findIndex((message) => message.id === id);
+    if (index === -1) {
+      return false;
+    }
+    const normalizedContent = this.normalizeContent(content);
+    const previous = this.messages[index];
+    this.messages[index] = {
+      ...previous,
+      content: this.truncateContent(options.mode === "replace" ? normalizedContent : previous.content + normalizedContent)
+    };
+    this.trimMessages();
+    this.notifyListeners();
+    return true;
+  }
+  removeMessage(id) {
+    if (!this.enabled) {
+      return false;
+    }
+    const index = this.messages.findIndex((message) => message.id === id);
+    if (index === -1) {
+      return false;
+    }
+    this.messages.splice(index, 1);
+    this.notifyListeners();
+    return true;
+  }
+  /**
+   * 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") {
+    if (!this.enabled) {
+      return;
+    }
+    const normalizedDelta = this.normalizeContent(contentDelta);
+    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: this.truncateContent(oldMessage.content + normalizedDelta)
+        };
+        this.messages[i] = updatedMessage;
+        this.trimMessages();
+        this.notifyListeners();
+        return;
+      }
+    }
+    this.addMessage(normalizedDelta, type);
+  }
+  /**
+   * Remove the last message of a specific type
+   * Useful for removing placeholder messages like "Thinking..." when actual response starts
+   */
+  removeLastMessage(type) {
+    if (!this.enabled) {
+      return false;
+    }
+    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;
+    if (!this.enabled) {
+      return;
+    }
+    this.notifyListeners();
+  }
+  onUpdate(listener) {
+    if (!this.enabled) {
+      return () => {
+      };
+    }
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  normalizeContent(content) {
+    return this.truncateContent(formatDisplayMessage(content));
+  }
+  truncateContent(content) {
+    if (content.length <= this.maxMessageCharacters) {
+      return content;
+    }
+    const tailLength = Math.max(0, this.maxMessageCharacters - TRUNCATION_PREFIX.length);
+    return `${TRUNCATION_PREFIX}${content.slice(content.length - tailLength)}`;
+  }
+  trimMessages() {
+    while (this.messages.length > this.maxMessages) {
+      this.messages.shift();
+    }
+    let totalCharacters = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    while (totalCharacters > this.maxCharacters && this.messages.length > 1) {
+      const removed = this.messages.shift();
+      if (removed) {
+        totalCharacters -= removed.content.length;
+      }
+    }
+  }
+  notifyListeners() {
+    const messages = this.getMessages();
+    this.listeners.forEach((listener) => listener(messages));
+  }
+}
+
+let ConversationHistory$1 = class ConversationHistory {
+  messages = [];
+  maxMessages;
+  maxCharacters;
+  constructor(options = {}) {
+    this.maxMessages = options.maxMessages ?? 20;
+    this.maxCharacters = options.maxCharacters ?? 5e4;
+  }
+  isDuplicate(role, content) {
+    if (this.messages.length === 0) {
+      return false;
+    }
+    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+      const message = this.messages[index];
+      if (message.role !== role) {
+        continue;
+      }
+      const normalizedIncoming = content.trim().replace(/\s+/g, " ");
+      const normalizedExisting = message.content.replace(/\s+/g, " ");
+      return normalizedIncoming === normalizedExisting;
+    }
+    return false;
+  }
+  addUserMessage(content) {
+    this.addMessage("user", content);
+  }
+  addAssistantMessage(content) {
+    this.addMessage("assistant", content);
+  }
+  hasHistory() {
+    return this.messages.length > 0;
+  }
+  size() {
+    return this.messages.length;
+  }
+  clear() {
+    this.messages = [];
+    logger.debug("[ConversationHistory] History cleared");
+  }
+  getContextForNewSession(prefixMessage = "Continue from the prior session using the conversation below as context.") {
+    if (this.messages.length === 0) {
+      return "";
+    }
+    const formattedMessages = this.messages.map((message) => {
+      const role = message.role === "user" ? "User" : "Assistant";
+      const content = message.content.length > 2e3 ? `${message.content.slice(0, 2e3)}... [truncated]` : message.content;
+      return `${role}: ${content}`;
+    }).join("\n\n");
+    return [
+      "[PREVIOUS CONVERSATION CONTEXT]",
+      prefixMessage,
+      "",
+      formattedMessages,
+      "",
+      "[END OF PREVIOUS CONTEXT]",
+      ""
+    ].join("\n");
+  }
+  getSummary() {
+    const totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    const userCount = this.messages.filter((message) => message.role === "user").length;
+    const assistantCount = this.messages.filter((message) => message.role === "assistant").length;
+    return `${this.messages.length} messages (${userCount} user, ${assistantCount} assistant), ${totalChars} chars`;
+  }
+  addMessage(role, content) {
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
+      return;
+    }
+    if (this.isDuplicate(role, trimmedContent)) {
+      logger.debug(`[ConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
+      return;
+    }
+    this.messages.push({
+      role,
+      content: trimmedContent,
+      timestamp: Date.now()
+    });
+    this.trimHistory();
+    logger.debug(`[ConversationHistory] Added ${role} message (${trimmedContent.length} chars), total: ${this.messages.length}`);
+  }
+  trimHistory() {
+    while (this.messages.length > this.maxMessages) {
+      this.messages.shift();
+    }
+    let totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
+    while (totalChars > this.maxCharacters && this.messages.length > 1) {
+      const removed = this.messages.shift();
+      if (removed) {
+        totalChars -= removed.content.length;
+      }
+    }
+  }
+};
+
+const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
+const INTERACTION_TIMED_OUT_ERROR = "Interaction timed out waiting for user response";
+const DEFAULT_INTERACTION_TIMEOUT_MS = 2 * 60 * 1e3;
+function getPendingInteractionTimeoutMs() {
+  const raw = Number(process.env.HAPPY_INTERACTION_TIMEOUT_MS);
+  if (Number.isFinite(raw) && raw > 0) {
+    return raw;
+  }
+  return DEFAULT_INTERACTION_TIMEOUT_MS;
+}
+class BasePermissionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  isResetting = false;
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
+  }
+  /**
+   * Update the session reference (used after offline reconnection swaps sessions).
+   * This is critical for avoiding stale session references after onSessionSwap.
+   */
+  updateSession(newSession) {
+    logger.debug(`${this.getLogPrefix()} Session reference updated`);
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  /**
+   * Setup RPC handler for permission responses.
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+          logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
+          return;
+        }
+        this.pendingRequests.delete(response.id);
+        this.clearPendingRequestTimeout(pending);
+        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const request = currentState.requests?.[response.id];
+          if (!request) return currentState;
+          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+          let res = {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [response.id]: {
+                ...request,
+                completedAt: Date.now(),
+                status: response.approved ? "approved" : "denied",
+                decision: result.decision
+              }
+            }
+          };
+          return res;
+        });
+        logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
+      }
+    );
+  }
+  /**
+   * Add a pending request to the agent state.
+   */
+  addPendingRequestToState(toolCallId, toolName, input) {
+    this.session.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [toolCallId]: {
+          tool: toolName,
+          arguments: input,
+          createdAt: Date.now()
+        }
+      }
+    }));
+  }
+  registerPendingRequest(toolCallId, toolName, input, logSuffix = "") {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        toolName,
+        input
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handlePendingRequestTimeout(toolCallId, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(toolCallId, pending);
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})${logSuffix}`);
+    });
+  }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.resolve({ decision: "abort" });
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind === "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "denied",
+          reason,
+          decision: "abort",
+          requestKind: request.requestKind || "permission"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    logger.debug(`${this.getLogPrefix()} Superseded ${pendingSnapshot.length} pending permission request(s)`);
+    return pendingSnapshot.length;
+  }
+  /**
+   * Reset state for new sessions.
+   * This method is idempotent - safe to call multiple times.
+   */
+  reset() {
+    if (this.isResetting) {
+      logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
+      return;
+    }
+    this.isResetting = true;
+    try {
+      const pendingSnapshot = Array.from(this.pendingRequests.entries());
+      this.pendingRequests.clear();
+      for (const [id, pending] of pendingSnapshot) {
+        try {
+          this.clearPendingRequestTimeout(pending);
+          pending.reject(new Error("Session reset"));
+        } catch (err) {
+          logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
+        }
+      }
+      this.session.updateAgentState((currentState) => {
+        const pendingRequests = currentState.requests || {};
+        const completedRequests = { ...currentState.completedRequests };
+        for (const [id, request] of Object.entries(pendingRequests)) {
+          completedRequests[id] = {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: "Session reset"
+          };
+        }
+        return {
+          ...currentState,
+          requests: {},
+          completedRequests
+        };
+      });
+      logger.debug(`${this.getLogPrefix()} Permission handler reset`);
+    } finally {
+      this.isResetting = false;
+    }
+  }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handlePendingRequestTimeout(toolCallId, pending) {
+    const active = this.pendingRequests.get(toolCallId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(toolCallId);
+    this.clearPendingRequestTimeout(active);
+    active.resolve({ decision: "abort" });
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[toolCallId] || {
+        tool: active.toolName,
+        arguments: active.input,
+        createdAt: Date.now(),
+        requestKind: "permission"
+      };
+      const { [toolCallId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            decision: "abort",
+            requestKind: request.requestKind || "permission"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
+  }
+}
+
+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 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);
+      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);
+      }
+      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 registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
+export { BasePermissionHandler as B, ConversationHistory$1 as C, INTERACTION_SUPERSEDED_ERROR as I, MissingMachineIdError as M, INTERACTION_TIMED_OUT_ERROR as a, MessageQueue2 as b, createSessionMetadata as c, MessageBuffer as d, ensureManagedProviderMachine as e, closeProviderSession as f, getPendingInteractionTimeoutMs as g, hashObject as h, inferToolResultError as i, forwardAgentMessageToProviderSession as j, launchRuntimeHandleWithFactoryResult as l, registerKillSessionHandler as r, syncControlledByUserState as s, waitForResponseCompleteWithAbort as w };