happy-imou-cloud 2.1.47 → 2.1.49

package/dist/{index-CyW9A7hx.cjs → index-xa1kwZoj.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var chalk = require('chalk');
-var persistence = require('./api-CVuTajTL.cjs');
+var persistence = require('./api-D7nAeZi7.cjs');
 var z = require('zod');
 var fs$2 = require('fs/promises');
 var os$1 = require('os');
@@ -52,7 +52,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-CyW9A7hx.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-xa1kwZoj.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();
@@ -617,7 +617,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-CyW9A7hx.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-xa1kwZoj.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$2, "..");
   return path;
@@ -1569,7 +1569,8 @@ function startDaemonControlServer({
         body: z.z.object({
           directory: z.z.string(),
           sessionId: z.z.string().optional(),
-          agent: z.z.enum(["claude", "codex", "gemini"]).optional()
+          agent: z.z.enum(["claude", "codex", "gemini"]).optional(),
+          launchMode: z.z.enum(["background", "terminalWindow", "localTerminal"]).optional()
         }),
         response: {
           200: z.z.object({
@@ -1590,9 +1591,9 @@ function startDaemonControlServer({
         }
       }
     }, async (request, reply) => {
-      const { directory, sessionId, agent } = request.body;
-      persistence.logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}, agent=${agent || "claude"}`);
-      const result = await spawnSession({ directory, sessionId, agent });
+      const { directory, sessionId, agent, launchMode } = request.body;
+      persistence.logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}, agent=${agent || "claude"}, launchMode=${launchMode || "background"}`);
+      const result = await spawnSession({ directory, sessionId, agent, launchMode });
       switch (result.type) {
         case "success":
           if (!result.sessionId) {
@@ -2336,20 +2337,37 @@ function resolveDaemonSpawnAgent(agent) {
       throw new Error(`Unsupported agent type: '${agent}'. Please update your CLI to the latest version.`);
   }
 }
-function buildDaemonSpawnArgs(agent, resume) {
+function buildDaemonSpawnArgs(agent, optionsOrResume) {
+  const options = isLegacyResumeOptions(optionsOrResume) ? { resume: optionsOrResume } : optionsOrResume ?? {};
+  const startingMode = options.startingMode ?? "remote";
+  const startedBy = options.startedBy ?? "daemon";
+  const resolvedAgent = resolveDaemonSpawnAgent(agent);
   const args = [
-    resolveDaemonSpawnAgent(agent),
+    resolvedAgent,
     "--happy-starting-mode",
-    "remote",
+    startingMode,
     "--started-by",
-    "daemon"
+    startedBy
   ];
-  const providerSessionId = typeof resume?.providerSessionId === "string" ? resume.providerSessionId.trim() : "";
-  if (providerSessionId.length > 0) {
+  const providerSessionId = typeof options.resume?.providerSessionId === "string" ? options.resume.providerSessionId.trim() : "";
+  if (providerSessionId.length > 0 && supportsProviderResumeArg(resolvedAgent)) {
     args.push("--resume", providerSessionId);
   }
   return args;
 }
+function supportsProviderResumeArg(agent) {
+  return agent === "claude" || agent === "codex";
+}
+function buildTerminalWindowSpawnArgs(agent, resume) {
+  return buildDaemonSpawnArgs(agent, {
+    resume,
+    startingMode: "local",
+    startedBy: "terminal"
+  });
+}
+function isLegacyResumeOptions(value) {
+  return Boolean(value && "providerSessionId" in value);
+}
 
 const SPAWN_SESSION_ERROR_CODES = {
   INVALID_REQUEST: "INVALID_REQUEST",
@@ -2412,6 +2430,157 @@ function buildDaemonChildEnv(baseEnv, extraEnv) {
   return childEnv;
 }
 
+function quotePosix(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function quoteAppleScriptString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function quoteWindowsCmd(value) {
+  return `"${value.replace(/(["^&|<>()%])/g, "^$1")}"`;
+}
+function buildRuntimeInvocation(args, platform, entrypointOverride) {
+  const projectRoot = projectPath();
+  const entrypoint = entrypointOverride || path.join(projectRoot, "dist", "index.mjs");
+  const runtime = isBun() ? "bun" : "node";
+  const runtimeArgs = ["--no-warnings", "--no-deprecation", entrypoint, ...args];
+  const commandParts = [runtime, ...runtimeArgs];
+  if (platform === "win32") {
+    return commandParts.map(quoteWindowsCmd).join(" ");
+  }
+  return commandParts.map(quotePosix).join(" ");
+}
+function buildUserFacingPreview(args) {
+  const agent = args[0];
+  if (agent === "claude" || agent === "codex" || agent === "gemini") {
+    return `hicloud ${agent}`;
+  }
+  return `hicloud ${args.join(" ")}`.trim();
+}
+function buildPathWithProjectBin(env, platform) {
+  const binPath = path.join(projectPath(), "node_modules", ".bin");
+  const pathDelimiter = platform === "win32" ? ";" : path.delimiter;
+  const currentPath = env?.PATH || env?.Path || process.env.PATH || "";
+  return currentPath ? `${binPath}${pathDelimiter}${currentPath}` : binPath;
+}
+function isValidEnvironmentVariableName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+function escapeWindowsBatchSetValue(value) {
+  return value.replace(/\r?\n/g, "").replace(/%/g, "%%");
+}
+function collectLaunchEnv(env, platform) {
+  const result = {};
+  for (const [key, value] of Object.entries(env || {})) {
+    if (typeof value === "string" && isValidEnvironmentVariableName(key)) {
+      result[key] = value;
+    }
+  }
+  result.PATH = buildPathWithProjectBin(env, platform);
+  return result;
+}
+function buildTerminalLaunchScriptContent(options) {
+  const platform = options.platform || process.platform;
+  const launchEnv = collectLaunchEnv(options.env, platform);
+  const preview = buildUserFacingPreview(options.args);
+  const runtimeInvocation = buildRuntimeInvocation(options.args, platform, options.entrypoint);
+  if (platform === "win32") {
+    const envLines2 = Object.entries(launchEnv).map(([key, value]) => `set "${key}=${escapeWindowsBatchSetValue(value)}"`).join("\r\n");
+    return [
+      "@echo off",
+      "setlocal",
+      envLines2,
+      `cd /d ${quoteWindowsCmd(options.cwd)}`,
+      `echo $ ${preview}`,
+      runtimeInvocation,
+      "echo.",
+      "echo Happy session command exited. You can close this window.",
+      'del "%~f0" >nul 2>nul',
+      "endlocal",
+      ""
+    ].join("\r\n");
+  }
+  const envLines = Object.entries(launchEnv).map(([key, value]) => `export ${key}=${quotePosix(value)}`).join("\n");
+  return [
+    "#!/usr/bin/env bash",
+    "set +e",
+    'rm -f "$0" >/dev/null 2>&1 || true',
+    envLines,
+    `cd ${quotePosix(options.cwd)} || exit $?`,
+    `echo ${quotePosix(`$ ${preview}`)}`,
+    runtimeInvocation,
+    "status=$?",
+    "echo",
+    'echo "Happy session command exited with status ${status}. You can close this window."',
+    'exec "${SHELL:-bash}" -l',
+    ""
+  ].join("\n");
+}
+function createTerminalLaunchScript(options) {
+  if (options.scriptPath) {
+    return options.scriptPath;
+  }
+  const platform = options.platform || process.platform;
+  const scriptDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "happy-terminal-launch-"));
+  const scriptPath = path.join(scriptDirectory, platform === "win32" ? "launch.cmd" : "launch.sh");
+  fs.writeFileSync(scriptPath, buildTerminalLaunchScriptContent({ ...options, platform }), { encoding: "utf8", mode: 448 });
+  if (platform !== "win32") {
+    fs.chmodSync(scriptPath, 448);
+  }
+  return scriptPath;
+}
+function buildTerminalWindowLaunchCommand(options) {
+  const platform = options.platform || process.platform;
+  const scriptPath = createTerminalLaunchScript({ ...options, platform });
+  const preview = buildUserFacingPreview(options.args);
+  if (platform === "win32") {
+    return {
+      command: "cmd.exe",
+      args: ["/d", "/s", "/c", `start "" cmd.exe /d /s /k ${quoteWindowsCmd(scriptPath)}`],
+      options: {
+        cwd: options.cwd,
+        detached: true,
+        stdio: "ignore",
+        env: options.env,
+        windowsHide: false
+      },
+      preview,
+      scriptPath
+    };
+  }
+  if (platform === "darwin") {
+    const appleScript = `tell application "Terminal" to do script ${quoteAppleScriptString(`bash ${quotePosix(scriptPath)}`)}`;
+    return {
+      command: "osascript",
+      args: ["-e", appleScript],
+      options: {
+        cwd: options.cwd,
+        detached: true,
+        stdio: "ignore",
+        env: options.env
+      },
+      preview,
+      scriptPath
+    };
+  }
+  return {
+    command: "x-terminal-emulator",
+    args: ["-e", "bash", scriptPath],
+    options: {
+      cwd: options.cwd,
+      detached: true,
+      stdio: "ignore",
+      env: options.env
+    },
+    preview,
+    scriptPath
+  };
+}
+function spawnHappyCLIInTerminalWindow(options) {
+  const launchCommand = buildTerminalWindowLaunchCommand(options);
+  return node_child_process.spawn(launchCommand.command, launchCommand.args, launchCommand.options);
+}
+
 const DIFFERENT_DAEMON_RUNNING_MESSAGE = "A different daemon was started without killing us. We should kill ourselves.";
 function pruneStaleTrackedSessions({
   trackedSessionPids,
@@ -3569,6 +3738,28 @@ async function startDaemon() {
     let api = null;
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const pidToAwaiter = /* @__PURE__ */ new Map();
+    const terminalLaunchAwaiters = /* @__PURE__ */ new Map();
+    const normalizePathForSessionMatch = (value) => (value || "").trim().replace(/[\\/]+$/, "");
+    const resolveTerminalLaunchAwaiter = (sessionId, sessionMetadata) => {
+      const reportedDirectory = normalizePathForSessionMatch(sessionMetadata.path);
+      const reportedFlavor = resolveRecoverySpawnAgent(sessionMetadata.flavor);
+      const now = Date.now();
+      for (const [awaiterId, awaiter] of terminalLaunchAwaiters.entries()) {
+        if (awaiter.startedAt - 5e3 > now) {
+          continue;
+        }
+        const directoryMatches = normalizePathForSessionMatch(awaiter.directory) === reportedDirectory;
+        const agentMatches = !awaiter.agent || !reportedFlavor || awaiter.agent === reportedFlavor;
+        if (!directoryMatches || !agentMatches) {
+          continue;
+        }
+        terminalLaunchAwaiters.delete(awaiterId);
+        awaiter.resolve({ type: "success", sessionId });
+        persistence.logger.debug(`[DAEMON RUN] Resolved terminal window session awaiter ${awaiterId} for session ${sessionId}`);
+        return true;
+      }
+      return false;
+    };
     const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
     let userScopedObserver = null;
     const removeTrackedSession = (pid, archiveReason) => {
@@ -3617,6 +3808,7 @@ async function startDaemon() {
         };
         pidToTrackedSession.set(pid, trackedSession);
         persistence.logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
+        resolveTerminalLaunchAwaiter(sessionId, sessionMetadata);
       }
     };
     const spawnSession = async (options) => {
@@ -3726,6 +3918,84 @@ async function startDaemon() {
             errorMessage: spawnError.errorMessage
           };
         }
+        if (options.launchMode === "terminalWindow" || options.launchMode === "localTerminal") {
+          persistence.logger.debug(`[DAEMON RUN] Using visible terminal window spawning`);
+          let args;
+          try {
+            args = buildTerminalWindowSpawnArgs(options.agent, options.resume);
+          } catch (error) {
+            const spawnError = createSpawnSessionError(
+              SPAWN_SESSION_ERROR_CODES.INVALID_REQUEST,
+              error instanceof Error ? error.message : String(error)
+            );
+            return {
+              type: spawnError.type,
+              errorMessage: spawnError.errorMessage
+            };
+          }
+          const terminalEnv = buildDaemonChildEnv(process.env, extraEnv);
+          const terminalProcess = spawnHappyCLIInTerminalWindow({
+            cwd: directory,
+            args,
+            env: terminalEnv
+          });
+          if (!terminalProcess.pid) {
+            persistence.logger.debug("[DAEMON RUN] Failed to spawn terminal window - no PID returned");
+            const spawnError = createSpawnSessionError(
+              SPAWN_SESSION_ERROR_CODES.SPAWN_NO_PID,
+              "Failed to spawn terminal window - no PID returned"
+            );
+            return {
+              type: spawnError.type,
+              errorMessage: spawnError.errorMessage
+            };
+          }
+          persistence.logger.debug(`[DAEMON RUN] Spawned terminal window process with PID ${terminalProcess.pid}`);
+          const trackedSession = {
+            startedBy: "daemon terminal window",
+            happySessionId: options.sessionId,
+            sessionIndex: null,
+            skipDetachedManagedSessionArchive: true,
+            pid: terminalProcess.pid,
+            childProcess: terminalProcess,
+            directoryCreated,
+            message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and opened a terminal window there.` : `Opened a terminal window in '${directory}' to start the session.`
+          };
+          pidToTrackedSession.set(terminalProcess.pid, trackedSession);
+          terminalProcess.on("exit", (code, signal) => {
+            persistence.logger.debug(`[DAEMON RUN] Terminal launcher PID ${terminalProcess.pid} exited with code ${code}, signal ${signal}`);
+          });
+          terminalProcess.on("error", (error) => {
+            persistence.logger.debug(`[DAEMON RUN] Terminal launcher process error:`, error);
+          });
+          terminalProcess.unref();
+          const terminalAwaiterId = node_crypto.randomUUID();
+          const launchStartedAt = Date.now();
+          persistence.logger.debug(`[DAEMON RUN] Waiting for terminal window session webhook ${terminalAwaiterId}`);
+          return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+              terminalLaunchAwaiters.delete(terminalAwaiterId);
+              persistence.logger.debug(`[DAEMON RUN] Terminal window session webhook timeout for PID ${terminalProcess.pid}`);
+              const spawnError = createSpawnSessionError(
+                SPAWN_SESSION_ERROR_CODES.SESSION_WEBHOOK_TIMEOUT,
+                `Terminal window session webhook timeout for PID ${terminalProcess.pid}`
+              );
+              resolve({
+                type: spawnError.type,
+                errorMessage: spawnError.errorMessage
+              });
+            }, sessionWebhookTimeoutMs);
+            terminalLaunchAwaiters.set(terminalAwaiterId, {
+              directory,
+              agent: options.agent,
+              startedAt: launchStartedAt,
+              resolve: (result) => {
+                clearTimeout(timeout);
+                resolve(result);
+              }
+            });
+          });
+        }
         let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
         const tmuxRequested = tmuxSessionName !== void 0;
         const tmuxAvailable = tmuxRequested ? await isTmuxAvailable() : false;
@@ -8798,6 +9068,69 @@ class AcpBackend {
     }
     return resolvePostPromptNoUpdatesTimeoutMs(this.transport);
   }
+  getResponseWaitTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      return Math.trunc(timeoutMs);
+    }
+    return readPositiveIntegerEnv("HAPPY_ACP_RESPONSE_WAIT_TIMEOUT_MS") ?? readPositiveIntegerEnv("HAPPIER_ACP_RESPONSE_WAIT_TIMEOUT_MS") ?? resolveAcpResponseWaitTimeoutMs(this.sessionPreferences.timeoutProfile);
+  }
+  createPromptCompletionWatchdog(timeoutMs) {
+    let timeoutHandle = null;
+    let cancelled = false;
+    const promise = new Promise((resolve, reject) => {
+      const schedule = () => {
+        if (cancelled) {
+          return;
+        }
+        if (this.responseCompletionError) {
+          reject(this.responseCompletionError);
+          return;
+        }
+        if (!this.waitingForResponse) {
+          resolve();
+          return;
+        }
+        const lastProgressAt = this.responseLastProgressAt ?? Date.now();
+        const elapsedMs = Math.max(0, Date.now() - lastProgressAt);
+        const remainingMs = Math.max(1, timeoutMs - elapsedMs);
+        timeoutHandle = setTimeout(() => {
+          timeoutHandle = null;
+          if (cancelled) {
+            return;
+          }
+          if (this.responseCompletionError) {
+            reject(this.responseCompletionError);
+            return;
+          }
+          if (!this.waitingForResponse) {
+            resolve();
+            return;
+          }
+          const latestProgressAt = this.responseLastProgressAt ?? Date.now();
+          const latestElapsedMs = Math.max(0, Date.now() - latestProgressAt);
+          if (latestElapsedMs < timeoutMs) {
+            schedule();
+            return;
+          }
+          const timeoutLabel = formatToolCallTimeoutLimit(timeoutMs);
+          const error = new Error(`Timeout waiting for Codex ACP prompt to complete after ${timeoutLabel} without response progress`);
+          this.failPendingResponseWait(error);
+          reject(error);
+        }, remainingMs);
+      };
+      schedule();
+    });
+    return {
+      promise,
+      cancel: () => {
+        cancelled = true;
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+          timeoutHandle = null;
+        }
+      }
+    };
+  }
   clearIdleTimeoutState() {
     if (this.idleTimeout) {
       clearTimeout(this.idleTimeout);
@@ -9400,10 +9733,14 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
         async () => {
           let timeoutHandle = null;
           try {
+            const resumeSession = this.connection.resumeSession ?? this.connection.unstable_resumeSession;
             const result = await raceWithProcessExit(
               this.process,
               () => Promise.race([
-                (sessionOperation === "resume" ? this.connection.resumeSession(sessionRequest) : sessionOperation === "load" ? this.connection.loadSession(sessionRequest) : this.connection.newSession(sessionRequest)).then((res) => {
+                (sessionOperation === "resume" ? resumeSession ? resumeSession(sessionRequest).then((response) => ({
+                  ...response,
+                  sessionId: requestedResumeSessionId
+                })) : Promise.reject(new Error("ACP agent advertised session resume, but this SDK connection does not expose resumeSession.")) : sessionOperation === "load" ? this.connection.loadSession(sessionRequest) : this.connection.newSession(sessionRequest)).then((res) => {
                   if (timeoutHandle) {
                     clearTimeout(timeoutHandle);
                     timeoutHandle = null;
@@ -9645,15 +9982,23 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
         prompt: [contentBlock]
       };
       persistence.logger.debug(`[AcpBackend] Prompt request:`, JSON.stringify(promptRequest, null, 2));
-      await raceWithProcessExit(
-        this.process,
-        () => this.connection.prompt(promptRequest),
-        {
-          agentName: this.transport.agentName,
-          operationName: "prompt",
-          getStderrExcerpt: () => this.getRecentStderrExcerpt()
-        }
-      );
+      const promptWatchdog = this.createPromptCompletionWatchdog(this.getResponseWaitTimeoutMs());
+      try {
+        await raceWithProcessExit(
+          this.process,
+          () => Promise.race([
+            this.connection.prompt(promptRequest),
+            promptWatchdog.promise
+          ]),
+          {
+            agentName: this.transport.agentName,
+            operationName: "prompt",
+            getStderrExcerpt: () => this.getRecentStderrExcerpt()
+          }
+        );
+      } finally {
+        promptWatchdog.cancel();
+      }
       persistence.logger.debug("[AcpBackend] Prompt request sent to ACP connection");
       if (this.waitingForResponse && this.activeToolCalls.size === 0 && this.sawSessionUpdateSincePrompt === false) {
         const noUpdatesTimeoutMs = this.getPostPromptNoUpdatesTimeoutMs();
@@ -9716,7 +10061,7 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
     if (!this.waitingForResponse) {
       return;
     }
-    const effectiveTimeoutMs = timeoutMs ?? resolveAcpResponseWaitTimeoutMs(this.sessionPreferences.timeoutProfile);
+    const effectiveTimeoutMs = this.getResponseWaitTimeoutMs(timeoutMs);
     return new Promise((resolve, reject) => {
       this.idleResolver = () => {
         this.idleResolver = null;
@@ -10050,7 +10395,7 @@ function registerGeminiAgent() {
   persistence.logger.debug("[Gemini] Registered with agent registry");
 }
 
-const DEFAULT_CODEX_ACP_NPX_PACKAGE = "@zed-industries/codex-acp@0.10.0";
+const DEFAULT_CODEX_ACP_NPX_PACKAGE = "@zed-industries/codex-acp@0.14.0";
 function readFirstEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -10899,7 +11244,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-CyW9A7hx.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-xa1kwZoj.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
@@ -12224,14 +12569,14 @@ var launch = /*#__PURE__*/Object.freeze({
 const unifiedProviderExecutors = {
   claude: async (opts) => {
     const claudeOptions = opts.claudeOptions ?? {};
-    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-CfdT_ccS.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-BBGNmGj6.cjs'); });
     await runClaude(opts.credentials, {
       ...claudeOptions,
       startingMode: claudeOptions.startingMode ?? (claudeOptions.startedBy === "daemon" ? "remote" : void 0)
     });
   },
   codex: async (opts) => {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-B-t0yy4k.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-jUU6U2tZ.cjs'); });
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -12240,7 +12585,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DZ5-uzB9.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-C0NT8MHK.cjs'); });
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -12323,7 +12668,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-BZRQuZsh.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-VcH4hbhi.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -12529,8 +12874,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('./api-CVuTajTL.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-CVuTajTL.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./api-D7nAeZi7.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-D7nAeZi7.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();

package/dist/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 require('chalk');
-require('./api-CVuTajTL.cjs');
+require('./api-D7nAeZi7.cjs');
 require('zod');
-require('./index-CyW9A7hx.cjs');
+require('./index-xa1kwZoj.cjs');
 require('node:child_process');
 require('node:fs');
 require('cross-spawn');

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import 'chalk';
-import './api-D3vYIva3.mjs';
+import './api-DnqaNvyV.mjs';
 import 'zod';
-import './index-Cp1I5I3U.mjs';
+import './index-7Z93BoVn.mjs';
 import 'node:child_process';
 import 'node:fs';
 import 'cross-spawn';

package/dist/lib.cjs

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