happy-imou-cloud 2.0.13 → 2.0.16

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 require('chalk');
-require('./api-DH5-IqeM.cjs');
-require('./persistence-Bl3FYvwd.cjs');
+require('./api-Db1SQcP_.cjs');
+require('./persistence-Btu2VPXI.cjs');
 require('zod');
-require('./index-CryJfCh5.cjs');
+require('./index-B6ID1zDR.cjs');
 require('node:child_process');
 require('node:fs');
 require('cross-spawn');
@@ -17,6 +17,7 @@ require('os');
 require('child_process');
 require('node:path');
 require('node:os');
+require('node:readline');
 require('node:fs/promises');
 require('fs/promises');
 require('crypto');
@@ -34,7 +35,7 @@ require('ink');
 require('url');
 require('fastify');
 require('fastify-type-provider-zod');
-require('node:readline');
 require('http');
 require('util');
+require('node:url');
 

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import 'chalk';
-import './api-D1meoL-9.mjs';
-import './persistence-9Iu0wGNM.mjs';
+import './api-sRF6xXi-.mjs';
+import './persistence-B89V4xY5.mjs';
 import 'zod';
-import './index-Cxrx9m5D.mjs';
+import './index-DpWeKfvS.mjs';
 import 'node:child_process';
 import 'node:fs';
 import 'cross-spawn';
@@ -15,6 +15,7 @@ import 'os';
 import 'child_process';
 import 'node:path';
 import 'node:os';
+import 'node:readline';
 import 'node:fs/promises';
 import 'fs/promises';
 import 'crypto';
@@ -32,6 +33,6 @@ import 'ink';
 import 'url';
 import 'fastify';
 import 'fastify-type-provider-zod';
-import 'node:readline';
 import 'http';
 import 'util';
+import 'node:url';

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var api = require('./api-DH5-IqeM.cjs');
+var api = require('./api-Db1SQcP_.cjs');
 var types = require('./types-DVk3crez.cjs');
 require('axios');
 require('chalk');

package/dist/lib.mjs

@@ -1,4 +1,4 @@
-export { A as ApiClient, a as ApiSessionClient, c as configuration, l as logger } from './api-D1meoL-9.mjs';
+export { A as ApiClient, a as ApiSessionClient, c as configuration, l as logger } from './api-sRF6xXi-.mjs';
 export { R as RawJSONLinesSchema } from './types-CiliQpqS.mjs';
 import 'axios';
 import 'chalk';

package/dist/{persistence-9Iu0wGNM.mjs → persistence-B89V4xY5.mjs}

@@ -1,7 +1,7 @@
 import { unlink, readFile, mkdir, open, stat, writeFile, rename } from 'node:fs/promises';
 import { existsSync, unlinkSync, readdirSync, constants, writeFileSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { c as configuration, l as logger, e as encodeBase64 } from './api-D1meoL-9.mjs';
+import { c as configuration, l as logger, e as encodeBase64 } from './api-sRF6xXi-.mjs';
 import * as z from 'zod';
 import 'axios';
 import 'chalk';

package/dist/{persistence-Bl3FYvwd.cjs → persistence-Btu2VPXI.cjs}

@@ -3,7 +3,7 @@
 var promises = require('node:fs/promises');
 var fs = require('node:fs');
 var path = require('node:path');
-var api = require('./api-DH5-IqeM.cjs');
+var api = require('./api-Db1SQcP_.cjs');
 var z = require('zod');
 require('axios');
 require('chalk');

package/dist/{registerKillSessionHandler-BElGmD1E.mjs → registerKillSessionHandler-CwmYlUfS.mjs}

@@ -1,13 +1,13 @@
-import { i as initialMachineMetadata, p as projectPath, f as formatDisplayMessage } from './index-Cxrx9m5D.mjs';
-import { readSettings } from './persistence-9Iu0wGNM.mjs';
+import { i as initialMachineMetadata, e as projectPath, R as RuntimeShell, h as resolveCanonicalToolNameV2, f as formatDisplayMessage } from './index-DpWeKfvS.mjs';
+import { readSettings } from './persistence-B89V4xY5.mjs';
 import os from 'node:os';
 import { resolve } from 'node:path';
-import { c as configuration, p as packageJson, l as logger } from './api-D1meoL-9.mjs';
+import { c as configuration, p as packageJson, l as logger } from './api-sRF6xXi-.mjs';
+import { randomUUID } from 'node:crypto';
 import { createHash } from 'crypto';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import 'node:crypto';
 import 'tweetnacl';
 import 'fs/promises';
 import 'path';
@@ -59,6 +59,199 @@ function createSessionMetadata(opts) {
   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) => {
@@ -99,6 +292,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";
 }
@@ -294,6 +508,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 = [];
+    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
@@ -640,4 +1176,4 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   });
 }
 
-export { MissingMachineIdError as M, MessageQueue2 as a, MessageBuffer as b, closeProviderSession as c, createSessionMetadata as d, ensureManagedProviderMachine as e, hashObject as h, registerKillSessionHandler as r, syncControlledByUserState as s };
+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 };