happy-coder 0.1.14 → 0.2.1

package/dist/index.cjs

@@ -1,16 +1,15 @@
 'use strict';
 
 var chalk = require('chalk');
-var types = require('./types-Cg4664gs.cjs');
+var types = require('./types-CkPUFpfr.cjs');
 var node_crypto = require('node:crypto');
-var claudeCode = require('@anthropic-ai/claude-code');
+var node_child_process = require('node:child_process');
+var node_readline = require('node:readline');
 var node_fs = require('node:fs');
 var node_path = require('node:path');
+var node_url = require('node:url');
 var os = require('node:os');
 var promises = require('fs/promises');
-var node_child_process = require('node:child_process');
-var node_readline = require('node:readline');
-var node_url = require('node:url');
 var promises$1 = require('node:fs/promises');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var node_http = require('node:http');
@@ -50,6 +49,343 @@ function _interopNamespaceDefault(e) {
 
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
+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.cjs', document.baseURI).href)));
+const __dirname$3 = node_path.join(__filename$1, "..");
+function getDefaultClaudeCodePath() {
+  return node_path.join(__dirname$3, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+}
+function logDebug(message) {
+  if (process.env.DEBUG) {
+    types.logger.debug(message);
+    console.log(message);
+  }
+}
+async function streamToStdin(stream, stdin, abortController) {
+  for await (const message of stream) {
+    if (abortController.signal.aborted) break;
+    stdin.write(JSON.stringify(message) + "\n");
+  }
+  stdin.end();
+}
+
+class Query {
+  constructor(childStdin, childStdout, processExitPromise) {
+    this.childStdin = childStdin;
+    this.childStdout = childStdout;
+    this.processExitPromise = processExitPromise;
+    this.readMessages();
+    this.sdkMessages = this.readSdkMessages();
+  }
+  pendingControlResponses = /* @__PURE__ */ new Map();
+  sdkMessages;
+  inputStream = new Stream();
+  /**
+   * 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()) {
+          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;
+          }
+          this.inputStream.enqueue(message);
+        }
+      }
+      await this.processExitPromise;
+    } catch (error) {
+      this.inputStream.error(error);
+    } finally {
+      this.inputStream.done();
+      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");
+    });
+  }
+}
+function query(config) {
+  const {
+    prompt,
+    abortController = config.abortController || new AbortController(),
+    options: {
+      allowedTools = [],
+      appendSystemPrompt,
+      customSystemPrompt,
+      cwd,
+      disallowedTools = [],
+      executable = "node",
+      executableArgs = [],
+      maxTurns,
+      mcpServers,
+      pathToClaudeCodeExecutable = getDefaultClaudeCodePath(),
+      permissionMode = "default",
+      permissionPromptToolName,
+      continue: continueConversation,
+      resume,
+      model,
+      fallbackModel,
+      strictMcpConfig
+    } = {}
+  } = config;
+  if (!process.env.CLAUDE_CODE_ENTRYPOINT) {
+    process.env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+  }
+  const args = ["--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 (permissionPromptToolName) args.push("--permission-prompt-tool", permissionPromptToolName);
+  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 (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");
+  }
+  if (!node_fs.existsSync(pathToClaudeCodeExecutable)) {
+    throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
+  }
+  logDebug(`Spawning Claude Code process: ${executable} ${[...executableArgs, pathToClaudeCodeExecutable, ...args].join(" ")}`);
+  const child = node_child_process.spawn(executable, [...executableArgs, pathToClaudeCodeExecutable, ...args], {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal: abortController.signal,
+    env: {
+      ...process.env
+    }
+  });
+  let childStdin = null;
+  if (typeof prompt === "string") {
+    child.stdin.end();
+  } else {
+    streamToStdin(prompt, child.stdin, abortController);
+    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");
+    }
+  };
+  abortController.signal.addEventListener("abort", cleanup);
+  process.on("exit", cleanup);
+  const processExitPromise = new Promise((resolve) => {
+    child.on("close", (code) => {
+      if (abortController.signal.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);
+  child.on("error", (error) => {
+    if (abortController.signal.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();
+    abortController.signal.removeEventListener("abort", cleanup);
+    if (process.env.CLAUDE_SDK_MCP_SERVERS) {
+      delete process.env.CLAUDE_SDK_MCP_SERVERS;
+    }
+  });
+  return query2;
+}
+
 function formatClaudeMessage(message, onAssistantResult) {
   types.logger.debugLargeJson("[CLAUDE] Message from non interactive & remote mode:", message);
   switch (message.type) {
@@ -159,9 +495,8 @@ function formatClaudeMessage(message, onAssistantResult) {
       break;
     }
     default: {
-      const exhaustiveCheck = message;
       if (process.env.DEBUG) {
-        console.log(chalk.gray(`[Unknown message type]`), exhaustiveCheck);
+        console.log(chalk.gray(`[Unknown message type: ${message.type}]`));
       }
     }
   }
@@ -207,6 +542,19 @@ async function awaitFileExist(file, timeout = 1e4) {
   return false;
 }
 
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
 async function claudeRemote(opts) {
   let startFrom = opts.sessionId;
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
@@ -223,6 +571,7 @@ async function claudeRemote(opts) {
     resume: startFrom ?? void 0,
     mcpServers: opts.mcpServers,
     permissionPromptToolName: opts.permissionPromptToolName,
+    permissionMode: opts.permissionMode,
     executable: "node",
     abortController
   };
@@ -237,7 +586,7 @@ async function claudeRemote(opts) {
       if (response) {
         (async () => {
           try {
-            const r = await response.interrupt();
+            await response.interrupt();
           } catch (e) {
           }
           abortController.abort();
@@ -247,10 +596,9 @@ async function claudeRemote(opts) {
       }
     }
   });
-  types.logger.debug(`[claudeRemote] Starting query with messages`);
-  response = claudeCode.query({
-    prompt: opts.messages,
-    abortController,
+  types.logger.debug(`[claudeRemote] Starting query with permission mode: ${opts.permissionMode}`);
+  response = query({
+    prompt: opts.message,
     options: sdkOptions
   });
   if (opts.interruptController) {
@@ -270,21 +618,76 @@ async function claudeRemote(opts) {
       }
     }
   };
+  const toolCalls = [];
+  const resolveToolCallId = (name, args) => {
+    for (let i = toolCalls.length - 1; i >= 0; i--) {
+      const call = toolCalls[i];
+      if (call.name === name && deepEqual(call.input, args)) {
+        if (call.used) {
+          types.logger.debug("[claudeRemote] Warning: Permission request matched an already-used tool call");
+          return null;
+        }
+        call.used = true;
+        types.logger.debug(`[claudeRemote] Resolved tool call ID: ${call.id} for ${name}`);
+        return call.id;
+      }
+    }
+    types.logger.debug(`[claudeRemote] No matching tool call found for permission request: ${name}`);
+    return null;
+  };
+  if (opts.onToolCallResolver) {
+    opts.onToolCallResolver(resolveToolCallId);
+  }
   try {
     types.logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
       types.logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
       formatClaudeMessage(message, opts.onAssistantResult);
+      if (message.type === "assistant") {
+        const assistantMsg = message;
+        if (assistantMsg.message && assistantMsg.message.content) {
+          for (const block of assistantMsg.message.content) {
+            if (block.type === "tool_use") {
+              toolCalls.push({
+                id: block.id,
+                name: block.name,
+                input: block.input,
+                used: false
+              });
+              types.logger.debug(`[claudeRemote] Tracked tool call: ${block.id} - ${block.name}`);
+            }
+          }
+        }
+      }
+      if (message.type === "user") {
+        const userMsg = message;
+        if (userMsg.message && userMsg.message.content && Array.isArray(userMsg.message.content)) {
+          for (const block of userMsg.message.content) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              const toolCall = toolCalls.find((tc) => tc.id === block.tool_use_id);
+              if (toolCall && !toolCall.used) {
+                toolCall.used = true;
+                types.logger.debug(`[claudeRemote] Tool completed execution, marked as used: ${block.tool_use_id}`);
+              }
+            }
+          }
+        }
+      }
       if (message.type === "system" && message.subtype === "init") {
         updateThinking(true);
-        types.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${message.session_id}`);
-        const projectDir = getProjectPath(opts.path);
-        const found = await awaitFileExist(node_path.join(projectDir, `${message.session_id}.jsonl`));
-        types.logger.debug(`[claudeRemote] Session file found: ${message.session_id} ${found}`);
-        opts.onSessionFound(message.session_id);
+        const systemInit = message;
+        if (systemInit.session_id) {
+          types.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
+          const projectDir = getProjectPath(opts.path);
+          const found = await awaitFileExist(node_path.join(projectDir, `${systemInit.session_id}.jsonl`));
+          types.logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
+          opts.onSessionFound(systemInit.session_id);
+        }
       }
       if (message.type === "result") {
         updateThinking(false);
+        types.logger.debug("[claudeRemote] Result received, exiting claudeRemote");
+        break;
       }
     }
     types.logger.debug(`[claudeRemote] Finished iterating over response`);
@@ -292,13 +695,17 @@ async function claudeRemote(opts) {
     if (abortController.signal.aborted) {
       types.logger.debug(`[claudeRemote] Aborted`);
     }
-    if (e instanceof claudeCode.AbortError) {
+    if (e instanceof AbortError) {
       types.logger.debug(`[claudeRemote] Aborted`);
     } else {
       throw e;
     }
   } finally {
     updateThinking(false);
+    toolCalls.length = 0;
+    if (opts.onToolCallResolver) {
+      opts.onToolCallResolver(null);
+    }
     if (opts.interruptController) {
       opts.interruptController.unregister();
     }
@@ -446,58 +853,69 @@ async function claudeLocal(opts) {
   return resolvedSessionId;
 }
 
-class MessageQueue {
+class MessageQueue2 {
+  constructor(modeHasher) {
+    this.modeHasher = modeHasher;
+    types.logger.debug(`[MessageQueue2] Initialized`);
+  }
   queue = [];
-  waiters = [];
+  waiter = null;
   closed = false;
-  closePromise;
-  closeResolve;
-  constructor() {
-    this.closePromise = new Promise((resolve) => {
-      this.closeResolve = resolve;
-    });
-  }
   /**
-   * Push a message to the queue
+   * Push a message to the queue with a mode.
    */
-  push(message) {
+  push(message, mode) {
     if (this.closed) {
       throw new Error("Cannot push to closed queue");
     }
-    types.logger.debug(`[MessageQueue] push() called. Waiters: ${this.waiters.length}, Queue size before: ${this.queue.length}`);
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      types.logger.debug(`[MessageQueue] Found waiter! Delivering message directly: "${message}"`);
-      waiter({
-        type: "user",
-        message: {
-          role: "user",
-          content: message
-        },
-        parent_tool_use_id: null,
-        session_id: ""
-      });
-    } else {
-      types.logger.debug(`[MessageQueue] No waiter found. Adding to queue: "${message}"`);
-      this.queue.push({
-        type: "user",
-        message: {
-          role: "user",
-          content: message
-        },
-        parent_tool_use_id: null,
-        session_id: ""
-      });
+    const modeHash = this.modeHasher(mode);
+    types.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash
+    });
+    if (this.waiter) {
+      types.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    types.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message to the beginning of the queue with a mode.
+   */
+  unshift(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot unshift to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    types.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    this.queue.unshift({
+      message,
+      mode,
+      modeHash
+    });
+    if (this.waiter) {
+      types.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
     }
-    types.logger.debug(`[MessageQueue] push() completed. Waiters: ${this.waiters.length}, Queue size after: ${this.queue.length}`);
+    types.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
   }
   /**
    * Close the queue - no more messages can be pushed
    */
   close() {
-    types.logger.debug(`[MessageQueue] close() called. Waiters: ${this.waiters.length}`);
+    types.logger.debug(`[MessageQueue2] close() called`);
     this.closed = true;
-    this.closeResolve?.();
+    if (this.waiter) {
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(false);
+    }
   }
   /**
    * Check if the queue is closed
@@ -512,56 +930,91 @@ class MessageQueue {
     return this.queue.length;
   }
   /**
-   * Async iterator implementation
+   * Wait for messages and return all messages with the same mode as a single string
+   * Returns { message: string, mode: T } or null if aborted/closed
    */
-  async *[Symbol.asyncIterator]() {
-    types.logger.debug(`[MessageQueue] Iterator started`);
-    while (true) {
-      const message = this.queue.shift();
-      if (message !== void 0) {
-        types.logger.debug(`[MessageQueue] Iterator yielding queued message`);
-        yield message;
-        continue;
-      }
-      if (this.closed) {
-        types.logger.debug(`[MessageQueue] Iterator ending - queue closed`);
-        return;
-      }
-      types.logger.debug(`[MessageQueue] Iterator waiting for next message...`);
-      const nextMessage = await this.waitForNext();
-      if (nextMessage === void 0) {
-        types.logger.debug(`[MessageQueue] Iterator ending - no more messages`);
-        return;
-      }
-      types.logger.debug(`[MessageQueue] Iterator yielding waited message`);
-      yield nextMessage;
+  async waitForMessagesAndGetAsString(abortSignal) {
+    if (this.queue.length > 0) {
+      return this.collectBatch();
+    }
+    if (this.closed || abortSignal?.aborted) {
+      return null;
+    }
+    const hasMessages = await this.waitForMessages(abortSignal);
+    if (!hasMessages) {
+      return null;
+    }
+    return this.collectBatch();
+  }
+  /**
+   * Collect a batch of messages with the same mode
+   */
+  collectBatch() {
+    if (this.queue.length === 0) {
+      return null;
+    }
+    const firstItem = this.queue[0];
+    const sameModeMessages = [];
+    let mode = firstItem.mode;
+    const targetModeHash = firstItem.modeHash;
+    while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash) {
+      const item = this.queue.shift();
+      sameModeMessages.push(item.message);
     }
+    const combinedMessage = sameModeMessages.join("\n");
+    types.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+    return {
+      message: combinedMessage,
+      mode
+    };
   }
   /**
-   * Wait for the next message or queue closure
+   * Wait for messages to arrive
    */
-  waitForNext() {
+  waitForMessages(abortSignal) {
     return new Promise((resolve) => {
-      if (this.closed) {
-        types.logger.debug(`[MessageQueue] waitForNext() called but queue is closed`);
-        resolve(void 0);
+      let abortHandler = null;
+      if (abortSignal) {
+        abortHandler = () => {
+          types.logger.debug("[MessageQueue2] Wait aborted");
+          if (this.waiter === waiterFunc) {
+            this.waiter = null;
+          }
+          resolve(false);
+        };
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      const waiterFunc = (hasMessages) => {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(hasMessages);
+      };
+      if (this.queue.length > 0) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(true);
         return;
       }
-      const waiter = (value) => resolve(value);
-      this.waiters.push(waiter);
-      types.logger.debug(`[MessageQueue] waitForNext() adding waiter. Total waiters: ${this.waiters.length}`);
-      this.closePromise?.then(() => {
-        const index = this.waiters.indexOf(waiter);
-        if (index !== -1) {
-          this.waiters.splice(index, 1);
-          types.logger.debug(`[MessageQueue] waitForNext() waiter removed due to close. Remaining waiters: ${this.waiters.length}`);
-          resolve(void 0);
+      if (this.closed || abortSignal?.aborted) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
         }
-      });
+        resolve(false);
+        return;
+      }
+      this.waiter = waiterFunc;
+      types.logger.debug("[MessageQueue2] Waiting for messages...");
     });
   }
 }
 
+var MessageQueue2$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MessageQueue2: MessageQueue2
+});
+
 class InvalidateSync {
   _invalidated = false;
   _invalidatedDouble = false;
@@ -656,6 +1109,39 @@ function startFileWatcher(file, onFileChange) {
   };
 }
 
+const PLAN_FAKE_REJECT = `User approved plan, but you need to be restarted. STOP IMMEDIATELY TO SWITCH FROM PLAN MODE. DO NOT REPLY TO THIS MESSAGE.`;
+const PLAN_FAKE_RESTART = `PlEaZe Continue with plan.`;
+
+function hackToolResponse(message) {
+  console.debug("hackToolResponse", JSON.stringify(message, null, 2));
+  if (message.type === "user" && message.message?.role === "user" && message.message?.content && Array.isArray(message.message.content)) {
+    let modified = false;
+    const hackedContent = message.message.content.map((item) => {
+      if (item.type === "tool_result" && item.is_error === true) {
+        if (item.content === PLAN_FAKE_REJECT) {
+          types.logger.debug(`[SESSION_SCANNER] Hacking exit_plan_mode tool_result: flipping is_error from true to false`);
+          modified = true;
+          return {
+            ...item,
+            is_error: false,
+            content: "Plan approved"
+          };
+        }
+      }
+      return item;
+    });
+    if (modified) {
+      return {
+        ...message,
+        message: {
+          ...message.message,
+          content: hackedContent
+        }
+      };
+    }
+  }
+  return message;
+}
 function createSessionScanner(opts) {
   const projectDir = getProjectPath(opts.workingDirectory);
   let finishedSessions = /* @__PURE__ */ new Set();
@@ -708,7 +1194,8 @@ function createSessionScanner(opts) {
               continue;
             }
           }
-          opts.onMessage(message);
+          const hackedMessage = hackToolResponse(message);
+          opts.onMessage(hackedMessage);
         } catch (e) {
           types.logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
           continue;
@@ -808,10 +1295,15 @@ function sortKeys(value) {
 
 async function loop(opts) {
   let mode = opts.startingMode ?? "local";
-  let currentMessageQueue = new MessageQueue();
+  let currentPermissionMode = opts.permissionMode ?? "default";
+  types.logger.debug(`[loop] Starting with permission mode: ${currentPermissionMode}`);
+  let currentMessageQueue = opts.messageQueue || new MessageQueue2(
+    (mode2) => mode2
+    // Simple string hasher since modes are already strings
+  );
   let sessionId = null;
   let onMessage = null;
-  const sessionScanner = createSessionScanner({
+  const sessionScanner = opts.sessionScanner || createSessionScanner({
     workingDirectory: opts.path,
     onMessage: (message) => {
       opts.session.sendClaudeSessionMessage(message);
@@ -819,7 +1311,20 @@ async function loop(opts) {
   });
   opts.session.onUserMessage((message) => {
     sessionScanner.onRemoteUserMessageForDeduplication(message.content.text);
-    currentMessageQueue.push(message.content.text);
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      const validModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
+      if (validModes.includes(message.meta.permissionMode)) {
+        messagePermissionMode = message.meta.permissionMode;
+        currentPermissionMode = messagePermissionMode;
+        types.logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+      } else {
+        types.logger.info(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
+      }
+    } else {
+      types.logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
+    }
+    currentMessageQueue.push(message.content.text, messagePermissionMode);
     types.logger.debugLargeJson("User message pushed to queue:", message);
     if (onMessage) {
       onMessage();
@@ -830,6 +1335,7 @@ async function loop(opts) {
     sessionScanner.onNewSession(newSessionId);
   };
   while (true) {
+    types.logger.debug(`[loop] Starting loop iteration, queue size: ${currentMessageQueue.size()}, mode: ${mode}`);
     if (currentMessageQueue.size() > 0) {
       if (mode !== "remote") {
         mode = "remote";
@@ -837,7 +1343,6 @@ async function loop(opts) {
           opts.onModeChange(mode);
         }
       }
-      continue;
     }
     if (mode === "local") {
       let abortedOutside = false;
@@ -904,15 +1409,16 @@ async function loop(opts) {
       }
     }
     if (mode === "remote") {
+      console.log("Starting remote mode...");
       types.logger.debug("Starting " + sessionId);
       const remoteAbortController = new AbortController();
       opts.session.setHandler("abort", () => {
-        if (!remoteAbortController.signal.aborted) {
+        if (remoteAbortController && !remoteAbortController.signal.aborted) {
           remoteAbortController.abort();
         }
       });
       const abortHandler = () => {
-        if (!remoteAbortController.signal.aborted) {
+        if (remoteAbortController && !remoteAbortController.signal.aborted) {
           if (mode !== "local") {
             mode = "local";
             if (opts.onModeChange) {
@@ -934,22 +1440,35 @@ async function loop(opts) {
       process.stdin.on("data", abortHandler);
       try {
         types.logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
+        types.logger.debug("[loop] Waiting for messages before starting claudeRemote...");
+        const messageData = await currentMessageQueue.waitForMessagesAndGetAsString(remoteAbortController.signal);
+        if (!messageData) {
+          console.log("[LOOP] No message received (queue closed or aborted), continuing loop");
+          types.logger.debug("[loop] No message received (queue closed or aborted), skipping remote mode");
+          continue;
+        }
+        currentPermissionMode = messageData.mode;
+        types.logger.debug(`[loop] Using permission mode from queue: ${currentPermissionMode}`);
         if (opts.onProcessStart) {
           opts.onProcessStart("remote");
         }
+        opts.session.sendSessionEvent({ type: "permission-mode-changed", mode: currentPermissionMode });
+        types.logger.debug(`[loop] Sent permission-mode-changed event to app: ${currentPermissionMode}`);
         await claudeRemote({
           abort: remoteAbortController.signal,
           sessionId,
           path: opts.path,
           mcpServers: opts.mcpServers,
           permissionPromptToolName: opts.permissionPromptToolName,
+          permissionMode: currentPermissionMode,
           onSessionFound,
           onThinkingChange: opts.onThinkingChange,
-          messages: currentMessageQueue,
+          message: messageData.message,
           onAssistantResult: opts.onAssistantResult,
           interruptController: opts.interruptController,
           claudeEnvVars: opts.claudeEnvVars,
-          claudeArgs: opts.claudeArgs
+          claudeArgs: opts.claudeArgs,
+          onToolCallResolver: opts.onToolCallResolver
         });
       } catch (e) {
         if (!remoteAbortController.signal.aborted) {
@@ -963,8 +1482,6 @@ async function loop(opts) {
         if (process.stdin.isTTY) {
           process.stdin.setRawMode(false);
         }
-        currentMessageQueue.close();
-        currentMessageQueue = new MessageQueue();
       }
       if (mode !== "remote") {
         console.log("Switching back to good old claude...");
@@ -1073,7 +1590,7 @@ class InterruptController {
   }
 }
 
-var version = "0.1.14";
+var version = "0.2.1";
 var packageJson = {
 	version: version};
 
@@ -1133,6 +1650,7 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
         if (!request) return currentState;
         let r = { ...currentState.requests };
         delete r[id];
+        const isExitPlanModeSuccess = request.tool === "exit_plan_mode" && !message.approved && message.reason === PLAN_FAKE_REJECT;
         return {
           ...currentState,
           requests: r,
@@ -1141,8 +1659,8 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
             [id]: {
               ...request,
               completedAt: Date.now(),
-              status: message.approved ? "approved" : "denied",
-              reason: message.reason
+              status: isExitPlanModeSuccess ? "approved" : message.approved ? "approved" : "denied",
+              reason: isExitPlanModeSuccess ? "Plan approved" : message.reason
             }
           }
         };
@@ -1440,11 +1958,53 @@ async function start(credentials, options = {}) {
   types.logger.infoDeveloper(`Session: ${response.id}`);
   types.logger.infoDeveloper(`Logs: ${logPath}`);
   const interruptController = new InterruptController();
+  const { MessageQueue2 } = await Promise.resolve().then(function () { return MessageQueue2$1; });
+  const messageQueue = new MessageQueue2(
+    (mode2) => mode2
+    // Simple string hasher since modes are already strings
+  );
   let requests = /* @__PURE__ */ new Map();
+  let toolCallResolver = null;
+  const sessionScanner = createSessionScanner({
+    workingDirectory,
+    onMessage: (message) => {
+      session.sendClaudeSessionMessage(message);
+    }
+  });
   const permissionServer = await startPermissionServerV2(async (request) => {
-    const id = node_crypto.randomUUID();
+    if (!toolCallResolver) {
+      const error = `Tool call resolver not available for permission request: ${request.name}`;
+      types.logger.info(`ERROR: ${error}`);
+      throw new Error(error);
+    }
+    const toolCallId = toolCallResolver(request.name, request.arguments);
+    if (!toolCallId) {
+      const error = `Could not resolve tool call ID for permission request: ${request.name}`;
+      types.logger.info(`ERROR: ${error}`);
+      throw new Error(error);
+    }
+    const id = toolCallId;
+    types.logger.debug(`Using tool call ID as permission request ID: ${id} for ${request.name}`);
     let promise = new Promise((resolve) => {
-      requests.set(id, resolve);
+      if (request.name === "exit_plan_mode") {
+        const wrappedResolve = (response2) => {
+          if (response2.approved) {
+            types.logger.debug("[HACK] exit_plan_mode approved - injecting approval message and denying");
+            sessionScanner.onRemoteUserMessageForDeduplication(PLAN_FAKE_RESTART);
+            messageQueue.unshift(PLAN_FAKE_RESTART, "default");
+            types.logger.debug(`[HACK] Message queue size after unshift: ${messageQueue.size()}`);
+            resolve({
+              approved: false,
+              reason: PLAN_FAKE_REJECT
+            });
+          } else {
+            resolve(response2);
+          }
+        };
+        requests.set(id, wrappedResolve);
+      } else {
+        requests.set(id, resolve);
+      }
     });
     let timeout = setTimeout(async () => {
       types.logger.debug("Permission timeout - attempting to interrupt Claude");
@@ -1528,12 +2088,15 @@ async function start(credentials, options = {}) {
     model: options.model,
     permissionMode: options.permissionMode,
     startingMode: options.startingMode,
+    messageQueue,
+    sessionScanner,
     onModeChange: (newMode) => {
       mode = newMode;
       session.sendSessionEvent({ type: "switch", mode: newMode });
       session.keepAlive(thinking, mode);
       if (newMode === "local") {
         types.logger.debug("Switching to local mode - clearing pending permission requests");
+        toolCallResolver = null;
         for (const [id, resolve] of requests) {
           types.logger.debug(`Rejecting pending permission request: ${id}`);
           resolve({ approved: false, reason: "Session switched to local mode" });
@@ -1600,6 +2163,9 @@ async function start(credentials, options = {}) {
     onThinkingChange: (newThinking) => {
       thinking = newThinking;
       session.keepAlive(thinking, mode);
+    },
+    onToolCallResolver: (resolver) => {
+      toolCallResolver = resolver;
     }
   });
   clearInterval(pingInterval);
@@ -1860,7 +2426,6 @@ class ApiDaemonSession extends node_events.EventEmitter {
   startKeepAlive() {
     this.stopKeepAlive();
     this.keepAliveInterval = setInterval(() => {
-      types.logger.daemonDebug("Sending keep-alive ping");
       this.socket.volatile.emit("machine-alive", {
         time: Date.now()
       });
@@ -2286,7 +2851,7 @@ Currently only supported on macOS.
       } else if (arg === "-m" || arg === "--model") {
         options.model = args[++i];
       } else if (arg === "-p" || arg === "--permission-mode") {
-        options.permissionMode = z.z.enum(["auto", "default", "plan"]).parse(args[++i]);
+        options.permissionMode = z.z.enum(["default", "acceptEdits", "bypassPermissions", "plan"]).parse(args[++i]);
       } else if (arg === "--local") ; else if (arg === "--happy-starting-mode") {
         options.startingMode = z.z.enum(["local", "remote"]).parse(args[++i]);
       } else if (arg === "--claude-env") {
@@ -2322,7 +2887,7 @@ ${chalk.bold("Options:")}
   -h, --help              Show this help message
   -v, --version           Show version
   -m, --model <model>     Claude model to use (default: sonnet)
-  -p, --permission-mode   Permission mode: auto, default, or plan
+  -p, --permission-mode   Permission mode: default, acceptEdits, bypassPermissions, or plan
   --auth, --login         Force re-authentication
   --claude-env KEY=VALUE  Set environment variable for Claude Code
   --claude-arg ARG        Pass additional argument to Claude CLI
@@ -2394,7 +2959,7 @@ ${chalk.bold("Examples:")}
       await writeSettings(settings);
     }
     if (settings.daemonAutoStartWhenRunningHappy) {
-      console.log("Starting Happy background service...");
+      console.debug("Starting Happy background service...");
       if (!await isDaemonRunning()) {
         const happyPath = process.argv[1];
         const isBuiltBinary = happyPath.endsWith("/bin/happy") || happyPath.endsWith("\\bin\\happy");