happy-imou-cloud 2.1.47 → 2.1.49

package/dist/{index-Cp1I5I3U.mjs → index-7Z93BoVn.mjs}

@@ -1,5 +1,5 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, q as encodeBase64, c as configuration, t as readCredentials, u as ensureSigningCredentials, r as readSettings, v as updateSettings, w as encodeBase64Url, m as delay, x as buildClientHeaders, y as decodeBase64, z as writeCredentialsLegacy, B as writeCredentialsDataKey, C as readDaemonState, D as HAPPY_CLOUD_DAEMON_PORT, E as clearDaemonState, F as packageJson, i as isAuthenticationRequiredError, G as buildSessionRuntimeIndex, I as acquireDaemonLock, J as writeDaemonState, A as ApiClient, K as releaseDaemonLock, L as validateProfileForAgent, M as getProfileEnvironmentVariables, N as clearCredentials, O as clearMachineId, P as readHappyOrgDispatchTruthSnapshot, Q as processHappyOrgRepoRequests, R as readHappyOrgRepoTaskBoard, S as HappyOrgTurnReportSchema, T as recordHappyOrgTurnReport, U as MessageContentSchema, V as buildSocketAuth, W as encrypt, H as HeadTailPreviewBuffer, X as getLatestDaemonLog } from './api-D3vYIva3.mjs';
+import { l as logger, q as encodeBase64, c as configuration, t as readCredentials, u as ensureSigningCredentials, r as readSettings, v as updateSettings, w as encodeBase64Url, m as delay, x as buildClientHeaders, y as decodeBase64, z as writeCredentialsLegacy, B as writeCredentialsDataKey, C as readDaemonState, D as HAPPY_CLOUD_DAEMON_PORT, E as clearDaemonState, F as packageJson, i as isAuthenticationRequiredError, G as buildSessionRuntimeIndex, I as acquireDaemonLock, J as writeDaemonState, A as ApiClient, K as releaseDaemonLock, L as validateProfileForAgent, M as getProfileEnvironmentVariables, N as clearCredentials, O as clearMachineId, P as readHappyOrgDispatchTruthSnapshot, Q as processHappyOrgRepoRequests, R as readHappyOrgRepoTaskBoard, S as HappyOrgTurnReportSchema, T as recordHappyOrgTurnReport, U as MessageContentSchema, V as buildSocketAuth, W as encrypt, H as HeadTailPreviewBuffer, X as getLatestDaemonLog } from './api-DnqaNvyV.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os$1, { homedir as homedir$1 } from 'os';
@@ -10,18 +10,18 @@ import qrcode from 'qrcode-terminal';
 import { writeFile, unlink, readdir, readFile, mkdir } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import os, { tmpdir, homedir } from 'node:os';
-import path, { join, resolve as resolve$1, dirname as dirname$1, normalize, isAbsolute, delimiter, relative, basename } from 'node:path';
+import path, { join, delimiter, resolve as resolve$1, dirname as dirname$1, normalize, isAbsolute, relative, basename } from 'node:path';
 import open from 'open';
 import React, { useState } from 'react';
 import { useInput, Box, Text, render } from 'ink';
 import { spawn, execSync, exec } from 'child_process';
 import { dirname, resolve, join as join$1 } from 'path';
 import { fileURLToPath } from 'url';
-import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync as writeFileSync$1, chmodSync, unlinkSync as unlinkSync$1, mkdirSync as mkdirSync$1 } from 'fs';
+import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync as writeFileSync$1, chmodSync as chmodSync$1, unlinkSync as unlinkSync$1, mkdirSync as mkdirSync$1 } from 'fs';
 import { execFileSync, spawn as spawn$2, execSync as execSync$1 } from 'node:child_process';
 import psList from 'ps-list';
 import spawn$1 from 'cross-spawn';
-import fs$1, { existsSync, readFileSync, readdirSync, statSync, unlinkSync, mkdirSync, writeFileSync, cpSync, rmSync, mkdtempSync, realpathSync } from 'node:fs';
+import fs$1, { existsSync, readFileSync, readdirSync, statSync, mkdtempSync, writeFileSync, chmodSync, unlinkSync, mkdirSync, cpSync, rmSync, realpathSync } from 'node:fs';
 import fastify from 'fastify';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
 import { randomUUID as randomUUID$1, randomBytes as randomBytes$1, createHash } from 'crypto';
@@ -1566,7 +1566,8 @@ function startDaemonControlServer({
         body: z.object({
           directory: z.string(),
           sessionId: z.string().optional(),
-          agent: z.enum(["claude", "codex", "gemini"]).optional()
+          agent: z.enum(["claude", "codex", "gemini"]).optional(),
+          launchMode: z.enum(["background", "terminalWindow", "localTerminal"]).optional()
         }),
         response: {
           200: z.object({
@@ -1587,9 +1588,9 @@ function startDaemonControlServer({
         }
       }
     }, async (request, reply) => {
-      const { directory, sessionId, agent } = request.body;
-      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;
+      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) {
@@ -2333,20 +2334,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",
@@ -2409,6 +2427,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 || 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 = join(projectPath(), "node_modules", ".bin");
+  const pathDelimiter = platform === "win32" ? ";" : 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 = mkdtempSync(join(tmpdir(), "happy-terminal-launch-"));
+  const scriptPath = join(scriptDirectory, platform === "win32" ? "launch.cmd" : "launch.sh");
+  writeFileSync(scriptPath, buildTerminalLaunchScriptContent({ ...options, platform }), { encoding: "utf8", mode: 448 });
+  if (platform !== "win32") {
+    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 spawn$2(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,
@@ -3566,6 +3735,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 });
+        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) => {
@@ -3614,6 +3805,7 @@ async function startDaemon() {
         };
         pidToTrackedSession.set(pid, trackedSession);
         logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
+        resolveTerminalLaunchAwaiter(sessionId, sessionMetadata);
       }
     };
     const spawnSession = async (options) => {
@@ -3723,6 +3915,84 @@ async function startDaemon() {
             errorMessage: spawnError.errorMessage
           };
         }
+        if (options.launchMode === "terminalWindow" || options.launchMode === "localTerminal") {
+          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) {
+            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
+            };
+          }
+          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) => {
+            logger.debug(`[DAEMON RUN] Terminal launcher PID ${terminalProcess.pid} exited with code ${code}, signal ${signal}`);
+          });
+          terminalProcess.on("error", (error) => {
+            logger.debug(`[DAEMON RUN] Terminal launcher process error:`, error);
+          });
+          terminalProcess.unref();
+          const terminalAwaiterId = randomUUID();
+          const launchStartedAt = Date.now();
+          logger.debug(`[DAEMON RUN] Waiting for terminal window session webhook ${terminalAwaiterId}`);
+          return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+              terminalLaunchAwaiters.delete(terminalAwaiterId);
+              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;
@@ -4383,7 +4653,7 @@ async function install$1() {
             </plist>
         `);
     writeFileSync$1(PLIST_FILE$1, plistContent);
-    chmodSync(PLIST_FILE$1, 420);
+    chmodSync$1(PLIST_FILE$1, 420);
     logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
     execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
     logger.info("Daemon installed and started successfully");
@@ -8795,6 +9065,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);
@@ -9397,10 +9730,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;
@@ -9642,15 +9979,23 @@ Recent stderr: ${recentStderrSummaryLine}` : `Signal: ${signal}`;
         prompt: [contentBlock]
       };
       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();
+      }
       logger.debug("[AcpBackend] Prompt request sent to ACP connection");
       if (this.waitingForResponse && this.activeToolCalls.size === 0 && this.sawSessionUpdateSincePrompt === false) {
         const noUpdatesTimeoutMs = this.getPostPromptNoUpdatesTimeoutMs();
@@ -9713,7 +10058,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;
@@ -10047,7 +10392,7 @@ function registerGeminiAgent() {
   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];
@@ -12221,14 +12566,14 @@ var launch = /*#__PURE__*/Object.freeze({
 const unifiedProviderExecutors = {
   claude: async (opts) => {
     const claudeOptions = opts.claudeOptions ?? {};
-    const { runClaude } = await import('./runClaude-BviM1Wl5.mjs');
+    const { runClaude } = await import('./runClaude-zCwRhpOw.mjs');
     await runClaude(opts.credentials, {
       ...claudeOptions,
       startingMode: claudeOptions.startingMode ?? (claudeOptions.startedBy === "daemon" ? "remote" : void 0)
     });
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-Dx3osc7U.mjs');
+    const { runCodex } = await import('./runCodex-BbgLVjb9.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -12237,7 +12582,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-CnJ75Q--.mjs');
+    const { runGemini } = await import('./runGemini-DcwNsudA.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -12320,7 +12665,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-fcJ-4Yq3.mjs');
+      const { renderRuntimeProviders } = await import('./command-CzfRRhVe.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -12526,8 +12871,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./api-D3vYIva3.mjs').then(function (n) { return n.Y; });
-        const { ApiClient: ApiClient2 } = await import('./api-D3vYIva3.mjs').then(function (n) { return n.Z; });
+        const { readCredentials: readCredentials2 } = await import('./api-DnqaNvyV.mjs').then(function (n) { return n.Y; });
+        const { ApiClient: ApiClient2 } = await import('./api-DnqaNvyV.mjs').then(function (n) { return n.Z; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();