happy-coder 0.1.13 → 0.2.0

package/dist/index.mjs

@@ -1,17 +1,16 @@
 import chalk from 'chalk';
-import { l as logger, d as delay, e as backoff, R as RawJSONLinesSchema, A as ApiClient, c as configuration, f as encodeBase64, g as encodeBase64Url, h as decodeBase64, j as encrypt, k as decrypt, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-D39L8JSd.mjs';
+import { l as logger, d as delay, e as backoff, R as RawJSONLinesSchema, c as configuration, f as encodeBase64, A as ApiClient, g as encodeBase64Url, h as decodeBase64, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-DNu8okOb.mjs';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { query, AbortError } from '@anthropic-ai/claude-code';
-import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
-import { resolve, join, dirname } from 'node:path';
-import os, { homedir } from 'node:os';
-import { access, watch as watch$1, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
+import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import os, { homedir } from 'node:os';
+import { access, watch as watch$1, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
 import { readFile, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { createServer, ServerResponse } from 'node:http';
+import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import * as z from 'zod';
 import { z as z$1 } from 'zod';
@@ -20,16 +19,352 @@ import { promisify } from 'util';
 import crypto, { createHash } from 'crypto';
 import { dirname as dirname$1, join as join$1 } from 'path';
 import { fileURLToPath as fileURLToPath$1 } from 'url';
-import httpProxy from 'http-proxy';
 import tweetnacl from 'tweetnacl';
 import axios from 'axios';
 import qrcode from 'qrcode-terminal';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import { hostname, homedir as homedir$1 } from 'os';
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, unlinkSync, mkdirSync as mkdirSync$1, writeFileSync, chmodSync } from 'fs';
+import { closeSync, existsSync as existsSync$1, readFileSync as readFileSync$1, unlinkSync, mkdirSync as mkdirSync$1, openSync, writeSync, writeFileSync, chmodSync } from 'fs';
 import 'expo-server-sdk';
 
+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 = fileURLToPath(import.meta.url);
+const __dirname$2 = join(__filename, "..");
+function getDefaultClaudeCodePath() {
+  return join(__dirname$2, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+}
+function logDebug(message) {
+  if (process.env.DEBUG) {
+    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 = 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 (!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 = 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) {
   logger.debugLargeJson("[CLAUDE] Message from non interactive & remote mode:", message);
   switch (message.type) {
@@ -139,9 +474,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}]`));
       }
     }
   }
@@ -187,6 +521,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)) {
@@ -203,6 +550,7 @@ async function claudeRemote(opts) {
     resume: startFrom ?? void 0,
     mcpServers: opts.mcpServers,
     permissionPromptToolName: opts.permissionPromptToolName,
+    permissionMode: opts.permissionMode,
     executable: "node",
     abortController
   };
@@ -217,7 +565,7 @@ async function claudeRemote(opts) {
       if (response) {
         (async () => {
           try {
-            const r = await response.interrupt();
+            await response.interrupt();
           } catch (e) {
           }
           abortController.abort();
@@ -227,10 +575,9 @@ async function claudeRemote(opts) {
       }
     }
   });
-  logger.debug(`[claudeRemote] Starting query with messages`);
+  logger.debug(`[claudeRemote] Starting query with permission mode: ${opts.permissionMode}`);
   response = query({
-    prompt: opts.messages,
-    abortController,
+    prompt: opts.message,
     options: sdkOptions
   });
   if (opts.interruptController) {
@@ -240,17 +587,86 @@ async function claudeRemote(opts) {
     });
   }
   printDivider();
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  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) {
+          logger.debug("[claudeRemote] Warning: Permission request matched an already-used tool call");
+          return null;
+        }
+        call.used = true;
+        logger.debug(`[claudeRemote] Resolved tool call ID: ${call.id} for ${name}`);
+        return call.id;
+      }
+    }
+    logger.debug(`[claudeRemote] No matching tool call found for permission request: ${name}`);
+    return null;
+  };
+  if (opts.onToolCallResolver) {
+    opts.onToolCallResolver(resolveToolCallId);
+  }
   try {
     logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
       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
+              });
+              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;
+                logger.debug(`[claudeRemote] Tool completed execution, marked as used: ${block.tool_use_id}`);
+              }
+            }
+          }
+        }
+      }
       if (message.type === "system" && message.subtype === "init") {
-        logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${message.session_id}`);
-        const projectDir = getProjectPath(opts.path);
-        const found = await awaitFileExist(join(projectDir, `${message.session_id}.jsonl`));
-        logger.debug(`[claudeRemote] Session file found: ${message.session_id} ${found}`);
-        opts.onSessionFound(message.session_id);
+        updateThinking(true);
+        const systemInit = message;
+        if (systemInit.session_id) {
+          logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
+          const projectDir = getProjectPath(opts.path);
+          const found = await awaitFileExist(join(projectDir, `${systemInit.session_id}.jsonl`));
+          logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
+          opts.onSessionFound(systemInit.session_id);
+        }
+      }
+      if (message.type === "result") {
+        updateThinking(false);
+        logger.debug("[claudeRemote] Result received, exiting claudeRemote");
+        break;
       }
     }
     logger.debug(`[claudeRemote] Finished iterating over response`);
@@ -264,6 +680,11 @@ async function claudeRemote(opts) {
       throw e;
     }
   } finally {
+    updateThinking(false);
+    toolCalls.length = 0;
+    if (opts.onToolCallResolver) {
+      opts.onToolCallResolver(null);
+    }
     if (opts.interruptController) {
       opts.interruptController.unregister();
     }
@@ -327,22 +748,70 @@ async function claudeLocal(opts) {
           input: child.stdio[3],
           crlfDelay: Infinity
         });
-        rl.on("line", (line) => {
-          const sessionMatch = line.match(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i);
-          if (sessionMatch) {
-            detectedIdsRandomUUID.add(sessionMatch[0]);
-            if (resolvedSessionId) {
-              return;
+        const activeFetches = /* @__PURE__ */ new Map();
+        let thinking = false;
+        let stopThinkingTimeout = null;
+        const updateThinking = (newThinking) => {
+          if (thinking !== newThinking) {
+            thinking = newThinking;
+            logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+            if (opts.onThinkingChange) {
+              opts.onThinkingChange(thinking);
             }
-            if (detectedIdsFileSystem.has(sessionMatch[0])) {
-              resolvedSessionId = sessionMatch[0];
-              opts.onSessionFound(sessionMatch[0]);
+          }
+        };
+        rl.on("line", (line) => {
+          try {
+            const message = JSON.parse(line);
+            switch (message.type) {
+              case "uuid":
+                detectedIdsRandomUUID.add(message.value);
+                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
+                  resolvedSessionId = message.value;
+                  opts.onSessionFound(message.value);
+                }
+                break;
+              case "fetch-start":
+                logger.debug(`[ClaudeLocal] Fetch start: ${message.method} ${message.hostname}${message.path} (id: ${message.id})`);
+                activeFetches.set(message.id, {
+                  hostname: message.hostname,
+                  path: message.path,
+                  startTime: message.timestamp
+                });
+                if (stopThinkingTimeout) {
+                  clearTimeout(stopThinkingTimeout);
+                  stopThinkingTimeout = null;
+                }
+                updateThinking(true);
+                break;
+              case "fetch-end":
+                logger.debug(`[ClaudeLocal] Fetch end: id ${message.id}`);
+                activeFetches.delete(message.id);
+                if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
+                  stopThinkingTimeout = setTimeout(() => {
+                    if (activeFetches.size === 0) {
+                      updateThinking(false);
+                    }
+                    stopThinkingTimeout = null;
+                  }, 500);
+                }
+                break;
+              default:
+                logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
             }
+          } catch (e) {
+            logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
           }
         });
         rl.on("error", (err) => {
           console.error("Error reading from fd 3:", err);
         });
+        child.on("exit", () => {
+          if (stopThinkingTimeout) {
+            clearTimeout(stopThinkingTimeout);
+          }
+          updateThinking(false);
+        });
       }
       child.on("error", (error) => {
       });
@@ -363,58 +832,69 @@ async function claudeLocal(opts) {
   return resolvedSessionId;
 }
 
-class MessageQueue {
+class MessageQueue2 {
+  constructor(modeHasher) {
+    this.modeHasher = modeHasher;
+    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");
     }
-    logger.debug(`[MessageQueue] push() called. Waiters: ${this.waiters.length}, Queue size before: ${this.queue.length}`);
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      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 {
-      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);
+    logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash
+    });
+    if (this.waiter) {
+      logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
     }
-    logger.debug(`[MessageQueue] push() completed. Waiters: ${this.waiters.length}, Queue size after: ${this.queue.length}`);
+    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);
+    logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    this.queue.unshift({
+      message,
+      mode,
+      modeHash
+    });
+    if (this.waiter) {
+      logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
   }
   /**
    * Close the queue - no more messages can be pushed
    */
   close() {
-    logger.debug(`[MessageQueue] close() called. Waiters: ${this.waiters.length}`);
+    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
@@ -429,56 +909,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]() {
-    logger.debug(`[MessageQueue] Iterator started`);
-    while (true) {
-      const message = this.queue.shift();
-      if (message !== void 0) {
-        logger.debug(`[MessageQueue] Iterator yielding queued message`);
-        yield message;
-        continue;
-      }
-      if (this.closed) {
-        logger.debug(`[MessageQueue] Iterator ending - queue closed`);
-        return;
-      }
-      logger.debug(`[MessageQueue] Iterator waiting for next message...`);
-      const nextMessage = await this.waitForNext();
-      if (nextMessage === void 0) {
-        logger.debug(`[MessageQueue] Iterator ending - no more messages`);
-        return;
-      }
-      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");
+    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) {
-        logger.debug(`[MessageQueue] waitForNext() called but queue is closed`);
-        resolve(void 0);
+      let abortHandler = null;
+      if (abortSignal) {
+        abortHandler = () => {
+          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);
-      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);
-          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;
+      logger.debug("[MessageQueue2] Waiting for messages...");
     });
   }
 }
 
+var MessageQueue2$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MessageQueue2: MessageQueue2
+});
+
 class InvalidateSync {
   _invalidated = false;
   _invalidatedDouble = false;
@@ -573,6 +1088,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.log("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) {
+          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();
@@ -625,7 +1173,8 @@ function createSessionScanner(opts) {
               continue;
             }
           }
-          opts.onMessage(message);
+          const hackedMessage = hackToolResponse(message);
+          opts.onMessage(hackedMessage);
         } catch (e) {
           logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
           continue;
@@ -725,10 +1274,15 @@ function sortKeys(value) {
 
 async function loop(opts) {
   let mode = opts.startingMode ?? "local";
-  let currentMessageQueue = new MessageQueue();
+  let currentPermissionMode = opts.permissionMode ?? "default";
+  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);
@@ -736,7 +1290,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;
+        logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+      } else {
+        logger.info(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
+      }
+    } else {
+      logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
+    }
+    currentMessageQueue.push(message.content.text, messagePermissionMode);
     logger.debugLargeJson("User message pushed to queue:", message);
     if (onMessage) {
       onMessage();
@@ -747,6 +1314,7 @@ async function loop(opts) {
     sessionScanner.onNewSession(newSessionId);
   };
   while (true) {
+    logger.debug(`[loop] Starting loop iteration, queue size: ${currentMessageQueue.size()}, mode: ${mode}`);
     if (currentMessageQueue.size() > 0) {
       if (mode !== "remote") {
         mode = "remote";
@@ -754,7 +1322,6 @@ async function loop(opts) {
           opts.onModeChange(mode);
         }
       }
-      continue;
     }
     if (mode === "local") {
       let abortedOutside = false;
@@ -798,6 +1365,7 @@ async function loop(opts) {
           path: opts.path,
           sessionId,
           onSessionFound,
+          onThinkingChange: opts.onThinkingChange,
           abort: interactiveAbortController.signal,
           claudeEnvVars: opts.claudeEnvVars,
           claudeArgs: opts.claudeArgs
@@ -820,15 +1388,16 @@ async function loop(opts) {
       }
     }
     if (mode === "remote") {
+      console.log("Starting remote mode...");
       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) {
@@ -850,21 +1419,35 @@ async function loop(opts) {
       process.stdin.on("data", abortHandler);
       try {
         logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
+        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");
+          logger.debug("[loop] No message received (queue closed or aborted), skipping remote mode");
+          continue;
+        }
+        currentPermissionMode = messageData.mode;
+        logger.debug(`[loop] Using permission mode from queue: ${currentPermissionMode}`);
         if (opts.onProcessStart) {
           opts.onProcessStart("remote");
         }
+        opts.session.sendSessionEvent({ type: "permission-mode-changed", mode: currentPermissionMode });
+        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,
-          messages: currentMessageQueue,
+          onThinkingChange: opts.onThinkingChange,
+          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) {
@@ -878,8 +1461,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...");
@@ -988,7 +1569,7 @@ class InterruptController {
   }
 }
 
-var version = "0.1.13";
+var version = "0.2.0";
 var packageJson = {
 	version: version};
 
@@ -1048,6 +1629,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,
@@ -1056,8 +1638,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
             }
           }
         };
@@ -1273,148 +1855,77 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
   });
 }
 
-async function startHTTPDirectProxy(options) {
-  const proxy = httpProxy.createProxyServer({
-    target: options.target,
-    changeOrigin: true,
-    secure: false
-  });
-  proxy.on("error", (err, req, res) => {
-    logger.debug(`[HTTPProxy] Proxy error: ${err.message} for ${req.method} ${req.url}`);
-    if (res instanceof ServerResponse && !res.headersSent) {
-      res.writeHead(500, { "Content-Type": "text/plain" });
-      res.end("Proxy error");
-    }
-  });
-  proxy.on("proxyReq", (proxyReq, req, res) => {
-    if (options.onRequest) {
-      options.onRequest(req, proxyReq);
-    }
-  });
-  proxy.on("proxyRes", (proxyRes, req, res) => {
-    if (options.onResponse) {
-      options.onResponse(req, proxyRes);
-    }
-  });
-  const server = createServer((req, res) => {
-    proxy.web(req, res);
-  });
-  const url = await new Promise((resolve, reject) => {
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      if (addr && typeof addr === "object") {
-        const proxyUrl = `http://127.0.0.1:${addr.port}`;
-        logger.debug(`[HTTPProxy] Started on ${proxyUrl} --> ${options.target}`);
-        resolve(proxyUrl);
-      } else {
-        reject(new Error("Failed to get server address"));
-      }
-    });
-  });
-  return url;
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await readFile(configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
 }
-
-async function startClaudeActivityTracker(onThinking) {
-  logger.debug(`[ClaudeActivityTracker] Starting activity tracker`);
-  let requestCounter = 0;
-  const activeRequests = /* @__PURE__ */ new Map();
-  let stopThinkingTimeout = null;
-  let isThinking = false;
-  const REQUEST_TIMEOUT = 5 * 60 * 1e3;
-  const checkAndStopThinking = () => {
-    if (activeRequests.size === 0 && isThinking && !stopThinkingTimeout) {
-      stopThinkingTimeout = setTimeout(() => {
-        if (isThinking && activeRequests.size === 0) {
-          isThinking = false;
-          onThinking(false);
-        }
-        stopThinkingTimeout = null;
-      }, 500);
-    }
-  };
-  const proxyUrl = await startHTTPDirectProxy({
-    target: process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
-    onRequest: (req, proxyReq) => {
-      if (req.method === "POST" && req.url?.startsWith("/v1/messages")) {
-        const requestId = ++requestCounter;
-        req._requestId = requestId;
-        if (stopThinkingTimeout) {
-          clearTimeout(stopThinkingTimeout);
-          stopThinkingTimeout = null;
-        }
-        const timeout = setTimeout(() => {
-          activeRequests.delete(requestId);
-          checkAndStopThinking();
-        }, REQUEST_TIMEOUT);
-        activeRequests.set(requestId, timeout);
-        if (!isThinking) {
-          isThinking = true;
-          onThinking(true);
-        }
-      }
-    },
-    onResponse: (req, proxyRes) => {
-      proxyRes.headers["connection"] = "close";
-      if (req.method === "POST" && req.url?.startsWith("/v1/messages")) {
-        const requestId = req._requestId;
-        const timeout = activeRequests.get(requestId);
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-        let cleaned = false;
-        const cleanupRequest = () => {
-          if (!cleaned) {
-            cleaned = true;
-            activeRequests.delete(requestId);
-            checkAndStopThinking();
-          }
-        };
-        proxyRes.on("end", () => {
-          cleanupRequest();
-        });
-        proxyRes.on("error", (err) => {
-          cleanupRequest();
-        });
-        proxyRes.on("aborted", () => {
-          cleanupRequest();
-        });
-        proxyRes.on("close", () => {
-          cleanupRequest();
-        });
-        req.on("close", () => {
-          cleanupRequest();
-        });
-      }
-    }
-  });
-  const reset = () => {
-    for (const [requestId, timeout] of activeRequests) {
-      clearTimeout(timeout);
-    }
-    activeRequests.clear();
-    if (stopThinkingTimeout) {
-      clearTimeout(stopThinkingTimeout);
-      stopThinkingTimeout = null;
-    }
-    if (isThinking) {
-      isThinking = false;
-      onThinking(false);
-    }
-  };
-  return {
-    proxyUrl,
-    reset
-  };
+async function writeSettings(settings) {
+  if (!existsSync(configuration.happyDir)) {
+    await mkdir(configuration.happyDir, { recursive: true });
+  }
+  await writeFile$1(configuration.settingsFile, JSON.stringify(settings, null, 2));
+}
+const credentialsSchema = z.object({
+  secret: z.string().base64(),
+  token: z.string()
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    return {
+      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
+      token: credentials.token
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCredentials(credentials) {
+  if (!existsSync(configuration.happyDir)) {
+    await mkdir(configuration.happyDir, { recursive: true });
+  }
+  await writeFile$1(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
 }
 
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = randomUUID();
+  if (options.daemonSpawn && options.startingMode === "local") {
+    logger.debug("Daemon spawn requested with local mode - forcing remote mode");
+    options.startingMode = "remote";
+  }
   const api = new ApiClient(credentials.token, credentials.secret);
   let state = {};
-  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version, os: os.platform() };
+  const settings = await readSettings() || { };
+  let metadata = {
+    path: workingDirectory,
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId: settings.machineId
+  };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   logger.debug(`Session created: ${response.id}`);
+  if (options.daemonSpawn) {
+    console.log(`daemon:sessionIdCreated:${response.id}`);
+  }
   const session = api.session(response);
   const pushClient = api.push();
   let thinking = false;
@@ -1422,20 +1933,57 @@ async function start(credentials, options = {}) {
   let pingInterval = setInterval(() => {
     session.keepAlive(thinking, mode);
   }, 2e3);
-  const activityTracker = await startClaudeActivityTracker((newThinking) => {
-    thinking = newThinking;
-    session.keepAlive(thinking, mode);
-  });
-  process.env.ANTHROPIC_BASE_URL = activityTracker.proxyUrl;
   const logPath = await logger.logFilePathPromise;
   logger.infoDeveloper(`Session: ${response.id}`);
   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 = randomUUID();
+    if (!toolCallResolver) {
+      const error = `Tool call resolver not available for permission request: ${request.name}`;
+      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}`;
+      logger.info(`ERROR: ${error}`);
+      throw new Error(error);
+    }
+    const id = toolCallId;
+    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) {
+            logger.debug("[HACK] exit_plan_mode approved - injecting approval message and denying");
+            sessionScanner.onRemoteUserMessageForDeduplication(PLAN_FAKE_RESTART);
+            messageQueue.unshift(PLAN_FAKE_RESTART, "default");
+            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 () => {
       logger.debug("Permission timeout - attempting to interrupt Claude");
@@ -1519,12 +2067,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") {
         logger.debug("Switching to local mode - clearing pending permission requests");
+        toolCallResolver = null;
         for (const [id, resolve] of requests) {
           logger.debug(`Rejecting pending permission request: ${id}`);
           resolve({ approved: false, reason: "Session switched to local mode" });
@@ -1558,7 +2109,6 @@ async function start(credentials, options = {}) {
     },
     onProcessStart: (processMode) => {
       logger.debug(`[Process Lifecycle] Starting ${processMode} mode`);
-      activityTracker.reset();
       logger.debug("Starting process - clearing any stale permission requests");
       for (const [id, resolve] of requests) {
         logger.debug(`Rejecting stale permission request: ${id}`);
@@ -1568,13 +2118,14 @@ async function start(credentials, options = {}) {
     },
     onProcessStop: (processMode) => {
       logger.debug(`[Process Lifecycle] Stopped ${processMode} mode`);
-      activityTracker.reset();
       logger.debug("Stopping process - clearing any stale permission requests");
       for (const [id, resolve] of requests) {
         logger.debug(`Rejecting stale permission request: ${id}`);
         resolve({ approved: false, reason: "Process restarted" });
       }
       requests.clear();
+      thinking = false;
+      session.keepAlive(thinking, mode);
     },
     mcpServers: {
       "permission": {
@@ -1587,61 +2138,19 @@ async function start(credentials, options = {}) {
     onAssistantResult,
     interruptController,
     claudeEnvVars: options.claudeEnvVars,
-    claudeArgs: options.claudeArgs
+    claudeArgs: options.claudeArgs,
+    onThinkingChange: (newThinking) => {
+      thinking = newThinking;
+      session.keepAlive(thinking, mode);
+    },
+    onToolCallResolver: (resolver) => {
+      toolCallResolver = resolver;
+    }
   });
   clearInterval(pingInterval);
   process.exit(0);
 }
 
-const defaultSettings = {
-  onboardingCompleted: false
-};
-async function readSettings() {
-  if (!existsSync(configuration.settingsFile)) {
-    return { ...defaultSettings };
-  }
-  try {
-    const content = await readFile(configuration.settingsFile, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return { ...defaultSettings };
-  }
-}
-async function writeSettings(settings) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
-  }
-  await writeFile$1(configuration.settingsFile, JSON.stringify(settings, null, 2));
-}
-const credentialsSchema = z.object({
-  secret: z.string().base64(),
-  token: z.string()
-});
-async function readCredentials() {
-  if (!existsSync(configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
-    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
-    return {
-      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
-      token: credentials.token
-    };
-  } catch {
-    return null;
-  }
-}
-async function writeCredentials(credentials) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
-  }
-  await writeFile$1(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
-}
-
 function displayQRCode(url) {
   console.log("=".repeat(80));
   console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
@@ -1669,10 +2178,8 @@ async function doAuth() {
   console.log("Please, authenticate using mobile app");
   const authUrl = "happy://terminal?" + encodeBase64Url(keypair.publicKey);
   displayQRCode(authUrl);
-  if (process.env.DEBUG === "1") {
-    console.log("\n\u{1F4CB} For manual entry, copy this URL:");
-    console.log(authUrl);
-  }
+  console.log("\n\u{1F4CB} For manual entry, copy this URL:");
+  console.log(authUrl);
   let credentials = null;
   while (true) {
     try {
@@ -1720,18 +2227,20 @@ class ApiDaemonSession extends EventEmitter {
   keepAliveInterval = null;
   token;
   secret;
+  spawnedProcesses = /* @__PURE__ */ new Set();
   constructor(token, secret, machineIdentity) {
     super();
     this.token = token;
     this.secret = secret;
     this.machineIdentity = machineIdentity;
+    logger.daemonDebug(`Connecting to server: ${configuration.serverUrl}`);
     const socket = io(configuration.serverUrl, {
       auth: {
         token: this.token,
         clientType: "machine-scoped",
         machineId: this.machineIdentity.machineId
       },
-      path: "/v1/user-machine-daemon",
+      path: "/v1/updates",
       reconnection: true,
       reconnectionAttempts: Infinity,
       reconnectionDelay: 1e3,
@@ -1741,68 +2250,146 @@ class ApiDaemonSession extends EventEmitter {
       autoConnect: false
     });
     socket.on("connect", () => {
-      logger.debug("[DAEMON] Connected to server");
+      logger.daemonDebug("Socket connected");
+      logger.daemonDebug(`Connected with auth - token: ${this.token.substring(0, 10)}..., machineId: ${this.machineIdentity.machineId}`);
+      const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
+      socket.emit("rpc-register", { method: rpcMethod });
+      logger.daemonDebug(`Emitted RPC registration: ${rpcMethod}`);
       this.emit("connected");
-      socket.emit("machine-connect", {
-        token: this.token,
-        machineIdentity: encodeBase64(encrypt(this.machineIdentity, this.secret))
-      });
       this.startKeepAlive();
     });
-    socket.on("disconnect", () => {
-      logger.debug("[DAEMON] Disconnected from server");
-      this.emit("disconnected");
-      this.stopKeepAlive();
-    });
-    socket.on("spawn-session", async (encryptedData, callback) => {
-      let requestData;
-      try {
-        requestData = decrypt(decodeBase64(encryptedData), this.secret);
-        logger.debug("[DAEMON] Received spawn-session request", requestData);
-        const args = [
-          "--directory",
-          requestData.directory,
-          "--happy-starting-mode",
-          requestData.startingMode
-        ];
-        if (requestData.metadata) {
-          args.push("--metadata", requestData.metadata);
-        }
-        if (requestData.startingMode === "interactive" && process.platform === "darwin") {
-          const script = `
-            tell application "Terminal"
-              activate
-              do script "cd ${requestData.directory} && happy ${args.join(" ")}"
-            end tell
-          `;
-          spawn$1("osascript", ["-e", script], { detached: true });
-        } else {
-          const child = spawn$1("happy", args, {
+    socket.on("rpc-request", async (data, callback) => {
+      logger.daemonDebug(`Received RPC request: ${JSON.stringify(data)}`);
+      const expectedMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
+      if (data.method === expectedMethod) {
+        logger.daemonDebug("Processing spawn-happy-session RPC");
+        try {
+          const { directory } = data.params || {};
+          if (!directory) {
+            throw new Error("Directory is required");
+          }
+          const args = [
+            "--daemon-spawn",
+            "--happy-starting-mode",
+            "remote"
+            // ALWAYS force remote mode for daemon spawns
+          ];
+          if (configuration.installationLocation === "local") {
+            args.push("--local");
+          }
+          if (configuration.serverUrl !== "https://handy-api.korshakov.org") {
+            args.push("--happy-server-url", configuration.serverUrl);
+          }
+          logger.daemonDebug(`Spawning happy in directory: ${directory} with args: ${args.join(" ")}`);
+          const happyPath = process.argv[1];
+          const isTypeScript = happyPath.endsWith(".ts");
+          const happyProcess = isTypeScript ? spawn$1("npx", ["tsx", happyPath, ...args], {
+            cwd: directory,
+            env: { ...process.env, EXPERIMENTAL_FEATURES: "1" },
             detached: true,
-            stdio: "ignore",
-            cwd: requestData.directory
+            stdio: ["ignore", "pipe", "pipe"]
+            // We need stdout
+          }) : spawn$1(process.argv[0], [happyPath, ...args], {
+            cwd: directory,
+            env: { ...process.env, EXPERIMENTAL_FEATURES: "1" },
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"]
+            // We need stdout
           });
-          child.unref();
+          this.spawnedProcesses.add(happyProcess);
+          let sessionId = null;
+          let output = "";
+          let timeoutId = null;
+          const cleanup = () => {
+            happyProcess.stdout.removeAllListeners("data");
+            happyProcess.stderr.removeAllListeners("data");
+            happyProcess.removeAllListeners("error");
+            happyProcess.removeAllListeners("exit");
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+          };
+          happyProcess.stdout.on("data", (data2) => {
+            output += data2.toString();
+            const match = output.match(/daemon:sessionIdCreated:(.+?)[\n\r]/);
+            if (match && !sessionId) {
+              sessionId = match[1];
+              logger.daemonDebug(`Session spawned successfully: ${sessionId}`);
+              callback({ sessionId });
+              cleanup();
+              happyProcess.unref();
+            }
+          });
+          happyProcess.stderr.on("data", (data2) => {
+            logger.daemonDebug(`Spawned process stderr: ${data2.toString()}`);
+          });
+          happyProcess.on("error", (error) => {
+            logger.daemonDebug("Error spawning session:", error);
+            if (!sessionId) {
+              callback({ error: `Failed to spawn: ${error.message}` });
+              cleanup();
+              this.spawnedProcesses.delete(happyProcess);
+            }
+          });
+          happyProcess.on("exit", (code, signal) => {
+            logger.daemonDebug(`Spawned process exited with code ${code}, signal ${signal}`);
+            this.spawnedProcesses.delete(happyProcess);
+            if (!sessionId) {
+              callback({ error: `Process exited before session ID received` });
+              cleanup();
+            }
+          });
+          timeoutId = setTimeout(() => {
+            if (!sessionId) {
+              logger.daemonDebug("Timeout waiting for session ID");
+              callback({ error: "Timeout waiting for session" });
+              cleanup();
+              happyProcess.kill();
+              this.spawnedProcesses.delete(happyProcess);
+            }
+          }, 1e4);
+        } catch (error) {
+          logger.daemonDebug("Error spawning session:", error);
+          callback({ error: error instanceof Error ? error.message : "Unknown error" });
         }
-        const result = { success: true };
-        socket.emit("session-spawn-result", {
-          requestId: requestData.requestId,
-          result: encodeBase64(encrypt(result, this.secret))
-        });
-        callback(encodeBase64(encrypt({ success: true }, this.secret)));
-      } catch (error) {
-        logger.debug("[DAEMON] Failed to spawn session", error);
-        const errorResult = {
-          success: false,
-          error: error instanceof Error ? error.message : "Unknown error"
-        };
-        socket.emit("session-spawn-result", {
-          requestId: requestData?.requestId || "",
-          result: encodeBase64(encrypt(errorResult, this.secret))
-        });
-        callback(encodeBase64(encrypt(errorResult, this.secret)));
+      } else {
+        logger.daemonDebug(`Unknown RPC method: ${data.method}`);
+        callback({ error: `Unknown method: ${data.method}` });
+      }
+    });
+    socket.on("disconnect", (reason) => {
+      logger.daemonDebug(`Disconnected from server. Reason: ${reason}`);
+      this.emit("disconnected");
+      this.stopKeepAlive();
+    });
+    socket.on("reconnect", () => {
+      logger.daemonDebug("Reconnected to server");
+      const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
+      socket.emit("rpc-register", { method: rpcMethod });
+      logger.daemonDebug(`Re-registered RPC method: ${rpcMethod}`);
+    });
+    socket.on("rpc-registered", (data) => {
+      logger.daemonDebug(`RPC registration confirmed: ${data.method}`);
+    });
+    socket.on("rpc-unregistered", (data) => {
+      logger.daemonDebug(`RPC unregistered: ${data.method}`);
+    });
+    socket.on("rpc-error", (data) => {
+      logger.daemonDebug(`RPC error: ${JSON.stringify(data)}`);
+    });
+    socket.onAny((event, ...args) => {
+      if (!event.startsWith("machine-alive")) {
+        logger.daemonDebug(`Socket event: ${event}, args: ${JSON.stringify(args)}`);
       }
     });
+    socket.on("connect_error", (error) => {
+      logger.daemonDebug(`Connection error: ${error.message}`);
+      logger.daemonDebug(`Error: ${JSON.stringify(error, null, 2)}`);
+    });
+    socket.on("error", (error) => {
+      logger.daemonDebug(`Socket error: ${error}`);
+    });
     socket.on("daemon-command", (data) => {
       switch (data.command) {
         case "shutdown":
@@ -1833,22 +2420,42 @@ class ApiDaemonSession extends EventEmitter {
     this.socket.connect();
   }
   shutdown() {
+    logger.daemonDebug(`Shutting down daemon, killing ${this.spawnedProcesses.size} spawned processes`);
+    for (const process2 of this.spawnedProcesses) {
+      try {
+        logger.daemonDebug(`Killing spawned process with PID: ${process2.pid}`);
+        process2.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            process2.kill("SIGKILL");
+          } catch (e) {
+          }
+        }, 1e3);
+      } catch (error) {
+        logger.daemonDebug(`Error killing process: ${error}`);
+      }
+    }
+    this.spawnedProcesses.clear();
     this.stopKeepAlive();
     this.socket.close();
     this.emit("shutdown");
   }
 }
 
+let pidFileFd = null;
 async function startDaemon() {
-  console.log("[DAEMON] Starting daemon process...");
+  if (process.platform !== "darwin") {
+    console.error("ERROR: Daemon is only supported on macOS");
+    process.exit(1);
+  }
+  logger.daemonDebug("Starting daemon process...");
+  logger.daemonDebug(`Server URL: ${configuration.serverUrl}`);
   if (await isDaemonRunning()) {
-    console.log("Happy daemon is already running");
+    logger.daemonDebug("Happy daemon is already running");
     process.exit(0);
   }
-  console.log("[DAEMON] Writing PID file with PID:", process.pid);
-  writePidFile();
-  console.log("[DAEMON] PID file written successfully");
-  logger.info("Happy CLI daemon started successfully");
+  pidFileFd = writePidFile();
+  logger.daemonDebug("PID file written");
   process.on("SIGINT", () => {
     stopDaemon().catch(console.error);
   });
@@ -1873,7 +2480,7 @@ async function startDaemon() {
     };
     let credentials = await readCredentials();
     if (!credentials) {
-      logger.debug("[DAEMON] No credentials found, running auth");
+      logger.daemonDebug("No credentials found, running auth");
       await doAuth();
       credentials = await readCredentials();
       if (!credentials) {
@@ -1881,64 +2488,64 @@ async function startDaemon() {
       }
     }
     const { token, secret } = credentials;
-    const daemon = new ApiDaemonSession(token, secret, machineIdentity);
+    const daemon = new ApiDaemonSession(
+      token,
+      secret,
+      machineIdentity
+    );
     daemon.on("connected", () => {
-      logger.debug("[DAEMON] Successfully connected to server");
+      logger.daemonDebug("Connected to server event received");
     });
     daemon.on("disconnected", () => {
-      logger.debug("[DAEMON] Disconnected from server");
+      logger.daemonDebug("Disconnected from server event received");
     });
     daemon.on("shutdown", () => {
-      logger.debug("[DAEMON] Shutdown requested");
+      logger.daemonDebug("Shutdown requested");
       stopDaemon();
       process.exit(0);
     });
     daemon.connect();
-    setInterval(() => {
-    }, 1e3);
+    logger.daemonDebug("Daemon started successfully");
   } catch (error) {
-    logger.debug("[DAEMON] Failed to start daemon", error);
+    logger.daemonDebug("Failed to start daemon", error);
     stopDaemon();
     process.exit(1);
   }
-  process.on("SIGINT", () => process.exit(0));
-  process.on("SIGTERM", () => process.exit(0));
-  process.on("exit", () => process.exit(0));
   while (true) {
     await new Promise((resolve) => setTimeout(resolve, 1e3));
   }
 }
 async function isDaemonRunning() {
   try {
-    console.log("[isDaemonRunning] Checking if daemon is running...");
+    logger.daemonDebug("[isDaemonRunning] Checking if daemon is running...");
     if (existsSync$1(configuration.daemonPidFile)) {
-      console.log("[isDaemonRunning] PID file exists");
+      logger.daemonDebug("[isDaemonRunning] PID file exists");
       const pid = parseInt(readFileSync$1(configuration.daemonPidFile, "utf-8"));
-      console.log("[isDaemonRunning] PID from file:", pid);
+      logger.daemonDebug("[isDaemonRunning] PID from file:", pid);
       try {
         process.kill(pid, 0);
-        console.log("[isDaemonRunning] Process exists, checking if it's a happy daemon...");
+        logger.daemonDebug("[isDaemonRunning] Process exists, checking if it's a happy daemon...");
         const isHappyDaemon = await isProcessHappyDaemon(pid);
-        console.log("[isDaemonRunning] isHappyDaemon:", isHappyDaemon);
+        logger.daemonDebug("[isDaemonRunning] isHappyDaemon:", isHappyDaemon);
         if (isHappyDaemon) {
           return true;
         } else {
-          console.log("[isDaemonRunning] PID is not a happy daemon, cleaning up");
-          logger.debug(`[DAEMON] PID ${pid} is not a happy daemon, cleaning up`);
+          logger.daemonDebug("[isDaemonRunning] PID is not a happy daemon, cleaning up");
+          logger.debug(`PID ${pid} is not a happy daemon, cleaning up`);
           unlinkSync(configuration.daemonPidFile);
         }
       } catch (error) {
-        console.log("[isDaemonRunning] Process not running, cleaning up stale PID file");
-        logger.debug("[DAEMON] Process not running, cleaning up stale PID file");
+        logger.daemonDebug("[isDaemonRunning] Process not running, cleaning up stale PID file");
+        logger.debug("Process not running, cleaning up stale PID file");
         unlinkSync(configuration.daemonPidFile);
       }
     } else {
-      console.log("[isDaemonRunning] No PID file found");
+      logger.daemonDebug("[isDaemonRunning] No PID file found");
     }
     return false;
   } catch (error) {
-    console.log("[isDaemonRunning] Error:", error);
-    logger.debug("[DAEMON] Error checking daemon status", error);
+    logger.daemonDebug("[isDaemonRunning] Error:", error);
+    logger.debug("Error checking daemon status", error);
     return false;
   }
 }
@@ -1948,20 +2555,46 @@ function writePidFile() {
     mkdirSync$1(happyDir, { recursive: true });
   }
   try {
-    writeFileSync(configuration.daemonPidFile, process.pid.toString(), { flag: "wx" });
+    const fd = openSync(configuration.daemonPidFile, "wx");
+    writeSync(fd, process.pid.toString());
+    return fd;
   } catch (error) {
     if (error.code === "EEXIST") {
-      logger.debug("[DAEMON] PID file already exists, another daemon may be starting");
-      throw new Error("Daemon PID file already exists");
+      try {
+        const fd = openSync(configuration.daemonPidFile, "r+");
+        const existingPid = readFileSync$1(configuration.daemonPidFile, "utf-8").trim();
+        closeSync(fd);
+        try {
+          process.kill(parseInt(existingPid), 0);
+          logger.daemonDebug("PID file exists and process is running");
+          logger.daemonDebug("Happy daemon is already running");
+          process.exit(0);
+        } catch {
+          logger.daemonDebug("PID file exists but process is dead, cleaning up");
+          unlinkSync(configuration.daemonPidFile);
+          return writePidFile();
+        }
+      } catch (lockError) {
+        logger.daemonDebug("Cannot acquire write lock on PID file, daemon is running");
+        logger.daemonDebug("Happy daemon is already running");
+        process.exit(0);
+      }
     }
     throw error;
   }
 }
 async function stopDaemon() {
   try {
+    if (pidFileFd !== null) {
+      try {
+        closeSync(pidFileFd);
+      } catch {
+      }
+      pidFileFd = null;
+    }
     if (existsSync$1(configuration.daemonPidFile)) {
       const pid = parseInt(readFileSync$1(configuration.daemonPidFile, "utf-8"));
-      logger.debug(`[DAEMON] Stopping daemon with PID ${pid}`);
+      logger.debug(`Stopping daemon with PID ${pid}`);
       try {
         process.kill(pid, "SIGTERM");
         await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -1971,12 +2604,12 @@ async function stopDaemon() {
         } catch {
         }
       } catch (error) {
-        logger.debug("[DAEMON] Process already dead or inaccessible", error);
+        logger.debug("Process already dead or inaccessible", error);
       }
       unlinkSync(configuration.daemonPidFile);
     }
   } catch (error) {
-    logger.debug("[DAEMON] Error stopping daemon", error);
+    logger.debug("Error stopping daemon", error);
   }
 }
 async function isProcessHappyDaemon(pid) {
@@ -2124,7 +2757,12 @@ async function uninstall() {
 (async () => {
   const args = process.argv.slice(2);
   let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
-  initializeConfiguration(installationLocation);
+  let serverUrl;
+  const serverUrlIndex = args.indexOf("--happy-server-url");
+  if (serverUrlIndex !== -1 && serverUrlIndex + 1 < args.length) {
+    serverUrl = args[serverUrlIndex + 1];
+  }
+  initializeConfiguration(installationLocation, serverUrl);
   initLoggerWithGlobalConfiguration();
   logger.debug("Starting happy CLI with args: ", process.argv);
   const subcommand = args[0];
@@ -2192,7 +2830,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$1.enum(["auto", "default", "plan"]).parse(args[++i]);
+        options.permissionMode = z$1.enum(["default", "acceptEdits", "bypassPermissions", "plan"]).parse(args[++i]);
       } else if (arg === "--local") ; else if (arg === "--happy-starting-mode") {
         options.startingMode = z$1.enum(["local", "remote"]).parse(args[++i]);
       } else if (arg === "--claude-env") {
@@ -2206,6 +2844,10 @@ Currently only supported on macOS.
       } else if (arg === "--claude-arg") {
         const claudeArg = args[++i];
         options.claudeArgs = [...options.claudeArgs || [], claudeArg];
+      } else if (arg === "--daemon-spawn") {
+        options.daemonSpawn = true;
+      } else if (arg === "--happy-server-url") {
+        i++;
       } else {
         console.error(chalk.red(`Unknown argument: ${arg}`));
         process.exit(1);
@@ -2224,7 +2866,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
@@ -2241,6 +2883,8 @@ ${chalk.bold("Options:")}
       You will require re-login each time you run this in a new directory.
   --happy-starting-mode <interactive|remote>
       Set the starting mode for new sessions (default: remote)
+  --happy-server-url <url>
+      Set the server URL (overrides HANDY_SERVER_URL environment variable)
 
 ${chalk.bold("Examples:")}
   happy                   Start a session with default settings
@@ -2267,7 +2911,71 @@ ${chalk.bold("Examples:")}
       }
       credentials = res;
     }
-    await readSettings() || { };
+    const settings = await readSettings() || { onboardingCompleted: false };
+    process.env.EXPERIMENTAL_FEATURES !== void 0;
+    if (settings.daemonAutoStartWhenRunningHappy === void 0) {
+      console.log(chalk.cyan("\n\u{1F680} Happy Daemon Setup\n"));
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      console.log(chalk.cyan("\n\u{1F4F1} Happy can run a background service that allows you to:"));
+      console.log(chalk.cyan("  \u2022 Spawn new conversations from your phone"));
+      console.log(chalk.cyan("  \u2022 Continue closed conversations remotely"));
+      console.log(chalk.cyan("  \u2022 Work with Claude while your computer has internet\n"));
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk.green("Would you like Happy to start this service automatically? (recommended) [Y/n]: "), resolve);
+      });
+      rl.close();
+      const shouldAutoStart = answer.toLowerCase() !== "n";
+      settings.daemonAutoStartWhenRunningHappy = shouldAutoStart;
+      if (shouldAutoStart) {
+        console.log(chalk.green("\u2713 Happy will start the background service automatically"));
+        console.log(chalk.gray("  The service will run whenever you use the happy command"));
+      } else {
+        console.log(chalk.yellow("  You can enable this later by running: happy daemon install"));
+      }
+      await writeSettings(settings);
+    }
+    if (settings.daemonAutoStartWhenRunningHappy) {
+      console.debug("Starting Happy background service...");
+      if (!await isDaemonRunning()) {
+        const happyPath = process.argv[1];
+        const isBuiltBinary = happyPath.endsWith("/bin/happy") || happyPath.endsWith("\\bin\\happy");
+        const daemonArgs = ["daemon", "start"];
+        if (serverUrl) {
+          daemonArgs.push("--happy-server-url", serverUrl);
+        }
+        if (installationLocation === "local") {
+          daemonArgs.push("--local");
+        }
+        const daemonProcess = isBuiltBinary ? spawn$1(happyPath, daemonArgs, {
+          detached: true,
+          stdio: ["ignore", "inherit", "inherit"],
+          // Show stdout/stderr for debugging
+          env: {
+            ...process.env,
+            HANDY_SERVER_URL: serverUrl || process.env.HANDY_SERVER_URL,
+            // Pass through server URL
+            HANDY_LOCAL: process.env.HANDY_LOCAL
+            // Pass through local flag
+          }
+        }) : spawn$1("npx", ["tsx", happyPath, ...daemonArgs], {
+          detached: true,
+          stdio: ["ignore", "inherit", "inherit"],
+          // Show stdout/stderr for debugging
+          env: {
+            ...process.env,
+            HANDY_SERVER_URL: serverUrl || process.env.HANDY_SERVER_URL,
+            // Pass through server URL
+            HANDY_LOCAL: process.env.HANDY_LOCAL
+            // Pass through local flag
+          }
+        });
+        daemonProcess.unref();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+    }
     try {
       await start(credentials, options);
     } catch (error) {