happy-imou-cloud 2.0.13 → 2.0.16

package/dist/{index-Cxrx9m5D.mjs → index-DpWeKfvS.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, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-D1meoL-9.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-9Iu0wGNM.mjs';
+import { l as logger, e as encodeBase64, c as configuration, h as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, j as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, k as encodeBase64Url, f as delay, m as buildClientHeaders, n as decodeBase64, H as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, o as getLatestDaemonLog } from './api-sRF6xXi-.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-B89V4xY5.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os, { homedir } from 'os';
@@ -20,7 +20,7 @@ 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, chmodSync, unlinkSync as unlinkSync$1, mkdirSync } from 'fs';
-import { execFileSync, spawn as spawn$2 } from 'node:child_process';
+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, rmSync, mkdirSync as mkdirSync$1, realpathSync } from 'node:fs';
@@ -31,6 +31,7 @@ import { createInterface } from 'node:readline';
 import { createServer } from 'http';
 import { promisify } from 'util';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
+import { fileURLToPath as fileURLToPath$1 } from 'node:url';
 import 'node:events';
 
 async function openBrowser(url) {
@@ -672,9 +673,9 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+const __dirname$2 = dirname(fileURLToPath(import.meta.url));
 function projectPath() {
-  const path = resolve(__dirname$1, "..");
+  const path = resolve(__dirname$2, "..");
   return path;
 }
 
@@ -4946,7 +4947,7 @@ class ClaudeTransport extends DefaultTransport {
     return 600;
   }
 }
-const claudeTransport = new ClaudeTransport();
+new ClaudeTransport();
 
 class CursorTransport extends DefaultTransport {
   constructor() {
@@ -4984,7 +4985,7 @@ function appendToolOutput(existing, next) {
   }
   return `${existing}${next}`;
 }
-function isRecord(value) {
+function isRecord$1(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasMeaningfulContent(value) {
@@ -4997,7 +4998,7 @@ function hasMeaningfulContent(value) {
   if (Array.isArray(value)) {
     return value.length > 0;
   }
-  if (isRecord(value)) {
+  if (isRecord$1(value)) {
     return Object.keys(value).length > 0;
   }
   return true;
@@ -5020,7 +5021,7 @@ function looksLikeToolMetadata(record) {
   const nestedKeys = ["input", "toolCall", "arguments", "content"];
   for (const key of nestedKeys) {
     const nested = record[key];
-    if (isRecord(nested) && looksLikeToolMetadata(nested)) {
+    if (isRecord$1(nested) && looksLikeToolMetadata(nested)) {
       return true;
     }
   }
@@ -5034,7 +5035,7 @@ function extractToolOutputChunk(content) {
     const parts = content.map((item) => extractToolOutputChunk(item)).filter((item) => Boolean(item));
     return parts.length > 0 ? parts.join("") : null;
   }
-  if (!isRecord(content)) {
+  if (!isRecord$1(content)) {
     return null;
   }
   const outputKeys = ["stdout", "stderr", "output", "text", "message", "data", "error", "reason"];
@@ -5062,7 +5063,7 @@ function mergeStreamedOutputWithResult(content, streamedOutput) {
   if (!hasMeaningfulContent(content)) {
     return streamedOutput;
   }
-  if (isRecord(content)) {
+  if (isRecord$1(content)) {
     const hasStructuredOutput = ["stdout", "stderr", "output", "text", "message", "data"].some((key) => key in content);
     if (!hasStructuredOutput) {
       return {
@@ -7354,6 +7355,1051 @@ function registerCodexAgent() {
   agentRegistry.register("codex", (opts) => createCodexBackend(opts).backend);
 }
 
+class Stream {
+  constructor(returned) {
+    this.returned = returned;
+  }
+  queue = [];
+  readResolve;
+  readReject;
+  isDone = false;
+  hasError;
+  started = false;
+  /**
+   * Implements async iterable protocol
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("Stream can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  /**
+   * Gets the next value from the stream
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return Promise.resolve({
+        done: false,
+        value: this.queue.shift()
+      });
+    }
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    if (this.hasError) {
+      return Promise.reject(this.hasError);
+    }
+    return new Promise((resolve, reject) => {
+      this.readResolve = resolve;
+      this.readReject = reject;
+    });
+  }
+  /**
+   * Adds a value to the stream
+   */
+  enqueue(value) {
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Marks the stream as complete
+   */
+  done() {
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: true, value: void 0 });
+    }
+  }
+  /**
+   * Propagates an error through the stream
+   */
+  error(error) {
+    this.hasError = error;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      reject(error);
+    }
+  }
+  /**
+   * Implements async iterator cleanup
+   */
+  async return() {
+    this.isDone = true;
+    if (this.returned) {
+      this.returned();
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+const __filename$1 = fileURLToPath$1(import.meta.url);
+const __dirname$1 = join(__filename$1, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = execSync$1("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homedir$1(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    logger.debug(`[Claude SDK] Global claude --version output: ${output}`);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function getCleanEnv() {
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const actualPathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || pathKey;
+  if (env[actualPathKey]) {
+    const cleanPath = env[actualPathKey].split(pathSep).filter((p) => {
+      const normalizedP = p.replace(/\\/g, "/").toLowerCase();
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase();
+      return !normalizedP.startsWith(normalizedCwd);
+    }).join(pathSep);
+    env[actualPathKey] = cleanPath;
+    logger.debug(`[Claude SDK] Cleaned PATH, removed local paths from: ${cwd}`);
+  }
+  if (isBun()) {
+    Object.keys(env).forEach((key) => {
+      if (key.startsWith("BUN_")) {
+        delete env[key];
+      }
+    });
+    logger.debug("[Claude SDK] Removed Bun-specific environment variables for Node.js compatibility");
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = homedir$1();
+  const cleanEnv = getCleanEnv();
+  try {
+    execSync$1("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = execSync$1("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && existsSync(result)) {
+        logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getDefaultClaudeCodePath() {
+  const nodeModulesPath = join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    logger.debug(`[Claude SDK] Using HAPPY_CLAUDE_PATH: ${process.env.HAPPY_CLAUDE_PATH}`);
+    return process.env.HAPPY_CLAUDE_PATH;
+  }
+  if (process.env.HAPPY_USE_BUNDLED_CLAUDE === "1") {
+    logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
+}
+function logDebug(message) {
+  if (process.env.DEBUG) {
+    logger.debug(message);
+    console.log(message);
+  }
+}
+async function streamToStdin(stream, stdin, abort) {
+  for await (const message of stream) {
+    if (abort?.aborted) break;
+    stdin.write(JSON.stringify(message) + "\n");
+  }
+  stdin.end();
+}
+
+class Query {
+  constructor(childStdin, childStdout, processExitPromise, canCallTool) {
+    this.childStdin = childStdin;
+    this.childStdout = childStdout;
+    this.processExitPromise = processExitPromise;
+    this.canCallTool = canCallTool;
+    this.readMessages();
+    this.sdkMessages = this.readSdkMessages();
+  }
+  pendingControlResponses = /* @__PURE__ */ new Map();
+  cancelControllers = /* @__PURE__ */ new Map();
+  sdkMessages;
+  inputStream = new Stream();
+  canCallTool;
+  /**
+   * Set an error on the stream
+   */
+  setError(error) {
+    this.inputStream.error(error);
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  next(...args) {
+    return this.sdkMessages.next(...args);
+  }
+  return(value) {
+    if (this.sdkMessages.return) {
+      return this.sdkMessages.return(value);
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  throw(e) {
+    if (this.sdkMessages.throw) {
+      return this.sdkMessages.throw(e);
+    }
+    return Promise.reject(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this.sdkMessages;
+  }
+  /**
+   * Read messages from Claude process stdout
+   */
+  async readMessages() {
+    const rl = createInterface({ input: this.childStdout });
+    try {
+      for await (const line of rl) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+            if (message.type === "control_response") {
+              const controlResponse = message;
+              const handler = this.pendingControlResponses.get(controlResponse.response.request_id);
+              if (handler) {
+                handler(controlResponse.response);
+              }
+              continue;
+            } else if (message.type === "control_request") {
+              await this.handleControlRequest(message);
+              continue;
+            } else if (message.type === "control_cancel_request") {
+              this.handleControlCancelRequest(message);
+              continue;
+            }
+            this.inputStream.enqueue(message);
+          } catch (e) {
+            logger.debug(line);
+          }
+        }
+      }
+      await this.processExitPromise;
+    } catch (error) {
+      this.inputStream.error(error);
+    } finally {
+      this.inputStream.done();
+      this.cleanupControllers();
+      rl.close();
+    }
+  }
+  /**
+   * Async generator for SDK messages
+   */
+  async *readSdkMessages() {
+    for await (const message of this.inputStream) {
+      yield message;
+    }
+  }
+  /**
+   * Send interrupt request to Claude
+   */
+  async interrupt() {
+    if (!this.childStdin) {
+      throw new Error("Interrupt requires --input-format stream-json");
+    }
+    await this.request({
+      subtype: "interrupt"
+    }, this.childStdin);
+  }
+  /**
+   * Send control request to Claude process
+   */
+  request(request, childStdin) {
+    const requestId = Math.random().toString(36).substring(2, 15);
+    const sdkRequest = {
+      request_id: requestId,
+      type: "control_request",
+      request
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingControlResponses.set(requestId, (response) => {
+        if (response.subtype === "success") {
+          resolve(response);
+        } else {
+          reject(new Error(response.error));
+        }
+      });
+      childStdin.write(JSON.stringify(sdkRequest) + "\n");
+    });
+  }
+  /**
+   * Handle incoming control requests for tool permissions
+   * Replicates the exact logic from the SDK's handleControlRequest method
+   */
+  async handleControlRequest(request) {
+    if (!this.childStdin) {
+      logDebug("Cannot handle control request - no stdin available");
+      return;
+    }
+    const controller = new AbortController();
+    this.cancelControllers.set(request.request_id, controller);
+    try {
+      const response = await this.processControlRequest(request, controller.signal);
+      const controlResponse = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlResponse) + "\n");
+    } catch (error) {
+      const controlErrorResponse = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlErrorResponse) + "\n");
+    } finally {
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  /**
+   * Handle control cancel requests
+   * Replicates the exact logic from the SDK's handleControlCancelRequest method
+   */
+  handleControlCancelRequest(request) {
+    const controller = this.cancelControllers.get(request.request_id);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  /**
+   * Process control requests based on subtype
+   * Replicates the exact logic from the SDK's processControlRequest method
+   */
+  async processControlRequest(request, signal) {
+    if (request.request.subtype === "can_use_tool") {
+      if (!this.canCallTool) {
+        throw new Error("canCallTool callback is not provided.");
+      }
+      return this.canCallTool(request.request.tool_name, request.request.input, {
+        signal,
+        requestId: request.request_id
+      });
+    }
+    throw new Error("Unsupported control request subtype: " + request.request.subtype);
+  }
+  /**
+   * Cleanup method to abort all pending control requests
+   */
+  cleanupControllers() {
+    for (const [requestId, controller] of this.cancelControllers.entries()) {
+      controller.abort();
+      this.cancelControllers.delete(requestId);
+    }
+  }
+}
+function query(config) {
+  const {
+    prompt,
+    options: {
+      allowedTools = [],
+      appendSystemPrompt,
+      customSystemPrompt,
+      cwd,
+      disallowedTools = [],
+      env,
+      executable = "node",
+      executableArgs = [],
+      maxTurns,
+      mcpServers,
+      pathToClaudeCodeExecutable = getDefaultClaudeCodePath(),
+      permissionMode,
+      continue: continueConversation,
+      resume,
+      model,
+      fallbackModel,
+      strictMcpConfig,
+      canCallTool,
+      settingsPath,
+      extraArgs = []
+    } = {}
+  } = config;
+  if (!process.env.CLAUDE_CODE_ENTRYPOINT) {
+    process.env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+  }
+  const args = [...extraArgs, "--output-format", "stream-json", "--verbose"];
+  if (customSystemPrompt) args.push("--system-prompt", customSystemPrompt);
+  if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+  if (maxTurns) args.push("--max-turns", maxTurns.toString());
+  if (model) args.push("--model", model);
+  if (canCallTool) {
+    if (typeof prompt === "string") {
+      throw new Error("canCallTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.");
+    }
+    args.push("--permission-prompt-tool", "stdio");
+  }
+  if (continueConversation) args.push("--continue");
+  if (resume) args.push("--resume", resume);
+  if (allowedTools.length > 0) args.push("--allowedTools", allowedTools.join(","));
+  if (disallowedTools.length > 0) args.push("--disallowedTools", disallowedTools.join(","));
+  if (mcpServers && Object.keys(mcpServers).length > 0) {
+    args.push("--mcp-config", JSON.stringify({ mcpServers }));
+  }
+  if (strictMcpConfig) args.push("--strict-mcp-config");
+  if (permissionMode) args.push("--permission-mode", permissionMode);
+  if (settingsPath) args.push("--settings", settingsPath);
+  if (fallbackModel) {
+    if (model && fallbackModel === model) {
+      throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
+    }
+    args.push("--fallback-model", fallbackModel);
+  }
+  if (typeof prompt === "string") {
+    args.push("--print", prompt.trim());
+  } else {
+    args.push("--input-format", "stream-json");
+  }
+  const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
+  const isCommandOnly = pathToClaudeCodeExecutable === "claude";
+  if (!isCommandOnly && !existsSync(pathToClaudeCodeExecutable)) {
+    throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
+  }
+  const spawnCommand = isJsFile ? executable : pathToClaudeCodeExecutable;
+  const spawnArgs = isJsFile ? [...executableArgs, pathToClaudeCodeExecutable, ...args] : args;
+  const spawnEnv = {
+    ...isCommandOnly ? getCleanEnv() : process.env,
+    ...env
+  };
+  logDebug(`Spawning Claude Code process: ${spawnCommand} ${spawnArgs.join(" ")} (using ${isCommandOnly ? "clean" : "normal"} env)`);
+  const child = spawn$2(spawnCommand, spawnArgs, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal: config.options?.abort,
+    env: spawnEnv,
+    // Use shell on Windows for global binaries and command-only mode
+    shell: !isJsFile && process.platform === "win32"
+  });
+  let childStdin = null;
+  if (typeof prompt === "string") {
+    child.stdin.end();
+  } else {
+    streamToStdin(prompt, child.stdin, config.options?.abort);
+    childStdin = child.stdin;
+  }
+  if (process.env.DEBUG) {
+    child.stderr.on("data", (data) => {
+      console.error("Claude Code stderr:", data.toString());
+    });
+  }
+  const cleanup = () => {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+  };
+  config.options?.abort?.addEventListener("abort", cleanup);
+  process.on("exit", cleanup);
+  const processExitPromise = new Promise((resolve) => {
+    child.on("close", (code) => {
+      if (config.options?.abort?.aborted) {
+        query2.setError(new AbortError("Claude Code process aborted by user"));
+      }
+      if (code !== 0) {
+        query2.setError(new Error(`Claude Code process exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+  const query2 = new Query(childStdin, child.stdout, processExitPromise, canCallTool);
+  child.on("error", (error) => {
+    if (config.options?.abort?.aborted) {
+      query2.setError(new AbortError("Claude Code process aborted by user"));
+    } else {
+      query2.setError(new Error(`Failed to spawn Claude Code process: ${error.message}`));
+    }
+  });
+  processExitPromise.finally(() => {
+    cleanup();
+    config.options?.abort?.removeEventListener("abort", cleanup);
+    if (process.env.CLAUDE_SDK_MCP_SERVERS) {
+      delete process.env.CLAUDE_SDK_MCP_SERVERS;
+    }
+  });
+  return query2;
+}
+
+class Future {
+  _resolve;
+  _reject;
+  _promise;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  get promise() {
+    return this._promise;
+  }
+}
+
+class PushableAsyncIterable {
+  queue = [];
+  waiters = [];
+  isDone = false;
+  error = null;
+  started = false;
+  constructor() {
+  }
+  /**
+   * Push a value to the iterable
+   */
+  push(value) {
+    if (this.isDone) {
+      throw new Error("Cannot push to completed iterable");
+    }
+    if (this.error) {
+      throw this.error;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Mark the iterable as complete
+   */
+  end() {
+    if (this.isDone) {
+      return;
+    }
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Set an error on the iterable
+   */
+  setError(err) {
+    if (this.isDone) {
+      return;
+    }
+    this.error = err;
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Cleanup waiting consumers
+   */
+  cleanup() {
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      if (this.error) {
+        waiter.reject(this.error);
+      } else {
+        waiter.resolve({ done: true, value: void 0 });
+      }
+    }
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return { done: false, value: this.queue.shift() };
+    }
+    if (this.isDone) {
+      if (this.error) {
+        throw this.error;
+      }
+      return { done: true, value: void 0 };
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  /**
+   * AsyncIterableIterator return implementation
+   */
+  async return(_value) {
+    this.end();
+    return { done: true, value: void 0 };
+  }
+  /**
+   * AsyncIterableIterator throw implementation
+   */
+  async throw(e) {
+    this.setError(e instanceof Error ? e : new Error(String(e)));
+    throw this.error;
+  }
+  /**
+   * Make this iterable
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("PushableAsyncIterable can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  /**
+   * Check if the iterable is done
+   */
+  get done() {
+    return this.isDone;
+  }
+  /**
+   * Check if the iterable has an error
+   */
+  get hasError() {
+    return this.error !== null;
+  }
+  /**
+   * Get the current queue size
+   */
+  get queueSize() {
+    return this.queue.length;
+  }
+  /**
+   * Get the number of waiting consumers
+   */
+  get waiterCount() {
+    return this.waiters.length;
+  }
+}
+
+function normalizeClaudeBackendError(error) {
+  const record = typeof error === "object" && error !== null ? error : null;
+  const text = formatDisplayMessage(error).trim();
+  const stderrText = record ? formatDisplayMessage(record.stderr).trim() : "";
+  const detailText = record ? formatDisplayMessage(record.detail).trim() : "";
+  const searchable = [text, stderrText, detailText].filter(Boolean).join("\n").trim();
+  return searchable || "Claude runtime backend exited unexpectedly";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createTimeoutError(timeoutMs) {
+  return new Error(`Claude response did not complete within ${timeoutMs}ms`);
+}
+function normalizePermissionResult(input, decision) {
+  if (decision === "approved" || decision === "approved_for_session") {
+    return {
+      behavior: "allow",
+      updatedInput: isRecord(input) ? input : {}
+    };
+  }
+  return {
+    behavior: "deny",
+    message: decision === "denied" ? "The user denied this tool request." : "The tool request was aborted."
+  };
+}
+function getClaudeExecutablePath(command) {
+  if (command === "claude") {
+    return resolve$1(join(projectPath(), "scripts", "claude_remote_launcher.cjs"));
+  }
+  return command;
+}
+class ClaudeCodeBackend {
+  constructor(options) {
+    this.options = options;
+  }
+  listeners = /* @__PURE__ */ new Set();
+  toolNamesByCallId = /* @__PURE__ */ new Map();
+  runtimeSessionId = randomUUID();
+  messageStream = null;
+  queryInstance = null;
+  runtimeAbortController = null;
+  consumeTask = null;
+  activeResponse = null;
+  responseCompletionOutcome = null;
+  disposed = false;
+  lastStatus = null;
+  onMessage(handler) {
+    this.listeners.add(handler);
+  }
+  offMessage(handler) {
+    this.listeners.delete(handler);
+  }
+  async startSession(initialPrompt) {
+    if (initialPrompt) {
+      await this.sendPrompt(this.runtimeSessionId, initialPrompt);
+    }
+    return { sessionId: this.runtimeSessionId };
+  }
+  async sendPrompt(_sessionId, prompt) {
+    if (this.disposed) {
+      throw new Error("Claude runtime backend has already been disposed");
+    }
+    if (this.activeResponse) {
+      throw new Error("Claude runtime backend is already processing a prompt");
+    }
+    await this.ensureQueryStarted();
+    this.responseCompletionOutcome = null;
+    this.activeResponse = new Future();
+    void this.activeResponse.promise.catch(() => {
+    });
+    this.emitStatus("running");
+    this.messageStream.push({
+      type: "user",
+      message: {
+        role: "user",
+        content: prompt
+      }
+    });
+  }
+  async cancel(_sessionId) {
+    if (!this.queryInstance) {
+      return;
+    }
+    try {
+      await this.queryInstance.interrupt();
+    } catch (error) {
+      logger.debug("[ClaudeRuntimeBackend] Error interrupting Claude query:", error);
+    }
+  }
+  async waitForResponseComplete(timeoutMs = 12e4) {
+    if (this.responseCompletionOutcome) {
+      const outcome = this.responseCompletionOutcome;
+      if (outcome.kind === "rejected") {
+        throw outcome.error;
+      }
+      return;
+    }
+    if (!this.activeResponse) {
+      return;
+    }
+    let timeoutHandle;
+    try {
+      await Promise.race([
+        this.activeResponse.promise,
+        new Promise((_, reject) => {
+          timeoutHandle = setTimeout(() => reject(createTimeoutError(timeoutMs)), timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    const activeQuery = this.queryInstance;
+    this.rejectActiveResponse(new Error("Claude runtime backend disposed"));
+    this.messageStream?.end();
+    this.runtimeAbortController?.abort();
+    if (activeQuery && typeof activeQuery.return === "function") {
+      try {
+        await activeQuery.return();
+      } catch (error) {
+        logger.debug("[ClaudeRuntimeBackend] Error closing Claude query iterator:", error);
+      }
+    }
+    try {
+      await this.consumeTask;
+    } catch (error) {
+      logger.debug("[ClaudeRuntimeBackend] Error while disposing backend:", error);
+    } finally {
+      this.queryInstance = null;
+      this.messageStream = null;
+      this.runtimeAbortController = null;
+      this.consumeTask = null;
+      this.toolNamesByCallId.clear();
+      this.emitStatus("stopped");
+    }
+  }
+  emit(message) {
+    for (const listener of this.listeners) {
+      listener(message);
+    }
+  }
+  emitStatus(status, detail) {
+    if (this.lastStatus?.status === status && this.lastStatus.detail === detail) {
+      return;
+    }
+    const message = {
+      type: "status",
+      status,
+      ...detail ? { detail } : {}
+    };
+    this.lastStatus = message;
+    this.emit(message);
+  }
+  async ensureQueryStarted() {
+    if (this.queryInstance) {
+      return;
+    }
+    this.emitStatus("starting");
+    this.runtimeAbortController = new AbortController();
+    this.messageStream = new PushableAsyncIterable();
+    this.queryInstance = query({
+      prompt: this.messageStream,
+      options: {
+        cwd: this.options.cwd,
+        env: this.options.env,
+        allowedTools: this.options.allowedTools,
+        appendSystemPrompt: this.options.appendSystemPrompt,
+        customSystemPrompt: this.options.customSystemPrompt,
+        disallowedTools: this.options.disallowedTools,
+        extraArgs: this.options.args,
+        fallbackModel: this.options.fallbackModel,
+        mcpServers: this.options.mcpServers,
+        model: this.options.model,
+        pathToClaudeCodeExecutable: getClaudeExecutablePath(this.options.command),
+        permissionMode: this.options.permissionMode,
+        settingsPath: this.options.settingsPath,
+        canCallTool: this.options.permissionHandler ? async (toolName, input, requestOptions) => {
+          const requestId = requestOptions.requestId ?? randomUUID();
+          this.emit({
+            type: "permission-request",
+            id: requestId,
+            reason: `Claude wants to use ${toolName}`,
+            payload: {
+              toolName,
+              input
+            }
+          });
+          const decision = await this.options.permissionHandler.handleToolCall(requestId, toolName, input);
+          this.emit({
+            type: "permission-response",
+            id: requestId,
+            approved: decision.decision === "approved" || decision.decision === "approved_for_session"
+          });
+          return normalizePermissionResult(input, decision.decision);
+        } : void 0,
+        abort: this.runtimeAbortController.signal
+      }
+    });
+    this.consumeTask = this.consumeMessages(this.queryInstance);
+  }
+  async consumeMessages(activeQuery) {
+    try {
+      for await (const message of activeQuery) {
+        this.handleMessage(message);
+      }
+    } catch (error) {
+      const aborted = this.runtimeAbortController?.signal.aborted === true;
+      if (!aborted) {
+        const detail = normalizeClaudeBackendError(error);
+        this.emitStatus("error", detail);
+        this.rejectActiveResponse(new Error(detail));
+      }
+    } finally {
+      if (!this.disposed && this.activeResponse) {
+        const detail = "Claude runtime backend stopped before completing the response";
+        this.emitStatus("error", detail);
+        this.rejectActiveResponse(new Error(detail));
+      }
+      if (!this.disposed) {
+        this.queryInstance = null;
+        this.messageStream = null;
+        this.runtimeAbortController = null;
+        this.consumeTask = null;
+        this.emitStatus("stopped");
+      }
+    }
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "system":
+        this.handleSystemMessage(message);
+        return;
+      case "assistant":
+        this.handleAssistantMessage(message);
+        return;
+      case "user":
+        this.handleUserMessage(message);
+        return;
+      case "result":
+        this.handleResultMessage(message);
+        return;
+      default:
+        return;
+    }
+  }
+  handleSystemMessage(message) {
+    if (message.subtype === "init") {
+      this.emitStatus("running");
+      this.emit({
+        type: "event",
+        name: "session-init",
+        payload: {
+          sessionId: message.session_id,
+          cwd: message.cwd,
+          model: message.model,
+          tools: message.tools
+        }
+      });
+    }
+  }
+  handleAssistantMessage(message) {
+    for (const block of message.message.content ?? []) {
+      if (block.type === "text" && typeof block.text === "string" && block.text.length > 0) {
+        this.emit({
+          type: "model-output",
+          textDelta: block.text
+        });
+        continue;
+      }
+      if (block.type === "thinking") {
+        const thinkingText = isRecord(block) && typeof block.thinking === "string" ? block.thinking : "";
+        if (thinkingText) {
+          this.emit({
+            type: "event",
+            name: "thinking",
+            payload: { text: thinkingText }
+          });
+        }
+        continue;
+      }
+      if (block.type === "tool_use" && block.id && block.name) {
+        this.toolNamesByCallId.set(block.id, block.name);
+        this.emit({
+          type: "tool-call",
+          toolName: block.name,
+          args: isRecord(block.input) ? block.input : {},
+          callId: block.id
+        });
+      }
+    }
+  }
+  handleUserMessage(message) {
+    const content = Array.isArray(message.message.content) ? message.message.content : [];
+    for (const block of content) {
+      if (block.type !== "tool_result" || !block.tool_use_id) {
+        continue;
+      }
+      const toolName = this.toolNamesByCallId.get(block.tool_use_id) ?? "unknown";
+      this.emit({
+        type: "tool-result",
+        toolName,
+        result: block.content,
+        callId: block.tool_use_id
+      });
+      if (toolName === "Bash" && isRecord(message.tool_use_result)) {
+        const toolResult = message.tool_use_result;
+        const stdout = formatDisplayMessage(toolResult.stdout).trim();
+        const stderr = formatDisplayMessage(toolResult.stderr).trim();
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
+        if (combined) {
+          this.emit({
+            type: "terminal-output",
+            data: combined,
+            callId: block.tool_use_id
+          });
+        }
+      }
+    }
+  }
+  handleResultMessage(message) {
+    if (message.usage) {
+      this.emit({
+        type: "token-count",
+        ...message.usage,
+        duration_ms: message.duration_ms,
+        duration_api_ms: message.duration_api_ms,
+        total_cost_usd: message.total_cost_usd,
+        session_id: message.session_id
+      });
+    }
+    if (message.is_error) {
+      const detail = typeof message.result === "string" && message.result.trim().length > 0 ? message.result : message.subtype;
+      this.emitStatus("error", detail);
+      this.rejectActiveResponse(new Error(detail));
+      return;
+    }
+    this.emitStatus("idle");
+    this.resolveActiveResponse();
+  }
+  resolveActiveResponse() {
+    this.responseCompletionOutcome = { kind: "resolved" };
+    if (!this.activeResponse) {
+      return;
+    }
+    const active = this.activeResponse;
+    this.activeResponse = null;
+    active.resolve(void 0);
+  }
+  rejectActiveResponse(error) {
+    this.responseCompletionOutcome = { kind: "rejected", error };
+    if (!this.activeResponse) {
+      return;
+    }
+    const active = this.activeResponse;
+    this.activeResponse = null;
+    active.reject(error);
+  }
+}
+
 function mapToClaudeMode(mode) {
   const codexToClaudeMap = {
     "yolo": "bypassPermissions",
@@ -7363,14 +8409,8 @@ function mapToClaudeMode(mode) {
   return codexToClaudeMap[mode] ?? mode;
 }
 
-function ensureExperimentalAcp(args) {
-  if (args.includes("--experimental-acp")) {
-    return args;
-  }
-  return ["--experimental-acp", ...args];
-}
-function defaultClaudeArgs() {
-  return ensureExperimentalAcp([]);
+function defaultClaudeCommand() {
+  return process.env.HAPPY_CLAUDE_COMMAND ?? process.env.HAPPY_CLAUDE_ACP_COMMAND ?? "claude";
 }
 function appendStringFlag(args, flag, value) {
   if (value && value.trim().length > 0) {
@@ -7382,11 +8422,22 @@ function appendListFlag(args, flag, values) {
     args.push(flag, values.join(","));
   }
 }
-function resolveClaudeAcpArgs(options) {
-  if (options.args) {
-    return ensureExperimentalAcp([...options.args]);
+function normalizeClaudePassthroughArgs(options) {
+  const sourceArgs = options.args ?? options.baseArgs ?? [];
+  return sourceArgs.filter((arg) => arg !== "--experimental-acp");
+}
+function resolveClaudeCliArgs(options) {
+  const args = [
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--input-format",
+    "stream-json",
+    ...normalizeClaudePassthroughArgs(options)
+  ];
+  if (options.permissionHandler) {
+    args.push("--permission-prompt-tool", "stdio");
   }
-  const args = ensureExperimentalAcp([...options.baseArgs ?? []]);
   appendStringFlag(args, "--system-prompt", options.customSystemPrompt);
   appendStringFlag(args, "--append-system-prompt", options.appendSystemPrompt);
   appendStringFlag(args, "--model", options.model);
@@ -7400,27 +8451,28 @@ function resolveClaudeAcpArgs(options) {
   return args;
 }
 function createClaudeBackend(options) {
-  const command = options.command ?? process.env.HAPPY_CLAUDE_ACP_COMMAND ?? "claude";
-  const args = resolveClaudeAcpArgs({
-    ...options,
-    baseArgs: options.baseArgs ?? defaultClaudeArgs()
-  });
-  const backendOptions = {
-    agentName: "claude",
-    cwd: options.cwd,
-    command,
-    args,
-    env: {
-      ...options.env,
-      NODE_ENV: "production"
-    },
-    mcpServers: options.mcpServers,
-    permissionHandler: options.permissionHandler,
-    selectionHandler: options.selectionHandler,
-    transportHandler: claudeTransport
-  };
+  const command = options.command ?? defaultClaudeCommand();
+  const args = resolveClaudeCliArgs(options);
   return {
-    backend: new AcpBackend(backendOptions),
+    backend: new ClaudeCodeBackend({
+      cwd: options.cwd,
+      env: {
+        ...options.env,
+        NODE_ENV: "production"
+      },
+      command,
+      args: normalizeClaudePassthroughArgs(options),
+      model: options.model,
+      fallbackModel: options.fallbackModel,
+      permissionMode: options.permissionMode ? mapToClaudeMode(options.permissionMode) : void 0,
+      customSystemPrompt: options.customSystemPrompt,
+      appendSystemPrompt: options.appendSystemPrompt,
+      allowedTools: options.allowedTools,
+      disallowedTools: options.disallowedTools,
+      settingsPath: options.settingsPath,
+      mcpServers: options.mcpServers,
+      permissionHandler: options.permissionHandler
+    }),
     command,
     args
   };
@@ -7651,11 +8703,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await import('./runClaude-D7dF4RDM.mjs');
+    const { runClaude } = await import('./runClaude-kRPXCaBj.mjs');
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-DnGz1XES.mjs');
+    const { runCodex } = await import('./runCodex-B1xN0wAU.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -7664,7 +8716,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-B8tXMHeL.mjs');
+    const { runGemini } = await import('./runGemini-Xn2VwS88.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -7740,7 +8792,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-CMvWClny.mjs');
+      const { renderRuntimeProviders } = await import('./command-WcgGTRnG.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -7918,8 +8970,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-9Iu0wGNM.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-D1meoL-9.mjs').then(function (n) { return n.q; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-B89V4xY5.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-sRF6xXi-.mjs').then(function (n) { return n.q; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -8335,4 +9387,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ExitCodeError as E, GEMINI_MODEL_ENV as G, RuntimeShell as R, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, createCodexBackend as d, publishSessionRegistration as e, formatDisplayMessage as f, getInitialGeminiModel as g, resolveCanonicalToolNameV2 as h, initialMachineMetadata as i, getProjectPath as j, claudeLocal as k, isBun as l, trimIdent as m, claudeCheckSession as n, mapToClaudeMode as o, projectPath as p, getEnvironmentInfo as q, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, startCaffeinate as u, validateCodexAcpSpawn as v };
+export { AbortError as A, ExitCodeError as E, Future as F, GEMINI_MODEL_ENV as G, PushableAsyncIterable as P, RuntimeShell as R, createGeminiBackend as a, stopCaffeinate as b, createDefaultRuntimeShell as c, createCodexBackend as d, projectPath as e, formatDisplayMessage as f, getInitialGeminiModel as g, resolveCanonicalToolNameV2 as h, initialMachineMetadata as i, getProjectPath as j, claudeLocal as k, trimIdent as l, createClaudeBackend as m, claudeCheckSession as n, mapToClaudeMode as o, publishSessionRegistration as p, query as q, readGeminiLocalConfig as r, saveGeminiModelToConfig as s, truncateDisplayMessage as t, getEnvironmentInfo as u, validateCodexAcpSpawn as v, startCaffeinate as w };