happy-coder 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -1,27 +1,27 @@
 'use strict';
 
 var chalk = require('chalk');
-var types = require('./types-B2JzqUiU.cjs');
+var types = require('./types-hotUTaWz.cjs');
 var node_crypto = require('node:crypto');
 var claudeCode = require('@anthropic-ai/claude-code');
 var node_fs = require('node:fs');
-var os = require('node:os');
 var node_path = require('node:path');
+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 = require('node:fs/promises');
+var promises$1 = require('node:fs/promises');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var node_http = require('node:http');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 var z = require('zod');
-var node_https = require('node:https');
-var net = require('node:net');
 var child_process = require('child_process');
 var util = require('util');
-var promises$1 = require('fs/promises');
 var crypto = require('crypto');
 var path = require('path');
+var url = require('url');
+var httpProxy = require('http-proxy');
 var tweetnacl = require('tweetnacl');
 var axios = require('axios');
 var qrcode = require('qrcode-terminal');
@@ -171,9 +171,13 @@ function printDivider() {
   console.log(chalk.gray("\u2550".repeat(60)));
 }
 
+function getProjectPath(workingDirectory) {
+  const projectId = node_path.resolve(workingDirectory).replace(/[\\\/\.:]/g, "-");
+  return node_path.join(os.homedir(), ".claude", "projects", projectId);
+}
+
 function claudeCheckSession(sessionId, path) {
-  const projectName = node_path.resolve(path).replace(/\//g, "-");
-  const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
+  const projectDir = getProjectPath(path);
   const sessionFile = node_path.join(projectDir, `${sessionId}.jsonl`);
   const sessionExists = node_fs.existsSync(sessionFile);
   if (!sessionExists) {
@@ -191,11 +195,29 @@ function claudeCheckSession(sessionId, path) {
   return hasGoodMessage;
 }
 
+async function awaitFileExist(file, timeout = 1e4) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      await promises.access(file);
+      return true;
+    } catch (e) {
+      await types.delay(1e3);
+    }
+  }
+  return false;
+}
+
 async function claudeRemote(opts) {
   let startFrom = opts.sessionId;
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
     startFrom = null;
   }
+  if (opts.claudeEnvVars) {
+    Object.entries(opts.claudeEnvVars).forEach(([key, value]) => {
+      process.env[key] = value;
+    });
+  }
   const abortController = new AbortController();
   const sdkOptions = {
     cwd: opts.path,
@@ -205,6 +227,9 @@ async function claudeRemote(opts) {
     executable: "node",
     abortController
   };
+  if (opts.claudeArgs && opts.claudeArgs.length > 0) {
+    sdkOptions.executableArgs = [...sdkOptions.executableArgs || [], ...opts.claudeArgs];
+  }
   let aborted = false;
   let response;
   opts.abort.addEventListener("abort", () => {
@@ -239,18 +264,14 @@ async function claudeRemote(opts) {
   try {
     types.logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
-      types.logger.debug(`[claudeRemote] Received message from SDK: ${message.type}`);
+      types.logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
       formatClaudeMessage(message, opts.onAssistantResult);
       if (message.type === "system" && message.subtype === "init") {
-        const projectName = node_path.resolve(opts.path).replace(/\//g, "-");
-        const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
-        node_fs.mkdirSync(projectDir, { recursive: true });
-        const watcher = node_fs.watch(projectDir).on("change", (_, filename) => {
-          if (filename === `${message.session_id}.jsonl`) {
-            opts.onSessionFound(message.session_id);
-            watcher.close();
-          }
-        });
+        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);
       }
     }
     types.logger.debug(`[claudeRemote] Finished iterating over response`);
@@ -272,10 +293,9 @@ async function claudeRemote(opts) {
   types.logger.debug(`[claudeRemote] Function completed`);
 }
 
-const __dirname$1 = node_path.dirname(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$2 = node_path.dirname(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))));
 async function claudeLocal(opts) {
-  const projectName = node_path.resolve(opts.path).replace(/\//g, "-");
-  const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
+  const projectDir = getProjectPath(opts.path);
   node_fs.mkdirSync(projectDir, { recursive: true });
   const watcher = node_fs.watch(projectDir);
   let resolvedSessionId = null;
@@ -309,11 +329,19 @@ async function claudeLocal(opts) {
       if (startFrom) {
         args.push("--resume", startFrom);
       }
-      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || node_path.resolve(node_path.join(__dirname$1, "..", "scripts", "claudeInteractiveLaunch.cjs"));
+      if (opts.claudeArgs) {
+        args.push(...opts.claudeArgs);
+      }
+      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || node_path.resolve(node_path.join(__dirname$2, "..", "scripts", "claudeInteractiveLaunch.cjs"));
+      const env = {
+        ...process.env,
+        ...opts.claudeEnvVars
+      };
       const child = node_child_process.spawn("node", [claudeCliPath, ...args], {
         stdio: ["inherit", "inherit", "inherit", "pipe"],
         signal: opts.abort,
-        cwd: opts.path
+        cwd: opts.path,
+        env
       });
       if (child.stdio[3]) {
         const rl = node_readline.createInterface({
@@ -538,16 +566,44 @@ class InvalidateSync {
   };
 }
 
+function startFileWatcher(file, onFileChange) {
+  const abortController = new AbortController();
+  void (async () => {
+    while (true) {
+      try {
+        types.logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = promises.watch(file, { persistent: true, signal: abortController.signal });
+        for await (const event of watcher) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          types.logger.debug(`[FILE_WATCHER] File changed: ${file}`);
+          onFileChange(file);
+        }
+      } catch (e) {
+        if (abortController.signal.aborted) {
+          return;
+        }
+        types.logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, restarting watcher in a second`);
+        await types.delay(1e3);
+      }
+    }
+  })();
+  return () => {
+    abortController.abort();
+  };
+}
+
 function createSessionScanner(opts) {
-  const projectName = node_path.resolve(opts.workingDirectory).replace(/\//g, "-");
-  const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
+  const projectDir = getProjectPath(opts.workingDirectory);
   let finishedSessions = /* @__PURE__ */ new Set();
   let pendingSessions = /* @__PURE__ */ new Set();
   let currentSessionId = null;
-  let currentSessionWatcherAbortController = null;
-  let processedMessages = /* @__PURE__ */ new Set();
-  let seenRemoteUserMessageCounters = /* @__PURE__ */ new Map();
+  let watchers = /* @__PURE__ */ new Map();
+  let processedMessageKeys = /* @__PURE__ */ new Set();
+  let unmatchedServerMessageContents = /* @__PURE__ */ new Set();
   const sync = new InvalidateSync(async () => {
+    types.logger.debug(`[SESSION_SCANNER] Syncing...`);
     let sessions = [];
     for (let p of pendingSessions) {
       sessions.push(p);
@@ -559,13 +615,17 @@ function createSessionScanner(opts) {
       const expectedSessionFile = node_path.join(projectDir, `${sessionId}.jsonl`);
       let file;
       try {
-        file = await promises.readFile(expectedSessionFile, "utf-8");
+        file = await promises$1.readFile(expectedSessionFile, "utf-8");
       } catch (error) {
+        types.logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
         return;
       }
       let lines = file.split("\n");
       for (let l of lines) {
         try {
+          if (l.trim() === "") {
+            continue;
+          }
           let message = JSON.parse(l);
           let parsed = types.RawJSONLinesSchema.safeParse(message);
           if (!parsed.success) {
@@ -573,21 +633,22 @@ function createSessionScanner(opts) {
             continue;
           }
           let key = getMessageKey(parsed.data);
-          if (processedMessages.has(key)) {
+          if (processedMessageKeys.has(key)) {
             continue;
           }
-          processedMessages.add(key);
+          processedMessageKeys.add(key);
           types.logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
           types.logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
           if (parsed.data.type === "user" && typeof parsed.data.message.content === "string" && parsed.data.isSidechain !== true && parsed.data.isMeta !== true) {
-            const currentCounter = seenRemoteUserMessageCounters.get(parsed.data.message.content);
-            if (currentCounter && currentCounter > 0) {
-              seenRemoteUserMessageCounters.set(parsed.data.message.content, currentCounter - 1);
+            if (unmatchedServerMessageContents.has(parsed.data.message.content)) {
+              types.logger.debug(`[SESSION_SCANNER] Matched server message echo: ${parsed.data.uuid}`);
+              unmatchedServerMessageContents.delete(parsed.data.message.content);
               continue;
             }
           }
           opts.onMessage(message);
         } catch (e) {
+          types.logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
           continue;
         }
       }
@@ -601,40 +662,37 @@ function createSessionScanner(opts) {
         finishedSessions.add(p);
       }
     }
-    currentSessionWatcherAbortController?.abort();
-    currentSessionWatcherAbortController = new AbortController();
-    void (async () => {
-      if (currentSessionId) {
-        const sessionFile = node_path.join(projectDir, `${currentSessionId}.jsonl`);
-        try {
-          for await (const change of promises.watch(sessionFile, { persistent: true, signal: currentSessionWatcherAbortController.signal })) {
-            await processSessionFile(currentSessionId);
-          }
-        } catch (error) {
-          if (error.name !== "AbortError") {
-            types.logger.debug(`[SESSION_SCANNER] Watch error: ${error.message}`);
-          }
-        }
+    for (let p of sessions) {
+      if (!watchers.has(p)) {
+        watchers.set(p, startFileWatcher(node_path.join(projectDir, `${p}.jsonl`), () => {
+          sync.invalidate();
+        }));
       }
-    })();
+    }
   });
+  sync.invalidate();
   const intervalId = setInterval(() => {
     sync.invalidate();
   }, 3e3);
   return {
-    refresh: () => sync.invalidate(),
     cleanup: () => {
       clearInterval(intervalId);
-      currentSessionWatcherAbortController?.abort();
+      for (let w of watchers.values()) {
+        w();
+      }
+      watchers.clear();
     },
     onNewSession: (sessionId) => {
       if (currentSessionId === sessionId) {
+        types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
         return;
       }
       if (finishedSessions.has(sessionId)) {
+        types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
         return;
       }
       if (pendingSessions.has(sessionId)) {
+        types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
         return;
       }
       if (currentSessionId) {
@@ -645,13 +703,18 @@ function createSessionScanner(opts) {
       sync.invalidate();
     },
     onRemoteUserMessageForDeduplication: (messageContent) => {
-      seenRemoteUserMessageCounters.set(messageContent, (seenRemoteUserMessageCounters.get(messageContent) || 0) + 1);
+      types.logger.debug(`[SESSION_SCANNER] Adding unmatched server message content: ${messageContent.substring(0, 50)}...`);
+      unmatchedServerMessageContents.add(messageContent);
     }
   };
 }
 function getMessageKey(message) {
   if (message.type === "user") {
-    return `user:${message.uuid}`;
+    if (Array.isArray(message.message.content) && message.message.content.length > 0 && typeof message.message.content[0] === "object" && "text" in message.message.content[0]) {
+      return `user-message-content:${stableStringify(message.message.content[0].text)}`;
+    } else {
+      return `user-message-content:${stableStringify(message.message.content)}`;
+    }
   } else if (message.type === "assistant") {
     const { usage, ...messageWithoutUsage } = message.message;
     return stableStringify(messageWithoutUsage);
@@ -663,6 +726,9 @@ function getMessageKey(message) {
   return `unknown:<error, this should be unreachable>`;
 }
 function stableStringify(obj) {
+  if (!obj) {
+    return "null";
+  }
   return JSON.stringify(sortKeys(obj), null, 2);
 }
 function sortKeys(value) {
@@ -679,7 +745,7 @@ function sortKeys(value) {
 }
 
 async function loop(opts) {
-  let mode = opts.startingMode ?? "interactive";
+  let mode = opts.startingMode ?? "local";
   let currentMessageQueue = new MessageQueue();
   let sessionId = null;
   let onMessage = null;
@@ -703,38 +769,74 @@ async function loop(opts) {
   };
   while (true) {
     if (currentMessageQueue.size() > 0) {
-      mode = "remote";
+      if (mode !== "remote") {
+        mode = "remote";
+        if (opts.onModeChange) {
+          opts.onModeChange(mode);
+        }
+      }
       continue;
     }
-    if (mode === "interactive") {
+    if (mode === "local") {
       let abortedOutside = false;
       const interactiveAbortController = new AbortController();
       opts.session.setHandler("switch", () => {
         if (!interactiveAbortController.signal.aborted) {
           abortedOutside = true;
-          mode = "remote";
+          if (mode !== "remote") {
+            mode = "remote";
+            if (opts.onModeChange) {
+              opts.onModeChange(mode);
+            }
+          }
           interactiveAbortController.abort();
         }
       });
+      opts.session.setHandler("abort", () => {
+        if (onMessage) {
+          onMessage();
+        }
+      });
       onMessage = () => {
         if (!interactiveAbortController.signal.aborted) {
           abortedOutside = true;
-          mode = "remote";
+          if (mode !== "remote") {
+            mode = "remote";
+            if (opts.onModeChange) {
+              opts.onModeChange(mode);
+            }
+          }
+          opts.session.sendSessionEvent({ type: "message", message: "Inference aborted" });
           interactiveAbortController.abort();
         }
         onMessage = null;
       };
-      await claudeLocal({
-        path: opts.path,
-        sessionId,
-        onSessionFound,
-        abort: interactiveAbortController.signal
-      });
+      try {
+        if (opts.onProcessStart) {
+          opts.onProcessStart("local");
+        }
+        await claudeLocal({
+          path: opts.path,
+          sessionId,
+          onSessionFound,
+          abort: interactiveAbortController.signal,
+          claudeEnvVars: opts.claudeEnvVars,
+          claudeArgs: opts.claudeArgs
+        });
+      } catch (e) {
+        if (!interactiveAbortController.signal.aborted) {
+          opts.session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+        }
+      } finally {
+        if (opts.onProcessStop) {
+          opts.onProcessStop("local");
+        }
+      }
       onMessage = null;
       if (!abortedOutside) {
         return;
       }
-      if (mode !== "interactive") {
+      if (mode !== "local") {
         console.log("Switching to remote mode...");
       }
     }
@@ -748,7 +850,13 @@ async function loop(opts) {
       });
       const abortHandler = () => {
         if (!remoteAbortController.signal.aborted) {
-          mode = "interactive";
+          if (mode !== "local") {
+            mode = "local";
+            if (opts.onModeChange) {
+              opts.onModeChange(mode);
+            }
+          }
+          opts.session.sendSessionEvent({ type: "message", message: "Inference aborted" });
           remoteAbortController.abort();
         }
         if (process.stdin.isTTY) {
@@ -763,6 +871,9 @@ async function loop(opts) {
       process.stdin.on("data", abortHandler);
       try {
         types.logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
+        if (opts.onProcessStart) {
+          opts.onProcessStart("remote");
+        }
         await claudeRemote({
           abort: remoteAbortController.signal,
           sessionId,
@@ -772,9 +883,18 @@ async function loop(opts) {
           onSessionFound,
           messages: currentMessageQueue,
           onAssistantResult: opts.onAssistantResult,
-          interruptController: opts.interruptController
+          interruptController: opts.interruptController,
+          claudeEnvVars: opts.claudeEnvVars,
+          claudeArgs: opts.claudeArgs
         });
+      } catch (e) {
+        if (!remoteAbortController.signal.aborted) {
+          opts.session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+        }
       } finally {
+        if (opts.onProcessStop) {
+          opts.onProcessStop("remote");
+        }
         process.stdin.off("data", abortHandler);
         if (process.stdin.isTTY) {
           process.stdin.setRawMode(false);
@@ -889,159 +1009,41 @@ class InterruptController {
   }
 }
 
-var version = "0.1.10";
+var version = "0.1.12";
 var packageJson = {
 	version: version};
 
-async function startAnthropicActivityProxy(onClaudeActivity) {
-  const requestTimeouts = /* @__PURE__ */ new Map();
-  let requestCounter = 0;
-  let idleTimer = null;
-  const maxTimeBeforeIdle = 50;
-  const requestTimeout = 5 * 60 * 1e3;
-  const cleanupRequest = (requestId, reason) => {
-    const timeout = requestTimeouts.get(requestId);
-    if (timeout) {
-      clearTimeout(timeout);
-      requestTimeouts.delete(requestId);
-      types.logger.debug(`[AnthropicProxy #${requestId}] Cleaned up (${reason}), active requests: ${requestTimeouts.size}`);
-      claudeDidSomeWork();
-    }
-  };
-  const claudeDidSomeWork = () => {
-    if (idleTimer) clearTimeout(idleTimer);
-    if (requestTimeouts.size === 0) {
-      idleTimer = setTimeout(() => {
-        types.logger.debug(`[AnthropicProxy] Idle for ${maxTimeBeforeIdle}ms, active requests: ${requestTimeouts.size}`);
-        onClaudeActivity("idle");
-      }, maxTimeBeforeIdle);
-    }
-  };
-  const server = node_http.createServer((req, res) => {
-    const requestId = ++requestCounter;
-    const isAnthropicRequest = req.headers.host === "api.anthropic.com" || req.url?.includes("anthropic.com");
-    if (isAnthropicRequest) {
-      const timeout = setTimeout(() => {
-        types.logger.debug(`[AnthropicProxy #${requestId}] Request timeout after ${requestTimeout}ms`);
-        cleanupRequest(requestId, "timeout");
-      }, requestTimeout);
-      requestTimeouts.set(requestId, timeout);
-      onClaudeActivity("working");
-      types.logger.debug(`[AnthropicProxy #${requestId}] Anthropic request: ${req.method} ${req.url}, active requests: ${requestTimeouts.size}`);
-    }
-    const chunks = [];
-    req.on("data", (chunk) => {
-      chunks.push(chunk);
-      if (isAnthropicRequest) {
-        claudeDidSomeWork();
-      }
+const __dirname$1 = path.dirname(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 RUNNER_PATH = path.join(__dirname$1, "..", "..", "scripts", "ripgrep_launcher.cjs");
+function run(args, options) {
+  return new Promise((resolve, reject) => {
+    const child = child_process.spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: options?.cwd
     });
-    req.on("end", () => {
-      const body = Buffer.concat(chunks);
-      let targetUrl;
-      if (isAnthropicRequest) {
-        targetUrl = new node_url.URL(req.url || "/", "https://api.anthropic.com");
-      } else {
-        const protocol = req.headers["x-forwarded-proto"] || "https";
-        const host = req.headers.host || "localhost";
-        targetUrl = new node_url.URL(req.url || "/", `${protocol}://${host}`);
-      }
-      const options = {
-        hostname: targetUrl.hostname,
-        port: targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80),
-        path: targetUrl.pathname + targetUrl.search,
-        method: req.method,
-        headers: {
-          ...req.headers,
-          host: targetUrl.hostname
-        }
-      };
-      const requestMethod = targetUrl.protocol === "https:" ? node_https.request : node_http.request;
-      const proxyReq = requestMethod(options, (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
-        proxyRes.on("end", () => {
-          if (isAnthropicRequest) {
-            cleanupRequest(requestId, "completed");
-          }
-        });
-      });
-      proxyReq.on("error", (error) => {
-        if (isAnthropicRequest) {
-          cleanupRequest(requestId, `error: ${error.message}`);
-        } else {
-          types.logger.debug(`[AnthropicProxy #${requestId}] Error:`, error.message);
-        }
-        res.writeHead(502);
-        res.end("Bad Gateway");
-      });
-      if (body.length > 0) {
-        proxyReq.write(body);
-      }
-      proxyReq.end();
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
     });
-  });
-  server.on("connect", (req, clientSocket, head) => {
-    const requestId = ++requestCounter;
-    const [hostname, port] = req.url?.split(":") || ["", "443"];
-    const isAnthropicRequest = hostname === "api.anthropic.com";
-    if (isAnthropicRequest) {
-      const timeout = setTimeout(() => {
-        types.logger.debug(`[AnthropicProxy #${requestId}] CONNECT timeout after ${requestTimeout}ms`);
-        cleanupRequest(requestId, "timeout");
-      }, requestTimeout);
-      requestTimeouts.set(requestId, timeout);
-      onClaudeActivity("working");
-      types.logger.debug(`[AnthropicProxy #${requestId}] CONNECT to api.anthropic.com, active requests: ${requestTimeouts.size}`);
-    }
-    const serverSocket = net.connect(parseInt(port) || 443, hostname, () => {
-      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
-      serverSocket.write(head);
-      serverSocket.pipe(clientSocket);
-      clientSocket.pipe(serverSocket);
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
     });
-    const cleanup = () => {
-      if (isAnthropicRequest) {
-        cleanupRequest(requestId, "CONNECT closed");
-      }
-    };
-    serverSocket.on("error", (err) => {
-      types.logger.debug(`[AnthropicProxy #${requestId}] CONNECT error:`, err.message);
-      clientSocket.end();
-      cleanup();
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code || 0,
+        stdout,
+        stderr
+      });
     });
-    clientSocket.on("error", cleanup);
-    clientSocket.on("end", cleanup);
-    serverSocket.on("end", cleanup);
-  });
-  const url = await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      if (addr && typeof addr === "object") {
-        resolve(`http://127.0.0.1:${addr.port}`);
-      }
+    child.on("error", (err) => {
+      reject(err);
     });
   });
-  types.logger.debug(`[AnthropicProxy] Started at ${url}`);
-  return {
-    url,
-    cleanup: () => {
-      if (idleTimer) clearTimeout(idleTimer);
-      for (const [requestId, timeout] of requestTimeouts) {
-        clearTimeout(timeout);
-        types.logger.debug(`[AnthropicProxy] Cleaning up timeout for request #${requestId}`);
-      }
-      requestTimeouts.clear();
-      if (requestTimeouts.size > 0) {
-        types.logger.debug(`[AnthropicProxy] Warning: ${requestTimeouts.size} active requests still pending at cleanup:`, Array.from(requestTimeouts.keys()));
-      }
-      server.close();
-    }
-  };
 }
 
 const execAsync = util.promisify(child_process.exec);
-function registerHandlers(session, interruptController, permissionCallbacks) {
+function registerHandlers(session, interruptController, permissionCallbacks, onSwitchRemoteRequested) {
   session.setHandler("abort", async () => {
     types.logger.info("Abort request - interrupting Claude");
     await interruptController.interrupt();
@@ -1063,11 +1065,22 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
         return;
       }
       session.updateAgentState((currentState) => {
+        const request = currentState.requests?.[id];
+        if (!request) return currentState;
         let r = { ...currentState.requests };
         delete r[id];
         return {
           ...currentState,
-          requests: r
+          requests: r,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [id]: {
+              ...request,
+              completedAt: Date.now(),
+              status: message.approved ? "approved" : "denied",
+              reason: message.reason
+            }
+          }
         };
       });
     });
@@ -1110,7 +1123,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
   session.setHandler("readFile", async (data) => {
     types.logger.info("Read file request:", data.path);
     try {
-      const buffer = await promises$1.readFile(data.path);
+      const buffer = await promises.readFile(data.path);
       const content = buffer.toString("base64");
       return { success: true, content };
     } catch (error) {
@@ -1123,7 +1136,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
     try {
       if (data.expectedHash !== null && data.expectedHash !== void 0) {
         try {
-          const existingBuffer = await promises$1.readFile(data.path);
+          const existingBuffer = await promises.readFile(data.path);
           const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
           if (existingHash !== data.expectedHash) {
             return {
@@ -1143,7 +1156,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
         }
       } else {
         try {
-          await promises$1.stat(data.path);
+          await promises.stat(data.path);
           return {
             success: false,
             error: "File already exists but was expected to be new"
@@ -1156,7 +1169,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
         }
       }
       const buffer = Buffer.from(data.content, "base64");
-      await promises$1.writeFile(data.path, buffer);
+      await promises.writeFile(data.path, buffer);
       const hash = crypto.createHash("sha256").update(buffer).digest("hex");
       return { success: true, hash };
     } catch (error) {
@@ -1167,7 +1180,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
   session.setHandler("listDirectory", async (data) => {
     types.logger.info("List directory request:", data.path);
     try {
-      const entries = await promises$1.readdir(data.path, { withFileTypes: true });
+      const entries = await promises.readdir(data.path, { withFileTypes: true });
       const directoryEntries = await Promise.all(
         entries.map(async (entry) => {
           const fullPath = path.join(data.path, entry.name);
@@ -1180,7 +1193,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
             type = "file";
           }
           try {
-            const stats = await promises$1.stat(fullPath);
+            const stats = await promises.stat(fullPath);
             size = stats.size;
             modified = stats.mtime.getTime();
           } catch (error) {
@@ -1209,7 +1222,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
     types.logger.info("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
     async function buildTree(path$1, name, currentDepth) {
       try {
-        const stats = await promises$1.stat(path$1);
+        const stats = await promises.stat(path$1);
         const node = {
           name,
           path: path$1,
@@ -1218,7 +1231,7 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
           modified: stats.mtime.getTime()
         };
         if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await promises$1.readdir(path$1, { withFileTypes: true });
+          const entries = await promises.readdir(path$1, { withFileTypes: true });
           const children = [];
           await Promise.all(
             entries.map(async (entry) => {
@@ -1261,6 +1274,158 @@ function registerHandlers(session, interruptController, permissionCallbacks) {
       return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
     }
   });
+  session.setHandler("ripgrep", async (data) => {
+    types.logger.info("Ripgrep request with args:", data.args, "cwd:", data.cwd);
+    try {
+      const result = await run(data.args, { cwd: data.cwd });
+      return {
+        success: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr
+      };
+    } catch (error) {
+      types.logger.debug("Failed to run ripgrep:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to run ripgrep"
+      };
+    }
+  });
+}
+
+async function startHTTPDirectProxy(options) {
+  const proxy = httpProxy.createProxyServer({
+    target: options.target,
+    changeOrigin: true,
+    secure: false
+  });
+  proxy.on("error", (err, req, res) => {
+    types.logger.debug(`[HTTPProxy] Proxy error: ${err.message} for ${req.method} ${req.url}`);
+    if (res instanceof node_http.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 = node_http.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}`;
+        types.logger.debug(`[HTTPProxy] Started on ${proxyUrl} --> ${options.target}`);
+        resolve(proxyUrl);
+      } else {
+        reject(new Error("Failed to get server address"));
+      }
+    });
+  });
+  return url;
+}
+
+async function startClaudeActivityTracker(onThinking) {
+  types.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 start(credentials, options = {}) {
@@ -1274,22 +1439,15 @@ async function start(credentials, options = {}) {
   const session = api.session(response);
   const pushClient = api.push();
   let thinking = false;
+  let mode = "local";
   let pingInterval = setInterval(() => {
-    session.keepAlive(thinking);
+    session.keepAlive(thinking, mode);
   }, 2e3);
-  const antropicActivityProxy = await startAnthropicActivityProxy(
-    (activity) => {
-      const newThinking = activity === "working";
-      if (newThinking !== thinking) {
-        thinking = newThinking;
-        types.logger.debug(`[PING] Thinking state changed: ${thinking}`);
-        session.keepAlive(thinking);
-      }
-    }
-  );
-  process.env.HTTP_PROXY = antropicActivityProxy.url;
-  process.env.HTTPS_PROXY = antropicActivityProxy.url;
-  types.logger.debug(`[AnthropicProxy] Set HTTP_PROXY and HTTPS_PROXY to ${antropicActivityProxy.url}`);
+  const activityTracker = await startClaudeActivityTracker((newThinking) => {
+    thinking = newThinking;
+    session.keepAlive(thinking, mode);
+  });
+  process.env.ANTHROPIC_BASE_URL = activityTracker.proxyUrl;
   const logPath = await types.logger.logFilePathPromise;
   types.logger.infoDeveloper(`Session: ${response.id}`);
   types.logger.infoDeveloper(`Logs: ${logPath}`);
@@ -1301,22 +1459,33 @@ async function start(credentials, options = {}) {
       requests.set(id, resolve);
     });
     let timeout = setTimeout(async () => {
-      types.logger.info("Permission timeout - attempting to interrupt Claude");
+      types.logger.debug("Permission timeout - attempting to interrupt Claude");
       const interrupted = await interruptController.interrupt();
       if (interrupted) {
-        types.logger.info("Claude interrupted successfully");
+        types.logger.debug("Claude interrupted successfully");
       }
       requests.delete(id);
       session.updateAgentState((currentState) => {
+        const request2 = currentState.requests?.[id];
+        if (!request2) return currentState;
         let r = { ...currentState.requests };
         delete r[id];
         return {
           ...currentState,
-          requests: r
+          requests: r,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [id]: {
+              ...request2,
+              completedAt: Date.now(),
+              status: "canceled",
+              reason: "Timeout"
+            }
+          }
         };
       });
     }, 1e3 * 60 * 4.5);
-    types.logger.info("Permission request" + id + " " + JSON.stringify(request));
+    types.logger.debug("Permission request" + id + " " + JSON.stringify(request));
     try {
       await pushClient.sendToAllDevices(
         "Permission Request",
@@ -1328,7 +1497,7 @@ async function start(credentials, options = {}) {
           type: "permission_request"
         }
       );
-      types.logger.info("Push notification sent for permission request");
+      types.logger.debug("Push notification sent for permission request");
     } catch (error) {
       types.logger.debug("Failed to send push notification:", error);
     }
@@ -1338,7 +1507,8 @@ async function start(credentials, options = {}) {
         ...currentState.requests,
         [id]: {
           tool: request.name,
-          arguments: request.arguments
+          arguments: request.arguments,
+          createdAt: Date.now()
         }
       }
     }));
@@ -1370,6 +1540,63 @@ async function start(credentials, options = {}) {
     model: options.model,
     permissionMode: options.permissionMode,
     startingMode: options.startingMode,
+    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");
+        for (const [id, resolve] of requests) {
+          types.logger.debug(`Rejecting pending permission request: ${id}`);
+          resolve({ approved: false, reason: "Session switched to local mode" });
+        }
+        requests.clear();
+        session.updateAgentState((currentState) => {
+          const pendingRequests = currentState.requests || {};
+          const completedRequests = { ...currentState.completedRequests };
+          for (const [id, request] of Object.entries(pendingRequests)) {
+            completedRequests[id] = {
+              ...request,
+              completedAt: Date.now(),
+              status: "canceled",
+              reason: "Session switched to local mode"
+            };
+          }
+          return {
+            ...currentState,
+            controlledByUser: true,
+            requests: {},
+            // Clear all pending requests
+            completedRequests
+          };
+        });
+      } else {
+        session.updateAgentState((currentState) => ({
+          ...currentState,
+          controlledByUser: false
+        }));
+      }
+    },
+    onProcessStart: (processMode) => {
+      types.logger.debug(`[Process Lifecycle] Starting ${processMode} mode`);
+      activityTracker.reset();
+      types.logger.debug("Starting process - clearing any stale permission requests");
+      for (const [id, resolve] of requests) {
+        types.logger.debug(`Rejecting stale permission request: ${id}`);
+        resolve({ approved: false, reason: "Process restarted" });
+      }
+      requests.clear();
+    },
+    onProcessStop: (processMode) => {
+      types.logger.debug(`[Process Lifecycle] Stopped ${processMode} mode`);
+      activityTracker.reset();
+      types.logger.debug("Stopping process - clearing any stale permission requests");
+      for (const [id, resolve] of requests) {
+        types.logger.debug(`Rejecting stale permission request: ${id}`);
+        resolve({ approved: false, reason: "Process restarted" });
+      }
+      requests.clear();
+    },
     mcpServers: {
       "permission": {
         type: "http",
@@ -1379,13 +1606,11 @@ async function start(credentials, options = {}) {
     permissionPromptToolName: "mcp__permission__" + permissionServer.toolName,
     session,
     onAssistantResult,
-    interruptController
+    interruptController,
+    claudeEnvVars: options.claudeEnvVars,
+    claudeArgs: options.claudeArgs
   });
   clearInterval(pingInterval);
-  if (antropicActivityProxy) {
-    types.logger.debug("[AnthropicProxy] Shutting down thinking activity monitoring proxy");
-    antropicActivityProxy.cleanup();
-  }
   process.exit(0);
 }
 
@@ -1397,7 +1622,7 @@ async function readSettings() {
     return { ...defaultSettings };
   }
   try {
-    const content = await promises.readFile(types.configuration.settingsFile, "utf8");
+    const content = await promises$1.readFile(types.configuration.settingsFile, "utf8");
     return JSON.parse(content);
   } catch {
     return { ...defaultSettings };
@@ -1405,9 +1630,9 @@ async function readSettings() {
 }
 async function writeSettings(settings) {
   if (!node_fs.existsSync(types.configuration.happyDir)) {
-    await promises.mkdir(types.configuration.happyDir, { recursive: true });
+    await promises$1.mkdir(types.configuration.happyDir, { recursive: true });
   }
-  await promises.writeFile(types.configuration.settingsFile, JSON.stringify(settings, null, 2));
+  await promises$1.writeFile(types.configuration.settingsFile, JSON.stringify(settings, null, 2));
 }
 const credentialsSchema = z__namespace.object({
   secret: z__namespace.string().base64(),
@@ -1418,7 +1643,7 @@ async function readCredentials() {
     return null;
   }
   try {
-    const keyBase64 = await promises.readFile(types.configuration.privateKeyFile, "utf8");
+    const keyBase64 = await promises$1.readFile(types.configuration.privateKeyFile, "utf8");
     const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
     return {
       secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
@@ -1430,9 +1655,9 @@ async function readCredentials() {
 }
 async function writeCredentials(credentials) {
   if (!node_fs.existsSync(types.configuration.happyDir)) {
-    await promises.mkdir(types.configuration.happyDir, { recursive: true });
+    await promises$1.mkdir(types.configuration.happyDir, { recursive: true });
   }
-  await promises.writeFile(types.configuration.privateKeyFile, JSON.stringify({
+  await promises$1.writeFile(types.configuration.privateKeyFile, JSON.stringify({
     secret: types.encodeBase64(credentials.secret),
     token: credentials.token
   }, null, 2));
@@ -1635,17 +1860,25 @@ class ApiDaemonSession extends node_events.EventEmitter {
   }
 }
 
-const DAEMON_PID_FILE = path.join(os$1.homedir(), ".happy", "daemon-pid");
 async function startDaemon() {
-  if (isDaemonRunning()) {
+  console.log("[DAEMON] Starting daemon process...");
+  if (await isDaemonRunning()) {
     console.log("Happy daemon is already running");
     process.exit(0);
   }
-  types.logger.info("Happy CLI daemon started successfully");
+  console.log("[DAEMON] Writing PID file with PID:", process.pid);
   writePidFile();
-  process.on("SIGINT", stopDaemon);
-  process.on("SIGTERM", stopDaemon);
-  process.on("exit", stopDaemon);
+  console.log("[DAEMON] PID file written successfully");
+  types.logger.info("Happy CLI daemon started successfully");
+  process.on("SIGINT", () => {
+    stopDaemon().catch(console.error);
+  });
+  process.on("SIGTERM", () => {
+    stopDaemon().catch(console.error);
+  });
+  process.on("exit", () => {
+    stopDaemon().catch(console.error);
+  });
   try {
     const settings = await readSettings() || { onboardingCompleted: false };
     if (!settings.machineId) {
@@ -1696,22 +1929,37 @@ async function startDaemon() {
     await new Promise((resolve) => setTimeout(resolve, 1e3));
   }
 }
-function isDaemonRunning() {
+async function isDaemonRunning() {
   try {
-    if (!fs.existsSync(DAEMON_PID_FILE)) {
-      console.log("No PID file found");
-      return false;
-    }
-    const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, "utf-8"));
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch (error) {
-      console.log("Process not running", error);
-      fs.unlinkSync(DAEMON_PID_FILE);
-      return false;
+    console.log("[isDaemonRunning] Checking if daemon is running...");
+    if (fs.existsSync(types.configuration.daemonPidFile)) {
+      console.log("[isDaemonRunning] PID file exists");
+      const pid = parseInt(fs.readFileSync(types.configuration.daemonPidFile, "utf-8"));
+      console.log("[isDaemonRunning] PID from file:", pid);
+      try {
+        process.kill(pid, 0);
+        console.log("[isDaemonRunning] Process exists, checking if it's a happy daemon...");
+        const isHappyDaemon = await isProcessHappyDaemon(pid);
+        console.log("[isDaemonRunning] isHappyDaemon:", isHappyDaemon);
+        if (isHappyDaemon) {
+          return true;
+        } else {
+          console.log("[isDaemonRunning] PID is not a happy daemon, cleaning up");
+          types.logger.debug(`[DAEMON] PID ${pid} is not a happy daemon, cleaning up`);
+          fs.unlinkSync(types.configuration.daemonPidFile);
+        }
+      } catch (error) {
+        console.log("[isDaemonRunning] Process not running, cleaning up stale PID file");
+        types.logger.debug("[DAEMON] Process not running, cleaning up stale PID file");
+        fs.unlinkSync(types.configuration.daemonPidFile);
+      }
+    } else {
+      console.log("[isDaemonRunning] No PID file found");
     }
-  } catch {
+    return false;
+  } catch (error) {
+    console.log("[isDaemonRunning] Error:", error);
+    types.logger.debug("[DAEMON] Error checking daemon status", error);
     return false;
   }
 }
@@ -1720,19 +1968,54 @@ function writePidFile() {
   if (!fs.existsSync(happyDir)) {
     fs.mkdirSync(happyDir, { recursive: true });
   }
-  fs.writeFileSync(DAEMON_PID_FILE, process.pid.toString());
+  try {
+    fs.writeFileSync(types.configuration.daemonPidFile, process.pid.toString(), { flag: "wx" });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      types.logger.debug("[DAEMON] PID file already exists, another daemon may be starting");
+      throw new Error("Daemon PID file already exists");
+    }
+    throw error;
+  }
 }
-function stopDaemon() {
+async function stopDaemon() {
   try {
-    if (fs.existsSync(DAEMON_PID_FILE)) {
-      types.logger.debug("[DAEMON] Stopping daemon");
-      process.kill(parseInt(fs.readFileSync(DAEMON_PID_FILE, "utf-8")), "SIGTERM");
-      fs.unlinkSync(DAEMON_PID_FILE);
+    if (fs.existsSync(types.configuration.daemonPidFile)) {
+      const pid = parseInt(fs.readFileSync(types.configuration.daemonPidFile, "utf-8"));
+      types.logger.debug(`[DAEMON] Stopping daemon with PID ${pid}`);
+      try {
+        process.kill(pid, "SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        try {
+          process.kill(pid, 0);
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      } catch (error) {
+        types.logger.debug("[DAEMON] Process already dead or inaccessible", error);
+      }
+      fs.unlinkSync(types.configuration.daemonPidFile);
     }
   } catch (error) {
-    types.logger.debug("[DAEMON] Error cleaning up PID file", error);
+    types.logger.debug("[DAEMON] Error stopping daemon", error);
   }
 }
+async function isProcessHappyDaemon(pid) {
+  return new Promise((resolve) => {
+    const ps = child_process.spawn("ps", ["-p", pid.toString(), "-o", "command="]);
+    let output = "";
+    ps.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    ps.on("close", () => {
+      const isHappyDaemon = output.includes("daemon start") && (output.includes("happy") || output.includes("src/index"));
+      resolve(isHappyDaemon);
+    });
+    ps.on("error", () => {
+      resolve(false);
+    });
+  });
+}
 
 function trimIdent(text) {
   const lines = text.split("\n");
@@ -1931,10 +2214,19 @@ Currently only supported on macOS.
         options.model = args[++i];
       } else if (arg === "-p" || arg === "--permission-mode") {
         options.permissionMode = z.z.enum(["auto", "default", "plan"]).parse(args[++i]);
-      } else if (arg === "--local") {
-        i++;
-      } else if (arg === "--happy-starting-mode") {
-        options.startingMode = z.z.enum(["interactive", "remote"]).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") {
+        const envVar = args[++i];
+        const [key, value] = envVar.split("=", 2);
+        if (!key || value === void 0) {
+          console.error(chalk.red(`Invalid environment variable format: ${envVar}. Use KEY=VALUE`));
+          process.exit(1);
+        }
+        options.claudeEnvVars = { ...options.claudeEnvVars, [key]: value };
+      } else if (arg === "--claude-arg") {
+        const claudeArg = args[++i];
+        options.claudeArgs = [...options.claudeArgs || [], claudeArg];
       } else {
         console.error(chalk.red(`Unknown argument: ${arg}`));
         process.exit(1);
@@ -1947,6 +2239,7 @@ ${chalk.bold("happy")} - Claude Code session sharing
 ${chalk.bold("Usage:")}
   happy [options]
   happy logout     Logs out of your account and removes data directory
+  happy daemon     Manage the background daemon (macOS only)
 
 ${chalk.bold("Options:")}
   -h, --help              Show this help message
@@ -1954,6 +2247,14 @@ ${chalk.bold("Options:")}
   -m, --model <model>     Claude model to use (default: sonnet)
   -p, --permission-mode   Permission mode: auto, default, 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
+
+  [Daemon Management]
+  --happy-daemon-start    Start the daemon in background
+  --happy-daemon-stop     Stop the daemon
+  --happy-daemon-install  Install daemon to run on startup
+  --happy-daemon-uninstall  Uninstall daemon from startup
 
   [Advanced]
   --local < global | local >
@@ -1967,6 +2268,10 @@ ${chalk.bold("Examples:")}
   happy -m opus           Use Claude Opus model
   happy -p plan           Use plan permission mode
   happy --auth            Force re-authentication before starting session
+  happy --claude-env KEY=VALUE
+                          Set environment variable for Claude Code
+  happy --claude-arg --option
+                          Pass argument to Claude CLI
   happy logout            Logs out of your account and removes data directory
 `);
       process.exit(0);
@@ -1983,6 +2288,7 @@ ${chalk.bold("Examples:")}
       }
       credentials = res;
     }
+    await readSettings() || { };
     try {
       await start(credentials, options);
     } catch (error) {