happy-imou-cloud 2.1.1 → 2.1.3

package/dist/{index-66vjECEd.mjs → index-TRC83Ks9.mjs}

@@ -1,6 +1,6 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, q as decodeBase64, r as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-DBy5lPZw.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-BOWh1NER.mjs';
+import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, q as decodeBase64, r as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-BGv79x9Q.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-Cmgj3ubQ.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os, { homedir } from 'os';
@@ -4845,10 +4845,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;
@@ -4925,7 +4925,7 @@ class DefaultTransport {
     return toolName;
   }
   getPostPromptNoUpdatesTimeoutMs() {
-    return 3e4;
+    return 2 * 6e4;
   }
 }
 
@@ -4935,11 +4935,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
 };
@@ -5136,6 +5136,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");
@@ -5146,6 +5161,12 @@ class CodexTransport extends DefaultTransport {
   getIdleTimeout() {
     return 800;
   }
+  getToolCallTimeout(toolCallId, toolKind) {
+    if (toolKind === "execute") {
+      return resolveCodexExecuteTimeoutMs();
+    }
+    return super.getToolCallTimeout(toolCallId, toolKind);
+  }
 }
 new CodexTransport();
 
@@ -5176,7 +5197,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) {
@@ -5314,6 +5335,9 @@ function extractToolOutputChunk(content) {
   const formatted = formatDisplayMessage(content);
   return formatted.length > 0 ? formatted : null;
 }
+function hasVisibleToolCallProgress(content) {
+  return extractToolOutputChunk(content) !== null;
+}
 function mergeStreamedOutputWithResult(content, streamedOutput) {
   if (!streamedOutput || streamedOutput.length === 0) {
     return content;
@@ -5436,41 +5460,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}`;
-      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);
-    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
+    });
+    logger.debug(`[AcpBackend] \u23F1\uFE0F Set no-progress timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
   } else {
     logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
   }
@@ -5496,11 +5493,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);
   logger.debug(`[AcpBackend] \u2705 Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
@@ -5539,10 +5532,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) {
     logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
   } else {
     logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
@@ -5865,7 +5856,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) {
@@ -5902,6 +5893,15 @@ function getSessionUpdates(params) {
 function asNonNegativeFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 }
+function shouldRefreshProgressForToolCallUpdate(update, wasToolCallActive, isToolCallActive) {
+  if (!wasToolCallActive && isToolCallActive) {
+    return true;
+  }
+  if (update.status === "completed" || update.status === "failed" || update.status === "cancelled") {
+    return true;
+  }
+  return hasVisibleToolCallProgress(update.content);
+}
 function extractUsageTokens(record) {
   const used = asNonNegativeFiniteNumber(record.used);
   const size = asNonNegativeFiniteNumber(record.size);
@@ -6174,6 +6174,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 */
@@ -6198,6 +6199,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 */
@@ -6231,12 +6238,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}`;
+      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();
@@ -6246,6 +6351,7 @@ class AcpBackend {
     this.responseCompletionOutcome = null;
     this.responseCompletionError = null;
     this.sawSessionUpdateSincePrompt = false;
+    this.resetResponseWaitTracking();
     this.clearIdleTimeoutState();
     this.clearPostPromptCompletionIdleTimeout();
     this.clearToolCallTracking();
@@ -6257,6 +6363,7 @@ class AcpBackend {
     this.responseCompletionError = error;
     this.responseCompletionOutcome = null;
     this.waitingForResponse = false;
+    this.resetResponseWaitTracking();
     this.clearPostPromptCompletionIdleTimeout();
     if (this.idleRejecter) {
       this.idleRejecter(error);
@@ -6266,6 +6373,7 @@ class AcpBackend {
   }
   settleResponseWaiter(outcome) {
     const hasActiveWaiter = Boolean(this.idleResolver || this.idleRejecter);
+    this.resetResponseWaitTracking();
     if (!this.waitingForResponse && !hasActiveWaiter) {
       return;
     }
@@ -6737,6 +6845,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);
@@ -6788,8 +6898,12 @@ ${recentStderrExcerpt}`);
         }, null, 2));
       }
       const ctx = this.createHandlerContext();
+      const toolCallId = update.toolCallId;
+      const wasToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
       if (sessionUpdateType === "agent_message_chunk") {
-        handleAgentMessageChunk(update, ctx);
+        if (handleAgentMessageChunk(update, ctx).handled) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "tool_call_update") {
@@ -6797,14 +6911,24 @@ ${recentStderrExcerpt}`);
         if (result.toolCallCountSincePrompt !== void 0) {
           this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
         }
+        const isToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+        if (shouldRefreshProgressForToolCallUpdate(update, wasToolCallActive, isToolCallActive)) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "agent_thought_chunk") {
-        handleAgentThoughtChunk(update, ctx);
+        if (handleAgentThoughtChunk(update, ctx).handled) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "tool_call") {
-        handleToolCall(update, ctx);
+        const result = handleToolCall(update, ctx);
+        const isToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+        if (result.handled && !wasToolCallActive && isToolCallActive) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "usage_update") {
@@ -6822,6 +6946,9 @@ ${recentStderrExcerpt}`);
       const handledPlan = handlePlanUpdate(update, ctx).handled;
       const handledThinking = handleThinkingUpdate(update, ctx).handled;
       const handledUsage = this.emitUsageTelemetry(update.usage, "acp-session-usage");
+      if (handledLegacy || handledPlan || handledThinking) {
+        this.markResponseProgress();
+      }
       const updateTypeStr = sessionUpdateType;
       const handledTypes = ["agent_message_chunk", "tool_call_update", "agent_thought_chunk", "tool_call", "usage_update", "task_complete"];
       if (updateTypeStr && !handledTypes.includes(updateTypeStr) && !handledLegacy && !handledPlan && !handledThinking && !handledUsage) {
@@ -6840,6 +6967,7 @@ ${recentStderrExcerpt}`);
     this.resetResponseTrackingForNewPrompt();
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
+    this.markResponseProgress({ refreshToolTimeouts: false });
     try {
       logger.debug(`[AcpBackend] Sending prompt (length: ${prompt.length}): ${prompt.substring(0, 100)}...`);
       logger.debug(`[AcpBackend] Full prompt: ${prompt}`);
@@ -6900,7 +7028,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;
     }
@@ -6916,26 +7044,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);
     });
   }
   /**
@@ -8421,7 +8542,7 @@ class ClaudeCodeBackend {
       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") {
@@ -9001,11 +9122,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await import('./runClaude-B74dHAnQ.mjs');
+    const { runClaude } = await import('./runClaude-7St9-Jci.mjs');
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-mLHjsgVj.mjs');
+    const { runCodex } = await import('./runCodex-BaXi_9BC.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9014,7 +9135,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-BMiho2ab.mjs');
+    const { runGemini } = await import('./runGemini-ClNqE9N3.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9090,7 +9211,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-CeaBwYCW.mjs');
+      const { renderRuntimeProviders } = await import('./command-FbV44egL.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9268,8 +9389,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-BOWh1NER.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-DBy5lPZw.mjs').then(function (n) { return n.v; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-Cmgj3ubQ.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-BGv79x9Q.mjs').then(function (n) { return n.v; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 require('chalk');
-require('./api-DId_j3C2.cjs');
-require('./persistence-Dzr6sFwD.cjs');
+require('./api-OoiG7XjD.cjs');
+require('./persistence-lN9HV4IZ.cjs');
 require('zod');
-require('./index-CuuYSKiv.cjs');
+require('./index-D9lWHpn-.cjs');
 require('node:child_process');
 require('node:fs');
 require('cross-spawn');

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import 'chalk';
-import './api-DBy5lPZw.mjs';
-import './persistence-BOWh1NER.mjs';
+import './api-BGv79x9Q.mjs';
+import './persistence-Cmgj3ubQ.mjs';
 import 'zod';
-import './index-66vjECEd.mjs';
+import './index-TRC83Ks9.mjs';
 import 'node:child_process';
 import 'node:fs';
 import 'cross-spawn';

package/dist/lib.cjs

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