happy-imou-cloud 2.0.13 → 2.0.16

package/dist/{index-CryJfCh5.cjs → index-B6ID1zDR.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chalk = require('chalk');
-var api = require('./api-DH5-IqeM.cjs');
-var persistence = require('./persistence-Bl3FYvwd.cjs');
+var api = require('./api-Db1SQcP_.cjs');
+var persistence = require('./persistence-Btu2VPXI.cjs');
 var z = require('zod');
 var fs$2 = require('fs/promises');
 var os$1 = require('os');
@@ -33,6 +33,7 @@ var node_readline = require('node:readline');
 var http = require('http');
 var util = require('util');
 var sdk = require('@agentclientprotocol/sdk');
+var node_url = require('node:url');
 require('node:events');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -71,7 +72,7 @@ async function openBrowser(url) {
   }
 }
 
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CryJfCh5.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-B6ID1zDR.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();
@@ -694,9 +695,9 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CryJfCh5.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-B6ID1zDR.cjs', document.baseURI).href))));
 function projectPath() {
-  const path = path$1.resolve(__dirname$1, "..");
+  const path = path$1.resolve(__dirname$2, "..");
   return path;
 }
 
@@ -4968,7 +4969,7 @@ class ClaudeTransport extends DefaultTransport {
     return 600;
   }
 }
-const claudeTransport = new ClaudeTransport();
+new ClaudeTransport();
 
 class CursorTransport extends DefaultTransport {
   constructor() {
@@ -5006,7 +5007,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) {
@@ -5019,7 +5020,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;
@@ -5042,7 +5043,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;
     }
   }
@@ -5056,7 +5057,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"];
@@ -5084,7 +5085,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 {
@@ -7376,6 +7377,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 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-B6ID1zDR.cjs', document.baseURI).href)));
+const __dirname$1 = path.join(__filename$1, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = node_child_process.execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: os.homedir(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    api.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;
+    api.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];
+      }
+    });
+    api.logger.debug("[Claude SDK] Removed Bun-specific environment variables for Node.js compatibility");
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = os.homedir();
+  const cleanEnv = getCleanEnv();
+  try {
+    node_child_process.execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    api.logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = node_child_process.execSync("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && fs.existsSync(result)) {
+        api.logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getDefaultClaudeCodePath() {
+  const nodeModulesPath = path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    api.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") {
+    api.logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    api.logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  api.logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    api.logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
+}
+function logDebug(message) {
+  if (process.env.DEBUG) {
+    api.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 = node_readline.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) {
+            api.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 && !fs.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 = node_child_process.spawn(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 path.resolve(path.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 = node_crypto.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) {
+      api.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) {
+        api.logger.debug("[ClaudeRuntimeBackend] Error closing Claude query iterator:", error);
+      }
+    }
+    try {
+      await this.consumeTask;
+    } catch (error) {
+      api.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 ?? node_crypto.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",
@@ -7385,14 +8431,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) {
@@ -7404,11 +8444,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);
@@ -7422,27 +8473,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
   };
@@ -7673,11 +8725,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-CDZxAF3l.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-C9-ylbQh.cjs'); });
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-Cik8VzFs.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-CRNBxY5f.cjs'); });
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -7686,7 +8738,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BM2BQ4I7.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BZ5hqJyl.cjs'); });
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -7762,7 +8814,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-Ch8Dgidj.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-eRjSBm2C.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -7940,8 +8992,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-Bl3FYvwd.cjs'); });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-DH5-IqeM.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-Btu2VPXI.cjs'); });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-Db1SQcP_.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();
@@ -8357,11 +9409,15 @@ ${chalk.bold("Examples:")}
   }
 }
 
+exports.AbortError = AbortError;
 exports.ExitCodeError = ExitCodeError;
+exports.Future = Future;
 exports.GEMINI_MODEL_ENV = GEMINI_MODEL_ENV;
+exports.PushableAsyncIterable = PushableAsyncIterable;
 exports.RuntimeShell = RuntimeShell;
 exports.claudeCheckSession = claudeCheckSession;
 exports.claudeLocal = claudeLocal;
+exports.createClaudeBackend = createClaudeBackend;
 exports.createCodexBackend = createCodexBackend;
 exports.createDefaultRuntimeShell = createDefaultRuntimeShell;
 exports.createGeminiBackend = createGeminiBackend;
@@ -8370,10 +9426,10 @@ exports.getEnvironmentInfo = getEnvironmentInfo;
 exports.getInitialGeminiModel = getInitialGeminiModel;
 exports.getProjectPath = getProjectPath;
 exports.initialMachineMetadata = initialMachineMetadata;
-exports.isBun = isBun;
 exports.mapToClaudeMode = mapToClaudeMode;
 exports.projectPath = projectPath;
 exports.publishSessionRegistration = publishSessionRegistration;
+exports.query = query;
 exports.readGeminiLocalConfig = readGeminiLocalConfig;
 exports.resolveCanonicalToolNameV2 = resolveCanonicalToolNameV2;
 exports.saveGeminiModelToConfig = saveGeminiModelToConfig;