happy-imou-cloud 2.1.1 → 2.1.2

package/dist/{index-CuuYSKiv.cjs → index-Cuvs0lFS.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chalk = require('chalk');
-var api = require('./api-DId_j3C2.cjs');
-var persistence = require('./persistence-Dzr6sFwD.cjs');
+var api = require('./api-DZimmN4C.cjs');
+var persistence = require('./persistence-C8-MtdQK.cjs');
 var z = require('zod');
 var fs$2 = require('fs/promises');
 var os$1 = require('os');
@@ -72,7 +72,7 @@ async function openBrowser(url) {
   }
 }
 
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CuuYSKiv.cjs', document.baseURI).href)));
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Cuvs0lFS.cjs', document.baseURI).href)));
 const QRCode = require$1("qrcode-terminal/vendor/QRCode");
 const QRErrorCorrectLevel = require$1("qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel");
 const pendingTempFiles = /* @__PURE__ */ new Set();
@@ -695,7 +695,7 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$2 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CuuYSKiv.cjs', document.baseURI).href))));
+const __dirname$2 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Cuvs0lFS.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$2, "..");
   return path;
@@ -4867,10 +4867,10 @@ function truncateDisplayMessage(value, maxLength) {
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */
   init: 6e4,
-  /** Default tool call timeout: 2 minutes */
-  toolCall: 12e4,
-  /** Think tool timeout: 30 seconds */
-  think: 3e4
+  /** Default tool call timeout: 10 minutes */
+  toolCall: 10 * 6e4,
+  /** Think tool timeout: 2 minutes */
+  think: 2 * 6e4
 };
 class DefaultTransport {
   agentName;
@@ -4947,7 +4947,7 @@ class DefaultTransport {
     return toolName;
   }
   getPostPromptNoUpdatesTimeoutMs() {
-    return 3e4;
+    return 2 * 6e4;
   }
 }
 
@@ -4957,11 +4957,11 @@ const GEMINI_TIMEOUTS = {
   /** Gemini ACP can swallow an initialize request sent too early after spawn */
   initDelay: 2500,
   /** Standard tool call timeout */
-  toolCall: 12e4,
+  toolCall: 10 * 6e4,
   /** Investigation tools (codebase_investigator) can run for a long time */
-  investigation: 6e5,
+  investigation: 30 * 6e4,
   /** Think tools are usually quick */
-  think: 3e4,
+  think: 2 * 6e4,
   /** Idle detection after last message chunk */
   idle: 500
 };
@@ -5158,6 +5158,21 @@ class GeminiTransport {
 }
 const geminiTransport = new GeminiTransport();
 
+const DEFAULT_CODEX_EXECUTE_TIMEOUT_MS = 30 * 6e4;
+function readPositiveIntegerEnv$1(name) {
+  const raw = typeof process.env[name] === "string" ? process.env[name].trim() : "";
+  if (!raw) {
+    return null;
+  }
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function resolveCodexExecuteTimeoutMs() {
+  return readPositiveIntegerEnv$1("HAPPY_CODEX_EXECUTE_TIMEOUT_MS") ?? readPositiveIntegerEnv$1("HAPPIER_CODEX_EXECUTE_TIMEOUT_MS") ?? DEFAULT_CODEX_EXECUTE_TIMEOUT_MS;
+}
 class CodexTransport extends DefaultTransport {
   constructor() {
     super("codex");
@@ -5168,6 +5183,12 @@ class CodexTransport extends DefaultTransport {
   getIdleTimeout() {
     return 800;
   }
+  getToolCallTimeout(toolCallId, toolKind) {
+    if (toolKind === "execute") {
+      return resolveCodexExecuteTimeoutMs();
+    }
+    return super.getToolCallTimeout(toolCallId, toolKind);
+  }
 }
 new CodexTransport();
 
@@ -5198,7 +5219,7 @@ class CursorTransport extends DefaultTransport {
 const cursorTransport = new CursorTransport();
 
 const DEFAULT_IDLE_TIMEOUT_MS = 500;
-const DEFAULT_TOOL_CALL_TIMEOUT_MS = 12e4;
+const DEFAULT_TOOL_CALL_TIMEOUT_MS = 10 * 6e4;
 const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_HEAD_BYTES = 2e3;
 const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_TAIL_BYTES = 4e3;
 function parseArgsFromContent(content) {
@@ -5458,41 +5479,14 @@ function startToolCall(toolCallId, toolKind, update, ctx, source) {
   }
   const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
   if (!ctx.toolCallTimeouts.has(toolCallId)) {
-    const timeout = setTimeout(() => {
-      const duration = formatDuration(ctx.toolCallStartTimes.get(toolCallId));
-      const timeoutLabel = formatToolCallTimeoutLimit(timeoutMs);
-      const timeoutDetail = `Tool call ${realToolName} timed out after ${timeoutLabel}`;
-      api.logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${source}): ${toolCallId} (${toolKind}) after ${timeoutLabel} - Duration: ${duration}, failing current turn`);
-      ctx.activeToolCalls.delete(toolCallId);
-      ctx.toolCallStartTimes.delete(toolCallId);
-      ctx.toolCallTimeouts.delete(toolCallId);
-      ctx.clearIdleTimeout();
-      const streamedOutput = renderToolOutput(ctx.toolCallOutputs.get(toolCallId));
-      ctx.toolCallOutputs.delete(toolCallId);
-      ctx.emit({
-        type: "tool-result",
-        toolName: realToolName,
-        result: streamedOutput ? {
-          stdout: streamedOutput,
-          error: timeoutDetail,
-          status: "failed",
-          timedOut: true
-        } : {
-          error: timeoutDetail,
-          status: "failed",
-          timedOut: true
-        },
-        callId: toolCallId
-      });
-      ctx.emit({
-        type: "status",
-        status: "error",
-        detail: timeoutDetail
-      });
-      ctx.failPendingResponseWait(new Error(timeoutDetail));
-    }, timeoutMs);
-    ctx.toolCallTimeouts.set(toolCallId, timeout);
-    api.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
+    ctx.armToolCallTimeout({
+      toolCallId,
+      toolKind,
+      toolName: realToolName,
+      timeoutMs,
+      source
+    });
+    api.logger.debug(`[AcpBackend] \u23F1\uFE0F Set no-progress timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
   } else {
     api.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
   }
@@ -5518,11 +5512,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
   const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
-  const timeout = ctx.toolCallTimeouts.get(toolCallId);
-  if (timeout) {
-    clearTimeout(timeout);
-    ctx.toolCallTimeouts.delete(toolCallId);
-  }
+  ctx.clearToolCallTimeout(toolCallId);
   const streamedOutput = renderToolOutput(ctx.toolCallOutputs.get(toolCallId));
   ctx.toolCallOutputs.delete(toolCallId);
   api.logger.debug(`[AcpBackend] \u2705 Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
@@ -5561,10 +5551,8 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   }
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
-  const timeout = ctx.toolCallTimeouts.get(toolCallId);
-  if (timeout) {
-    clearTimeout(timeout);
-    ctx.toolCallTimeouts.delete(toolCallId);
+  const clearedTimeout = ctx.clearToolCallTimeout(toolCallId);
+  if (clearedTimeout) {
     api.logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
   } else {
     api.logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
@@ -5887,7 +5875,7 @@ const RETRY_CONFIG = {
   /** Maximum delay between retries in ms */
   maxDelayMs: 5e3
 };
-const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS = 3e4;
+const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS = 2 * 6e4;
 function readPositiveIntegerEnv(name) {
   const raw = typeof process.env[name] === "string" ? process.env[name].trim() : "";
   if (!raw) {
@@ -6196,6 +6184,7 @@ class AcpBackend {
   /** Track active tool calls to prevent duplicate events */
   activeToolCalls = /* @__PURE__ */ new Set();
   toolCallTimeouts = /* @__PURE__ */ new Map();
+  toolCallTimeoutSpecs = /* @__PURE__ */ new Map();
   /** Track tool call start times for performance monitoring */
   toolCallStartTimes = /* @__PURE__ */ new Map();
   /** Track streamed tool output between ACP updates and final completion */
@@ -6220,6 +6209,12 @@ class AcpBackend {
   waitingForResponse = false;
   /** First fatal prompt-level error observed for the current turn */
   responseCompletionError = null;
+  /** Resettable no-progress timeout while waiting for a turn to finish */
+  responseWaitTimeout = null;
+  /** Current inactivity threshold used by waitForResponseComplete */
+  responseWaitTimeoutMs = null;
+  /** Timestamp of the last meaningful response progress for the current turn */
+  responseLastProgressAt = null;
   /** Fallback completion when prompt returns but the agent emits no session updates */
   postPromptCompletionIdleTimeout = null;
   /** Whether at least one session/update arrived after the current prompt */
@@ -6253,12 +6248,110 @@ class AcpBackend {
       this.postPromptCompletionIdleTimeout = null;
     }
   }
+  clearResponseWaitTimeout() {
+    if (this.responseWaitTimeout) {
+      clearTimeout(this.responseWaitTimeout);
+      this.responseWaitTimeout = null;
+    }
+  }
+  resetResponseWaitTracking() {
+    this.clearResponseWaitTimeout();
+    this.responseWaitTimeoutMs = null;
+    this.responseLastProgressAt = null;
+  }
+  armResponseWaitTimeout(timeoutMs) {
+    this.responseWaitTimeoutMs = timeoutMs;
+    this.clearResponseWaitTimeout();
+    const lastProgressAt = this.responseLastProgressAt ?? Date.now();
+    const elapsedMs = Math.max(0, Date.now() - lastProgressAt);
+    const remainingMs = Math.max(1, timeoutMs - elapsedMs);
+    this.responseWaitTimeout = setTimeout(() => {
+      this.responseWaitTimeout = null;
+      this.responseWaitTimeoutMs = null;
+      this.failPendingResponseWait(new Error("Timeout waiting for response to complete"));
+    }, remainingMs);
+  }
+  scheduleToolCallTimeout(toolCallId) {
+    const spec = this.toolCallTimeoutSpecs.get(toolCallId);
+    if (!spec) {
+      return;
+    }
+    const existing = this.toolCallTimeouts.get(toolCallId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timeout = setTimeout(() => {
+      const duration = formatDuration(this.toolCallStartTimes.get(toolCallId));
+      const timeoutLabel = formatToolCallTimeoutLimit(spec.timeoutMs);
+      const timeoutDetail = `Tool call ${spec.toolName} timed out after ${timeoutLabel}`;
+      api.logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${spec.source}): ${toolCallId} (${spec.toolKind}) after ${timeoutLabel} without progress - Duration: ${duration}, failing current turn`);
+      this.activeToolCalls.delete(toolCallId);
+      this.toolCallStartTimes.delete(toolCallId);
+      this.clearToolCallTimeout(toolCallId);
+      this.clearIdleTimeoutState();
+      const streamedOutput = renderToolOutput(this.toolCallOutputs.get(toolCallId));
+      this.toolCallOutputs.delete(toolCallId);
+      this.emit({
+        type: "tool-result",
+        toolName: spec.toolName,
+        result: streamedOutput ? {
+          stdout: streamedOutput,
+          error: timeoutDetail,
+          status: "failed",
+          timedOut: true
+        } : {
+          error: timeoutDetail,
+          status: "failed",
+          timedOut: true
+        },
+        callId: toolCallId
+      });
+      this.emit({
+        type: "status",
+        status: "error",
+        detail: timeoutDetail
+      });
+      this.failPendingResponseWait(new Error(timeoutDetail));
+    }, spec.timeoutMs);
+    this.toolCallTimeouts.set(toolCallId, timeout);
+  }
+  armToolCallTimeout(spec) {
+    this.toolCallTimeoutSpecs.set(spec.toolCallId, spec);
+    this.scheduleToolCallTimeout(spec.toolCallId);
+  }
+  clearToolCallTimeout(toolCallId) {
+    const timeout = this.toolCallTimeouts.get(toolCallId);
+    const hadTimeout = Boolean(timeout);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.toolCallTimeouts.delete(toolCallId);
+    }
+    this.toolCallTimeoutSpecs.delete(toolCallId);
+    return hadTimeout;
+  }
+  refreshActiveToolCallTimeouts() {
+    for (const toolCallId of this.activeToolCalls) {
+      if (this.toolCallTimeoutSpecs.has(toolCallId)) {
+        this.scheduleToolCallTimeout(toolCallId);
+      }
+    }
+  }
+  markResponseProgress(opts = {}) {
+    this.responseLastProgressAt = Date.now();
+    if (opts.refreshToolTimeouts !== false) {
+      this.refreshActiveToolCallTimeouts();
+    }
+    if (this.waitingForResponse && this.responseWaitTimeoutMs != null) {
+      this.armResponseWaitTimeout(this.responseWaitTimeoutMs);
+    }
+  }
   clearToolCallTracking() {
     this.activeToolCalls.clear();
     for (const timeout of this.toolCallTimeouts.values()) {
       clearTimeout(timeout);
     }
     this.toolCallTimeouts.clear();
+    this.toolCallTimeoutSpecs.clear();
     this.toolCallStartTimes.clear();
     this.toolCallIdToNameMap.clear();
     this.toolCallOutputs.clear();
@@ -6268,6 +6361,7 @@ class AcpBackend {
     this.responseCompletionOutcome = null;
     this.responseCompletionError = null;
     this.sawSessionUpdateSincePrompt = false;
+    this.resetResponseWaitTracking();
     this.clearIdleTimeoutState();
     this.clearPostPromptCompletionIdleTimeout();
     this.clearToolCallTracking();
@@ -6279,6 +6373,7 @@ class AcpBackend {
     this.responseCompletionError = error;
     this.responseCompletionOutcome = null;
     this.waitingForResponse = false;
+    this.resetResponseWaitTracking();
     this.clearPostPromptCompletionIdleTimeout();
     if (this.idleRejecter) {
       this.idleRejecter(error);
@@ -6288,6 +6383,7 @@ class AcpBackend {
   }
   settleResponseWaiter(outcome) {
     const hasActiveWaiter = Boolean(this.idleResolver || this.idleRejecter);
+    this.resetResponseWaitTracking();
     if (!this.waitingForResponse && !hasActiveWaiter) {
       return;
     }
@@ -6759,6 +6855,8 @@ ${recentStderrExcerpt}`);
       emit: (msg) => this.emit(msg),
       emitIdleStatus: () => this.emitIdleStatus(),
       failPendingResponseWait: (error) => this.failPendingResponseWait(error),
+      armToolCallTimeout: (spec) => this.armToolCallTimeout(spec),
+      clearToolCallTimeout: (toolCallId) => this.clearToolCallTimeout(toolCallId),
       clearIdleTimeout: () => {
         if (this.idleTimeout) {
           clearTimeout(this.idleTimeout);
@@ -6799,6 +6897,7 @@ ${recentStderrExcerpt}`);
     this.clearPostPromptCompletionIdleTimeout();
     for (const update of updates) {
       const sessionUpdateType = update.sessionUpdate;
+      this.markResponseProgress();
       if (sessionUpdateType !== "agent_message_chunk" && sessionUpdateType !== "tool_call_update") {
         api.logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
           sessionUpdate: sessionUpdateType,
@@ -6862,6 +6961,7 @@ ${recentStderrExcerpt}`);
     this.resetResponseTrackingForNewPrompt();
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
+    this.markResponseProgress({ refreshToolTimeouts: false });
     try {
       api.logger.debug(`[AcpBackend] Sending prompt (length: ${prompt.length}): ${prompt.substring(0, 100)}...`);
       api.logger.debug(`[AcpBackend] Full prompt: ${prompt}`);
@@ -6922,7 +7022,7 @@ ${recentStderrExcerpt}`);
    * Wait for the response to complete (idle status after all chunks received)
    * Call this after sendPrompt to wait for Gemini to finish responding
    */
-  async waitForResponseComplete(timeoutMs = 12e4) {
+  async waitForResponseComplete(timeoutMs = 10 * 6e4) {
     if (this.responseCompletionError) {
       throw this.responseCompletionError;
     }
@@ -6938,26 +7038,19 @@ ${recentStderrExcerpt}`);
       return;
     }
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.idleResolver = null;
-        this.idleRejecter = null;
-        this.waitingForResponse = false;
-        reject(new Error("Timeout waiting for response to complete"));
-      }, timeoutMs);
       this.idleResolver = () => {
-        clearTimeout(timeout);
         this.idleResolver = null;
         this.idleRejecter = null;
         this.waitingForResponse = false;
         resolve();
       };
       this.idleRejecter = (error) => {
-        clearTimeout(timeout);
         this.idleResolver = null;
         this.idleRejecter = null;
         this.waitingForResponse = false;
         reject(error);
       };
+      this.armResponseWaitTimeout(timeoutMs);
     });
   }
   /**
@@ -7772,7 +7865,7 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CuuYSKiv.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Cuvs0lFS.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
@@ -8443,7 +8536,7 @@ class ClaudeCodeBackend {
       api.logger.debug("[ClaudeRuntimeBackend] Error interrupting Claude query:", error);
     }
   }
-  async waitForResponseComplete(timeoutMs = 12e4) {
+  async waitForResponseComplete(timeoutMs = 10 * 6e4) {
     if (this.responseCompletionOutcome) {
       const outcome = this.responseCompletionOutcome;
       if (outcome.kind === "rejected") {
@@ -9023,11 +9116,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-oIFzkfuU.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-DVnqKa1q.cjs'); });
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-D_9CuL6M.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-Bzsp8gFO.cjs'); });
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9036,7 +9129,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-CcWGezMt.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-6Dwyk_Km.cjs'); });
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9112,7 +9205,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-DwfUpmId.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-RcCJI1jl.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9290,8 +9383,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-Dzr6sFwD.cjs'); });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-DId_j3C2.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-C8-MtdQK.cjs'); });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-DZimmN4C.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();