happy-imou-cloud 2.0.13 → 2.0.16

package/dist/{registerKillSessionHandler-BjkY-oUn.cjs → registerKillSessionHandler-eZ2TsHqx.cjs}

@@ -1,15 +1,15 @@
 'use strict';
 
-var index = require('./index-CryJfCh5.cjs');
-var persistence = require('./persistence-Bl3FYvwd.cjs');
+var index = require('./index-B6ID1zDR.cjs');
+var persistence = require('./persistence-Btu2VPXI.cjs');
 var os = require('node:os');
 var path = require('node:path');
-var api = require('./api-DH5-IqeM.cjs');
+var api = require('./api-Db1SQcP_.cjs');
+var node_crypto = require('node:crypto');
 var crypto = require('crypto');
 require('axios');
 require('node:events');
 require('socket.io-client');
-require('node:crypto');
 require('tweetnacl');
 require('fs/promises');
 require('path');
@@ -61,6 +61,199 @@ function createSessionMetadata(opts) {
   return { state, metadata };
 }
 
+async function launchRuntimeHandleWithFactoryResult(opts) {
+  const shell = opts.shell ?? new index.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 = index.resolveCanonicalToolNameV2(rawToolName);
+  return attachToolHappierMetaV2(value, {
+    v: 2,
+    protocol: "acp",
+    provider,
+    rawToolName,
+    canonicalToolName
+  });
+}
+function forwardAgentMessageToProviderSession(msg, options) {
+  const createId = options.createId ?? node_crypto.randomUUID;
+  const toolResultType = options.toolResultType ?? "tool-result";
+  switch (msg.type) {
+    case "tool-call": {
+      options.send({
+        type: "tool-call",
+        name: index.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: index.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: index.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) => {
@@ -101,6 +294,27 @@ async function closeProviderSession(session, opts = {}) {
   }
 }
 
+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";
 }
@@ -296,6 +510,328 @@ class MessageBuffer {
   }
 }
 
+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 = [];
+    api.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)) {
+      api.logger.debug(`[ConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
+      return;
+    }
+    this.messages.push({
+      role,
+      content: trimmedContent,
+      timestamp: Date.now()
+    });
+    this.trimHistory();
+    api.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) {
+    api.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) {
+          api.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;
+        });
+        api.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);
+      api.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
+      };
+    });
+    api.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) {
+      api.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) {
+          api.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
+        };
+      });
+      api.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."
+    });
+    api.logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
+  }
+}
+
 class MessageQueue2 {
   queue = [];
   // Made public for testing
@@ -642,12 +1178,21 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   });
 }
 
+exports.BasePermissionHandler = BasePermissionHandler;
+exports.ConversationHistory = ConversationHistory$1;
+exports.INTERACTION_SUPERSEDED_ERROR = INTERACTION_SUPERSEDED_ERROR;
+exports.INTERACTION_TIMED_OUT_ERROR = INTERACTION_TIMED_OUT_ERROR;
 exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
 exports.MissingMachineIdError = MissingMachineIdError;
 exports.closeProviderSession = closeProviderSession;
 exports.createSessionMetadata = createSessionMetadata;
 exports.ensureManagedProviderMachine = ensureManagedProviderMachine;
+exports.forwardAgentMessageToProviderSession = forwardAgentMessageToProviderSession;
+exports.getPendingInteractionTimeoutMs = getPendingInteractionTimeoutMs;
 exports.hashObject = hashObject;
+exports.inferToolResultError = inferToolResultError;
+exports.launchRuntimeHandleWithFactoryResult = launchRuntimeHandleWithFactoryResult;
 exports.registerKillSessionHandler = registerKillSessionHandler;
 exports.syncControlledByUserState = syncControlledByUserState;
+exports.waitForResponseCompleteWithAbort = waitForResponseCompleteWithAbort;