happy-imou-cloud 2.0.11 → 2.0.13

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

@@ -1,15 +1,15 @@
 'use strict';
 
-var index = require('./index-J7QKJ8lc.cjs');
-var persistence = require('./persistence-xK5CKhbn.cjs');
+var index = require('./index-CryJfCh5.cjs');
+var persistence = require('./persistence-Bl3FYvwd.cjs');
 var os = require('node:os');
 var path = require('node:path');
-var api = require('./api-Ye-rPX6s.cjs');
-var node_crypto = require('node:crypto');
+var api = require('./api-DH5-IqeM.cjs');
 var crypto = require('crypto');
 require('axios');
 require('node:events');
 require('socket.io-client');
+require('node:crypto');
 require('tweetnacl');
 require('fs/promises');
 require('path');
@@ -61,199 +61,6 @@ 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) => {
@@ -294,27 +101,6 @@ 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";
 }
@@ -510,328 +296,6 @@ 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
@@ -1178,21 +642,12 @@ 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;